@jarenjs/refs 0.8.2 → 0.9.2

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

@@ -0,0 +1,378 @@
+declare const _default: {
+    metaSchema: {
+        $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;
+                    })[];
+                };
+            };
+        };
+    };
+    applicator: {
+        $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;
+                };
+            };
+        };
+    };
+    content: {
+        $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;
+            };
+        };
+    };
+    core: {
+        $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: {};
+            };
+        };
+    };
+    format: {
+        $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;
+            };
+        };
+    };
+    metadata: {
+        $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;
+            };
+        };
+    };
+    validation: {
+        $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 _default;