redoc 2.0.0-rc.9 → 2.1.0

package/typings/components/SeeMore/SeeMore.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+interface SeeMoreProps {
+    children?: React.ReactNode;
+    height: string;
+}
+export declare function SeeMore({ children, height }: SeeMoreProps): JSX.Element;
+export {};

package/typings/components/SelectOnClick/SelectOnClick.d.ts

@@ -1,6 +1,6 @@
 import * as React from 'react';
 export declare class SelectOnClick extends React.PureComponent {
     private child;
-    handleClick: () => void;
+    selectElement: () => void;
     render(): JSX.Element;
 }

package/typings/components/SideMenu/Logo.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export default function RedoclyLogo(): JSX.Element | null;

package/typings/components/SideMenu/MenuItem.d.ts

@@ -1,19 +1,22 @@
 import * as React from 'react';
-import { IMenuItem, OperationModel } from '../../services';
+import { OperationModel } from '../../services';
+import type { IMenuItem } from '../../services';
 export interface MenuItemProps {
     item: IMenuItem;
     onActivate?: (item: IMenuItem) => void;
     withoutChildren?: boolean;
+    children?: React.ReactChild;
 }
 export declare class MenuItem extends React.Component<MenuItemProps> {
-    ref: Element | null;
-    activate: (evt: React.MouseEvent<HTMLElement, MouseEvent>) => void;
+    ref: React.RefObject<HTMLLabelElement>;
+    activate: (evt: React.MouseEvent<HTMLElement>) => void;
     componentDidMount(): void;
     componentDidUpdate(): void;
     scrollIntoViewIfActive(): void;
-    saveRef: (ref: any) => void;
     render(): JSX.Element;
 }
 export interface OperationMenuItemContentProps {
     item: OperationModel;
+    children?: React.ReactChild;
 }
+export declare const OperationMenuItemContent: (props: OperationMenuItemContentProps) => JSX.Element;

package/typings/components/SideMenu/MenuItems.d.ts

@@ -1,5 +1,5 @@
 import * as React from 'react';
