vscode-json-languageservice 5.6.2 → 5.6.3

package/lib/umd/services/schemas/draft-2019-09-flat.js

@@ -0,0 +1,314 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    // This file is generated - do not edit directly!
+    // Derived from https://json-schema.org/draft/2019-09
+    exports.default = {
+        $id: 'https://json-schema.org/draft/2019-09/schema',
+        $schema: 'https://json-schema.org/draft/2019-09/schema',
+        title: '(Flattened static) Core and Validation specifications meta-schema',
+        type: [
+            'object',
+            'boolean',
+        ],
+        properties: {
+            definitions: {
+                $comment: 'While no longer an official keyword as it is replaced by $defs, this keyword is retained in the meta-schema to prevent incompatible extensions as it remains in common use.',
+                type: 'object',
+                additionalProperties: {
+                    $ref: '#',
+                },
+                default: {},
+            },
+            dependencies: {
+                $comment: '"dependencies" is no longer a keyword, but schema authors should avoid redefining it to facilitate a smooth transition to "dependentSchemas" and "dependentRequired"',
+                type: 'object',
+                additionalProperties: {
+                    anyOf: [
+                        {
+                            $ref: '#',
+                        },
+                        {
+                            $ref: '#/$defs/stringArray',
+                        },
+                    ],
+                },
+            },
+            $id: {
+                type: 'string',
+                format: 'uri-reference',
+                $comment: 'Non-empty fragments not allowed.',
+                pattern: '^[^#]*#?$',
+            },
+            $schema: {
+                type: 'string',
+                format: 'uri',
+            },
+            $anchor: {
+                type: 'string',
+                pattern: '^[A-Za-z][-A-Za-z0-9.:_]*$',
+            },
+            $ref: {
+                type: 'string',
+                format: 'uri-reference',
+            },
+            $recursiveAnchor: {
+                type: 'boolean',
+                default: false,
+            },
+            $vocabulary: {
+                type: 'object',
+                propertyNames: {
+                    type: 'string',
+                    format: 'uri',
+                },
+                additionalProperties: {
+                    type: 'boolean',
+                },
+            },
+            $comment: {
+                type: 'string',
+            },
+            $defs: {
+                type: 'object',
+                additionalProperties: {
+                    $ref: '#',
+                },
+                default: {},
+            },
+            additionalItems: {
+                $ref: '#',
+            },
+            unevaluatedItems: {
+                $ref: '#',
+            },
+            items: {
+                anyOf: [
+                    {
+                        $ref: '#',
+                    },
+                    {
+                        $ref: '#/$defs/schemaArray',
+                    },
+                ],
+            },
+            contains: {
+                $ref: '#',
+            },
+            additionalProperties: {
+                $ref: '#',
+            },
+            unevaluatedProperties: {
+                $ref: '#',
+            },
+            properties: {
+                type: 'object',
+                additionalProperties: {
+                    $ref: '#',
+                },
+                default: {},
+            },
+            patternProperties: {
+                type: 'object',
+                additionalProperties: {
+                    $ref: '#',
+                },
+                propertyNames: {
+                    format: 'regex',
+                },
+                default: {},
+            },
+            dependentSchemas: {
+                type: 'object',
+                additionalProperties: {
+                    $ref: '#',
+                },
+            },
+            propertyNames: {
+                $ref: '#',
+            },
+            if: {
+                $ref: '#',
+            },
+            then: {
+                $ref: '#',
+            },
+            else: {
+                $ref: '#',
+            },
+            allOf: {
+                $ref: '#/$defs/schemaArray',
+            },
+            anyOf: {
+                $ref: '#/$defs/schemaArray',
+            },
+            oneOf: {
+                $ref: '#/$defs/schemaArray',
+            },
+            not: {
+                $ref: '#',
+            },
+            multipleOf: {
+                type: 'number',
+                exclusiveMinimum: 0,
+            },
+            maximum: {
+                type: 'number',
+            },
+            exclusiveMaximum: {
+                type: 'number',
+            },
+            minimum: {
+                type: 'number',
+            },
+            exclusiveMinimum: {
+                type: 'number',
+            },
+            maxLength: {
+                $ref: '#/$defs/nonNegativeInteger',
+            },
+            minLength: {
+                $ref: '#/$defs/nonNegativeIntegerDefault0',
+            },
+            pattern: {
+                type: 'string',
+                format: 'regex',
+            },
+            maxItems: {
+                $ref: '#/$defs/nonNegativeInteger',
+            },
+            minItems: {
+                $ref: '#/$defs/nonNegativeIntegerDefault0',
+            },
+            uniqueItems: {
+                type: 'boolean',
+                default: false,
+            },
+            maxContains: {
+                $ref: '#/$defs/nonNegativeInteger',
+            },
+            minContains: {
+                $ref: '#/$defs/nonNegativeInteger',
+                default: 1,
+            },
+            maxProperties: {
+                $ref: '#/$defs/nonNegativeInteger',
+            },
+            minProperties: {
+                $ref: '#/$defs/nonNegativeIntegerDefault0',
+            },
+            required: {
+                $ref: '#/$defs/stringArray',
+            },
+            dependentRequired: {
+                type: 'object',
+                additionalProperties: {
+                    $ref: '#/$defs/stringArray',
+                },
+            },
+            const: true,
+            enum: {
+                type: 'array',
+                items: true,
+            },
+            type: {
+                anyOf: [
+                    {
+                        $ref: '#/$defs/simpleTypes',
+                    },
+                    {
+                        type: 'array',
+                        items: {
+                            $ref: '#/$defs/simpleTypes',
+                        },
+                        minItems: 1,
+                        uniqueItems: true,
+                    },
+                ],
+            },
+            title: {
+                type: 'string',
+            },
+            description: {
+                type: 'string',
+            },
+            default: true,
+            deprecated: {
+                type: 'boolean',
+                default: false,
+            },
+            readOnly: {
+                type: 'boolean',
+                default: false,
+            },
+            writeOnly: {
+                type: 'boolean',
+                default: false,
+            },
+            examples: {
+                type: 'array',
+                items: true,
+            },
+            format: {
+                type: 'string',
+            },
+            contentMediaType: {
+                type: 'string',
+            },
+            contentEncoding: {
+                type: 'string',
+            },
+            contentSchema: {
+                $ref: '#',
+            },
+        },
+        $defs: {
+            schemaArray: {
+                type: 'array',
+                minItems: 1,
+                items: {
+                    $ref: '#',
+                },
+            },
+            nonNegativeInteger: {
+                type: 'integer',
+                minimum: 0,
+            },
+            nonNegativeIntegerDefault0: {
+                $ref: '#/$defs/nonNegativeInteger',
+                default: 0,
+            },
+            simpleTypes: {
+                enum: [
+                    'array',
+                    'boolean',
+                    'integer',
+                    'null',
+                    'number',
+                    'object',
+                    'string',
+                ],
+            },
+            stringArray: {
+                type: 'array',
+                items: {
+                    type: 'string',
+                },
+                uniqueItems: true,
+                default: [],
+            },
+        },
+    };
+});

