@gitbook/react-openapi 0.7.1 → 1.0.0

package/dist/OpenAPISchema.jsx

@@ -0,0 +1,295 @@
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import clsx from 'clsx';
+import { useId } from 'react';
+import { InteractiveSection } from './InteractiveSection';
+import { Markdown } from './Markdown';
+import { checkIsReference, noReference, resolveDescription } from './utils';
+import { stringifyOpenAPI } from './stringifyOpenAPI';
+import { OpenAPISchemaName } from './OpenAPISchemaName';
+import { OpenAPIDisclosure } from './OpenAPIDisclosure';
+/**
+ * Render a property of an OpenAPI schema.
+ */
+export function OpenAPISchemaProperty(props) {
+    var _a;
+    var schema = props.schema, _b = props.circularRefs, parentCircularRefs = _b === void 0 ? new Map() : _b, context = props.context, className = props.className;
+    var id = useId();
+    var parentCircularRef = parentCircularRefs.get(schema);
+    var circularRefs = new Map(parentCircularRefs).set(schema, id);
+    // Avoid recursing infinitely, and instead render a link to the parent schema
+    var properties = parentCircularRef ? null : getSchemaProperties(schema);
+    var alternatives = parentCircularRef
+        ? null
+        : getSchemaAlternatives(schema, new Set(circularRefs.keys()));
+    if ((properties && !!properties.length) || schema.type === 'object') {
+        return (<InteractiveSection id={id} className={clsx('openapi-schema', className)}>
+                <OpenAPISchemaPresentation {...props}/>
+                <OpenAPIDisclosure context={context}>
+                    {properties && properties.length > 0 ? (<OpenAPISchemaProperties properties={properties} circularRefs={circularRefs} context={context}/>) : null}
+                </OpenAPIDisclosure>
+            </InteractiveSection>);
+    }
+    if ((_a = alternatives === null || alternatives === void 0 ? void 0 : alternatives[0]) === null || _a === void 0 ? void 0 : _a.length) {
+        return (<InteractiveSection id={id} className={clsx('openapi-schema', className)}>
+                <OpenAPISchemaPresentation {...props}/>
+                {alternatives[0].map(function (alternative, index) { return (<OpenAPISchemaAlternative key={index} schema={alternative} circularRefs={circularRefs} context={context}/>); })}
+            </InteractiveSection>);
+    }
+    return (<InteractiveSection id={id} className={clsx('openapi-schema', className)}>
+            <OpenAPISchemaPresentation {...props}/>
+            {(properties && properties.length > 0) ||
+            (schema.enum && schema.enum.length > 0) ||
+            parentCircularRef ? (<>
+                    {(properties === null || properties === void 0 ? void 0 : properties.length) ? (<OpenAPISchemaProperties properties={properties} circularRefs={circularRefs} context={context}/>) : null}
+                    {parentCircularRef ? (<OpenAPISchemaCircularRef id={parentCircularRef} schema={schema}/>) : null}
+                </>) : null}
+        </InteractiveSection>);
+}
+/**
+ * Render a set of properties of an OpenAPI schema.
+ */
+export function OpenAPISchemaProperties(props) {
+    var id = props.id, properties = props.properties, circularRefs = props.circularRefs, context = props.context;
+    if (!properties.length) {
+        return null;
+    }
+    return (<div id={id} className="openapi-schema-properties">
+            {properties.map(function (property) { return (<OpenAPISchemaProperty key={property.propertyName} circularRefs={circularRefs} {...property} context={context}/>); })}
+        </div>);
+}
+/**
+ * Render a root schema (such as the request body or response body).
+ */
+export function OpenAPIRootSchema(props) {
+    var schema = props.schema, context = props.context;
+    // Avoid recursing infinitely, and instead render a link to the parent schema
+    var properties = getSchemaProperties(schema);
+    if (properties && properties.length > 0) {
+        return <OpenAPISchemaProperties properties={properties} context={context}/>;
+    }
+    return (<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) {
+    var schema = props.schema, circularRefs = props.circularRefs, context = props.context;
+    var id = useId();
+    var subProperties = getSchemaProperties(schema);
+    return (<OpenAPIDisclosure context={context}>
+            <OpenAPISchemaProperties id={id} properties={subProperties !== null && subProperties !== void 0 ? subProperties : [{ schema: schema }]} circularRefs={subProperties ? new Map(circularRefs).set(schema, id) : circularRefs} context={context}/>
+        </OpenAPIDisclosure>);
+}
+/**
+ * Render a circular reference to a schema.
+ */
+function OpenAPISchemaCircularRef(props) {
+    var id = props.id, schema = props.schema;
+    return (<div className="openapi-schema-circular">
+            Circular reference to <a href={"#".concat(id)}>{getSchemaTitle(schema)}</a>{' '}
+            <span className="openapi-schema-circular-glyph">↩</span>
+        </div>);
+}
+/**
+ * Render the enum value for a schema.
+ */
+export function OpenAPISchemaEnum(props) {
+    var enumValues = props.enumValues;
+    return (<div className="openapi-schema-enum">
+            <span>
+                Options:{' '}
+                {enumValues.map(function (value, index) { return (<span key={index} className="openapi-schema-enum-value">
+                        <code>{"".concat(value)}</code>
+                        {index < enumValues.length - 1 ? ', ' : ''}
+                    </span>); })}
+            </span>
+        </div>);
+}
+export function OpenAPISchemaPresentation(props) {
+    var schema = props.schema, propertyName = props.propertyName, required = props.required;
+    var shouldDisplayExample = function (schema) {
+        return (typeof schema.example === 'string' ||
+            typeof schema.example === 'number' ||
+            typeof schema.example === 'boolean' ||
+            (Array.isArray(schema.example) && schema.example.length > 0) ||
+            (typeof schema.example === 'object' &&
+                schema.example !== null &&
+                Object.keys(schema.example).length > 0));
+    };
+    var description = resolveDescription(schema);
+    return (<div className="openapi-schema-presentation">
+            <OpenAPISchemaName type={getSchemaTitle(schema)} propertyName={propertyName} required={required} deprecated={schema.deprecated}/>
+            {schema['x-deprecated-sunset'] ? (<div className="openapi-deprecated-sunset openapi-schema-description openapi-markdown">
+                    Sunset date:{' '}
+                    <span className="openapi-deprecated-sunset-date">
+                        {schema['x-deprecated-sunset']}
+                    </span>
+                </div>) : null}
+            {description ? (<Markdown source={description} className="openapi-schema-description"/>) : null}
+            {shouldDisplayExample(schema) ? (<div className="openapi-schema-example">
+                    Example:{' '}
+                    <code>
+                        {typeof schema.example === 'string'
+                ? schema.example
+                : stringifyOpenAPI(schema.example)}
+                    </code>
+                </div>) : null}
+            {schema.pattern ? (<div className="openapi-schema-pattern">
+                    Pattern: <code>{schema.pattern}</code>
+                </div>) : null}
+            {schema.enum && schema.enum.length > 0 ? (<OpenAPISchemaEnum enumValues={schema.enum}/>) : null}
+        </div>);
+}
+/**
+ * Get the sub-properties of a schema.
+ */
+function getSchemaProperties(schema) {
+    if (schema.allOf) {
+        return schema.allOf.reduce(function (acc, subSchema) {
+            var _a;
+            var properties = (_a = getSchemaProperties(noReference(subSchema))) !== null && _a !== void 0 ? _a : [
+                {
+                    schema: noReference(subSchema),
+                },
+            ];
+            return __spreadArray(__spreadArray([], acc, true), properties, true);
+        }, []);
+    }
+    // check array AND schema.items as this is sometimes null despite what the type indicates
+    if (schema.type === 'array' && !!schema.items) {
+        var items = noReference(schema.items);
+        var itemProperties = getSchemaProperties(items);
+        if (itemProperties) {
+            return itemProperties;
+        }
+        return [
+            {
+                propertyName: 'items',
+                schema: items,
+            },
+        ];
+    }
+    if (schema.type === 'object' || schema.properties) {
+        var result_1 = [];
+        if (schema.properties) {
+            Object.entries(schema.properties).forEach(function (_a) {
+                var propertyName = _a[0], rawPropertySchema = _a[1];
+                var isReference = checkIsReference(rawPropertySchema);
+                var propertySchema = isReference
+                    ? { propertyName: propertyName }
+                    : rawPropertySchema;
+                result_1.push({
+                    propertyName: propertyName,
+                    required: Array.isArray(schema.required)
+                        ? schema.required.includes(propertyName)
+                        : undefined,
+                    schema: propertySchema,
+                });
+            });
+        }
+        if (schema.additionalProperties) {
+            var additionalProperties = noReference(schema.additionalProperties);
+            result_1.push({
+                propertyName: 'Other properties',
+                schema: additionalProperties === true ? {} : additionalProperties,
+            });
+        }
+        return result_1;
+    }
+    return null;
+}
+/**
+ * Get the alternatives to display for a schema.
+ */
+export function getSchemaAlternatives(schema, ancestors) {
+    if (ancestors === void 0) { ancestors = new Set(); }
+    var 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(function (acc, alternative) {
+        var _a;
+        if (!!alternative[alternativeType] && !ancestors.has(alternative)) {
+            return __spreadArray(__spreadArray([], acc, true), (((_a = getSchemaAlternatives(alternative, ancestors)) === null || _a === void 0 ? void 0 : _a[0]) || []), true);
+        }
+        return __spreadArray(__spreadArray([], acc, true), [alternative], false);
+    }, []);
+}
+export function getSchemaTitle(schema, 
+/** If the title is inferred in a oneOf with discriminator, we can use it to optimize the title */
+discriminator) {
+    var _a;
+    if (schema.title) {
+        // If the schema has a title, use it
+        return schema.title;
+    }
+    // Try using the discriminator
+    if ((discriminator === null || discriminator === void 0 ? void 0 : discriminator.propertyName) && schema.properties) {
+        var discriminatorProperty = noReference(schema.properties[discriminator.propertyName]);
+        if (discriminatorProperty) {
+            if (discriminatorProperty.enum) {
+                return discriminatorProperty.enum.map(function (value) { return value.toString(); }).join(' | ');
+            }
+        }
+    }
+    // Otherwise try to infer a nice title
+    var 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 = "".concat(getSchemaTitle(noReference(schema.items)), "[]");
+    }
+    else if (Array.isArray(schema.type)) {
+        type = schema.type.join(' | ');
+    }
+    else if (schema.type || schema.properties) {
+        type = (_a = schema.type) !== null && _a !== void 0 ? _a : 'object';
+        if (schema.format) {
+            type += " ".concat(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 (schema.nullable) {
+        type = "nullable ".concat(type);
+    }
+    return type;
+}

package/dist/OpenAPISchemaName.d.ts

@@ -0,0 +1,12 @@
+interface OpenAPISchemaNameProps {
+    propertyName?: string | JSX.Element;
+    required?: boolean;
+    type?: string;
+    deprecated?: boolean;
+}
+/**
+ * Display the schema name row.
+ * It includes the property name, type, required and deprecated status.
+ */
+export declare function OpenAPISchemaName(props: OpenAPISchemaNameProps): JSX.Element;
+export {};

package/dist/OpenAPISchemaName.jsx

@@ -0,0 +1,15 @@
+/**
+ * Display the schema name row.
+ * It includes the property name, type, required and deprecated status.
+ */
+export function OpenAPISchemaName(props) {
+    var type = props.type, propertyName = props.propertyName, required = props.required, deprecated = props.deprecated;
+    return (<div className="openapi-schema-name">
+            {propertyName ? (<span data-deprecated={deprecated} className="openapi-schema-propertyname">
+                    {propertyName}
+                </span>) : null}
+            {type ? <span className="openapi-schema-type">{type}</span> : null}
+            {required ? <span className="openapi-schema-required">required</span> : null}
+            {deprecated ? <span className="openapi-deprecated">Deprecated</span> : null}
+        </div>);
+}

package/dist/OpenAPISecurities.d.ts

@@ -1,10 +1,8 @@
-import * as React from 'react';
-import { OpenAPIClientContext } from './types';
-import { OpenAPIOperationData } from './fetchOpenAPIOperation';
+import type { OpenAPIClientContext, OpenAPIOperationData } from './types';
 /**
  * Present securities authorization that can be used for this operation.
  */
 export declare function OpenAPISecurities(props: {
     securities: OpenAPIOperationData['securities'];
     context: OpenAPIClientContext;
-}): React.JSX.Element | null;
+}): import("react").JSX.Element | null;

package/dist/OpenAPISecurities.jsx

@@ -0,0 +1,55 @@
+import { InteractiveSection } from './InteractiveSection';
+import { Markdown } from './Markdown';
+import { OpenAPISchemaName } from './OpenAPISchemaName';
+import { resolveDescription } from './utils';
+/**
+ * Present securities authorization that can be used for this operation.
+ */
+export function OpenAPISecurities(props) {
+    var securities = props.securities, context = props.context;
+    if (securities.length === 0) {
+        return null;
+    }
+    return (<InteractiveSection header="Authorizations" toggeable defaultOpened={false} toggleIcon={context.icons.chevronRight} className="openapi-securities" tabs={securities.map(function (_a) {
+            var key = _a[0], security = _a[1];
+            var description = resolveDescription(security);
+            return {
+                key: key,
+                label: key,
+                body: (<div className="openapi-schema-body">
+                            <div className="openapi-schema-presentation">
+                                {getLabelForType(security)}
+
+                                {description ? (<Markdown source={description} className="openapi-securities-description"/>) : null}
+                            </div>
+                        </div>),
+            };
+        })}/>);
+}
+function getLabelForType(security) {
+    var _a;
+    switch (security.type) {
+        case 'apiKey':
+            return (<OpenAPISchemaName propertyName={(_a = security.name) !== null && _a !== void 0 ? _a : 'apiKey'} type="string" required/>);
+        case 'http':
+            if (security.scheme === 'basic') {
+                return <OpenAPISchemaName propertyName="Authorization" type="string" required/>;
+            }
+            if (security.scheme == 'bearer') {
+                var description = resolveDescription(security);
+                return (<>
+                        <OpenAPISchemaName propertyName="Authorization" type="string" required/>
+                        {/** Show a default description if none is provided */}
+                        {!description ? (<Markdown source={"Bearer authentication header of the form Bearer ".concat("&lt;token&gt;", ".")} className="openapi-securities-description"/>) : null}
+                    </>);
+            }
+            return <OpenAPISchemaName propertyName="HTTP" required/>;
+        case 'oauth2':
+            return <OpenAPISchemaName propertyName="OAuth2" required/>;
+        case 'openIdConnect':
+            return <OpenAPISchemaName propertyName="OpenID Connect" required/>;
+        default:
+            // @ts-ignore
+            return security.type;
+    }
+}

package/dist/OpenAPIServerURL.d.ts

@@ -1,11 +1,10 @@
-import * as React from 'react';
-import { OpenAPIV3 } from 'openapi-types';
+import type { OpenAPIV3 } from '@gitbook/openapi-parser';
 /**
  * Show the url of the server with variables replaced by their default values.
  */
 export declare function OpenAPIServerURL(props: {
     servers: OpenAPIV3.ServerObject[];
-}): React.JSX.Element;
+}): import("react").JSX.Element | null;
 /**
  * Get the default URL for the server.
  */

