@redocly/openapi-docs 0.0.0-beta-20240215154132

package/lib-esm/jotai/app.d.ts

@@ -0,0 +1,41 @@
+import { LayoutVariant } from '@redocly/theme';
+import type { MenuLink } from '../types';
+import type { TabType } from '../models/tab';
+export type AppSessionStore = {
+    collapsedSidebar: boolean;
+    activeVersionIdx: number;
+    versionPath: string;
+    language?: TabType;
+};
+export type AppLocalStore = {
+    layout: LayoutVariant;
+};
+export type AppStore = {
+    isSidebarOpened: boolean;
+    activeMimeName: string;
+    menuNextLinks: MenuLink[];
+};
+type LanguageAtom = {
+    languages?: TabType[];
+    activeLanguage: TabType;
+};
+export declare const appStore: import("jotai").PrimitiveAtom<AppStore> & {
+    init: AppStore;
+};
+export declare const isSidebarOpenedAtom: import("jotai").WritableAtom<boolean, boolean[], void>;
+export declare const activeMimeNameAtom: import("jotai").WritableAtom<string, string[], void>;
+export declare const flatMenuItemsAtom: import("jotai").WritableAtom<MenuLink[], MenuLink[][], void>;
+/**
+ * appLocalStore saved to local storage
+ */
+export declare const appLocalStore: import("jotai").WritableAtom<AppLocalStore, [AppLocalStore | typeof import("jotai/utils").RESET | ((prev: AppLocalStore) => AppLocalStore | typeof import("jotai/utils").RESET)], void>;
+export declare const layoutAtom: import("jotai").WritableAtom<LayoutVariant, LayoutVariant[], void>;
+/**
+ * appSessionStore saved to session storage
+ */
+export declare const appSessionStore: import("jotai").WritableAtom<AppSessionStore, [AppSessionStore | typeof import("jotai/utils").RESET | ((prev: AppSessionStore) => AppSessionStore | typeof import("jotai/utils").RESET)], void>;
+export declare const collapsedSidebarAtom: import("jotai").WritableAtom<boolean, boolean[], void>;
+export declare const activeVersionIdxAtom: import("jotai").WritableAtom<number, number[], void>;
+export declare const versionPathAtom: import("jotai").WritableAtom<string, string[], void>;
+export declare const languageAtom: import("jotai").WritableAtom<LanguageAtom, LanguageAtom[], void>;
+export {};

package/lib-esm/jotai/app.js

@@ -0,0 +1,2 @@
+import{atom}from"jotai";import{atomWithStorage,createJSONStorage}from"jotai/utils";import{LayoutVariant,IS_BROWSER}from"@redocly/theme";import{globalStoreAtom}from"./store";import{normalizeLanguages}from"../utils";export const appStore=atom({isSidebarOpened:!0,activeMimeName:"",menuNextLinks:[]});export const isSidebarOpenedAtom=atom((e=>e(appStore).isSidebarOpened),((e,t,o)=>{const a=e(appStore);t(appStore,Object.assign(Object.assign({},a),{isSidebarOpened:o}))}));export const activeMimeNameAtom=atom((e=>e(appStore).activeMimeName),((e,t,o)=>{const a=e(appStore);t(appStore,Object.assign(Object.assign({},a),{activeMimeName:o}))}));export const flatMenuItemsAtom=atom((e=>e(appStore).menuNextLinks),((e,t,o)=>{const a=e(appStore);t(appStore,Object.assign(Object.assign({},a),{menuNextLinks:o}))}));export const appLocalStore=atomWithStorage("redoc.appLocalStore",{layout:LayoutVariant.THREE_PANEL});export const layoutAtom=atom((e=>e(appLocalStore).layout),((e,t,o=LayoutVariant.STACKED)=>{const a=e(appLocalStore);t(appLocalStore,Object.assign(Object.assign({},a),{layout:o}))}));export const appSessionStore=atomWithStorage("redoc.appSessionStore",{collapsedSidebar:!1,activeVersionIdx:0,versionPath:""},IS_BROWSER?createJSONStorage((()=>sessionStorage)):void 0);export const collapsedSidebarAtom=atom((e=>e(appSessionStore).collapsedSidebar),((e,t,o)=>{const a=e(appSessionStore);t(appSessionStore,Object.assign(Object.assign({},a),{collapsedSidebar:o}))}));export const activeVersionIdxAtom=atom((e=>e(appSessionStore).activeVersionIdx),((e,t,o)=>{const a=e(appSessionStore);t(appSessionStore,Object.assign(Object.assign({},a),{activeVersionIdx:o}))}));export const versionPathAtom=atom((e=>e(appSessionStore).versionPath),((e,t,o)=>{const a=e(appSessionStore);o&&t(appSessionStore,Object.assign(Object.assign({},a),{versionPath:o}))}));export const languageAtom=atom((e=>{const{parser:t,options:o}=e(globalStoreAtom),a=normalizeLanguages(t.definition.paths,o.generateCodeSamples);return{languages:a,activeLanguage:e(appSessionStore).language||a[0]}}),((e,t,{activeLanguage:o})=>{const a=e(appSessionStore);t(appSessionStore,Object.assign(Object.assign({},a),{language:o}))}));
+//# sourceMappingURL=app.js.map

package/lib-esm/jotai/nexus.d.ts

@@ -0,0 +1,5 @@
+import type { Getter, Setter } from 'jotai';
+export declare let readAtom: Getter;
+export declare let writeAtom: Setter;
+declare const JotaiNexus: () => null;
+export default JotaiNexus;

package/lib-esm/jotai/nexus.js

@@ -0,0 +1,2 @@
+import{useAtomCallback}from"jotai/utils";import{useCallback}from"react";export let readAtom;export let writeAtom;const JotaiNexus=()=>useAtomCallback(useCallback(((t,e)=>(readAtom=t,writeAtom=e,null)),[]))();export default JotaiNexus;
+//# sourceMappingURL=nexus.js.map

package/lib-esm/jotai/operation.d.ts

@@ -0,0 +1,15 @@
+import type { Server } from '../types/server';
+export type OperationStore = {
+    activeExampleName?: string;
+    activeOneOf: {
+        [pointer: string]: number;
+    };
+    activeServer?: Server;
+    requestValues: {
+        [field: string]: any;
+    };
+    activeResponseTab: string;
+};
+export declare const operationStore: import("jotai/vanilla/utils/atomFamily").AtomFamily<any, import("jotai").PrimitiveAtom<OperationStore> & {
+    init: OperationStore;
+}>;

package/lib-esm/jotai/operation.js

@@ -0,0 +1,2 @@
+import{atom}from"jotai";import{atomFamily}from"jotai/utils";import deepEqual from"fast-deep-equal";export const operationStore=atomFamily((e=>atom({activeExampleName:void 0,activeOneOf:{[e]:0},activeServer:void 0,requestValues:{},activeResponseTab:"200"})),deepEqual);
+//# sourceMappingURL=operation.js.map

package/lib-esm/jotai/store.d.ts