package/lib/umd/services/schemas/draft-2020-12-flat.d.ts

@@ -0,0 +1,276 @@
+declare const _default: {
+    $id: string;
+    $schema: string;
+    title: string;
+    type: string[];
+    properties: {
+        definitions: {
+            $comment: string;
+            type: string;
+            additionalProperties: {
+                $ref: string;
+            };
+            default: {};
+        };
+        dependencies: {
+            $comment: string;
+            type: string;
+            additionalProperties: {
+                anyOf: {
+                    $ref: string;
+                }[];
+            };
+        };
+        $id: {
+            type: string;
+            format: string;
+            $comment: string;
+            pattern: string;
+        };
+        $schema: {
+            type: string;
+            format: string;
+        };
+        $anchor: {
+            type: string;
+            pattern: string;
+        };
+        $ref: {
+            type: string;
+            format: string;
+        };
+        $dynamicRef: {
+            type: string;
+            format: string;
+        };
+        $vocabulary: {
+            type: string;
+            propertyNames: {
+                type: string;
+                format: string;
+            };
+            additionalProperties: {
+                type: string;
+            };
+        };
+        $comment: {
+            type: string;
+        };
+        $defs: {
+            type: string;
+            additionalProperties: {
+                $ref: string;
+            };
+            default: {};
+        };
+        prefixItems: {
+            $ref: string;
+        };
+        items: {
+            $ref: string;
+        };
+        contains: {
+            $ref: string;
+        };
+        additionalProperties: {
+            $ref: string;
+        };
+        properties: {
+            type: string;
+            additionalProperties: {
+                $ref: string;
+            };
+            default: {};
+        };
+        patternProperties: {
+            type: string;
+            additionalProperties: {
+                $ref: string;
+            };
+            propertyNames: {
+                format: string;
+            };
+            default: {};
+        };
+        dependentSchemas: {
+            type: string;
+            additionalProperties: {
+                $ref: string;
+            };
+        };
+        propertyNames: {
+            $ref: string;
+        };
+        if: {
+            $ref: string;
+        };
+        then: {
+            $ref: string;
+        };
+        else: {
+            $ref: string;
+        };
+        allOf: {
+            $ref: string;
+        };
+        anyOf: {
+            $ref: string;
+        };
+        oneOf: {
+            $ref: string;
+        };
+        not: {
+            $ref: string;
+        };
+        unevaluatedItems: {
+            $ref: string;
+        };
+        unevaluatedProperties: {
+            $ref: string;
+        };
+        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;
+            } | {
+                type: string;
+                items: {
+                    $ref: string;
+                };
+                minItems: number;
+                uniqueItems: boolean;
+                $ref?: undefined;
+            })[];
+        };
+        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;
+        };
+        format: {
+            type: string;
+        };
+        contentMediaType: {
+            type: string;
+        };
+        contentEncoding: {
+            type: string;
+        };
+        contentSchema: {
+            $ref: string;
+        };
+    };
+    $defs: {
+        schemaArray: {
+            type: string;
+            minItems: number;
+            items: {
+                $ref: string;
+            };
+        };
+        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;