@scalar/schemas 0.2.0 → 0.3.0

package/dist/openapi/3.1/security-schemes.d.ts

@@ -0,0 +1,96 @@
+export declare const securityScheme: import("@scalar/validation").UnionSchema<readonly [import("@scalar/validation").ObjectSchema<{
+    type: import("@scalar/validation").LiteralSchema<"apiKey">;
+    name: import("@scalar/validation").StringSchema;
+    in: import("@scalar/validation").UnionSchema<readonly [import("@scalar/validation").LiteralSchema<"query">, import("@scalar/validation").LiteralSchema<"header">, import("@scalar/validation").LiteralSchema<"cookie">]>;
+    description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+}>, import("@scalar/validation").ObjectSchema<{
+    type: import("@scalar/validation").LiteralSchema<"http">;
+    scheme: import("@scalar/validation").UnionSchema<readonly [import("@scalar/validation").LiteralSchema<"basic">, import("@scalar/validation").LiteralSchema<"bearer">]>;
+    bearerFormat: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+}>, import("@scalar/validation").IntersectionSchema<readonly [import("@scalar/validation").ObjectSchema<{
+    type: import("@scalar/validation").LiteralSchema<"oauth2">;
+    flows: import("@scalar/validation").ObjectSchema<{
+        implicit: import("@scalar/validation").OptionalSchema<import("@scalar/validation").IntersectionSchema<readonly [import("@scalar/validation").ObjectSchema<{
+            refreshUrl: import("@scalar/validation").StringSchema;
+            scopes: import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").StringSchema>;
+        }>, import("@scalar/validation").ObjectSchema<{
+            'x-scalar-security-query': import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").StringSchema>>;
+        }>, import("@scalar/validation").ObjectSchema<{
+            'x-scalar-security-body': import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").StringSchema>>;
+        }>, import("@scalar/validation").ObjectSchema<{
+            'x-tokenName': import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        }>, import("@scalar/validation").ObjectSchema<{
+            'x-scalar-secret-auth-url': import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        }>, import("@scalar/validation").ObjectSchema<{
+            'x-scalar-secret-token-url': import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        }>, import("@scalar/validation").ObjectSchema<{
+            authorizationUrl: import("@scalar/validation").StringSchema;
+        }>]>>;
+        password: import("@scalar/validation").OptionalSchema<import("@scalar/validation").IntersectionSchema<readonly [import("@scalar/validation").ObjectSchema<{
+            refreshUrl: import("@scalar/validation").StringSchema;
+            scopes: import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").StringSchema>;
+        }>, import("@scalar/validation").ObjectSchema<{
+            'x-scalar-security-query': import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").StringSchema>>;
+        }>, import("@scalar/validation").ObjectSchema<{
+            'x-scalar-security-body': import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").StringSchema>>;
+        }>, import("@scalar/validation").ObjectSchema<{
+            'x-tokenName': import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        }>, import("@scalar/validation").ObjectSchema<{
+            'x-scalar-secret-auth-url': import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        }>, import("@scalar/validation").ObjectSchema<{
+            'x-scalar-secret-token-url': import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        }>, import("@scalar/validation").ObjectSchema<{
+            tokenUrl: import("@scalar/validation").StringSchema;
+        }>, import("@scalar/validation").ObjectSchema<{
+            'x-scalar-credentials-location': import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnionSchema<readonly [import("@scalar/validation").LiteralSchema<"header">, import("@scalar/validation").LiteralSchema<"body">]>>;
+        }>]>>;
+        clientCredentials: import("@scalar/validation").OptionalSchema<import("@scalar/validation").IntersectionSchema<readonly [import("@scalar/validation").ObjectSchema<{
+            refreshUrl: import("@scalar/validation").StringSchema;
+            scopes: import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").StringSchema>;
+        }>, import("@scalar/validation").ObjectSchema<{
+            'x-scalar-security-query': import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").StringSchema>>;
+        }>, import("@scalar/validation").ObjectSchema<{
+            'x-scalar-security-body': import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").StringSchema>>;
+        }>, import("@scalar/validation").ObjectSchema<{
+            'x-tokenName': import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        }>, import("@scalar/validation").ObjectSchema<{
+            'x-scalar-secret-auth-url': import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        }>, import("@scalar/validation").ObjectSchema<{
+            'x-scalar-secret-token-url': import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        }>, import("@scalar/validation").ObjectSchema<{
+            tokenUrl: import("@scalar/validation").StringSchema;
+        }>, import("@scalar/validation").ObjectSchema<{
+            'x-scalar-credentials-location': import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnionSchema<readonly [import("@scalar/validation").LiteralSchema<"header">, import("@scalar/validation").LiteralSchema<"body">]>>;
+        }>]>>;
+        authorizationCode: import("@scalar/validation").OptionalSchema<import("@scalar/validation").IntersectionSchema<readonly [import("@scalar/validation").ObjectSchema<{
+            refreshUrl: import("@scalar/validation").StringSchema;
+            scopes: import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").StringSchema>;
+        }>, import("@scalar/validation").ObjectSchema<{
+            'x-scalar-security-query': import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").StringSchema>>;
+        }>, import("@scalar/validation").ObjectSchema<{
+            'x-scalar-security-body': import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").StringSchema>>;
+        }>, import("@scalar/validation").ObjectSchema<{
+            'x-tokenName': import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        }>, import("@scalar/validation").ObjectSchema<{
+            'x-scalar-secret-auth-url': import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        }>, import("@scalar/validation").ObjectSchema<{
+            'x-scalar-secret-token-url': import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        }>, import("@scalar/validation").ObjectSchema<{
+            authorizationUrl: import("@scalar/validation").StringSchema;
+            tokenUrl: import("@scalar/validation").StringSchema;
+        }>, import("@scalar/validation").ObjectSchema<{
+            'x-usePkce': import("@scalar/validation").UnionSchema<readonly [import("@scalar/validation").LiteralSchema<"no">, import("@scalar/validation").LiteralSchema<"SHA-256">, import("@scalar/validation").LiteralSchema<"plain">]>;
+        }>, import("@scalar/validation").ObjectSchema<{
+            'x-scalar-credentials-location': import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnionSchema<readonly [import("@scalar/validation").LiteralSchema<"header">, import("@scalar/validation").LiteralSchema<"body">]>>;
+        }>]>>;
+    }>;
+    description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-default-scopes': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").StringSchema>>;
+}>]>, import("@scalar/validation").ObjectSchema<{
+    type: import("@scalar/validation").LiteralSchema<"openIdConnect">;
+    openIdConnectUrl: import("@scalar/validation").StringSchema;
+    description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+}>]>;
+//# sourceMappingURL=security-schemes.d.ts.map

