@redocly/reference-docs 2.43.3 → 2.43.5

package/lib-browser/redoc-lib/src/styled-components.d.ts

@@ -0,0 +1,9 @@
+import * as styledComponents from 'styled-components';
+import type { ProTheme } from '../../services/extendTheme';
+import type { ResolvedThemeInterface, MediaValue } from './theme';
+export type { ResolvedThemeInterface, MediaValue };
+declare const styled: styledComponents.ThemedStyledInterface<ProTheme>, css: styledComponents.ThemedCssFunction<ProTheme>, createGlobalStyle: <P extends object = {}>(first: TemplateStringsArray | styledComponents.CSSObject | styledComponents.InterpolationFunction<styledComponents.ThemedStyledProps<P, ProTheme>>, ...interpolations: styledComponents.Interpolation<styledComponents.ThemedStyledProps<P, ProTheme>>[]) => styledComponents.GlobalStyleComponent<P, ProTheme>, keyframes: (strings: TemplateStringsArray | styledComponents.CSSKeyframes, ...interpolations: styledComponents.SimpleInterpolation[]) => styledComponents.Keyframes, ThemeProvider: styledComponents.ThemeProviderComponent<ProTheme, ProTheme>;
+export { css, createGlobalStyle, keyframes, ThemeProvider };
+export default styled;
+export declare function extensionsHook(styledName: string): any;
+export { mediaCSS, mediaMap, ZERO_BREAKPOINT } from './utils/media-css';

package/lib-browser/redoc-lib/src/styled-components.js

@@ -0,0 +1,2 @@
+import*as styledComponents from"styled-components";const{default:styled,css:css,createGlobalStyle:createGlobalStyle,keyframes:keyframes,ThemeProvider:ThemeProvider}=styledComponents;export{css,createGlobalStyle,keyframes,ThemeProvider};export default styled;export function extensionsHook(e){return t=>{if(t.theme.extensionsHook)return t.theme.extensionsHook(e,t)}}export{mediaCSS,mediaMap,ZERO_BREAKPOINT}from"./utils/media-css";
+//# sourceMappingURL=styled-components.js.map

package/lib-browser/redoc-lib/src/theme.d.ts

