@gitbook/react-openapi 0.7.1 → 1.0.1

package/dist/OpenAPIRequestBody.jsx

@@ -0,0 +1,22 @@
+import { OpenAPIRootSchema } from './OpenAPISchema';
+import { InteractiveSection } from './InteractiveSection';
+import { checkIsReference } from './utils';
+/**
+ * Display an interactive request body.
+ */
+export function OpenAPIRequestBody(props) {
+    var _a;
+    var requestBody = props.requestBody, context = props.context;
+    if (checkIsReference(requestBody)) {
+        return null;
+    }
+    return (<InteractiveSection header="Body" className="openapi-requestbody" tabs={Object.entries((_a = requestBody.content) !== null && _a !== void 0 ? _a : {}).map(function (_a) {
+            var _b;
+            var contentType = _a[0], mediaTypeObject = _a[1];
+            return {
+                key: contentType,
+                label: contentType,
+                body: (<OpenAPIRootSchema schema={(_b = mediaTypeObject.schema) !== null && _b !== void 0 ? _b : {}} context={context}/>),
+            };
+        })}/>);
+}

package/dist/OpenAPIResponse.d.ts

@@ -1,10 +1,10 @@
-import * as React from 'react';
-import { OpenAPIV3 } from 'openapi-types';
-import { OpenAPIClientContext } from './types';
+import type { OpenAPIV3 } from '@gitbook/openapi-parser';
+import type { OpenAPIClientContext } from './types';
 /**
  * Display an interactive response body.
  */
 export declare function OpenAPIResponse(props: {
     response: OpenAPIV3.ResponseObject;
+    mediaType: OpenAPIV3.MediaTypeObject;
     context: OpenAPIClientContext;
-}): React.JSX.Element | null;
+}): import("react").JSX.Element | null;

package/dist/OpenAPIResponse.jsx

@@ -0,0 +1,39 @@
+import { OpenAPISchemaProperties } from './OpenAPISchema';
+import { resolveDescription } from './utils';
+import { OpenAPIDisclosure } from './OpenAPIDisclosure';
+/**
+ * Display an interactive response body.
+ */
+export function OpenAPIResponse(props) {
+    var _a, _b, _c;
+    var response = props.response, context = props.context, mediaType = props.mediaType;
+    var headers = Object.entries((_a = response.headers) !== null && _a !== void 0 ? _a : {}).map(function (_a) {
+        var name = _a[0], header = _a[1];
+        return [name, header !== null && header !== void 0 ? header : {}];
+    });
+    var content = Object.entries((_b = mediaType.schema) !== null && _b !== void 0 ? _b : {});
+    var description = resolveDescription(response);
+    if (content.length === 0 && !description && headers.length === 0) {
+        return null;
+    }
+    return (<div className="openapi-response-body">
+            {headers.length > 0 ? (<OpenAPIDisclosure context={context} label={'Headers'}>
+                    <OpenAPISchemaProperties properties={headers.map(function (_a) {
+                var _b;
+                var name = _a[0], header = _a[1];
+                return ({
+                    propertyName: name,
+                    schema: (_b = header.schema) !== null && _b !== void 0 ? _b : {},
+                    required: header.required,
+                });
+            })} context={context}/>
+                </OpenAPIDisclosure>) : null}
+            <div className="openapi-responsebody">
+                <OpenAPISchemaProperties id={"response-".concat(context.blockKey)} properties={[
+            {
+                schema: (_c = mediaType.schema) !== null && _c !== void 0 ? _c : {},
+            },
+        ]} context={context}/>
+            </div>
+        </div>);
+}

package/dist/OpenAPIResponseExample.d.ts

@@ -1,10 +1,8 @@
-import * as React from 'react';
-import { OpenAPIOperationData } from './fetchOpenAPIOperation';
-import { OpenAPIContextProps } from './types';
+import type { OpenAPIContextProps, OpenAPIOperationData } from './types';
 /**
  * Display an example of the response content.
  */
 export declare function OpenAPIResponseExample(props: {
     data: OpenAPIOperationData;
     context: OpenAPIContextProps;
-}): React.JSX.Element | null;
+}): import("react").JSX.Element | null;

package/dist/OpenAPIResponseExample.jsx