package/dist/OpenAPIServerURL.jsx

@@ -0,0 +1,67 @@
+import { OpenAPIServerURLVariable } from './OpenAPIServerURLVariable';
+/**
+ * Show the url of the server with variables replaced by their default values.
+ */
+export function OpenAPIServerURL(props) {
+    var _a;
+    var servers = props.servers;
+    var server = servers[0];
+    if (!server) {
+        return null;
+    }
+    var parts = parseServerURL((_a = server === null || server === void 0 ? void 0 : server.url) !== null && _a !== void 0 ? _a : '');
+    return (<span>
+            {parts.map(function (part, i) {
+            var _a;
+            if (part.kind === 'text') {
+                return <span key={i}>{part.text}</span>;
+            }
+            else {
+                var variable = (_a = server.variables) === null || _a === void 0 ? void 0 : _a[part.name];
+                if (!variable) {
+                    return <span key={i}>{"{".concat(part.name, "}")}</span>;
+                }
+                return (<OpenAPIServerURLVariable key={i} name={part.name} variable={variable}/>);
+            }
+        })}
+        </span>);
+}
+/**
+ * Get the default URL for the server.
+ */
+export function getServersURL(servers) {
+    var _a;
+    var server = servers[0];
+    if (!server) {
+        return '';
+    }
+    var parts = parseServerURL((_a = server === null || server === void 0 ? void 0 : server.url) !== null && _a !== void 0 ? _a : '');
+    return parts
+        .map(function (part) {
+        var _a, _b, _c;
+        if (part.kind === 'text') {
+            return part.text;
+        }
+        else {
+            return (_c = (_b = (_a = server.variables) === null || _a === void 0 ? void 0 : _a[part.name]) === null || _b === void 0 ? void 0 : _b.default) !== null && _c !== void 0 ? _c : "{".concat(part.name, "}");
+        }
+    })
+        .join('');
+}
+function parseServerURL(url) {
+    var parts = url.split(/{([^}]+)}/g);
+    var result = [];
+    for (var i = 0; i < parts.length; i++) {
+        var part = parts[i];
+        if (!part) {
+            continue;
+        }
+        if (i % 2 === 0) {
+            result.push({ kind: 'text', text: part });
+        }
+        else {
+            result.push({ kind: 'variable', name: part });
+        }
+    }
+    return result;
+}

