@gitbook/react-openapi 0.7.1 → 1.0.0

package/dist/OpenAPICodeSample.js

@@ -1,110 +0,0 @@
-import * as React from 'react';
-import { codeSampleGenerators } from './code-samples';
-import { generateMediaTypeExample, generateSchemaExample } from './generateSchemaExample';
-import { InteractiveSection } from './InteractiveSection';
-import { getServersURL } from './OpenAPIServerURL';
-import { ScalarApiButton } from './ScalarApiButton';
-import { noReference } from './utils';
-/**
- * Display code samples to execute the operation.
- * It supports the Redocly custom syntax as well (https://redocly.com/docs/api-reference-docs/specification-extensions/x-code-samples/)
- */
-export function OpenAPICodeSample(props) {
-    const { data, context } = props;
-    const searchParams = new URLSearchParams();
-    const headersObject = {};
-    data.operation.parameters?.forEach((rawParam) => {
-        const param = noReference(rawParam);
-        if (!param) {
-            return;
-        }
-        if (param.in === 'header' && param.required) {
-            const example = param.schema
-                ? generateSchemaExample(noReference(param.schema))
-                : undefined;
-            if (example !== undefined) {
-                headersObject[param.name] =
-                    typeof example !== 'string' ? JSON.stringify(example) : example;
-            }
-        }
-        else if (param.in === 'query' && param.required) {
-            const example = param.schema
-                ? generateSchemaExample(noReference(param.schema))
-                : undefined;
-            if (example !== undefined) {
-                searchParams.append(param.name, String(Array.isArray(example) ? example[0] : example));
-            }
-        }
-    });
-    const requestBody = noReference(data.operation.requestBody);
-    const requestBodyContent = requestBody ? Object.entries(requestBody.content)[0] : undefined;
-    const input = {
-        url: getServersURL(data.servers) +
-            data.path +
-            (searchParams.size ? `?${searchParams.toString()}` : ''),
-        method: data.method,
-        body: requestBodyContent
-            ? generateMediaTypeExample(requestBodyContent[1], { onlyRequired: true })
-            : undefined,
-        headers: {
-            ...getSecurityHeaders(data.securities),
-            ...headersObject,
-            ...(requestBodyContent
-                ? {
-                    'Content-Type': requestBodyContent[0],
-                }
-                : undefined),
-        },
-    };
-    const autoCodeSamples = codeSampleGenerators.map((generator) => ({
-        key: `default-${generator.id}`,
-        label: generator.label,
-        body: React.createElement(context.CodeBlock, { code: generator.generate(input), syntax: generator.syntax }),
-    }));
-    // Use custom samples if defined
-    let customCodeSamples = null;
-    ['x-custom-examples', 'x-code-samples', 'x-codeSamples'].forEach((key) => {
-        const customSamples = data.operation[key];
-        if (customSamples && Array.isArray(customSamples)) {
-            customCodeSamples = customSamples
-                .filter((sample) => {
-                return (typeof sample.label === 'string' &&
-                    typeof sample.source === 'string' &&
-                    typeof sample.lang === 'string');
-            })
-                .map((sample) => ({
-                key: `redocly-${sample.lang}`,
-                label: sample.label,
-                body: React.createElement(context.CodeBlock, { code: sample.source, syntax: sample.lang }),
-            }));
-        }
-    });
-    // Code samples can be disabled at the top-level or at the operation level
-    // If code samples are defined at the operation level, it will override the top-level setting
-    const codeSamplesDisabled = data['x-codeSamples'] === false || data.operation['x-codeSamples'] === false;
-    const samples = customCodeSamples ?? (!codeSamplesDisabled ? autoCodeSamples : []);
-    if (samples.length === 0) {
-        return null;
-    }
-    return (React.createElement(InteractiveSection, { header: "Request", className: "openapi-codesample", tabs: samples, overlay: data['x-hideTryItPanel'] || data.operation['x-hideTryItPanel'] ? null : (React.createElement(ScalarApiButton, { method: data.method, path: data.path })) }));
-}
-function getSecurityHeaders(securities) {
-    const security = securities[0];
-    if (!security) {
-        return {};
-    }
-    switch (security[1].type) {
-        case 'http': {
-            let scheme = security[1].scheme;
-            if (scheme === 'bearer') {
-                scheme = 'Bearer';
-            }
-            return {
-                Authorization: scheme + ' ' + (security[1].bearerFormat ?? '<token>'),
-            };
-        }
-        default: {
-            return {};
-        }
-    }
-}