@@ -0,0 +1,21 @@
+import type { Options, OpenAPIParser } from '../services';
+export interface OpenAPIDefinitionVersion {
+    id: string;
+    title: string;
+    url?: string;
+    parser: OpenAPIParser;
+}
+export type GlobalStore = {
+    options: Options;
+    versions: Array<OpenAPIDefinitionVersion>;
+};
+export declare const globalStore: import("jotai").PrimitiveAtom<GlobalStore> & {
+    init: GlobalStore;
+};
+export type GlobalStoreAtom = {
+    parser: OpenAPIParser;
+    options: Options;
+    hasVersions: boolean;
+};
+export declare const globalStoreAtom: import("jotai").Atom<GlobalStoreAtom>;
+export declare const globalOptionsAtom: import("jotai").Atom<Options>;

package/lib-esm/jotai/store.js

@@ -0,0 +1,2 @@
+import{atom}from"jotai";import{activeVersionIdxAtom}from"./app";export const globalStore=atom({options:{},versions:[]});export const globalStoreAtom=atom((o=>{var t;const{versions:r,options:s}=o(globalStore);return{parser:null===(t=r[o(activeVersionIdxAtom)||0])||void 0===t?void 0:t.parser,options:s,hasVersions:r.length>1}}));export const globalOptionsAtom=atom((o=>o(globalStore).options));
+//# sourceMappingURL=store.js.map

package/lib-esm/models/callback.d.ts

@@ -0,0 +1,4 @@
+import type { Options, OpenAPIParser } from '../services';
+import type { OpenAPICallback, Referenced } from '../types';
+import type { CallbackModel, GroupModel } from './types';
+export declare function getCallback(parser: OpenAPIParser, name: string, infoOrRef: Referenced<OpenAPICallback>, parentPointer: string, options: Options, href: string, parent?: GroupModel): CallbackModel;

package/lib-esm/models/callback.js

@@ -0,0 +1,2 @@
+import{isOperationName,JsonPointer}from"../utils";import{getOperation}from"./operation";import{joinWithSeparator}from"../services";export function getCallback(e,t,r,o,a,s,i){const{resolved:n}=e.deref(r),p=[];for(const r of Object.keys(n)){const c=n[r],m=Object.keys(c).filter(isOperationName);for(const n of m){const m=c[n],f=getOperation(e,Object.assign(Object.assign({},m),{pathName:r,pointer:JsonPointer.join(o,["callbacks",t,n]),httpVerb:n,pathParameters:c.parameters||[],pathServers:c.servers}),i,a,s,{isCallback:!0,id:joinWithSeparator(t,n)});p.push(f)}}return{name:t,operations:p}}
+//# sourceMappingURL=callback.js.map

package/lib-esm/models/code-sample-options.d.ts

@@ -0,0 +1,11 @@
+import type { CodeSamplesConfig } from '../services';
+import type { Events } from '../events';
+export interface CodeSampleOptions {
+    payloadSampleIdx: number;
+    hideRequestPayloadSample: boolean;
+    hideSingleRequestSampleTab: boolean;
+    generatedPayloadSamplesMaxDepth: number;
+    onlyRequiredInSamples: boolean;
+    events: Pick<Events, 'codeSamplesLanguageSwitch' | 'codeSamplesCopy'>;
+    generateCodeSamples?: CodeSamplesConfig;
+}

package/lib-esm/models/code-sample-options.js

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

package/lib-esm/models/example.d.ts

@@ -0,0 +1,10 @@
+import type { OpenAPIExample, Referenced } from '../types';
+import type { OpenAPIParser } from '../services';
+import type { ExampleModel } from './types';
+export declare function getExternalExampleValue(mimeType: string, externalValueUrl?: string): Promise<string | undefined>;
+type GetExamplesInput = Pick<ExampleModel, 'mime' | 'encoding'> & {
+    parser: OpenAPIParser;
+    infoOrRef: Referenced<OpenAPIExample>;
+};
+export declare function getExamples({ parser, infoOrRef, mime, encoding }: GetExamplesInput): ExampleModel;
+export {};

package/lib-esm/models/example.js

@@ -0,0 +1,2 @@
+import{resolve as urlResolve}from"url";import{getValueFromMdParsedExtension,isJsonLike}from"../utils";const ExternalExamplesCache={};export function getExternalExampleValue(e,r){return r?(r in ExternalExamplesCache||(ExternalExamplesCache[r]=fetch(r).then((r=>r.text().then((t=>{if(!r.ok)return Promise.reject(new Error(t));if(!isJsonLike(e))return t;try{return JSON.parse(t)}catch(e){return t}}))))),ExternalExamplesCache[r]):Promise.resolve(void 0)}export function getExamples({parser:e,infoOrRef:r,mime:t,encoding:n}){let a;const{resolved:l}=e.deref(r),o=l.value,s=l.value,i=getValueFromMdParsedExtension(l,"summary"),u=getValueFromMdParsedExtension(l,"description");return l.externalValue&&(a=urlResolve(e.definitionUrl||"",l.externalValue)),{value:s,rawValue:o,externalValueUrl:a,summary:i,description:u,mime:t,encoding:n}}
+//# sourceMappingURL=example.js.map

package/lib-esm/models/field.d.ts

@@ -0,0 +1,7 @@
+import type { OpenAPIParser, Options } from '../services';
+import type { OpenAPIParameter, Referenced } from '../types';
+import type { FieldModel, Deps } from './types';
+export declare function getField(parser: OpenAPIParser, infoOrRef: Referenced<OpenAPIParameter> & {
+    name?: string;
+    kind?: string;
+}, pointer: string, options: Options, deps: Deps, refsStack?: string[], absolutePointer?: string): FieldModel;

package/lib-esm/models/field.js