@@ -0,0 +1,250 @@
+import type { Typography } from '../../services/extendTheme';
+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 ButtonSizeSetting {
+    padding: string;
+    fontSize: string;
+    minWidth: string;
+}
+export interface HTTPResponseColors {
+    color: string;
+    borderColor: string;
+    backgroundColor: string;
+    tabTextColor: string;
+}
+export declare type MediaValue<T = string> = T | {
+    [size: string]: T;
+};
+export interface FontSettings {
+    fontSize: MediaValue;
+    fontWeight: string;
+    fontFamily: MediaValue;
+    lineHeight: MediaValue;
+    color: string;
+}
+export interface ResolvedThemeInterface {
+    spacing: {
+        unit: number;
+        sectionHorizontal: number;
+        sectionVertical: number;
+    };
+    breakpoints: {
+        small: string;
+        medium: string;
+        large: string;
+    } & {
+        [size: string]: string;
+    };
+    mediaQueries: {
+        print: string;
+        small?: string;
+        medium?: string;
+        large?: string;
+    };
+    colors: {
+        tonalOffset: number;
+        primary: ColorSetting;
+        secondary: ColorSetting;
+        accent: ColorSetting;
+        success: ColorSetting;
+        warning: ColorSetting;
+        error: ColorSetting;
+        border: {
+            light: string;
+            dark: string;
+        };
+        text: {
+            primary: string;
+            secondary: string;
+            light: string;
+        };
+        responses: {
+            success: HTTPResponseColors;
+            error: HTTPResponseColors;
+            redirect: HTTPResponseColors;
+            info: HTTPResponseColors;
+        };
+        http: {
+            get: string;
+            post: string;
+            put: string;
+            options: string;
+            patch: string;
+            delete: string;
+            basic: string;
+            link: string;
+            head: string;
+        };
+    };
+    schema: {
+        caretSize: string;
+        caretColor: string;
+        linesColor: string;
+        defaultDetailsWidth: string;
+        typeNameColor: string;
+        typeTitleColor: string;
+        requireLabelColor: string;
+        labelsTextSize: string;
+        nestingSpacing: string;
+        nestedBackground: string;
+        nestedAlternativeBackground: string;
+    };
+    typography: {
+        fontSize: MediaValue;
+        lineHeight: MediaValue;
+        fontWeightLight: string;
+        fontWeightRegular: string;
+        fontWeightBold: string;
+        fontFamily: MediaValue;
+        fieldName: {
+            fontSize: string;
+            fontFamily: string;
+            fontWeight: string;
+        };
+        smoothing: string;
+        optimizeSpeed: boolean;
+        code: FontSettings & {
+            backgroundColor: string;
+            wrap: boolean;
+        };
+        headings: {
+            fontFamily: MediaValue;
+            fontWeight: string;
+            lineHeight: MediaValue;
+        };
+        links: {
+            color: string;
+            visited: string;
+            hover: string;
+            textDecoration: string;
+            hoverTextDecoration: string;
+        };
+    };
+    sidebar: {
+        showAtBreakpoint: string;
+        width: string;
+        backgroundColor: string;
+        rightLineColor: string;
+        textColor: string;
+        activeTextColor: string;
+        borderRadius: string;
+        activeBgColor: string;
+        separatorLabelColor: string;
+        separatorLineColor: string;
+        fontFamily: string;
+        fontSize: string;
+        caretSize: number;
+        caretColor: string;
+        spacing: {
+            unit: number;
+            paddingHorizontal: number;
+            paddingVertical: number;
+            offsetTop: number;
+            offsetLeft: number;
+            offsetNesting: number;
+        };
+    };
+    logo: {
+        maxHeight: string;
+        maxWidth: string;
+        gutter: string;
+    };
+    components: {
+        buttons: {
+            borderRadius: string;
+            hoverStyle: string;
+            fontWeight: string;
+            boxShadow: string;
+            hoverBoxShadow: string;
+            fontFamily: string;
+            sizes: {
+                small: ButtonSizeSetting;
+                medium: ButtonSizeSetting;
+                large: ButtonSizeSetting;
+                xlarge: ButtonSizeSetting;
+                [k: string]: ButtonSizeSetting;
+            };
+        };
+        panels: {
+            borderRadius: string;
+            backgroundColor: string;
+            title: Typography & {
+                fontFamily: MediaValue;
+            };
+            subTitle: Typography & {
+                fontFamily: MediaValue;
+            };
+            iconColor: string;
+        };
+        layoutControls: {
+            top: string;
+            width: string;
+            height: string;
+        };
+        httpBadges: {
+            borderRadius: string;
+            fontWeight: string;
+            fontFamily: MediaValue;
+            color: string;
+            sizes: {
+                small: {
+                    fontSize: MediaValue;
+                    lineHeight: MediaValue;
+                };
+                medium: {
+                    fontSize: MediaValue;
+                    lineHeight: MediaValue;
+                };
+            };
+        };
+        tryItButton: {
+            fullWidth: boolean;
+        };
+        tryItSendButton: {
+            fullWidth: boolean;
+        };
+    };
+    rightPanel: {
+        showAtBreakpoint: string;
+        backgroundColor: string;
+        panelBackgroundColor: string;
+        panelControlsBackgroundColor: string;
+        textColor: string;
+        width: MediaValue;
+    };
+    codeBlock: {
+        backgroundColor: string;
+        maxHeight: string;
+    };
+    layout: {
+        showDarkRightPanel?: boolean;
+        'three-panel': {
+            middlePanelMaxWidth: MediaValue;
+            maxWidth: MediaValue;
+        };
+        stacked: {
+            maxWidth: MediaValue;
+        };
+    };
+    shape: {
+        borderRadius: string;
+    };
+    fab: {
+        backgroundColor: string;
+        color: string;
+    };
+    extensionsHook?: (name: string, props: any) => string;
+}
+export declare type primitive = string | number | boolean | undefined | null;
+export declare type AdvancedThemeDeep<T> = T extends primitive ? T | ((theme: ResolvedThemeInterface) => MediaValue<T>) : AdvancedThemeObject<T>;
+export declare type AdvancedThemeObject<T> = {
+    [P in keyof T]?: AdvancedThemeDeep<T[P]>;
+};
+export declare type ThemeInterface = AdvancedThemeObject<ResolvedThemeInterface>;