package/dist/OpenAPIOperation.js

@@ -1,38 +0,0 @@
-import * as React from 'react';
-import classNames from 'classnames';
-import { ApiClientModalProvider } from '@scalar/api-client-react';
-import { toJSON } from './fetchOpenAPIOperation';
-import { Markdown } from './Markdown';
-import { OpenAPICodeSample } from './OpenAPICodeSample';
-import { OpenAPIResponseExample } from './OpenAPIResponseExample';
-import { OpenAPIServerURL } from './OpenAPIServerURL';
-import { OpenAPISpec } from './OpenAPISpec';
-/**
- * Display an interactive OpenAPI operation.
- */
-export function OpenAPIOperation(props) {
-    const { className, data, context } = props;
-    const { operation, servers, method, path } = data;
-    const clientContext = {
-        defaultInteractiveOpened: context.defaultInteractiveOpened,
-        icons: context.icons,
-        blockKey: context.blockKey,
-    };
-    return (React.createElement(ApiClientModalProvider, { configuration: { spec: { url: context.specUrl } }, initialRequest: { path: data.path, method: data.method } },
-        React.createElement("div", { className: classNames('openapi-operation', className) },
-            React.createElement("div", { className: "openapi-intro" },
-                React.createElement("h2", { className: "openapi-summary", id: context.id }, operation.summary),
-                operation.description ? (React.createElement(Markdown, { className: "openapi-description", source: operation.description })) : null,
-                React.createElement("div", { className: "openapi-target" },
-                    React.createElement("span", { className: classNames('openapi-method', `openapi-method-${method.toLowerCase()}`) }, method.toUpperCase()),
-                    React.createElement("span", { className: "openapi-url" },
-                        React.createElement(OpenAPIServerURL, { servers: servers }),
-                        path))),
-            React.createElement("div", { className: classNames('openapi-columns') },
-                React.createElement("div", { className: classNames('openapi-column-spec') },
-                    React.createElement(OpenAPISpec, { rawData: toJSON(data), context: clientContext })),
-                React.createElement("div", { className: classNames('openapi-column-preview') },
-                    React.createElement("div", { className: classNames('openapi-column-preview-body') },
-                        React.createElement(OpenAPICodeSample, { ...props }),
-                        React.createElement(OpenAPIResponseExample, { ...props })))))));
-}

package/dist/OpenAPIRequestBody.js

@@ -1,18 +0,0 @@
-import * as React from 'react';
-import { OpenAPIRootSchema } from './OpenAPISchema';
-import { noReference } from './utils';
-import { InteractiveSection } from './InteractiveSection';
-import { Markdown } from './Markdown';
-/**
- * Display an interactive request body.
- */
-export function OpenAPIRequestBody(props) {
-    const { requestBody, context } = props;
-    return (React.createElement(InteractiveSection, { header: "Body", className: "openapi-requestbody", tabs: Object.entries(requestBody.content ?? {}).map(([contentType, mediaTypeObject]) => {
-            return {
-                key: contentType,
-                label: contentType,
-                body: (React.createElement(OpenAPIRootSchema, { schema: noReference(mediaTypeObject.schema) ?? {}, context: context })),
-            };
-        }), defaultOpened: context.defaultInteractiveOpened }, requestBody.description ? (React.createElement(Markdown, { source: requestBody.description, className: "openapi-requestbody-description" })) : null));
-}

package/dist/OpenAPIResponse.js