@@ -0,0 +1,2 @@
+import{extractExtensions,getValueFromMdParsedExtension,mapValues}from"../utils";import{getSchema}from"./schema";import{getExamples}from"./example";const DEFAULT_SERIALIZATION={path:{style:"simple",explode:!1},query:{style:"form",explode:!0},header:{style:"simple",explode:!1},cookie:{style:"form",explode:!0}};export function getField(e,o,t,l,i,n,s=t){var d,a,r,p,m,c,x;const{resolved:u}=e.deref(o),v=o.kind||"field",f=o.name||u.name,h=u.in,E=!!u.required;let g,F,y=u.schema,O="";if(!y&&u.in&&u.content){O=Object.keys(u.content)[0];const o=u.content[O];y=o&&(null==o?void 0:o.example)?Object.assign(Object.assign({},e.deref(o.schema,n,!0).resolved),{example:u.example||o.example}):o.schema}const A=(null==i?void 0:i.parentFieldFullPath)?i.parentFieldFullPath+"/"+f:f,I=getSchema({parser:e,schemaOrRef:y||{},pointer:t,options:l,baseRefsStack:n,absolutePointer:o.$ref||(null===(d=u.schema)||void 0===d?void 0:d.absolutePointer)||s,deps:Object.assign(Object.assign({},i),{parentFieldFullPath:A,in:h})}),P=void 0===u.description?getValueFromMdParsedExtension(I,"description")||"":getValueFromMdParsedExtension(u,"description"),b=u.example||I.example,L=u.examples||(null===(r=null===(a=u.content)||void 0===a?void 0:a[O])||void 0===r?void 0:r.examples),R=L?mapValues(L,((o,t)=>getExamples({parser:e,infoOrRef:o,mime:t,encoding:u.encoding}))):void 0;O?g=O:u.style?F=u.style:h&&(F=null!==(m=null===(p=DEFAULT_SERIALIZATION[h])||void 0===p?void 0:p.style)&&void 0!==m?m:"form");const S=void 0===u.explode&&h?null===(x=null===(c=DEFAULT_SERIALIZATION[h])||void 0===c?void 0:c.explode)||void 0===x||x:!!u.explode;return{deps:i||{},schema:I,name:f,required:E,description:P,example:b,examples:R,deprecated:void 0===u.deprecated?I.deprecated:u.deprecated,in:h,kind:v,extensions:l.showExtensions?extractExtensions(u,l.showExtensions):void 0,explode:S,style:F,const:(null==I?void 0:I.const)||(null==u?void 0:u.const)||"",serializationMime:g,fieldFullPath:A}}
+//# sourceMappingURL=field.js.map

package/lib-esm/models/group.d.ts

@@ -0,0 +1,4 @@
+import type { OpenAPITag } from '../types';
+import type { MarkdownHeading, MenuItemGroupType, Options } from '../services';
+import type { GroupModel } from './types';
+export declare function getTagOrGroup(type: MenuItemGroupType, tagOrGroup: OpenAPITag | MarkdownHeading, { markdownHeadingsAnchorLevel }: Pick<Options, 'markdownHeadingsAnchorLevel'>, parent?: GroupModel): GroupModel;

package/lib-esm/models/group.js

@@ -0,0 +1,2 @@
+import{joinWithSeparator}from"../services";import{getValueFromMdParsedExtension,safeSlugify}from"../utils";import{getHref}from"../services/menu/operation";import{saveTextBeforeHeading}from"../utils/saveTextBeforeHeading";export function getTagOrGroup(e,i,{markdownHeadingsAnchorLevel:r},t){let a;a=(null==t?void 0:t.id)&&"schema"===e?joinWithSeparator(t.id,safeSlugify(i.name)):i.id||safeSlugify(i.name);const o=i["x-displayName"]||i.name,s=i.level||1,n=i.isSchema,m=i.ast||void 0;return{id:a,type:e,parent:t,name:o,level:s,depth:0,isSchema:n,description:saveTextBeforeHeading(getValueFromMdParsedExtension(i,"description")||"",r),items:i.items,ast:m,externalDocs:i.externalDocs,href:getHref({id:a})}}
+//# sourceMappingURL=group.js.map

package/lib-esm/models/index.d.ts

@@ -0,0 +1,15 @@
+export * from './code-sample-options';
+export { getTagOrGroup } from './group';
+export { getOperation, isPayloadSample } from './operation';
+export type { Sample, XPayloadSample } from './operation';
+export { getRequestBody } from './request';
+export { getExamples, getExternalExampleValue } from './example';
+export { getActiveMediaType, getMediaContent } from './mediaContent';
+export type { MediaContentModel, OperationModel, GroupModel, SchemaModel } from './types';
+export { getMediaType } from './mediaType';
+export { getResponse } from './response';
+export { getSchema } from './schema';
+export { getField } from './field';
+export { getCallback } from './callback';
+export * from './security';
+export * from './types';

package/lib-esm/models/index.js

@@ -0,0 +1,2 @@
+export*from"./code-sample-options";export{getTagOrGroup}from"./group";export{getOperation,isPayloadSample}from"./operation";export{getRequestBody}from"./request";export{getExamples,getExternalExampleValue}from"./example";export{getActiveMediaType,getMediaContent}from"./mediaContent";export{getMediaType}from"./mediaType";export{getResponse}from"./response";export{getSchema}from"./schema";export{getField}from"./field";export{getCallback}from"./callback";export*from"./security";export*from"./types";
+//# sourceMappingURL=index.js.map

package/lib-esm/models/mediaContent.d.ts

@@ -0,0 +1,7 @@
+import type { MediaContentModel, MediaContentModelInput } from './types';
+/**
+ * MediaContent model ready to be sued by React components
+ * Contains multiple MediaTypes and keeps track of the currently active one
+ */
+export declare function getMediaContent({ parser, info, isRequestType, options, data: { operation, type, response, absolutePointer }, }: MediaContentModelInput): MediaContentModel;
+export declare function getActiveMediaType(content: MediaContentModel, mime?: string): import("./types").MediaTypeModel;

package/lib-esm/models/mediaContent.js

@@ -0,0 +1,2 @@
+import{readAtom}from"../jotai/nexus";import{mergeSimilarMediaTypes}from"../utils";import{getMediaType}from"./mediaType";import{activeMimeNameAtom}from"../jotai/app";export function getMediaContent({parser:e,info:t,isRequestType:i,options:a,data:{operation:o,type:r,response:p,absolutePointer:m=""}}){a.unstable_ignoreMimeParameters&&(t=mergeSimilarMediaTypes(t));const s=Object.keys(t).map((s=>getMediaType(e,s,i,t[s],a,{operation:o,type:r,response:p,absolutePointer:m}))),n=s.filter((e=>!!e.examples)).length>0;return{mediaTypes:s,isRequestType:i,hasSample:n,operation:o}}export function getActiveMediaType(e,t){const i=t||readAtom(activeMimeNameAtom);return i&&e.mediaTypes.find((e=>e.name===i))||e.mediaTypes[0]}
+//# sourceMappingURL=mediaContent.js.map

package/lib-esm/models/mediaType.d.ts

@@ -0,0 +1,19 @@
+import type { OpenAPIMediaType } from '../types';
+import type { OpenAPIParser, Options } from '../services';
+import type { MediaTypeModel, ResponseModel, OperationModel } from './types';
+/**
+ * @param parser
+ * @param name
+ * @param isRequestType needed to know if skip RO/RW fields in objects
+ * @param info
+ * @param options
+ * @param operation
+ * @param type
+ * @param response
+ */
+export declare function getMediaType(parser: OpenAPIParser, name: string, isRequestType: boolean, info: OpenAPIMediaType, options: Options, { operation, type, response, absolutePointer, }: {
+    operation: OperationModel;
+    type?: 'request' | 'response';
+    response?: ResponseModel;
+    absolutePointer?: string;
+}): MediaTypeModel;

package/lib-esm/models/mediaType.js