package/dist/OpenAPIServerURLVariable.d.ts

@@ -1,9 +1,8 @@
-import * as React from 'react';
-import { OpenAPIV3 } from 'openapi-types';
+import type { OpenAPIV3 } from '@gitbook/openapi-parser';
 /**
  * Interactive component to show the value of a server variable and let the user change it.
  */
 export declare function OpenAPIServerURLVariable(props: {
     name: string;
     variable: OpenAPIV3.ServerVariableObject;
-}): React.JSX.Element;
+}): import("react").JSX.Element;

package/dist/OpenAPIServerURLVariable.jsx

@@ -0,0 +1,8 @@
+'use client';
+/**
+ * Interactive component to show the value of a server variable and let the user change it.
+ */
+export function OpenAPIServerURLVariable(props) {
+    var variable = props.variable;
+    return <span className="openapi-url-var">{variable.default}</span>;
+}

package/dist/OpenAPISpec.d.ts

@@ -1,5 +1,4 @@
-import * as React from 'react';
-import { OpenAPIClientContext } from './types';
+import type { OpenAPIClientContext, OpenAPIOperationData } from './types';
 /**
  * Client component to render the spec for the request and response.
  *
@@ -7,6 +6,6 @@ import { OpenAPIClientContext } from './types';
  * (the entire schema is rendered at once, while the client component only renders the visible part)
  */
 export declare function OpenAPISpec(props: {
-    rawData: any;
+    data: OpenAPIOperationData;
     context: OpenAPIClientContext;
-}): React.JSX.Element;
+}): import("react").JSX.Element;