@@ -1,32 +0,0 @@
-import * as React from 'react';
-import classNames from 'classnames';
-import { OpenAPIRootSchema, OpenAPISchemaProperties } from './OpenAPISchema';
-import { noReference } from './utils';
-import { InteractiveSection } from './InteractiveSection';
-import { Markdown } from './Markdown';
-/**
- * Display an interactive response body.
- */
-export function OpenAPIResponse(props) {
-    const { response, context } = props;
-    const content = Object.entries(response.content ?? {});
-    const headers = Object.entries(response.headers ?? {}).map(([name, header]) => [name, noReference(header) ?? {}]);
-    if (content.length === 0 && !response.description && headers.length === 0) {
-        return null;
-    }
-    return (React.createElement(React.Fragment, null,
-        response.description ? (React.createElement(Markdown, { source: response.description, className: "openapi-response-description" })) : null,
-        headers.length > 0 ? (React.createElement(InteractiveSection, { toggeable: true, defaultOpened: !!context.defaultInteractiveOpened, toggleCloseIcon: context.icons.chevronDown, toggleOpenIcon: context.icons.chevronRight, header: "Headers", className: classNames('openapi-responseheaders') },
-            React.createElement(OpenAPISchemaProperties, { properties: headers.map(([name, header]) => ({
-                    propertyName: name,
-                    schema: noReference(header.schema) ?? {},
-                    required: header.required,
-                })), context: context }))) : null,
-        content.length > 0 ? (React.createElement(InteractiveSection, { header: "Body", className: classNames('openapi-responsebody'), tabs: content.map(([contentType, mediaType]) => {
-                return {
-                    key: contentType,
-                    label: contentType,
-                    body: (React.createElement(OpenAPIRootSchema, { schema: noReference(mediaType.schema) ?? {}, context: context })),
-                };
-            }) })) : null));
-}

package/dist/OpenAPIResponseExample.js

@@ -1,54 +0,0 @@
-import * as React from 'react';
-import { InteractiveSection } from './InteractiveSection';
-import { generateSchemaExample } from './generateSchemaExample';
-import { createStateKey, noReference } from './utils';
-/**
- * Display an example of the response content.
- */
-export function OpenAPIResponseExample(props) {
-    const { data, context } = props;
-    // if there are no responses defined for the operation
-    if (!data.operation.responses) {
-        return null;
-    }
-    const responses = Object.entries(data.operation.responses);
-    // Sort response to get 200, and 2xx first
-    responses.sort(([a], [b]) => {
-        if (a === 'default') {
-            return 1;
-        }
-        if (b === 'default') {
-            return -1;
-        }
-        if (a === '200') {
-            return -1;
-        }
-        if (b === '200') {
-            return 1;
-        }
-        return Number(a) - Number(b);
-    });
-    const examples = responses
-        .map((response) => {
-        const responseObject = noReference(response[1]);
-        const schema = noReference((responseObject.content?.['application/json'] ??
-            responseObject.content?.[Object.keys(responseObject.content)[0]])?.schema);
-        if (!schema) {
-            return null;
-        }
-        const example = generateSchemaExample(schema);
-        if (example === undefined) {
-            return null;
-        }
-        return {
-            key: `${response[0]}`,
-            label: `${response[0]}`,
-            body: (React.createElement(context.CodeBlock, { code: typeof example === 'string' ? example : JSON.stringify(example, null, 2), syntax: "json" })),
-        };
-    })
-        .filter((val) => Boolean(val));
-    if (examples.length === 0) {
-        return null;
-    }
-    return (React.createElement(InteractiveSection, { stateKey: createStateKey('response', context.blockKey), header: "Response", className: "openapi-response-example", tabs: examples }));
-}

package/dist/OpenAPIResponses.js

@@ -1,18 +0,0 @@
-import * as React from 'react';
-import classNames from 'classnames';
-import { createStateKey, noReference } from './utils';
-import { OpenAPIResponse } from './OpenAPIResponse';
-import { InteractiveSection } from './InteractiveSection';
-/**
- * Display an interactive response body.
- */
-export function OpenAPIResponses(props) {
-    const { responses, context } = props;
-    return (React.createElement(InteractiveSection, { stateKey: createStateKey('response', context.blockKey), header: "Response", className: classNames('openapi-responses'), tabs: Object.entries(responses).map(([statusCode, response]) => {
-            return {
-                key: statusCode,
-                label: statusCode,
-                body: React.createElement(OpenAPIResponse, { response: noReference(response), context: context }),
-            };
-        }) }));
-}

package/dist/OpenAPISchema.js