@@ -0,0 +1,2 @@
+import*as Sampler from"openapi-sampler";import{getSchema}from"./schema";import{isFormUrlEncoded,isJsonLike,JsonPointer,mapValues}from"../utils";import{getExamples}from"./example";function generateExamples({parser:e,info:{encoding:a,schema:o},schema:n,mime:i,isRequestType:r,onlyRequiredInSamples:s,generatedPayloadSamplesMaxDepth:m}){const p={skipReadOnly:r,skipWriteOnly:!r,skipNonRequired:r&&s,maxSampleDepth:m};let t={};if(n&&n.oneOf)for(const o of n.oneOf){const r=Sampler.sample(o.rawSchema,p,e.definition);n.discriminatorProp&&"object"==typeof r&&r&&(r[n.discriminatorProp]=o.title),t[o.title]=getExamples({parser:e,infoOrRef:{value:r},mime:i,encoding:a})}else t=n?{default:getExamples({parser:e,infoOrRef:{value:Sampler.sample(o,p,e.definition)},mime:i,encoding:a})}:{default:{value:null,rawValue:"null"}};return t}export function getMediaType(e,a,o,n,i,{operation:r,type:s,response:m,absolutePointer:p=""}){let t;const l=n.schema&&getSchema({parser:e,schemaOrRef:n.schema,pointer:"",absolutePointer:JsonPointer.join(p,["content",a,"schema"]),options:i,deps:{operation:r,type:s,response:m}}),{onlyRequiredInSamples:d,generatedPayloadSamplesMaxDepth:c}=i,{encoding:f,examples:u,example:g}=n;return void 0!==u?t=mapValues(u,(o=>getExamples({parser:e,infoOrRef:o,mime:a,encoding:f}))):void 0!==g?t={default:getExamples({parser:e,infoOrRef:{value:e.deref(g).resolved},mime:a,encoding:f})}:(isJsonLike(a)||isFormUrlEncoded(a))&&(t=generateExamples({parser:e,info:n,schema:l,mime:a,isRequestType:o,onlyRequiredInSamples:d,generatedPayloadSamplesMaxDepth:c})),{examples:t,schema:l,name:a,isRequestType:o,onlyRequiredInSamples:d,operation:r}}
+//# sourceMappingURL=mediaType.js.map

package/lib-esm/models/operation.d.ts

@@ -0,0 +1,19 @@
+import type { ExtendedOpenAPIOperation, Unstable_ExternalCodeSample, OpenAPIParser, Options } from '../services';
+import type { OpenAPIServer, OpenAPIXCodeSample } from '../types';
+import type { MediaContentModel, OperationModel, GroupModel } from './types';
+export interface Sample {
+    lang: string;
+    label?: string;
+}
+export interface XPayloadSample extends Sample {
+    lang: 'payload';
+    requestBodyContent: MediaContentModel;
+    source: string;
+}
+export interface Callback {
+    isCallback: boolean;
+    id?: string;
+}
+export declare function isPayloadSample(sample: XPayloadSample | OpenAPIXCodeSample | Unstable_ExternalCodeSample): sample is XPayloadSample;
+export declare function getOperation(parser: OpenAPIParser, operationDefinition: ExtendedOpenAPIOperation, parent: GroupModel | undefined, options: Options, href: string, callback?: Callback): OperationModel;
+export declare function mergeInMockServer(servers: OpenAPIServer[], mockServerOptions: Options['mockServer']): OpenAPIServer[];

package/lib-esm/models/operation.js

@@ -0,0 +1,2 @@
+import{extractExtensions,getOperationId,getOperationName,getStatusCodeType,getValueFromMdParsedExtension,isStatusCode,JsonPointer,mergeParams,normalizeServers,sortByField,sortByRequired,getInitialServerWithVariables}from"../utils";import{getCallback}from"./callback";import{getField}from"./field";import{getRequestBody}from"./request";import{getSecurityRequirement}from"./security";import{getResponse}from"./response";export function isPayloadSample(e){return"payload"===e.lang&&"requestBodyContent"in e}let isCodeSamplesWarningPrinted=!1;export function getOperation(e,r,t,o,s,i){var a,n,l;const p=r.isWebhook,d={operationDefinition:r,parent:t,pointer:r.pointer,description:getValueFromMdParsedExtension(r,"description"),externalDocs:r.externalDocs,deprecated:!!r.deprecated,httpVerb:r.httpVerb,operationId:r.operationId,path:r.pathName,isWebhook:p,isCallback:Boolean(null==i?void 0:i.isCallback),isEvent:(null==i?void 0:i.isCallback)||p,name:getOperationName(r),defaultExampleName:r.defaultSampleName,type:"operation",callbackId:null==i?void 0:i.id,href:s,get callbacks(){return Object.keys(r.callbacks||[]).map((i=>{var a;return getCallback(e,i,null===(a=r.callbacks)||void 0===a?void 0:a[i],d.pointer,o,s,t)}))},get responses(){let t=!1;return Object.keys(r.responses||[]).filter((e=>"default"===e||("success"===getStatusCodeType(e)&&(t=!0),isStatusCode(e)))).map((s=>getResponse({parser:e,code:s,defaultAsError:t,infoOrRef:r.responses[s],options:o,isEvent:d.isEvent,operation:d})))},get parameters(){let t=mergeParams(e,r.pathParameters,r.parameters,{pathPointer:JsonPointer.dirName(d.pointer),operationPointer:d.pointer}).map((({paramOrRef:r,pointer:t})=>getField(e,r,t,o,{operation:d,type:"request"})));return o.sortPropsAlphabetically&&(t=sortByField(t,"name")),o.requiredPropsFirst&&(t=sortByRequired(t)),t}};(null==i?void 0:i.isCallback)?(d.security=(r.security||[]).map((r=>getSecurityRequirement({requirement:r,parser:e}))),d.servers=normalizeServers("",r.servers||r.pathServers||[])):(d.id=getOperationId(r,t),d.security=(r.security||e.definition.security||[]).map((r=>getSecurityRequirement({requirement:r,parser:e}))),d.servers=normalizeServers(e.definitionUrl,mergeInMockServer(r.servers||r.pathServers||e.definition.servers||[],o.mockServer))),o.showExtensions&&(d.extensions=extractExtensions(r,o.showExtensions)),d.activeServer=getInitialServerWithVariables(d.servers),d.requestBody=r.requestBody&&getRequestBody({parser:e,infoOrRef:r.requestBody,options:o,operation:d,isEvent:d.isEvent});const u=null===(n=null===(a=d.requestBody)||void 0===a?void 0:a.content)||void 0===n?void 0:n.mediaTypes,[m]=u||[],[c]=Object.keys((null==m?void 0:m.examples)||[]);d.activeExampleName=!1===r.defaultSampleName?void 0:r.defaultSampleName||c;const v=null===(l=d.requestBody)||void 0===l?void 0:l.content;return d.payload=(null==v?void 0:v.hasSample)?{lang:"payload",label:"Payload",source:"",requestBodyContent:v}:void 0,d.definitionSamples=r["x-codeSamples"]||r["x-code-samples"]||[],r["x-code-samples"]&&!isCodeSamplesWarningPrinted&&(isCodeSamplesWarningPrinted=!0,console.warn('"x-code-samples" is deprecated. Use "x-codeSamples" instead')),d.hasSamples=(null==v?void 0:v.hasSample)||d.definitionSamples.length>0,d}export function mergeInMockServer(e,r){if(!r)return e;const t={url:r.url,description:r.description};switch(r.position){case"first":return[t,...e];case"last":return[...e,t];case"replace":return[t];default:return e}}
+//# sourceMappingURL=operation.js.map