package/lib-browser/redoc-lib/src/theme.js

@@ -0,0 +1,2 @@
+import{darken,lighten,readableColor,transparentize}from"polished";import{ZERO_BREAKPOINT}from"./utils/media-css";const defaultTheme={spacing:{unit:5,sectionHorizontal:({spacing:o})=>8*o.unit,sectionVertical:({spacing:o})=>4*o.unit},breakpoints:{small:"50rem",medium:"85rem",large:"105rem"},colors:{tonalOffset:.2,primary:{main:"#0065FB",light:({colors:o})=>lighten(o.tonalOffset,o.primary.main),dark:({colors:o})=>darken(o.tonalOffset,o.primary.main),contrastText:({colors:o})=>readableColor(o.primary.main)},secondary:{main:"#E4E7EB",light:"#F5F7FA",dark:"#E4E7EB",contrastText:"#3E4C59"},accent:{main:"#59C3FF",light:"#b3dcf3",dark:"#033B73",contrastText:"#ffffff"},success:{main:"#41DE50",light:({colors:o})=>lighten(2*o.tonalOffset,o.success.main),dark:({colors:o})=>darken(o.tonalOffset,o.success.main),contrastText:({colors:o})=>readableColor(o.success.main)},warning:{main:"#ffa500",light:({colors:o})=>lighten(o.tonalOffset,o.warning.main),dark:({colors:o})=>darken(o.tonalOffset,o.warning.main),contrastText:"#ffffff"},error:{main:"#FF6161",light:({colors:o})=>lighten(o.tonalOffset,o.error.main),dark:({colors:o})=>darken(o.tonalOffset,o.error.main),contrastText:"#ffffff"},text:{primary:"#1F2933",secondary:"#7b8794",light:"#F5F7FA"},border:{dark:"#616E7C",light:"#E4E7EB"},responses:{success:{borderColor:"#B1E996",backgroundColor:"#F6FFF4",tabTextColor:({colors:o})=>o.responses.success.borderColor},error:{borderColor:"#FFC9C9",backgroundColor:"#FFF4F4",tabTextColor:({colors:o})=>o.responses.error.borderColor},redirect:{borderColor:({colors:o})=>o.warning.main,backgroundColor:({colors:o})=>transparentize(.9,o.responses.redirect.borderColor),tabTextColor:({colors:o})=>o.responses.redirect.borderColor},info:{borderColor:"#87ceeb",backgroundColor:({colors:o})=>transparentize(.9,o.responses.info.borderColor),tabTextColor:({colors:o})=>o.responses.info.borderColor}},http:{get:"#3A9601",post:"#0065FB",put:"#93527B",options:"#947014",patch:"#bf581d",delete:"#C83637",basic:"#707070",link:"#07818F",head:"#A23DAD"}},schema:{linesColor:o=>o.colors.border.light,defaultDetailsWidth:"70%",typeNameColor:o=>o.colors.text.secondary,typeTitleColor:o=>o.schema.typeNameColor,requireLabelColor:"#FF0000",labelsTextSize:"0.9em",nestingSpacing:"1em",nestedBackground:o=>o.colors.secondary.light,nestedAlternativeBackground:"#ffffff",caretColor:({colors:o})=>o.text.primary,caretSize:"9px"},typography:{fontSize:"14px",lineHeight:"1.5em",fontWeightRegular:"400",fontWeightBold:"600",fontWeightLight:"300",fontFamily:"Source Sans Pro, sans-serif",smoothing:"antialiased",optimizeSpeed:!0,headings:{fontFamily:({typography:o})=>o.fontFamily,fontWeight:"700",lineHeight:"1.6em"},code:{fontSize:"13px",fontFamily:"Source Code Pro, monospace",lineHeight:({typography:o})=>o.lineHeight,fontWeight:({typography:o})=>o.fontWeightRegular,color:"#e53935",backgroundColor:"rgba(38, 50, 56, 0.05)",wrap:!1},links:{color:({colors:o})=>o.primary.main,visited:({typography:o})=>o.links.color,hover:({typography:o})=>lighten(.2,o.links.color),textDecoration:"auto",hoverTextDecoration:"auto"},fieldName:{fontSize:({typography:o})=>o.code.fontSize,fontFamily:({typography:o})=>o.code.fontFamily,fontWeight:({typography:o})=>o.code.fontWeight}},sidebar:{separatorLabelColor:({sidebar:o})=>o.textColor,separatorLineColor:"#DADADA",caretColor:({sidebar:o})=>o.textColor,caretSize:({sidebar:o})=>o.spacing.unit,spacing:{unit:8,paddingHorizontal:({sidebar:o})=>o.spacing.unit,paddingVertical:({sidebar:o})=>o.spacing.unit,offsetTop:({sidebar:o})=>2*o.spacing.unit,offsetLeft:({sidebar:o})=>2*o.spacing.unit,offsetNesting:({sidebar:o})=>2*o.spacing.unit},borderRadius:"4px",fontFamily:({typography:o})=>o.fontFamily,fontSize:({typography:o})=>o.fontSize,showAtBreakpoint:"small",width:"285px",backgroundColor:"#fff",rightLineColor:o=>o.colors.border.light,textColor:o=>o.colors.text.primary,activeTextColor:o=>o.sidebar.textColor,activeBgColor:o=>o.colors.border.light},components:{buttons:{borderRadius:({shape:o})=>o.borderRadius,hoverStyle:"",fontWeight:({typography:o})=>o.fontWeightBold,boxShadow:"none",hoverBoxShadow:"0px 0px 12px 0px rgba(0, 0, 0, 0.1)",fontFamily:"inherit",sizes:{small:{fontSize:"12px",padding:"8px 10px",minWidth:"90px"},medium:{fontSize:"14px",padding:"8px 20px",minWidth:"120px"},large:{fontSize:"14px",padding:"12px 24px",minWidth:"150px"},xlarge:{fontSize:"16px",padding:"20px 24px",minWidth:"200px"}}},httpBadges:{borderRadius:"16px",fontFamily:({typography:o})=>o.code.fontFamily,fontWeight:({typography:o})=>o.fontWeightBold,color:({colors:o})=>o.text.light,sizes:{medium:{fontSize:"12px",lineHeight:"20px"},small:{fontSize:"8px",lineHeight:"15px"}}},tryItButton:{fullWidth:!1},tryItSendButton:{fullWidth:!1},panels:{borderRadius:"8px",backgroundColor:"#fff",title:{fontSize:"18px",fontWeight:({typography:o})=>o.headings.fontWeight,fontFamily:({typography:o})=>o.fontFamily,lineHeight:"18px",color:"#1F2933",transform:""},subTitle:{fontSize:"0.9em",fontWeight:"normal",fontFamily:({typography:o})=>o.fontFamily,lineHeight:"18px",color:"#1F2933",transform:""},iconColor:"#1F2933"},layoutControls:{top:"20px",width:"36px",height:"36px"}},logo:{maxHeight:({sidebar:o})=>o.width,maxWidth:({sidebar:o})=>o.width,gutter:"2px"},fab:{backgroundColor:"#f2f2f2",color:"#0065FB"},rightPanel:{showAtBreakpoint:"medium",backgroundColor:"#1F2933",panelBackgroundColor:"#52606D",panelControlsBackgroundColor:"#323F4B",width:"37.5%",textColor:"#ffffff"},codeBlock:{backgroundColor:({rightPanel:o})=>o.panelControlsBackgroundColor,maxHeight:"auto"},shape:{borderRadius:"4px"},layout:{showDarkRightPanel:!1,stacked:{maxWidth:{[ZERO_BREAKPOINT]:"",small:"90%",medium:"75%",large:"1200px"}},"three-panel":{middlePanelMaxWidth:"none",maxWidth:{[ZERO_BREAKPOINT]:"100%",small:"100%",medium:"100%",large:"1800px"}}}};export default defaultTheme;export function resolveTheme(o){const e={};let r=0;const t=(i,a)=>{Object.keys(i).forEach((n=>{const l=(a?a+".":"")+n,s=i[n];"function"==typeof s?Object.defineProperty(i,n,{get(){if(!e[l]){if(r++,r>1e3)throw new Error(`Theme probably contains circular dependency at ${l}: ${s.toString()}`);e[l]=s(o)}return e[l]},enumerable:!0}):"object"==typeof s&&t(s,l)}))};return t(o,""),JSON.parse(JSON.stringify(o))}
+//# sourceMappingURL=theme.js.map