package/dist/openapi/3.1/security-schemes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"security-schemes.d.ts","sourceRoot":"","sources":["../../../src/openapi/3.1/security-schemes.ts"],"names":[],"mappings":"AA4KA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAG1B,CAAA"}

package/dist/openapi/3.1/security-schemes.js

@@ -0,0 +1,107 @@
+import { intersection, literal, object, optional, record, string, union } from '@scalar/validation';
+import { XDefaultScopes, XScalarAuthUrl, XScalarCredentialsLocation, XScalarSecurityBody, XScalarSecurityQuery, XScalarTokenUrl, XTokenName, XusePkce, } from '../../extensions/security/index.js';
+const securitySchemeBase = object({
+    description: optional(string({
+        typeComment: 'A description for security scheme. CommonMark syntax MAY be used for rich text representation.',
+    })),
+});
+const apiKeySecurityScheme = object({
+    ...securitySchemeBase.properties,
+    type: literal('apiKey'),
+    name: string({ typeComment: 'REQUIRED. The name of the header, query or cookie parameter to be used.' }),
+    in: union([literal('query'), literal('header'), literal('cookie')], {
+        typeComment: 'REQUIRED. The location of the API key. Valid values are "query", "header", or "cookie".',
+    }),
+}, { typeName: 'ApiKeySecuritySchemeObject' });
+const httpSecurityScheme = object({
+    ...securitySchemeBase.properties,
+    type: literal('http'),
+    scheme: union([literal('basic'), literal('bearer')], {
+        typeName: 'HttpSecuritySchemeScheme',
+        typeComment: 'REQUIRED. The name of the HTTP Authentication scheme to be used in the Authorization header as defined in RFC7235.',
+    }),
+    bearerFormat: optional(string({
+        typeComment: 'A hint to the client to identify how the bearer token is formatted. Bearer tokens are usually generated by an authorization server, so this information is primarily for documentation purposes.',
+    })),
+}, { typeName: 'HttpSecuritySchemeObject' });
+const oauthFlowExtensionObjects = [
+    XScalarSecurityQuery,
+    XScalarSecurityBody,
+    XTokenName,
+    XScalarAuthUrl,
+    XScalarTokenUrl,
+];
+const oauthFlowCore = object({
+    refreshUrl: string({
+        typeComment: 'The URL to be used for obtaining refresh tokens. This MUST be in the form of a URL. The OAuth2 standard requires the use of TLS.',
+    }),
+    scopes: record(string(), string(), {
+        typeComment: 'REQUIRED. The available scopes for the OAuth2 security scheme. A map between the scope name and a short description for it. The map MAY be empty.',
+        typeName: 'OAuthFlowScopes',
+    }),
+}, { typeName: 'OAuthFlowBaseCore' });
+const implicitOAuth2Flow = intersection([
+    oauthFlowCore,
+    ...oauthFlowExtensionObjects,
+    object({
+        authorizationUrl: string({
+            typeComment: 'REQUIRED. The authorization URL to be used for this flow. This MUST be in the form of a URL. The OAuth2 standard requires the use of TLS.',
+        }),
+    }),
+], { typeName: 'ImplicitOAuthFlowObject' });
+const passwordOAuth2Flow = intersection([
+    oauthFlowCore,
+    ...oauthFlowExtensionObjects,
+    object({
+        tokenUrl: string({
+            typeComment: 'REQUIRED. The token URL to be used for this flow. This MUST be in the form of a URL. The OAuth2 standard requires the use of TLS.',
+        }),
+    }),
+    XScalarCredentialsLocation,
+], { typeName: 'PasswordOAuthFlowObject' });
+const clientCredentialsOAuth2Flow = intersection([
+    oauthFlowCore,
+    ...oauthFlowExtensionObjects,
+    object({
+        tokenUrl: string({
+            typeComment: 'REQUIRED. The token URL to be used for this flow. This MUST be in the form of a URL. The OAuth2 standard requires the use of TLS.',
+        }),
+    }),
+    XScalarCredentialsLocation,
+], { typeName: 'ClientCredentialsOAuthFlowObject' });
+const authorizationCodeOAuth2Flow = intersection([
+    oauthFlowCore,
+    ...oauthFlowExtensionObjects,
+    object({
+        authorizationUrl: string({
+            typeComment: 'REQUIRED. The authorization URL to be used for this flow. This MUST be in the form of a URL. The OAuth2 standard requires the use of TLS.',
+        }),
+        tokenUrl: string({
+            typeComment: 'REQUIRED. The token URL to be used for this flow. This MUST be in the form of a URL. The OAuth2 standard requires the use of TLS.',
+        }),
+    }),
+    XusePkce,
+    XScalarCredentialsLocation,
+], { typeName: 'AuthorizationCodeOAuthFlowObject' });
+const oauth2Flows = object({
+    implicit: optional(implicitOAuth2Flow),
+    password: optional(passwordOAuth2Flow),
+    clientCredentials: optional(clientCredentialsOAuth2Flow),
+    authorizationCode: optional(authorizationCodeOAuth2Flow),
+}, { typeName: 'OAuthFlowsObject' });
+const oauth2SecurityScheme = intersection([
+    object({
+        ...securitySchemeBase.properties,
+        type: literal('oauth2'),
+        flows: oauth2Flows,
+    }),
+    XDefaultScopes,
+], { typeName: 'OAuth2SecuritySchemeObject' });
+const openIdConnectSecurityScheme = object({
+    ...securitySchemeBase.properties,
+    type: literal('openIdConnect'),
+    openIdConnectUrl: string({
+        typeComment: 'REQUIRED. Well-known URL to discover the [[OpenID-Connect-Discovery]] provider metadata.',
+    }),
+}, { typeName: 'OpenIdConnectSecuritySchemeObject' });
+export const securityScheme = union([apiKeySecurityScheme, httpSecurityScheme, oauth2SecurityScheme, openIdConnectSecurityScheme], { typeName: 'SecuritySchemeObject' });