package/lib-esm/models/request.d.ts

@@ -0,0 +1,12 @@
+import type { OpenAPIRequestBody, Referenced } from '../types';
+import type { OpenAPIParser, Options } from '../services';
+import type { RequestBodyModel, OperationModel } from './types';
+type GetRequestBodyInput = {
+    parser: OpenAPIParser;
+    infoOrRef: Referenced<OpenAPIRequestBody>;
+    options: Options;
+    isEvent?: boolean;
+    operation: OperationModel;
+};
+export declare function getRequestBody({ parser, infoOrRef, options, isEvent, operation, }: GetRequestBodyInput): RequestBodyModel;
+export {};

package/lib-esm/models/request.js

@@ -0,0 +1,2 @@
+import{getContentWithLegacyExamples,getValueFromMdParsedExtension,JsonPointer}from"../utils";import{getMediaContent}from"./mediaContent";export function getRequestBody({parser:e,infoOrRef:t,options:o,isEvent:n,operation:r}){const{resolved:i}=e.deref(t),s=getValueFromMdParsedExtension(i,"description")||"",a=i.required;let d;const p=!n,u=getContentWithLegacyExamples(i);return void 0!==u&&(d=getMediaContent({parser:e,info:u,isRequestType:p,options:o,data:{operation:r,type:"request",absolutePointer:t.$ref||JsonPointer.join(r.pointer,["requestBody"])}})),{description:s,required:a,content:d}}
+//# sourceMappingURL=request.js.map

package/lib-esm/models/response.d.ts

@@ -0,0 +1,14 @@
+import type { OpenAPIResponse, Referenced } from '../types';
+import type { OpenAPIParser, Options } from '../services';
+import type { ResponseModel, OperationModel } from './types';
+type ResponseProps = {
+    parser: OpenAPIParser;
+    code: string;
+    defaultAsError: boolean;
+    infoOrRef: Referenced<OpenAPIResponse>;
+    options: Options;
+    operation: OperationModel;
+    isEvent?: boolean;
+};
+export declare function getResponse({ parser, code, defaultAsError, infoOrRef, options, isEvent, operation, }: ResponseProps): ResponseModel;
+export {};

package/lib-esm/models/response.js

@@ -0,0 +1,2 @@
+import{getStatusCodeType,getContentWithLegacyExamples,JsonPointer,getValueFromMdParsedExtension}from"../utils";import{getField}from"./field";import{getMediaContent}from"./mediaContent";export function getResponse({parser:e,code:t,defaultAsError:o,infoOrRef:n,options:s,isEvent:r,operation:i}){const a=!!r,{resolved:d}=e.deref(n),p={code:t};void 0!==d["x-summary"]?(p.summary=getValueFromMdParsedExtension(d,"x-summary"),p.description=getValueFromMdParsedExtension(d,"description")||""):(p.summary=getValueFromMdParsedExtension(d,"description")||"",p.description=""),p.type=getStatusCodeType(t,o);const m=d.headers,u=n.$ref||JsonPointer.join((null==i?void 0:i.pointer)||"",["responses",t]);void 0!==m&&(p.headers=Object.keys(m).map((t=>{const o=m[t];return getField(e,Object.assign(Object.assign({},o),{name:t}),JsonPointer.join(u,["headers",t]),s,{operation:i,type:"response",response:p})})));const c=getContentWithLegacyExamples(d);return void 0!==c&&(p.content=getMediaContent({parser:e,info:c,isRequestType:a,options:s,data:{operation:i,type:"response",response:p,absolutePointer:u}})),p}
+//# sourceMappingURL=response.js.map

package/lib-esm/models/schema.d.ts

@@ -0,0 +1,13 @@
+import type { OpenAPISchema, Referenced } from '../types';
+import type { OpenAPIParser, Options } from '../services';
+import type { Deps, SchemaModel } from './types';
+export declare function getSchema({ parser, schemaOrRef, pointer, options, isChild, baseRefsStack, deps, absolutePointer, }: {
+    parser: OpenAPIParser;
+    schemaOrRef: Referenced<OpenAPISchema>;
+    pointer: string;
+    options: Options;
+    isChild?: boolean;
+    baseRefsStack?: string[];
+    deps: Deps;
+    absolutePointer?: string;
+}): SchemaModel;

package/lib-esm/models/schema.js

