docs: protected Object interceptSync(MethodInvocationContext context, ReturnType returnTypeObject, Class returnType) {
          final ValueWrapper wrapper = new ValueWrapper();
          CacheOperation cacheOperation = new CacheOperation(context, returnType);
  
          AnnotationValue<Cacheable> cacheConfig = cacheOperation.cacheable;
          if (cacheConfig != null) {
              CacheKeyGenerator defaultKeyGenerator = cacheOperation.defaultKeyGenerator;
              CacheKeyGenerator keyGenerator = resolveKeyGenerator(defaultKeyGenerator, cacheConfig);
              Object[] parameterValues = resolveParams(context, cacheConfig.get(MEMBER_PARAMETERS, String[].class, StringUtils.EMPTY_STRING_ARRAY));
              Object key = keyGenerator.generateKey(context, parameterValues);
              Argument returnArgument = returnTypeObject.asArgument();
              if (cacheConfig.getRequiredValue(MEMBER_ATOMIC, Boolean.class)) {
                  SyncCache syncCache = cacheManager.getCache(cacheOperation.cacheableCacheName);
  
                  try {
                      wrapper.value = syncCache.get(key, returnArgument, () -> {
                          try {
                              doProceed(context, wrapper);
                              return wrapper.value;
                          } catch (RuntimeException e) {
                              throw new ValueSupplierException(key, e);
                          }
                      });
                  } catch (ValueSupplierException e) {
                      throw e.getCause();
                  } catch (RuntimeException e) {
                      errorHandler.handleLoadError(syncCache, key, e);
                      throw e;
                  }
              } else {
                  String[] cacheNames = resolveCacheNames(cacheOperation.defaultConfig, cacheConfig);
                  boolean cacheHit = false;
                  for (String cacheName : cacheNames) {
                      SyncCache syncCache = cacheManager.getCache(cacheName);
                      try {
                          Optional optional = syncCache.get(key, returnArgument);
                          if (optional.isPresent()) {
                              if (LOG.isDebugEnabled()) {
                                  LOG.debug("Value found in cache [" + cacheName + "] for invocation: " + context);
                              }
                              cacheHit = true;
                              wrapper.value = optional.get();
                              break;
                          }
                      } catch (RuntimeException e) {
                          if (errorHandler.handleLoadError(syncCache, key, e)) {
                              throw e;
                          }
                      }
                  }
                  if (!cacheHit) {
                      if (LOG.isDebugEnabled()) {
                          LOG.debug("Value not found in cache for invocation: " + context);
                      }
                      doProceed(context, wrapper);
                      syncPut(cacheNames, key, wrapper.value);
                  }
              }
          } else {
              if (!cacheOperation.hasWriteOperations()) {
                  return context.proceed();
              } else {
                  doProceed(context, wrapper);
              }
          }
  
          List<AnnotationValue<CachePut>> cachePuts = cacheOperation.putOperations;
          if (cachePuts != null) {
  
              for (AnnotationValue<CachePut> cachePut : cachePuts) {
                  boolean async = cachePut.get(MEMBER_ASYNC, Boolean.class, false);
                  if (async) {
                      ioExecutor.submit(() ->
                              processCachePut(context, wrapper, cachePut, cacheOperation)
                      );
                  } else {
                      processCachePut(context, wrapper, cachePut, cacheOperation);
                  }
              }
          }
  
          List<AnnotationValue<CacheInvalidate>> cacheInvalidates = cacheOperation.invalidateOperations;
          if (cacheInvalidates != null) {
              for (AnnotationValue<CacheInvalidate> cacheInvalidate : cacheInvalidates) {
                  boolean async = cacheInvalidate.get(MEMBER_ASYNC, Boolean.class, false);
                  if (async) {
                      ioExecutor.submit(() -> {
                                  try {
                                      processCacheEvict(context, cacheInvalidate, cacheOperation, async);
                                  } catch (Exception e) {
                                      throw new CacheSystemException("Cache invalidate operation failed: " + e.getMessage(), e);
                                  }
                              }
                      );
                  } else {
                      processCacheEvict(context, cacheInvalidate, cacheOperation, async);
                  }
              }
          }
  
          return wrapper.optional ? Optional.ofNullable(wrapper.value) : wrapper.value;
      }