package/lib-browser/redoc-lib/src/types/index.d.ts

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

package/lib-browser/redoc-lib/src/types/index.js

@@ -0,0 +1,2 @@
+export*from"./open-api";export*from"./server";
+//# sourceMappingURL=index.js.map

package/lib-browser/redoc-lib/src/types/open-api.d.ts

@@ -0,0 +1,331 @@
+import type { Sample } from '../services';
+import type { Omit } from './index';
+export interface OpenAPIDefinition {
+    openapi: string;
+    info: OpenAPIInfo;
+    servers?: OpenAPIServer[];
+    paths: OpenAPIPaths;
+    components?: OpenAPIComponents;
+    security?: OpenAPISecurityRequirement[];
+    tags?: OpenAPITag[];
+    externalDocs?: OpenAPIExternalDocumentation;
+    'x-webhooks'?: OpenAPIPaths;
+    webhooks?: OpenAPIPaths;
+    'x-tagGroups'?: Array<{
+        name: string;
+        tags: Array<string>;
+    }>;
+}
+export interface OpenAPIInfo {
+    title: string;
+    version: string;
+    description?: string;
+    summary?: string;
+    termsOfService?: string;
+    contact?: OpenAPIContact;
+    license?: OpenAPILicense;
+}
+export interface OpenAPIServer {
+    url: string;
+    description?: string;
+    variables?: {
+        [name: string]: OpenAPIServerVariable;
+    };
+}
+export interface OpenAPIServerVariable {
+    enum?: string[];
+    default: string;
+    description?: string;
+}
+export interface OpenAPIPaths {
+    [path: string]: OpenAPIPath;
+}
+export interface OpenAPIRef {
+    $ref: string;
+    'x-refsStack'?: string[];
+    summary?: string;
+    description?: string;
+}
+export declare type Referenced<T> = OpenAPIRef | T;
+export interface OpenAPIPath extends Partial<OpenAPIRef> {
+    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>>;
+}
+export interface OpenAPIXCodeSample extends Sample {
+    source: string;
+}
+export interface OpenAPIOperation {
+    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-code-samples'?: OpenAPIXCodeSample[];
+}
+export interface OpenAPIParameter {
+    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;
+}
+export interface OpenAPIExample {
+    value: any;
+    summary?: string;
+    description?: string;
+    externalValue?: string;
+}
+export interface OpenAPISchema {
+    $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;
+}
+export interface OpenAPIDiscriminator {
+    propertyName: string;
+    mapping?: {
+        [name: string]: string;
+    };
+    'x-explicitMappingOnly'?: boolean;
+}
+export interface OpenAPIMediaType {
+    schema?: Referenced<OpenAPISchema>;
+    example?: any;
+    examples?: {
+        [name: string]: Referenced<OpenAPIExample>;
+    };
+    encoding?: {
+        [field: string]: OpenAPIEncoding;
+    };
+}
+export interface OpenAPIEncoding {
+    contentType: string;
+    headers?: {
+        [name: string]: Referenced<OpenAPIHeader>;
+    };
+    style: OpenAPIParameterStyle;
+    explode: boolean;
+    allowReserved: boolean;
+}
+export declare type OpenAPIParameterLocation = 'query' | 'header' | 'path' | 'cookie';
+export declare type OpenAPIParameterStyle = 'matrix' | 'label' | 'form' | 'simple' | 'spaceDelimited' | 'pipeDelimited' | 'deepObject';
+export interface OpenAPIRequestBody {
+    description?: string;
+    required?: boolean;
+    content: {
+        [mime: string]: OpenAPIMediaType;
+    };
+    'x-examples'?: {
+        [mime: string]: {
+            [name: string]: Referenced<OpenAPIExample>;
+        };
+    };
+    'x-example'?: {
+        [mime: string]: any;
+    };
+}
+export interface OpenAPIResponses {
+    [code: string]: OpenAPIResponse;
+}
+export interface OpenAPIResponse {
+    description?: string;
+    headers?: {
+        [name: string]: Referenced<OpenAPIHeader>;
+    };
+    content?: {
+        [mime: string]: OpenAPIMediaType;
+    };
+    links?: {
+        [name: string]: Referenced<OpenAPILink>;
+    };
+    'x-examples'?: {
+        [mime: string]: {
+            [name: string]: Referenced<OpenAPIExample>;
+        };
+    };
+    'x-example'?: {
+        [mime: string]: any;
+    };
+}
+export interface OpenAPILink {
+    $ref?: string;
+}
+export declare type OpenAPIHeader = Omit<OpenAPIParameter, 'in' | 'name'>;
+export interface OpenAPICallback {
+    [name: string]: OpenAPIPath;
+}
+export 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>;
+    };
+}
+export interface OpenAPISecurityRequirement {
+    [name: string]: string[];
+}
+export interface OpenAPISecurityScheme {
+    type: 'apiKey' | 'http' | 'oauth2' | 'openIdConnect';
+    description?: string;
+    name?: string;
+    in?: 'query' | 'header' | 'cookie';
+    scheme?: string;
+    bearerFormat: string;
+    'x-defaultClientId'?: string;
+    flows: {
+        implicit?: {
+            refreshUrl?: string;
+            scopes: Record<string, string>;
+            authorizationUrl: string;
+            'x-defaultClientId'?: string;
+            'x-tokenEndpointAuthMethod'?: 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;
+            'x-tokenEndpointAuthMethod'?: string;
+        };
+        authorizationCode?: {
+            refreshUrl?: string;
+            scopes: Record<string, string>;
+            authorizationUrl: string;
+            tokenUrl: string;
+            'x-defaultClientId'?: string;
+            'x-tokenEndpointAuthMethod'?: string;
+        };
+    };
+    openIdConnectUrl?: string;
+}
+export interface OpenAPITag {
+    name: string;
+    description?: string;
+    externalDocs?: OpenAPIExternalDocumentation;
+    'x-displayName'?: string;
+}
+export interface OpenAPIExternalDocumentation {
+    description?: string;
+    url: string;
+}
+export interface OpenAPIContact {
+    name?: string;
+    url?: string;
+    email?: string;
+}
+export interface OpenAPILicense {
+    name: string;
+    url?: string;
+    identifier?: string;
+}
+export interface ParsedDocument extends OpenAPIDefinition {
+    swagger: unknown;
+}

