private static void SetArrayRefToComponent(JObject schemaJObject, KeyValuePair<string, JsonSchemaProperty> schemaProperty, Type enumerableTypeArg)
        {
            schemaJObject["properties"]![schemaProperty.Key]!["items"]!["$ref"] = ComponentRefPath(enumerableTypeArg);
        }

        private static void SetPropertyToRef(Type propertyType, JObject schemaJObject, KeyValuePair<string, JsonSchemaProperty> schemaProperty)
        {
            var jsonForRef = $"{{ \"$ref\": \"{ComponentRefPath(propertyType)}\" }}";

            var propertiesNode = schemaJObject["properties"];
            propertiesNode![schemaProperty.Key] = JObject.Parse(jsonForRef);
        }

using System;
using System.Collections.Generic;

namespace Tenlastic {
    [Serializable]
    public class CollectionModel {

        [Serializable]
        public struct BooleanPermissions {
            public bool @base;
            public dynamic roles;
        }

        [Serializable]
        public struct DynamicPermissions {
            public dynamic @base;
            public dynamic roles;
        }

        [Serializable]
        public struct Index {
            public dynamic key;
            public IndexOptions options;
        }

        [Serializable]
        public struct IndexOptions {
            public int expireAfterSeconds;
            public dynamic partialFilterExpression;
            public bool unique;
        }

        [Serializable]
        public class JsonSchemaProperty {
            public bool additionalProperties;
            public dynamic @default;
            public string format;
            public JsonSchemaProperties properties;
            public string type;
        }

        [Serializable]
        public class JsonSchemaProperties : Dictionary<string, JsonSchemaProperty> { }

        [Serializable]
        public struct Permissions {
            public StringPermissions create;
            public BooleanPermissions delete;
            public DynamicPermissions find;
            public PopulatePermissions[] populate;
            public StringPermissions read;
            public RolePermissions[] roles;
            public StringPermissions update;
        }

        [Serializable]
        public class PopulatePermissions {
            public string path;
            public PopulatePermissions populate;
        }

        [Serializable]
        public struct RolePermissions {
            public string name;
            public dynamic query;
        }

        [Serializable]
        public struct StringPermissions {
            public string[] @base;
            public dynamic roles;
        }