-import { IMenuItem } from '../../services';
+import type { IMenuItem } from '../../services';
 export interface MenuItemsProps {
     items: IMenuItem[];
     expanded?: boolean;

package/typings/components/SideMenu/SideMenu.d.ts

@@ -1,9 +1,11 @@
 import * as React from 'react';
-import { IMenuItem, MenuStore } from '../../services/MenuStore';
+import { MenuStore } from '../../services';
+import type { IMenuItem } from '../../services';
 export declare class SideMenu extends React.Component<{
     menu: MenuStore;
     className?: string;
 }> {
+    static contextType: React.Context<import("../../services").RedocNormalizedOptions>;
     private _updateScroll?;
     render(): JSX.Element;
     activate: (item: IMenuItem) => void;

package/typings/components/SideMenu/styled.elements.d.ts

@@ -1,18 +1,18 @@
-export declare const OperationBadge: import("styled-components").StyledComponent<"span", import("../../theme").ResolvedThemeInterface, {
-    className: string;
+import { ResolvedThemeInterface } from '../../styled-components';
+export declare const OperationBadge: import("styled-components").StyledComponent<"span", ResolvedThemeInterface, {
+    className: `operation-type ${string}`;
 } & {
     type: string;
 }, "className">;
-export declare const MenuItemUl: import("styled-components").StyledComponent<"ul", import("../../theme").ResolvedThemeInterface, {
+export declare const MenuItemUl: import("styled-components").StyledComponent<"ul", ResolvedThemeInterface, {
     expanded: boolean;
 }, never>;
-export declare const MenuItemLi: import("styled-components").StyledComponent<"li", import("../../theme").ResolvedThemeInterface, {
+export declare const MenuItemLi: import("styled-components").StyledComponent<"li", ResolvedThemeInterface, {
     depth: number;
 }, never>;
 export declare const menuItemDepth: {
-    0: import("styled-components").FlattenInterpolation<import("styled-components").ThemeProps<import("../../theme").ResolvedThemeInterface>>;
-    1: import("styled-components").FlattenInterpolation<import("styled-components").ThemeProps<import("../../theme").ResolvedThemeInterface>>;
-    2: import("styled-components").FlattenInterpolation<import("styled-components").ThemeProps<import("../../theme").ResolvedThemeInterface>>;
+    0: import("styled-components").FlattenInterpolation<import("styled-components").ThemedStyledProps<object, ResolvedThemeInterface>>;
+    1: import("styled-components").FlattenInterpolation<import("styled-components").ThemedStyledProps<object, ResolvedThemeInterface>>;
 };
 export interface MenuItemLabelType {
     depth: number;
@@ -20,11 +20,10 @@ export interface MenuItemLabelType {
     deprecated?: boolean;
     type?: string;
 }
-export declare const MenuItemLabel: import("styled-components").StyledComponent<"label", import("../../theme").ResolvedThemeInterface, {
-    role: "menuitem";
-    className: any;
-} & MenuItemLabelType, "className" | "role">;
-export declare const MenuItemTitle: import("styled-components").StyledComponent<"span", import("../../theme").ResolvedThemeInterface, {
+export declare const MenuItemLabel: import("styled-components").StyledComponent<"label", ResolvedThemeInterface, {
+    className: string;
+} & MenuItemLabelType, "className">;
+export declare const MenuItemTitle: import("styled-components").StyledComponent<"span", ResolvedThemeInterface, {
     width?: string | undefined;
 }, never>;
-export declare const RedocAttribution: import("styled-components").StyledComponent<"div", import("../../theme").ResolvedThemeInterface, {}, never>;
+export declare const RedocAttribution: import("styled-components").StyledComponent<"div", ResolvedThemeInterface, {}, never>;

package/typings/components/SourceCode/SourceCode.d.ts

@@ -1,11 +1,7 @@
-import * as React from 'react';
+/// <reference types="react" />
 export interface SourceCodeProps {
     source: string;
     lang: string;
 }
-export declare class SourceCode extends React.PureComponent<SourceCodeProps> {
-    render(): JSX.Element;
-}
-export declare class SourceCodeWithCopy extends React.PureComponent<SourceCodeProps> {
-    render(): JSX.Element;
-}
+export declare const SourceCode: (props: SourceCodeProps) => JSX.Element;
+export declare const SourceCodeWithCopy: (props: SourceCodeProps) => JSX.Element;

package/typings/components/StickySidebar/ChevronSvg.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="react" />
 export declare const AnimatedChevronButton: ({ open }: {
     open: boolean;
 }) => JSX.Element;

package/typings/components/StickySidebar/StickyResponsiveSidebar.d.ts

@@ -1,16 +1,23 @@
 import * as React from 'react';
 import { MenuStore } from '../../services/MenuStore';
-import { RedocRawOptions } from '../../services/RedocNormalizedOptions';
+import { RedocNormalizedOptions, RedocRawOptions } from '../../services/RedocNormalizedOptions';
+import { OptionsContext } from '../OptionsProvider';
 export interface StickySidebarProps {
     className?: string;
     scrollYOffset?: RedocRawOptions['scrollYOffset'];
     menu: MenuStore;
 }
-export declare class StickyResponsiveSidebar extends React.Component<StickySidebarProps> {
+export interface StickySidebarState {
+    offsetTop?: string;
+}
+export declare class StickyResponsiveSidebar extends React.Component<StickySidebarProps, StickySidebarState> {
+    static contextType: React.Context<RedocNormalizedOptions>;
+    context: React.ContextType<typeof OptionsContext>;
+    state: StickySidebarState;
     stickyElement: Element;
     componentDidMount(): void;
     componentWillUnmount(): void;
-    getScrollYOffset(options: any): string;
+    getScrollYOffset(options: RedocNormalizedOptions): string;
     render(): JSX.Element;
     private toggleNavMenu;
 }

package/typings/components/StoreBuilder.d.ts

@@ -1,4 +1,4 @@
-import { Component } from 'react';
+import * as React from 'react';
 import { AppStore } from '../services/';
 import { RedocRawOptions } from '../services/RedocNormalizedOptions';
 export interface StoreBuilderProps {
@@ -9,7 +9,7 @@ export interface StoreBuilderProps {
     onLoaded?: (e?: Error) => void;
     children: (props: {
         loading: boolean;
-        store?: AppStore;
+        store: AppStore | null;
     }) => any;
 }
 export interface StoreBuilderState {
@@ -19,19 +19,8 @@ export interface StoreBuilderState {
     prevSpec?: any;
     prevSpecUrl?: string;
 }
-declare const Provider: import("react").ProviderExoticComponent<import("react").ProviderProps<AppStore | undefined>>, Consumer: import("react").ExoticComponent<import("react").ConsumerProps<AppStore | undefined>>;
-export { Provider as StoreProvider, Consumer as StoreConsumer };
-export declare class StoreBuilder extends Component<StoreBuilderProps, StoreBuilderState> {
-    static getDerivedStateFromProps(nextProps: StoreBuilderProps, prevState: StoreBuilderState): {
-        loading: boolean;
-        resolvedSpec: null;
-        prevSpec: object | undefined;
-        prevSpecUrl: string | undefined;
-    } | null;
-    state: StoreBuilderState;
-    makeStore(spec: any, specUrl: any, options: any): AppStore | undefined;
-    componentDidMount(): void;
-    componentDidUpdate(): void;
-    load(): Promise<void>;
-    render(): any;
-}
+declare const StoreContext: React.Context<AppStore | undefined>;
+declare const Provider: React.Provider<AppStore | undefined>, Consumer: React.Consumer<AppStore | undefined>;
+export { Provider as StoreProvider, Consumer as StoreConsumer, StoreContext };
+export declare function StoreBuilder(props: StoreBuilderProps): any;
+export declare function useStore(): AppStore | undefined;

package/typings/components/index.d.ts

@@ -19,10 +19,16 @@ export * from './Responses/ResponsesList';
 export * from './Responses/ResponseTitle';
 export * from './ResponseSamples/ResponseSamples';
 export * from './PayloadSamples/PayloadSamples';
+export * from './PayloadSamples/styled.elements';
 export * from './MediaTypeSwitch/MediaTypesSwitch';
+export * from './Parameters/Parameters';
+export * from './PayloadSamples/Example';
+export * from './DropdownOrLabel/DropdownOrLabel';
 export * from './ErrorBoundary';
 export * from './StoreBuilder';
 export * from './OptionsProvider';
 export * from './SideMenu/';
 export * from './StickySidebar/StickyResponsiveSidebar';
 export * from './SearchBox/SearchBox';
+export * from './SchemaDefinition/SchemaDefinition';
+export * from './SourceCode/SourceCode';

package/typings/index.d.ts

@@ -1,5 +1,7 @@
 export * from './components';
-export { MiddlePanel, Row, RightPanel, Section } from './common-elements/';
+export { MiddlePanel, Row, RightPanel, Section, Dropdown, SimpleDropdown, } from './common-elements/';
+export type { DropdownOption } from './common-elements';
+export type { OpenAPIEncoding } from './types';
 export * from './services';
 export * from './utils';
 export * from './styled-components';

package/typings/services/AppStore.d.ts

@@ -1,20 +1,11 @@
-import { OpenAPISpec } from '../types';
+import type { OpenAPISpec } from '../types';
 import { MarkerService } from './MarkerService';
 import { MenuStore } from './MenuStore';
 import { SpecStore } from './models';
-import { RedocNormalizedOptions, RedocRawOptions } from './RedocNormalizedOptions';
+import { RedocNormalizedOptions } from './RedocNormalizedOptions';
+import type { RedocRawOptions } from './RedocNormalizedOptions';
 import { SearchStore } from './SearchStore';
-export interface StoreState {
-    menu: {
-        activeItemIdx: number;
-    };
-    spec: {
-        url?: string;
-        data: any;
-    };
-    searchIndex: any;
-    options: RedocRawOptions;
-}
+import type { StoreState } from './types';
 export declare function createStore(spec: object, specUrl: string | undefined, options?: RedocRawOptions): Promise<AppStore>;
 export declare class AppStore {
     /**

package/typings/services/HistoryService.d.ts

@@ -1,7 +1,7 @@
 export declare class HistoryService {
     private _emiter;
     constructor();
-    readonly currentId: string;
+    get currentId(): string;
     linkForId(id: string): string;
     subscribe(cb: any): () => void;
     emit: () => void;

package/typings/services/Labels.d.ts

@@ -1,14 +1,3 @@
-export interface LabelsConfig {
-    enum: string;
-    enumSingleValue: string;
-    enumArray: string;
-    default: string;
-    deprecated: string;
-    example: string;
-    nullable: string;
-    recursive: string;
-    arrayOf: string;
-}
-export declare type LabelsConfigRaw = Partial<LabelsConfig>;
+import type { LabelsConfig, LabelsConfigRaw } from './types';
 export declare function setRedocLabels(_labels?: LabelsConfigRaw): void;
 export declare function l(key: keyof LabelsConfig, idx?: number): string;

package/typings/services/MarkdownRenderer.d.ts

@@ -1,34 +1,25 @@
-import * as marked from 'marked';
-import { AppStore } from './AppStore';
+import { marked } from 'marked';
 import { RedocNormalizedOptions } from './RedocNormalizedOptions';
+import type { MarkdownHeading, MDXComponentMeta } from './types';
 export declare const LEGACY_REGEXP = "^ {0,3}<!-- ReDoc-Inject:\\s+?<({component}).*?/?>\\s+?-->\\s*$";
 export declare const MDX_COMPONENT_REGEXP: string;
 export declare const COMPONENT_REGEXP: string;
-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 declare function buildComponentComment(name: string): string;
 export declare class MarkdownRenderer {
     options?: RedocNormalizedOptions | undefined;
+    parentId?: string | undefined;
     static containsComponent(rawText: string, componentName: string): boolean;
+    static getTextBeforeHading(md: string, heading: string): string;
     headings: MarkdownHeading[];
     currentTopHeading: MarkdownHeading;
+    parser: marked.Parser;
     private headingEnhanceRenderer;
     private originalHeadingRule;
-    constructor(options?: RedocNormalizedOptions | undefined);
+    constructor(options?: RedocNormalizedOptions | undefined, parentId?: string | undefined);
     saveHeading(name: string, level: number, container?: MarkdownHeading[], parentId?: string): MarkdownHeading;
     flattenHeadings(container?: MarkdownHeading[]): MarkdownHeading[];
     attachHeadingsDescriptions(rawText: string): void;
-    headingRule: (text: string, level: number, raw: string, slugger: marked.Slugger) => string;
+    headingRule: (text: string, level: 1 | 2 | 3 | 4 | 5 | 6, raw: string, slugger: marked.Slugger) => string;
     renderMd(rawText: string, extractHeadings?: boolean): string;
     extractHeadings(rawText: string): MarkdownHeading[];
     renderMdWithComponents(rawText: string): Array<string | MDXComponentMeta>;

package/typings/services/MenuBuilder.d.ts

@@ -1,23 +1,9 @@
-import { OpenAPIOperation, OpenAPIParameter, OpenAPISpec, OpenAPITag, Referenced } from '../types';
+import type { OpenAPISpec } from '../types';
 import { GroupModel, OperationModel } from './models';
-import { OpenAPIParser } from './OpenAPIParser';
-import { RedocNormalizedOptions } from './RedocNormalizedOptions';
-export declare type TagInfo = OpenAPITag & {
-    operations: ExtendedOpenAPIOperation[];
-    used?: boolean;
-};
-export declare type ExtendedOpenAPIOperation = {
-    pathName: string;
-    httpVerb: string;
-    pathParameters: Array<Referenced<OpenAPIParameter>>;
-} & OpenAPIOperation;
-export declare type TagsInfoMap = Dict<TagInfo>;
-export interface TagGroup {
-    name: string;
-    tags: string[];
-}
+import type { OpenAPIParser } from './OpenAPIParser';
+import type { RedocNormalizedOptions } from './RedocNormalizedOptions';
+import type { ContentItemModel, TagGroup, TagInfo, TagsInfoMap } from './types';
 export declare const GROUP_DEPTH = 0;
-export declare type ContentItemModel = GroupModel | OperationModel;
 export declare class MenuBuilder {
     /**
      * Builds page content structure based on tags
@@ -27,28 +13,37 @@ export declare class MenuBuilder {
      * extracts items from markdown description
      * @param description - markdown source
      */
-    static addMarkdownItems(description: string, options: RedocNormalizedOptions): ContentItemModel[];
+    static addMarkdownItems(description: string, parent: GroupModel | undefined, initialDepth: number, options: RedocNormalizedOptions): ContentItemModel[];
     /**
-     * Returns array of OperationsGroup items for the tag groups (x-tagGroups vendor extenstion)
+     * Returns array of OperationsGroup items for the tag groups (x-tagGroups vendor extension)
      * @param tags value of `x-tagGroups` vendor extension
      */
     static getTagGroupsItems(parser: OpenAPIParser, parent: GroupModel | undefined, groups: TagGroup[], tags: TagsInfoMap, options: RedocNormalizedOptions): GroupModel[];
     /**
      * Returns array of OperationsGroup items for the tags of the group or for all tags
+     * @param parser
      * @param tagsMap tags info returned from `getTagsWithOperations`
      * @param parent parent item
      * @param group group which this tag belongs to. if not provided gets all tags
+     * @param options normalized options
      */
     static getTagsItems(parser: OpenAPIParser, tagsMap: TagsInfoMap, parent: GroupModel | undefined, group: TagGroup | undefined, options: RedocNormalizedOptions): ContentItemModel[];
     /**
      * Returns array of Operation items for the tag
+     * @param parser
      * @param parent parent OperationsGroup
      * @param tag tag info returned from `getTagsWithOperations`
      * @param depth items depth
+     * @param options - normalized options
      */
     static getOperationsItems(parser: OpenAPIParser, parent: GroupModel | undefined, tag: TagInfo, depth: number, options: RedocNormalizedOptions): OperationModel[];
     /**
      * collects tags and maps each tag to list of operations belonging to this tag
      */
-    static getTagsWithOperations(spec: OpenAPISpec): TagsInfoMap;
+    static getTagsWithOperations(parser: OpenAPIParser, spec: OpenAPISpec): TagsInfoMap;
+    static getTagRelatedSchema({ parser, tag, parent, }: {
+        parser: OpenAPIParser;
+        tag: TagInfo;
+        parent: GroupModel;
+    }): GroupModel[];
 }

package/typings/services/MenuStore.d.ts

@@ -1,26 +1,8 @@
-import { SpecStore } from './models';
 import { HistoryService } from './HistoryService';
-import { ScrollService } from './ScrollService';
-export declare type MenuItemGroupType = 'group' | 'tag' | 'section';
-export declare type MenuItemType = MenuItemGroupType | 'operation';
+import type { SpecStore } from './models';
+import type { ScrollService } from './ScrollService';
+import type { IMenuItem } from './types';
 /** Generic interface for MenuItems */
-export interface IMenuItem {
-    id: string;
-    absoluteIdx?: number;
-    name: 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 declare const SECTION_ATTR = "data-section-id";
 /**
  * Stores all side-menu related information
@@ -72,16 +54,21 @@ export declare class MenuStore {
      * @param idx item absolute index
      */
     getElementAt(idx: number): Element | null;
+    /**
+     * get section/operation DOM Node related to the item or if it is group item, returns first item of the group
+     * @param idx item absolute index
+     */
+    getElementAtOrFirstChild(idx: number): Element | null;
     /**
      * current active item
      */
-    readonly activeItem: IMenuItem;
+    get activeItem(): IMenuItem;
     getItemById: (id: string) => IMenuItem | undefined;
     /**
      * activate menu item
      * @param item item to activate
      * @param updateLocation [true] whether to update location
-     * @param rewriteHistory [false] whether to rewrite browser history (do not create new enrty)
+     * @param rewriteHistory [false] whether to rewrite browser history (do not create new entry)
      */
     activate(item: IMenuItem | undefined, updateLocation?: boolean, rewriteHistory?: boolean): void;
     /**

package/typings/services/OpenAPIParser.d.ts

@@ -1,52 +1,50 @@
-import { OpenAPIRef, OpenAPISchema, OpenAPISpec, Referenced } from '../types';
+import type { OpenAPIRef, OpenAPISpec } from '../types';
 import { RedocNormalizedOptions } from './RedocNormalizedOptions';
-export declare type MergedOpenAPISchema = OpenAPISchema & {
-    parentRefs?: string[];
-};
+import type { MergedOpenAPISchema } from './types';
 /**
  * Loads and keeps spec. Provides raw spec operations
  */
+export declare function pushRef(stack: string[], ref?: string): string[];
+export declare function concatRefStacks(base: string[], stack?: string[]): string[];
 export declare class OpenAPIParser {
     private options;
     specUrl?: string;
     spec: OpenAPISpec;
-    private _refCounter;
+    private readonly allowMergeRefs;
     constructor(spec: OpenAPISpec, specUrl?: string, options?: RedocNormalizedOptions);
-    validate(spec: any): void;
-    preprocess(spec: OpenAPISpec): void;
+    validate(spec: Record<string, any>): void;
     /**
      * get spec part by JsonPointer ($ref)
      */
-    byRef: <T extends any = any>(ref: string) => T | undefined;
+    byRef: <T extends unknown = any>(ref: string) => T | undefined;
     /**
-     * checks if the objectt is OpenAPI reference (containts $ref property)
+     * checks if the object is OpenAPI reference (contains $ref property)
      */
-    isRef(obj: any): obj is OpenAPIRef;
-    /**
-     * resets visited enpoints. should be run after
-     */
-    resetVisited(): void;
-    exitRef<T>(ref: Referenced<T>): void;
+    isRef<T extends unknown>(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 forceCircular whether to dereference even if it is cirular ref
+     * @param forceCircular whether to dereference even if it is circular ref
+     * @param mergeAsAllOf
      */
-    deref<T extends object>(obj: OpenAPIRef | T, forceCircular?: boolean): T;
-    shalowDeref<T extends object>(obj: OpenAPIRef | T): T;
+    deref<T extends unknown>(obj: OpenAPIRef | T, baseRefsStack?: string[], mergeAsAllOf?: boolean): {
+        resolved: T;
+        refsStack: string[];
+    };
+    mergeRefs<T extends unknown>(ref: OpenAPIRef, resolved: T, mergeAsAllOf: boolean): T;
     /**
-     * Merge allOf contsraints.
+     * Merge allOf constraints.
      * @param schema schema with allOF
      * @param $ref pointer of the schema
-     * @param forceCircular whether to dereference children even if it is a cirular ref
+     * @param forceCircular whether to dereference children even if it is a circular ref
+     * @param used$Refs
      */
-    mergeAllOf(schema: OpenAPISchema, $ref?: string, forceCircular?: boolean): MergedOpenAPISchema;
+    mergeAllOf(schema: MergedOpenAPISchema, $ref: string | undefined, refsStack: string[]): 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[]): Dict<string>;
-    exitParents(shema: MergedOpenAPISchema): void;
+    findDerived($refs: string[]): Record<string, string[] | string>;
     private hoistOneOfs;
 }

package/typings/services/RedocNormalizedOptions.d.ts

@@ -1,6 +1,6 @@
 import { ResolvedThemeInterface, ThemeInterface } from '../theme';
-import { LabelsConfigRaw } from './Labels';
-import { MDXComponentMeta } from './MarkdownRenderer';
+import { SideNavStyleEnum } from './types';
+import type { LabelsConfigRaw, MDXComponentMeta } from './types';
 export interface RedocRawOptions {
     theme?: ThemeInterface;
     scrollYOffset?: number | string | (() => number);
@@ -8,25 +8,55 @@ export interface RedocRawOptions {
     expandResponses?: string | 'all';
     requiredPropsFirst?: boolean | string;
     sortPropsAlphabetically?: boolean | string;
-    noAutoAuth?: boolean | string;
+    sortEnumValuesAlphabetically?: boolean | string;
+    sortOperationsAlphabetically?: boolean | string;
+    sortTagsAlphabetically?: boolean | string;
     nativeScrollbars?: boolean | string;
     pathInMiddlePanel?: boolean | string;
     untrustedSpec?: boolean | string;
     hideLoading?: boolean | string;
     hideDownloadButton?: boolean | string;
+    downloadFileName?: string;
+    downloadDefinitionUrl?: string;
     disableSearch?: boolean | string;
     onlyRequiredInSamples?: boolean | string;
     showExtensions?: boolean | string | string[];
+    sideNavStyle?: SideNavStyleEnum;
     hideSingleRequestSampleTab?: boolean | string;
+    menuToggle?: boolean | string;
+    jsonSampleExpandLevel?: number | string | 'all';
+    hideSchemaTitles?: boolean | string;
+    simpleOneOfTypeLabel?: boolean | string;
+    payloadSampleIdx?: number;
+    expandSingleSchemaField?: boolean | string;
+    schemaExpansionLevel?: number | string | 'all';
+    showObjectSchemaExamples?: boolean | string;
+    showSecuritySchemeType?: boolean;
+    hideSecuritySection?: boolean;
     unstable_ignoreMimeParameters?: boolean;
-    allowedMdComponents?: Dict<MDXComponentMeta>;
+    allowedMdComponents?: Record<string, MDXComponentMeta>;
     labels?: LabelsConfigRaw;
+    enumSkipQuotes?: boolean | string;
+    expandDefaultServerVariables?: boolean;
+    maxDisplayedEnumValues?: number;
+    ignoreNamedSchemas?: string[] | string;
+    hideSchemaPattern?: boolean;
+    generatedPayloadSamplesMaxDepth?: number;
+    nonce?: string;
+    hideFab?: boolean;
+    minCharacterLengthToInitSearch?: number;
+    showWebhookVerb?: boolean;
 }
+export declare function argValueToBoolean(val?: string | boolean, defaultValue?: boolean): boolean;
 export declare class RedocNormalizedOptions {
     static normalizeExpandResponses(value: RedocRawOptions['expandResponses']): {};
     static normalizeHideHostname(value: RedocRawOptions['hideHostname']): boolean;
     static normalizeScrollYOffset(value: RedocRawOptions['scrollYOffset']): () => number;
     static normalizeShowExtensions(value: RedocRawOptions['showExtensions']): string[] | boolean;
+    static normalizeSideNavStyle(value: RedocRawOptions['sideNavStyle']): SideNavStyleEnum;
+    static normalizePayloadSampleIdx(value: RedocRawOptions['payloadSampleIdx']): number;
+    private static normalizeJsonSampleExpandLevel;
+    private static normalizeGeneratedPayloadSamplesMaxDepth;
     theme: ResolvedThemeInterface;
     scrollYOffset: () => number;
     hideHostname: boolean;
@@ -35,16 +65,41 @@ export declare class RedocNormalizedOptions {
     } | 'all';
     requiredPropsFirst: boolean;
     sortPropsAlphabetically: boolean;
-    noAutoAuth: boolean;
+    sortEnumValuesAlphabetically: boolean;
+    sortOperationsAlphabetically: boolean;
+    sortTagsAlphabetically: boolean;
     nativeScrollbars: boolean;
     pathInMiddlePanel: boolean;
     untrustedSpec: boolean;
     hideDownloadButton: boolean;
+    downloadFileName?: string;
+    downloadDefinitionUrl?: string;
     disableSearch: boolean;
     onlyRequiredInSamples: boolean;
     showExtensions: boolean | string[];
+    sideNavStyle: SideNavStyleEnum;
     hideSingleRequestSampleTab: boolean;
+    menuToggle: boolean;
+    jsonSampleExpandLevel: number;
+    enumSkipQuotes: boolean;
+    hideSchemaTitles: boolean;
+    simpleOneOfTypeLabel: boolean;
+    payloadSampleIdx: number;
+    expandSingleSchemaField: boolean;
+    schemaExpansionLevel: number;
+    showObjectSchemaExamples: boolean;
+    showSecuritySchemeType?: boolean;
+    hideSecuritySection?: boolean;
     unstable_ignoreMimeParameters: boolean;
-    allowedMdComponents: Dict<MDXComponentMeta>;
+    allowedMdComponents: Record<string, MDXComponentMeta>;
+    expandDefaultServerVariables: boolean;
+    maxDisplayedEnumValues?: number;
+    ignoreNamedSchemas: Set<string>;
+    hideSchemaPattern: boolean;
+    generatedPayloadSamplesMaxDepth: number;
+    hideFab: boolean;
+    minCharacterLengthToInitSearch: number;
+    showWebhookVerb: boolean;
+    nonce?: string;
     constructor(raw: RedocRawOptions, defaults?: RedocRawOptions);
 }

package/typings/services/ScrollService.d.ts

@@ -1,4 +1,4 @@
-import { RedocNormalizedOptions } from './RedocNormalizedOptions';
+import type { RedocNormalizedOptions } from './RedocNormalizedOptions';
 export declare class ScrollService {
     private options;
     private _scrollParent;