@@ -0,0 +1,2 @@
+var __rest=this&&this.__rest||function(e,t){var i={};for(var n in e)Object.prototype.hasOwnProperty.call(e,n)&&t.indexOf(n)<0&&(i[n]=e[n]);if(null!=e&&"function"==typeof Object.getOwnPropertySymbols){var r=0;for(n=Object.getOwnPropertySymbols(e);r<n.length;r++)t.indexOf(n[r])<0&&Object.prototype.propertyIsEnumerable.call(e,n[r])&&(i[n[r]]=e[n[r]])}return i};import{isObject}from"@redocly/theme";import{pushRef}from"../services/OpenAPIParser";import{detectType,extractExtensions,getValueFromMdParsedExtension,humanizeConstraints,isNamedDefinition,isPrimitiveType,JsonPointer,pluralizeType,sortByField,sortByRequired}from"../utils";import{getField}from"./field";export function getSchema({parser:e,schemaOrRef:t,pointer:i,options:n,isChild:r=!1,baseRefsStack:s=[],deps:o,absolutePointer:a}){var l,p,d,m,c,f,y,u;const{resolved:O,refsStack:h}=e.deref(t,s,!0),b=t.$ref||i||a||"",v=pushRef(h,b),P=e.mergeAllOf(O,b,v,t.$ref||a),g=P.type||detectType(P),x={parser:e,options:n,deps:o,schemaOrRef:t,isChild:r,typePrefix:"",pointer:b,absolutePointer:a,refsStack:v,rawSchema:O,type:g,isCircular:!!P["x-circular-ref"],title:P.title||isNamedDefinition(b)&&JsonPointer.baseName(b)||"",description:getValueFromMdParsedExtension(P,"description")||"",format:P.format,enum:P.enum||[],example:P.example,deprecated:!!P.deprecated,pattern:P.pattern,externalDocs:P.externalDocs,displayFormat:P.format,isPrimitive:isPrimitiveType(P,g),constraints:humanizeConstraints(P),default:P.default,readOnly:!!P.readOnly,writeOnly:!!P.writeOnly,const:P.const||"",contentEncoding:P.contentEncoding,contentMediaType:P.contentMediaType,minItems:P.minItems,maxItems:P.maxItems,nullable:P.nullable||P["x-nullable"],schema:P,displayType:"",items:void 0,extensions:void 0,oneOfType:"",discriminatorProp:void 0,oneOf:void 0,"x-enumDescriptions":getValueFromMdParsedExtension(P,"x-enumDescriptions"),get fields(){if(hasType(x,"object")||hasType(x,"array")&&(Array.isArray(P.items)||Array.isArray(P.prefixItems)))return buildFields(e,P,b,n,v,o)}};if((P.nullable||P["x-nullable"])&&(Array.isArray(x.type)&&!x.type.some((e=>null===e||"null"===e))?x.type=[...x.type,"null"]:Array.isArray(x.type)||null===x.type&&"null"===x.type||(x.type=[x.type,"null"])),x.displayType=Array.isArray(x.type)?x.type.map((e=>null===e?"null":e)).join(" or "):x.type,x.isCircular)return x;if(P.if&&P.then||P.if&&P.else){const{oneOf:t,oneOfType:i}=initConditionalOperators({schema:P,parser:e,pointer:b,options:n,deps:o,refsStack:v});return x.oneOf=t,x.oneOfType=i,x}if(!r&&void 0!==getDiscriminator(P)){const{oneOf:t,discriminatorProp:i}=initDiscriminator({schema:P,parser:e,deps:o,mergedSchema:P,options:n,pointer:b,refsStack:v});return x.oneOf=t,x.discriminatorProp=i,x}if(r&&Array.isArray(P.oneOf)&&P.oneOf.find((e=>e.$ref===b))&&delete P.oneOf,void 0!==P.oneOf){const{oneOf:t,displayType:i}=initOneOf({schemaOneOf:P.oneOf,parser:e,deps:o,options:n,pointer:b,refsStack:v,schema:P});return x.oneOfType="One of",t&&(x.oneOf=t),x.displayType=i,void 0!==P.anyOf&&console.warn(`oneOf and anyOf are not supported on the same level. Skipping anyOf at ${b}`),x}if(void 0!==P.anyOf){const{oneOf:t,displayType:i}=initOneOf({schemaOneOf:P.anyOf,parser:e,deps:o,options:n,pointer:b,refsStack:v,schema:P});return t&&(x.oneOf=t),x.displayType=i,x.oneOfType="Any of",x}if(hasType(x,"array")&&(P.items&&(x.items=getSchema({parser:e,schemaOrRef:P.items,pointer:b+"/items",options:n,baseRefsStack:v,deps:o,absolutePointer:JsonPointer.join(P.absolutePointer||"",["items"])})),x.displayType=P.prefixItems||Array.isArray(P.items)?"items":pluralizeType((null===(l=x.items)||void 0===l?void 0:l.displayType)||x.displayType),x.displayFormat=(null===(p=x.items)||void 0===p?void 0:p.format)||"",x.typePrefix=(null===(d=x.items)||void 0===d?void 0:d.typePrefix)||"Array of ",x.title=x.title||(null===(m=x.items)||void 0===m?void 0:m.title)||"",x.isPrimitive=void 0!==(null===(c=x.items)||void 0===c?void 0:c.isPrimitive)?null===(f=x.items)||void 0===f?void 0:f.isPrimitive:x.isPrimitive,void 0===x.example&&void 0!==(null===(y=x.items)||void 0===y?void 0:y.example)&&(x.example=[x.items.example]),(null===(u=x.items)||void 0===u?void 0:u.isPrimitive)&&(x.enum=x.items.enum,x["x-enumDescriptions"]=getValueFromMdParsedExtension(x.items,"x-enumDescriptions")),Array.isArray(x.type))){const e=x.type.filter((e=>"array"!==e));e.length&&(x.displayType+=` or ${e.join(" or ")}`)}return x.enum.length&&n.sortEnumValuesAlphabetically&&x.enum.sort(),n.showExtensions&&(x.extensions=extractExtensions(P,n.showExtensions)),x}function initDiscriminator({schema:e,parser:t,pointer:i,options:n,refsStack:r,deps:s,mergedSchema:o}){const a=getDiscriminator(e),l=null==a?void 0:a.propertyName,p=t.findDerived([...o["x-parentRefs"]||[],i]);if(e.oneOf)for(const t of e.oneOf){if(void 0===t.$ref)continue;const e=JsonPointer.baseName(t.$ref);p[t.$ref]=e}const d=(null==a?void 0:a.mapping)||{};let m=(null==a?void 0:a["x-explicitMappingOnly"])||!1;0===Object.keys(d).length&&(m=!1);const c={};for(const e in d){const t=d[e];Array.isArray(c[t])?c[t].push(e):c[t]=[e]}const f=m?Object.assign({},c):Object.assign(Object.assign({},p),c);let y=[];for(const e of Object.keys(f)){const t=f[e];if(Array.isArray(t))for(const i of t)y.push({$ref:e,name:i});else y.push({$ref:e,name:t})}const u=Object.keys(d);0!==u.length&&(y=y.sort(((e,t)=>{const i=u.indexOf(e.name),n=u.indexOf(t.name);return i<0&&n<0?e.name.localeCompare(t.name):i<0?1:n<0?-1:i-n})));return{oneOf:y.map((({$ref:e,name:i},a)=>{const l=getSchema({parser:t,schemaOrRef:{$ref:e},pointer:e,options:n,isChild:!0,baseRefsStack:r.slice(0,-1),deps:Object.assign(Object.assign({},s),{parentFieldFullPath:s.parentFieldFullPath?s.parentFieldFullPath+"/"+a:a.toString()}),absolutePointer:o.absolutePointer});return l.title=i,l})),discriminatorProp:l}}function initOneOf({schemaOneOf:e,parser:t,refsStack:i,pointer:n,schema:r,options:s,deps:o}){const a=e.map(((e,a)=>{const{resolved:l,refsStack:p}=t.deref(e,i,!0),d=t.mergeAllOf(l,n+"/oneOf/"+a,p),m=isNamedDefinition(e.$ref)&&!d.title?JsonPointer.baseName(e.$ref):`${d.title||""}${d.const&&JSON.stringify(d.const)||""}`;return getSchema({parser:t,schemaOrRef:Object.assign(Object.assign({},d),{title:m,allOf:[Object.assign(Object.assign({},r),{oneOf:void 0,anyOf:void 0})],discriminator:l.allOf?void 0:d.discriminator}),pointer:e.$ref||n+"/oneOf/"+a,options:s,baseRefsStack:p,deps:Object.assign(Object.assign({},o),{parentFieldFullPath:o.parentFieldFullPath?o.parentFieldFullPath+"/"+a:a.toString()})})}));let l;if(s.simpleOneOfTypeLabel){l=collectUniqueOneOfTypesDeep(r).join(" or ")}else l=a.map((e=>{let t=e.typePrefix+(e.title?`${e.title} (${e.displayType})`:e.displayType);return t.indexOf(" or ")>-1&&(t=`(${t})`),t})).join(" or ");return{oneOf:a,displayType:l}}function initConditionalOperators({schema:e,parser:t,pointer:i,options:n,refsStack:r,deps:s}){const{if:o,else:a={},then:l={}}=e,p=__rest(e,["if","else","then"]);return{oneOf:[{allOf:[p,l,o],title:o&&o["x-displayName"]||(null==o?void 0:o.title)||"case 1"},{allOf:[p,a],title:a&&a["x-displayName"]||(null==a?void 0:a.title)||"case 2"}].map(((e,o)=>getSchema({parser:t,schemaOrRef:Object.assign({},e),pointer:i+"/oneOf/"+o,options:n,baseRefsStack:r,deps:Object.assign(Object.assign({},s),{parentFieldFullPath:s.parentFieldFullPath?s.parentFieldFullPath+"/"+o:o.toString()})}))),oneOfType:"One of"}}function normalizeField(e,t,i){return e||(console.warn(`Field "${t}" is invalid, skipping.\n Field must be an object but got ${typeof e} at "${i}"`),{})}function buildFields(e,t,i,n,r,s){let o=t.properties||(hasType(t,"array")?t.prefixItems||t.items:void 0)||{};const a=t.patternProperties||{},l=t.additionalProperties||t.unevaluatedProperties,p=t.prefixItems?t.items:t.additionalItems,d=t.default||{};let m=Object.keys(o).map((a=>{var l;const p=normalizeField(o[a],a,i),m=void 0!==t.required&&t.required.indexOf(a)>-1;return getField(e,{name:t.properties?a:`[${a}]`,required:m,schema:Object.assign(Object.assign({},p),{example:(null===(l=t.example)||void 0===l?void 0:l[a])||p.example,default:void 0===p.default&&d?d[a]:p.default})},i+"/properties/"+a,n,s,r,JsonPointer.join(t.absolutePointer||"",["properties",a]))}));return n.sortPropsAlphabetically&&(m=sortByField(m,"name")),n.requiredPropsFirst&&(m=sortByRequired(m,n.sortPropsAlphabetically?void 0:t.required)),m.push(...Object.keys(a).map((t=>{const o=normalizeField(a[t],t,i);return getField(e,{name:t,required:!1,schema:o,kind:"patternProperties"},`${i}/patternProperties/${t}`,n,s,r)}))),(isObject(l)||!0===l)&&m.push(getField(e,{name:(isObject(l)&&l["x-additionalPropertiesName"]||"property name").concat("*"),required:!1,schema:!0===l?{}:l,kind:"additionalProperties"},i+"/additionalProperties",n,s,r,JsonPointer.join(t.absolutePointer||"",["additionalProperties"]))),m.push(...buildAdditionalItems({parser:e,schema:p,fieldsCount:m.length,$ref:i,options:n,refsStack:r,deps:s})),m}function buildAdditionalItems({parser:e,schema:t=!1,fieldsCount:i,$ref:n,options:r,refsStack:s,deps:o}){return"boolean"==typeof t?t?[getField(e,{name:`[${i}...]`,schema:{},kind:"additionalItems"},`${n}/additionalItems`,r,o,s)]:[]:Array.isArray(t)?[...t.map(((t,a)=>getField(e,{name:`[${i+a}]`,schema:t,kind:"additionalItems"},`${n}/additionalItems/${a}`,r,o,s)))]:isObject(t)?[getField(e,{name:`[${i}...]`,schema:t,kind:"additionalItems"},`${n}/additionalItems`,r,o,s)]:[]}function getDiscriminator(e){return e.discriminator||e["x-discriminator"]}function collectUniqueOneOfTypesDeep(e){const t=new Set;return function e(i){for(const n of i.oneOf||[])n.oneOf?e(n):n.type&&t.add(n.type)}(e),Array.from(t.values())}function hasType(e,t){return e.type===t||Array.isArray(e.type)&&e.type.includes(t)}
+//# sourceMappingURL=schema.js.map

