class PropertyResolverUtils {

	/**
	 * The constant LOGGER.
	 */
	private static final Logger LOGGER = LoggerFactory.getLogger(PropertyResolverUtils.class);

	/**
	 * The Factory.
	 */
	private final ConfigurableBeanFactory factory;

	/**
	 * The Message source.
	 */
	private final MessageSource messageSource;

	/**
	 * The Spring doc config properties.
	 */
	private final SpringDocConfigProperties springDocConfigProperties;

	/**
	 * Instantiates a new Property resolver utils.
	 *
	 * @param factory                   the factory
	 * @param messageSource             the message source
	 * @param springDocConfigProperties the spring doc config properties
	 */
	public PropertyResolverUtils(ConfigurableBeanFactory factory, MessageSource messageSource, SpringDocConfigProperties springDocConfigProperties) {
		this.factory = factory;
		this.messageSource = messageSource;
		this.springDocConfigProperties = springDocConfigProperties;
	}

	/**
	 * Resolve string.
	 *
	 * @param parameterProperty the parameter property
	 * @param locale            the locale
	 * @return the string
	 */
	public String resolve(String parameterProperty, Locale locale) {<FILL_FUNCTION_BODY>}

	/**
	 * Returns a string where all leading indentation has been removed from each line.
	 * It detects the smallest common indentation of all the lines in the input string,
	 * and removes it.
	 *
	 * @param text The original string with possible leading indentation.
	 * @return The string with leading indentation removed from each line.
	 */
    private String trimIndent(String text) {
		if (text == null) {
			return null;
		}
		final String newLine = "\n";
		String[] lines = text.split(newLine);
		int minIndent = resolveMinIndent(lines);
        return Arrays.stream(lines)
            .map(line -> line.substring(Math.min(line.length(), minIndent)))
            .reduce((a, b) -> a + newLine + b)
            .orElse(StringUtils.EMPTY);
    }

	private int resolveMinIndent(String[] lines) {
		return Arrays.stream(lines)
			.filter(line -> !line.trim().isEmpty())
			.mapToInt(this::countLeadingSpaces)
			.min()
			.orElse(0);
	}

	private int countLeadingSpaces(String line) {
        int count = 0;
        for (char ch : line.toCharArray()) {
            if (ch != ' ') break;
            count++;
        }
        return count;
    }

	/**
	 * Gets factory.
	 *
	 * @return the factory
	 */
	public ConfigurableBeanFactory getFactory() {
		return factory;
	}

	/**
	 * Gets spring doc config properties.
	 *
	 * @return the spring doc config properties
	 */
	public SpringDocConfigProperties getSpringDocConfigProperties() {
		return springDocConfigProperties;
	}

	/**
	 * Gets spec version.
	 *
	 * @return the spec version
	 */
	public SpecVersion getSpecVersion() {
		return springDocConfigProperties.getSpecVersion();
	}

	/**
	 * Is openapi 31 boolean.
	 *
	 * @return the boolean
	 */
	public boolean isOpenapi31() {
		return springDocConfigProperties.isOpenapi31();
	}

	/**
	 * Is resolve extensions properties boolean.
	 *
	 * @return the boolean
	 */
	public boolean isResolveExtensionsProperties() {
		return springDocConfigProperties.getApiDocs().isResolveExtensionsProperties();
	}
	/**
	 * Resolve extensions map.
	 *
	 * @param locale     the locale
	 * @param extensions the extensions
	 * @return the map
	 */
	public Map<String, Object> resolveExtensions(Locale locale, Map<String, Object> extensions) {
		if (!CollectionUtils.isEmpty(extensions)) {
			Map<String, Object> extensionsResolved = new HashMap<>();
			extensions.forEach((key, value) -> {
				String keyResolved = resolve(key, locale);
				if (value instanceof HashMap<?, ?>) {
					Map<String, Object> valueResolved = new HashMap<>();
					((HashMap<?, ?>) value).forEach((key1, value1) -> {
						String key1Resolved = resolve(key1.toString(), locale);
						String value1Resolved = resolve(value1.toString(), locale);
						valueResolved.put(key1Resolved, value1Resolved);
					});
					extensionsResolved.put(keyResolved, valueResolved);
				}
				else
					extensionsResolved.put(keyResolved, value);
			});
			return extensionsResolved;
		}
		else
			return extensions;
	}
}

		String result = parameterProperty;
		if (parameterProperty != null) {
			if (!springDocConfigProperties.isDisableI18n())
				try {
					result = messageSource.getMessage(parameterProperty, null, locale);
				}
				catch (NoSuchMessageException ex) {
					LOGGER.trace(ex.getMessage());
				}
			if (parameterProperty.equals(result))
				try {
                    if (springDocConfigProperties.isTrimKotlinIndent()) {
                        parameterProperty = trimIndent(parameterProperty);
                    }
					result = factory.resolveEmbeddedValue(parameterProperty);
				}
				catch (IllegalArgumentException ex) {
					LOGGER.warn(ex.getMessage());
				}
		}
		return result;
	
<no_super_class>