package/dist/openapi/3.1/server-variable.d.ts

@@ -0,0 +1,6 @@
+export declare const serverVariable: import("@scalar/validation").ObjectSchema<{
+    enum: import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").StringSchema>>;
+    default: import("@scalar/validation").StringSchema;
+    description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+}>;
+//# sourceMappingURL=server-variable.d.ts.map

package/dist/openapi/3.1/server-variable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-variable.d.ts","sourceRoot":"","sources":["../../../src/openapi/3.1/server-variable.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,cAAc;;;;EAmB1B,CAAA"}

package/dist/openapi/3.1/server-variable.js

@@ -0,0 +1,12 @@
+import { array, object, optional, string } from '@scalar/validation';
+export const serverVariable = object({
+    enum: optional(array(string(), {
+        typeComment: 'An enumeration of string values to be used if the substitution options are from a limited set. The array MUST NOT be empty.',
+    })),
+    default: string({
+        typeComment: `REQUIRED. The default value to use for substitution, which SHALL be sent if an alternate value is not supplied. If the enum is defined, the value MUST exist in the enum\'s values. Note that this behavior is different from the Schema Object's default keyword, which documents the receiver's behavior rather than inserting the value into the data.`,
+    }),
+    description: optional(string({
+        typeComment: 'An optional description for the server variable. CommonMark syntax MAY be used for rich text representation.',
+    })),
+}, { typeName: 'ServerVariableObject' });