package/lib-esm/models/security.d.ts

@@ -0,0 +1,13 @@
+import type { OpenAPISecurityRequirement, OpenAPISecurityScheme, Referenced } from '../types';
+import type { OpenAPIParser } from '../services';
+import type { SecurityRequirement, SecurityScheme } from './types';
+type GetSecurityRequirementsInput = {
+    requirement: OpenAPISecurityRequirement;
+    parser: OpenAPIParser;
+};
+export declare function getSecurityRequirement({ requirement, parser, }: GetSecurityRequirementsInput): SecurityRequirement;
+export declare function getSecurityScheme(parser: Partial<OpenAPIParser>, id: string, scheme: Referenced<OpenAPISecurityScheme>): SecurityScheme;
+export declare function getSecuritySchemes({ parser, }: {
+    parser: Partial<OpenAPIParser>;
+}): Array<SecurityScheme>;
+export {};

package/lib-esm/models/security.js

@@ -0,0 +1,2 @@
+import{getValueFromMdParsedExtension}from"../utils";export function getSecurityRequirement({requirement:e,parser:t}){const n=t.definition.components&&t.definition.components.securitySchemes||{};return{schemes:Object.keys(e||{}).map((r=>{const o=t.deref(n[r]).resolved,i=e[r]||[];if(o)return Object.assign(Object.assign({},o),{id:r,sectionId:r,scopes:i})})).filter(Boolean)}}export function getSecurityScheme(e,t,n){if(!(null==e?void 0:e.deref))return{};const{resolved:r}=e.deref(n),o=t,i=r.type,s=getValueFromMdParsedExtension(r,"description")||"";let c,a,d,p={};switch(r.type){case"apiKey":c={name:r.name,in:r.in};break;case"http":a={scheme:r.scheme,bearerFormat:r.bearerFormat};break;case"openIdConnect":d={connectUrl:r.openIdConnectUrl};break;case"oauth2":p=r.flows}return{id:t,sectionId:o,type:i,description:s,apiKey:c,http:a,flows:p,openId:d}}export function getSecuritySchemes({parser:e}){var t,n;if(!e)return[];const r=(null===(n=null===(t=e.definition)||void 0===t?void 0:t.components)||void 0===n?void 0:n.securitySchemes)||{};return Object.keys(r).map((t=>getSecurityScheme(e,t,r[t])))}
+//# sourceMappingURL=security.js.map

package/lib-esm/models/tab.d.ts

@@ -0,0 +1,4 @@
+export type TabType = {
+    title: string;
+    key: string;
+};

package/lib-esm/models/tab.js

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

package/lib-esm/models/types.d.ts

