@scalar/workspace-store 0.56.0 → 0.57.0

package/dist/schemas/v3.2/strict/ref-definitions.js

@@ -0,0 +1,80 @@
+import { Type } from '@scalar/typebox';
+/**
+ * Reference definitions for OpenAPI 3.1 objects.
+ * These can be used with Type.Ref to create references to these objects in other schemas.
+ *
+ * Referencing them this way helps avoid circular dependencies in TypeBox schemas while keeping the overhead performance lower.
+ */
+export const REF_DEFINITIONS = {
+    ComponentsObject: 'ComponentsObject',
+    SecurityRequirementObject: 'SecurityRequirementObject',
+    TagObject: 'TagObject',
+    CallbackObject: 'CallbackObject',
+    PathsObject: 'PathsObject',
+    PathItemObject: 'PathItemObject',
+    OperationObject: 'OperationObject',
+    SchemaObject: 'SchemaObject',
+    EncodingObject: 'EncodingObject',
+    HeaderObject: 'HeaderObject',
+    MediaTypeObject: 'MediaTypeObject',
+    ServerObject: 'ServerObject',
+    ExternalDocumentationObject: 'ExternalDocumentationObject',
+    InfoObject: 'InfoObject',
+    ContactObject: 'ContactObject',
+    LicenseObject: 'LicenseObject',
+    ResponseObject: 'ResponseObject',
+    ResponsesObject: 'ResponsesObject',
+    ParameterObject: 'ParameterObject',
+    ExampleObject: 'ExampleObject',
+    RequestBodyObject: 'RequestBodyObject',
+    SecuritySchemeObject: 'SecuritySchemeObject',
+    SecuritySchemes: 'SecuritySchemes',
+    LinkObject: 'LinkObject',
+    XMLObject: 'XMLObject',
+    DiscriminatorObject: 'DiscriminatorObject',
+    OAuthFlowsObject: 'OAuthFlowsObject',
+    ServerVariableObject: 'ServerVariableObject',
+    // Navigation schemas
+    TraversedDescriptionObject: 'TraversedDescriptionObject',
+    TraversedOperationObject: 'TraversedOperationObject',
+    TraversedAsyncApiOperationObject: 'TraversedAsyncApiOperationObject',
+    TraversedAsyncApiChannelObject: 'TraversedAsyncApiChannelObject',
+    TraversedAsyncApiMessageObject: 'TraversedAsyncApiMessageObject',
+    TraversedSchemaObject: 'TraversedSchemaObject',
+    TraversedWebhookObject: 'TraversedWebhookObject',
+    TraversedTagObject: 'TraversedTagObject',
+    TraversedEntryObject: 'TraversedEntryObject',
+    TraversedDocumentObject: 'TraversedDocumentObject',
+};
+// Type alias for schema definitions
+export const ComponentsObjectRef = Type.Ref(REF_DEFINITIONS.ComponentsObject);
+export const SecurityRequirementObjectRef = Type.Ref(REF_DEFINITIONS.SecurityRequirementObject);
+export const TagObjectRef = Type.Ref(REF_DEFINITIONS.TagObject);
+export const CallbackObjectRef = Type.Ref(REF_DEFINITIONS.CallbackObject);
+export const PathItemObjectRef = Type.Ref(REF_DEFINITIONS.PathItemObject);
+export const PathsObjectRef = Type.Ref(REF_DEFINITIONS.PathsObject);
+export const OperationObjectRef = Type.Ref(REF_DEFINITIONS.OperationObject);
+export const SchemaObjectRef = Type.Ref(REF_DEFINITIONS.SchemaObject);
+export const EncodingObjectRef = Type.Ref(REF_DEFINITIONS.EncodingObject);
+export const HeaderObjectRef = Type.Ref(REF_DEFINITIONS.HeaderObject);
+export const MediaTypeObjectRef = Type.Ref(REF_DEFINITIONS.MediaTypeObject);
+export const ServerObjectRef = Type.Ref(REF_DEFINITIONS.ServerObject);
+export const ExternalDocumentationObjectRef = Type.Ref(REF_DEFINITIONS.ExternalDocumentationObject);
+export const InfoObjectRef = Type.Ref(REF_DEFINITIONS.InfoObject);
+export const ContactObjectRef = Type.Ref(REF_DEFINITIONS.ContactObject);
+export const LicenseObjectRef = Type.Ref(REF_DEFINITIONS.LicenseObject);
+export const ResponseObjectRef = Type.Ref(REF_DEFINITIONS.ResponseObject);
+export const ResponsesObjectRef = Type.Ref(REF_DEFINITIONS.ResponsesObject);
+export const ParameterObjectRef = Type.Ref(REF_DEFINITIONS.ParameterObject);
+export const ExampleObjectRef = Type.Ref(REF_DEFINITIONS.ExampleObject);
+export const RequestBodyObjectRef = Type.Ref(REF_DEFINITIONS.RequestBodyObject);
+export const SecuritySchemeObjectRef = Type.Ref(REF_DEFINITIONS.SecuritySchemeObject);
+export const LinkObjectRef = Type.Ref(REF_DEFINITIONS.LinkObject);
+export const XMLObjectRef = Type.Ref(REF_DEFINITIONS.XMLObject);
+export const DiscriminatorObjectRef = Type.Ref(REF_DEFINITIONS.DiscriminatorObject);
+export const OAuthFlowsObjectRef = Type.Ref(REF_DEFINITIONS.OAuthFlowsObject);
+export const ServerVariableObjectRef = Type.Ref(REF_DEFINITIONS.ServerVariableObject);
+// Navigation schema references
+export const TraversedEntryObjectRef = Type.Ref(REF_DEFINITIONS.TraversedEntryObject);
+// export const TraversedTagObjectRef = Type.Ref(REF_DEFINITIONS.TraversedTagObject)
+export const TraversedDocumentObjectRef = Type.Ref(REF_DEFINITIONS.TraversedDocumentObject);

