redoc 2.5.2 → 3.0.0-rc.0

package/typings/services/models/Group.model.d.ts

@@ -1,25 +0,0 @@
-import type { OpenAPIExternalDocumentation, OpenAPITag } from '../../types';
-import type { ContentItemModel, IMenuItem, MarkdownHeading, MenuItemGroupType } from '../types';
-/**
- * Operations Group model ready to be used by components
- */
-export declare class GroupModel implements IMenuItem {
-    id: string;
-    absoluteIdx?: number;
-    name: string;
-    sidebarLabel: string;
-    description?: string;
-    type: MenuItemGroupType;
-    items: ContentItemModel[];
-    parent?: GroupModel;
-    externalDocs?: OpenAPIExternalDocumentation;
-    active: boolean;
-    expanded: boolean;
-    depth: number;
-    level: number;
-    constructor(type: MenuItemGroupType, tagOrGroup: OpenAPITag | MarkdownHeading, parent?: GroupModel);
-    activate(): void;
-    expand(): void;
-    collapse(): void;
-    deactivate(): void;
-}

package/typings/services/models/MediaContent.d.ts

@@ -1,24 +0,0 @@
-import type { OpenAPIMediaType } from '../../types';
-import { MediaTypeModel } from './MediaType';
-import type { OpenAPIParser } from '../OpenAPIParser';
-import type { RedocNormalizedOptions } from '../RedocNormalizedOptions';
-/**
- * MediaContent model ready to be sued by React components
- * Contains multiple MediaTypes and keeps track of the currently active one
- */
-export declare class MediaContentModel {
-    isRequestType: boolean;
-    mediaTypes: MediaTypeModel[];
-    activeMimeIdx: number;
-    /**
-     * @param isRequestType needed to know if skipe RO/RW fields in objects
-     */
-    constructor(parser: OpenAPIParser, info: Record<string, OpenAPIMediaType>, isRequestType: boolean, options: RedocNormalizedOptions);
-    /**
-     * Set active media type by index
-     * @param idx media type index
-     */
-    activate(idx: number): void;
-    get active(): MediaTypeModel;
-    get hasSample(): boolean;
-}

package/typings/services/models/MediaType.d.ts

@@ -1,20 +0,0 @@
-import type { OpenAPIMediaType } from '../../types';
-import type { RedocNormalizedOptions } from '../RedocNormalizedOptions';
-import { SchemaModel } from './Schema';
-import type { OpenAPIParser } from '../OpenAPIParser';
-import { ExampleModel } from './Example';
-export declare class MediaTypeModel {
-    examples?: {
-        [name: string]: ExampleModel;
-    };
-    schema?: SchemaModel;
-    name: string;
-    isRequestType: boolean;
-    onlyRequiredInSamples: boolean;
-    generatedSamplesMaxDepth: number;
-    /**
-     * @param isRequestType needed to know if skipe RO/RW fields in objects
-     */
-    constructor(parser: OpenAPIParser, name: string, isRequestType: boolean, info: OpenAPIMediaType, options: RedocNormalizedOptions);
-    generateExample(parser: OpenAPIParser, info: OpenAPIMediaType): void;
-}

package/typings/services/models/Operation.d.ts

