{
    "$Version": "4.0",
    "$Reference": {
        "https://oasis-tcs.github.io/odata-vocabularies/vocabularies/Org.OData.Core.V1.json": {
            "$Include": [
                {
                    "$Namespace": "Org.OData.Core.V1",
                    "$Alias": "Core"
                }
            ]
        }
    },
    "Org.OData.Validation.V1": {
        "$Alias": "Validation",
        "@Core.Description": "Terms describing validation rules",
        "@Core.Links": [
            {
                "rel": "alternate",
                "href": "https://oasis-tcs.github.io/odata-vocabularies/vocabularies/Org.OData.Validation.V1.xml"
            },
            {
                "rel": "latest-version",
                "href": "https://oasis-tcs.github.io/odata-vocabularies/vocabularies/Org.OData.Validation.V1.json"
            },
            {
                "rel": "describedby",
                "href": "https://github.com/oasis-tcs/odata-vocabularies/blob/master/vocabularies/Org.OData.Validation.V1.md"
            }
        ],
        "Pattern": {
            "$Kind": "Term",
            "$Nullable": true,
            "$AppliesTo": [
                "Property",
                "Parameter",
                "Term"
            ],
            "@Core.Description": "The pattern that a string property, parameter, or term must match. This SHOULD be a valid regular expression, according to the ECMA 262 regular expression dialect.",
            "@Core.RequiresType": "Edm.String"
        },
        "Minimum": {
            "$Kind": "Term",
            "$Type": "Edm.PrimitiveType",
            "$Nullable": true,
            "$AppliesTo": [
                "Property",
                "Parameter",
                "Term"
            ],
            "@Core.Description": "Minimum value that a property, parameter, or term can have.",
            "@Validation.ApplicableTerms": [
                "Validation.Exclusive"
            ]
        },
        "Maximum": {
            "$Kind": "Term",
            "$Type": "Edm.PrimitiveType",
            "$Nullable": true,
            "$AppliesTo": [
                "Property",
                "Parameter",
                "Term"
            ],
            "@Core.Description": "Maximum value that a property, parameter, or term can have.",
            "@Validation.ApplicableTerms": [
                "Validation.Exclusive"
            ]
        },
        "Exclusive": {
            "$Kind": "Term",
            "$Type": "Core.Tag",
            "$Nullable": true,
            "$DefaultValue": true,
            "$AppliesTo": [
                "Annotation"
            ],
            "@Core.Description": "Tags a Minimum or Maximum as exclusive, i.e. an open interval boundary."
        },
        "AllowedValues": {
            "$Kind": "Term",
            "$Collection": true,
            "$Type": "Validation.AllowedValue",
            "$AppliesTo": [
                "Property",
                "Parameter",
                "TypeDefinition"
            ],
            "@Core.Description": "A collection of valid values for the annotated property, parameter, or type definition"
        },
        "AllowedValue": {
            "$Kind": "ComplexType",
            "@Validation.ApplicableTerms": [
                "Core.SymbolicName"
            ],
            "Value": {
                "$Type": "Edm.PrimitiveType",
                "$Nullable": true,
                "@Core.Description": "An allowed value for the property, parameter, or type definition"
            }
        },
        "MultipleOf": {
            "$Kind": "Term",
            "$Type": "Edm.Decimal",
            "$Nullable": true,
            "$AppliesTo": [
                "Property",
                "Parameter",
                "Term"
            ],
            "@Core.Description": "The value of the annotated property, parameter, or term must be an integer multiple of this positive value. For temporal types, the value is measured in seconds."
        },
        "Constraint": {
            "$Kind": "Term",
            "$Type": "Validation.ConstraintType",
            "$Nullable": true,
            "$AppliesTo": [
                "Property",
                "EntityType",
                "ComplexType"
            ],
            "@Core.Description": "Condition that the annotation target has to fulfill"
        },
        "ConstraintType": {
            "$Kind": "ComplexType",
            "FailureMessage": {
                "$Nullable": true,
                "@Core.IsLanguageDependent": true,
                "@Core.Description": "Human-readable message that can be shown to end users if the constraint is not fulfilled"
            },
            "Condition": {
                "$Type": "Edm.Boolean",
                "@Core.Description": "Value MUST be a dynamic expression that evaluates to true if and only if the constraint is fulfilled"
            }
        },
        "ItemsOf": {
            "$Kind": "Term",
            "$Collection": true,
            "$Type": "Validation.ItemsOfType",
            "$AppliesTo": [
                "EntityType",
                "ComplexType"
            ],
            "@Core.Description": "A list of constraints describing that entities related via one navigation property MUST also be related via another, collection-valued navigation property. The same `path` value MUST NOT occur more than once.",
            "@Core.LongDescription": "Example: entity type `Customer` has navigation properties `AllOrders`, `OpenOrders`, and `ClosedOrders`. \nThe term allows to express that items of `OpenOrders` and `ClosedOrders` are also items of the `AllOrders` navigation property,\neven though they are defined in an `Orders` entity set."
        },
        "ItemsOfType": {
            "$Kind": "ComplexType",
            "@Core.Description": "Entities related via the single- or collection-valued navigation property identified by `path` are also related via the collection-valued navigation property identified by `target`.",
            "path": {
                "$Type": "Edm.NavigationPropertyPath",
                "@Core.Description": "A path to a single- or collection-valued navigation property"
            },
            "target": {
                "$Type": "Edm.NavigationPropertyPath",
                "@Core.Description": "A path to a collection-valued navigation property"
            }
        },
        "OpenPropertyTypeConstraint": {
            "$Kind": "Term",
            "$Collection": true,
            "$Type": "Core.QualifiedTypeName",
            "$AppliesTo": [
                "ComplexType",
                "EntityType"
            ],
            "@Core.Description": "Dynamic properties added to the annotated open structured type are restricted to the listed types."
        },
        "DerivedTypeConstraint": {
            "$Kind": "Term",
            "$Collection": true,
            "$Type": "Core.QualifiedTypeName",
            "$AppliesTo": [
                "EntitySet",
                "Singleton",
                "NavigationProperty",
                "Property",
                "TypeDefinition",
                "Parameter",
                "ReturnType"
            ],
            "@Core.Description": "Values are restricted to types that are both identical to or derived from the declared type and a type listed in this collection.",
            "@Core.LongDescription": "This allows restricting values to certain sub-trees of an inheritance hierarchy. Types listed in this collection that are not derived from the declared type of the annotated model element are ignored."
        },
        "AllowedTerms": {
            "$Kind": "Term",
            "$Collection": true,
            "$Type": "Core.QualifiedTermName",
            "$AppliesTo": [
                "Term",
                "Property"
            ],
            "@Core.Description": "Annotate a term of type Edm.AnnotationPath, or a property of type Edm.AnnotationPath that is used within a structured term, to restrict the terms that can be targeted by the path.",
            "@Core.LongDescription": "The annotation path expression is intended to end in a path segment with one of the listed terms. For forward compatibility, clients should be prepared for the annotation to reference terms besides those listed.",
            "@Core.RequiresType": "Edm.AnnotationPath"
        },
        "ApplicableTerms": {
            "$Kind": "Term",
            "$Collection": true,
            "$Type": "Core.QualifiedTermName",
            "@Core.Description": "Names of specific terms that are applicable and may be applied in the current context. This annotation does not restrict the use of other terms."
        },
        "MaxItems": {
            "$Kind": "Term",
            "$Type": "Edm.Int64",
            "$AppliesTo": [
                "Collection"
            ],
            "@Core.Description": "The annotated collection must have at most the specified number of items."
        },
        "MinItems": {
            "$Kind": "Term",
            "$Type": "Edm.Int64",
            "$AppliesTo": [
                "Collection"
            ],
            "@Core.Description": "The annotated collection must have at least the specified number of items."
        }
    }
}