package/dist/openapi/3.1/server.d.ts

@@ -0,0 +1,10 @@
+export declare const server: import("@scalar/validation").ObjectSchema<{
+    url: import("@scalar/validation").StringSchema;
+    description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    variables: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").ObjectSchema<{
+        enum: import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").StringSchema>>;
+        default: import("@scalar/validation").StringSchema;
+        description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    }>>>;
+}>;
+//# sourceMappingURL=server.d.ts.map

package/dist/openapi/3.1/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../src/openapi/3.1/server.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,MAAM;;;;;;;;EAmBlB,CAAA"}

package/dist/openapi/3.1/server.js

@@ -0,0 +1,13 @@
+import { object, optional, record, string } from '@scalar/validation';
+import { serverVariable } from '../../openapi/3.1/server-variable.js';
+export const server = object({
+    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}.',
+    }),
+    description: optional(string({
+        typeComment: 'An optional string describing the host designated by the URL. CommonMark syntax MAY be used for rich text representation.',
+    })),
+    variables: optional(record(string(), serverVariable, {
+        typeComment: `A map between a variable name and its value. The value is used for substitution in the server's URL template.`,
+    })),
+}, { typeName: 'ServerObject' });

package/dist/openapi/3.1/tag.d.ts

@@ -0,0 +1,17 @@
+export declare const tag: import("@scalar/validation").IntersectionSchema<readonly [import("@scalar/validation").ObjectSchema<{
+    name: import("@scalar/validation").StringSchema;
+    description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    externalDocs: import("@scalar/validation").OptionalSchema<import("@scalar/validation").ObjectSchema<{
+        url: import("@scalar/validation").StringSchema;
+        description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    }>>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-displayName': import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-internal': import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-scalar-ignore': import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-scalar-order': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").StringSchema>>;
+}>]>;
+//# sourceMappingURL=tag.d.ts.map

package/dist/openapi/3.1/tag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tag.d.ts","sourceRoot":"","sources":["../../../src/openapi/3.1/tag.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;IAiBf,CAAA"}

