@scalar/schemas 0.3.2 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,50 @@
 # @scalar/schemas
 
+## 0.4.0
+
+### Minor Changes
+
+- [#9398](https://github.com/scalar/scalar/pull/9398): feat: read code samples from x-readme, x-stainless and x-scalar extensions
+
+  In addition to `x-codeSamples`, the code sample picker now reads custom samples from `x-scalar-examples`, `x-stainless-snippets`, `x-stainless-examples`, and `x-readme.code-samples`. When more than one is present on an operation, the highest-priority source is used (x-scalar-examples > x-stainless-snippets > x-stainless-examples > x-readme > x-codeSamples).
+
+- [#9422](https://github.com/scalar/scalar/pull/9422): Add a `nonce` option for Content Security Policy support.
+
+  When you pass a `nonce`, the rendered HTML stamps it onto the inline `<script>` and the CDN `<script>` tag (and Scalar's own `<style>` tags, plus a matching `<meta property="csp-nonce">`). This lets the API Reference run under a strict `script-src` with no `unsafe-inline` and no `unsafe-eval`.
+
+  ```ts
+  ApiReference({
+    url: '/openapi.json',
+    // Match this value in your `script-src` CSP directive.
+    nonce: 'r4nd0m',
+  })
+  ```
+
+  Note: `style-src` still needs `'unsafe-inline'`. The reference renders inline `style="…"` attributes, which a CSP nonce can never authorize (nonces only apply to `<script>`, `<style>` and `<link>` elements), so a nonce-only `style-src` is not possible. The win is a fully strict `script-src`.
+
+- [#9400](https://github.com/scalar/scalar/pull/9400): feat(api-reference): add `expandAllSchemaProperties` config option.
+
+  When enabled, nested schema properties are expanded by default while keeping the
+  "Show/Hide Child Attributes" button available for manual collapsing. Expansion
+  is cycle-safe: every finite branch is expanded fully, and self-referential
+  ($ref or inline) schemas stop at the point they would otherwise recurse forever.
+
+- [#9399](https://github.com/scalar/scalar/pull/9399): Show custom SDK installation instructions from `x-scalar-sdk-installation` in the introduction card, falling back to the client selector when there are none. Each entry takes a `lang` and a Markdown `description`, so a single tab can render rich instructions with syntax-highlighted code blocks (for example Maven and Gradle for Java)
+
+## 0.3.3
+
+### Patch Changes
+
+- [#9309](https://github.com/scalar/scalar/pull/9309): feat: add `modelsSectionLabel` configuration (`'Models' | 'Schemas' | string`) to use OpenAPI-style Schemas terminology in the sidebar, content, and search.
+- [#9383](https://github.com/scalar/scalar/pull/9383): fix: preserve multi-type schema arrays when coercing schemas with validation keywords
+- [#7618](https://github.com/scalar/scalar/pull/7618): feat(api-reference): add `setPageTitle` to customize the browser tab title
+
+  Pass a `setPageTitle` function to control the browser tab title. It is called whenever the section in view changes — on sidebar clicks, on scroll, and when switching documents — and receives the section title and the active OpenAPI document:
+
+  ```js
+  setPageTitle: ({ title, document }) => `${document.title} – ${title}`
+  ```
+
 ## 0.3.2
 
 ### Patch Changes

package/dist/api-reference/api-reference-configuration.d.ts

@@ -71,6 +71,7 @@ export declare const apiReferenceConfigurationSchema: import("@scalar/validation
     isEditable: import("@scalar/validation").BooleanSchema;
     isLoading: import("@scalar/validation").BooleanSchema;
     hideModels: import("@scalar/validation").BooleanSchema;
+    modelsSectionLabel: import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnionSchema<readonly [import("@scalar/validation").LiteralSchema<"Models">, import("@scalar/validation").LiteralSchema<"Schemas">, import("@scalar/validation").StringSchema]>>;
     documentDownloadType: import("@scalar/validation").UnionSchema<readonly [import("@scalar/validation").LiteralSchema<"both">, import("@scalar/validation").LiteralSchema<"yaml">, import("@scalar/validation").LiteralSchema<"json">, import("@scalar/validation").LiteralSchema<"direct">, import("@scalar/validation").LiteralSchema<"none">]>;
     hideDownloadButton: import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
     hideTestRequestButton: import("@scalar/validation").BooleanSchema;
@@ -125,12 +126,20 @@ export declare const apiReferenceConfigurationSchema: import("@scalar/validation
         name: string;
         method?: string;
     }) => string>>;
+    setPageTitle: import("@scalar/validation").OptionalSchema<import("@scalar/validation").FunctionSchema<(input: {
+        title: string;
+        document: {
+            title: string;
+            slug: string;
+        };
+    }) => string>>;
     redirect: import("@scalar/validation").OptionalSchema<import("@scalar/validation").FunctionSchema<(input: string) => string | null | undefined>>;
     withDefaultFonts: import("@scalar/validation").BooleanSchema;
     defaultOpenFirstTag: import("@scalar/validation").BooleanSchema;
     defaultOpenAllTags: import("@scalar/validation").BooleanSchema;
     expandAllModelSections: import("@scalar/validation").BooleanSchema;
     expandAllResponses: import("@scalar/validation").BooleanSchema;
+    expandAllSchemaProperties: import("@scalar/validation").BooleanSchema;
     tagsSorter: import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnionSchema<readonly [import("@scalar/validation").LiteralSchema<"alpha">, import("@scalar/validation").FunctionSchema<(a: any, b: any) => number>]>>;
     operationsSorter: import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnionSchema<readonly [import("@scalar/validation").LiteralSchema<"alpha">, import("@scalar/validation").LiteralSchema<"method">, import("@scalar/validation").FunctionSchema<(a: any, b: any) => number>]>>;
     orderSchemaPropertiesBy: import("@scalar/validation").UnionSchema<readonly [import("@scalar/validation").LiteralSchema<"alpha">, import("@scalar/validation").LiteralSchema<"preserve">]>;
@@ -193,6 +202,7 @@ export declare const apiReferenceConfigurationWithSourceSchema: (rawInput: unkno
     defaultOpenAllTags: boolean;
     expandAllModelSections: boolean;
     expandAllResponses: boolean;
+    expandAllSchemaProperties: boolean;
     orderSchemaPropertiesBy: "alpha" | "preserve";
     orderRequiredPropertiesFirst: boolean;
 } & {
@@ -224,6 +234,7 @@ export declare const apiReferenceConfigurationWithSourceSchema: (rawInput: unkno
         }>>;
         apiClientPlugins: any[];
     })[] | undefined;
+    modelsSectionLabel?: string | undefined;
     hideDownloadButton?: boolean | undefined;
     darkMode?: boolean | undefined;
     forceDarkModeState?: "dark" | "light" | undefined;
@@ -273,6 +284,13 @@ export declare const apiReferenceConfigurationWithSourceSchema: (rawInput: unkno
         name: string;
         method?: string;
     }) => string) | undefined;
+    setPageTitle?: ((input: {
+        title: string;
+        document: {
+            title: string;
+            slug: string;
+        };
+    }) => string) | undefined;
     redirect?: ((input: string) => string | null | undefined) | undefined;
     tagsSorter?: "alpha" | ((a: any, b: any) => number) | undefined;
     operationsSorter?: "alpha" | "method" | ((a: any, b: any) => number) | undefined;

package/dist/api-reference/api-reference-configuration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"api-reference-configuration.d.ts","sourceRoot":"","sources":["../../src/api-reference/api-reference-configuration.ts"],"names":[],"mappings":"AAoBA,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kHAyFN,MAAM,KAAK,IAAI;oHAGb,MAAM,KAAK,IAAI;oHAGf,IAAI;6GAGX,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;qHAKhD;QACN,OAAO,EAAE,OAAO,CAAA;QAChB,cAAc,EAAE,OAAO,CAAA;QACvB,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KACrC,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;gHAOE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;mHAG5B,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;;;;;;;;;yHA4BzB;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,MAAM;uHAG9B;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,MAAM;qHAG9B;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,MAAM;2HAIpD;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,MAAM;yHAKvD;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,MAAM;8GAGvD,MAAM,KAAK,MAAM,GAAG,IAAI,GAAG,SAAS;;;;;;oNA0Bb,GAAG,KAAK,GAAG,KAAK,MAAM;gRAGG,GAAG,KAAK,GAAG,KAAK,MAAM;;;IAWtG,CAAA;AAKF,eAAO,MAAM,yCAAyC,GAAI,UAAU,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAvHrC,MAAM,KAAK,IAAI;8BAGb,MAAM,KAAK,IAAI;8BAGf,IAAI;uBAGX,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;+BAKhD;QACN,OAAO,EAAE,OAAO,CAAA;QAChB,cAAc,EAAE,OAAO,CAAA;QACvB,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KACrC,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;0BAOE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;6BAG5B,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;;;;;;;;;mCA4BzB;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,MAAM;iCAG9B;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,MAAM;+BAG9B;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,MAAM;qCAIpD;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,MAAM;mCAKvD;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,MAAM;wBAGvD,MAAM,KAAK,MAAM,GAAG,IAAI,GAAG,SAAS;gCA0Bb,GAAG,KAAK,GAAG,KAAK,MAAM;iDAGG,GAAG,KAAK,GAAG,KAAK,MAAM;CAqFvG,CAAA"}
+{"version":3,"file":"api-reference-configuration.d.ts","sourceRoot":"","sources":["../../src/api-reference/api-reference-configuration.ts"],"names":[],"mappings":"AAqBA,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kHA6FN,MAAM,KAAK,IAAI;oHAGb,MAAM,KAAK,IAAI;oHAGf,IAAI;6GAGX,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;qHAKhD;QACN,OAAO,EAAE,OAAO,CAAA;QAChB,cAAc,EAAE,OAAO,CAAA;QACvB,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KACrC,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;gHAOE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;mHAG5B,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;;;;;;;;;yHA4BzB;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,MAAM;uHAG9B;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,MAAM;qHAG9B;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,MAAM;2HAIpD;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,MAAM;yHAKvD;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,MAAM;kHAGnD;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,KAAK,MAAM;8GAG3E,MAAM,KAAK,MAAM,GAAG,IAAI,GAAG,SAAS;;;;;;;oNA+Bb,GAAG,KAAK,GAAG,KAAK,MAAM;gRAGG,GAAG,KAAK,GAAG,KAAK,MAAM;;;IAWtG,CAAA;AAKF,eAAO,MAAM,yCAAyC,GAAI,UAAU,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BA/HrC,MAAM,KAAK,IAAI;8BAGb,MAAM,KAAK,IAAI;8BAGf,IAAI;uBAGX,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;+BAKhD;QACN,OAAO,EAAE,OAAO,CAAA;QAChB,cAAc,EAAE,OAAO,CAAA;QACvB,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KACrC,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;0BAOE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;6BAG5B,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;;;;;;;;;mCA4BzB;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,MAAM;iCAG9B;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,MAAM;+BAG9B;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,MAAM;qCAIpD;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,MAAM;mCAKvD;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,MAAM;4BAGnD;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,KAAK,MAAM;wBAG3E,MAAM,KAAK,MAAM,GAAG,IAAI,GAAG,SAAS;gCA+Bb,GAAG,KAAK,GAAG,KAAK,MAAM;iDAGG,GAAG,KAAK,GAAG,KAAK,MAAM;CAuFvG,CAAA"}

package/dist/api-reference/api-reference-configuration.js

@@ -1,3 +1,4 @@
+import { DEFAULT_MODELS_SECTION_LABEL } from '@scalar/types/api-reference';
 import { any, array, boolean, coerce, fn, intersection, literal, object, optional, record, string, union, } from '@scalar/validation';
 import { apiReferencePluginSchema } from '../api-reference/api-reference-plugin.js';
 import { baseConfigurationSchema } from './base-configuration.js';
@@ -33,6 +34,9 @@ export const apiReferenceConfigurationSchema = intersection([
             default: false,
             typeComment: 'Whether to show models in the sidebar, search, and content.',
         }),
+        modelsSectionLabel: optional(union([literal('Models'), literal('Schemas'), string()]), {
+            typeComment: 'Label for the components.schemas section in the sidebar, content, and search. Use `Schemas` for OpenAPI terminology.',
+        }),
         documentDownloadType: union([literal('both'), literal('yaml'), literal('json'), literal('direct'), literal('none')], {
             typeComment: 'Sets the file type of the document to download, set to `none` to hide the download button',
         }),
@@ -133,6 +137,9 @@ export const apiReferenceConfigurationSchema = intersection([
         generateWebhookSlug: optional(fn(), {
             typeComment: 'Customize the webhook portion of the hash',
         }),
+        setPageTitle: optional(fn(), {
+            typeComment: 'Customize the browser tab title for the section currently in view',
+        }),
         redirect: optional(fn(), {
             typeComment: 'To handle redirects, pass a function that receives the current path/hash and passes that to history.replaceState',
         }),
@@ -156,6 +163,10 @@ export const apiReferenceConfigurationSchema = intersection([
             default: false,
             typeComment: 'Whether to expand all responses by default. Warning: this can cause performance issues on big documents',
         }),
+        expandAllSchemaProperties: boolean({
+            default: false,
+            typeComment: 'Whether to expand all nested schema properties by default. The Show/Hide Child Attributes toggle remains available so nested sections can still be collapsed manually. Warning: this can cause performance issues on big documents',
+        }),
         tagsSorter: optional(union([literal('alpha'), fn()]), {
             typeComment: 'Function to sort tags',
         }),
@@ -215,5 +226,6 @@ export const apiReferenceConfigurationWithSourceSchema = (rawInput) => {
         // @ts-expect-error - We're deleting the deprecated attribute
         delete input.showToolbar;
     }
+    input.modelsSectionLabel ??= DEFAULT_MODELS_SECTION_LABEL;
     return input;
 };

package/dist/api-reference/html-rendering-configuration.d.ts

@@ -10,5 +10,12 @@ export declare const htmlRenderingConfigurationSchema: import("@scalar/validatio
      */
     cdn: import("@scalar/validation").StringSchema;
     pageTitle: import("@scalar/validation").StringSchema;
+    /**
+     * A Content Security Policy (CSP) nonce to apply to the generated inline `<script>` and `<style>`
+     * tags so the API Reference can render under a strict CSP without `unsafe-inline`.
+     *
+     * Generate a fresh value per request and match it in your `script-src` and `style-src` directives.
+     */
+    nonce: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
 }>;
 //# sourceMappingURL=html-rendering-configuration.d.ts.map

package/dist/api-reference/html-rendering-configuration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"html-rendering-configuration.d.ts","sourceRoot":"","sources":["../../src/api-reference/html-rendering-configuration.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,gCAAgC;IAC3C;;;;;;;;OAQG;;;EAOH,CAAA"}
+{"version":3,"file":"html-rendering-configuration.d.ts","sourceRoot":"","sources":["../../src/api-reference/html-rendering-configuration.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,gCAAgC;IAC3C;;;;;;;;OAQG;;;IAOH;;;;;OAKG;;EAEH,CAAA"}

package/dist/api-reference/html-rendering-configuration.js

@@ -1,4 +1,4 @@
-import { object, string } from '@scalar/validation';
+import { object, optional, string } from '@scalar/validation';
 export const htmlRenderingConfigurationSchema = object({
     /**
      * The URL to the Scalar API Reference JS CDN.
@@ -15,4 +15,11 @@ export const htmlRenderingConfigurationSchema = object({
     pageTitle: string({
         default: 'Scalar API Reference',
     }),
+    /**
+     * A Content Security Policy (CSP) nonce to apply to the generated inline `<script>` and `<style>`
+     * tags so the API Reference can render under a strict CSP without `unsafe-inline`.
+     *
+     * Generate a fresh value per request and match it in your `script-src` and `style-src` directives.
+     */
+    nonce: optional(string()),
 });

package/dist/asyncapi/3.1/asyncapi-object.d.ts

@@ -22,7 +22,7 @@ export declare const asyncApiObjectSchema: import("@scalar/validation").Intersec
     }>;
     servers: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").Schema>>;
     defaultContentType: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
-    channels: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").LazySchema<() => import("@scalar/validation").Schema>>>;
+    channels: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").Schema>>;
     operations: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").LazySchema<() => import("@scalar/validation").Schema>>>;
     components: import("@scalar/validation").OptionalSchema<import("@scalar/validation").Schema>;
 }>, import("@scalar/validation").IntersectionSchema<readonly [import("@scalar/validation").ObjectSchema<{

package/dist/asyncapi/3.1/channel.d.ts

@@ -1,4 +1,15 @@
-/** Channel Object | Reference Object */
-export declare const asyncApiChannelObject: import("@scalar/validation").LazySchema<() => import("@scalar/validation").Schema>;
-export declare const asyncApiChannelsObject: import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").LazySchema<() => import("@scalar/validation").Schema>>;
+/** Channel Object */
+export declare const asyncApiChannelObject: import("@scalar/validation").LazySchema<() => import("@scalar/validation").ObjectSchema<{
+    address: import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnionSchema<readonly [import("@scalar/validation").StringSchema, import("@scalar/validation").NullableSchema]>>;
+    messages: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").LazySchema<() => import("@scalar/validation").Schema>>>;
+    title: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    summary: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    servers: import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").Schema>>;
+    parameters: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").Schema>>;
+    tags: import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").Schema>>;
+    externalDocs: import("@scalar/validation").OptionalSchema<import("@scalar/validation").Schema>;
+    bindings: import("@scalar/validation").OptionalSchema<import("@scalar/validation").Schema>;
+}>>;
+export declare const asyncApiChannelsObject: import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").Schema>;
 //# sourceMappingURL=channel.d.ts.map

package/dist/asyncapi/3.1/channel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"channel.d.ts","sourceRoot":"","sources":["../../../src/asyncapi/3.1/channel.ts"],"names":[],"mappings":"AAUA,wCAAwC;AACxC,eAAO,MAAM,qBAAqB,oFA4BjC,CAAA;AAED,eAAO,MAAM,sBAAsB,0KAGjC,CAAA"}
+{"version":3,"file":"channel.d.ts","sourceRoot":"","sources":["../../../src/asyncapi/3.1/channel.ts"],"names":[],"mappings":"AAUA,qBAAqB;AACrB,eAAO,MAAM,qBAAqB;;;;;;;;;;;GA0BjC,CAAA;AAED,eAAO,MAAM,sBAAsB,2HAGjC,CAAA"}

package/dist/asyncapi/3.1/channel.js

@@ -6,8 +6,8 @@ import { asyncApiParametersObject } from './parameters.js';
 import { asyncApiResolvedReference, recursiveRef } from './reference.js';
 import { asyncApiServerObject } from './server.js';
 import { asyncApiTagsObject } from './tag.js';
-/** Channel Object | Reference Object */
-export const asyncApiChannelObject = lazy(() => recursiveRef(object({
+/** Channel Object */
+export const asyncApiChannelObject = lazy(() => object({
     address: optional(union([string(), nullable()], { typeComment: 'Channel address or null when unknown.' })),
     messages: optional(asyncApiMessagesObject),
     title: optional(string({ typeComment: 'A human-friendly title for the channel.' })),
@@ -22,8 +22,8 @@ export const asyncApiChannelObject = lazy(() => recursiveRef(object({
     tags: optional(asyncApiTagsObject),
     externalDocs: optional(asyncApiExternalDocumentationObject),
     bindings: optional(recursiveRef(asyncApiChannelBindingsObject)),
-}, { typeName: 'AsyncApiChannelObject' })));
-export const asyncApiChannelsObject = record(string(), asyncApiChannelObject, {
+}, { typeName: 'AsyncApiChannelObject' }));
+export const asyncApiChannelsObject = record(string(), recursiveRef(asyncApiChannelObject), {
     typeName: 'AsyncApiChannelsObject',
     typeComment: 'Map of channelId to Channel Object or Reference Object.',
 });

package/dist/asyncapi/3.1/components.d.ts

@@ -1,7 +1,7 @@
 export declare const asyncApiComponentsObject: import("@scalar/validation").LazySchema<() => import("@scalar/validation").ObjectSchema<{
     schemas: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").Schema>>;
     servers: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").Schema>>;
-    channels: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").LazySchema<() => import("@scalar/validation").Schema>>>;
+    channels: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").Schema>>;
     operations: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").LazySchema<() => import("@scalar/validation").Schema>>>;
     messages: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").LazySchema<() => import("@scalar/validation").Schema>>>;
     securitySchemes: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").Schema>>;

package/dist/asyncapi/3.1/components.js

@@ -1,6 +1,6 @@
 import { lazy, object, optional, record, string } from '@scalar/validation';
 import { asyncApiChannelBindingsObject, asyncApiMessageBindingsObject, asyncApiOperationBindingsObject, asyncApiServerBindingsObject, } from './bindings.js';
-import { asyncApiChannelObject } from './channel.js';
+import { asyncApiChannelsObject } from './channel.js';
 import { asyncApiCorrelationIdObject } from './correlation-id.js';
 import { asyncApiExternalDocumentationObject } from './external-documentation.js';
 import { asyncApiMessageObject } from './message.js';
@@ -21,7 +21,7 @@ export const asyncApiComponentsObject = lazy(() => object({
         typeComment: 'Reusable Multi Format Schema, Schema Object, or Reference Object.',
     })),
     servers: optional(record(string(), asyncApiServerObject)),
-    channels: optional(record(string(), asyncApiChannelObject)),
+    channels: optional(asyncApiChannelsObject),
     operations: optional(record(string(), asyncApiOperationObject)),
     messages: optional(record(string(), asyncApiMessageObject)),
     securitySchemes: optional(record(string(), asyncApiSecuritySchemeObject)),

package/dist/asyncapi/3.1/schema-payload.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema-payload.d.ts","sourceRoot":"","sources":["../../../src/asyncapi/3.1/schema-payload.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,+BAA+B;;;EAa3C,CAAA;AAcD,uCAAuC;AACvC,eAAO,MAAM,+BAA+B,qCAAwC,CAAA;AAEpF,oEAAoE;AACpE,eAAO,MAAM,qBAAqB,qCAIjC,CAAA"}
+{"version":3,"file":"schema-payload.d.ts","sourceRoot":"","sources":["../../../src/asyncapi/3.1/schema-payload.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,+BAA+B;;;EAa3C,CAAA;AAQD,uCAAuC;AACvC,eAAO,MAAM,+BAA+B,qCAAwC,CAAA;AAEpF,oEAAoE;AACpE,eAAO,MAAM,qBAAqB,qCAIjC,CAAA"}

package/dist/asyncapi/3.1/schema-payload.js

@@ -1,4 +1,5 @@
 import { literal, object, optional, string, union, unknown } from '@scalar/validation';
+import { schema as schemaObject } from '../../openapi/3.1/schema.js';
 import { recursiveRef } from './reference.js';
 export const asyncApiMultiFormatSchemaObject = object({
     schemaFormat: optional(string({
@@ -8,14 +9,11 @@ export const asyncApiMultiFormatSchemaObject = object({
         typeComment: 'REQUIRED. Schema definition in the format given by schemaFormat.',
     }),
 }, { typeName: 'AsyncApiMultiFormatSchemaObject' });
-const asyncApiSchemaJsonShape = union([
-    literal(true),
-    literal(false),
-    unknown({
-        typeName: 'AsyncApiSchemaObject',
-        typeComment: 'JSON Schema Draft 07 compatible schema (boolean true/false or object); see AsyncAPI Schema Object.',
-    }),
-], { typeName: 'AsyncApiSchemaJsonShape' });
+// AsyncAPI's default schema format is JSON Schema, the same dialect OpenAPI 3.1 uses, so we reuse the
+// OpenAPI Schema Object here instead of an opaque `unknown`. A schema may also be a boolean per JSON Schema.
+const asyncApiSchemaJsonShape = union([literal(true), literal(false), schemaObject], {
+    typeName: 'AsyncApiSchemaJsonShape',
+});
 /** Schema Object | Reference Object */
 export const asyncApiSchemaObjectOrReference = recursiveRef(asyncApiSchemaJsonShape);
 /** Multi Format Schema Object | Schema Object | Reference Object */

package/dist/extensions/document/x-scalar-sdk-installation.d.ts

@@ -1,7 +1,6 @@
 export declare const XScalarSdkInstallation: import("@scalar/validation").ObjectSchema<{
     'x-scalar-sdk-installation': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").ObjectSchema<{
         lang: import("@scalar/validation").StringSchema;
-        source: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
         description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
     }>>>;
 }>;

package/dist/extensions/document/x-scalar-sdk-installation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"x-scalar-sdk-installation.d.ts","sourceRoot":"","sources":["../../../src/extensions/document/x-scalar-sdk-installation.ts"],"names":[],"mappings":"AAgBA,eAAO,MAAM,sBAAsB;;;;;;EAiBlC,CAAA"}
+{"version":3,"file":"x-scalar-sdk-installation.d.ts","sourceRoot":"","sources":["../../../src/extensions/document/x-scalar-sdk-installation.ts"],"names":[],"mappings":"AAiBA,eAAO,MAAM,sBAAsB;;;;;EAiBlC,CAAA"}

package/dist/extensions/document/x-scalar-sdk-installation.js

@@ -1,9 +1,8 @@
 import { array, object, optional, string } from '@scalar/validation';
 import { typeCommentWithExample } from '../type-comment.js';
 const XScalarSdkInstallationItem = object({
-    lang: string({ typeComment: 'Programming language or platform (for example `shell`, `javascript`)' }),
-    source: optional(string({ typeComment: 'Installation command or snippet source' })),
-    description: optional(string({ typeComment: 'Human-readable description of this installation option' })),
+    lang: string({ typeComment: 'Programming language or platform (for example `TypeScript`, `Java`, `Python`)' }),
+    description: optional(string({ typeComment: 'Installation instructions in Markdown (supports fenced code blocks)' })),
 }, {
     typeName: 'XScalarSdkInstallationItem',
     typeComment: 'One SDK installation instruction block',
@@ -17,7 +16,7 @@ export const XScalarSdkInstallation = object({
     typeComment: typeCommentWithExample('Scalar SDK installation instructions for the API description.', {
         language: 'yaml',
         body: `x-scalar-sdk-installation:
-  - lang: shell
-    source: npm install @scalar/api-client`,
+  - lang: TypeScript
+    description: Install our SDK from npm with \`npm install @scalar/sdk\``,
     }),
 });

package/dist/extensions/operation/x-code-samples.d.ts

@@ -19,5 +19,30 @@ export declare const XCodeSamples: import("@scalar/validation").ObjectSchema<{
         label: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
         source: import("@scalar/validation").StringSchema;
     }>>>;
+    'x-readme': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ObjectSchema<{
+        'code-samples': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").ObjectSchema<{
+            language: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+            code: import("@scalar/validation").StringSchema;
+            name: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+            install: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+            correspondingExample: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        }>>>;
+        'samples-languages': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").StringSchema>>;
+    }>>;
+    'x-stainless-snippets': import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").StringSchema>>;
+    'x-stainless-examples': import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnionSchema<readonly [import("@scalar/validation").ObjectSchema<{
+        title: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        request: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").StringSchema>>;
+        response: import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnknownSchema>;
+    }>, import("@scalar/validation").ArraySchema<import("@scalar/validation").ObjectSchema<{
+        title: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        request: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").StringSchema>>;
+        response: import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnknownSchema>;
+    }>>]>>;
+    'x-scalar-examples': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").ObjectSchema<{
+        lang: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        label: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        source: import("@scalar/validation").StringSchema;
+    }>>>;
 }>;
 //# sourceMappingURL=x-code-samples.d.ts.map

package/dist/extensions/operation/x-code-samples.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"x-code-samples.d.ts","sourceRoot":"","sources":["../../../src/extensions/operation/x-code-samples.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,WAAW;;;;EAUvB,CAAA;AAED,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;EAmBxB,CAAA"}
+{"version":3,"file":"x-code-samples.d.ts","sourceRoot":"","sources":["../../../src/extensions/operation/x-code-samples.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,WAAW;;;;EAUvB,CAAA;AA0CD,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BxB,CAAA"}

package/dist/extensions/operation/x-code-samples.js

@@ -1,4 +1,4 @@
-import { array, object, optional, string } from '@scalar/validation';
+import { array, object, optional, record, string, union, unknown } from '@scalar/validation';
 import { typeCommentInlineCode, typeCommentWithExample } from '../type-comment.js';
 export const XCodeSample = object({
     lang: optional(string({ typeComment: 'Programming language for syntax highlighting' })),
@@ -8,13 +8,44 @@ export const XCodeSample = object({
     typeName: 'XCodeSample',
     typeComment: 'A single code sample for documentation or examples',
 });
+const XReadmeCodeSample = object({
+    language: optional(string({ typeComment: 'Programming language for syntax highlighting' })),
+    code: string({ typeComment: 'Source code for the sample' }),
+    name: optional(string({ typeComment: 'Label shown in the code sample picker' })),
+    install: optional(string({ typeComment: 'Installation instructions for the sample' })),
+    correspondingExample: optional(string({ typeComment: 'Name of the response example this sample maps to' })),
+}, {
+    typeName: 'XReadmeCodeSample',
+    typeComment: 'A single ReadMe custom code sample',
+});
+const XReadme = object({
+    'code-samples': optional(array(XReadmeCodeSample, { typeComment: 'ReadMe custom code samples' })),
+    'samples-languages': optional(array(string(), { typeComment: 'Languages to generate code samples for' })),
+}, {
+    typeName: 'XReadme',
+    typeComment: 'ReadMe extension object. Only code-samples carries source code.',
+});
+const XLanguageExample = object({
+    title: optional(string({ typeComment: 'Label shown in the code sample picker' })),
+    request: optional(record(string(), string(), { typeComment: 'Source code keyed by programming language' })),
+    response: optional(unknown({ typeComment: 'Example response for the request' })),
+}, {
+    typeName: 'XLanguageExample',
+    typeComment: 'Per-language request snippets with an optional title and response',
+});
+/** A single example or an array of examples, as used by x-stainless-examples and x-scalar-examples. */
+const XLanguageExamples = union([XLanguageExample, array(XLanguageExample)]);
 export const XCodeSamples = object({
     'x-codeSamples': optional(array(XCodeSample, { typeComment: 'Code samples (camelCase spelling)' })),
     'x-code-samples': optional(array(XCodeSample, { typeComment: 'Code samples (kebab-case spelling)' })),
     'x-custom-examples': optional(array(XCodeSample, { typeComment: 'Custom code examples for the operation' })),
+    'x-readme': optional(XReadme),
+    'x-stainless-snippets': optional(record(string(), string(), { typeComment: 'Stainless snippets, source code keyed by language' })),
+    'x-stainless-examples': optional(XLanguageExamples),
+    'x-scalar-examples': optional(array(XCodeSample, { typeComment: 'Scalar code samples (same shape as x-codeSamples)' })),
 }, {
     typeName: 'XCodeSamples',
-    typeComment: typeCommentWithExample(`Code samples attached to an operation. Supports ${typeCommentInlineCode('x-codeSamples')}, ${typeCommentInlineCode('x-code-samples')}, and ${typeCommentInlineCode('x-custom-examples')}.`, {
+    typeComment: typeCommentWithExample(`Code samples attached to an operation. Supports ${typeCommentInlineCode('x-codeSamples')}, ${typeCommentInlineCode('x-code-samples')}, ${typeCommentInlineCode('x-custom-examples')}, ${typeCommentInlineCode('x-readme')}, ${typeCommentInlineCode('x-stainless-snippets')}, ${typeCommentInlineCode('x-stainless-examples')}, and ${typeCommentInlineCode('x-scalar-examples')}.`, {
         language: 'yaml',
         body: `x-code-samples:
   - lang: curl

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

@@ -19,7 +19,6 @@ export declare const openApiSchema: import("@scalar/validation").IntersectionSch
     }>, import("@scalar/validation").ObjectSchema<{
         'x-scalar-sdk-installation': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").ObjectSchema<{
             lang: import("@scalar/validation").StringSchema;
-            source: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
             description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
         }>>>;
     }>]>;

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

@@ -1 +1 @@
-{"version":3,"file":"document.d.ts","sourceRoot":"","sources":["../../../src/openapi/3.1/document.ts"],"names":[],"mappings":"AA2GA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAGxB,CAAA"}
+{"version":3,"file":"document.d.ts","sourceRoot":"","sources":["../../../src/openapi/3.1/document.ts"],"names":[],"mappings":"AA2GA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAGxB,CAAA"}

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

@@ -17,7 +17,6 @@ export declare const info: import("@scalar/validation").IntersectionSchema<reado
 }>, import("@scalar/validation").ObjectSchema<{
     'x-scalar-sdk-installation': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").ObjectSchema<{
         lang: import("@scalar/validation").StringSchema;
-        source: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
         description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
     }>>>;
 }>]>;

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

@@ -1 +1 @@
-{"version":3,"file":"info.d.ts","sourceRoot":"","sources":["../../../src/openapi/3.1/info.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;IAuBhB,CAAA"}
+{"version":3,"file":"info.d.ts","sourceRoot":"","sources":["../../../src/openapi/3.1/info.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;IAuBhB,CAAA"}

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

@@ -48,6 +48,31 @@ export declare const operation: import("@scalar/validation").IntersectionSchema<
         label: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
         source: import("@scalar/validation").StringSchema;
     }>>>;
+    'x-readme': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ObjectSchema<{
+        'code-samples': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").ObjectSchema<{
+            language: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+            code: import("@scalar/validation").StringSchema;
+            name: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+            install: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+            correspondingExample: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        }>>>;
+        'samples-languages': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").StringSchema>>;
+    }>>;
+    'x-stainless-snippets': import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").StringSchema>>;
+    'x-stainless-examples': import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnionSchema<readonly [import("@scalar/validation").ObjectSchema<{
+        title: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        request: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").StringSchema>>;
+        response: import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnknownSchema>;
+    }>, import("@scalar/validation").ArraySchema<import("@scalar/validation").ObjectSchema<{
+        title: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        request: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").StringSchema>>;
+        response: import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnknownSchema>;
+    }>>]>>;
+    'x-scalar-examples': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").ObjectSchema<{
+        lang: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        label: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        source: import("@scalar/validation").StringSchema;
+    }>>>;
 }>, import("@scalar/validation").ObjectSchema<{
     'x-scalar-stability': import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnionSchema<readonly [import("@scalar/validation").LiteralSchema<"deprecated">, import("@scalar/validation").LiteralSchema<"experimental">, import("@scalar/validation").LiteralSchema<"stable">]>>;
 }>, import("@scalar/validation").ObjectSchema<{

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

@@ -1 +1 @@
-{"version":3,"file":"operation.d.ts","sourceRoot":"","sources":["../../../src/openapi/3.1/operation.ts"],"names":[],"mappings":"AAqBA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAiDrB,CAAA"}
+{"version":3,"file":"operation.d.ts","sourceRoot":"","sources":["../../../src/openapi/3.1/operation.ts"],"names":[],"mappings":"AAqBA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAiDrB,CAAA"}

package/dist/openapi/3.1/reference.js

@@ -18,7 +18,7 @@ const reference = object({
  * Use for `components.schemas` and schema composition (`allOf`, `properties`, `items`, and similar)
  * where references follow JSON Schema / OpenAPI schema rules only.
  */
-export const normalRef = (inner) => union([inner, reference]);
+export const normalRef = (inner) => union([reference, inner]);
 const e = (value) => {
     if (isObject(value) && '$ref' in value) {
         return e(value['$ref-value']);

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

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/openapi/3.1/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,MAAM,EAaZ,MAAM,oBAAoB,CAAA;AAqI3B,eAAO,MAAM,MAAM,EAAE,MAOpB,CAAA"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/openapi/3.1/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,MAAM,EAaZ,MAAM,oBAAoB,CAAA;AA0K3B,eAAO,MAAM,MAAM,EAAE,MAOpB,CAAA"}

package/dist/openapi/3.1/schema.js

@@ -43,24 +43,33 @@ const coreSchemaProperties = object({
     anyOf: optional(array(normalRef(lazy(() => schema)), { typeName: 'SchemaObjectAnyOf' })),
     not: optional(normalRef(lazy(() => schema))),
 });
-const numericSchema = object({
-    type: union([literal('number'), literal('integer')]),
-    format: optional(string({ typeComment: 'Different subtypes.' })),
+const numericValidationKeywords = object({
     multipleOf: optional(number({ typeComment: 'Number must be a multiple of this value.' })),
     maximum: optional(number({ typeComment: 'Maximum value (inclusive).' })),
     exclusiveMaximum: optional(number({ typeComment: 'Maximum value (exclusive).' })),
     minimum: optional(number({ typeComment: 'Minimum value (inclusive).' })),
     exclusiveMinimum: optional(number({ typeComment: 'Minimum value (exclusive).' })),
-}, { typeName: 'NumberSchemaObject' });
-const stringSchema = object({
-    type: literal('string'),
-    format: optional(string({ typeComment: 'Different subtypes.' })),
+});
+const numericSchema = intersection([
+    object({
+        type: union([literal('number'), literal('integer')]),
+        format: optional(string({ typeComment: 'Different subtypes.' })),
+    }),
+    numericValidationKeywords,
+], { typeName: 'NumberSchemaObject' });
+const stringValidationKeywords = object({
     maxLength: optional(number({ typeComment: 'Maximum string length.' })),
     minLength: optional(number({ typeComment: 'Minimum string length.' })),
     pattern: optional(string({ typeComment: 'Regular expression pattern.' })),
-}, { typeName: 'StringSchemaObject' });
-const objectSchema = object({
-    type: literal('object'),
+});
+const stringSchema = intersection([
+    object({
+        type: literal('string'),
+        format: optional(string({ typeComment: 'Different subtypes.' })),
+    }),
+    stringValidationKeywords,
+], { typeName: 'StringSchemaObject' });
+const objectValidationKeywords = object({
     maxProperties: optional(number({ typeComment: 'Maximum number of properties.' })),
     minProperties: optional(number({ typeComment: 'Minimum number of properties.' })),
     properties: optional(record(string(), normalRef(lazy(() => schema)), { typeName: 'SchemaObjectProperties' })),
@@ -70,15 +79,26 @@ const objectSchema = object({
     })),
     patternProperties: optional(record(string(), normalRef(lazy(() => schema)), { typeName: 'SchemaObjectPatternProperties' })),
     propertyNames: optional(normalRef(lazy(() => schema))),
-}, { typeName: 'ObjectSchemaObject' });
-const arraySchema = object({
-    type: literal('array'),
+});
+const objectSchema = intersection([
+    object({
+        type: literal('object'),
+    }),
+    objectValidationKeywords,
+], { typeName: 'ObjectSchemaObject' });
+const arrayValidationKeywords = object({
     maxItems: optional(number({ typeComment: 'Maximum number of items in array.' })),
     minItems: optional(number({ typeComment: 'Minimum number of items in array.' })),
     uniqueItems: optional(boolean({ typeComment: 'Whether array items must be unique.' })),
     items: optional(normalRef(lazy(() => schema))),
     prefixItems: optional(array(normalRef(lazy(() => schema)), { typeComment: 'Schema for tuple validation.' })),
-}, { typeName: 'ArraySchemaObject' });
+});
+const arraySchema = intersection([
+    object({
+        type: literal('array'),
+    }),
+    arrayValidationKeywords,
+], { typeName: 'ArraySchemaObject' });
 const schemaTypeMulti = union([
     literal('null'),
     literal('boolean'),
@@ -89,12 +109,24 @@ const schemaTypeMulti = union([
     literal('array'),
 ], { typeName: 'SchemaObjectMultiTypeKeywords' });
 const otherTypeSchema = object({
-    type: union([literal('null'), literal('boolean'), array(schemaTypeMulti)], {
+    type: union([literal('null'), literal('boolean')], {
         typeName: 'SchemaObjectOtherTypeKeyword',
     }),
-}, { typeName: 'MultiTypeSchemaObject' });
+});
+const multiTypeSchema = intersection([
+    object({
+        type: array(schemaTypeMulti, {
+            typeName: 'SchemaObjectMultiTypeKeywordArray',
+        }),
+        format: optional(string({ typeComment: 'Different subtypes.' })),
+    }),
+    numericValidationKeywords,
+    stringValidationKeywords,
+    arrayValidationKeywords,
+    objectValidationKeywords,
+], { typeName: 'MultiTypeSchemaObject' });
 export const schema = intersection([
     coreSchemaProperties,
     ...schemaExtensionObjects,
-    union([otherTypeSchema, numericSchema, stringSchema, objectSchema, arraySchema, object({})]),
+    union([otherTypeSchema, numericSchema, stringSchema, objectSchema, arraySchema, multiTypeSchema, object({})]),
 ], { typeName: 'SchemaObject' });

package/package.json

@@ -14,7 +14,7 @@
     "schemas",
     "scalar"
   ],
-  "version": "0.3.2",
+  "version": "0.4.0",
   "engines": {
     "node": ">=22"
   },
@@ -41,12 +41,12 @@
     "CHANGELOG.md"
   ],
   "dependencies": {
-    "@scalar/helpers": "0.8.0",
-    "@scalar/validation": "0.6.0"
+    "@scalar/validation": "0.6.0",
+    "@scalar/helpers": "0.8.1"
   },
   "devDependencies": {
     "vitest": "4.1.0",
-    "@scalar/types": "0.12.2"
+    "@scalar/types": "0.13.0"
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",