@@ -1,72 +0,0 @@
-import { GroupModel } from './Group.model';
-import { SecurityRequirementModel } from './SecurityRequirement';
-import { CallbackModel } from './Callback';
-import { FieldModel } from './Field';
-import { RequestBodyModel } from './RequestBody';
-import { ResponseModel } from './Response';
-import type { OpenAPIExternalDocumentation, OpenAPIServer, OpenAPIXBadges, OpenAPIXCodeSample } from '../../types';
-import type { OpenAPIParser } from '../OpenAPIParser';
-import type { RedocNormalizedOptions } from '../RedocNormalizedOptions';
-import type { MediaContentModel } from './MediaContent';
-import type { ContentItemModel, ExtendedOpenAPIOperation, IMenuItem } from '../types';
-export interface XPayloadSample {
-    lang: 'payload';
-    label: string;
-    requestBodyContent: MediaContentModel;
-    source: string;
-}
-export declare function isPayloadSample(sample: XPayloadSample | OpenAPIXCodeSample): sample is XPayloadSample;
-/**
- * Operation model ready to be used by components
- */
-export declare class OperationModel implements IMenuItem {
-    private parser;
-    private operationSpec;
-    private options;
-    id: string;
-    absoluteIdx?: number;
-    name: string;
-    sidebarLabel: string;
-    description?: string;
-    type: "operation";
-    parent?: GroupModel;
-    externalDocs?: OpenAPIExternalDocumentation;
-    items: ContentItemModel[];
-    depth: number;
-    ready?: boolean;
-    active: boolean;
-    expanded: boolean;
-    pointer: string;
-    operationId?: string;
-    operationHash?: string;
-    httpVerb: string;
-    badges: OpenAPIXBadges[];
-    deprecated: boolean;
-    path: string;
-    servers: OpenAPIServer[];
-    security: SecurityRequirementModel[];
-    extensions: Record<string, any>;
-    isCallback: boolean;
-    isWebhook: boolean;
-    isEvent: boolean;
-    constructor(parser: OpenAPIParser, operationSpec: ExtendedOpenAPIOperation, parent: GroupModel | undefined, options: RedocNormalizedOptions, isCallback?: boolean);
-    /**
-     * set operation as active (used by side menu)
-     */
-    activate(): void;
-    /**
-     * set operation as inactive (used by side menu)
-     */
-    deactivate(): void;
-    /**
-     * Toggle expansion in middle panel (for callbacks, which are operations)
-     */
-    toggle(): void;
-    expand(): void;
-    collapse(): void;
-    get requestBody(): RequestBodyModel | undefined;
-    get codeSamples(): (OpenAPIXCodeSample | XPayloadSample)[];
-    get parameters(): FieldModel[];
-    get responses(): ResponseModel[];
-    get callbacks(): CallbackModel[];
-}

package/typings/services/models/RequestBody.d.ts

@@ -1,17 +0,0 @@
-import type { OpenAPIRequestBody, Referenced } from '../../types';
-import type { OpenAPIParser } from '../OpenAPIParser';
-import type { RedocNormalizedOptions } from '../RedocNormalizedOptions';
-import { MediaContentModel } from './MediaContent';
-type RequestBodyProps = {
-    parser: OpenAPIParser;
-    infoOrRef: Referenced<OpenAPIRequestBody>;
-    options: RedocNormalizedOptions;
-    isEvent: boolean;
-};
-export declare class RequestBodyModel {
-    description: string;
-    required?: boolean;
-    content?: MediaContentModel;
-    constructor({ parser, infoOrRef, options, isEvent }: RequestBodyProps);
-}
-export {};

package/typings/services/models/Response.d.ts

@@ -1,26 +0,0 @@
-import type { OpenAPIResponse, Referenced } from '../../types';
-import type { OpenAPIParser } from '../OpenAPIParser';
-import type { RedocNormalizedOptions } from '../RedocNormalizedOptions';
-import { FieldModel } from './Field';
-import { MediaContentModel } from './MediaContent';
-type ResponseProps = {
-    parser: OpenAPIParser;
-    code: string;
-    defaultAsError: boolean;
-    infoOrRef: Referenced<OpenAPIResponse>;
-    options: RedocNormalizedOptions;
-    isEvent: boolean;
-};
-export declare class ResponseModel {
-    expanded: boolean;
-    content?: MediaContentModel;
-    code: string;
-    summary: string;
-    description: string;
-    type: string;
-    headers: FieldModel[];
-    extensions: Record<string, any>;
-    constructor({ parser, code, defaultAsError, infoOrRef, options, isEvent: isRequest, }: ResponseProps);
-    toggle(): void;
-}
-export {};