package/dist/schemas/v3.2/strict/reference.d.ts

@@ -0,0 +1,63 @@
+import { type TSchema } from '@scalar/typebox';
+export declare const ReferenceObjectExtensionsSchema: import("@scalar/typebox").TObject<{
+    /** Indicates the current status of the reference resolution. Can be either 'loading' while fetching the reference or 'error' if the resolution failed. */
+    $status: import("@scalar/typebox").TOptional<import("@scalar/typebox").TUnion<[import("@scalar/typebox").TLiteral<"loading">, import("@scalar/typebox").TLiteral<"error">]>>;
+    /** Indicates whether this reference should be resolved globally across all documents, rather than just within the current document context. */
+    $global: import("@scalar/typebox").TOptional<import("@scalar/typebox").TBoolean>;
+}>;
+/**
+ * A simple object to allow referencing other components in the OpenAPI Description, internally and externally.
+ *
+ * The $ref string value contains a URI RFC3986, which identifies the value being referenced.
+ *
+ * See the rules for resolving Relative References. */
+export declare const ReferenceObjectSchema: import("@scalar/typebox").TIntersect<[import("@scalar/typebox").TObject<{
+    /** REQUIRED. The reference identifier. This MUST be in the form of a URI. */
+    $ref: import("@scalar/typebox").TString;
+    /** A short summary which by default SHOULD override that of the referenced component. If the referenced object-type does not allow a summary field, then this field has no effect. */
+    summary: import("@scalar/typebox").TOptional<import("@scalar/typebox").TString>;
+    /** A description which by default SHOULD override that of the referenced component. CommonMark syntax MAY be used for rich text representation. If the referenced object-type does not allow a description field, then this field has no effect. */
+    description: import("@scalar/typebox").TOptional<import("@scalar/typebox").TString>;
+}>, import("@scalar/typebox").TObject<{
+    /** Indicates the current status of the reference resolution. Can be either 'loading' while fetching the reference or 'error' if the resolution failed. */
+    $status: import("@scalar/typebox").TOptional<import("@scalar/typebox").TUnion<[import("@scalar/typebox").TLiteral<"loading">, import("@scalar/typebox").TLiteral<"error">]>>;
+    /** Indicates whether this reference should be resolved globally across all documents, rather than just within the current document context. */
+    $global: import("@scalar/typebox").TOptional<import("@scalar/typebox").TBoolean>;
+}>]>;
+/**
+ * A simple object to allow referencing other components in the OpenAPI Description, internally and externally.
+ *
+ * The $ref string value contains a URI RFC3986, which identifies the value being referenced.
+ *
+ * See the rules for resolving Relative References. */
+export type ReferenceObject = {
+    /** REQUIRED. The reference identifier. This MUST be in the form of a URI. */
+    '$ref': string;
+    /** A short summary which by default SHOULD override that of the referenced component. If the referenced object-type does not allow a summary field, then this field has no effect. */
+    summary?: string;
+    /** A description which by default SHOULD override that of the referenced component. CommonMark syntax MAY be used for rich text representation. If the referenced object-type does not allow a description field, then this field has no effect. */
+    description?: string;
+    /** Indicates the current status of the reference resolution. Can be either 'loading' while fetching the reference or 'error' if the resolution failed. */
+    '$status'?: 'loading' | 'error';
+    /** Indicates whether this reference should be resolved globally across all documents, rather than just within the current document context. */
+    '$global'?: boolean;
+};
+export declare const reference: <T extends TSchema>(schema: T) => import("@scalar/typebox").TIntersect<[import("@scalar/typebox").TIntersect<[import("@scalar/typebox").TObject<{
+    /** REQUIRED. The reference identifier. This MUST be in the form of a URI. */
+    $ref: import("@scalar/typebox").TString;
+    /** A short summary which by default SHOULD override that of the referenced component. If the referenced object-type does not allow a summary field, then this field has no effect. */
+    summary: import("@scalar/typebox").TOptional<import("@scalar/typebox").TString>;
+    /** A description which by default SHOULD override that of the referenced component. CommonMark syntax MAY be used for rich text representation. If the referenced object-type does not allow a description field, then this field has no effect. */
+    description: import("@scalar/typebox").TOptional<import("@scalar/typebox").TString>;
+}>, import("@scalar/typebox").TObject<{
+    /** Indicates the current status of the reference resolution. Can be either 'loading' while fetching the reference or 'error' if the resolution failed. */
+    $status: import("@scalar/typebox").TOptional<import("@scalar/typebox").TUnion<[import("@scalar/typebox").TLiteral<"loading">, import("@scalar/typebox").TLiteral<"error">]>>;
+    /** Indicates whether this reference should be resolved globally across all documents, rather than just within the current document context. */
+    $global: import("@scalar/typebox").TOptional<import("@scalar/typebox").TBoolean>;
+}>]>, import("@scalar/typebox").TObject<{
+    '$ref-value': T;
+}>]>;
+export type ReferenceType<Value> = Value | (ReferenceObject & {
+    '$ref-value': Value;
+});
+//# sourceMappingURL=reference.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reference.d.ts","sourceRoot":"","sources":["../../../../src/schemas/v3.2/strict/reference.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAQ,MAAM,iBAAiB,CAAA;AAIpD,eAAO,MAAM,+BAA+B;IAC1C,0JAA0J;;IAE1J,+IAA+I;;EAE/I,CAAA;AAEF;;;;;sDAKsD;AACtD,eAAO,MAAM,qBAAqB;IAE9B,6EAA6E;;IAE7E,sLAAsL;;IAEtL,oPAAoP;;;IAlBtP,0JAA0J;;IAE1J,+IAA+I;;IAoBhJ,CAAA;AAED;;;;;sDAKsD;AACtD,MAAM,MAAM,eAAe,GAAG;IAC5B,6EAA6E;IAC7E,MAAM,EAAE,MAAM,CAAA;IACd,sLAAsL;IACtL,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,oPAAoP;IACpP,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,0JAA0J;IAC1J,SAAS,CAAC,EAAE,SAAS,GAAG,OAAO,CAAA;IAC/B,+IAA+I;IAC/I,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB,CAAA;AAED,eAAO,MAAM,SAAS,GAAI,CAAC,SAAS,OAAO,EAAE,QAAQ,CAAC;IA7BlD,6EAA6E;;IAE7E,sLAAsL;;IAEtL,oPAAoP;;;IAlBtP,0JAA0J;;IAE1J,+IAA+I;;;;IA0C1E,CAAA;AAEvE,MAAM,MAAM,aAAa,CAAC,KAAK,IAAI,KAAK,GAAG,CAAC,eAAe,GAAG;IAAE,YAAY,EAAE,KAAK,CAAA;CAAE,CAAC,CAAA"}

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