@@ -0,0 +1,108 @@
+import { generateSchemaExample } from './generateSchemaExample';
+import { checkIsReference, createStateKey, resolveDescription } from './utils';
+import { stringifyOpenAPI } from './stringifyOpenAPI';
+import { OpenAPITabs, OpenAPITabsList, OpenAPITabsPanels } from './OpenAPITabs';
+import { InteractiveSection } from './InteractiveSection';
+/**
+ * Display an example of the response content.
+ */
+export function OpenAPIResponseExample(props) {
+    var data = props.data, context = props.context;
+    // if there are no responses defined for the operation
+    if (!data.operation.responses) {
+        return null;
+    }
+    var responses = Object.entries(data.operation.responses);
+    // Sort response to get 200, and 2xx first
+    responses.sort(function (_a, _b) {
+        var a = _a[0];
+        var b = _b[0];
+        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);
+    });
+    var examples = responses
+        .map(function (_a) {
+        var key = _a[0], value = _a[1];
+        var responseObject = value;
+        var mediaTypeObject = (function () {
+            var _a;
+            if (!responseObject.content) {
+                return null;
+            }
+            var key = Object.keys(responseObject.content)[0];
+            return ((_a = responseObject.content['application/json']) !== null && _a !== void 0 ? _a : (key ? responseObject.content[key] : null));
+        })();
+        if (!mediaTypeObject) {
+            return {
+                key: key,
+                label: key,
+                description: resolveDescription(responseObject),
+                body: <OpenAPIEmptyResponseExample />,
+            };
+        }
+        var example = handleUnresolvedReference((function () {
+            var examples = mediaTypeObject.examples, example = mediaTypeObject.example;
+            if (examples) {
+                var key_1 = Object.keys(examples)[0];
+                if (key_1) {
+                    // @TODO handle multiple examples
+                    var firstExample = examples[key_1];
+                    if (firstExample) {
+                        return firstExample;
+                    }
+                }
+            }
+            if (example) {
+                return { value: example };
+            }
+            var schema = mediaTypeObject.schema;
+            if (!schema) {
+                return null;
+            }
+            return { value: generateSchemaExample(schema) };
+        })());
+        return {
+            key: key,
+            label: key,
+            description: resolveDescription(responseObject),
+            body: (example === null || example === void 0 ? void 0 : example.value) ? (<context.CodeBlock code={typeof example.value === 'string'
+                    ? example.value
+                    : stringifyOpenAPI(example.value, null, 2)} syntax="json"/>) : (<OpenAPIEmptyResponseExample />),
+        };
+    })
+        .filter(function (val) {
+        return Boolean(val);
+    });
+    if (examples.length === 0) {
+        return null;
+    }
+    return (<OpenAPITabs stateKey={createStateKey('response-example')} items={examples}>
+            <InteractiveSection header={<OpenAPITabsList />} className="openapi-response-example">
+                <OpenAPITabsPanels />
+            </InteractiveSection>
+        </OpenAPITabs>);
+}
+function OpenAPIEmptyResponseExample() {
+    return (<pre className="openapi-response-example-empty">
+            <p>No body</p>
+        </pre>);
+}
+function handleUnresolvedReference(input) {
+    var isReference = checkIsReference(input === null || input === void 0 ? void 0 : input.value);
+    if (isReference) {
+        // If we find a reference that wasn't resolved or needed to be resolved externally, render out the URL
+        return { value: input.value.$ref };
+    }
+    return input;
+}

package/dist/OpenAPIResponses.d.ts

@@ -1,10 +1,9 @@
-import * as React from 'react';
-import { OpenAPIV3 } from 'openapi-types';
+import type { OpenAPIV3, OpenAPIV3_1 } from '@gitbook/openapi-parser';
 import { OpenAPIClientContext } from './types';
 /**
  * Display an interactive response body.
  */
 export declare function OpenAPIResponses(props: {
-    responses: OpenAPIV3.ResponsesObject;
+    responses: OpenAPIV3.ResponsesObject | OpenAPIV3_1.ResponsesObject;
     context: OpenAPIClientContext;
-}): React.JSX.Element;
+}): import("react").JSX.Element;

package/dist/OpenAPIResponses.jsx