package/dist/openapi/3.1/tag.js

@@ -0,0 +1,18 @@
+import { intersection, object, optional, string } from '@scalar/validation';
+import { XInternal, XScalarIgnore } from '../../extensions/document/index.js';
+import { XScalarOrder } from '../../extensions/general/index.js';
+import { XDisplayName } from '../../extensions/tag/index.js';
+import { externalDocs } from '../../openapi/3.1/external-docs.js';
+export const tag = intersection([
+    object({
+        name: string({ typeComment: 'REQUIRED. The name of the tag.' }),
+        description: optional(string({
+            typeComment: 'A description for the tag. CommonMark syntax MAY be used for rich text representation.',
+        })),
+        externalDocs: optional(externalDocs),
+    }),
+    XDisplayName,
+    XInternal,
+    XScalarIgnore,
+    XScalarOrder,
+], { typeName: 'TagObject' });

package/dist/openapi/3.1/xml.d.ts

@@ -0,0 +1,8 @@
+export declare const xml: import("@scalar/validation").ObjectSchema<{
+    name: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    namespace: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    prefix: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    attribute: import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+    wrapped: import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+}>;
+//# sourceMappingURL=xml.d.ts.map

package/dist/openapi/3.1/xml.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xml.d.ts","sourceRoot":"","sources":["../../../src/openapi/3.1/xml.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,GAAG;;;;;;EA4Bf,CAAA"}

package/dist/openapi/3.1/xml.js

@@ -0,0 +1,16 @@
+import { boolean, object, optional, string } from '@scalar/validation';
+export const xml = object({
+    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.',
+    })),
+    namespace: optional(string({
+        typeComment: 'The URI of the namespace definition. Value MUST be in the form of a non-relative URI.',
+    })),
+    prefix: optional(string({ typeComment: 'The prefix to be used for the name.' })),
+    attribute: optional(boolean({
+        typeComment: 'Declares whether the property definition translates to an attribute instead of an element. Default value is false.',
+    })),
+    wrapped: optional(boolean({
+        typeComment: 'MAY be used only for an array definition. Signifies whether the array is wrapped (for example, <books><book/><book/></books>) or unwrapped (<book/><book/>). Default value is false. The definition takes effect only when defined alongside type being "array" (outside the items).',
+    })),
+}, { typeName: 'XMLObject' });

package/package.json

@@ -14,7 +14,7 @@
     "schemas",
     "scalar"
   ],
-  "version": "0.2.0",
+  "version": "0.3.0",
   "engines": {
     "node": ">=22"
   },
@@ -24,6 +24,16 @@
       "import": "./dist/api-reference/index.js",
       "types": "./dist/api-reference/index.d.ts",
       "default": "./dist/api-reference/index.js"
+    },
+    "./asyncapi/3.1": {
+      "import": "./dist/asyncapi/3.1/index.js",
+      "types": "./dist/asyncapi/3.1/index.d.ts",
+      "default": "./dist/asyncapi/3.1/index.js"
+    },
+    "./openapi/3.1": {
+      "import": "./dist/openapi/3.1/index.js",
+      "types": "./dist/openapi/3.1/index.d.ts",
+      "default": "./dist/openapi/3.1/index.js"
     }
   },
   "files": [
@@ -31,16 +41,18 @@
     "CHANGELOG.md"
   ],
   "dependencies": {
-    "@scalar/validation": "0.5.0"
+    "@scalar/validation": "0.6.0",
+    "@scalar/helpers": "0.8.0"
   },
   "devDependencies": {
     "vitest": "4.1.0",
-    "@scalar/types": "0.11.0"
+    "@scalar/types": "0.12.0"
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
     "test": "vitest --run",
     "types:check": "tsc --noEmit",
-    "types:generate": "tsx scripts/generate-types.ts"
+    "types:generate": "tsx scripts/generate-types.ts",
+    "types:generate:stage": "tsx scripts/stage-generated-types.ts"
   }
 }

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2023-present Scalar
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.