package/lib-browser/redoc-lib/src/types/open-api.js

@@ -0,0 +1,2 @@
+export{};
+//# sourceMappingURL=open-api.js.map

package/lib-browser/redoc-lib/src/types/server.d.ts

@@ -0,0 +1,7 @@
+export interface ServerVariables {
+    [name: string]: string;
+}
+export interface Server {
+    url: string;
+    variables: ServerVariables;
+}

package/lib-browser/redoc-lib/src/types/server.js

@@ -0,0 +1,2 @@
+export{};
+//# sourceMappingURL=server.js.map

package/lib-browser/redoc-lib/src/utils/JsonPointer.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Wrapper for JsonPointer. Provides common operations
+ */
+export declare class JsonPointer {
+    /**
+     * returns last JsonPointer token
+     * if level > 1 returns levels last (second last/third last)
+     * @example
+     * // returns subpath
+     * JsonPointerHelper.baseName('/path/0/subpath')
+     * // returns foo
+     * JsonPointerHelper.baseName('/path/foo/subpath', 2)
+     */
+    static baseName(pointer?: string, level?: number): string;
+    /**
+     * returns dirname of pointer
+     * if level > 1 returns corresponding dirname in the hierarchy
+     * @example
+     * // returns /path/0
+     * JsonPointerHelper.dirName('/path/0/subpath')
+     * // returns /path
+     * JsonPointerHelper.dirName('/path/foo/subpath', 2)
+     */
+    static dirName(pointer: string, level?: number): string;
+    /**
+     * returns relative path tokens
+     * @example
+     * // returns ['subpath']
+     * JsonPointerHelper.relative('/path/0', '/path/0/subpath')
+     * // returns ['foo', 'subpath']
+     * JsonPointerHelper.relative('/path', '/path/foo/subpath')
+     */
+    static relative(from: string, to: string): string[];
+    /**
+     * overridden JsonPointer original parse to take care of prefixing '#' symbol
+     * that is not valid JsonPointer
+     */
+    static parse(pointer?: string): string[];
+    /**
+     * Creates a JSON pointer path, by joining one or more tokens to a base path.
+     *
+     * @param {string} base - The base path
+     * @param {string|string[]} tokens - The token(s) to append (e.g. ["name", "first"])
+     * @returns {string}
+     */
+    static join(base: string, tokens: string | string[]): string;
+    static get<T>(object: GenericObject, pointer: string): T;
+    static compile(tokens: string[]): string;
+    static escape(pointer: string): string;
+}
+export default JsonPointer;

package/lib-browser/redoc-lib/src/utils/JsonPointer.js

@@ -0,0 +1,2 @@
+"use strict";import JsonPointerLib from"json-pointer";const origParse=JsonPointerLib.parse;export class JsonPointer{static baseName(t="",e=1){const n=JsonPointer.parse(t);return n[n.length-e]}static dirName(t,e=1){const n=JsonPointer.parse(t);return JsonPointerLib.compile(n.slice(0,n.length-e))}static relative(t,e){const n=JsonPointer.parse(t);return JsonPointer.parse(e).slice(n.length)}static parse(t=""){let e=t;return"#"===e.charAt(0)&&(e=e.substring(1)),origParse(e)}static join(t,e){const n=JsonPointer.parse(t).concat(e);return JsonPointerLib.compile(n)}static get(t,e){return JsonPointerLib.get(t,e)}static compile(t){return JsonPointerLib.compile(t)}static escape(t){return JsonPointerLib.escape(t)}}JsonPointerLib.parse=JsonPointer.parse,Object.assign(JsonPointer,JsonPointerLib);export default JsonPointer;
+//# sourceMappingURL=JsonPointer.js.map