@@ -0,0 +1,23 @@
+import { Type } from '@scalar/typebox';
+import { compose } from '../../../schemas/compose.js';
+export const ReferenceObjectExtensionsSchema = Type.Object({
+    /** Indicates the current status of the reference resolution. Can be either 'loading' while fetching the reference or 'error' if the resolution failed. */
+    '$status': Type.Optional(Type.Union([Type.Literal('loading'), Type.Literal('error')])),
+    /** Indicates whether this reference should be resolved globally across all documents, rather than just within the current document context. */
+    '$global': Type.Optional(Type.Boolean()),
+});
+/**
+ * A simple object to allow referencing other components in the OpenAPI Description, internally and externally.
+ *
+ * The $ref string value contains a URI RFC3986, which identifies the value being referenced.
+ *
+ * See the rules for resolving Relative References. */
+export const ReferenceObjectSchema = compose(Type.Object({
+    /** REQUIRED. The reference identifier. This MUST be in the form of a URI. */
+    '$ref': Type.String(),
+    /** A short summary which by default SHOULD override that of the referenced component. If the referenced object-type does not allow a summary field, then this field has no effect. */
+    summary: Type.Optional(Type.String()),
+    /** A description which by default SHOULD override that of the referenced component. CommonMark syntax MAY be used for rich text representation. If the referenced object-type does not allow a description field, then this field has no effect. */
+    description: Type.Optional(Type.String()),
+}), ReferenceObjectExtensionsSchema);
+export const reference = (schema) => compose(ReferenceObjectSchema, Type.Object({ '$ref-value': schema }));