@@ -1,235 +0,0 @@
-import classNames from 'classnames';
-import React, { useId } from 'react';
-import { InteractiveSection } from './InteractiveSection';
-import { Markdown } from './Markdown';
-import { SYMBOL_REF_RESOLVED } from './resolveOpenAPIPath';
-import { noReference } from './utils';
-/**
- * Render a property of an OpenAPI schema.
- */
-export function OpenAPISchemaProperty(props) {
-    const { propertyName, required, schema, circularRefs: parentCircularRefs = new Map(), context, className, } = props;
-    const id = useId();
-    const parentCircularRef = parentCircularRefs.get(schema);
-    const circularRefs = new Map(parentCircularRefs).set(schema, id);
-    // Avoid recursing infinitely, and instead render a link to the parent schema
-    const properties = parentCircularRef ? null : getSchemaProperties(schema);
-    const alternatives = parentCircularRef
-        ? null
-        : getSchemaAlternatives(schema, new Set(circularRefs.keys()));
-    const shouldDisplayExample = (schema) => {
-        return (typeof schema.example === 'string' ||
-            typeof schema.example === 'number' ||
-            typeof schema.example === 'boolean');
-    };
-    return (React.createElement(InteractiveSection, { id: id, className: classNames('openapi-schema', className), toggeable: !!properties || !!alternatives, defaultOpened: !!context.defaultInteractiveOpened, toggleOpenIcon: context.icons.chevronRight, toggleCloseIcon: context.icons.chevronDown, tabs: alternatives?.[0].map((alternative, index) => ({
-            key: `${index}`,
-            label: getSchemaTitle(alternative, alternatives[1]),
-            body: circularRefs.has(alternative) ? (React.createElement(OpenAPISchemaCircularRef, { id: circularRefs.get(alternative), schema: alternative })) : (React.createElement(OpenAPISchemaAlternative, { schema: alternative, circularRefs: circularRefs, context: context })),
-        })), header: React.createElement("div", { className: classNames('openapi-schema-presentation') },
-            React.createElement("div", { className: classNames('openapi-schema-name') },
-                propertyName ? (React.createElement("span", { className: classNames('openapi-schema-propertyname') }, propertyName)) : null,
-                required ? (React.createElement("span", { className: classNames('openapi-schema-required') }, "*")) : null,
-                React.createElement("span", { className: classNames('openapi-schema-type') }, getSchemaTitle(schema))),
-            schema.description ? (React.createElement(Markdown, { source: schema.description, className: "openapi-schema-description" })) : null,
-            shouldDisplayExample(schema) ? (React.createElement("span", { className: "openapi-schema-example" },
-                "Example: ",
-                React.createElement("code", null, JSON.stringify(schema.example)))) : null,
-            schema.pattern ? (React.createElement("div", { className: "openapi-schema-pattern" },
-                "Pattern: ",
-                React.createElement("code", null, schema.pattern))) : null) }, (properties && properties.length > 0) ||
-        (schema.enum && schema.enum.length > 0) ||
-        parentCircularRef ? (React.createElement(React.Fragment, null,
-        properties?.length ? (React.createElement(OpenAPISchemaProperties, { properties: properties, circularRefs: circularRefs, context: context })) : null,
-        schema.enum && schema.enum.length > 0 ? (React.createElement(OpenAPISchemaEnum, { enumValues: schema.enum })) : null,
-        parentCircularRef ? (React.createElement(OpenAPISchemaCircularRef, { id: parentCircularRef, schema: schema })) : null)) : null));
-}
-/**
- * Render a set of properties of an OpenAPI schema.
- */
-export function OpenAPISchemaProperties(props) {
-    const { id, properties, circularRefs, context } = props;
-    if (!properties.length) {
-        return null;
-    }
-    return (React.createElement("div", { id: id, className: classNames('openapi-schema-properties') }, properties.map((property) => (React.createElement(OpenAPISchemaProperty, { key: property.propertyName, circularRefs: circularRefs, ...property, context: context })))));
-}
-/**
- * Render a root schema (such as the request body or response body).
- */
-export function OpenAPIRootSchema(props) {
-    const { schema, context } = props;
-    // Avoid recursing infinitely, and instead render a link to the parent schema
-    const properties = getSchemaProperties(schema);
-    if (properties && properties.length > 0) {
-        return React.createElement(OpenAPISchemaProperties, { properties: properties, context: context });
-    }
-    return (React.createElement(OpenAPISchemaProperty, { schema: schema, context: context, className: "openapi-schema-root" }));
-}
-/**
- * Render a tab for an alternative schema.
- * It renders directly the properties if relevant;
- * for primitives, it renders the schema itself.
- */
-function OpenAPISchemaAlternative(props) {
-    const { schema, circularRefs, context } = props;
-    const id = useId();
-    const subProperties = getSchemaProperties(schema);
-    return (React.createElement(OpenAPISchemaProperties, { id: id, properties: subProperties ?? [{ schema }], circularRefs: subProperties ? new Map(circularRefs).set(schema, id) : circularRefs, context: context }));
-}
-/**
- * Render a circular reference to a schema.
- */
-function OpenAPISchemaCircularRef(props) {
-    const { id, schema } = props;
-    return (React.createElement("div", { className: "openapi-schema-circular" },
-        "Circular reference to ",
-        React.createElement("a", { href: `#${id}` }, getSchemaTitle(schema)),
-        ' ',
-        React.createElement("span", { className: "openapi-schema-circular-glyph" }, "\u21A9")));
-}
-/**
- * Render the enum value for a schema.
- */
-export function OpenAPISchemaEnum(props) {
-    const { enumValues } = props;
-    return (React.createElement("div", { className: "openapi-schema-enum" }, enumValues.map((value, index) => (React.createElement("span", { key: index, className: "openapi-schema-enum-value" }, `${value}`)))));
-}
-/**
- * Get the sub-properties of a schema.
- */
-function getSchemaProperties(schema) {
-    if (schema.allOf) {
-        return schema.allOf.reduce((acc, subSchema) => {
-            const properties = getSchemaProperties(noReference(subSchema)) ?? [
-                {
-                    schema: noReference(subSchema),
-                },
-            ];
-            return [...acc, ...properties];
-        }, []);
-    }
-    // check array AND schema.items as this is sometimes null despite what the type indicates
-    if (schema.type === 'array' && !!schema.items) {
-        const items = noReference(schema.items);
-        const itemProperties = getSchemaProperties(items);
-        if (itemProperties) {
-            return itemProperties;
-        }
-        return [
-            {
-                propertyName: 'items',
-                schema: items,
-            },
-        ];
-    }
-    if (schema.type === 'object' || schema.properties) {
-        const result = [];
-        if (schema.properties) {
-            Object.entries(schema.properties).forEach(([propertyName, rawPropertySchema]) => {
-                const propertySchema = noReference(rawPropertySchema);
-                if (propertySchema.deprecated) {
-                    return;
-                }
-                result.push({
-                    propertyName,
-                    required: Array.isArray(schema.required)
-                        ? schema.required.includes(propertyName)
-                        : undefined,
-                    schema: propertySchema,
-                });
-            });
-        }
-        if (schema.additionalProperties) {
-            const additionalProperties = noReference(schema.additionalProperties);
-            result.push({
-                propertyName: 'Other properties',
-                schema: additionalProperties === true ? {} : additionalProperties,
-            });
-        }
-        return result;
-    }
-    return null;
-}
-/**
- * Get the alternatives to display for a schema.
- */
-export function getSchemaAlternatives(schema, ancestors = new Set()) {
-    const downAncestors = new Set(ancestors).add(schema);
-    if (schema.anyOf) {
-        return [
-            flattenAlternatives('anyOf', schema.anyOf.map(noReference), downAncestors),
-            noReference(schema.discriminator),
-        ];
-    }
-    if (schema.oneOf) {
-        return [
-            flattenAlternatives('oneOf', schema.oneOf.map(noReference), downAncestors),
-            noReference(schema.discriminator),
-        ];
-    }
-    if (schema.allOf) {
-        // allOf is managed in `getSchemaProperties`
-        return null;
-    }
-    return null;
-}
-function flattenAlternatives(alternativeType, alternatives, ancestors) {
-    return alternatives.reduce((acc, alternative) => {
-        if (!!alternative[alternativeType] && !ancestors.has(alternative)) {
-            return [...acc, ...(getSchemaAlternatives(alternative, ancestors)?.[0] || [])];
-        }
-        return [...acc, alternative];
-    }, []);
-}
-function getSchemaTitle(schema, 
-/** If the title is inferred in a oneOf with discriminator, we can use it to optimize the title */
-discriminator) {
-    if (schema.title) {
-        // If the schema has a title, use it
-        return schema.title;
-    }
-    // Try using the discriminator
-    if (discriminator && schema.properties) {
-        const discriminatorProperty = noReference(schema.properties[discriminator.propertyName]);
-        if (discriminatorProperty) {
-            if (discriminatorProperty.enum) {
-                return discriminatorProperty.enum.map((value) => value.toString()).join(' | ');
-            }
-        }
-    }
-    // Otherwise try to infer a nice title
-    let type = 'any';
-    if (schema.enum) {
-        type = 'enum';
-        // check array AND schema.items as this is sometimes null despite what the type indicates
-    }
-    else if (schema.type === 'array' && !!schema.items) {
-        type = `array of ${getSchemaTitle(noReference(schema.items))}`;
-    }
-    else if (schema.type || schema.properties) {
-        type = schema.type ?? 'object';
-        if (schema.format) {
-            type += ` (${schema.format})`;
-        }
-    }
-    else if ('anyOf' in schema) {
-        type = 'any of';
-    }
-    else if ('oneOf' in schema) {
-        type = 'one of';
-    }
-    else if ('allOf' in schema) {
-        type = 'all of';
-    }
-    else if ('not' in schema) {
-        type = 'not';
-    }
-    if (SYMBOL_REF_RESOLVED in schema) {
-        type = `${schema[SYMBOL_REF_RESOLVED]} (${type})`;
-    }
-    if (schema.nullable) {
-        type = `nullable ${type}`;
-    }
-    return type;
-}

