@gitbook/react-openapi 1.1.9 → 1.2.0

package/dist/context.js

@@ -0,0 +1,43 @@
+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);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { translations } from './translations';
+/**
+ * Resolve OpenAPI context from the input.
+ */
+export function resolveOpenAPIContext(context) {
+    var locale = context.locale, rest = __rest(context, ["locale"]);
+    return __assign(__assign({}, rest), { translation: translations[locale !== null && locale !== void 0 ? locale : 'en'] });
+}
+/**
+ * Get the client context from the OpenAPI context.
+ */
+export function getOpenAPIClientContext(context) {
+    return {
+        translation: context.translation,
+        icons: context.icons,
+        defaultInteractiveOpened: context.defaultInteractiveOpened,
+        blockKey: context.blockKey,
+        id: context.id,
+        $$isClientContext$$: true,
+    };
+}

package/dist/generateSchemaExample.js

@@ -130,6 +130,10 @@ var getExampleFromSchema = function (schema, options, level, parentSchema, name,
     // Sometimes, we just want the structure and no values.
     // But if `emptyString` is  set, we do want to see some values.
     var makeUpRandomData = !!(options === null || options === void 0 ? void 0 : options.emptyString);
+    // If the property is deprecated we don't show it in examples.
+    if (schema.deprecated) {
+        return undefined;
+    }
     // Check if the property is read-only/write-only
     if (((options === null || options === void 0 ? void 0 : options.mode) === 'write' && schema.readOnly) ||
         ((options === null || options === void 0 ? void 0 : options.mode) === 'read' && schema.writeOnly)) {

package/dist/getOrCreateStoreByKey.d.ts

@@ -0,0 +1,10 @@
+type Key = string | number;
+type State = {
+    key: Key | null;
+};
+type Actions = {
+    setKey: (key: Key | null) => void;
+};
+export type Store = State & Actions;
+export declare const getOrCreateStoreByKey: (storeKey: string, initialKey?: Key) => import("zustand").StoreApi<Store>;
+export {};

package/dist/getOrCreateStoreByKey.js

@@ -0,0 +1,19 @@
+import { createStore } from 'zustand';
+var createStateStore = function (initial) {
+    return createStore()(function (set) { return ({
+        key: initial !== null && initial !== void 0 ? initial : null,
+        setKey: function (key) {
+            set(function () { return ({ key: key }); });
+        },
+    }); });
+};
+var defaultStores = new Map();
+var createStateStoreFactory = function (stores) {
+    return function (storeKey, initialKey) {
+        if (!stores.has(storeKey)) {
+            stores.set(storeKey, createStateStore(initialKey));
+        }
+        return stores.get(storeKey);
+    };
+};
+export var getOrCreateStoreByKey = createStateStoreFactory(defaultStores);

package/dist/index.d.ts

@@ -1,5 +1,9 @@
 export * from './schemas';
 export * from './OpenAPIOperation';
+export * from './OpenAPIWebhook';
 export * from './OpenAPIOperationContext';
 export * from './resolveOpenAPIOperation';
-export type { OpenAPISchemasData, OpenAPIOperationData } from './types';
+export * from './resolveOpenAPIWebhook';
+export type { OpenAPIOperationData, OpenAPIWebhookData } from './types';
+export type { OpenAPIContextInput } from './context';
+export { checkIsValidLocale } from './translations';

package/dist/index.js

@@ -1,4 +1,7 @@
 export * from './schemas';
 export * from './OpenAPIOperation';
+export * from './OpenAPIWebhook';
 export * from './OpenAPIOperationContext';
 export * from './resolveOpenAPIOperation';
+export * from './resolveOpenAPIWebhook';
+export { checkIsValidLocale } from './translations';

package/dist/resolveOpenAPIOperation.js

@@ -63,7 +63,7 @@ export { fromJSON, toJSON };
  */
 export function resolveOpenAPIOperation(filesystem, operationDescriptor) {
     return __awaiter(this, void 0, void 0, function () {
-        var path, method, schema, operation, commonParameters, servers, security, securities, _i, security_1, entry, securityKey, securityScheme;
+        var path, method, schema, operation, commonParameters, servers, security, isOptionalSecurity, flatSecurities, securities, _i, flatSecurities_1, entry, securityKey, securityScheme;
         var _a, _b, _c, _d, _e, _f;
         return __generator(this, function (_g) {
             switch (_g.label) {
@@ -81,15 +81,20 @@ export function resolveOpenAPIOperation(filesystem, operationDescriptor) {
                         operation = __assign(__assign({}, operation), { parameters: __spreadArray(__spreadArray([], commonParameters, true), ((_a = operation.parameters) !== null && _a !== void 0 ? _a : []), true) });
                     }
                     servers = 'servers' in schema ? ((_b = schema.servers) !== null && _b !== void 0 ? _b : []) : [];
-                    security = flattenSecurities((_d = (_c = operation.security) !== null && _c !== void 0 ? _c : schema.security) !== null && _d !== void 0 ? _d : []);
+                    security = (_d = (_c = operation.security) !== null && _c !== void 0 ? _c : schema.security) !== null && _d !== void 0 ? _d : [];
+                    isOptionalSecurity = security.some(function (entry) { return Object.keys(entry).length === 0; });
+                    flatSecurities = flattenSecurities(security);
                     securities = [];
-                    for (_i = 0, security_1 = security; _i < security_1.length; _i++) {
-                        entry = security_1[_i];
+                    for (_i = 0, flatSecurities_1 = flatSecurities; _i < flatSecurities_1.length; _i++) {
+                        entry = flatSecurities_1[_i];
                         securityKey = Object.keys(entry)[0];
                         if (securityKey) {
                             securityScheme = (_f = (_e = schema.components) === null || _e === void 0 ? void 0 : _e.securitySchemes) === null || _f === void 0 ? void 0 : _f[securityKey];
                             if (securityScheme && !checkIsReference(securityScheme)) {
-                                securities.push([securityKey, securityScheme]);
+                                securities.push([
+                                    securityKey,
+                                    __assign(__assign({}, securityScheme), { required: !isOptionalSecurity }),
+                                ]);
                             }
                         }
                     }

package/dist/resolveOpenAPIWebhook.d.ts

@@ -0,0 +1,11 @@
+import { fromJSON, toJSON } from 'flatted';
+import type { Filesystem, OpenAPIV3xDocument } from '@gitbook/openapi-parser';
+import type { OpenAPIWebhookData } from './types';
+export { fromJSON, toJSON };
+/**
+ * Resolve an OpenAPI webhook in a file and compile it to a more usable format.
+ */
+export declare function resolveOpenAPIWebhook(filesystem: Filesystem<OpenAPIV3xDocument>, webhookDescriptor: {
+    name: string;
+    method: string;
+}): Promise<OpenAPIWebhookData | null>;

package/dist/resolveOpenAPIWebhook.js

@@ -0,0 +1,127 @@
+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);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+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 { fromJSON, toJSON } from 'flatted';
+import { dereferenceFilesystem } from './dereference';
+export { fromJSON, toJSON };
+/**
+ * Resolve an OpenAPI webhook in a file and compile it to a more usable format.
+ */
+export function resolveOpenAPIWebhook(filesystem, webhookDescriptor) {
+    return __awaiter(this, void 0, void 0, function () {
+        var name, method, schema, operation, commonParameters, servers;
+        var _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    name = webhookDescriptor.name, method = webhookDescriptor.method;
+                    return [4 /*yield*/, dereferenceFilesystem(filesystem)];
+                case 1:
+                    schema = _c.sent();
+                    operation = getWebhookByNameAndMethod(schema, name, method);
+                    if (!operation) {
+                        return [2 /*return*/, null];
+                    }
+                    commonParameters = getPathObjectParameter(schema, name);
+                    if (commonParameters) {
+                        operation = __assign(__assign({}, operation), { parameters: __spreadArray(__spreadArray([], commonParameters, true), ((_a = operation.parameters) !== null && _a !== void 0 ? _a : []), true) });
+                    }
+                    servers = 'servers' in schema ? ((_b = schema.servers) !== null && _b !== void 0 ? _b : []) : [];
+                    return [2 /*return*/, {
+                            servers: servers,
+                            operation: operation,
+                            method: method,
+                            name: name,
+                        }];
+            }
+        });
+    });
+}
+/**
+ * Get a path object from its path.
+ */
+function getPathObject(schema, name) {
+    var _a;
+    if ((_a = schema.webhooks) === null || _a === void 0 ? void 0 : _a[name]) {
+        return schema.webhooks[name];
+    }
+    return null;
+}
+/**
+ * Resolve parameters from a path in an OpenAPI schema.
+ */
+function getPathObjectParameter(schema, path) {
+    var pathObject = getPathObject(schema, path);
+    if (pathObject === null || pathObject === void 0 ? void 0 : pathObject.parameters) {
+        return pathObject.parameters;
+    }
+    return null;
+}
+/**
+ * Get an operation by its path and method.
+ */
+function getWebhookByNameAndMethod(schema, name, method) {
+    // Types are buffy for OpenAPIV3_1.OperationObject, so we use v3
+    var pathObject = getPathObject(schema, name);
+    if (!pathObject) {
+        return null;
+    }
+    var normalizedMethod = method.toLowerCase();
+    if (!pathObject[normalizedMethod]) {
+        return null;
+    }
+    return pathObject[normalizedMethod];
+}

package/dist/schemas/OpenAPISchemas.d.ts

@@ -1,15 +1,14 @@
-import type { OpenAPIContextProps, OpenAPISchemasData } from '../types';
-type OpenAPISchemasContextProps = Omit<OpenAPIContextProps, 'renderCodeBlock' | 'renderHeading' | 'renderDocument'>;
+import type { OpenAPISchema } from '@gitbook/openapi-parser';
+import { type OpenAPIContextInput } from '../context';
 /**
- * Display OpenAPI Schemas.
+ * OpenAPI Schemas component.
  */
 export declare function OpenAPISchemas(props: {
     className?: string;
-    data: OpenAPISchemasData;
-    context: OpenAPISchemasContextProps;
+    schemas: OpenAPISchema[];
+    context: OpenAPIContextInput;
     /**
      * Whether to show the schema directly if there is only one.
      */
     grouped?: boolean;
 }): import("react").JSX.Element | null;
-export {};

package/dist/schemas/OpenAPISchemas.jsx

@@ -1,62 +1,65 @@
 import clsx from 'clsx';
-import { OpenAPIDisclosureGroup } from '../OpenAPIDisclosureGroup';
+import { OpenAPIDisclosure } from '../OpenAPIDisclosure';
+import { OpenAPIExample } from '../OpenAPIExample';
 import { OpenAPIRootSchema } from '../OpenAPISchemaServer';
-import { Section, SectionBody } from '../StaticSection';
+import { Section, SectionBody, StaticSection } from '../StaticSection';
+import { getOpenAPIClientContext, resolveOpenAPIContext, } from '../context';
+import { t } from '../translate';
+import { getExampleFromSchema } from '../util/example';
 /**
- * Display OpenAPI Schemas.
+ * OpenAPI Schemas component.
  */
 export function OpenAPISchemas(props) {
-    var className = props.className, data = props.data, context = props.context, grouped = props.grouped;
-    var schemas = data.schemas;
-    var clientContext = {
-        defaultInteractiveOpened: context.defaultInteractiveOpened,
-        icons: context.icons,
-        blockKey: context.blockKey,
-    };
-    if (!schemas.length) {
+    var schemas = props.schemas, contextInput = props.context, grouped = props.grouped, className = props.className;
+    var firstSchema = schemas[0];
+    if (!firstSchema) {
         return null;
     }
-    return (<div className={clsx('openapi-schemas', className)}>
-            <OpenAPIRootSchemasSchema grouped={grouped} schemas={schemas} context={clientContext}/>
-        </div>);
-}
-/**
- * Root schema for OpenAPI schemas.
- * It displays a single model or a disclosure group for multiple schemas.
- */
-function OpenAPIRootSchemasSchema(props) {
-    var _a;
-    var schemas = props.schemas, context = props.context, grouped = props.grouped;
+    var context = resolveOpenAPIContext(contextInput);
+    var clientContext = getOpenAPIClientContext(context);
     // If there is only one model and we are not grouping, we show it directly.
     if (schemas.length === 1 && !grouped) {
-        var schema = (_a = schemas === null || schemas === void 0 ? void 0 : schemas[0]) === null || _a === void 0 ? void 0 : _a.schema;
-        if (!schema) {
-            return null;
-        }
-        return (<Section>
-                <SectionBody>
-                    <OpenAPIRootSchema schema={schema} context={context}/>
-                </SectionBody>
-            </Section>);
+        var title = "The ".concat(firstSchema.name, " object");
+        return (<div className={clsx('openapi-schemas', className)}>
+                <div className="openapi-summary" id={context.id}>
+                    {context.renderHeading({
+                title: title,
+                deprecated: Boolean(firstSchema.schema.deprecated),
+                stability: firstSchema.schema['x-stability'],
+            })}
+                </div>
+                <div className="openapi-columns">
+                    <div className="openapi-column-spec">
+                        <StaticSection className="openapi-parameters" header={t(context.translation, 'attributes')}>
+                            <OpenAPIRootSchema schema={firstSchema.schema} context={clientContext}/>
+                        </StaticSection>
+                    </div>
+                    <div className="openapi-column-preview">
+                        <div className="openapi-column-preview-body">
+                            <div className="openapi-panel">
+                                <h4 className="openapi-panel-heading">{title}</h4>
+                                <div className="openapi-panel-body">
+                                    <OpenAPIExample example={getExampleFromSchema({
+                schema: firstSchema.schema,
+            })} context={context} syntax="json"/>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>);
     }
     // If there are multiple schemas, we use a disclosure group to show them all.
-    return (<OpenAPIDisclosureGroup allowsMultipleExpanded icon={context.icons.chevronRight} groups={schemas.map(function (_a) {
+    return (<div className={clsx('openapi-schemas', className)}>
+            {schemas.map(function (_a) {
             var name = _a.name, schema = _a.schema;
-            return ({
-                id: name,
-                label: (<div className="openapi-response-tab-content" key={"model-".concat(name)}>
-                        <span className="openapi-response-statuscode">{name}</span>
-                    </div>),
-                tabs: [
-                    {
-                        id: 'model',
-                        body: (<Section className="openapi-section-schemas">
-                                <SectionBody>
-                                    <OpenAPIRootSchema schema={schema} context={context}/>
-                                </SectionBody>
-                            </Section>),
-                    },
-                ],
-            });
-        })}/>);
+            return (<OpenAPIDisclosure className="openapi-schemas-disclosure" key={name} icon={context.icons.chevronRight} label={name}>
+                        <Section className="openapi-section-schemas">
+                            <SectionBody>
+                                <OpenAPIRootSchema schema={schema} context={clientContext}/>
+                            </SectionBody>
+                        </Section>
+                    </OpenAPIDisclosure>);
+        })}
+        </div>);
 }

package/dist/schemas/resolveOpenAPISchemas.d.ts

@@ -1,9 +1,10 @@
-import type { Filesystem, OpenAPIV3xDocument } from '@gitbook/openapi-parser';
-import type { OpenAPISchemasData } from '../types';
+import type { Filesystem, OpenAPISchema, OpenAPIV3xDocument } from '@gitbook/openapi-parser';
 /**
  * Resolve an OpenAPI schemas from a file and compile it to a more usable format.
  * Schemas are extracted from the OpenAPI components.schemas
  */
 export declare function resolveOpenAPISchemas(filesystem: Filesystem<OpenAPIV3xDocument>, options: {
     schemas: string[];
-}): Promise<OpenAPISchemasData | null>;
+}): Promise<{
+    schemas: OpenAPISchema[];
+} | null>;

package/dist/schemas/resolveOpenAPISchemas.js

@@ -36,7 +36,6 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 import { filterSelectedOpenAPISchemas } from '@gitbook/openapi-parser';
 import { dereferenceFilesystem } from '../dereference';
-//!!TODO: We should return only the schemas that are used in the block. Still a WIP awaiting future work.
 /**
  * Resolve an OpenAPI schemas from a file and compile it to a more usable format.
  * Schemas are extracted from the OpenAPI components.schemas

package/dist/stringifyOpenAPI.d.ts

@@ -1,4 +1,4 @@
 /**
  * Stringify an OpenAPI object. Same API as JSON.stringify.
  */
-export declare function stringifyOpenAPI(body: unknown, _?: null, indent?: number): string;
+export declare function stringifyOpenAPI(value: any, replacer?: ((this: any, key: string, value: any) => any) | null, space?: string | number): string;

package/dist/stringifyOpenAPI.js

@@ -1,12 +1,15 @@
 /**
  * Stringify an OpenAPI object. Same API as JSON.stringify.
  */
-export function stringifyOpenAPI(body, _, indent) {
-    return JSON.stringify(body, function (key, value) {
+export function stringifyOpenAPI(value, replacer, space) {
+    return JSON.stringify(value, function (key, value) {
         // Ignore internal keys
         if (key.startsWith('x-gitbook-')) {
             return undefined;
         }
+        if (replacer) {
+            return replacer(key, value);
+        }
         return value;
-    }, indent);
+    }, space);
 }

package/dist/translate.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { Translation, TranslationKey } from './translations';
+/**
+ * Translate a string.
+ */
+export declare function t(translation: Translation, id: TranslationKey, ...args: React.ReactNode[]): React.ReactNode;
+/**
+ * Version of `t` that returns a string.
+ */
+export declare function tString(translation: Translation, id: TranslationKey, ...args: React.ReactNode[]): string;

package/dist/translate.jsx

@@ -0,0 +1,75 @@
+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 React from 'react';
+/**
+ * Translate a string.
+ */
+export function t(translation, id) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    var string = translation[id];
+    if (!string) {
+        throw new Error("Translation not found for \"".concat(id, "\""));
+    }
+    // Now we are going to replace the arguments
+    // but we want to return a string as long as it's possible
+    // (eg. if there isn't any argument that is a ReactNode)
+    var parts = [];
+    var currentStringToReplace = string;
+    args.forEach(function (arg, i) {
+        if (typeof arg === 'string') {
+            currentStringToReplace = currentStringToReplace.replace("${".concat(i + 1, "}"), arg);
+        }
+        else {
+            var _a = currentStringToReplace.split("${".concat(i + 1, "}")), partToPush = _a[0], partToReplace = _a[1];
+            if (partToPush === undefined || partToReplace === undefined) {
+                throw new Error("Invalid translation \"".concat(id, "\""));
+            }
+            parts.push(<React.Fragment key={"string-".concat(i)}>{partToPush}</React.Fragment>);
+            parts.push(<React.Fragment key={"arg-".concat(i)}>{arg}</React.Fragment>);
+            currentStringToReplace = partToReplace;
+        }
+    });
+    if (!parts.length) {
+        return currentStringToReplace;
+    }
+    return (<>
+            {parts}
+            {currentStringToReplace}
+        </>);
+}
+/**
+ * Version of `t` that returns a string.
+ */
+export function tString(translation, id) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    var result = t.apply(void 0, __spreadArray([translation, id], args, false));
+    return reactToString(result);
+}
+function reactToString(el) {
+    if (typeof el === 'string' || typeof el === 'number' || typeof el === 'boolean') {
+        return "".concat(el);
+    }
+    if (el === null || el === undefined) {
+        return '';
+    }
+    if (Array.isArray(el)) {
+        return el.map(reactToString).join('');
+    }
+    if (typeof el === 'object' && 'props' in el) {
+        return el.props.children.map(reactToString).join('');
+    }
+    throw new Error("Unsupported type ".concat(typeof el));
+}

package/dist/translations/de.d.ts

@@ -0,0 +1,37 @@
+export declare const de: {
+    required: string;
+    deprecated: string;
+    deprecated_and_sunset_on: string;
+    stability_experimental: string;
+    stability_alpha: string;
+    stability_beta: string;
+    copy_to_clipboard: string;
+    copied: string;
+    no_content: string;
+    unresolved_reference: string;
+    circular_reference: string;
+    read_only: string;
+    write_only: string;
+    optional: string;
+    min: string;
+    max: string;
+    nullable: string;
+    body: string;
+    payload: string;
+    headers: string;
+    authorizations: string;
+    responses: string;
+    path_parameters: string;
+    query_parameters: string;
+    header_parameters: string;
+    attributes: string;
+    test_it: string;
+    information: string;
+    success: string;
+    redirect: string;
+    error: string;
+    show: string;
+    hide: string;
+    available_items: string;
+    child_attributes: string;
+};

package/dist/translations/de.js

@@ -0,0 +1,37 @@
+export var de = {
+    required: 'Erforderlich',
+    deprecated: 'Veraltet',
+    deprecated_and_sunset_on: 'Diese Operation ist veraltet und wird am ${1} eingestellt.',
+    stability_experimental: 'Experimentell',
+    stability_alpha: 'Alpha',
+    stability_beta: 'Beta',
+    copy_to_clipboard: 'In die Zwischenablage kopieren',
+    copied: 'Kopiert',
+    no_content: 'Kein Inhalt',
+    unresolved_reference: 'Nicht aufgelöste Referenz',
+    circular_reference: 'Zirkuläre Referenz',
+    read_only: 'Nur lesen',
+    write_only: 'Nur schreiben',
+    optional: 'Optional',
+    min: 'Min',
+    max: 'Max',
+    nullable: 'Nullfähig',
+    body: 'Rumpf',
+    payload: 'Nutzlast',
+    headers: 'Kopfzeilen',
+    authorizations: 'Autorisierungen',
+    responses: 'Antworten',
+    path_parameters: 'Pfadparameter',
+    query_parameters: 'Abfrageparameter',
+    header_parameters: 'Header-Parameter',
+    attributes: 'Attribute',
+    test_it: 'Teste es',
+    information: 'Information',
+    success: 'Erfolg',
+    redirect: 'Umleitung',
+    error: 'Fehler',
+    show: 'Anzeigen',
+    hide: 'Verstecken',
+    available_items: 'Verfügbare Elemente',
+    child_attributes: 'Unterattribute',
+};