        public string _id;
        public DateTime createdAt;
        public Index[] indexes;
        public JsonSchemaProperty jsonSchema;
        public string name;
        public string namespaceId;
        public Permissions permissions;
        public DateTime updatedAt;

    }
}

        private JsonSchemaProperty GetReferenceIdProperty(JsonSchemaProperty property, bool inherit = true)
        {
            if (property.ExtensionData != null && property.ExtensionData.TryGetValue("x-id", out var propertyName))
            {
                return GetProperty(property.ParentSchema, (string)propertyName);
            }
            return null;
        }

        private IEnumerable<StatementSyntax> GenClientConstructorBody(string clientName, JsonSchemaProperty idKey, JsonSchemaProperty typeKey, HashSet<RefField> cache)
        {
            yield return SF.ParseStatement($"Instance = Instance ?? this;");
            foreach (var refField in cache)
            {
                yield return SF.ParseStatement($"Items.Indexes.Add({refField.InvokerName});");
            }
        }

        private string GetInvokerName(JsonSchemaProperty property)
        {
            return GetPropertyName(property) + "Invoker";
        }

        private IEnumerable<SyntaxToken> GenDefinitionClassPropertyModifiers(JsonSchemaProperty property, JsonSchemaProperty idKey, bool isOverride)
        {
            yield return SF.Token(SyntaxKind.PublicKeyword);
            if (isOverride)
            {
                yield return SF.Token(SyntaxKind.OverrideKeyword);
            }
            else if (property == idKey)
            {
                yield return SF.Token(SyntaxKind.VirtualKeyword);
            }
        }

        private string GetPropertyName(JsonSchemaProperty property)
        {
            return GetDefinitionName(property.Name);
        }

        private string GetFieldName(JsonSchemaProperty property)
        {
            return GetFieldName(property.Name);
        }

        public static Dictionary<string, JsonSchemaProperty> PropertyDictionaryFromType<T>()
        {
            return PropertyDictionaryFromType(typeof(T));
        }

        public static Dictionary<string, JsonSchemaProperty> PropertyDictionaryFromType(Type type)
        {
            Args.ThrowIfNull(type);
            return PropertyDictionaryFromType(type, pi => 
                pi.PropertyType.HasCustomAttributeOfType<JsonSchemaAttribute>() || 
                Extensions.PropertyDataTypeFilter(pi) || 
                pi.PropertyType.IsForEachable() ||
                pi.PropertyType.IsSubclassOf(typeof(RepoData))
            );
        }

        public static Dictionary<string, JsonSchemaProperty> FromDaoType<T>() where T : Dao
        {
            return FromDaoType(typeof(T));
        }

        public static Dictionary<string, JsonSchemaProperty> FromDaoType(Type type)
        {
            Args.ThrowIfNull(type);
            Args.ThrowIf(!type.IsSubclassOf(typeof(Dao)), "Specified type {0} is not a subclass of Dao", type.Name);
            return PropertyDictionaryFromType(type, pi => pi.HasCustomAttributeOfType<ColumnAttribute>());
        }

        public static Dictionary<string, JsonSchemaProperty> PropertyDictionaryFromType(Type type, Func<PropertyInfo, bool> propertyPredicate)
        {
            Dictionary<string, JsonSchemaProperty> result = new Dictionary<string, JsonSchemaProperty>();
            foreach (PropertyInfo prop in type.GetProperties().Where(propertyPredicate))
            {
                result.Add(prop.Name, FromPropertyInfo(prop));
            }
            return result;
        }

        public static JsonSchemaProperty ArrayProperty(JsonSchema item, string? description = null, bool isRequired = false)
        {
            return Enrich(new JsonSchemaProperty { Type = JsonObjectType.Array, Item = item }, description, isRequired);
        }

        public static JsonSchemaProperty BooleanProperty(string? description = null, bool isRequired = false)
        {
            return Enrich(new JsonSchemaProperty { Type = JsonObjectType.Boolean }, description, isRequired);
        }

        public static JsonSchemaProperty DateTimeProperty(string? description = null, bool isRequired = false)
        {
            return Enrich(new JsonSchemaProperty { Type = JsonObjectType.String, Format = JsonFormatStrings.DateTime }, description, isRequired);
        }

        public static JsonSchemaProperty NumberProperty(string? description = null, bool isRequired = false)
        {
            return Enrich(new JsonSchemaProperty { Type = JsonObjectType.Number }, description, isRequired);
        }

        public static JsonSchemaProperty StringProperty(string? description = null, bool isRequired = false)
        {
            return Enrich(new JsonSchemaProperty { Type = JsonObjectType.String }, description, isRequired);
        }

        public static JsonSchemaProperty ObjectProperty(JsonSchema reference, string? description = null, bool isRequired = false)
        {
            return Enrich(new JsonSchemaProperty { Reference = reference }, description, isRequired);
        }

        
        [UnitTest]
        public void JsonSchemaDictionary()
        {
            Dictionary<string, JsonSchemaProperty> props = JsonSchemaProperty.PropertyDictionaryFromType<TestParentRepoData>();
            OutLine(props.ToJson(true));
        }

        public static JsonSchemaProperty ArrayProperty(JsonSchema item, string? description = null, bool isRequired = false)
        {
            return Enrich(new JsonSchemaProperty { Type = JsonObjectType.Array, Item = item }, description, isRequired);
        }

        public static JsonSchemaProperty BooleanProperty(string? description = null, bool isRequired = false)
        {
            return Enrich(new JsonSchemaProperty { Type = JsonObjectType.Boolean }, description, isRequired);
        }

        public static JsonSchemaProperty DateTimeProperty(string? description = null, bool isRequired = false)
        {
            return Enrich(new JsonSchemaProperty { Type = JsonObjectType.String, Format = JsonFormatStrings.DateTime }, description, isRequired);
        }

        public static JsonSchemaProperty GuidProperty(string? description = null, bool isRequired = false)
        {
            return Enrich(new JsonSchemaProperty { Type = JsonObjectType.String, Format = JsonFormatStrings.Guid }, description, isRequired);
        }

        public static JsonSchemaProperty NumberProperty(string? description = null, bool isRequired = false)
        {
            return Enrich(new JsonSchemaProperty { Type = JsonObjectType.Number }, description, isRequired);
        }

        public static JsonSchemaProperty ObjectProperty(JsonSchema item, string? description = null, bool isRequired = false)
        {
            return Enrich(new JsonSchemaProperty { Type = JsonObjectType.Object, Reference = item }, description, isRequired);
        }

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Text.Json.Serialization;

namespace ImageCasterApi.Json
{
    /// <summary>
    /// This is not intended to fulfil the JSON Schema spec nor be
    /// backward compatible with any version of the spec.
    ///
    /// This is due to be removed once .NET Core has official
    /// support for JSON Schemas.
    /// </summary>
    /// <see href="https://github.com/dotnet/runtime/issues/29887"/>
    public class JsonSchemaProperty
    {
        [JsonPropertyName("title")]
        public string Title { get; set; }