package/dist/schemas/v3.2/strict/request-body.d.ts

@@ -0,0 +1,23 @@
+import { type XScalarSelectedContentType } from '../../../schemas/extensions/operation/x-scalar-selected-content-type.js';
+import type { MediaTypeObject } from './media-type.js';
+/** Describes a single request body. */
+export declare const RequestBodyObjectSchemaDefinition: import("@scalar/typebox").TIntersect<[import("@scalar/typebox").TObject<{
+    /** A brief description of the request body. This could contain examples of use. CommonMark syntax MAY be used for rich text representation. */
+    description: import("@scalar/typebox").TOptional<import("@scalar/typebox").TString>;
+    /** REQUIRED. The content of the request body. The key is a media type or media type range and the value describes it. For requests that match multiple keys, only the most specific key is applicable. e.g. "text/plain" overrides "text/* */
+    content: import("@scalar/typebox").TRecord<import("@scalar/typebox").TString, import("@scalar/typebox").TRef<"MediaTypeObject">>;
+    /** Determines if the request body is required in the request. Defaults to false. */
+    required: import("@scalar/typebox").TOptional<import("@scalar/typebox").TBoolean>;
+}>, import("@scalar/typebox").TObject<{
+    'x-scalar-selected-content-type': import("@scalar/typebox").TOptional<import("@scalar/typebox").TRecord<import("@scalar/typebox").TString, import("@scalar/typebox").TString>>;
+}>]>;
+/** Describes a single request body. */
+export type RequestBodyObject = {
+    /** A brief description of the request body. This could contain examples of use. CommonMark syntax MAY be used for rich text representation. */
+    description?: string;
+    /** REQUIRED. The content of the request body. The key is a media type or media type range and the value describes it. For requests that match multiple keys, only the most specific key is applicable. e.g. "text/plain" overrides "text/* */
+    content: Record<string, MediaTypeObject>;
+    /** Determines if the request body is required in the request. Defaults to false. */
+    required?: boolean;
+} & XScalarSelectedContentType;
+//# sourceMappingURL=request-body.d.ts.map

package/dist/schemas/v3.2/strict/request-body.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-body.d.ts","sourceRoot":"","sources":["../../../../src/schemas/v3.2/strict/request-body.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,KAAK,0BAA0B,EAEhC,MAAM,+DAA+D,CAAA;AAEtE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAGnD,uCAAuC;AACvC,eAAO,MAAM,iCAAiC;IAE1C,+IAA+I;;IAE/I,8OAA8O;;IAE9O,oFAAoF;;;;IAIvF,CAAA;AAED,uCAAuC;AACvC,MAAM,MAAM,iBAAiB,GAAG;IAC9B,+IAA+I;IAC/I,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,8OAA8O;IAC9O,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAA;IACxC,oFAAoF;IACpF,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,GAAG,0BAA0B,CAAA"}

