processSchema = (resolvedSchema) => {
    if (resolvedSchema.type === 'object' && resolvedSchema.properties) {
      const schemaDetails = {
          type: resolvedSchema.type,
          properties: {},
          required: []
        },
        requiredProperties = new Set(resolvedSchema.required || []);

      for (let [propName, propValue] of Object.entries(resolvedSchema.properties)) {
        if (!propValue.type) {
          continue;
        }
        const propertyDetails = {
          type: propValue.type,
          deprecated: propValue.deprecated,
          enum: propValue.enum || undefined,
          minLength: propValue.minLength,
          maxLength: propValue.maxLength,
          minimum: propValue.minimum,
          maximum: propValue.maximum,
          pattern: propValue.pattern,
          example: propValue.example,
          description: propValue.description,
          format: propValue.format
        };

        if (requiredProperties.has(propName)) {
          schemaDetails.required.push(propName);
        }
        if (propValue.properties) {
          let processedProperties = processSchema(propValue);
          propertyDetails.properties = processedProperties.properties;
          if (processedProperties.required) {
            propertyDetails.required = processedProperties.required;
          }
        }
        else if (propValue.type === 'array' && propValue.items) {
          propertyDetails.items = processSchema(propValue.items);
        }

        schemaDetails.properties[propName] = propertyDetails;
      }
      if (schemaDetails.required && schemaDetails.required.length === 0) {
        schemaDetails.required = undefined;
      }
      return schemaDetails;
    }
    else if (resolvedSchema.type === 'array' && resolvedSchema.items) {
      const arrayDetails = {
        type: resolvedSchema.type,
        items: processSchema(resolvedSchema.items)
      };
      if (resolvedSchema.minItems !== undefined) { arrayDetails.minItems = resolvedSchema.minItems; }
      if (resolvedSchema.maxItems !== undefined) { arrayDetails.maxItems = resolvedSchema.maxItems; }
      return arrayDetails;
    }
    return {
      type: resolvedSchema.type
    };
  }
Processes and resolves types from Nested JSON schema structure.

@param {Object} resolvedSchema - The resolved JSON schema to process for type extraction.
@returns {Object} The processed schema details.