package/typings/services/models/Schema.d.ts

@@ -1,62 +0,0 @@
-import type { OpenAPIExternalDocumentation, OpenAPISchema, Referenced } from '../../types';
-import type { OpenAPIParser } from '../OpenAPIParser';
-import type { RedocNormalizedOptions } from '../RedocNormalizedOptions';
-import { FieldModel } from './Field';
-import { MergedOpenAPISchema } from '../types';
-export declare class SchemaModel {
-    private options;
-    private refsStack;
-    pointer: string;
-    type: string | string[];
-    displayType: string;
-    typePrefix: string;
-    title: string;
-    description: string;
-    externalDocs?: OpenAPIExternalDocumentation;
-    isPrimitive: boolean;
-    isCircular: boolean;
-    format?: string;
-    displayFormat?: string;
-    nullable: boolean;
-    deprecated: boolean;
-    pattern?: string;
-    example?: any;
-    examples?: any[];
-    enum: any[];
-    default?: any;
-    readOnly: boolean;
-    writeOnly: boolean;
-    constraints: string[];
-    fields?: FieldModel[];
-    items?: SchemaModel;
-    oneOf?: SchemaModel[];
-    oneOfType: string;
-    discriminatorProp: string;
-    activeOneOf: number;
-    rawSchema: OpenAPISchema;
-    schema: MergedOpenAPISchema;
-    extensions?: Record<string, any>;
-    'x-enumDescriptions': {
-        [name: string]: string;
-    };
-    const: any;
-    contentEncoding?: string;
-    contentMediaType?: string;
-    minItems?: number;
-    maxItems?: number;
-    /**
-     * @param isChild if schema discriminator Child
-     * When true forces dereferencing in allOfs even if circular
-     */
-    constructor(parser: OpenAPIParser, schemaOrRef: Referenced<OpenAPISchema>, pointer: string, options: RedocNormalizedOptions, isChild?: boolean, refsStack?: string[]);
-    /**
-     * Set specified alternative schema as active
-     * @param idx oneOf index
-     */
-    activateOneOf(idx: number): void;
-    hasType(type: string): boolean;
-    init(parser: OpenAPIParser, isChild: boolean): void;
-    private initOneOf;
-    private initDiscriminator;
-    private initConditionalOperators;
-}

package/typings/services/models/SecurityRequirement.d.ts

@@ -1,12 +0,0 @@
-import type { OpenAPISecurityRequirement, OpenAPISecurityScheme } from '../../types';
-import type { OpenAPIParser } from '../OpenAPIParser';
-export interface SecurityScheme extends OpenAPISecurityScheme {
-    id: string;
-    sectionId: string;
-    displayName: string;
-    scopes: string[];
-}
-export declare class SecurityRequirementModel {
-    schemes: SecurityScheme[];
-    constructor(requirement: OpenAPISecurityRequirement, parser: OpenAPIParser);
-}

package/typings/services/models/SecuritySchemes.d.ts

@@ -1,26 +0,0 @@
-import type { OpenAPISecurityScheme, Referenced } from '../../types';
-import type { OpenAPIParser } from '../OpenAPIParser';
-export declare class SecuritySchemeModel {
-    id: string;
-    sectionId: string;
-    type: OpenAPISecurityScheme['type'];
-    description: string;
-    displayName: string;
-    apiKey?: {
-        name: string;
-        in: OpenAPISecurityScheme['in'];
-    };
-    http?: {
-        scheme: string;
-        bearerFormat?: string;
-    };
-    flows: OpenAPISecurityScheme['flows'];
-    openId?: {
-        connectUrl: string;
-    };
-    constructor(parser: OpenAPIParser, id: string, scheme: Referenced<OpenAPISecurityScheme>);
-}
-export declare class SecuritySchemesModel {
-    schemes: SecuritySchemeModel[];
-    constructor(parser: OpenAPIParser);
-}