@@ -0,0 +1,35 @@
+import { OpenAPIResponse } from './OpenAPIResponse';
+import { InteractiveSection } from './InteractiveSection';
+import { OpenAPIDisclosureGroup } from './OpenAPIDisclosureGroup';
+import { Markdown } from './Markdown';
+/**
+ * Display an interactive response body.
+ */
+export function OpenAPIResponses(props) {
+    var responses = props.responses, context = props.context;
+    return (<InteractiveSection header="Responses" className="openapi-responses">
+            <OpenAPIDisclosureGroup allowsMultipleExpanded icon={context.icons.chevronRight} groups={Object.entries(responses).map(function (_a) {
+            var _b;
+            var statusCode = _a[0], response = _a[1];
+            var content = Object.entries((_b = response.content) !== null && _b !== void 0 ? _b : {});
+            var description = response.description;
+            return {
+                id: statusCode,
+                label: (<div className="openapi-response-tab-content" key={"response-".concat(statusCode)}>
+                                    <span className="openapi-response-statuscode">
+                                        {statusCode}
+                                    </span>
+                                    {description ? (<Markdown source={description} className="openapi-response-description"/>) : null}
+                                </div>),
+                tabs: content.map(function (_a) {
+                    var contentType = _a[0], mediaType = _a[1];
+                    return ({
+                        id: contentType,
+                        label: contentType,
+                        body: (<OpenAPIResponse key={"$response-".concat(statusCode, "-").concat(contentType)} response={response} mediaType={mediaType} context={context}/>),
+                    });
+                }),
+            };
+        })}/>
+        </InteractiveSection>);
+}

package/dist/OpenAPISchema.d.ts

@@ -1,8 +1,7 @@
-import { OpenAPIV3 } from 'openapi-types';
-import React from 'react';
-import { OpenAPIClientContext } from './types';
+import type { OpenAPIV3 } from '@gitbook/openapi-parser';
+import type { OpenAPIClientContext } from './types';
 type CircularRefsIds = Map<OpenAPIV3.SchemaObject, string>;
-interface OpenAPISchemaPropertyEntry {
+export interface OpenAPISchemaPropertyEntry {
     propertyName?: string;
     required?: boolean;
     schema: OpenAPIV3.SchemaObject;
@@ -15,7 +14,7 @@ export declare function OpenAPISchemaProperty(props: OpenAPISchemaPropertyEntry
     circularRefs?: CircularRefsIds;
     context: OpenAPIClientContext;
     className?: string;
-}): React.JSX.Element;
+}): import("react").JSX.Element;
 /**
  * Render a set of properties of an OpenAPI schema.
  */
@@ -24,22 +23,26 @@ export declare function OpenAPISchemaProperties(props: {
     properties: OpenAPISchemaPropertyEntry[];
     circularRefs?: CircularRefsIds;
     context: OpenAPIClientContext;
-}): React.JSX.Element | null;
+}): import("react").JSX.Element | null;
 /**
  * Render a root schema (such as the request body or response body).
  */
 export declare function OpenAPIRootSchema(props: {
     schema: OpenAPIV3.SchemaObject;
     context: OpenAPIClientContext;
-}): React.JSX.Element;
+}): import("react").JSX.Element;
 /**
  * Render the enum value for a schema.
  */
 export declare function OpenAPISchemaEnum(props: {
     enumValues: any[];
-}): React.JSX.Element;
+}): import("react").JSX.Element;
+export declare function OpenAPISchemaPresentation(props: OpenAPISchemaPropertyEntry): import("react").JSX.Element;
 /**
  * Get the alternatives to display for a schema.
  */
 export declare function getSchemaAlternatives(schema: OpenAPIV3.SchemaObject, ancestors?: Set<OpenAPIV3.SchemaObject>): null | [OpenAPIV3.SchemaObject[], OpenAPIV3.DiscriminatorObject | undefined];
+export declare function getSchemaTitle(schema: OpenAPIV3.SchemaObject, 
+/** If the title is inferred in a oneOf with discriminator, we can use it to optimize the title */
+discriminator?: OpenAPIV3.DiscriminatorObject): string;
 export {};

package/dist/OpenAPISchema.jsx

@@ -0,0 +1,285 @@
+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, 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}/>
+                {properties && properties.length > 0 ? (<OpenAPIDisclosure context={context}>
+                        <OpenAPISchemaProperties properties={properties} circularRefs={circularRefs} context={context}/>
+                    </OpenAPIDisclosure>) : null}
+            </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={"alternative-".concat(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(subSchema)) !== null && _a !== void 0 ? _a : [
+                {
+                    schema: 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 = 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], propertySchema = _a[1];
+                result_1.push({
+                    propertyName: propertyName,
+                    required: Array.isArray(schema.required)
+                        ? schema.required.includes(propertyName)
+                        : undefined,
+                    schema: propertySchema,
+                });
+            });
+        }
+        if (schema.additionalProperties) {
+            var additionalProperties = 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, downAncestors), schema.discriminator];
+    }
+    if (schema.oneOf) {
+        return [flattenAlternatives('oneOf', schema.oneOf, downAncestors), 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 = schema.properties[discriminator.propertyName];
+        if (discriminatorProperty && !checkIsReference(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(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;