@jarenjs/refs 0.8.4 → 0.9.2

package/dist/types/json-schema-2019-09/index.d.ts

@@ -0,0 +1,370 @@
+declare const draft2019: ({
+    $schema: string;
+    $id: string;
+    $vocabulary: {
+        "https://json-schema.org/draft/2019-09/vocab/core": boolean;
+        "https://json-schema.org/draft/2019-09/vocab/applicator": boolean;
+        "https://json-schema.org/draft/2019-09/vocab/validation": boolean;
+        "https://json-schema.org/draft/2019-09/vocab/meta-data": boolean;
+        "https://json-schema.org/draft/2019-09/vocab/format": boolean;
+        "https://json-schema.org/draft/2019-09/vocab/content": boolean;
+    };
+    $recursiveAnchor: boolean;
+    title: string;
+    allOf: {
+        $ref: string;
+    }[];
+    type: string[];
+    properties: {
+        definitions: {
+            $comment: string;
+            type: string;
+            additionalProperties: {
+                $recursiveRef: string;
+            };
+            default: {};
+        };
+        dependencies: {
+            $comment: string;
+            type: string;
+            additionalProperties: {
+                anyOf: ({
+                    $recursiveRef: string;
+                    $ref?: undefined;
+                } | {
+                    $recursiveRef?: undefined;
+                    $ref: string;
+                })[];
+            };
+        };
+    };
+} | {
+    $schema: string;
+    $id: string;
+    $vocabulary: {
+        "https://json-schema.org/draft/2019-09/vocab/applicator": boolean;
+    };
+    $recursiveAnchor: boolean;
+    title: string;
+    type: string[];
+    properties: {
+        additionalItems: {
+            $recursiveRef: string;
+        };
+        unevaluatedItems: {
+            $recursiveRef: string;
+        };
+        items: {
+            anyOf: ({
+                $ref?: undefined;
+                $recursiveRef: string;
+            } | {
+                $recursiveRef?: undefined;
+                $ref: string;
+            })[];
+        };
+        contains: {
+            $recursiveRef: string;
+        };
+        additionalProperties: {
+            $recursiveRef: string;
+        };
+        unevaluatedProperties: {
+            $recursiveRef: string;
+        };
+        properties: {
+            type: string;
+            additionalProperties: {
+                $recursiveRef: string;
+            };
+            default: {};
+        };
+        patternProperties: {
+            type: string;
+            additionalProperties: {
+                $recursiveRef: string;
+            };
+            propertyNames: {
+                format: string;
+            };
+            default: {};
+        };
+        dependentSchemas: {
+            type: string;
+            additionalProperties: {
+                $recursiveRef: string;
+            };
+        };
+        propertyNames: {
+            $recursiveRef: string;
+        };
+        if: {
+            $recursiveRef: string;
+        };
+        then: {
+            $recursiveRef: string;
+        };
+        else: {
+            $recursiveRef: string;
+        };
+        allOf: {
+            $ref: string;
+        };
+        anyOf: {
+            $ref: string;
+        };
+        oneOf: {
+            $ref: string;
+        };
+        not: {
+            $recursiveRef: string;
+        };
+    };
+    $defs: {
+        schemaArray: {
+            type: string;
+            minItems: number;
+            items: {
+                $recursiveRef: string;
+            };
+        };
+    };
+} | {
+    $schema: string;
+    $id: string;
+    $vocabulary: {
+        "https://json-schema.org/draft/2019-09/vocab/content": boolean;
+    };
+    $recursiveAnchor: boolean;
+    title: string;
+    type: string[];
+    properties: {
+        contentMediaType: {
+            type: string;
+        };
+        contentEncoding: {
+            type: string;
+        };
+        contentSchema: {
+            $recursiveRef: string;
+        };
+    };
+} | {
+    $schema: string;
+    $id: string;
+    $vocabulary: {
+        "https://json-schema.org/draft/2019-09/vocab/core": boolean;
+    };
+    $recursiveAnchor: boolean;
+    title: string;
+    type: string[];
+    properties: {
+        $id: {
+            type: string;
+            format: string;
+            $comment: string;
+            pattern: string;
+        };
+        $schema: {
+            type: string;
+            format: string;
+        };
+        $anchor: {
+            type: string;
+            pattern: string;
+        };
+        $ref: {
+            type: string;
+            format: string;
+        };
+        $recursiveRef: {
+            type: string;
+            format: string;
+        };
+        $recursiveAnchor: {
+            type: string;
+            default: boolean;
+        };
+        $vocabulary: {
+            type: string;
+            propertyNames: {
+                type: string;
+                format: string;
+            };
+            additionalProperties: {
+                type: string;
+            };
+        };
+        $comment: {
+            type: string;
+        };
+        $defs: {
+            type: string;
+            additionalProperties: {
+                $recursiveRef: string;
+            };
+            default: {};
+        };
+    };
+} | {
+    $schema: string;
+    $id: string;
+    $vocabulary: {
+        "https://json-schema.org/draft/2019-09/vocab/format": boolean;
+    };
+    $recursiveAnchor: boolean;
+    title: string;
+    type: string[];
+    properties: {
+        format: {
+            type: string;
+        };
+    };
+} | {
+    $schema: string;
+    $id: string;
+    $vocabulary: {
+        "https://json-schema.org/draft/2019-09/vocab/meta-data": boolean;
+    };
+    $recursiveAnchor: boolean;
+    title: string;
+    type: string[];
+    properties: {
+        title: {
+            type: string;
+        };
+        description: {
+            type: string;
+        };
+        default: boolean;
+        deprecated: {
+            type: string;
+            default: boolean;
+        };
+        readOnly: {
+            type: string;
+            default: boolean;
+        };
+        writeOnly: {
+            type: string;
+            default: boolean;
+        };
+        examples: {
+            type: string;
+            items: boolean;
+        };
+    };
+} | {
+    $schema: string;
+    $id: string;
+    $vocabulary: {
+        "https://json-schema.org/draft/2019-09/vocab/validation": boolean;
+    };
+    $recursiveAnchor: boolean;
+    title: string;
+    type: string[];
+    properties: {
+        multipleOf: {
+            type: string;
+            exclusiveMinimum: number;
+        };
+        maximum: {
+            type: string;
+        };
+        exclusiveMaximum: {
+            type: string;
+        };
+        minimum: {
+            type: string;
+        };
+        exclusiveMinimum: {
+            type: string;
+        };
+        maxLength: {
+            $ref: string;
+        };
+        minLength: {
+            $ref: string;
+        };
+        pattern: {
+            type: string;
+            format: string;
+        };
+        maxItems: {
+            $ref: string;
+        };
+        minItems: {
+            $ref: string;
+        };
+        uniqueItems: {
+            type: string;
+            default: boolean;
+        };
+        maxContains: {
+            $ref: string;
+        };
+        minContains: {
+            $ref: string;
+            default: number;
+        };
+        maxProperties: {
+            $ref: string;
+        };
+        minProperties: {
+            $ref: string;
+        };
+        required: {
+            $ref: string;
+        };
+        dependentRequired: {
+            type: string;
+            additionalProperties: {
+                $ref: string;
+            };
+        };
+        const: boolean;
+        enum: {
+            type: string;
+            items: boolean;
+        };
+        type: {
+            anyOf: ({
+                $ref: string;
+                type?: undefined;
+                items?: undefined;
+                minItems?: undefined;
+                uniqueItems?: undefined;
+            } | {
+                $ref?: undefined;
+                type: string;
+                items: {
+                    $ref: string;
+                };
+                minItems: number;
+                uniqueItems: boolean;
+            })[];
+        };
+    };
+    $defs: {
+        nonNegativeInteger: {
+            type: string;
+            minimum: number;
+        };
+        nonNegativeIntegerDefault0: {
+            $ref: string;
+            default: number;
+        };
+        simpleTypes: {
+            enum: string[];
+        };
+        stringArray: {
+            type: string;
+            items: {
+                type: string;
+            };
+            uniqueItems: boolean;
+            default: never[];
+        };
+    };
+})[];
+export default draft2019;