package/dist/OpenAPISchema.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/OpenAPISchema.test.js

@@ -1,91 +0,0 @@
-import { it, describe, expect } from 'bun:test';
-import { getSchemaAlternatives } from './OpenAPISchema';
-describe('getSchemaAlternatives', () => {
-    it('should flatten oneOf', () => {
-        expect(getSchemaAlternatives({
-            oneOf: [
-                {
-                    oneOf: [
-                        {
-                            type: 'number',
-                        },
-                        {
-                            type: 'boolean',
-                        },
-                    ],
-                },
-                {
-                    type: 'string',
-                },
-            ],
-        })).toEqual([
-            [
-                {
-                    type: 'number',
-                },
-                {
-                    type: 'boolean',
-                },
-                {
-                    type: 'string',
-                },
-            ],
-            undefined,
-        ]);
-    });
-    it('should not flatten oneOf and allOf', () => {
-        expect(getSchemaAlternatives({
-            oneOf: [
-                {
-                    allOf: [
-                        {
-                            type: 'number',
-                        },
-                        {
-                            type: 'boolean',
-                        },
-                    ],
-                },
-                {
-                    type: 'string',
-                },
-            ],
-        })).toEqual([
-            [
-                {
-                    allOf: [
-                        {
-                            type: 'number',
-                        },
-                        {
-                            type: 'boolean',
-                        },
-                    ],
-                },
-                {
-                    type: 'string',
-                },
-            ],
-            undefined,
-        ]);
-    });
-    it('should stop at circular references', () => {
-        const a = {
-            anyOf: [
-                {
-                    type: 'string',
-                },
-            ],
-        };
-        a.anyOf.push(a);
-        expect(getSchemaAlternatives(a)).toEqual([
-            [
-                {
-                    type: 'string',
-                },
-                a,
-            ],
-            undefined,
-        ]);
-    });
-});