package/typings/services/models/Webhook.d.ts

@@ -1,9 +0,0 @@
-import type { OpenAPIPath, Referenced } from '../../types';
-import type { OpenAPIParser } from '../OpenAPIParser';
-import { OperationModel } from './Operation';
-import type { RedocNormalizedOptions } from '../RedocNormalizedOptions';
-export declare class WebhookModel {
-    operations: OperationModel[];
-    constructor(parser: OpenAPIParser, options: RedocNormalizedOptions, infoOrRef?: Referenced<OpenAPIPath>);
-    initWebhooks(parser: OpenAPIParser, webhooks: OpenAPIPath, options: RedocNormalizedOptions): void;
-}

package/typings/services/models/index.d.ts

@@ -1,13 +0,0 @@
-export * from '../SpecStore';
-export * from './Group.model';
-export * from './Operation';
-export * from './RequestBody';
-export * from './Example';
-export * from './MediaContent';
-export * from './MediaType';
-export * from './Response';
-export * from './Schema';
-export * from './Field';
-export * from './ApiInfo';
-export * from './SecuritySchemes';
-export * from './Callback';

package/typings/services/types.d.ts

@@ -1,106 +0,0 @@
-import { OpenAPIOperation, OpenAPIParameter, OpenAPISchema, OpenAPIServer, OpenAPITag, Referenced } from '../types';
-import { AppStore } from './AppStore';
-import { GroupModel } from './models';
-import { OperationModel } from './models/Operation';
-import { RedocRawOptions } from './RedocNormalizedOptions';
-export interface StoreState {
-    menu: {
-        activeItemIdx: number;
-    };
-    spec: {
-        url?: string;
-        data: any;
-    };
-    searchIndex: any;
-    options: RedocRawOptions;
-}
-export interface LabelsConfig {
-    enum: string;
-    enumSingleValue: string;
-    enumArray: string;
-    default: string;
-    deprecated: string;
-    example: string;
-    examples: string;
-    recursive: string;
-    arrayOf: string;
-    webhook: string;
-    const: string;
-    noResultsFound: string;
-    download: string;
-    downloadSpecification: string;
-    responses: string;
-    callbackResponses: string;
-    requestSamples: string;
-    responseSamples: string;
-}
-export type LabelsConfigRaw = Partial<LabelsConfig>;
-export interface MDXComponentMeta {
-    component: React.ComponentType;
-    propsSelector: (store?: AppStore) => any;
-    props?: object;
-}
-export interface MarkdownHeading {
-    id: string;
-    name: string;
-    level: number;
-    items?: MarkdownHeading[];
-    description?: string;
-}
-export type ContentItemModel = GroupModel | OperationModel;
-export type TagInfo = OpenAPITag & {
-    operations: ExtendedOpenAPIOperation[];
-    used?: boolean;
-};
-export type ExtendedOpenAPIOperation = {
-    pointer: string;
-    pathName: string;
-    httpVerb: string;
-    pathParameters: Array<Referenced<OpenAPIParameter>>;
-    pathServers: Array<OpenAPIServer> | undefined;
-    isWebhook: boolean;
-} & OpenAPIOperation;
-export type TagsInfoMap = Record<string, TagInfo>;
-export interface TagGroup {
-    name: string;
-    tags: string[];
-}
-export type MenuItemGroupType = 'group' | 'tag' | 'section' | 'schema';
-export type MenuItemType = MenuItemGroupType | 'operation';
-export interface IMenuItem {
-    id: string;
-    absoluteIdx?: number;
-    name: string;
-    sidebarLabel: string;
-    description?: string;
-    depth: number;
-    active: boolean;
-    expanded: boolean;
-    items: IMenuItem[];
-    parent?: IMenuItem;
-    deprecated?: boolean;
-    type: MenuItemType;
-    deactivate(): void;
-    activate(): void;
-    collapse(): void;
-    expand(): void;
-}
-export interface SearchDocument {
-    title: string;
-    description: string;
-    id: string;
-}
-export interface SearchResult<T = string> {
-    meta: T;
-    score: number;
-}
-export declare enum SideNavStyleEnum {
-    SummaryOnly = "summary-only",
-    PathOnly = "path-only",
-    IdOnly = "id-only"
-}
-export type MergedOpenAPISchema = OpenAPISchema & {
-    'x-refsStack'?: string[];
-    'x-parentRefs'?: string[];
-    'x-circular-ref'?: boolean;
-};

