@gitbook/react-openapi 0.4.0 → 0.5.0

package/dist/OpenAPISchema.js

@@ -0,0 +1,232 @@
+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) }, (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

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

package/dist/OpenAPISchema.test.js

@@ -0,0 +1,91 @@
+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.d.ts

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

package/dist/OpenAPISecurities.js

@@ -0,0 +1,42 @@
+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;
+    }
+}

package/dist/OpenAPIServerURL.d.ts

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

package/dist/OpenAPIServerURL.js

@@ -0,0 +1,51 @@
+import * as React from 'react';
+import { OpenAPIServerURLVariable } from './OpenAPIServerURLVariable';
+/**
+ * Show the url of the server with variables replaced by their default values.
+ */
+export function OpenAPIServerURL(props) {
+    const { servers } = props;
+    const server = servers[0];
+    const parts = parseServerURL(server?.url ?? '');
+    return (React.createElement("span", null, parts.map((part, i) => {
+        if (part.kind === 'text') {
+            return React.createElement("span", { key: i }, part.text);
+        }
+        else {
+            if (!server.variables?.[part.name]) {
+                return React.createElement("span", { key: i }, `{${part.name}}`);
+            }
+            return (React.createElement(OpenAPIServerURLVariable, { key: i, name: part.name, variable: server.variables[part.name] }));
+        }
+    })));
+}
+/**
+ * Get the default URL for the server.
+ */
+export function getServersURL(servers) {
+    const server = servers[0];
+    const parts = parseServerURL(server?.url ?? '');
+    return parts
+        .map((part) => {
+        if (part.kind === 'text') {
+            return part.text;
+        }
+        else {
+            return server.variables?.[part.name]?.default ?? `{${part.name}}`;
+        }
+    })
+        .join('');
+}
+function parseServerURL(url) {
+    const parts = url.split(/{([^}]+)}/g);
+    const result = [];
+    for (let i = 0; i < parts.length; i++) {
+        if (i % 2 === 0) {
+            result.push({ kind: 'text', text: parts[i] });
+        }
+        else {
+            result.push({ kind: 'variable', name: parts[i] });
+        }
+    }
+    return result;
+}

package/dist/OpenAPIServerURLVariable.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+import { OpenAPIV3 } from 'openapi-types';
+/**
+ * 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;

package/dist/OpenAPIServerURLVariable.js

@@ -0,0 +1,10 @@
+'use client';
+import * as React from 'react';
+import classNames from 'classnames';
+/**
+ * Interactive component to show the value of a server variable and let the user change it.
+ */
+export function OpenAPIServerURLVariable(props) {
+    const { variable } = props;
+    return React.createElement("span", { className: classNames('openapi-url-var') }, variable.default);
+}

package/dist/OpenAPISpec.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import { OpenAPIClientContext } from './types';
+/**
+ * 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 declare function OpenAPISpec(props: {
+    rawData: any;
+    context: OpenAPIClientContext;
+}): React.JSX.Element;

package/dist/OpenAPISpec.js

@@ -0,0 +1,70 @@
+'use client';
+import * as React from 'react';
+import { fromJSON } from './fetchOpenAPIOperation';
+import { InteractiveSection } from './InteractiveSection';
+import { OpenAPIRequestBody } from './OpenAPIRequestBody';
+import { OpenAPIResponses } from './OpenAPIResponses';
+import { OpenAPISchemaProperties } from './OpenAPISchema';
+import { OpenAPISecurities } from './OpenAPISecurities';
+import { noReference } 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) {
+    const { rawData, context } = props;
+    const parsedData = fromJSON(rawData);
+    const { operation, securities } = parsedData;
+    const parameterGroups = groupParameters((operation.parameters || []).map(noReference));
+    return (React.createElement(React.Fragment, null,
+        securities.length > 0 ? (React.createElement(OpenAPISecurities, { securities: securities, context: context })) : null,
+        parameterGroups.map((group) => (React.createElement(InteractiveSection, { key: group.key, className: "openapi-parameters", toggeable: true, toggleOpenIcon: context.icons.chevronRight, toggleCloseIcon: context.icons.chevronDown, header: group.label, defaultOpened: group.key === 'path' || context.defaultInteractiveOpened },
+            React.createElement(OpenAPISchemaProperties, { properties: group.parameters.map((parameter) => ({
+                    propertyName: parameter.name,
+                    schema: {
+                        // Description of the parameter is defined at the parameter level
+                        // we use display it if the schema doesn't override it
+                        description: parameter.description,
+                        example: parameter.example,
+                        ...(noReference(parameter.schema) ?? {}),
+                    },
+                    required: parameter.required,
+                })), context: context })))),
+        operation.requestBody ? (React.createElement(OpenAPIRequestBody, { requestBody: noReference(operation.requestBody), context: context })) : null,
+        operation.responses ? (React.createElement(OpenAPIResponses, { responses: noReference(operation.responses), context: context })) : null));
+}
+function groupParameters(parameters) {
+    const sorted = ['path', 'query', 'header'];
+    const groups = [];
+    parameters.forEach((parameter) => {
+        const key = parameter.in;
+        const label = getParameterGroupName(parameter.in);
+        const group = groups.find((group) => group.key === key);
+        if (group) {
+            group.parameters.push(parameter);
+        }
+        else {
+            groups.push({
+                key,
+                label,
+                parameters: [parameter],
+            });
+        }
+    });
+    groups.sort((a, b) => 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/ScalarApiButton.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { OpenAPIOperationData } from './fetchOpenAPIOperation';
+/**
+ * Button which launches the Scalar API Client
+ */
+export declare function ScalarApiButton(props: {
+    fetchOperationData: () => Promise<OpenAPIOperationData>;
+}): React.JSX.Element;
+/**
+ * Wrap the rendering with a context to open the scalar modal.
+ */
+export declare function ScalarApiClient(props: {
+    children: React.ReactNode;
+}): React.JSX.Element;

