redoc 2.5.2 → 3.0.0-rc.0

package/bundle/redoc.d.ts

@@ -0,0 +1,683 @@
+import type { ComponentType } from 'react';
+import type { ConfigFunction } from '@markdoc/markdoc/dist/src/types';
+import { JSX } from 'react/jsx-runtime';
+import type { LayoutVariant } from '@redocly/config';
+import type { PropsWithChildren } from 'react';
+import type { ReactElement } from 'react';
+import type { RedocConfig } from '@redocly/config';
+import type { Schema } from '@markdoc/markdoc/dist/src/types';
+import { ServerStyleSheet } from 'styled-components';
+
+declare interface CodeSamplesConfig {
+    languages: {
+        lang: 'Payload' | string;
+        label?: string;
+    }[];
+}
+
+export declare function convertSwagger2OpenAPI(spec: GenericObject): Promise<OpenAPIDefinition>;
+
+declare type DownloadUrlsConfig = {
+    title?: string;
+    url: string;
+}[];
+
+declare interface McpPrompt {
+    name: string;
+    title?: string;
+    description: string;
+    arguments: McpPromptArgument[];
+}
+
+declare interface McpPromptArgument {
+    name: string;
+    description: string;
+    required: boolean;
+}
+
+declare interface McpResource {
+    name: string;
+    title?: string;
+    description?: string;
+    uri: string;
+    mimeType: string;
+    security?: OpenAPISecurityRequirement[];
+    tags?: string[];
+    'x-badges'?: OpenAPIXBadges[];
+}
+
+declare interface McpTool {
+    name: string;
+    title?: string;
+    description?: string;
+    inputSchema: OpenAPISchema;
+    outputSchema?: OpenAPISchema;
+    security?: OpenAPISecurityRequirement[];
+    tags?: string[];
+    'x-badges'?: OpenAPIXBadges[];
+}
+
+declare type MergedOpenAPISchema = OpenAPISchema & {
+    'x-refsStack'?: string[];
+    'x-parentRefs'?: string[];
+    'x-circular-ref'?: boolean;
+    'x-complex'?: boolean;
+    absolutePointer?: string;
+};
+
+declare interface OpenAPICallback {
+    [name: string]: OpenAPIPath;
+}
+
+declare interface OpenAPIComponents {
+    schemas?: {
+        [name: string]: Referenced<OpenAPISchema>;
+    };
+    responses?: {
+        [name: string]: Referenced<OpenAPIResponse>;
+    };
+    parameters?: {
+        [name: string]: Referenced<OpenAPIParameter>;
+    };
+    examples?: {
+        [name: string]: Referenced<OpenAPIExample>;
+    };
+    requestBodies?: {
+        [name: string]: Referenced<OpenAPIRequestBody>;
+    };
+    headers?: {
+        [name: string]: Referenced<OpenAPIHeader>;
+    };
+    securitySchemes?: {
+        [name: string]: Referenced<OpenAPISecurityScheme>;
+    };
+    links?: {
+        [name: string]: Referenced<OpenAPILink>;
+    };
+    callbacks?: {
+        [name: string]: Referenced<OpenAPICallback>;
+    };
+}
+
+declare interface OpenAPIContact {
+    name?: string;
+    url?: string;
+    email?: string;
+}
+
+declare interface OpenAPIDefinition {
+    openapi: string;
+    info: OpenAPIInfo;
+    servers?: OpenAPIServer[];
+    paths: OpenAPIPaths;
+    components?: OpenAPIComponents;
+    security?: OpenAPISecurityRequirement[];
+    tags?: OpenAPITag[];
+    externalDocs?: OpenAPIExternalDocumentation;
+    webhooks?: OpenAPIPaths;
+    'x-mcp'?: OpenAPIMcp;
+    'x-webhooks'?: OpenAPIPaths;
+    'x-tagGroups'?: Array<{
+        name: string;
+        tags: Array<string>;
+    }>;
+}
+
+declare interface OpenAPIDiscriminator {
+    propertyName: string;
+    mapping?: {
+        [name: string]: string;
+    };
+    'x-explicitMappingOnly'?: boolean;
+}
+
+declare interface OpenAPIEncoding {
+    contentType: string;
+    headers?: {
+        [name: string]: Referenced<OpenAPIHeader>;
+    };
+    style: OpenAPIParameterStyle;
+    explode: boolean;
+    allowReserved: boolean;
+}
+
+declare interface OpenAPIExample extends ParsedDescriptionWithSummary {
+    value: any;
+    summary?: string;
+    description?: string;
+    externalValue?: string;
+}
+
+declare interface OpenAPIExternalDocumentation extends ParsedDescription {
+    description?: string;
+    url: string;
+}
+
+declare type OpenAPIHeader = Omit<OpenAPIParameter, 'in' | 'name'>;
+
+declare interface OpenAPIInfo extends ParsedDescriptionWithSummary {
+    title: string;
+    version: string;
+    description?: string;
+    summary?: string;
+    termsOfService?: string;
+    contact?: OpenAPIContact;
+    license?: OpenAPILicense;
+    externalDocs?: OpenAPIExternalDocumentation;
+    'x-logo'?: XLogo;
+    'x-metadata'?: XMetadata;
+    'x-seo'?: XSEO;
+}
+
+declare interface OpenAPILicense {
+    name: string;
+    url?: string;
+    identifier?: string;
+}
+
+declare interface OpenAPILink {
+    $ref?: string;
+}
+
+declare interface OpenAPIMcp {
+    protocolVersion: string;
+    capabilities: {
+        [key: string]: boolean | {
+            listChanged?: boolean;
+            subscribe?: boolean;
+            [key: string]: unknown;
+        };
+    };
+    servers: OpenAPIServer[];
+    tools: McpTool[];
+    resources: McpResource[];
+    prompts: McpPrompt[];
+}
+
+declare interface OpenAPIMediaType {
+    schema?: Referenced<OpenAPISchema>;
+    example?: any;
+    examples?: {
+        [name: string]: Referenced<OpenAPIExample>;
+    };
+    encoding?: {
+        [field: string]: OpenAPIEncoding;
+    };
+}
+
+declare interface OpenAPIOperation extends ParsedDescriptionWithSummary {
+    tags?: string[];
+    summary?: string;
+    description?: string;
+    externalDocs?: OpenAPIExternalDocumentation;
+    operationId?: string;
+    parameters?: Array<Referenced<OpenAPIParameter>>;
+    requestBody?: Referenced<OpenAPIRequestBody>;
+    responses: OpenAPIResponses;
+    callbacks?: {
+        [name: string]: Referenced<OpenAPICallback>;
+    };
+    deprecated?: boolean;
+    security?: OpenAPISecurityRequirement[];
+    servers?: OpenAPIServer[];
+    'x-codeSamples'?: OpenAPIXCodeSample[];
+    'x-badges'?: OpenAPIXBadges[];
+}
+
+declare interface OpenAPIParameter extends ParsedDescription {
+    name: string;
+    in?: OpenAPIParameterLocation;
+    description?: string;
+    required?: boolean;
+    deprecated?: boolean;
+    allowEmptyValue?: boolean;
+    style?: OpenAPIParameterStyle;
+    explode?: boolean;
+    allowReserved?: boolean;
+    schema?: Referenced<OpenAPISchema>;
+    example?: any;
+    examples?: {
+        [media: string]: Referenced<OpenAPIExample>;
+    };
+    content?: {
+        [media: string]: OpenAPIMediaType;
+    };
+    encoding?: Record<string, OpenAPIEncoding>;
+    const?: any;
+}
+
+declare type OpenAPIParameterLocation = 'query' | 'header' | 'path' | 'cookie';
+
+declare type OpenAPIParameterStyle = 'matrix' | 'label' | 'form' | 'simple' | 'spaceDelimited' | 'pipeDelimited' | 'deepObject';
+
+declare class OpenAPIParser {
+    private options;
+    definitionUrl?: string;
+    definition: OpenAPIDefinition;
+    private readonly allowMergeRefs;
+    constructor(definition: OpenAPIDefinition, definitionUrl?: string, options?: Options & {
+        versionId?: string;
+    });
+    validate(spec: GenericObject): void;
+    /**
+     * get spec part by JsonPointer ($ref)
+     */
+    byRef: <T>(ref: string) => T | undefined;
+    /**
+     * checks if the object is OpenAPI reference (contains $ref property)
+     */
+    isRef<T>(obj: OpenAPIRef | T): obj is OpenAPIRef;
+    /**
+     * Resolve given reference object or return as is if it is not a reference
+     * @param obj object to dereference
+     * @param baseRefsStack
+     * @param mergeAsAllOf
+     */
+    deref<T>(obj: OpenAPIRef | T, baseRefsStack?: string[], mergeAsAllOf?: boolean, level?: number): {
+        resolved: T;
+        refsStack: string[];
+    };
+    mergeRefs<T>(ref: OpenAPIRef, resolved: T, mergeAsAllOf: boolean): T;
+    /**
+     * Merge allOf constraints.
+     * @param schema schema with allOF
+     * @param $ref pointer of the schema
+     * @param refsStack
+     * @param absolutePointer
+     */
+    mergeAllOf(schema: MergedOpenAPISchema, $ref: string | undefined, refsStack: string[], absolutePointer?: string, level?: number): MergedOpenAPISchema;
+    /**
+     * Find all derived definitions among #/components/schemas from any of $refs
+     * returns map of definition pointer to definition name
+     * @param $refs array of references to find derived from
+     */
+    findDerived($refs: string[]): Record<string, string[] | string>;
+    private hoistOneOfs;
+}
+
+declare interface OpenAPIPath extends Partial<OpenAPIRef>, ParsedDescriptionWithSummary {
+    summary?: string;
+    description?: string;
+    get?: OpenAPIOperation;
+    put?: OpenAPIOperation;
+    post?: OpenAPIOperation;
+    delete?: OpenAPIOperation;
+    options?: OpenAPIOperation;
+    head?: OpenAPIOperation;
+    patch?: OpenAPIOperation;
+    trace?: OpenAPIOperation;
+    servers?: OpenAPIServer[];
+    parameters?: Array<Referenced<OpenAPIParameter>>;
+}
+
+declare interface OpenAPIPaths {
+    [path: string]: OpenAPIPath;
+}
+
+declare interface OpenAPIRef extends ParsedDescriptionWithSummary {
+    $ref: string;
+    'x-refsStack'?: string[];
+    summary?: string;
+    description?: string;
+}
+
+declare interface OpenAPIRequestBody extends ParsedDescription {
+    $ref?: string;
+    description?: string;
+    required?: boolean;
+    content?: {
+        [mime: string]: OpenAPIMediaType;
+    };
+    'x-examples'?: {
+        [mime: string]: {
+            [name: string]: Referenced<OpenAPIExample>;
+        };
+    };
+    'x-example'?: {
+        [mime: string]: any;
+    };
+}
+
+declare interface OpenAPIResponse extends ParsedDescription {
+    description?: string;
+    headers?: {
+        [name: string]: Referenced<OpenAPIHeader>;
+    };
+    content?: {
+        [mime: string]: OpenAPIMediaType;
+    };
+    links?: {
+        [name: string]: Referenced<OpenAPILink>;
+    };
+    $ref?: string;
+    'x-examples'?: {
+        [mime: string]: {
+            [name: string]: Referenced<OpenAPIExample>;
+        };
+    };
+    'x-example'?: {
+        [mime: string]: any;
+    };
+}
+
+declare interface OpenAPIResponses {
+    [code: string]: OpenAPIResponse;
+}
+
+declare interface OpenAPISchema extends ParsedDescription {
+    $ref?: string;
+    type?: string | string[];
+    properties?: {
+        [name: string]: OpenAPISchema;
+    };
+    patternProperties?: {
+        [name: string]: OpenAPISchema;
+    };
+    additionalProperties?: boolean | OpenAPISchema;
+    unevaluatedProperties?: boolean | OpenAPISchema;
+    description?: string;
+    default?: any;
+    items?: OpenAPISchema | OpenAPISchema[] | boolean;
+    required?: string[];
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    deprecated?: boolean;
+    format?: string;
+    externalDocs?: OpenAPIExternalDocumentation;
+    discriminator?: OpenAPIDiscriminator;
+    nullable?: boolean;
+    oneOf?: OpenAPISchema[];
+    anyOf?: OpenAPISchema[];
+    allOf?: OpenAPISchema[];
+    not?: OpenAPISchema;
+    title?: string;
+    multipleOf?: number;
+    maximum?: number;
+    exclusiveMaximum?: boolean | number;
+    minimum?: number;
+    exclusiveMinimum?: boolean | number;
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string;
+    maxItems?: number;
+    minItems?: number;
+    uniqueItems?: boolean;
+    maxProperties?: number;
+    minProperties?: number;
+    enum?: any[];
+    example?: any;
+    examples?: any[];
+    const?: string;
+    contentEncoding?: string;
+    contentMediaType?: string;
+    if?: OpenAPISchema;
+    else?: OpenAPISchema;
+    then?: OpenAPISchema;
+    prefixItems?: OpenAPISchema[];
+    additionalItems?: OpenAPISchema | boolean;
+    xml?: XMLObject;
+}
+
+declare interface OpenAPISecurityRequirement {
+    [name: string]: string[];
+}
+
+declare interface OpenAPISecurityScheme extends ParsedDescription {
+    type: 'apiKey' | 'http' | 'oauth2' | 'openIdConnect';
+    description?: string;
+    name?: string;
+    in?: 'query' | 'header' | 'cookie';
+    scheme?: string;
+    bearerFormat: string;
+    'x-defaultClientId'?: string;
+    deprecated?: boolean;
+    oauth2MetadataUrl?: string;
+    flows: {
+        implicit?: {
+            refreshUrl?: string;
+            scopes: Record<string, string>;
+            authorizationUrl: string;
+            'x-defaultClientId'?: string;
+        };
+        deviceAuthorization?: {
+            deviceAuthorizationUrl: string;
+            scopes: Record<string, string>;
+            tokenUrl: string;
+            refreshUrl?: string;
+            'x-defaultClientId'?: string;
+        };
+        password?: {
+            refreshUrl?: string;
+            scopes: Record<string, string>;
+            tokenUrl: string;
+            'x-defaultClientId'?: string;
+        };
+        clientCredentials?: {
+            refreshUrl?: string;
+            scopes: Record<string, string>;
+            tokenUrl: string;
+            'x-defaultClientId'?: string;
+        };
+        authorizationCode?: {
+            refreshUrl?: string;
+            scopes: Record<string, string>;
+            authorizationUrl: string;
+            tokenUrl: string;
+            'x-defaultClientId'?: string;
+        };
+    };
+    openIdConnectUrl?: string;
+}
+
+declare interface OpenAPIServer extends ParsedDescription {
+    url: string;
+    description?: string;
+    name?: string;
+    variables?: OpenAPIServerVariables;
+}
+
+declare interface OpenAPIServerVariable extends ParsedDescription {
+    enum?: string[];
+    default: string;
+    description?: string;
+}
+
+declare interface OpenAPIServerVariables {
+    [name: string]: OpenAPIServerVariable;
+}
+
+declare interface OpenAPITag extends ParsedDescription {
+    name: string;
+    description?: string;
+    externalDocs?: OpenAPIExternalDocumentation;
+    'x-displayName'?: string;
+}
+
+declare interface OpenAPIXBadges {
+    name: string;
+    color?: string;
+    position?: 'before' | 'after';
+}
+
+declare interface OpenAPIXCodeSample extends Sample {
+    source: string;
+}
+
+declare type OperationStore = {
+    activeExampleName?: string;
+    activeOneOf: {
+        [pointer: string]: number;
+    };
+    activeSecuritySchemeIds?: string[];
+    requestValues: {
+        [field: string]: any;
+    };
+    request: {
+        expandedAll?: boolean;
+    };
+    response: {
+        expandedAll?: boolean;
+    };
+};
+
+declare interface Options {
+    scrollYOffset: () => number;
+    sortRequiredPropsFirst: boolean;
+    sanitize: boolean;
+    hideDownloadButtons: boolean | null;
+    hideSidebar: boolean;
+    downloadUrls?: DownloadUrlsConfig;
+    onlyRequiredInSamples: boolean;
+    generatedSamplesMaxDepth: number;
+    showExtensions: string[] | boolean;
+    hideSchemaTitles: boolean;
+    jsonSamplesExpandLevel: number;
+    schemasExpansionLevel: number | undefined;
+    maxDisplayedEnumValues: number;
+    ignoreNamedSchemas: Set<string>;
+    schemaDefinitionsTagName?: string;
+    layout: LayoutVariant;
+    skipBundle: boolean;
+    routingBasePath: string;
+    codeSamples: CodeSamplesConfig;
+    hidePropertiesPrefix: boolean;
+    markdocOptions?: {
+        tags: Record<string, Schema>;
+        nodes: Record<string, Schema>;
+        components: Record<string, ComponentType>;
+        variables?: Record<string, any>;
+        partials?: Record<string, any>;
+        functions?: Record<string, ConfigFunction>;
+    };
+}
+
+declare interface ParsedDescription {
+    'x-parsed-md-description'?: GenericObject;
+}
+
+declare interface ParsedDescriptionWithSummary extends ParsedDescription {
+    'x-parsed-md-summary'?: GenericObject;
+}
+
+export declare function Redoc({ onLoaded, children, store, withCommonStyles, disableTelemetry: disableTelemetryProps, router: routerProps, typeOfUsage, }: PropsWithChildren<Partial<RedoclyOpenAPIDocsProps>>): JSX.Element;
+
+declare interface RedoclyOpenAPIDocsProps extends RoutingProps, StoreProps {
+    onLoaded?: () => void;
+    store?: StoreProviderProps;
+    withCommonStyles?: boolean;
+    disableTelemetry?: boolean;
+    typeOfUsage?: 'html' | 'cli' | 'react' | 'docker';
+}
+
+export declare function RedocStandalone({ definition, definitionUrl, disableTelemetry, options, activeItemId, activeSampleLanguage, activeDeepLink, router, typeOfUsage, }: RedocStandaloneProps): ReactElement;
+
+export declare interface RedocStandaloneProps {
+    definition?: Record<string, any>;
+    definitionUrl?: string;
+    disableTelemetry?: boolean;
+    options?: RedocConfig;
+    activeItemId?: string;
+    activeSampleLanguage?: string;
+    activeDeepLink?: string;
+    router?: 'hash' | 'history';
+    typeOfUsage?: 'html' | 'cli' | 'react' | 'docker';
+}
+
+declare type Referenced<T> = T | OpenAPIRef;
+
+declare type RouterType = 'history' | 'memory' | 'hash';
+
+declare interface RoutingProps {
+    /**
+     * Only applies when using `history`-based routing. (See the `router` prop.) Specifies the base path under which
+     * all API component controlled pages are located. The host must route any location under this path to the API component.
+     */
+    basePath?: string;
+    /**
+     * Only applies when using `static`-based routing. (See the `router` prop.) Specifies the current static path
+     * that is being rendered by the StaticRouter, which allows us to properly render the currently active route
+     * on the server and already render the content instead of sending an empty page to the client.
+     */
+    staticRouterPath?: string;
+    /**
+     * Which routing solution to use when the user navigates using the table of contents.
+     * Only applies when using the *sidebar* layout.
+     *
+     * - **`history`** - The table of contents pushes entries onto the navigation stack, e.g. `location.pushState`.
+     *   This requires that the host routes any location under `basePath` (see `basePath` prop) to the API component.
+     * - **`hash`** - Navigation happens using hash-fragments (`/some/page#these-fragments-here`).
+     *   This still allows the user to link to individual pages without requiring the more complex routing setup `history` needs.
+     * - **`memory`** - Internal navigation does not change the host `location` at all.
+     *   This works in every scenario, but it lacks the important feature of being able to link to individual pages.
+     * - **`static`** - Renders a single static page for the provided `staticRouterPath`.
+     *   This can be used when the page is being rendered on the server (either SSR or SSG) to pre-generate the
+     *   markup of the page, which can be rehydrated on the client. This can reduce the amount of time spent rendering
+     *   the page on the client.
+     *
+     *   @default "history"
+     */
+    router?: RouterType;
+    /**
+     * Either uses the app's own or the parent router ex. (Portal).
+     *
+     *   @default false
+     */
+    disableRouter?: boolean;
+}
+
+declare interface Sample {
+    lang: string;
+    label?: string;
+}
+
+export { ServerStyleSheet }
+
+declare interface StoreProps {
+    options: Options;
+    layout: LayoutVariant;
+    collapsedSidebar: boolean;
+    parser: OpenAPIParser;
+}
+
+declare interface StoreProviderProps {
+    options?: RedocConfig;
+    definition: OpenAPIDefinition;
+    definitionUrl?: string;
+    router?: 'hash' | 'history' | 'memory';
+    disableTelemetry?: boolean;
+    typeOfUsage?: 'html' | 'cli' | 'react' | 'docker';
+    withState?: {
+        activeMimeName?: string;
+        layout?: LayoutVariant;
+        operation?: {
+            pointer: string;
+            state: Partial<OperationStore>;
+        };
+    };
+}
+
+declare interface XLogo {
+    url?: string;
+    backgroundColor?: string;
+    altText?: string;
+    href?: string;
+}
+
+declare interface XMetadata {
+    apiId?: string;
+    [key: string]: unknown;
+}
+
+declare interface XMLObject {
+    name?: string;
+    namespace?: string;
+    prefix?: string;
+    attribute?: boolean;
+    wrapped?: boolean;
+}
+
+declare interface XSEO {
+    title?: string;
+}
+
+export { }