package/typings/styled-components.d.ts

@@ -1,12 +0,0 @@
-import * as styledComponents from 'styled-components';
-import type { ResolvedThemeInterface } from './theme';
-export type { ResolvedThemeInterface };
-declare const styled: styledComponents.ThemedStyledInterface<ResolvedThemeInterface>, css: styledComponents.ThemedCssFunction<ResolvedThemeInterface>, createGlobalStyle: <P extends object = {}>(first: TemplateStringsArray | styledComponents.CSSObject | styledComponents.InterpolationFunction<styledComponents.ThemedStyledProps<P, ResolvedThemeInterface>>, ...interpolations: styledComponents.Interpolation<styledComponents.ThemedStyledProps<P, ResolvedThemeInterface>>[]) => styledComponents.GlobalStyleComponent<P, ResolvedThemeInterface>, keyframes: (strings: TemplateStringsArray | styledComponents.CSSKeyframes, ...interpolations: styledComponents.SimpleInterpolation[]) => styledComponents.Keyframes, ThemeProvider: styledComponents.BaseThemeProviderComponent<ResolvedThemeInterface, ResolvedThemeInterface>;
-export declare const media: {
-    lessThan(breakpoint: any, print?: boolean, extra?: string): (...args: any[]) => styledComponents.FlattenInterpolation<styledComponents.ThemedStyledProps<object, ResolvedThemeInterface>>;
-    greaterThan(breakpoint: any): (...args: any[]) => styledComponents.FlattenInterpolation<styledComponents.ThemedStyledProps<object, ResolvedThemeInterface>>;
-    between(firstBreakpoint: any, secondBreakpoint: any): (...args: any[]) => styledComponents.FlattenInterpolation<styledComponents.ThemedStyledProps<object, ResolvedThemeInterface>>;
-};
-export { css, createGlobalStyle, keyframes, ThemeProvider };
-export default styled;
-export declare function extensionsHook(styledName: string): (props: any) => any;

package/typings/styled-patch.d.ts

@@ -1,22 +0,0 @@
-import * as styledComponents from 'styled-components';
-
-// FIXME
-declare module 'styled-components' {
-  interface ThemedStyledComponentsModule<T> {
-    keyframes(
-      strings: TemplateStringsArray | string[],
-      ...interpolations: SimpleInterpolation[]
-    ): Keyframes;
-  }
-
-  export interface BaseThemedCssFunction<T extends object> {
-    <P extends object>(
-      first:
-        | TemplateStringsArray
-        | CSSObject
-        | InterpolationFunction<ThemedStyledProps<P, T>>
-        | string[],
-      ...interpolations: Array<Interpolation<ThemedStyledProps<P, T>>>
-    ): FlattenInterpolation<ThemedStyledProps<P, T>>;
-  }
-}

package/typings/theme.d.ts

