@scalar/schemas 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,13 @@
+# @scalar/schemas
+
+## 0.2.0
+
+### Minor Changes
+
+- [#9211](https://github.com/scalar/scalar/pull/9211): feat: write custom schemas for api-reference configuration
+
+## 0.1.0
+
+### Minor Changes
+
+- [#8844](https://github.com/scalar/scalar/pull/8844): feat: write custom schemas for api-reference configuration

package/LICENSE

@@ -0,0 +1,21 @@
+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.

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

@@ -0,0 +1,278 @@
+export declare const apiReferenceConfigurationSchema: import("@scalar/validation").IntersectionSchema<readonly [import("@scalar/validation").ObjectSchema<{
+    title: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    slug: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    authentication: import("@scalar/validation").OptionalSchema<import("@scalar/validation").AnySchema>;
+    baseServerURL: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    hideClientButton: import("@scalar/validation").BooleanSchema;
+    proxyUrl: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    oauth2RedirectUri: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    searchHotKey: import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnionSchema<(import("@scalar/validation").LiteralSchema<"a"> | import("@scalar/validation").LiteralSchema<"b"> | import("@scalar/validation").LiteralSchema<"c"> | import("@scalar/validation").LiteralSchema<"d"> | import("@scalar/validation").LiteralSchema<"e"> | import("@scalar/validation").LiteralSchema<"f"> | import("@scalar/validation").LiteralSchema<"g"> | import("@scalar/validation").LiteralSchema<"h"> | import("@scalar/validation").LiteralSchema<"i"> | import("@scalar/validation").LiteralSchema<"j"> | import("@scalar/validation").LiteralSchema<"k"> | import("@scalar/validation").LiteralSchema<"l"> | import("@scalar/validation").LiteralSchema<"m"> | import("@scalar/validation").LiteralSchema<"n"> | import("@scalar/validation").LiteralSchema<"o"> | import("@scalar/validation").LiteralSchema<"p"> | import("@scalar/validation").LiteralSchema<"q"> | import("@scalar/validation").LiteralSchema<"r"> | import("@scalar/validation").LiteralSchema<"s"> | import("@scalar/validation").LiteralSchema<"t"> | import("@scalar/validation").LiteralSchema<"u"> | import("@scalar/validation").LiteralSchema<"v"> | import("@scalar/validation").LiteralSchema<"w"> | import("@scalar/validation").LiteralSchema<"x"> | import("@scalar/validation").LiteralSchema<"y"> | import("@scalar/validation").LiteralSchema<"z">)[]>>;
+    servers: import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").AnySchema>>;
+    showSidebar: import("@scalar/validation").BooleanSchema;
+    showDeveloperTools: import("@scalar/validation").UnionSchema<(import("@scalar/validation").LiteralSchema<"localhost"> | import("@scalar/validation").LiteralSchema<"always"> | import("@scalar/validation").LiteralSchema<"never">)[]>;
+    showToolbar: import("@scalar/validation").UnionSchema<(import("@scalar/validation").LiteralSchema<"localhost"> | import("@scalar/validation").LiteralSchema<"always"> | import("@scalar/validation").LiteralSchema<"never">)[]>;
+    operationTitleSource: import("@scalar/validation").UnionSchema<(import("@scalar/validation").LiteralSchema<"summary"> | import("@scalar/validation").LiteralSchema<"path">)[]>;
+    theme: import("@scalar/validation").UnionSchema<(import("@scalar/validation").LiteralSchema<"default"> | import("@scalar/validation").LiteralSchema<"alternate"> | import("@scalar/validation").LiteralSchema<"moon"> | import("@scalar/validation").LiteralSchema<"purple"> | import("@scalar/validation").LiteralSchema<"solarized"> | import("@scalar/validation").LiteralSchema<"bluePlanet"> | import("@scalar/validation").LiteralSchema<"deepSpace"> | import("@scalar/validation").LiteralSchema<"saturn"> | import("@scalar/validation").LiteralSchema<"kepler"> | import("@scalar/validation").LiteralSchema<"elysiajs"> | import("@scalar/validation").LiteralSchema<"fastify"> | import("@scalar/validation").LiteralSchema<"mars"> | import("@scalar/validation").LiteralSchema<"laserwave"> | import("@scalar/validation").LiteralSchema<"none">)[]>;
+    _integration: import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnionSchema<(import("@scalar/validation").NullableSchema | import("@scalar/validation").LiteralSchema<"elysiajs"> | import("@scalar/validation").LiteralSchema<"fastify"> | import("@scalar/validation").LiteralSchema<"adonisjs"> | import("@scalar/validation").LiteralSchema<"astro"> | import("@scalar/validation").LiteralSchema<"docusaurus"> | import("@scalar/validation").LiteralSchema<"dotnet"> | import("@scalar/validation").LiteralSchema<"express"> | import("@scalar/validation").LiteralSchema<"fastapi"> | import("@scalar/validation").LiteralSchema<"go"> | import("@scalar/validation").LiteralSchema<"hono"> | import("@scalar/validation").LiteralSchema<"html"> | import("@scalar/validation").LiteralSchema<"laravel"> | import("@scalar/validation").LiteralSchema<"litestar"> | import("@scalar/validation").LiteralSchema<"nestjs"> | import("@scalar/validation").LiteralSchema<"nextjs"> | import("@scalar/validation").LiteralSchema<"nitro"> | import("@scalar/validation").LiteralSchema<"nuxt"> | import("@scalar/validation").LiteralSchema<"platformatic"> | import("@scalar/validation").LiteralSchema<"react"> | import("@scalar/validation").LiteralSchema<"rust"> | import("@scalar/validation").LiteralSchema<"svelte"> | import("@scalar/validation").LiteralSchema<"vue">)[]>>;
+    onRequestSent: import("@scalar/validation").OptionalSchema<import("@scalar/validation").FunctionSchema<(input: string) => void>>;
+    persistAuth: import("@scalar/validation").BooleanSchema;
+    telemetry: import("@scalar/validation").BooleanSchema;
+    externalUrls: import("@scalar/validation").ObjectSchema<{
+        dashboardUrl: import("@scalar/validation").StringSchema;
+        registryUrl: import("@scalar/validation").StringSchema;
+        proxyUrl: import("@scalar/validation").StringSchema;
+        apiBaseUrl: import("@scalar/validation").StringSchema;
+    }>;
+}>, import("@scalar/validation").ObjectSchema<{
+    default: import("@scalar/validation").BooleanSchema;
+    url: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    content: import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnionSchema<(import("@scalar/validation").StringSchema | import("@scalar/validation").NullableSchema | import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").AnySchema> | import("@scalar/validation").FunctionSchema<() => string | any>)[]>>;
+    title: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    slug: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    spec: import("@scalar/validation").OptionalSchema<import("@scalar/validation").ObjectSchema<{
+        url: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        content: import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnionSchema<(import("@scalar/validation").StringSchema | import("@scalar/validation").NullableSchema | import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").AnySchema> | import("@scalar/validation").FunctionSchema<() => string | any>)[]>>;
+    }>>;
+    agent: import("@scalar/validation").OptionalSchema<import("@scalar/validation").ObjectSchema<{
+        key: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        disabled: import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+        hideAddApi: import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+    }>>;
+}>, import("@scalar/validation").ObjectSchema<{
+    layout: import("@scalar/validation").UnionSchema<(import("@scalar/validation").LiteralSchema<"modern"> | import("@scalar/validation").LiteralSchema<"classic">)[]>;
+    proxy: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    fetch: import("@scalar/validation").OptionalSchema<import("@scalar/validation").FunctionSchema<typeof fetch>>;
+    plugins: import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").FunctionSchema<() => {
+        name: string;
+        extensions: import("@scalar/validation").Static<import("@scalar/validation").ObjectSchema<{
+            name: import("@scalar/validation").StringSchema;
+            component: import("@scalar/validation").UnknownSchema;
+            renderer: import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnknownSchema>;
+        }>>[];
+        views: import("@scalar/validation").Static<import("@scalar/validation").ObjectSchema<{
+            'content.end': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").ObjectSchema<{
+                component: import("@scalar/validation").UnknownSchema;
+                renderer: import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnknownSchema>;
+                props: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").AnySchema>>;
+            }>>>;
+        }>>;
+        hooks: import("@scalar/validation").Static<import("@scalar/validation").ObjectSchema<{
+            onInit: import("@scalar/validation").OptionalSchema<import("@scalar/validation").FunctionSchema<({ config }: {
+                config: any;
+            }) => void>>;
+            onConfigChange: import("@scalar/validation").OptionalSchema<import("@scalar/validation").FunctionSchema<({ config }: {
+                config: any;
+            }) => void>>;
+            onDestroy: import("@scalar/validation").OptionalSchema<import("@scalar/validation").FunctionSchema<() => void>>;
+        }>>;
+        apiClientPlugins: any[];
+    }>>>;
+    isEditable: import("@scalar/validation").BooleanSchema;
+    isLoading: import("@scalar/validation").BooleanSchema;
+    hideModels: import("@scalar/validation").BooleanSchema;
+    documentDownloadType: import("@scalar/validation").UnionSchema<(import("@scalar/validation").LiteralSchema<"none"> | import("@scalar/validation").LiteralSchema<"both"> | import("@scalar/validation").LiteralSchema<"yaml"> | import("@scalar/validation").LiteralSchema<"json"> | import("@scalar/validation").LiteralSchema<"direct">)[]>;
+    hideDownloadButton: import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+    hideTestRequestButton: import("@scalar/validation").BooleanSchema;
+    hideSearch: import("@scalar/validation").BooleanSchema;
+    showOperationId: import("@scalar/validation").BooleanSchema;
+    darkMode: import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+    forceDarkModeState: import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnionSchema<(import("@scalar/validation").LiteralSchema<"dark"> | import("@scalar/validation").LiteralSchema<"light">)[]>>;
+    hideDarkModeToggle: import("@scalar/validation").BooleanSchema;
+    metaData: import("@scalar/validation").OptionalSchema<import("@scalar/validation").AnySchema>;
+    favicon: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    hiddenClients: import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnionSchema<(import("@scalar/validation").ArraySchema<import("@scalar/validation").StringSchema> | import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").UnionSchema<(import("@scalar/validation").BooleanSchema | import("@scalar/validation").ArraySchema<import("@scalar/validation").StringSchema>)[]>> | import("@scalar/validation").LiteralSchema<true>)[]>>;
+    defaultHttpClient: import("@scalar/validation").OptionalSchema<import("@scalar/validation").ObjectSchema<{
+        targetKey: import("@scalar/validation").StringSchema;
+        clientKey: import("@scalar/validation").StringSchema;
+    }>>;
+    customCss: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    onSpecUpdate: import("@scalar/validation").OptionalSchema<import("@scalar/validation").FunctionSchema<(input: string) => void>>;
+    onServerChange: import("@scalar/validation").OptionalSchema<import("@scalar/validation").FunctionSchema<(input: string) => void>>;
+    onDocumentSelect: import("@scalar/validation").OptionalSchema<import("@scalar/validation").FunctionSchema<() => void>>;
+    onLoaded: import("@scalar/validation").OptionalSchema<import("@scalar/validation").FunctionSchema<(slug: string) => Promise<void> | void>>;
+    onBeforeRequest: import("@scalar/validation").OptionalSchema<import("@scalar/validation").FunctionSchema<(input: {
+        request: Request;
+        requestBuilder: unknown;
+        envVariables: Record<string, string>;
+    }) => Promise<void> | void>>;
+    onShowMore: import("@scalar/validation").OptionalSchema<import("@scalar/validation").FunctionSchema<(tagId: string) => Promise<void> | void>>;
+    onSidebarClick: import("@scalar/validation").OptionalSchema<import("@scalar/validation").FunctionSchema<(href: string) => Promise<void> | void>>;
+    pathRouting: import("@scalar/validation").OptionalSchema<import("@scalar/validation").ObjectSchema<{
+        basePath: import("@scalar/validation").StringSchema;
+    }>>;
+    mcp: import("@scalar/validation").OptionalSchema<import("@scalar/validation").ObjectSchema<{
+        name: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        url: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        disabled: import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+    }>>;
+    generateHeadingSlug: import("@scalar/validation").OptionalSchema<import("@scalar/validation").FunctionSchema<(input: {
+        slug?: string;
+    }) => string>>;
+    generateModelSlug: import("@scalar/validation").OptionalSchema<import("@scalar/validation").FunctionSchema<(input: {
+        name?: string;
+    }) => string>>;
+    generateTagSlug: import("@scalar/validation").OptionalSchema<import("@scalar/validation").FunctionSchema<(input: {
+        name?: string;
+    }) => string>>;
+    generateOperationSlug: import("@scalar/validation").OptionalSchema<import("@scalar/validation").FunctionSchema<(input: {
+        path: string;
+        operationId?: string;
+        method: string;
+        summary?: string;
+    }) => string>>;
+    generateWebhookSlug: import("@scalar/validation").OptionalSchema<import("@scalar/validation").FunctionSchema<(input: {
+        name: string;
+        method?: 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;
+    tagsSorter: import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnionSchema<(import("@scalar/validation").LiteralSchema<"alpha"> | import("@scalar/validation").FunctionSchema<(a: any, b: any) => number>)[]>>;
+    operationsSorter: import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnionSchema<(import("@scalar/validation").LiteralSchema<"alpha"> | import("@scalar/validation").LiteralSchema<"method"> | import("@scalar/validation").FunctionSchema<(a: any, b: any) => number>)[]>>;
+    orderSchemaPropertiesBy: import("@scalar/validation").UnionSchema<(import("@scalar/validation").LiteralSchema<"alpha"> | import("@scalar/validation").LiteralSchema<"preserve">)[]>;
+    orderRequiredPropertiesFirst: import("@scalar/validation").BooleanSchema;
+}>]>;
+export declare const apiReferenceConfigurationWithSourceSchema: (rawInput: unknown) => {
+    hideClientButton: boolean;
+    showSidebar: boolean;
+    showDeveloperTools: "localhost" | "always" | "never";
+    showToolbar: "localhost" | "always" | "never";
+    operationTitleSource: "summary" | "path";
+    theme: "default" | "alternate" | "moon" | "purple" | "solarized" | "bluePlanet" | "deepSpace" | "saturn" | "kepler" | "elysiajs" | "fastify" | "mars" | "laserwave" | "none";
+    persistAuth: boolean;
+    telemetry: boolean;
+    externalUrls: {
+        dashboardUrl: string;
+        registryUrl: string;
+        proxyUrl: string;
+        apiBaseUrl: string;
+    };
+} & {
+    proxyUrl?: string | undefined;
+    title?: string | undefined;
+    slug?: string | undefined;
+    authentication?: any;
+    baseServerURL?: string | undefined;
+    oauth2RedirectUri?: string | undefined;
+    searchHotKey?: "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z" | undefined;
+    servers?: any[] | undefined;
+    _integration?: "elysiajs" | "fastify" | "adonisjs" | "astro" | "docusaurus" | "dotnet" | "express" | "fastapi" | "go" | "hono" | "html" | "laravel" | "litestar" | "nestjs" | "nextjs" | "nitro" | "nuxt" | "platformatic" | "react" | "rust" | "svelte" | "vue" | null | undefined;
+    onRequestSent?: ((input: string) => void) | undefined;
+} & {
+    default: boolean;
+} & {
+    title?: string | undefined;
+    slug?: string | undefined;
+    url?: string | undefined;
+    content?: string | Record<string, any> | (() => string | any) | null | undefined;
+    spec?: {
+        url?: string | undefined;
+        content?: string | Record<string, any> | (() => string | any) | null | undefined;
+    } | undefined;
+    agent?: {
+        key?: string | undefined;
+        disabled?: boolean | undefined;
+        hideAddApi?: boolean | undefined;
+    } | undefined;
+} & {
+    layout: "modern" | "classic";
+    isEditable: boolean;
+    isLoading: boolean;
+    hideModels: boolean;
+    documentDownloadType: "none" | "both" | "yaml" | "json" | "direct";
+    hideTestRequestButton: boolean;
+    hideSearch: boolean;
+    showOperationId: boolean;
+    hideDarkModeToggle: boolean;
+    withDefaultFonts: boolean;
+    defaultOpenFirstTag: boolean;
+    defaultOpenAllTags: boolean;
+    expandAllModelSections: boolean;
+    expandAllResponses: boolean;
+    orderSchemaPropertiesBy: "alpha" | "preserve";
+    orderRequiredPropertiesFirst: boolean;
+} & {
+    proxy?: string | undefined;
+    fetch?: typeof fetch | undefined;
+    plugins?: (() => {
+        name: string;
+        extensions: import("@scalar/validation").Static<import("@scalar/validation").ObjectSchema<{
+            name: import("@scalar/validation").StringSchema;
+            component: import("@scalar/validation").UnknownSchema;
+            renderer: import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnknownSchema>;
+        }>>[];
+        views: import("@scalar/validation").Static<import("@scalar/validation").ObjectSchema<{
+            'content.end': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").ObjectSchema<{
+                component: import("@scalar/validation").UnknownSchema;
+                renderer: import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnknownSchema>;
+                props: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").AnySchema>>;
+            }>>>;
+        }>>;
+        hooks: import("@scalar/validation").Static<import("@scalar/validation").ObjectSchema<{
+            onInit: import("@scalar/validation").OptionalSchema<import("@scalar/validation").FunctionSchema<({ config }: {
+                config: any;
+            }) => void>>;
+            onConfigChange: import("@scalar/validation").OptionalSchema<import("@scalar/validation").FunctionSchema<({ config }: {
+                config: any;
+            }) => void>>;
+            onDestroy: import("@scalar/validation").OptionalSchema<import("@scalar/validation").FunctionSchema<() => void>>;
+        }>>;
+        apiClientPlugins: any[];
+    })[] | undefined;
+    hideDownloadButton?: boolean | undefined;
+    darkMode?: boolean | undefined;
+    forceDarkModeState?: "dark" | "light" | undefined;
+    metaData?: any;
+    favicon?: string | undefined;
+    hiddenClients?: true | string[] | Record<string, boolean | string[]> | undefined;
+    defaultHttpClient?: {
+        targetKey: string;
+        clientKey: string;
+    } | undefined;
+    customCss?: string | undefined;
+    onSpecUpdate?: ((input: string) => void) | undefined;
+    onServerChange?: ((input: string) => void) | undefined;
+    onDocumentSelect?: (() => void) | undefined;
+    onLoaded?: ((slug: string) => Promise<void> | void) | undefined;
+    onBeforeRequest?: ((input: {
+        request: Request;
+        requestBuilder: unknown;
+        envVariables: Record<string, string>;
+    }) => Promise<void> | void) | undefined;
+    onShowMore?: ((tagId: string) => Promise<void> | void) | undefined;
+    onSidebarClick?: ((href: string) => Promise<void> | void) | undefined;
+    pathRouting?: {
+        basePath: string;
+    } | undefined;
+    mcp?: {
+        name?: string | undefined;
+        url?: string | undefined;
+        disabled?: boolean | undefined;
+    } | undefined;
+    generateHeadingSlug?: ((input: {
+        slug?: string;
+    }) => string) | undefined;
+    generateModelSlug?: ((input: {
+        name?: string;
+    }) => string) | undefined;
+    generateTagSlug?: ((input: {
+        name?: string;
+    }) => string) | undefined;
+    generateOperationSlug?: ((input: {
+        path: string;
+        operationId?: string;
+        method: string;
+        summary?: string;
+    }) => string) | undefined;
+    generateWebhookSlug?: ((input: {
+        name: string;
+        method?: 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;
+};
+//# sourceMappingURL=api-reference-configuration.d.ts.map

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

@@ -0,0 +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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kHAqFN,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;;;;;;4MA0Bb,GAAG,KAAK,GAAG,KAAK,MAAM;yQAGG,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;CA2EvG,CAAA"}

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

@@ -0,0 +1,209 @@
+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';
+import { sourceConfigurationSchema } from './source-configuration.js';
+export const apiReferenceConfigurationSchema = intersection([
+    baseConfigurationSchema,
+    sourceConfigurationSchema,
+    object({
+        layout: union([literal('modern'), literal('classic')], {
+            typeComment: 'The layout to use for the references',
+        }),
+        proxy: optional(string(), {
+            typeComment: '@deprecated Use proxyUrl instead',
+        }),
+        fetch: optional(fn(), {
+            typeComment: 'Custom fetch function for custom logic. Can be used to add custom headers, handle auth, etc.',
+        }),
+        plugins: optional(array(apiReferencePluginSchema), {
+            typeComment: 'Plugins for the API reference',
+        }),
+        isEditable: boolean({
+            default: false,
+            typeComment: 'Allows the user to inject an editor for the spec',
+        }),
+        isLoading: boolean({
+            default: false,
+            typeComment: 'Controls whether the references show a loading state in the intro',
+        }),
+        hideModels: boolean({
+            default: false,
+            typeComment: 'Whether to show models in the sidebar, search, and content.',
+        }),
+        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',
+        }),
+        hideDownloadButton: optional(boolean(), {
+            typeComment: "@deprecated Use `documentDownloadType: 'none'` instead",
+        }),
+        hideTestRequestButton: boolean({
+            default: false,
+            typeComment: 'Whether to show the "Test Request" button',
+        }),
+        hideSearch: boolean({
+            default: false,
+            typeComment: 'Whether to show the sidebar search bar',
+        }),
+        showOperationId: boolean({
+            default: false,
+            typeComment: 'Whether to show the operationId',
+        }),
+        darkMode: optional(boolean(), {
+            typeComment: 'Whether dark mode is on or off initially (light mode)',
+        }),
+        forceDarkModeState: optional(union([literal('dark'), literal('light')]), {
+            typeComment: 'forceDarkModeState makes it always this state no matter what',
+        }),
+        hideDarkModeToggle: boolean({
+            default: false,
+            typeComment: 'Whether to show the dark mode toggle',
+        }),
+        metaData: optional(any(), {
+            typeComment: 'If used, passed data will be added to the HTML header. @see https://unhead.unjs.io/usage/composables/use-seo-meta',
+        }),
+        favicon: optional(string(), {
+            typeComment: 'Path to a favicon image',
+        }),
+        hiddenClients: optional(union([record(string(), union([boolean(), array(string())])), array(string()), literal(true)]), {
+            typeComment: 'List of httpsnippet clients to hide from the clients menu. By default hides Unirest, pass `[]` to show all clients',
+        }),
+        defaultHttpClient: optional(object({
+            targetKey: string(),
+            clientKey: string(),
+        }), {
+            typeComment: 'Determine the HTTP client that is selected by default',
+        }),
+        customCss: optional(string(), {
+            typeComment: 'Custom CSS to be added to the page',
+        }),
+        onSpecUpdate: optional(fn(), {
+            typeComment: 'onSpecUpdate is fired on spec/swagger content change',
+        }),
+        onServerChange: optional(fn(), {
+            typeComment: 'onServerChange is fired on selected server change',
+        }),
+        onDocumentSelect: optional(fn(), {
+            typeComment: 'onDocumentSelect is fired when the config is selected',
+        }),
+        onLoaded: optional(fn(), {
+            typeComment: 'Callback fired when the reference is fully loaded',
+        }),
+        onBeforeRequest: optional(fn(), {
+            typeComment: 'Fired before the outbound request is built; callback receives a mutable request builder. Experimental API.',
+        }),
+        onShowMore: optional(fn(), {
+            typeComment: 'onShowMore is fired when the user clicks the "Show more" button on the references',
+        }),
+        onSidebarClick: optional(fn(), {
+            typeComment: 'onSidebarClick is fired when the user clicks on a sidebar item',
+        }),
+        pathRouting: optional(object({
+            basePath: string(),
+        }), {
+            typeComment: 'Route using paths instead of hashes, your server MUST support this. @experimental',
+        }),
+        mcp: optional(object({
+            name: optional(string(), {
+                typeComment: 'Display name for the MCP server',
+            }),
+            url: optional(string(), {
+                typeComment: 'URL of the MCP server',
+            }),
+            disabled: optional(boolean(), {
+                typeComment: 'When true, disables the MCP integration',
+            }),
+        }), {
+            typeComment: 'MCP (Model Context Protocol) configuration. When provided, enables MCP integration with the given name and url.',
+        }),
+        generateHeadingSlug: optional(fn(), {
+            typeComment: 'Customize the heading portion of the hash',
+        }),
+        generateModelSlug: optional(fn(), {
+            typeComment: 'Customize the model portion of the hash',
+        }),
+        generateTagSlug: optional(fn(), {
+            typeComment: 'Customize the tag portion of the hash',
+        }),
+        generateOperationSlug: optional(fn(), {
+            typeComment: 'Customize the operation portion of the hash',
+        }),
+        generateWebhookSlug: optional(fn(), {
+            typeComment: 'Customize the webhook portion of the hash',
+        }),
+        redirect: optional(fn(), {
+            typeComment: 'To handle redirects, pass a function that receives the current path/hash and passes that to history.replaceState',
+        }),
+        withDefaultFonts: boolean({
+            default: true,
+            typeComment: 'Whether to include default fonts',
+        }),
+        defaultOpenFirstTag: boolean({
+            default: true,
+            typeComment: 'Whether to expand the first tag in the sidebar when no specific URL target is present',
+        }),
+        defaultOpenAllTags: boolean({
+            default: false,
+            typeComment: 'Whether to expand all tags by default. Warning: this can cause performance issues on big documents',
+        }),
+        expandAllModelSections: boolean({
+            default: false,
+            typeComment: 'Whether to expand all models by default. Warning: this can cause performance issues on big documents',
+        }),
+        expandAllResponses: boolean({
+            default: false,
+            typeComment: 'Whether to expand all responses by default. Warning: this can cause performance issues on big documents',
+        }),
+        tagsSorter: optional(union([literal('alpha'), fn()]), {
+            typeComment: 'Function to sort tags',
+        }),
+        operationsSorter: optional(union([literal('alpha'), literal('method'), fn()]), {
+            typeComment: 'Function to sort operations',
+        }),
+        orderSchemaPropertiesBy: union([literal('alpha'), literal('preserve')], {
+            typeComment: 'Order the schema properties by',
+        }),
+        orderRequiredPropertiesFirst: boolean({
+            default: true,
+            typeComment: 'Sort the schema properties by required ones first',
+        }),
+    }),
+]);
+const OLD_PROXY_URL = 'https://api.scalar.com/request-proxy';
+const NEW_PROXY_URL = 'https://proxy.scalar.com';
+export const apiReferenceConfigurationWithSourceSchema = (rawInput) => {
+    const input = coerce(apiReferenceConfigurationSchema, rawInput);
+    if (input.hideDownloadButton) {
+        console.warn(`[DEPRECATED] You're using the deprecated 'hideDownloadButton' attribute. Use 'documentDownloadType: 'none'' instead.`);
+        input.documentDownloadType = 'none';
+    }
+    if (input.spec?.url) {
+        console.warn(`[DEPRECATED] You're using the deprecated 'spec.url' attribute. Remove the spec prefix and move the 'url' attribute to the top level.`);
+        input.url = input.spec.url;
+        delete input.spec;
+    }
+    if (input.spec?.content) {
+        console.warn(`[DEPRECATED] You're using the deprecated 'spec.content' attribute. Remove the spec prefix and move the 'content' attribute to the top level.`);
+        input.content = input.spec.content;
+        delete input.spec;
+    }
+    if (input.proxy) {
+        console.warn(`[DEPRECATED] You're using the deprecated 'proxy' attribute. Use 'proxyUrl' instead.`);
+        if (!input.proxyUrl) {
+            input.proxyUrl = input.proxy;
+        }
+        delete input.proxy;
+    }
+    if (input.proxyUrl === OLD_PROXY_URL) {
+        console.warn(`[DEPRECATED] Warning: configuration.proxyUrl points to our old proxy (${OLD_PROXY_URL}).`);
+        console.warn(`[DEPRECATED] We are overwriting the value and use the new proxy URL (${NEW_PROXY_URL}) instead.`);
+        console.warn(`[DEPRECATED] Action Required: You should manually update your configuration to use the new URL (${NEW_PROXY_URL}). Read more: https://github.com/scalar/scalar`);
+        input.proxyUrl = NEW_PROXY_URL;
+    }
+    if (input.showToolbar && input.showToolbar !== 'localhost') {
+        console.warn(`[DEPRECATED] You're using the deprecated 'showToolbar' attribute. Use 'showDeveloperTools' instead.`);
+        input.showDeveloperTools = input.showToolbar;
+        // @ts-expect-error - We're deleting the deprecated attribute
+        delete input.showToolbar;
+    }
+    return input;
+};

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

@@ -0,0 +1,31 @@
+import { type Static } from '@scalar/validation';
+declare const openApiExtensionSchema: import("@scalar/validation").ObjectSchema<{
+    name: import("@scalar/validation").StringSchema;
+    component: import("@scalar/validation").UnknownSchema;
+    renderer: import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnknownSchema>;
+}>;
+declare const viewsSchema: import("@scalar/validation").ObjectSchema<{
+    'content.end': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").ObjectSchema<{
+        component: import("@scalar/validation").UnknownSchema;
+        renderer: import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnknownSchema>;
+        props: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").AnySchema>>;
+    }>>>;
+}>;
+declare const lifecycleHooksSchema: import("@scalar/validation").ObjectSchema<{
+    onInit: import("@scalar/validation").OptionalSchema<import("@scalar/validation").FunctionSchema<({ config }: {
+        config: any;
+    }) => void>>;
+    onConfigChange: import("@scalar/validation").OptionalSchema<import("@scalar/validation").FunctionSchema<({ config }: {
+        config: any;
+    }) => void>>;
+    onDestroy: import("@scalar/validation").OptionalSchema<import("@scalar/validation").FunctionSchema<() => void>>;
+}>;
+export declare const apiReferencePluginSchema: import("@scalar/validation").FunctionSchema<() => {
+    name: string;
+    extensions: Static<typeof openApiExtensionSchema>[];
+    views: Static<typeof viewsSchema>;
+    hooks: Static<typeof lifecycleHooksSchema>;
+    apiClientPlugins: any[];
+}>;
+export {};
+//# sourceMappingURL=api-reference-plugin.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api-reference-plugin.d.ts","sourceRoot":"","sources":["../../src/api-reference/api-reference-plugin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAA6D,MAAM,oBAAoB,CAAA;AAE3G,QAAA,MAAM,sBAAsB;;;;EAY1B,CAAA;AAgBF,QAAA,MAAM,WAAW;;;;;;EAIf,CAAA;AAEF,QAAA,MAAM,oBAAoB;iHACS;QAAE,MAAM,EAAE,GAAG,CAAA;KAAE,KAAK,IAAI;yHAChB;QAAE,MAAM,EAAE,GAAG,CAAA;KAAE,KAAK,IAAI;6GACpC,IAAI;EACjC,CAAA;AAEF,eAAO,MAAM,wBAAwB,oDAE3B;IACJ,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,MAAM,CAAC,OAAO,sBAAsB,CAAC,EAAE,CAAA;IACnD,KAAK,EAAE,MAAM,CAAC,OAAO,WAAW,CAAC,CAAA;IACjC,KAAK,EAAE,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAA;IAC1C,gBAAgB,EAAE,GAAG,EAAE,CAAA;CACxB,CACA,CAAA"}

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

@@ -0,0 +1,34 @@
+import { any, array, fn, object, optional, record, string, unknown } from '@scalar/validation';
+const openApiExtensionSchema = object({
+    name: string({
+        typeComment: 'Name of specification extension property. Has to start with \`x-\`.',
+    }),
+    component: unknown({
+        typeComment: 'Vue component to render the specification extension',
+    }),
+    renderer: optional(unknown({
+        typeComment: 'Custom renderer to render the specification extension',
+    })),
+});
+const viewComponentSchema = object({
+    component: unknown({
+        typeComment: 'Vue component to render in the view',
+    }),
+    renderer: optional(unknown({
+        typeComment: 'Custom renderer to render the view component (e.g., ReactRenderer)',
+    })),
+    props: optional(record(string(), any()), {
+        typeComment: 'Additional props to pass to the component',
+    }),
+});
+const viewsSchema = object({
+    'content.end': optional(array(viewComponentSchema), {
+        typeComment: 'Components to render at specific views in the API Reference',
+    }),
+});
+const lifecycleHooksSchema = object({
+    onInit: optional(fn()),
+    onConfigChange: optional(fn()),
+    onDestroy: optional(fn()),
+});
+export const apiReferencePluginSchema = fn();

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

@@ -0,0 +1,27 @@
+export declare const baseConfigurationSchema: import("@scalar/validation").ObjectSchema<{
+    title: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    slug: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    authentication: import("@scalar/validation").OptionalSchema<import("@scalar/validation").AnySchema>;
+    baseServerURL: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    hideClientButton: import("@scalar/validation").BooleanSchema;
+    proxyUrl: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    oauth2RedirectUri: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    searchHotKey: import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnionSchema<(import("@scalar/validation").LiteralSchema<"a"> | import("@scalar/validation").LiteralSchema<"b"> | import("@scalar/validation").LiteralSchema<"c"> | import("@scalar/validation").LiteralSchema<"d"> | import("@scalar/validation").LiteralSchema<"e"> | import("@scalar/validation").LiteralSchema<"f"> | import("@scalar/validation").LiteralSchema<"g"> | import("@scalar/validation").LiteralSchema<"h"> | import("@scalar/validation").LiteralSchema<"i"> | import("@scalar/validation").LiteralSchema<"j"> | import("@scalar/validation").LiteralSchema<"k"> | import("@scalar/validation").LiteralSchema<"l"> | import("@scalar/validation").LiteralSchema<"m"> | import("@scalar/validation").LiteralSchema<"n"> | import("@scalar/validation").LiteralSchema<"o"> | import("@scalar/validation").LiteralSchema<"p"> | import("@scalar/validation").LiteralSchema<"q"> | import("@scalar/validation").LiteralSchema<"r"> | import("@scalar/validation").LiteralSchema<"s"> | import("@scalar/validation").LiteralSchema<"t"> | import("@scalar/validation").LiteralSchema<"u"> | import("@scalar/validation").LiteralSchema<"v"> | import("@scalar/validation").LiteralSchema<"w"> | import("@scalar/validation").LiteralSchema<"x"> | import("@scalar/validation").LiteralSchema<"y"> | import("@scalar/validation").LiteralSchema<"z">)[]>>;
+    servers: import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").AnySchema>>;
+    showSidebar: import("@scalar/validation").BooleanSchema;
+    showDeveloperTools: import("@scalar/validation").UnionSchema<(import("@scalar/validation").LiteralSchema<"localhost"> | import("@scalar/validation").LiteralSchema<"always"> | import("@scalar/validation").LiteralSchema<"never">)[]>;
+    showToolbar: import("@scalar/validation").UnionSchema<(import("@scalar/validation").LiteralSchema<"localhost"> | import("@scalar/validation").LiteralSchema<"always"> | import("@scalar/validation").LiteralSchema<"never">)[]>;
+    operationTitleSource: import("@scalar/validation").UnionSchema<(import("@scalar/validation").LiteralSchema<"summary"> | import("@scalar/validation").LiteralSchema<"path">)[]>;
+    theme: import("@scalar/validation").UnionSchema<(import("@scalar/validation").LiteralSchema<"default"> | import("@scalar/validation").LiteralSchema<"alternate"> | import("@scalar/validation").LiteralSchema<"moon"> | import("@scalar/validation").LiteralSchema<"purple"> | import("@scalar/validation").LiteralSchema<"solarized"> | import("@scalar/validation").LiteralSchema<"bluePlanet"> | import("@scalar/validation").LiteralSchema<"deepSpace"> | import("@scalar/validation").LiteralSchema<"saturn"> | import("@scalar/validation").LiteralSchema<"kepler"> | import("@scalar/validation").LiteralSchema<"elysiajs"> | import("@scalar/validation").LiteralSchema<"fastify"> | import("@scalar/validation").LiteralSchema<"mars"> | import("@scalar/validation").LiteralSchema<"laserwave"> | import("@scalar/validation").LiteralSchema<"none">)[]>;
+    _integration: import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnionSchema<(import("@scalar/validation").NullableSchema | import("@scalar/validation").LiteralSchema<"elysiajs"> | import("@scalar/validation").LiteralSchema<"fastify"> | import("@scalar/validation").LiteralSchema<"adonisjs"> | import("@scalar/validation").LiteralSchema<"astro"> | import("@scalar/validation").LiteralSchema<"docusaurus"> | import("@scalar/validation").LiteralSchema<"dotnet"> | import("@scalar/validation").LiteralSchema<"express"> | import("@scalar/validation").LiteralSchema<"fastapi"> | import("@scalar/validation").LiteralSchema<"go"> | import("@scalar/validation").LiteralSchema<"hono"> | import("@scalar/validation").LiteralSchema<"html"> | import("@scalar/validation").LiteralSchema<"laravel"> | import("@scalar/validation").LiteralSchema<"litestar"> | import("@scalar/validation").LiteralSchema<"nestjs"> | import("@scalar/validation").LiteralSchema<"nextjs"> | import("@scalar/validation").LiteralSchema<"nitro"> | import("@scalar/validation").LiteralSchema<"nuxt"> | import("@scalar/validation").LiteralSchema<"platformatic"> | import("@scalar/validation").LiteralSchema<"react"> | import("@scalar/validation").LiteralSchema<"rust"> | import("@scalar/validation").LiteralSchema<"svelte"> | import("@scalar/validation").LiteralSchema<"vue">)[]>>;
+    onRequestSent: import("@scalar/validation").OptionalSchema<import("@scalar/validation").FunctionSchema<(input: string) => void>>;
+    persistAuth: import("@scalar/validation").BooleanSchema;
+    telemetry: import("@scalar/validation").BooleanSchema;
+    externalUrls: import("@scalar/validation").ObjectSchema<{
+        dashboardUrl: import("@scalar/validation").StringSchema;
+        registryUrl: import("@scalar/validation").StringSchema;
+        proxyUrl: import("@scalar/validation").StringSchema;
+        apiBaseUrl: import("@scalar/validation").StringSchema;
+    }>;
+}>;
+//# sourceMappingURL=base-configuration.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"base-configuration.d.ts","sourceRoot":"","sources":["../../src/api-reference/base-configuration.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;mHA4HC,MAAM,KAAK,IAAI;;;;;;;;;EAYlD,CAAA"}

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

@@ -0,0 +1,136 @@
+import { any, array, boolean, fn, literal, nullable, object, optional, string, union } from '@scalar/validation';
+const externalUrlsSchema = object({
+    dashboardUrl: string({ default: 'https://dashboard.scalar.com' }),
+    registryUrl: string({ default: 'https://registry.scalar.com' }),
+    proxyUrl: string({ default: 'https://proxy.scalar.com' }),
+    apiBaseUrl: string({ default: 'https://api.scalar.com' }),
+}, {
+    typeComment: 'External service URLs used by Scalar packages',
+});
+export const baseConfigurationSchema = object({
+    title: optional(string(), {
+        typeComment: 'The title of the OpenAPI document.',
+    }),
+    slug: optional(string(), {
+        typeComment: 'The slug of the OpenAPI document used in the URL. If none is passed, the title will be used. If no title is used, it will just use the index.',
+    }),
+    authentication: optional(any(), {
+        typeComment: 'Prefill authentication',
+    }),
+    baseServerURL: optional(string(), {
+        typeComment: 'Base URL for the API server',
+    }),
+    hideClientButton: boolean({
+        default: false,
+        typeComment: 'Whether to hide the client button',
+    }),
+    proxyUrl: optional(string(), {
+        typeComment: 'URL to a request proxy for the API client',
+    }),
+    oauth2RedirectUri: optional(string(), {
+        typeComment: 'Default OAuth 2.0 redirect URI used to prefill auth flows in the API client.',
+    }),
+    searchHotKey: optional(union([
+        literal('a'),
+        literal('b'),
+        literal('c'),
+        literal('d'),
+        literal('e'),
+        literal('f'),
+        literal('g'),
+        literal('h'),
+        literal('i'),
+        literal('j'),
+        literal('k'),
+        literal('l'),
+        literal('m'),
+        literal('n'),
+        literal('o'),
+        literal('p'),
+        literal('q'),
+        literal('r'),
+        literal('s'),
+        literal('t'),
+        literal('u'),
+        literal('v'),
+        literal('w'),
+        literal('x'),
+        literal('y'),
+        literal('z'),
+    ]), {
+        typeComment: "Key used with CTRL/CMD to open the search modal (defaults to 'k' e.g. CMD+k)",
+    }),
+    servers: optional(array(any()), {
+        typeComment: 'List of OpenAPI server objects',
+    }),
+    showSidebar: boolean({
+        default: true,
+        typeComment: 'Whether to show the sidebar',
+    }),
+    showDeveloperTools: union([literal('localhost'), literal('always'), literal('never')], {
+        typeComment: 'Whether and when to show the developer tools.',
+    }),
+    showToolbar: union([literal('localhost'), literal('always'), literal('never')], {
+        typeComment: '@deprecated Use showDeveloperTools instead',
+    }),
+    operationTitleSource: union([literal('summary'), literal('path')], {
+        typeComment: 'Whether to use the operation summary or the operation path for the sidebar and search',
+    }),
+    theme: union([
+        literal('default'),
+        literal('alternate'),
+        literal('moon'),
+        literal('purple'),
+        literal('solarized'),
+        literal('bluePlanet'),
+        literal('deepSpace'),
+        literal('saturn'),
+        literal('kepler'),
+        literal('elysiajs'),
+        literal('fastify'),
+        literal('mars'),
+        literal('laserwave'),
+        literal('none'),
+    ], {
+        typeComment: 'A string to use one of the color presets',
+    }),
+    _integration: optional(union([
+        literal('adonisjs'),
+        literal('astro'),
+        literal('docusaurus'),
+        literal('dotnet'),
+        literal('elysiajs'),
+        literal('express'),
+        literal('fastapi'),
+        literal('fastify'),
+        literal('go'),
+        literal('hono'),
+        literal('html'),
+        literal('laravel'),
+        literal('litestar'),
+        literal('nestjs'),
+        literal('nextjs'),
+        literal('nitro'),
+        literal('nuxt'),
+        literal('platformatic'),
+        literal('react'),
+        literal('rust'),
+        literal('svelte'),
+        literal('vue'),
+        nullable(),
+    ]), {
+        typeComment: 'Integration type identifier',
+    }),
+    onRequestSent: optional(fn(), {
+        typeComment: 'onRequestSent is fired when a request is sent',
+    }),
+    persistAuth: boolean({
+        default: false,
+        typeComment: 'Whether to persist auth to local storage',
+    }),
+    telemetry: boolean({
+        default: true,
+        typeComment: 'Enables / disables telemetry',
+    }),
+    externalUrls: externalUrlsSchema,
+});

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

@@ -0,0 +1,14 @@
+export declare const htmlRenderingConfigurationSchema: import("@scalar/validation").ObjectSchema<{
+    /**
+     * The URL to the Scalar API Reference JS CDN.
+     *
+     * Use this to pin a specific version of the Scalar API Reference.
+     *
+     * @default https://cdn.jsdelivr.net/npm/@scalar/api-reference
+     *
+     * @example https://cdn.jsdelivr.net/npm/@scalar/api-reference@1.25.122
+     */
+    cdn: import("@scalar/validation").StringSchema;
+    pageTitle: import("@scalar/validation").StringSchema;
+}>;
+//# sourceMappingURL=html-rendering-configuration.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,18 @@
+import { object, string } from '@scalar/validation';
+export const htmlRenderingConfigurationSchema = object({
+    /**
+     * The URL to the Scalar API Reference JS CDN.
+     *
+     * Use this to pin a specific version of the Scalar API Reference.
+     *
+     * @default https://cdn.jsdelivr.net/npm/@scalar/api-reference
+     *
+     * @example https://cdn.jsdelivr.net/npm/@scalar/api-reference@1.25.122
+     */
+    cdn: string({
+        default: 'https://cdn.jsdelivr.net/npm/@scalar/api-reference',
+    }),
+    pageTitle: string({
+        default: 'Scalar API Reference',
+    }),
+});

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

@@ -0,0 +1,3 @@
+export { apiReferenceConfigurationSchema, apiReferenceConfigurationWithSourceSchema, } from './api-reference-configuration.js';
+export { htmlRenderingConfigurationSchema } from './html-rendering-configuration.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/api-reference/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,+BAA+B,EAC/B,yCAAyC,GAC1C,MAAM,+BAA+B,CAAA;AACtC,OAAO,EAAE,gCAAgC,EAAE,MAAM,gCAAgC,CAAA"}

package/dist/api-reference/index.js

@@ -0,0 +1,2 @@
+export { apiReferenceConfigurationSchema, apiReferenceConfigurationWithSourceSchema, } from './api-reference-configuration.js';
+export { htmlRenderingConfigurationSchema } from './html-rendering-configuration.js';

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

@@ -0,0 +1,22 @@
+/**
+ * A source is any potential document input used for API Reference
+ * and API Client integrations. Sources may be specified in the configuration
+ * or used independently. Some configurations may have multiple sources.
+ */
+export declare const sourceConfigurationSchema: import("@scalar/validation").ObjectSchema<{
+    default: import("@scalar/validation").BooleanSchema;
+    url: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    content: import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnionSchema<(import("@scalar/validation").StringSchema | import("@scalar/validation").NullableSchema | import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").AnySchema> | import("@scalar/validation").FunctionSchema<() => string | any>)[]>>;
+    title: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    slug: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    spec: import("@scalar/validation").OptionalSchema<import("@scalar/validation").ObjectSchema<{
+        url: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        content: import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnionSchema<(import("@scalar/validation").StringSchema | import("@scalar/validation").NullableSchema | import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").AnySchema> | import("@scalar/validation").FunctionSchema<() => string | any>)[]>>;
+    }>>;
+    agent: import("@scalar/validation").OptionalSchema<import("@scalar/validation").ObjectSchema<{
+        key: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        disabled: import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+        hideAddApi: import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+    }>>;
+}>;
+//# sourceMappingURL=source-configuration.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"source-configuration.d.ts","sourceRoot":"","sources":["../../src/api-reference/source-configuration.ts"],"names":[],"mappings":"AAYA;;;;GAIG;AACH,eAAO,MAAM,yBAAyB;;;8WAP+C,MAAM,GAAG,GAAG;;;;;kXAAZ,MAAM,GAAG,GAAG;;;;;;;EA8C/F,CAAA"}

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

@@ -0,0 +1,45 @@
+import { any, boolean, fn, nullable, object, optional, record, string, union } from '@scalar/validation';
+/**
+ * The content of an OpenAPI document. Accepts any of:
+ *  - a raw string (YAML or JSON),
+ *  - `null` to explicitly opt out of inline content,
+ *  - a plain object representing the parsed document, or
+ *  - a function that returns either of the above (sync or async resolution
+ *    happens further downstream).
+ */
+const contentSchema = union([string(), nullable(), record(string(), any()), fn()]);
+/**
+ * A source is any potential document input used for API Reference
+ * and API Client integrations. Sources may be specified in the configuration
+ * or used independently. Some configurations may have multiple sources.
+ */
+export const sourceConfigurationSchema = object({
+    default: boolean({ default: false }),
+    url: optional(string(), {
+        typeComment: 'URL to an OpenAPI/Swagger document',
+    }),
+    content: optional(contentSchema, {
+        typeComment: 'Directly embed the OpenAPI document. Can be a string, object, function returning an object, or null. It is recommended to pass a URL instead of content.',
+    }),
+    title: optional(string(), {
+        typeComment: 'The title of the OpenAPI document. @deprecated Please move `title` to the top level and remove the `spec` prefix.',
+    }),
+    slug: optional(string(), {
+        typeComment: 'The slug of the OpenAPI document used in the URL. @deprecated Please move `slug` to the top level and remove the `spec` prefix.',
+    }),
+    spec: optional(object({
+        url: optional(string()),
+        content: optional(contentSchema),
+    }), {
+        typeComment: '@deprecated Use `url` and `content` on the top level instead.',
+    }),
+    agent: optional(object({
+        key: optional(string()),
+        disabled: optional(boolean()),
+        hideAddApi: optional(boolean(), {
+            typeComment: 'When true, hide the control to add more APIs in the agent chat. Only preloaded/registry documents are shown; the public API list is not offered.',
+        }),
+    }), {
+        typeComment: 'Agent Scalar configuration',
+    }),
+});

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@scalar/schemas",
+  "description": "Schemas for Scalar packages",
+  "license": "MIT",
+  "author": "Scalar (https://github.com/scalar)",
+  "homepage": "https://github.com/scalar/scalar",
+  "bugs": "https://github.com/scalar/scalar/issues/new/choose",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/scalar/scalar.git",
+    "directory": "packages/schemas"
+  },
+  "keywords": [
+    "schemas",
+    "scalar"
+  ],
+  "version": "0.2.0",
+  "engines": {
+    "node": ">=22"
+  },
+  "type": "module",
+  "exports": {
+    "./api-reference": {
+      "import": "./dist/api-reference/index.js",
+      "types": "./dist/api-reference/index.d.ts",
+      "default": "./dist/api-reference/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "CHANGELOG.md"
+  ],
+  "dependencies": {
+    "@scalar/validation": "0.5.0"
+  },
+  "devDependencies": {
+    "vitest": "4.1.0",
+    "@scalar/types": "0.11.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"
+  }
+}