package/dist/schemas/v3.2/strict/request-body.js

@@ -0,0 +1,13 @@
+import { Type } from '@scalar/typebox';
+import { compose } from '../../../schemas/compose.js';
+import { XScalarSelectedContentTypeSchema, } from '../../../schemas/extensions/operation/x-scalar-selected-content-type.js';
+import { MediaTypeObjectRef } from './ref-definitions.js';
+/** Describes a single request body. */
+export const RequestBodyObjectSchemaDefinition = compose(Type.Object({
+    /** A brief description of the request body. This could contain examples of use. CommonMark syntax MAY be used for rich text representation. */
+    description: Type.Optional(Type.String()),
+    /** REQUIRED. The content of the request body. The key is a media type or media type range and the value describes it. For requests that match multiple keys, only the most specific key is applicable. e.g. "text/plain" overrides "text/* */
+    content: Type.Record(Type.String(), MediaTypeObjectRef),
+    /** Determines if the request body is required in the request. Defaults to false. */
+    required: Type.Optional(Type.Boolean()),
+}), XScalarSelectedContentTypeSchema);

package/dist/schemas/v3.2/strict/response.d.ts

@@ -0,0 +1,50 @@
+import type { HeaderObject } from '../../../schemas/v3.2/strict/header.js';
+import type { MediaTypeObject } from '../../../schemas/v3.2/strict/media-type.js';
+import type { LinkObject } from './link.js';
+import { type ReferenceType } from './reference.js';
+export declare const ResponseObjectSchemaDefinition: import("@scalar/typebox").TObject<{
+    /** A short summary of the meaning of the response. Added in OpenAPI 3.2. */
+    summary: import("@scalar/typebox").TOptional<import("@scalar/typebox").TString>;
+    /** A description of the response. CommonMark syntax MAY be used for rich text representation. Optional as of OpenAPI 3.2. */
+    description: import("@scalar/typebox").TOptional<import("@scalar/typebox").TString>;
+    /** Maps a header name to its definition. RFC7230 states header names are case insensitive. If a response header is defined with the name "Content-Type", it SHALL be ignored. */
+    headers: import("@scalar/typebox").TOptional<import("@scalar/typebox").TRecord<import("@scalar/typebox").TString, import("@scalar/typebox").TUnion<[import("@scalar/typebox").TRef<"HeaderObject">, import("@scalar/typebox").TIntersect<[import("@scalar/typebox").TIntersect<[import("@scalar/typebox").TObject<{
+        $ref: import("@scalar/typebox").TString;
+        summary: import("@scalar/typebox").TOptional<import("@scalar/typebox").TString>;
+        description: import("@scalar/typebox").TOptional<import("@scalar/typebox").TString>;
+    }>, import("@scalar/typebox").TObject<{
+        $status: import("@scalar/typebox").TOptional<import("@scalar/typebox").TUnion<[import("@scalar/typebox").TLiteral<"loading">, import("@scalar/typebox").TLiteral<"error">]>>;
+        $global: import("@scalar/typebox").TOptional<import("@scalar/typebox").TBoolean>;
+    }>]>, import("@scalar/typebox").TObject<{
+        '$ref-value': import("@scalar/typebox").TRef<"HeaderObject">;
+    }>]>]>>>;
+    /** A map containing descriptions of potential response payloads. The key is a media type or media type range and the value describes it. For responses that match multiple keys, only the most specific key is applicable. e.g. "text/plain" overrides "text/*"  */
+    content: import("@scalar/typebox").TOptional<import("@scalar/typebox").TRecord<import("@scalar/typebox").TString, import("@scalar/typebox").TRef<"MediaTypeObject">>>;
+    /** A map of operations links that can be followed from the response. The key of the map is a short name for the link, following the naming constraints of the names for Component Objects. */
+    links: import("@scalar/typebox").TOptional<import("@scalar/typebox").TRecord<import("@scalar/typebox").TString, import("@scalar/typebox").TUnion<[import("@scalar/typebox").TRef<"LinkObject">, import("@scalar/typebox").TIntersect<[import("@scalar/typebox").TIntersect<[import("@scalar/typebox").TObject<{
+        $ref: import("@scalar/typebox").TString;
+        summary: import("@scalar/typebox").TOptional<import("@scalar/typebox").TString>;
+        description: import("@scalar/typebox").TOptional<import("@scalar/typebox").TString>;
+    }>, import("@scalar/typebox").TObject<{
+        $status: import("@scalar/typebox").TOptional<import("@scalar/typebox").TUnion<[import("@scalar/typebox").TLiteral<"loading">, import("@scalar/typebox").TLiteral<"error">]>>;
+        $global: import("@scalar/typebox").TOptional<import("@scalar/typebox").TBoolean>;
+    }>]>, import("@scalar/typebox").TObject<{
+        '$ref-value': import("@scalar/typebox").TRef<"LinkObject">;
+    }>]>]>>>;
+}>;
+/**
+ * Describes a single response from an API operation, including design-time, static links to operations based on the response.
+ */
+export type ResponseObject = {
+    /** A short summary of the meaning of the response. Added in OpenAPI 3.2. */
+    summary?: string;
+    /** A description of the response. CommonMark syntax MAY be used for rich text representation. Optional as of OpenAPI 3.2. */
+    description?: string;
+    /** Maps a header name to its definition. RFC7230 states header names are case insensitive. If a response header is defined with the name "Content-Type", it SHALL be ignored. */
+    headers?: Record<string, ReferenceType<HeaderObject>>;
+    /** A map containing descriptions of potential response payloads. The key is a media type or media type range and the value describes it. For responses that match multiple keys, only the most specific key is applicable. e.g. "text/plain" overrides "text/*"  */
+    content?: Record<string, MediaTypeObject>;
+    /** A map of operations links that can be followed from the response. The key of the map is a short name for the link, following the naming constraints of the names for Component Objects. */
+    links?: Record<string, ReferenceType<LinkObject>>;
+};
+//# sourceMappingURL=response.d.ts.map