@@ -1,163 +0,0 @@
-declare const defaultTheme: ThemeInterface;
-export default defaultTheme;
-export declare function resolveTheme(theme: ThemeInterface): ResolvedThemeInterface;
-export interface ColorSetting {
-    main: string;
-    light: string;
-    dark: string;
-    contrastText: string;
-}
-export interface HTTPResponseColos {
-    color: string;
-    backgroundColor: string;
-    tabTextColor: string;
-}
-export interface FontSettings {
-    fontSize: string;
-    fontWeight: string;
-    fontFamily: string;
-    lineHeight: string;
-    color: string;
-}
-export interface Servers {
-    overlay: {
-        backgroundColor: string;
-        textColor: string;
-    };
-    url: {
-        backgroundColor: string;
-    };
-}
-export interface ResolvedThemeInterface {
-    spacing: {
-        unit: number;
-        sectionHorizontal: number;
-        sectionVertical: number;
-    };
-    breakpoints: {
-        small: string;
-        medium: string;
-        large: string;
-    };
-    colors: {
-        tonalOffset: number;
-        primary: ColorSetting;
-        success: ColorSetting;
-        warning: ColorSetting;
-        error: ColorSetting;
-        gray: {
-            50: string;
-            100: string;
-        };
-        border: {
-            light: string;
-            dark: string;
-        };
-        text: {
-            primary: string;
-            secondary: string;
-        };
-        responses: {
-            success: HTTPResponseColos;
-            error: HTTPResponseColos;
-            redirect: HTTPResponseColos;
-            info: HTTPResponseColos;
-        };
-        http: {
-            get: string;
-            post: string;
-            put: string;
-            options: string;
-            patch: string;
-            delete: string;
-            basic: string;
-            link: string;
-            head: string;
-        };
-    };
-    schema: {
-        linesColor: string;
-        defaultDetailsWidth: string;
-        typeNameColor: string;
-        typeTitleColor: string;
-        requireLabelColor: string;
-        labelsTextSize: string;
-        nestingSpacing: string;
-        nestedBackground: string;
-        arrow: {
-            size: string;
-            color: string;
-        };
-    };
-    typography: {
-        fontSize: string;
-        lineHeight: string;
-        fontWeightLight: string;
-        fontWeightRegular: string;
-        fontWeightBold: string;
-        fontFamily: string;
-        smoothing: string;
-        optimizeSpeed: boolean;
-        code: FontSettings & {
-            backgroundColor: string;
-            wrap: boolean;
-        };
-        headings: {
-            fontFamily: string;
-            fontWeight: string;
-            lineHeight: string;
-        };
-        links: {
-            color: string;
-            visited: string;
-            hover: string;
-            textDecoration: string;
-            hoverTextDecoration: string;
-        };
-    };
-    sidebar: {
-        width: string;
-        backgroundColor: string;
-        textColor: string;
-        activeTextColor: string;
-        groupItems: {
-            activeBackgroundColor: string;
-            activeTextColor: string;
-            textTransform: string;
-        };
-        level1Items: {
-            activeBackgroundColor: string;
-            activeTextColor: string;
-            textTransform: string;
-        };
-        arrow: {
-            size: string;
-            color: string;
-        };
-    };
-    logo: {
-        maxHeight: string;
-        maxWidth: string;
-        gutter: string;
-    };
-    rightPanel: {
-        backgroundColor: string;
-        textColor: string;
-        width: string;
-        servers: Servers;
-    };
-    codeBlock: {
-        backgroundColor: string;
-    };
-    fab: {
-        backgroundColor: string;
-        color: string;
-    };
-    extensionsHook?: (name: string, props: any) => string;
-}
-export type primitive = string | number | boolean | undefined | null;
-export type AdvancedThemeDeep<T> = T extends primitive ? T | ((theme: ResolvedThemeInterface) => T) : AdvancedThemeObject<T>;
-export type AdvancedThemeObject<T> = {
-    [P in keyof T]?: AdvancedThemeDeep<T[P]>;
-};
-export type ThemeInterface = AdvancedThemeObject<ResolvedThemeInterface>;

package/typings/types/index.d.ts

@@ -1,2 +0,0 @@
-export * from './open-api';
-export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;

package/typings/types/index.ts

@@ -1,3 +0,0 @@
-export * from './open-api';
-
-export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;