docusaurus-plugin-openapi-docs 1.0.5 → 1.1.1

package/lib/openapi/utils/services/OpenAPIParser.js

@@ -0,0 +1,342 @@
+"use strict";
+/* ============================================================================
+ * Copyright (c) Palo Alto Networks
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ * ========================================================================== */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAPIParser = void 0;
+const helpers_1 = require("../utils/helpers");
+const JsonPointer_1 = require("../utils/JsonPointer");
+const openapi_1 = require("../utils/openapi");
+const RedocNormalizedOptions_1 = require("./RedocNormalizedOptions");
+/**
+ * Helper class to keep track of visited references to avoid
+ * endless recursion because of circular refs
+ */
+class RefCounter {
+    constructor() {
+        this._counter = {};
+    }
+    reset() {
+        this._counter = {};
+    }
+    visit(ref) {
+        this._counter[ref] = this._counter[ref] ? this._counter[ref] + 1 : 1;
+    }
+    exit(ref) {
+        this._counter[ref] = this._counter[ref] && this._counter[ref] - 1;
+    }
+    visited(ref) {
+        return !!this._counter[ref];
+    }
+}
+/**
+ * Loads and keeps spec. Provides raw spec operations
+ */
+class OpenAPIParser {
+    constructor(spec, specUrl, options = new RedocNormalizedOptions_1.RedocNormalizedOptions()) {
+        this.options = options;
+        this._refCounter = new RefCounter();
+        this.allowMergeRefs = false;
+        /**
+         * get spec part by JsonPointer ($ref)
+         */
+        this.byRef = (ref) => {
+            let res;
+            if (!this.spec) {
+                return;
+            }
+            if (ref.charAt(0) !== "#") {
+                ref = "#" + ref;
+            }
+            ref = decodeURIComponent(ref);
+            try {
+                res = JsonPointer_1.JsonPointer.get(this.spec, ref);
+            }
+            catch (e) {
+                // do nothing
+            }
+            return res || {};
+        };
+        this.validate(spec);
+        this.spec = spec;
+        this.allowMergeRefs = spec.openapi.startsWith("3.1");
+        const href = undefined;
+        if (typeof specUrl === "string") {
+            this.specUrl = new URL(specUrl, href).href;
+        }
+    }
+    validate(spec) {
+        if (spec.openapi === undefined) {
+            throw new Error("Document must be valid OpenAPI 3.0.0 definition");
+        }
+    }
+    /**
+     * checks if the object is OpenAPI reference (contains $ref property)
+     */
+    isRef(obj) {
+        if (!obj) {
+            return false;
+        }
+        return obj.$ref !== undefined && obj.$ref !== null;
+    }
+    /**
+     * resets visited endpoints. should be run after
+     */
+    resetVisited() {
+        if (process.env.NODE_ENV !== "production") {
+            // check in dev mode
+            for (const k in this._refCounter._counter) {
+                if (this._refCounter._counter[k] > 0) {
+                    console.warn("Not exited reference: " + k);
+                }
+            }
+        }
+        this._refCounter = new RefCounter();
+    }
+    exitRef(ref) {
+        if (!this.isRef(ref)) {
+            return;
+        }
+        this._refCounter.exit(ref.$ref);
+    }
+    /**
+     * 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 circular ref
+     */
+    deref(obj, forceCircular = false, mergeAsAllOf = false) {
+        if (this.isRef(obj)) {
+            const schemaName = (0, openapi_1.getDefinitionName)(obj.$ref);
+            if (schemaName && this.options.ignoreNamedSchemas.has(schemaName)) {
+                return { type: "object", title: schemaName };
+            }
+            const resolved = this.byRef(obj.$ref);
+            const visited = this._refCounter.visited(obj.$ref);
+            this._refCounter.visit(obj.$ref);
+            if (visited && !forceCircular) {
+                // circular reference detected
+                // tslint:disable-next-line
+                return Object.assign({}, resolved, { "x-circular-ref": true });
+            }
+            // deref again in case one more $ref is here
+            let result = resolved;
+            if (this.isRef(resolved)) {
+                result = this.deref(resolved, false, mergeAsAllOf);
+                this.exitRef(resolved);
+            }
+            return this.allowMergeRefs
+                ? this.mergeRefs(obj, resolved, mergeAsAllOf)
+                : result;
+        }
+        return obj;
+    }
+    shallowDeref(obj) {
+        if (this.isRef(obj)) {
+            const schemaName = (0, openapi_1.getDefinitionName)(obj.$ref);
+            if (schemaName && this.options.ignoreNamedSchemas.has(schemaName)) {
+                return { type: "object", title: schemaName };
+            }
+            const resolved = this.byRef(obj.$ref);
+            return this.allowMergeRefs
+                ? this.mergeRefs(obj, resolved, false)
+                : resolved;
+        }
+        return obj;
+    }
+    mergeRefs(ref, resolved, mergeAsAllOf) {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { $ref, ...rest } = ref;
+        const keys = Object.keys(rest);
+        if (keys.length === 0) {
+            if (this.isRef(resolved)) {
+                return this.shallowDeref(resolved);
+            }
+            return resolved;
+        }
+        if (mergeAsAllOf &&
+            keys.some((k) => k !== "description" && k !== "title" && k !== "externalDocs")) {
+            return {
+                allOf: [rest, resolved],
+            };
+        }
+        else {
+            // small optimization
+            return {
+                ...resolved,
+                ...rest,
+            };
+        }
+    }
+    /**
+     * 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 circular ref
+     */
+    mergeAllOf(schema, $ref, forceCircular = false, used$Refs = new Set()) {
+        if ($ref) {
+            used$Refs.add($ref);
+        }
+        schema = this.hoistOneOfs(schema);
+        if (schema.allOf === undefined) {
+            return schema;
+        }
+        let receiver = {
+            ...schema,
+            allOf: undefined,
+            parentRefs: [],
+            title: schema.title || (0, openapi_1.getDefinitionName)($ref),
+        };
+        // avoid mutating inner objects
+        if (receiver.properties !== undefined &&
+            typeof receiver.properties === "object") {
+            receiver.properties = { ...receiver.properties };
+        }
+        if (receiver.items !== undefined && typeof receiver.items === "object") {
+            receiver.items = { ...receiver.items };
+        }
+        const allOfSchemas = schema.allOf
+            .map((subSchema) => {
+            if (subSchema && subSchema.$ref && used$Refs.has(subSchema.$ref)) {
+                return undefined;
+            }
+            const resolved = this.deref(subSchema, forceCircular, true);
+            const subRef = subSchema.$ref || undefined;
+            const subMerged = this.mergeAllOf(resolved, subRef, forceCircular, used$Refs);
+            receiver.parentRefs.push(...(subMerged.parentRefs || []));
+            return {
+                $ref: subRef,
+                schema: subMerged,
+            };
+        })
+            .filter((child) => child !== undefined);
+        for (const { $ref: subSchemaRef, schema: subSchema } of allOfSchemas) {
+            const { type, enum: enumProperty, properties, items, required, oneOf, anyOf, title, ...otherConstraints } = subSchema;
+            if (receiver.type !== type &&
+                receiver.type !== undefined &&
+                type !== undefined) {
+                console.warn(`Incompatible types in allOf at "${$ref}": "${receiver.type}" and "${type}"`);
+            }
+            if (type !== undefined) {
+                if (Array.isArray(type) && Array.isArray(receiver.type)) {
+                    receiver.type = [...type, ...receiver.type];
+                }
+                else {
+                    receiver.type = type;
+                }
+            }
+            if (enumProperty !== undefined) {
+                if (Array.isArray(enumProperty) && Array.isArray(receiver.enum)) {
+                    receiver.enum = [...enumProperty, ...receiver.enum];
+                }
+                else {
+                    receiver.enum = enumProperty;
+                }
+            }
+            if (properties !== undefined) {
+                receiver.properties = receiver.properties || {};
+                for (const prop in properties) {
+                    if (!receiver.properties[prop]) {
+                        receiver.properties[prop] = properties[prop];
+                    }
+                    else {
+                        // merge inner properties
+                        const mergedProp = this.mergeAllOf({ allOf: [receiver.properties[prop], properties[prop]] }, $ref + "/properties/" + prop);
+                        receiver.properties[prop] = mergedProp;
+                        this.exitParents(mergedProp); // every prop resolution should have separate recursive stack
+                    }
+                }
+            }
+            if (items !== undefined) {
+                const receiverItems = (0, helpers_1.isBoolean)(receiver.items)
+                    ? { items: receiver.items }
+                    : receiver.items
+                        ? Object.assign({}, receiver.items)
+                        : {};
+                const subSchemaItems = (0, helpers_1.isBoolean)(items)
+                    ? { items }
+                    : Object.assign({}, items);
+                // merge inner properties
+                receiver.items = this.mergeAllOf({ allOf: [receiverItems, subSchemaItems] }, $ref + "/items");
+            }
+            if (required !== undefined) {
+                receiver.required = (receiver.required || []).concat(required);
+            }
+            if (oneOf !== undefined) {
+                receiver.oneOf = oneOf;
+            }
+            if (anyOf !== undefined) {
+                receiver.anyOf = anyOf;
+            }
+            // merge rest of constraints
+            // TODO: do more intelligent merge
+            receiver = {
+                ...receiver,
+                title: receiver.title || title,
+                ...otherConstraints,
+            };
+            if (subSchemaRef) {
+                receiver.parentRefs.push(subSchemaRef);
+                if (receiver.title === undefined && (0, openapi_1.isNamedDefinition)(subSchemaRef)) {
+                    // this is not so correct behaviour. commented out for now
+                    // ref: https://github.com/Redocly/redoc/issues/601
+                    // receiver.title = JsonPointer.baseName(subSchemaRef);
+                }
+            }
+        }
+        return receiver;
+    }
+    /**
+     * 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) {
+        const res = {};
+        const schemas = (this.spec.components && this.spec.components.schemas) || {};
+        for (const defName in schemas) {
+            const def = this.deref(schemas[defName]);
+            if (def.allOf !== undefined &&
+                def.allOf.find((obj) => obj.$ref !== undefined && $refs.indexOf(obj.$ref) > -1)) {
+                res["#/components/schemas/" + defName] = [
+                    def["x-discriminator-value"] || defName,
+                ];
+            }
+        }
+        return res;
+    }
+    exitParents(shema) {
+        for (const parent$ref of shema.parentRefs || []) {
+            this.exitRef({ $ref: parent$ref });
+        }
+    }
+    hoistOneOfs(schema) {
+        if (schema.allOf === undefined) {
+            return schema;
+        }
+        const allOf = schema.allOf;
+        for (let i = 0; i < allOf.length; i++) {
+            const sub = allOf[i];
+            if ((0, helpers_1.isArray)(sub.oneOf)) {
+                const beforeAllOf = allOf.slice(0, i);
+                const afterAllOf = allOf.slice(i + 1);
+                return {
+                    oneOf: sub.oneOf.map((part) => {
+                        const merged = this.mergeAllOf({
+                            allOf: [...beforeAllOf, part, ...afterAllOf],
+                        });
+                        // each oneOf should be independent so exiting all the parent refs
+                        // otherwise it will cause false-positive recursive detection
+                        this.exitParents(merged);
+                        return merged;
+                    }),
+                };
+            }
+        }
+        return schema;
+    }
+}
+exports.OpenAPIParser = OpenAPIParser;

package/lib/openapi/utils/services/RedocNormalizedOptions.d.ts

@@ -0,0 +1,100 @@
+export declare enum SideNavStyleEnum {
+    SummaryOnly = "summary-only",
+    PathOnly = "path-only",
+    IdOnly = "id-only"
+}
+export interface RedocRawOptions {
+    scrollYOffset?: number | string | (() => number);
+    hideHostname?: boolean | string;
+    expandResponses?: string | "all";
+    requiredPropsFirst?: boolean | string;
+    sortPropsAlphabetically?: 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;
+    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 normalizeShowExtensions(value: RedocRawOptions["showExtensions"]): string[] | boolean;
+    static normalizeSideNavStyle(value: RedocRawOptions["sideNavStyle"]): SideNavStyleEnum;
+    static normalizePayloadSampleIdx(value: RedocRawOptions["payloadSampleIdx"]): number;
+    private static normalizeJsonSampleExpandLevel;
+    private static normalizeGeneratedPayloadSamplesMaxDepth;
+    hideHostname: boolean;
+    expandResponses: {
+        [code: string]: boolean;
+    } | "all";
+    requiredPropsFirst: boolean;
+    sortPropsAlphabetically: 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;
+    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/lib/openapi/utils/services/RedocNormalizedOptions.js

@@ -0,0 +1,170 @@
+"use strict";
+/* ============================================================================
+ * Copyright (c) Palo Alto Networks
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ * ========================================================================== */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedocNormalizedOptions = exports.argValueToBoolean = exports.SideNavStyleEnum = void 0;
+// @ts-nocheck
+const helpers_1 = require("../utils/helpers");
+var SideNavStyleEnum;
+(function (SideNavStyleEnum) {
+    SideNavStyleEnum["SummaryOnly"] = "summary-only";
+    SideNavStyleEnum["PathOnly"] = "path-only";
+    SideNavStyleEnum["IdOnly"] = "id-only";
+})(SideNavStyleEnum = exports.SideNavStyleEnum || (exports.SideNavStyleEnum = {}));
+function argValueToBoolean(val, defaultValue) {
+    if (val === undefined) {
+        return defaultValue || false;
+    }
+    if (typeof val === "string") {
+        return val !== "false";
+    }
+    return val;
+}
+exports.argValueToBoolean = argValueToBoolean;
+function argValueToNumber(value) {
+    if (typeof value === "string") {
+        return parseInt(value, 10);
+    }
+    if (typeof value === "number") {
+        return value;
+    }
+}
+function argValueToExpandLevel(value, defaultValue = 0) {
+    if (value === "all")
+        return Infinity;
+    return argValueToNumber(value) || defaultValue;
+}
+class RedocNormalizedOptions {
+    constructor(raw, defaults = {}) {
+        var _a;
+        raw = { ...defaults, ...raw };
+        this.hideHostname = RedocNormalizedOptions.normalizeHideHostname(raw.hideHostname);
+        this.expandResponses = RedocNormalizedOptions.normalizeExpandResponses(raw.expandResponses);
+        this.requiredPropsFirst = argValueToBoolean(raw.requiredPropsFirst);
+        this.sortPropsAlphabetically = argValueToBoolean(raw.sortPropsAlphabetically);
+        this.sortEnumValuesAlphabetically = argValueToBoolean(raw.sortEnumValuesAlphabetically);
+        this.sortOperationsAlphabetically = argValueToBoolean(raw.sortOperationsAlphabetically);
+        this.sortTagsAlphabetically = argValueToBoolean(raw.sortTagsAlphabetically);
+        this.nativeScrollbars = argValueToBoolean(raw.nativeScrollbars);
+        this.pathInMiddlePanel = argValueToBoolean(raw.pathInMiddlePanel);
+        this.untrustedSpec = argValueToBoolean(raw.untrustedSpec);
+        this.hideDownloadButton = argValueToBoolean(raw.hideDownloadButton);
+        this.downloadFileName = raw.downloadFileName;
+        this.downloadDefinitionUrl = raw.downloadDefinitionUrl;
+        this.disableSearch = argValueToBoolean(raw.disableSearch);
+        this.onlyRequiredInSamples = argValueToBoolean(raw.onlyRequiredInSamples);
+        this.showExtensions = RedocNormalizedOptions.normalizeShowExtensions(raw.showExtensions);
+        this.sideNavStyle = RedocNormalizedOptions.normalizeSideNavStyle(raw.sideNavStyle);
+        this.hideSingleRequestSampleTab = argValueToBoolean(raw.hideSingleRequestSampleTab);
+        this.menuToggle = argValueToBoolean(raw.menuToggle, true);
+        this.jsonSampleExpandLevel =
+            RedocNormalizedOptions.normalizeJsonSampleExpandLevel(raw.jsonSampleExpandLevel);
+        this.enumSkipQuotes = argValueToBoolean(raw.enumSkipQuotes);
+        this.hideSchemaTitles = argValueToBoolean(raw.hideSchemaTitles);
+        this.simpleOneOfTypeLabel = argValueToBoolean(raw.simpleOneOfTypeLabel);
+        this.payloadSampleIdx = RedocNormalizedOptions.normalizePayloadSampleIdx(raw.payloadSampleIdx);
+        this.expandSingleSchemaField = argValueToBoolean(raw.expandSingleSchemaField);
+        this.schemaExpansionLevel = argValueToExpandLevel(raw.schemaExpansionLevel);
+        this.showObjectSchemaExamples = argValueToBoolean(raw.showObjectSchemaExamples);
+        this.showSecuritySchemeType = argValueToBoolean(raw.showSecuritySchemeType);
+        this.hideSecuritySection = argValueToBoolean(raw.hideSecuritySection);
+        this.unstable_ignoreMimeParameters = argValueToBoolean(raw.unstable_ignoreMimeParameters);
+        this.expandDefaultServerVariables = argValueToBoolean(raw.expandDefaultServerVariables);
+        this.maxDisplayedEnumValues = argValueToNumber(raw.maxDisplayedEnumValues);
+        const ignoreNamedSchemas = (0, helpers_1.isArray)(raw.ignoreNamedSchemas)
+            ? raw.ignoreNamedSchemas
+            : (_a = raw.ignoreNamedSchemas) === null || _a === void 0 ? void 0 : _a.split(",").map((s) => s.trim());
+        this.ignoreNamedSchemas = new Set(ignoreNamedSchemas);
+        this.hideSchemaPattern = argValueToBoolean(raw.hideSchemaPattern);
+        this.generatedPayloadSamplesMaxDepth =
+            RedocNormalizedOptions.normalizeGeneratedPayloadSamplesMaxDepth(raw.generatedPayloadSamplesMaxDepth);
+        this.nonce = raw.nonce;
+        this.hideFab = argValueToBoolean(raw.hideFab);
+        this.minCharacterLengthToInitSearch =
+            argValueToNumber(raw.minCharacterLengthToInitSearch) || 3;
+        this.showWebhookVerb = argValueToBoolean(raw.showWebhookVerb);
+    }
+    static normalizeExpandResponses(value) {
+        if (value === "all") {
+            return "all";
+        }
+        if (typeof value === "string") {
+            const res = {};
+            value.split(",").forEach((code) => {
+                res[code.trim()] = true;
+            });
+            return res;
+        }
+        else if (value !== undefined) {
+            console.warn(`expandResponses must be a string but received value "${value}" of type ${typeof value}`);
+        }
+        return {};
+    }
+    static normalizeHideHostname(value) {
+        return !!value;
+    }
+    static normalizeShowExtensions(value) {
+        if (typeof value === "undefined") {
+            return false;
+        }
+        if (value === "") {
+            return true;
+        }
+        if (typeof value !== "string") {
+            return value;
+        }
+        switch (value) {
+            case "true":
+                return true;
+            case "false":
+                return false;
+            default:
+                return value.split(",").map((ext) => ext.trim());
+        }
+    }
+    static normalizeSideNavStyle(value) {
+        const defaultValue = SideNavStyleEnum.SummaryOnly;
+        if (typeof value !== "string") {
+            return defaultValue;
+        }
+        switch (value) {
+            case defaultValue:
+                return value;
+            case SideNavStyleEnum.PathOnly:
+                return SideNavStyleEnum.PathOnly;
+            case SideNavStyleEnum.IdOnly:
+                return SideNavStyleEnum.IdOnly;
+            default:
+                return defaultValue;
+        }
+    }
+    static normalizePayloadSampleIdx(value) {
+        if (typeof value === "number") {
+            return Math.max(0, value); // always greater or equal than 0
+        }
+        if (typeof value === "string") {
+            return isFinite(value) ? parseInt(value, 10) : 0;
+        }
+        return 0;
+    }
+    static normalizeJsonSampleExpandLevel(level) {
+        if (level === "all") {
+            return +Infinity;
+        }
+        if (!isNaN(Number(level))) {
+            return Math.ceil(Number(level));
+        }
+        return 2;
+    }
+    static normalizeGeneratedPayloadSamplesMaxDepth(value) {
+        if (!isNaN(Number(value))) {
+            return Math.max(0, Number(value));
+        }
+        return 10;
+    }
+}
+exports.RedocNormalizedOptions = RedocNormalizedOptions;

package/lib/openapi/utils/types/index.d.ts

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

package/lib/openapi/utils/types/index.js

@@ -0,0 +1,23 @@
+"use strict";
+/* ============================================================================
+ * Copyright (c) Palo Alto Networks
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ * ========================================================================== */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./open-api"), exports);