package/dist/OpenAPISpec.jsx

@@ -0,0 +1,91 @@
+'use client';
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { InteractiveSection } from './InteractiveSection';
+import { OpenAPIRequestBody } from './OpenAPIRequestBody';
+import { OpenAPIResponses } from './OpenAPIResponses';
+import { OpenAPISchemaProperties } from './OpenAPISchema';
+import { OpenAPISecurities } from './OpenAPISecurities';
+import { noReference, resolveDescription } from './utils';
+/**
+ * Client component to render the spec for the request and response.
+ *
+ * We use a client component as rendering recursive JSON schema in the server is expensive
+ * (the entire schema is rendered at once, while the client component only renders the visible part)
+ */
+export function OpenAPISpec(props) {
+    var _a;
+    var data = props.data, context = props.context;
+    var operation = data.operation, securities = data.securities;
+    var parameters = (_a = operation.parameters) !== null && _a !== void 0 ? _a : [];
+    var parameterGroups = groupParameters(parameters);
+    return (<>
+            {securities.length > 0 ? (<OpenAPISecurities securities={securities} context={context}/>) : null}
+
+            {parameterGroups.map(function (group) {
+            return (<InteractiveSection key={group.key} className="openapi-parameters" header={group.label}>
+                        <OpenAPISchemaProperties properties={group.parameters.map(function (parameter) {
+                    var _a;
+                    var description = resolveDescription(parameter);
+                    return {
+                        propertyName: parameter.name,
+                        schema: __assign({ 
+                            // Description of the parameter is defined at the parameter level
+                            // we use display it if the schema doesn't override it
+                            description: description, example: parameter.example, 
+                            // Deprecated can be defined at the parameter level
+                            deprecated: parameter.deprecated }, ((_a = noReference(parameter.schema)) !== null && _a !== void 0 ? _a : {})),
+                        required: parameter.required,
+                    };
+                })} context={context}/>
+                    </InteractiveSection>);
+        })}
+
+            {operation.requestBody ? (<OpenAPIRequestBody requestBody={noReference(operation.requestBody)} context={context}/>) : null}
+            {operation.responses ? (<OpenAPIResponses responses={noReference(operation.responses)} context={context}/>) : null}
+        </>);
+}
+function groupParameters(parameters) {
+    var sorted = ['path', 'query', 'header'];
+    var groups = [];
+    parameters
+        .filter(function (parameter) { return parameter.in; })
+        .forEach(function (parameter) {
+        var key = parameter.in;
+        var label = getParameterGroupName(parameter.in);
+        var group = groups.find(function (group) { return group.key === key; });
+        if (group) {
+            group.parameters.push(parameter);
+        }
+        else {
+            groups.push({
+                key: key,
+                label: label,
+                parameters: [parameter],
+            });
+        }
+    });
+    groups.sort(function (a, b) { return sorted.indexOf(a.key) - sorted.indexOf(b.key); });
+    return groups;
+}
+function getParameterGroupName(paramIn) {
+    switch (paramIn) {
+        case 'path':
+            return 'Path parameters';
+        case 'query':
+            return 'Query parameters';
+        case 'header':
+            return 'Header parameters';
+        default:
+            return paramIn;
+    }
+}

package/dist/OpenAPITabs.d.ts

@@ -0,0 +1,25 @@
+import { Key, TabsProps } from 'react-aria-components';
+export type Tab = {
+    key: Key;
+    label: string;
+    body: React.ReactNode;
+    description?: string;
+};
+/**
+ * The OpenAPI Tabs wrapper component.
+ */
+export declare function OpenAPITabs(props: React.PropsWithChildren<TabsProps & {
+    items: Tab[];
+}>): import("react").JSX.Element;
+/**
+ * The OpenAPI Tabs list component.
+ * This component should be used as a child of the OpenAPITabs component.
+ * It renders the list of tabs.
+ */
+export declare function OpenAPITabsList(): import("react").JSX.Element;
+/**
+ * The OpenAPI Tabs panels component.
+ * This component should be used as a child of the OpenAPITabs component.
+ * It renders the content of the selected tab.
+ */
+export declare function OpenAPITabsPanels(): import("react").JSX.Element | null;