@scalar/workspace-store 0.64.0 → 0.66.0

package/dist/schemas/v3.2/openapi/index.js

@@ -51,6 +51,7 @@ const externalDocs = object({
     })),
 }, { typeName: 'ExternalDocumentationObject' });
 const xml = object({
+    nodeType: optional(union([literal('element'), literal('attribute'), literal('text'), literal('cdata'), literal('none')])),
     name: optional(string({
         typeComment: 'Replaces the name of the element/attribute used for the described schema property. When defined within items, it will affect the name of the individual XML elements within the list. When defined alongside type being "array" (outside the items), it will affect the wrapping element if and only if wrapped is true. If wrapped is false, it will be ignored.',
     })),
@@ -66,6 +67,7 @@ const xml = object({
     })),
 }, { typeName: 'XMLObject' });
 const discriminatorObject = object({
+    defaultMapping: optional(string({ typeComment: 'Schema name or URI reference used when the discriminator value is absent or unmapped.' })),
     propertyName: string({
         typeComment: 'REQUIRED. The name of the property in the payload that will hold the discriminating value. This property SHOULD be required in the payload schema, as the behavior when the property is absent is undefined.',
     }),
@@ -274,6 +276,7 @@ export const generateSchema = (maybeRef, options = {}) => {
         })),
     }, { typeName: 'ServerVariableObject' });
     const servers = object({
+        name: optional(string({ typeComment: 'A name for the server.' })),
         url: string({
             typeComment: 'REQUIRED. A URL to the target host. This URL supports Server Variables and MAY be relative, to indicate that the host location is relative to the location where the document containing the Server Object is being served. Variable substitutions will be made when a variable is named in {braces}.',
         }),
@@ -290,6 +293,9 @@ export const generateSchema = (maybeRef, options = {}) => {
     const tag = intersection([
         object({
             name: string({ typeComment: 'REQUIRED. The name of the tag.' }),
+            summary: optional(string({ typeComment: 'A short summary of the tag.' })),
+            parent: optional(string({ typeComment: 'The name of the parent tag.' })),
+            kind: optional(string({ typeComment: 'A machine-readable category for the tag.' })),
             description: optional(string({
                 typeComment: 'A description for the tag. CommonMark syntax MAY be used for rich text representation.',
             })),
@@ -305,6 +311,7 @@ export const generateSchema = (maybeRef, options = {}) => {
         typeComment: 'Lists the required security schemes to execute this operation. An empty object ({}) indicates anonymous access is supported.',
     });
     const securitySchemeBase = object({
+        deprecated: optional(boolean({ typeComment: 'Whether the security scheme is deprecated.' })),
         description: optional(string({
             typeComment: 'A description for security scheme. CommonMark syntax MAY be used for rich text representation.',
         })),
@@ -391,11 +398,21 @@ export const generateSchema = (maybeRef, options = {}) => {
         XusePkce,
         XScalarCredentialsLocation,
     ]);
+    const deviceAuthorizationOAuth2Flow = intersection([
+        oauthFlowCore,
+        ...oauthFlowExtensionObjects,
+        object({
+            deviceAuthorizationUrl: string({ typeComment: 'The device authorization endpoint URL.' }),
+            tokenUrl: string({ typeComment: 'The token endpoint URL.' }),
+        }, { typeName: 'DeviceAuthorizationOAuthFlowObject' }),
+        XScalarCredentialsLocation,
+    ]);
     const oauth2Flows = object({
         implicit: optional(implicitOAuth2Flow),
         password: optional(passwordOAuth2Flow),
         clientCredentials: optional(clientCredentialsOAuth2Flow),
         authorizationCode: optional(authorizationCodeOAuth2Flow),
+        deviceAuthorization: optional(deviceAuthorizationOAuth2Flow),
     }, { typeName: 'OAuthFlowsObject' });
     const oauth2SecurityScheme = intersection([
         object({
@@ -424,6 +441,7 @@ export const generateSchema = (maybeRef, options = {}) => {
     ], { typeName: 'SecuritySchemeObject' });
     const components = object({
         schemas: optional(record(string(), maybeRef(schema), { typeName: 'ComponentsSchemas' })),
+        mediaTypes: optional(record(string(), maybeRef(lazy(() => mediaType)), { typeName: 'ComponentsMediaTypes' })),
         responses: optional(record(string(), maybeRef(lazy(() => response)), { typeName: 'ComponentsResponses' })),
         parameters: optional(record(string(), maybeRef(lazy(() => parameter)), { typeName: 'ComponentsParameters' })),
         examples: optional(record(string(), maybeRef(lazy(() => example)), { typeName: 'ComponentsExamples' })),
@@ -443,6 +461,8 @@ export const generateSchema = (maybeRef, options = {}) => {
             value: optional(any({
                 typeComment: 'Embedded literal example. The value field and externalValue field are mutually exclusive.',
             })),
+            dataValue: optional(any()),
+            serializedValue: optional(string()),
             externalValue: optional(string({
                 typeComment: 'A URI that identifies the literal example. The value field and externalValue field are mutually exclusive.',
             })),
@@ -475,18 +495,28 @@ export const generateSchema = (maybeRef, options = {}) => {
     const headerWithContent = intersection([
         headerBase,
         object({
-            content: optional(record(string(), lazy(() => mediaType), { typeName: 'HeaderContent' })),
+            content: optional(record(string(), maybeRef(lazy(() => mediaType)), { typeName: 'HeaderContent' })),
         }, { typeName: 'HeaderObjectWithContent' }),
     ]);
     const header = union([headerWithSchema, headerWithContent], { typeName: 'HeaderObject' });
     const encoding = object({
+        style: optional(string()),
+        explode: optional(boolean()),
+        allowReserved: optional(boolean()),
+        encoding: optional(record(string(), lazy(() => encoding))),
+        prefixEncoding: optional(array(lazy(() => encoding))),
+        itemEncoding: optional(lazy(() => encoding)),
         contentType: optional(string({
             typeComment: 'The Content-Type for encoding a specific property. The value is a comma-separated list, each element of which is either a specific media type (e.g. image/png) or a wildcard media type (e.g. image/*).',
         })),
         headers: optional(record(string(), maybeRef(lazy(() => header)), { typeName: 'EncodingHeaders' })),
     }, { typeName: 'EncodingObject' });
     const mediaType = object({
+        description: optional(string()),
+        prefixEncoding: optional(array(encoding)),
+        itemEncoding: optional(encoding),
         schema: optional(maybeRef(lazy(() => schema))),
+        itemSchema: optional(maybeRef(lazy(() => schema))),
         example: optional(any({ typeComment: 'Example of the media type.' })),
         examples: optional(record(string(), maybeRef(lazy(() => example)), { typeName: 'MediaTypeExamples' })),
         encoding: optional(record(string(), encoding, {
@@ -499,9 +529,9 @@ export const generateSchema = (maybeRef, options = {}) => {
             name: string({
                 typeComment: 'REQUIRED. The name of the parameter. Parameter names are case sensitive. If in is "path", the name field MUST correspond to a template expression occurring within the path field in the Paths Object.',
             }),
-            in: union([literal('query'), literal('header'), literal('path'), literal('cookie')], {
+            in: union([literal('query'), literal('header'), literal('path'), literal('cookie'), literal('querystring')], {
                 typeName: 'ParameterLocation',
-                typeComment: 'REQUIRED. The location of the parameter. Possible values are "query", "header", "path" or "cookie".',
+                typeComment: 'REQUIRED. The location of the parameter. Possible values are "query", "header", "path", "cookie" or "querystring".',
             }),
             description: optional(string({
                 typeComment: 'A brief description of the parameter. This could contain examples of use. CommonMark syntax MAY be used for rich text representation.',
@@ -537,9 +567,9 @@ export const generateSchema = (maybeRef, options = {}) => {
             name: string({
                 typeComment: 'REQUIRED. The name of the parameter. Parameter names are case sensitive. If in is "path", the name field MUST correspond to a template expression occurring within the path field in the Paths Object.',
             }),
-            in: union([literal('query'), literal('header'), literal('path'), literal('cookie')], {
+            in: union([literal('query'), literal('header'), literal('path'), literal('cookie'), literal('querystring')], {
                 typeName: 'ParameterLocation',
-                typeComment: 'REQUIRED. The location of the parameter. Possible values are "query", "header", "path" or "cookie".',
+                typeComment: 'REQUIRED. The location of the parameter. Possible values are "query", "header", "path", "cookie" or "querystring".',
             }),
             description: optional(string({
                 typeComment: 'A brief description of the parameter. This could contain examples of use. CommonMark syntax MAY be used for rich text representation.',
@@ -556,7 +586,9 @@ export const generateSchema = (maybeRef, options = {}) => {
             allowReserved: optional(boolean({
                 typeComment: 'When this is true, parameter values are serialized using reserved expansion, as defined by RFC6570. This field only applies to parameters with an in value of query. The default value is false.',
             })),
-            content: optional(record(string(), lazy(() => mediaType), { typeName: 'ParameterContent' })),
+            example: optional(any()),
+            examples: optional(record(string(), maybeRef(example))),
+            content: optional(record(string(), maybeRef(lazy(() => mediaType)), { typeName: 'ParameterContent' })),
         }, { typeName: 'ParameterObjectWithContent' }),
         XGlobal,
         XInternal,
@@ -568,7 +600,7 @@ export const generateSchema = (maybeRef, options = {}) => {
             description: optional(string({
                 typeComment: 'A brief description of the request body. This could contain examples of use. CommonMark syntax MAY be used for rich text representation.',
             })),
-            content: record(string(), lazy(() => mediaType), {
+            content: record(string(), maybeRef(lazy(() => mediaType)), {
                 typeComment: 'REQUIRED. The content of the request body. The key is a media type or media type range and the value describes it.',
                 typeName: 'RequestBodyContent',
             }),
@@ -596,11 +628,12 @@ export const generateSchema = (maybeRef, options = {}) => {
         server: optional(servers),
     }, { typeName: 'LinkObject' });
     const response = object({
-        description: string({
-            typeComment: 'REQUIRED. A description of the response. CommonMark syntax MAY be used for rich text representation.',
-        }),
+        summary: optional(string({ typeComment: 'A short summary of the response.' })),
+        description: optional(string({
+            typeComment: 'A description of the response. CommonMark syntax MAY be used for rich text representation.',
+        })),
         headers: optional(record(string(), maybeRef(lazy(() => header)), { typeName: 'ResponseHeaders' })),
-        content: optional(record(string(), lazy(() => mediaType), { typeName: 'ResponseContent' })),
+        content: optional(record(string(), maybeRef(lazy(() => mediaType)), { typeName: 'ResponseContent' })),
         links: optional(record(string(), maybeRef(lazy(() => link)), { typeName: 'ResponseLinks' })),
     }, { typeName: 'ResponseObject' });
     const responsesObject = record(string(), maybeRef(lazy(() => response)), {
@@ -663,6 +696,8 @@ export const generateSchema = (maybeRef, options = {}) => {
         options: optional(maybeRef(lazy(() => operation))),
         head: optional(maybeRef(lazy(() => operation))),
         trace: optional(maybeRef(lazy(() => operation))),
+        query: optional(maybeRef(lazy(() => operation))),
+        additionalOperations: optional(record(string(), maybeRef(lazy(() => operation)), { typeName: 'AdditionalOperations' })),
         servers: optional(array(servers, { typeName: 'PathItemServers' })),
         parameters: optional(array(maybeRef(lazy(() => parameter)), { typeName: 'PathItemParameters' })),
     }, { typeName: 'PathItemObject' });
@@ -673,6 +708,7 @@ export const generateSchema = (maybeRef, options = {}) => {
         })),
     }, { typeName: 'OpenApiExtensionsPartial' });
     const openApiDocumentCore = object({
+        $self: optional(string({ typeComment: 'The URI identifying this OpenAPI document.' })),
         openapi: string({
             typeComment: 'REQUIRED. This string MUST be the version number of the OpenAPI Specification that the OpenAPI Document uses. The openapi field SHOULD be used by tooling to interpret the OpenAPI Document. This is not related to the API info.version string.',
         }),
@@ -722,7 +758,7 @@ export const generateSchema = (maybeRef, options = {}) => {
         XPostResponse,
     ], {
         typeName: 'OpenApiDocument',
-        typeComment: 'Root OpenAPI 3.1 document including Scalar workspace extensions (OpenApiExtensionsSchema).',
+        typeComment: 'Root OpenAPI 3.2 document including Scalar workspace extensions (OpenApiExtensionsSchema).',
     });
     return openapi;
 };

package/dist/schemas/v3.2/openapi/reference.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reference.d.ts","sourceRoot":"","sources":["../../../../src/schemas/v3.2/openapi/reference.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,MAAM,EASZ,MAAM,oBAAoB,CAAA;AAsC3B,eAAO,MAAM,SAAS,GAAI,QAAQ,MAAM,KAAG,MAAoC,CAAA;AAS/E,eAAO,MAAM,YAAY,GAAI,QAAQ,MAAM,KAAG,MACkE,CAAA"}
+{"version":3,"file":"reference.d.ts","sourceRoot":"","sources":["../../../../src/schemas/v3.2/openapi/reference.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,MAAM,EASZ,MAAM,oBAAoB,CAAA;AAsC3B,eAAO,MAAM,SAAS,GAAI,QAAQ,MAAM,KAAG,MAAoC,CAAA;AAkB/E,eAAO,MAAM,YAAY,GAAI,QAAQ,MAAM,KAAG,MACkE,CAAA"}

package/dist/schemas/v3.2/openapi/reference.js

@@ -20,10 +20,18 @@ const reference = object({
     typeName: 'ReferenceObject',
 });
 export const normalRef = (schema) => union([schema, reference]);
+/**
+ * Follows a chain of references to the value at its end. References can form a loop (`A` points at
+ * `B` and `B` points back at `A`, or a schema points at itself), so we stop at the first reference we
+ * have already passed. Without that, a loop in an untrusted document overflows the stack.
+ */
 const e = (value) => {
-    if (isObject(value) && '$ref' in value) {
-        return e(value['$ref-value']);
+    const seen = new Set();
+    let current = value;
+    while (isObject(current) && '$ref' in current && !seen.has(current)) {
+        seen.add(current);
+        current = current['$ref-value'];
     }
-    return value;
+    return current;
 };
 export const recursiveRef = (schema) => union([schema, intersection([reference, object({ '$ref-value': evaluate(e, schema) }), referenceExtensions])]);