package/dist/schemas/v3.2/strict/response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response.d.ts","sourceRoot":"","sources":["../../../../src/schemas/v3.2/strict/response.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAA;AAChE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAA;AAEvE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAA;AAExC,OAAO,EAAE,KAAK,aAAa,EAAa,MAAM,aAAa,CAAA;AAE3D,eAAO,MAAM,8BAA8B;IACzC,4EAA4E;;IAE5E,6HAA6H;;IAE7H,iLAAiL;;;;;;;;;;;IAEjL,oQAAoQ;;IAEpQ,8LAA8L;;;;;;;;;;;EAE9L,CAAA;AAEF;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,4EAA4E;IAC5E,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,6HAA6H;IAC7H,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,iLAAiL;IACjL,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,YAAY,CAAC,CAAC,CAAA;IACrD,oQAAoQ;IACpQ,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAA;IACzC,8LAA8L;IAC9L,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,UAAU,CAAC,CAAC,CAAA;CAClD,CAAA"}

package/dist/schemas/v3.2/strict/response.js

@@ -0,0 +1,15 @@
+import { Type } from '@scalar/typebox';
+import { HeaderObjectRef, LinkObjectRef, MediaTypeObjectRef } from './ref-definitions.js';
+import { reference } from './reference.js';
+export const ResponseObjectSchemaDefinition = Type.Object({
+    /** A short summary of the meaning of the response. Added in OpenAPI 3.2. */
+    summary: Type.Optional(Type.String()),
+    /** A description of the response. CommonMark syntax MAY be used for rich text representation. Optional as of OpenAPI 3.2. */
+    description: Type.Optional(Type.String()),
+    /** Maps a header name to its definition. RFC7230 states header names are case insensitive. If a response header is defined with the name "Content-Type", it SHALL be ignored. */
+    headers: Type.Optional(Type.Record(Type.String(), Type.Union([HeaderObjectRef, reference(HeaderObjectRef)]))),
+    /** A map containing descriptions of potential response payloads. The key is a media type or media type range and the value describes it. For responses that match multiple keys, only the most specific key is applicable. e.g. "text/plain" overrides "text/*"  */
+    content: Type.Optional(Type.Record(Type.String(), MediaTypeObjectRef)),
+    /** A map of operations links that can be followed from the response. The key of the map is a short name for the link, following the naming constraints of the names for Component Objects. */
+    links: Type.Optional(Type.Record(Type.String(), Type.Union([LinkObjectRef, reference(LinkObjectRef)]))),
+});