package/dist/OpenAPISecurities.js

@@ -1,42 +0,0 @@
-import * as React from 'react';
-import { InteractiveSection } from './InteractiveSection';
-import { Markdown } from './Markdown';
-/**
- * Present securities authorization that can be used for this operation.
- */
-export function OpenAPISecurities(props) {
-    const { securities, context } = props;
-    if (securities.length === 0) {
-        return null;
-    }
-    return (React.createElement(InteractiveSection, { header: "Authorization", className: "openapi-securities", toggeable: true, defaultOpened: false, toggleCloseIcon: context.icons.chevronDown, toggleOpenIcon: context.icons.chevronRight, tabs: securities.map(([key, security]) => {
-            return {
-                key: key,
-                label: key,
-                body: (React.createElement(React.Fragment, null,
-                    React.createElement("p", { className: "openapi-securities-label" }, getLabelForType(security)),
-                    security.description ? (React.createElement(Markdown, { source: security.description, className: "openapi-securities-description" })) : null)),
-            };
-        }) }));
-}
-function getLabelForType(security) {
-    switch (security.type) {
-        case 'apiKey':
-            return 'API Key';
-        case 'http':
-            if (security.scheme === 'basic') {
-                return 'Basic Auth';
-            }
-            if (security.scheme == 'bearer') {
-                return `Bearer Token ${security.bearerFormat ? `(${security.bearerFormat})` : ''}`;
-            }
-            return 'HTTP';
-        case 'oauth2':
-            return 'OAuth2';
-        case 'openIdConnect':
-            return 'OpenID Connect';
-        default:
-            // @ts-ignore
-            return security.type;
-    }
-}