package/dist/ScalarApiButton.js

@@ -0,0 +1,89 @@
+'use client';
+import { getHarRequest, getParametersFromOperation, getRequestFromOperation, } from '@scalar/oas-utils';
+import React from 'react';
+import { fromJSON } from './fetchOpenAPIOperation';
+const ApiClientReact = React.lazy(async () => {
+    const mod = await import('@scalar/api-client-react');
+    return { default: mod.ApiClientReact };
+});
+const ScalarContext = React.createContext(() => { });
+/**
+ * Button which launches the Scalar API Client
+ */
+export function ScalarApiButton(props) {
+    const { fetchOperationData } = props;
+    const open = React.useContext(ScalarContext);
+    return (React.createElement("div", { className: "scalar scalar-activate" },
+        React.createElement("button", { className: "scalar-activate-button", onClick: () => {
+                open(fetchOperationData);
+            } },
+            React.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", width: "10", height: "12", fill: "none" },
+                React.createElement("path", { stroke: "currentColor", strokeWidth: "1.5", d: "M1 10.05V1.43c0-.2.2-.31.37-.22l7.26 4.08c.17.1.17.33.01.43l-7.26 4.54a.25.25 0 0 1-.38-.21Z" })),
+            "Test it")));
+}
+/**
+ * Wrap the rendering with a context to open the scalar modal.
+ */
+export function ScalarApiClient(props) {
+    const { children } = props;
+    const [active, setActive] = React.useState(null);
+    const proxy = '/~scalar/proxy';
+    const open = React.useCallback(async (fetchOperationData) => {
+        setActive({ operationData: null });
+        const operationData = fromJSON(await fetchOperationData());
+        setActive({ operationData });
+    }, []);
+    const onClose = React.useCallback(() => {
+        setActive(null);
+    }, []);
+    const request = React.useMemo(() => {
+        const operationData = active?.operationData;
+        if (!operationData) {
+            return null;
+        }
+        const operationId = operationData.operation.operationId ?? operationData.method + operationData.path;
+        const operation = {
+            ...operationData,
+            httpVerb: operationData.method,
+            pathParameters: operationData.operation.parameters,
+        };
+        const variables = getParametersFromOperation(operation, 'path', false);
+        const request = getHarRequest({
+            url: operationData.path,
+        }, getRequestFromOperation({
+            ...operation,
+            information: {
+                requestBody: operationData.operation.requestBody,
+            },
+        }, { requiredOnly: false }));
+        return {
+            id: operationId,
+            type: operationData.method,
+            path: operationData.path,
+            variables,
+            cookies: request.cookies.map((cookie) => {
+                return { ...cookie, enabled: true };
+            }),
+            query: request.queryString.map((queryString) => {
+                const query = queryString;
+                return { ...queryString, enabled: query.required ?? true };
+            }),
+            headers: request.headers.map((header) => {
+                return { ...header, enabled: true };
+            }),
+            url: operationData.servers[0]?.url,
+            body: request.postData?.text,
+        };
+    }, [active]);
+    return (React.createElement(ScalarContext.Provider, { value: open },
+        children,
+        active ? (React.createElement("div", { className: "scalar" },
+            React.createElement("div", { className: "scalar-container" },
+                React.createElement("div", { className: "scalar-app" },
+                    React.createElement(React.Suspense, { fallback: React.createElement(ScalarLoading, null) },
+                        React.createElement(ApiClientReact, { close: onClose, proxy: proxy, isOpen: true, request: request }))),
+                React.createElement("div", { onClick: () => onClose(), className: "scalar-app-exit" })))) : null));
+}
+function ScalarLoading() {
+    return React.createElement("div", { className: "scalar-app-loading" }, "Loading...");
+}

package/dist/code-samples.d.ts

@@ -0,0 +1,14 @@
+export interface CodeSampleInput {
+    method: string;
+    url: string;
+    headers?: Record<string, string>;
+    body?: any;
+}
+interface CodeSampleGenerator {
+    id: string;
+    label: string;
+    syntax: string;
+    generate: (operation: CodeSampleInput) => string;
+}
+export declare const codeSampleGenerators: CodeSampleGenerator[];
+export {};