package/dist/schemas/v3.2/strict/responses.d.ts

@@ -0,0 +1,32 @@
+import { type ReferenceType } from './reference.js';
+import type { ResponseObject } from './response.js';
+/**
+ * A container for the expected responses of an operation. The container maps a HTTP response code to the expected response.
+ *
+ * The documentation is not necessarily expected to cover all possible HTTP response codes because they may not be known in advance. However, documentation is expected to cover a successful operation response and any known errors.
+ *
+ * The default MAY be used as a default Response Object for all HTTP codes that are not covered individually by the Responses Object.
+ *
+ * The Responses Object MUST contain at least one response code, and if only one response code is provided it SHOULD be the response for a successful operation call.
+ */
+export declare const ResponsesObjectSchemaDefinition: import("@scalar/typebox").TRecord<import("@scalar/typebox").TString, import("@scalar/typebox").TUnion<[import("@scalar/typebox").TRef<"ResponseObject">, import("@scalar/typebox").TIntersect<[import("@scalar/typebox").TIntersect<[import("@scalar/typebox").TObject<{
+    $ref: import("@scalar/typebox").TString;
+    summary: import("@scalar/typebox").TOptional<import("@scalar/typebox").TString>;
+    description: import("@scalar/typebox").TOptional<import("@scalar/typebox").TString>;
+}>, import("@scalar/typebox").TObject<{
+    $status: import("@scalar/typebox").TOptional<import("@scalar/typebox").TUnion<[import("@scalar/typebox").TLiteral<"loading">, import("@scalar/typebox").TLiteral<"error">]>>;
+    $global: import("@scalar/typebox").TOptional<import("@scalar/typebox").TBoolean>;
+}>]>, import("@scalar/typebox").TObject<{
+    '$ref-value': import("@scalar/typebox").TRef<"ResponseObject">;
+}>]>]>>;
+/**
+ * A container for the expected responses of an operation. The container maps a HTTP response code to the expected response.
+ *
+ * The documentation is not necessarily expected to cover all possible HTTP response codes because they may not be known in advance. However, documentation is expected to cover a successful operation response and any known errors.
+ *
+ * The default MAY be used as a default Response Object for all HTTP codes that are not covered individually by the Responses Object.
+ *
+ * The Responses Object MUST contain at least one response code, and if only one response code is provided it SHOULD be the response for a successful operation call.
+ */
+export type ResponsesObject = Record<string, ReferenceType<ResponseObject>>;
+//# sourceMappingURL=responses.d.ts.map

package/dist/schemas/v3.2/strict/responses.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"responses.d.ts","sourceRoot":"","sources":["../../../../src/schemas/v3.2/strict/responses.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,aAAa,EAAa,MAAM,aAAa,CAAA;AAC3D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAEhD;;;;;;;;GAQG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;OAG3C,CAAA;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,cAAc,CAAC,CAAC,CAAA"}

package/dist/schemas/v3.2/strict/responses.js

@@ -0,0 +1,13 @@
+import { Type } from '@scalar/typebox';
+import { ResponseObjectRef } from './ref-definitions.js';
+import { reference } from './reference.js';
+/**
+ * A container for the expected responses of an operation. The container maps a HTTP response code to the expected response.
+ *
+ * The documentation is not necessarily expected to cover all possible HTTP response codes because they may not be known in advance. However, documentation is expected to cover a successful operation response and any known errors.
+ *
+ * The default MAY be used as a default Response Object for all HTTP codes that are not covered individually by the Responses Object.
+ *
+ * The Responses Object MUST contain at least one response code, and if only one response code is provided it SHOULD be the response for a successful operation call.
+ */
+export const ResponsesObjectSchemaDefinition = Type.Record(Type.String(), Type.Union([ResponseObjectRef, reference(ResponseObjectRef)]));