        [JsonPropertyName("description")]
        public string Description { get; set; }

        [Required]
        [JsonPropertyName("type")]
        public string Type { get; set; }

        [JsonPropertyName("format")]
        public string Format { get; set; }
        
        [JsonPropertyName("default")]
        public object Default { get; set; }

        [JsonPropertyName("minimum")]
        public int? Minimum { get; set; }

        [JsonPropertyName("maximum")]
        public int? Maximum { get; set; }

        [JsonPropertyName("enum")]
        public IEnumerable<string> Enum { get; set; }

        [JsonPropertyName("items")]
        public JsonSchemaProperty Items { get; set; }

        [JsonPropertyName("properties")]
        public Dictionary<string, JsonSchemaProperty> Properties { get; set; }
    }
}

        public JsonSchemaProperty? Visit(IArrayField field)
        {
            var item = Builder.Object();

            foreach (var nestedField in field.Fields.ForApi(withHiddenFields))
            {
                var childProperty = nestedField.Accept(this);

                if (childProperty != null)
                {
                    childProperty.Description = nestedField.RawProperties.Hints;
                    childProperty.IsRequired = nestedField.RawProperties.IsRequired;

                    item.Properties.Add(nestedField.Name, childProperty);
                }
            }

            return Builder.ArrayProperty(item);
        }

        public JsonSchemaProperty? Visit(IField<AssetsFieldProperties> field)
        {
            var item = schemaResolver("AssetItem", Builder.Guid());

            return Builder.ArrayProperty(item);
        }

        public JsonSchemaProperty? Visit(IField<BooleanFieldProperties> field)
        {
            return Builder.BooleanProperty();
        }

        public JsonSchemaProperty? Visit(IField<DateTimeFieldProperties> field)
        {
            return Builder.DateTimeProperty();
        }

        public JsonSchemaProperty? Visit(IField<GeolocationFieldProperties> field)
        {
            var geolocationSchema = Builder.Object();

            geolocationSchema.Properties.Add("latitude", new JsonSchemaProperty
            {
                Type = JsonObjectType.Number,
                Minimum = -90,
                Maximum = 90,
                IsRequired = true
            });

            geolocationSchema.Properties.Add("longitude", new JsonSchemaProperty
            {
                Type = JsonObjectType.Number,
                Minimum = -180,
                Maximum = 180,
                IsRequired = true
            });

            var reference = schemaResolver("GeolocationDto", geolocationSchema);

            return Builder.ObjectProperty(reference);
        }

        public JsonSchemaProperty? Visit(IField<JsonFieldProperties> field)
        {
            return Builder.JsonProperty();
        }

        /// <summary>
        /// Receive the JSON Schema for the ImageCaster configuration, or
        /// a partial schema from part including one or more of the properties.
        /// </summary>
        /// <param name="properties">The properties to obtain.</param>
        /// <returns></returns>
        /// <exception cref="ArgumentException"></exception>
        [HttpGet("json-schema")]
        public ActionResult<JsonSchema> GetSchema([FromQuery] string[] properties)
        {
            JsonSchema response;
            
            if (properties.Length == 0)
            {
                response = _schema;
            }
            else
            {
                response = new JsonSchema()
                {
                    Schema = _schema.Schema,
                    Id = _schema.Id,
                    Title = _schema.Title,
                    Description = _schema.Description,
                    Type = _schema.Type,
                    Properties = new Dictionary<string, JsonSchemaProperty>()
                };

                Dictionary<string, JsonSchemaProperty> jsonProperties = _schema.Properties;

                foreach (string property in properties)
                {
                    if (!jsonProperties.ContainsKey(property))
                    {
                        return StatusCode(404, "Property not found.");
                    }
                    
                    response.Properties.Add(property, jsonProperties[property]);
                }
            }

            return response;
        }

        /// <returns>All exif tags values available in ImageCaster.</returns>
        [HttpGet("exif-tags")]
        public ActionResult<List<string>> ExifTags()
        {
            return _exifTags;
        }

        /// <returns>All IPTC tags in ImageCaster.</returns>
        [HttpGet("iptc-tags")]
        public ActionResult<List<string>> IptcTags()
        {
            return _iptcTags;
        }

        
        /// <returns>All resize filters available in ImageCaster.</returns>
        [HttpGet("resize-filters")]
        public ActionResult<List<string>> ResizeFilters()
        {
            return _resizeFilters;
        }

        /// <returns>All fonts available on the server.</returns>
        [HttpGet("fonts")]
        public ActionResult<List<string>> ServerFonts()
        {
            return _fontFamilies;
        }