@@ -0,0 +1,231 @@
+import type { Node } from '@markdoc/markdoc';
+import type { OpenAPISecurityScheme, OpenAPIEncoding, OpenAPIMediaType, OpenAPIParameterLocation, OpenAPIParameterStyle, OpenAPIExternalDocumentation, Server, OpenAPIServer, OpenAPIXCodeSample, OpenAPISchema, Referenced, OpenAPIInfo } from '../types';
+import type { OpenAPIParser } from '../services/OpenAPIParser';
+import type { Options } from '../services/Options';
+import type { ExtendedOpenAPIOperation, MenuItemGroupType, MenuItemType, MergedOpenAPISchema, Unstable_ExternalCodeSample } from '../services/types';
+export type ContentItemModel = GroupModel | OperationMenuItem;
+export interface ExtendedOpenAPISecurityScheme extends OpenAPISecurityScheme {
+    id: string;
+    sectionId: string;
+    scopes: string[];
+    'x-defaultClientId'?: string;
+}
+export interface SecurityRequirement {
+    schemes: ExtendedOpenAPISecurityScheme[];
+}
+export interface SecurityScheme {
+    id: string;
+    sectionId: string;
+    type: OpenAPISecurityScheme['type'];
+    description: string | GenericObject;
+    apiKey?: {
+        name: string;
+        in: OpenAPISecurityScheme['in'];
+    };
+    http?: {
+        scheme: string;
+        bearerFormat?: string;
+    };
+    openId?: {
+        connectUrl: string;
+    };
+    flows: OpenAPISecurityScheme['flows'];
+}
+export type RequestBodyModel = {
+    description: string | GenericObject;
+    required?: boolean;
+    content: MediaContentModel | undefined;
+};
+export type ExampleModel = {
+    value: any;
+    rawValue: any;
+    externalValueUrl?: string;
+    summary?: string;
+    description?: string | GenericObject;
+    mime: string;
+    encoding?: {
+        [field: string]: OpenAPIEncoding;
+    };
+};
+export type MediaTypeModel = {
+    examples?: {
+        [name: string]: ExampleModel;
+    };
+    schema?: SchemaModel;
+    name: string;
+    isRequestType: boolean;
+    onlyRequiredInSamples: boolean;
+    operation: OperationModel;
+};
+export type MediaContentModel = {
+    mediaTypes: MediaTypeModel[];
+    isRequestType: boolean;
+    hasSample: boolean;
+    operation: OperationModel;
+};
+export type MediaContentModelInput = {
+    parser: OpenAPIParser;
+    info: Record<string, OpenAPIMediaType>;
+    isRequestType: boolean;
+    options: Options;
+    data: {
+        operation: OperationModel;
+        type?: 'request' | 'response';
+        response?: ResponseModel;
+        absolutePointer?: string;
+    };
+};
+export type ResponseModel = {
+    content?: MediaContentModel;
+    code: string;
+    summary: string | GenericObject;
+    description: string | GenericObject;
+    type: string;
+    headers: FieldModel[];
+};
+export type FieldModel = {
+    schema: SchemaModel;
+    name: string;
+    required: boolean;
+    description: string | GenericObject;
+    example?: string;
+    examples?: Record<string, ExampleModel>;
+    deprecated: boolean;
+    in?: OpenAPIParameterLocation;
+    kind: string;
+    extensions?: GenericObject;
+    explode: boolean;
+    style?: OpenAPIParameterStyle;
+    const?: any;
+    serializationMime?: string;
+    fieldFullPath?: string;
+    deps: Deps;
+    absolutePointer?: string;
+};
+export type CallbackModel = {
+    name: string;
+    operations: OperationModel[];
+};
+export type OperationModel = {
+    id: string;
+    absoluteIdx?: number;
+    name: string;
+    description?: string | GenericObject;
+    ast?: Node[];
+    href: string;
+    type: MenuItemType;
+    parent?: GroupModel;
+    externalDocs?: OpenAPIExternalDocumentation;
+    items: ContentItemModel[];
+    depth: number;
+    activeExampleName?: string;
+    activeServer: Server;
+    defaultExampleName?: string | false;
+    defaultMimeType?: string;
+    pointer: string;
+    operationId?: string;
+    httpVerb: string;
+    deprecated: boolean;
+    path: string;
+    servers: OpenAPIServer[];
+    security: SecurityRequirement[];
+    extensions: GenericObject;
+    isCallback: boolean;
+    isWebhook: boolean;
+    isEvent: boolean;
+    callbackId: string;
+    requestBody?: RequestBodyModel;
+    payload?: {
+        lang: string;
+        label: string;
+        source: string;
+        requestBodyContent: MediaContentModel;
+    };
+    definitionSamples: OpenAPIXCodeSample[] | Unstable_ExternalCodeSample[];
+    hasSamples: boolean;
+    parameters: FieldModel[];
+    responses: ResponseModel[];
+    callbacks: CallbackModel[];
+};
+export type GroupModel = {
+    id: string;
+    href: string;
+    name: string;
+    description?: string | GenericObject;
+    isSchema?: boolean;
+    type: MenuItemGroupType;
+    items: ContentItemModel[];
+    ast?: Node[];
+    parent?: GroupModel;
+    externalDocs?: OpenAPIExternalDocumentation;
+    infoDefinition?: OpenAPIInfo;
+    depth: number;
+    level: number;
+};
+export type OperationMenuItem = {
+    id: string;
+    href: string;
+    name: string;
+    operationDefinition: ExtendedOpenAPIOperation;
+    depth: number;
+    items: ContentItemModel[];
+    parent?: GroupModel;
+    deprecated?: boolean;
+    type: 'operation';
+    httpVerb: string;
+    path: string;
+    isWebhook: boolean;
+    operationId?: string;
+};
+export type SchemaModel = {
+    parser: OpenAPIParser;
+    options: Options;
+    deps: Deps;
+    schemaOrRef: Referenced<OpenAPISchema>;
+    isChild: boolean;
+    refsStack: string[];
+    pointer: string;
+    absolutePointer?: string;
+    type: string | string[];
+    displayType: string;
+    typePrefix: string;
+    title: string;
+    description: string | GenericObject;
+    externalDocs?: OpenAPIExternalDocumentation;
+    isPrimitive: boolean;
+    isCircular: boolean;
+    format?: string;
+    displayFormat?: string;
+    nullable: boolean;
+    deprecated: boolean;
+    pattern?: string;
+    example?: any;
+    enum: any[];
+    default?: any;
+    readOnly: boolean;
+    writeOnly: boolean;
+    constraints: string[];
+    fields?: FieldModel[];
+    items?: SchemaModel;
+    oneOf?: SchemaModel[];
+    oneOfType: string;
+    discriminatorProp?: string;
+    rawSchema: OpenAPISchema;
+    schema: MergedOpenAPISchema;
+    extensions?: GenericObject;
+    'x-enumDescriptions'?: {
+        [name: string]: string;
+    };
+    const: any;
+    contentEncoding?: string;
+    contentMediaType?: string;
+    minItems?: number;
+    maxItems?: number;
+};
+export type Deps = {
+    parentFieldFullPath?: string;
+    operation: OperationModel;
+    type?: 'request' | 'response';
+    response?: ResponseModel;
+    in?: string;
+};

package/lib-esm/models/types.js

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

package/lib-esm/services/MarkerService.d.ts

@@ -0,0 +1,11 @@
+import Mark from 'mark.js';
+export declare class MarkerService {
+    map: Map<Element, Mark>;
+    private prevTerm;
+    add(el: HTMLElement): void;
+    delete(el: Element): void;
+    addOnly(elements: Element[]): void;
+    clearAll(): void;
+    mark(term?: string): void;
+    unmark(): void;
+}