fumadocs-openapi 6.0.1 → 6.0.3

package/dist/server/index.js

@@ -1,1493 +1,2 @@
-import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
-import Slugger from 'github-slugger';
-import { Fragment as Fragment$1 } from 'react';
-import { sample } from 'openapi-sampler';
-import { js2xml } from 'xml-js';
-import { compile } from '@fumari/json-schema-to-typescript';
-import { remarkGfm, remarkImage, rehypeCode } from 'fumadocs-core/mdx-plugins';
-import defaultMdxComponents from 'fumadocs-ui/mdx';
-import { remark } from 'remark';
-import remarkRehype from 'remark-rehype';
-import { toJsxRuntime } from 'hast-util-to-jsx-runtime';
-import { Heading } from 'fumadocs-ui/components/heading';
-import { Tabs, Tab } from 'fumadocs-ui/components/tabs';
-import { Accordions, Accordion } from 'fumadocs-ui/components/accordion';
-import * as Base from 'fumadocs-ui/components/codeblock';
-import { highlight } from 'fumadocs-core/server';
-import { APIPlayground, Root, API, APIInfo, APIExample as APIExample$1, Property, ObjectCollapsible } from '../ui/index.js';
-import { load, upgrade, dereference } from '@scalar/openapi-parser';
-import { fetchUrls } from '@scalar/openapi-parser/plugins/fetch-urls';
-import { readFiles } from '@scalar/openapi-parser/plugins/read-files';
-import { cva } from 'class-variance-authority';
-
-function getPreferredType(body) {
-    if ('application/json' in body) return 'application/json';
-    return Object.keys(body)[0];
-}
-function isNullable(schema, includeOneOf = true) {
-    if (Array.isArray(schema.type) && schema.type.includes('null')) return true;
-    if (includeOneOf && (schema.anyOf || schema.oneOf)) {
-        if (schema.anyOf?.some((item)=>isNullable(item))) return true;
-        if (schema.oneOf?.some((item)=>isNullable(item))) return true;
-    }
-    return false;
-}
-
-function getSecurities(requirement, document) {
-    const results = [];
-    const schemas = document.components?.securitySchemes ?? {};
-    for (const [key, scopes] of Object.entries(requirement)){
-        if (!(key in schemas)) return [];
-        const schema = schemas[key];
-        results.push({
-            ...schema,
-            scopes
-        });
-    }
-    return results;
-}
-function getSecurityPrefix(security) {
-    if (security.type === 'http') return ({
-        basic: 'Basic',
-        bearer: 'Bearer'
-    })[security.scheme];
-    if (security.type === 'oauth2') return 'Bearer';
-}
-
-function generateSample(path, method, { baseUrl, schema: { document } }) {
-    const params = [];
-    const responses = {};
-    for (const param of method.parameters ?? []){
-        if (param.schema) {
-            params.push({
-                name: param.name,
-                in: param.in,
-                schema: param.schema,
-                sample: param.example ?? sample(param.schema)
-            });
-        } else if (param.content) {
-            const key = getPreferredType(param.content);
-            const content = key ? param.content[key] : undefined;
-            if (!key || !content) throw new Error(`Cannot find parameter schema for ${param.name} in ${path} ${method.method}`);
-            params.push({
-                name: param.name,
-                in: param.in,
-                schema: content.schema ?? {},
-                sample: content.example ?? param.example ?? sample(content.schema)
-            });
-        }
-    }
-    const requirements = method.security ?? document.security;
-    if (requirements && requirements.length > 0) {
-        for (const security of getSecurities(requirements[0], document)){
-            const prefix = getSecurityPrefix(security);
-            params.push({
-                name: security.type === 'apiKey' ? security.name : 'Authorization',
-                schema: {
-                    type: 'string'
-                },
-                sample: prefix ? `${prefix} <token>` : '<token>',
-                in: 'header'
-            });
-        }
-    }
-    let bodyOutput;
-    if (method.requestBody) {
-        const body = method.requestBody.content;
-        const type = getPreferredType(body);
-        if (!type) throw new Error(`Cannot find body schema for ${path} ${method.method}: missing media type`);
-        const schema = (type ? body[type].schema : undefined) ?? {};
-        bodyOutput = {
-            schema,
-            mediaType: type,
-            sample: body[type].example ?? generateBody(method.method, schema)
-        };
-    }
-    for (const [code, response] of Object.entries(method.responses ?? {})){
-        const content = response.content;
-        if (!content) continue;
-        const mediaType = getPreferredType(content);
-        if (!mediaType) continue;
-        const responseSchema = content[mediaType].schema;
-        if (!responseSchema) continue;
-        responses[code] = {
-            mediaType,
-            sample: content[mediaType].example ?? generateBody(method.method, responseSchema),
-            schema: responseSchema
-        };
-    }
-    let pathWithParameters = path;
-    const queryParams = new URLSearchParams();
-    for (const param of params){
-        const value = generateBody(method.method, param.schema);
-        if (param.in === 'query') queryParams.append(param.name, String(value));
-        if (param.in === 'path') pathWithParameters = pathWithParameters.replace(`{${param.name}}`, String(value));
-    }
-    if (queryParams.size > 0) pathWithParameters = `${pathWithParameters}?${queryParams.toString()}`;
-    return {
-        url: new URL(`${baseUrl}${pathWithParameters}`).toString(),
-        body: bodyOutput,
-        responses,
-        method: method.method,
-        parameters: params
-    };
-}
-function generateBody(method, schema) {
-    return sample(schema, {
-        skipReadOnly: method !== 'GET',
-        skipWriteOnly: method === 'GET'
-    });
-}
-
-/**
- * Convert input value to hardcoded string (with quotes)
- */ function inputToString(value, mediaType = 'application/json', multiLine = 'none') {
-    const getStr = (v)=>{
-        if (multiLine === 'none') return JSON.stringify(v);
-        const delimit = multiLine === 'backtick' ? `\`` : `'`;
-        return `${delimit}${v.replaceAll(delimit, `\\${delimit}`)}${delimit}`;
-    };
-    if (typeof value === 'string') return getStr(value);
-    if (mediaType === 'application/json' || mediaType === 'multipart/form-data') {
-        return getStr(JSON.stringify(value, null, 2));
-    }
-    if (mediaType === 'application/xml') {
-        return getStr(js2xml(value, {
-            compact: true,
-            spaces: 2
-        }));
-    }
-    throw new Error(`Unsupported media type: ${mediaType}`);
-}
-
-function getSampleRequest$3(endpoint) {
-    const s = [];
-    s.push(`curl -X ${endpoint.method} "${endpoint.url}"`);
-    for (const param of endpoint.parameters){
-        if (param.in === 'header') {
-            const header = `${param.name}: ${param.sample}`;
-            s.push(`-H "${header}"`);
-        }
-        if (param.in === 'cookie') {
-            const cookie = JSON.stringify(`${param.name}=${param.sample}`);
-            s.push(`--cookie ${cookie}`);
-        }
-    }
-    if (endpoint.body?.mediaType === 'multipart/form-data') {
-        const sample = endpoint.body.sample;
-        if (sample && typeof sample === 'object') {
-            for (const [key, value] of Object.entries(sample)){
-                s.push(`-F ${key}=${inputToString(value)}`);
-            }
-        }
-    } else if (endpoint.body) {
-        s.push(`-H "Content-Type: ${endpoint.body.mediaType}"`);
-        s.push(`-d ${inputToString(endpoint.body.sample, endpoint.body.mediaType, 'single-quote')}`);
-    }
-    return s.flatMap((v, i)=>v.split('\n').map((line)=>i > 0 ? `  ${line}` : line).join('\n')).join(' \\\n');
-}
-
-function getSampleRequest$2(endpoint) {
-    const s = [];
-    const options = new Map();
-    const headers = new Map();
-    const cookies = new Map();
-    for (const param of endpoint.parameters){
-        if (param.in === 'header') {
-            headers.set(param.name, param.sample);
-        }
-        if (param.in === 'cookie') {
-            cookies.set(param.name, param.sample);
-        }
-    }
-    if (cookies.size > 0) {
-        headers.set('cookie', Array.from(cookies.entries()).map(([key, value])=>`${key}=${value}`).join('; '));
-    }
-    if (headers.size > 0) {
-        options.set('headers', JSON.stringify(Object.fromEntries(headers.entries()), null, 2).replaceAll('\n', '\n  '));
-    }
-    if (endpoint.body?.mediaType === 'multipart/form-data' && typeof endpoint.body.sample === 'object' && endpoint.body.sample) {
-        s.push(`const formData = new FormData();`);
-        for (const [key, value] of Object.entries(endpoint.body.sample))s.push(`formData.set(${key}, ${inputToString(value)})`);
-        options.set('body', 'formData');
-    } else if (endpoint.body) {
-        let code;
-        if (endpoint.body.mediaType === 'application/json') {
-            code = typeof endpoint.body.sample === 'string' ? inputToString(endpoint.body.sample, endpoint.body.mediaType, 'backtick') : `JSON.stringify(${JSON.stringify(endpoint.body.sample, null, 2)})`;
-        } else {
-            code = inputToString(endpoint.body.sample, endpoint.body.mediaType, 'backtick');
-        }
-        options.set('body', code.replaceAll('\n', '\n  '));
-    }
-    const optionsStr = Array.from(options.entries()).map(([k, v])=>`  ${k}: ${v}`).join(',\n');
-    s.push(`fetch(${JSON.stringify(endpoint.url)}, {\n${optionsStr}\n});`);
-    return s.join('\n\n');
-}
-
-function getSampleRequest$1(endpoint) {
-    const imports = [
-        'fmt',
-        'net/http',
-        'io/ioutil'
-    ];
-    const headers = new Map();
-    const variables = new Map();
-    // additional lines before initializing request
-    const additional = [];
-    for (const p of endpoint.parameters){
-        if (p.in === 'header') headers.set(p.name, JSON.stringify(p.sample));
-    }
-    const cookies = endpoint.parameters.filter((p)=>p.in === 'cookie');
-    variables.set('url', JSON.stringify(endpoint.url));
-    if (cookies.length > 0) headers.set('Cookie', JSON.stringify(cookies.map((p)=>`${p.name}=${p.sample}`).join('; ')));
-    if (endpoint.body) {
-        headers.set('Content-Type', `"${endpoint.body.mediaType}"`);
-        if (endpoint.body.mediaType === 'multipart/form-data' && typeof endpoint.body.sample === 'object') {
-            imports.push('mime/multipart', 'bytes');
-            variables.set('payload', `new(bytes.Buffer)`);
-            variables.set('mp', 'multipart.NewWriter(payload)');
-            for (const [key, value] of Object.entries(endpoint.body.sample ?? {})){
-                additional.push(`mp.WriteField("${key}", ${inputToString(value, undefined, 'backtick')})`);
-            }
-        } else {
-            imports.push('strings');
-            variables.set('payload', `strings.NewReader(${inputToString(endpoint.body.sample, endpoint.body.mediaType, 'backtick').replaceAll('\n', '\n  ')})`);
-        }
-    }
-    return `package main
-
-import (
-${imports.map((v)=>`  "${v}"`).join('\n')}
-)
-
-func main() {
-${Array.from(variables.entries()).map(([k, v])=>`  ${k} := ${v}`).join('\n')}
-  ${additional.join('\n  ')}
-  req, _ := http.NewRequest("${endpoint.method}", url, ${variables.has('payload') ? 'payload' : 'nil'})
-  ${Array.from(headers.entries()).map(([key, value])=>`req.Header.Add("${key}", ${value})`).join('\n  ')}
-  res, _ := http.DefaultClient.Do(req)
-  defer res.Body.Close()
-  body, _ := ioutil.ReadAll(res.Body)
-
-  fmt.Println(res)
-  fmt.Println(string(body))
-}`;
-}
-
-function getSampleRequest(endpoint) {
-    const headers = new Map();
-    const cookies = new Map();
-    const variables = new Map();
-    for (const param of endpoint.parameters){
-        if (param.in === 'header') headers.set(param.name, param.sample);
-        if (param.in === 'cookie') cookies.set(param.name, param.sample);
-    }
-    if (endpoint.body) {
-        switch(endpoint.body.mediaType){
-            case 'application/json':
-                variables.set('json', JSON.stringify(endpoint.body.sample, null, 2));
-                break;
-            case 'multipart/form-data':
-                headers.set('Content-Type', endpoint.body.mediaType);
-                variables.set('data', JSON.stringify(endpoint.body.sample, null, 2));
-                break;
-            default:
-                headers.set('Content-Type', endpoint.body.mediaType);
-                variables.set('data', inputToString(endpoint.body.sample, endpoint.body.mediaType, 'backtick'));
-        }
-    }
-    if (headers.size > 0) {
-        variables.set('headers', JSON.stringify(Object.fromEntries(headers.entries()), null, 2));
-    }
-    if (cookies.size > 0) {
-        variables.set('cookies', JSON.stringify(Object.fromEntries(cookies.entries()), null, 2));
-    }
-    return `import requests
-
-url = ${JSON.stringify(endpoint.url)}
-${Array.from(variables.entries()).map(([k, v])=>`${k} = ${v}`).join('\n')}
-response = requests.request("${endpoint.method}", url${variables.size > 0 ? `, ${Array.from(variables.keys()).map((k)=>`${k}=${k}`).join(', ')}` : ''})
-
-print(response.text)`;
-}
-
-async function getTypescriptSchema(endpoint, code, dereferenceMap) {
-    if (code in endpoint.responses) {
-        return compile(// re-running on the same schema results in error
-        // because it uses `defineProperty` to define internal references
-        // we clone the schema to fix this problem
-        // @ts-expect-error any types
-        endpoint.responses[code].schema, 'Response', {
-            $refOptions: false,
-            schemaToId: dereferenceMap,
-            bannerComment: '',
-            additionalProperties: false,
-            format: true,
-            enableConstEnums: false
-        });
-    }
-}
-
-function idToTitle(id) {
-    let result = [];
-    for (const c of id){
-        if (result.length === 0) result.push(c.toLocaleUpperCase());
-        else if (c === '.') result = [];
-        else if (/^[A-Z]$/.test(c) && result.at(-1) !== ' ') result.push(' ', c);
-        else if (c === '-') result.push(' ');
-        else result.push(c);
-    }
-    return result.join('');
-}
-
-const processor = remark().use(remarkGfm).use(remarkImage, {
-    useImport: false
-}).use(remarkRehype).use(rehypeCode, {
-    langs: [],
-    lazy: true
-});
-async function Markdown({ text }) {
-    const nodes = processor.parse({
-        value: text
-    });
-    const hast = await processor.run(nodes);
-    return toJsxRuntime(hast, {
-        development: false,
-        jsx: jsx,
-        jsxs: jsxs,
-        Fragment,
-        components: defaultMdxComponents
-    });
-}
-
-function heading(depth, child, ctx) {
-    const id = ctx.slugger.slug(child);
-    return /*#__PURE__*/ jsx(Heading, {
-        id: id,
-        as: `h${depth.toString()}`,
-        children: child.trim()
-    }, id);
-}
-
-/**
- * Combine multiple object schemas into one
- */ function combineSchema(schema) {
-    const result = {
-        type: undefined
-    };
-    function add(s) {
-        if (s.type) {
-            var _result;
-            (_result = result).type ?? (_result.type = []);
-            if (!Array.isArray(result.type)) {
-                result.type = [
-                    result.type
-                ];
-            }
-            for (const v of Array.isArray(s.type) ? s.type : [
-                s.type
-            ]){
-                if (!result.type.includes(v)) {
-                    result.type.push(v);
-                }
-            }
-        }
-        if (s.properties) {
-            var _result1;
-            (_result1 = result).properties ?? (_result1.properties = {});
-            Object.assign(result.properties, s.properties);
-        }
-        if (s.additionalProperties === true) {
-            result.additionalProperties = true;
-        } else if (s.additionalProperties && typeof result.additionalProperties !== 'boolean') {
-            var _result2;
-            (_result2 = result).additionalProperties ?? (_result2.additionalProperties = {});
-            Object.assign(result.additionalProperties, s.additionalProperties);
-        }
-        if (s.required) {
-            var _result3;
-            (_result3 = result).required ?? (_result3.required = []);
-            result.required.push(...s.required);
-        }
-        if (s.enum && s.enum.length > 0) {
-            var _result4;
-            (_result4 = result).enum ?? (_result4.enum = []);
-            result.enum.push(...s.enum);
-        }
-        if (s.allOf) {
-            s.allOf.forEach(add);
-        }
-    }
-    schema.forEach(add);
-    return result;
-}
-
-const keys$1 = {
-    default: 'Default',
-    minimum: 'Minimum',
-    maximum: 'Maximum',
-    minLength: 'Minimum length',
-    maxLength: 'Maximum length',
-    pattern: 'Pattern',
-    format: 'Format'
-};
-function isObject(schema) {
-    return schema.type === 'object' || schema.properties !== undefined || schema.additionalProperties !== undefined;
-}
-function Schema({ name, schema, ctx }) {
-    if (schema.readOnly === true && !ctx.readOnly || schema.writeOnly === true && !ctx.writeOnly) return null;
-    const parseObject = ctx.parseObject ?? true;
-    const stack = ctx.stack ?? [];
-    const { renderer } = ctx.render;
-    // object type
-    if (isObject(schema) && parseObject && (schema.additionalProperties || schema.properties)) {
-        let body = null;
-        let footer = null;
-        const { additionalProperties, properties } = schema;
-        if (additionalProperties === true) {
-            footer = /*#__PURE__*/ jsx(renderer.Property, {
-                name: "[key: string]",
-                type: "any"
-            });
-        } else if (additionalProperties) {
-            footer = /*#__PURE__*/ jsx(Schema, {
-                name: "[key: string]",
-                schema: additionalProperties,
-                ctx: {
-                    ...ctx,
-                    required: false,
-                    parseObject: false
-                }
-            });
-        }
-        if (properties) {
-            body = Object.entries(properties).map(([key, value])=>{
-                return /*#__PURE__*/ jsx(Schema, {
-                    name: key,
-                    schema: value,
-                    ctx: {
-                        ...ctx,
-                        required: schema.required?.includes(key) ?? false,
-                        parseObject: false
-                    }
-                }, key);
-            });
-        }
-        return /*#__PURE__*/ jsxs("div", {
-            className: "flex flex-col gap-4",
-            children: [
-                body,
-                footer
-            ]
-        });
-    }
-    if (schema.allOf && parseObject) {
-        return /*#__PURE__*/ jsx(Schema, {
-            name: name,
-            schema: combineSchema(schema.allOf),
-            ctx: ctx
-        });
-    }
-    let footer = null;
-    const fields = [];
-    for (const [key, value] of Object.entries(keys$1)){
-        if (key in schema) {
-            fields.push({
-                key: value,
-                value: JSON.stringify(schema[key])
-            });
-        }
-    }
-    if (schema.enum) {
-        fields.push({
-            key: 'Value in',
-            value: schema.enum.map((value)=>JSON.stringify(value)).join(' | ')
-        });
-    }
-    if (isObject(schema) && !parseObject && !stack.includes(schema)) {
-        footer = /*#__PURE__*/ jsx(renderer.ObjectCollapsible, {
-            name: "Show Attributes",
-            children: /*#__PURE__*/ jsx(Schema, {
-                name: name,
-                schema: schema,
-                ctx: {
-                    ...ctx,
-                    parseObject: true,
-                    required: false,
-                    stack: [
-                        schema,
-                        ...stack
-                    ]
-                }
-            })
-        });
-    } else {
-        const mentionedObjectTypes = [
-            ...schema.anyOf ?? schema.oneOf ?? [],
-            ...schema.not ? [
-                schema.not
-            ] : [],
-            ...schema.type === 'array' ? [
-                schema.items
-            ] : []
-        ].filter((s)=>isComplexType(s) && !stack.includes(s));
-        footer = mentionedObjectTypes.map((s, idx)=>{
-            return /*#__PURE__*/ jsx(renderer.ObjectCollapsible, {
-                name: s.title ?? (mentionedObjectTypes.length === 1 ? 'Show Attributes' : `Object ${idx + 1}`),
-                children: /*#__PURE__*/ jsx(Schema, {
-                    name: "element",
-                    schema: s,
-                    ctx: {
-                        ...ctx,
-                        stack: [
-                            schema,
-                            ...stack
-                        ],
-                        parseObject: true,
-                        required: false
-                    }
-                })
-            }, idx);
-        });
-    }
-    return /*#__PURE__*/ jsxs(renderer.Property, {
-        name: name,
-        type: getSchemaType(schema, ctx),
-        required: ctx.required,
-        deprecated: schema.deprecated,
-        children: [
-            schema.description ? /*#__PURE__*/ jsx(Markdown, {
-                text: schema.description
-            }) : null,
-            fields.length > 0 ? /*#__PURE__*/ jsx("div", {
-                className: "flex flex-col gap-2",
-                children: fields.map((field)=>/*#__PURE__*/ jsxs("span", {
-                        children: [
-                            field.key,
-                            ": ",
-                            /*#__PURE__*/ jsx("code", {
-                                children: field.value
-                            })
-                        ]
-                    }, field.key))
-            }) : null,
-            footer
-        ]
-    });
-}
-/**
- * Check if the schema needs another collapsible to explain
- */ function isComplexType(schema) {
-    if (schema.anyOf ?? schema.oneOf ?? schema.allOf) return true;
-    return isObject(schema) || schema.type === 'array';
-}
-function getSchemaType(schema, ctx, isRoot = true) {
-    if (isNullable(schema) && isRoot) {
-        const type = getSchemaType(schema, ctx, false);
-        // null if schema only contains `nullable`
-        return type === 'unknown' ? 'null' : `${type} | null`;
-    }
-    if (schema.title) return schema.title;
-    if (schema.type === 'array') return `array<${getSchemaType(schema.items, ctx)}>`;
-    if (schema.oneOf) return schema.oneOf.map((one)=>getSchemaType(one, ctx, false)).filter((v)=>v !== 'unknown').join(' | ');
-    if (schema.allOf) {
-        return schema.allOf.map((one)=>getSchemaType(one, ctx, false)).filter((v)=>v !== 'unknown').join(' & ');
-    }
-    if (schema.not) return `not ${getSchemaType(schema.not, ctx, false)}`;
-    if (schema.anyOf) {
-        return `Any properties in ${schema.anyOf.map((one)=>getSchemaType(one, ctx, false)).filter((v)=>v !== 'unknown').join(', ')}`;
-    }
-    if (schema.type === 'string' && schema.format === 'binary' && ctx.allowFile) return 'file';
-    if (schema.type && Array.isArray(schema.type)) {
-        const nonNullTypes = schema.type.filter((v)=>v !== 'null');
-        if (nonNullTypes.length > 0) return nonNullTypes.join(' | ');
-    } else if (schema.type && schema.type !== 'null') {
-        return schema.type;
-    }
-    if (isObject(schema)) return 'object';
-    return 'unknown';
-}
-
-/**
- * Summarize method endpoint information
- */ function createMethod(method, path, operation) {
-    return {
-        description: path.description,
-        summary: path.summary,
-        ...operation,
-        parameters: [
-            ...operation.parameters ?? [],
-            ...path.parameters ?? []
-        ],
-        method: method.toUpperCase()
-    };
-}
-
-const methodKeys = [
-    'get',
-    'post',
-    'patch',
-    'delete',
-    'head',
-    'put'
-];
-
-function Operation({ type = 'operation', path, method, ctx, hasHead, headingLevel = 2 }) {
-    const body = method.requestBody;
-    const security = method.security ?? ctx.schema.document.security;
-    let headNode = null;
-    let bodyNode = null;
-    let responseNode = null;
-    let callbacksNode = null;
-    if (hasHead) {
-        const title = method.summary ?? (method.operationId ? idToTitle(method.operationId) : path);
-        headNode = /*#__PURE__*/ jsxs(Fragment, {
-            children: [
-                heading(headingLevel, title, ctx),
-                method.description ? /*#__PURE__*/ jsx(Markdown, {
-                    text: method.description
-                }, "description") : null
-            ]
-        });
-        headingLevel++;
-    }
-    if (body) {
-        const type = getPreferredType(body.content);
-        if (!type) throw new Error(`No supported media type for body content: ${path}`);
-        bodyNode = /*#__PURE__*/ jsxs(Fragment, {
-            children: [
-                heading(headingLevel, 'Request Body', ctx),
-                /*#__PURE__*/ jsxs("div", {
-                    className: "mb-8 flex flex-row items-center justify-between gap-2",
-                    children: [
-                        /*#__PURE__*/ jsx("code", {
-                            children: type
-                        }),
-                        /*#__PURE__*/ jsx("span", {
-                            children: body.required ? 'Required' : 'Optional'
-                        })
-                    ]
-                }),
-                body.description ? /*#__PURE__*/ jsx(Markdown, {
-                    text: body.description
-                }) : null,
-                /*#__PURE__*/ jsx(Schema, {
-                    name: "body",
-                    schema: body.content[type].schema ?? {},
-                    ctx: {
-                        readOnly: method.method === 'GET',
-                        writeOnly: method.method !== 'GET',
-                        required: body.required ?? false,
-                        render: ctx,
-                        allowFile: type === 'multipart/form-data'
-                    }
-                })
-            ]
-        });
-    }
-    if (method.responses && ctx.showResponseSchema) {
-        responseNode = /*#__PURE__*/ jsxs(Fragment, {
-            children: [
-                heading(headingLevel, 'Response Body', ctx),
-                Object.entries(method.responses).map(([status, response])=>{
-                    if (!response.content) return;
-                    const mediaType = getPreferredType(response.content);
-                    if (!mediaType) return null;
-                    const content = response.content[mediaType];
-                    if (!content.schema) return null;
-                    return /*#__PURE__*/ jsxs(Fragment$1, {
-                        children: [
-                            heading(headingLevel + 1, status, ctx),
-                            /*#__PURE__*/ jsx(Markdown, {
-                                text: response.description
-                            }),
-                            /*#__PURE__*/ jsx(Schema, {
-                                name: "response",
-                                schema: content.schema,
-                                ctx: {
-                                    render: ctx,
-                                    writeOnly: false,
-                                    readOnly: true,
-                                    required: true
-                                }
-                            })
-                        ]
-                    }, status);
-                })
-            ]
-        });
-    }
-    const parameterGroups = new Map();
-    const endpoint = generateSample(path, method, ctx);
-    for (const param of method.parameters ?? []){
-        const pInfo = endpoint.parameters.find((item)=>item.name === param.name && item.in === param.in);
-        if (!pInfo) continue;
-        const schema = pInfo.schema;
-        const groupName = {
-            path: 'Path Parameters',
-            query: 'Query Parameters',
-            header: 'Header Parameters',
-            cookie: 'Cookie Parameters'
-        }[param.in] ?? 'Other Parameters';
-        const group = parameterGroups.get(groupName) ?? [];
-        group.push(/*#__PURE__*/ jsx(Schema, {
-            name: param.name,
-            schema: {
-                ...schema,
-                description: param.description ?? schema.description,
-                deprecated: (param.deprecated ?? false) || (schema.deprecated ?? false)
-            },
-            ctx: {
-                parseObject: false,
-                readOnly: method.method === 'GET',
-                writeOnly: method.method !== 'GET',
-                required: param.required ?? false,
-                render: ctx
-            }
-        }, param.name));
-        parameterGroups.set(groupName, group);
-    }
-    if (method.callbacks) {
-        callbacksNode = /*#__PURE__*/ jsxs(Fragment, {
-            children: [
-                heading(headingLevel, 'Webhooks', ctx),
-                Object.entries(method.callbacks).map(([name, callback])=>/*#__PURE__*/ jsx(WebhookCallback, {
-                        callback: callback,
-                        ctx: ctx,
-                        headingLevel: headingLevel
-                    }, name))
-            ]
-        });
-    }
-    const info = /*#__PURE__*/ jsxs(ctx.renderer.APIInfo, {
-        head: headNode,
-        method: method.method,
-        route: path,
-        children: [
-            type === 'operation' ? /*#__PURE__*/ jsx(ctx.renderer.APIPlayground, {
-                path: path,
-                method: method,
-                ctx: ctx
-            }) : null,
-            security ? /*#__PURE__*/ jsxs(Fragment, {
-                children: [
-                    heading(headingLevel, 'Authorization', ctx),
-                    /*#__PURE__*/ jsx(AuthSection, {
-                        requirements: security,
-                        ctx: ctx
-                    })
-                ]
-            }) : null,
-            bodyNode,
-            Array.from(parameterGroups.entries()).map(([group, params])=>{
-                return /*#__PURE__*/ jsxs(Fragment$1, {
-                    children: [
-                        heading(headingLevel, group, ctx),
-                        params
-                    ]
-                }, group);
-            }),
-            responseNode,
-            callbacksNode
-        ]
-    });
-    if (type === 'operation') {
-        return /*#__PURE__*/ jsxs(ctx.renderer.API, {
-            children: [
-                info,
-                /*#__PURE__*/ jsx(APIExample, {
-                    method: method,
-                    endpoint: endpoint,
-                    ctx: ctx
-                })
-            ]
-        });
-    } else {
-        return info;
-    }
-}
-const defaultSamples = [
-    {
-        label: 'cURL',
-        source: getSampleRequest$3,
-        lang: 'bash'
-    },
-    {
-        label: 'JavaScript',
-        source: getSampleRequest$2,
-        lang: 'js'
-    },
-    {
-        label: 'Go',
-        source: getSampleRequest$1,
-        lang: 'go'
-    },
-    {
-        label: 'Python',
-        source: getSampleRequest,
-        lang: 'python'
-    }
-];
-async function APIExample({ method, endpoint, ctx }) {
-    const renderer = ctx.renderer;
-    const children = [];
-    const samples = dedupe([
-        ...defaultSamples,
-        ...ctx.generateCodeSamples ? await ctx.generateCodeSamples(endpoint) : [],
-        ...method['x-codeSamples'] ?? []
-    ]).flatMap((sample)=>{
-        if (sample.source === false) return [];
-        const result = typeof sample.source === 'function' ? sample.source(endpoint) : sample.source;
-        if (result === undefined) return [];
-        return {
-            ...sample,
-            source: result
-        };
-    });
-    if (samples.length > 0) {
-        children.push(/*#__PURE__*/ jsx(renderer.Requests, {
-            items: samples.map((s)=>s.label),
-            children: samples.map((s)=>/*#__PURE__*/ jsx(renderer.Request, {
-                    name: s.label,
-                    code: s.source,
-                    language: s.lang
-                }, s.label))
-        }, "requests"));
-    }
-    children.push(/*#__PURE__*/ jsx(ResponseTabs, {
-        operation: method,
-        ctx: ctx,
-        endpoint: endpoint
-    }, "responses"));
-    return /*#__PURE__*/ jsx(renderer.APIExample, {
-        children: children
-    });
-}
-function WebhookCallback({ callback, ctx, headingLevel }) {
-    return Object.entries(callback).map(([path, pathItem])=>{
-        const pathNodes = methodKeys.map((method)=>{
-            const operation = pathItem[method];
-            if (!operation) return null;
-            return /*#__PURE__*/ jsx(Operation, {
-                type: "webhook",
-                hasHead: true,
-                path: path,
-                headingLevel: headingLevel + 1,
-                method: createMethod(method, pathItem, operation),
-                ctx: ctx
-            }, method);
-        });
-        return /*#__PURE__*/ jsx(Fragment$1, {
-            children: pathNodes
-        }, path);
-    });
-}
-/**
- * Remove duplicated labels
- */ function dedupe(samples) {
-    const set = new Set();
-    const out = [];
-    for(let i = samples.length - 1; i >= 0; i--){
-        if (set.has(samples[i].label)) continue;
-        set.add(samples[i].label);
-        out.unshift(samples[i]);
-    }
-    return out;
-}
-function AuthSection({ ctx: { schema: { document }, renderer }, requirements }) {
-    let id = 0;
-    const info = [];
-    for (const requirement of requirements){
-        for (const schema of getSecurities(requirement, document)){
-            const prefix = getSecurityPrefix(schema);
-            const scopeElement = schema.scopes.length > 0 ? /*#__PURE__*/ jsxs("p", {
-                children: [
-                    "Scope: ",
-                    /*#__PURE__*/ jsx("code", {
-                        children: schema.scopes.join(', ')
-                    })
-                ]
-            }) : null;
-            if (schema.type === 'http' || schema.type === 'oauth2') {
-                info.push(/*#__PURE__*/ jsxs(renderer.Property, {
-                    name: "Authorization",
-                    type: prefix ? `${prefix} <token>` : '<token>',
-                    required: true,
-                    children: [
-                        schema.description ? /*#__PURE__*/ jsx(Markdown, {
-                            text: schema.description
-                        }) : null,
-                        /*#__PURE__*/ jsxs("p", {
-                            children: [
-                                "In: ",
-                                /*#__PURE__*/ jsx("code", {
-                                    children: "header"
-                                })
-                            ]
-                        }),
-                        scopeElement
-                    ]
-                }, id++));
-            }
-            if (schema.type === 'apiKey') {
-                info.push(/*#__PURE__*/ jsxs(renderer.Property, {
-                    name: schema.name,
-                    type: "<token>",
-                    children: [
-                        schema.description ? /*#__PURE__*/ jsx(Markdown, {
-                            text: schema.description
-                        }) : null,
-                        /*#__PURE__*/ jsxs("p", {
-                            children: [
-                                "In: ",
-                                /*#__PURE__*/ jsx("code", {
-                                    children: schema.in
-                                }),
-                                scopeElement
-                            ]
-                        })
-                    ]
-                }, id++));
-            }
-            if (schema.type === 'openIdConnect') {
-                info.push(/*#__PURE__*/ jsxs(renderer.Property, {
-                    name: "OpenID Connect",
-                    type: "<token>",
-                    required: true,
-                    children: [
-                        schema.description ? /*#__PURE__*/ jsx(Markdown, {
-                            text: schema.description
-                        }) : null,
-                        scopeElement
-                    ]
-                }, id++));
-            }
-        }
-    }
-    return info;
-}
-async function ResponseTabs({ endpoint, operation, ctx: { renderer, generateTypeScriptSchema, schema } }) {
-    const items = [];
-    const children = [];
-    if (!operation.responses) return null;
-    for (const code of Object.keys(operation.responses)){
-        const types = [];
-        let description = operation.responses[code].description;
-        if (!description && code in endpoint.responses) description = endpoint.responses[code].schema.description ?? '';
-        if (code in endpoint.responses) {
-            types.push({
-                lang: 'json',
-                label: 'Response',
-                code: JSON.stringify(endpoint.responses[code].sample, null, 2)
-            });
-        }
-        let ts;
-        if (generateTypeScriptSchema) {
-            ts = await generateTypeScriptSchema(endpoint, code);
-        } else if (generateTypeScriptSchema === undefined) {
-            ts = await getTypescriptSchema(endpoint, code, schema.dereferenceMap);
-        }
-        if (ts) {
-            types.push({
-                code: ts,
-                lang: 'ts',
-                label: 'TypeScript'
-            });
-        }
-        items.push(code);
-        children.push(/*#__PURE__*/ jsxs(renderer.Response, {
-            value: code,
-            children: [
-                /*#__PURE__*/ jsx(Markdown, {
-                    text: description
-                }),
-                types.length > 0 ? /*#__PURE__*/ jsx(renderer.ResponseTypes, {
-                    children: types.map((type)=>/*#__PURE__*/ jsx(renderer.ResponseType, {
-                            ...type
-                        }, type.lang))
-                }) : null
-            ]
-        }, code));
-    }
-    if (items.length === 0) return null;
-    return /*#__PURE__*/ jsx(renderer.Responses, {
-        items: items,
-        children: children
-    });
-}
-
-async function CodeBlock({ code, lang, options, ...rest }) {
-    const rendered = await highlight(code, {
-        lang,
-        ...options,
-        components: {
-            pre: (props)=>/*#__PURE__*/ jsx(Base.Pre, {
-                    ...props,
-                    ...rest
-                })
-        }
-    });
-    return /*#__PURE__*/ jsx(Base.CodeBlock, {
-        className: "my-0",
-        children: rendered
-    });
-}
-
-function Playground({ path, method, ctx }) {
-    let currentId = 0;
-    const bodyContent = method.requestBody?.content;
-    const mediaType = bodyContent ? getPreferredType(bodyContent) : undefined;
-    const context = {
-        allowFile: mediaType === 'multipart/form-data',
-        references: {},
-        nextId () {
-            return String(currentId++);
-        },
-        registered: new WeakMap(),
-        render: ctx
-    };
-    const bodySchema = bodyContent && mediaType && bodyContent[mediaType].schema ? toSchema(bodyContent[mediaType].schema, true, context) : undefined;
-    const props = {
-        authorization: getAuthorizationField(method, ctx),
-        method: method.method,
-        route: path,
-        path: method.parameters?.filter((v)=>v.in === 'path').map((v)=>parameterToField(v, context)),
-        query: method.parameters?.filter((v)=>v.in === 'query').map((v)=>parameterToField(v, context)),
-        header: method.parameters?.filter((v)=>v.in === 'header').map((v)=>parameterToField(v, context)),
-        body: bodySchema && mediaType ? {
-            ...bodySchema,
-            mediaType: mediaType
-        } : undefined,
-        schemas: context.references,
-        proxyUrl: ctx.proxyUrl
-    };
-    return /*#__PURE__*/ jsx(APIPlayground, {
-        ...props
-    });
-}
-function getAuthorizationField(method, { schema: { document } }) {
-    const security = method.security ?? document.security ?? [];
-    if (security.length === 0) return;
-    const singular = security.find((requirements)=>Object.keys(requirements).length === 1);
-    if (!singular) return;
-    return getSecurities(singular, document)[0];
-}
-function getIdFromSchema(schema, required, ctx) {
-    const registered = ctx.registered.get(schema);
-    if (registered === undefined) {
-        const id = ctx.nextId();
-        ctx.registered.set(schema, id);
-        ctx.references[id] = toSchema(schema, required, ctx);
-        return id;
-    }
-    return registered;
-}
-function parameterToField(v, ctx) {
-    return {
-        name: v.name,
-        ...toSchema(v.schema ?? {
-            type: 'string'
-        }, v.required ?? false, ctx)
-    };
-}
-function toReference(schema, required, ctx) {
-    return {
-        type: 'ref',
-        isRequired: required,
-        schema: getIdFromSchema(schema, false, ctx)
-    };
-}
-function toSchema(schema, required, ctx) {
-    if (schema.type === 'array') {
-        return {
-            type: 'array',
-            description: schema.description ?? schema.title,
-            isRequired: required,
-            items: getIdFromSchema(schema.items, false, ctx)
-        };
-    }
-    if (schema.type === 'object' || schema.properties !== undefined || schema.allOf !== undefined) {
-        const properties = {};
-        Object.entries(schema.properties ?? {}).forEach(([key, prop])=>{
-            properties[key] = toReference(prop, schema.required?.includes(key) ?? false, ctx);
-        });
-        schema.allOf?.forEach((c)=>{
-            const field = toSchema(c, true, ctx);
-            if (field.type === 'object') Object.assign(properties, field.properties);
-        });
-        const additional = schema.additionalProperties;
-        let additionalProperties;
-        if (additional && typeof additional === 'object') {
-            if ((!additional.type || additional.type.length === 0) && !additional.anyOf && !additional.allOf && !additional.oneOf) {
-                additionalProperties = true;
-            } else {
-                additionalProperties = getIdFromSchema(additional, false, ctx);
-            }
-        } else {
-            additionalProperties = additional;
-        }
-        return {
-            type: 'object',
-            isRequired: required,
-            description: schema.description ?? schema.title,
-            properties,
-            additionalProperties
-        };
-    }
-    if (schema.type === undefined) {
-        const combine = schema.anyOf ?? schema.oneOf;
-        if (combine) {
-            return {
-                type: 'switcher',
-                description: schema.description ?? schema.title,
-                items: Object.fromEntries(combine.map((item, idx)=>{
-                    return [
-                        item.title ?? item.type ?? `Item ${idx.toString()}`,
-                        toReference(item, true, ctx)
-                    ];
-                })),
-                isRequired: required
-            };
-        }
-        return {
-            type: 'null',
-            isRequired: false
-        };
-    }
-    if (ctx.allowFile && schema.type === 'string' && schema.format === 'binary') {
-        return {
-            type: 'file',
-            isRequired: required,
-            description: schema.description ?? schema.title
-        };
-    }
-    if (Array.isArray(schema.type)) {
-        const items = {};
-        for (const type of schema.type){
-            if (type === 'array') {
-                items[type] = {
-                    type,
-                    items: 'items' in schema && schema.items ? toSchema(schema.items, false, ctx) : toSchema({}, required, ctx),
-                    isRequired: required
-                };
-            } else {
-                items[type] = toSchema({
-                    ...schema,
-                    type
-                }, required, ctx);
-            }
-        }
-        return {
-            type: 'switcher',
-            description: schema.description ?? schema.title,
-            items,
-            isRequired: required
-        };
-    }
-    return {
-        type: schema.type === 'integer' ? 'number' : schema.type,
-        defaultValue: schema.example ?? '',
-        isRequired: required,
-        description: schema.description ?? schema.title
-    };
-}
-
-function createRenders(shikiOptions) {
-    return {
-        Root: (props)=>/*#__PURE__*/ jsx(Root, {
-                shikiOptions: shikiOptions,
-                ...props,
-                children: props.children
-            }),
-        API,
-        APIInfo: ({ children, head })=>/*#__PURE__*/ jsxs(APIInfo, {
-                children: [
-                    head,
-                    children
-                ]
-            }),
-        APIExample: APIExample$1,
-        Responses: Tabs,
-        Response: Tab,
-        ResponseTypes: (props)=>/*#__PURE__*/ jsx(Accordions, {
-                type: "single",
-                className: "!-m-4 border-none pt-2",
-                defaultValue: "Response",
-                children: props.children
-            }),
-        ResponseType: (props)=>/*#__PURE__*/ jsx(Accordion, {
-                title: props.label,
-                children: /*#__PURE__*/ jsx(CodeBlock, {
-                    code: props.code,
-                    lang: props.lang,
-                    options: shikiOptions
-                })
-            }),
-        Property,
-        ObjectCollapsible,
-        Requests: (props)=>/*#__PURE__*/ jsx(Tabs, {
-                groupId: "fumadocs_openapi_requests",
-                ...props
-            }),
-        Request: (props)=>/*#__PURE__*/ jsx(Tab, {
-                value: props.name,
-                children: /*#__PURE__*/ jsx(CodeBlock, {
-                    lang: props.language,
-                    code: props.code,
-                    options: shikiOptions
-                })
-            }),
-        APIPlayground: Playground
-    };
-}
-
-const cache = new Map();
-/**
- * process & reference input document to a Fumadocs OpenAPI compatible format
- */ async function processDocument(document, disableCache = false) {
-    const cached = !disableCache && typeof document === 'string' ? cache.get(document) : null;
-    if (cached) return cached;
-    const dereferenceMap = new Map();
-    const loaded = await load(document, {
-        plugins: [
-            readFiles(),
-            fetchUrls()
-        ]
-    });
-    // upgrade
-    loaded.specification = upgrade(loaded.specification).specification;
-    const { schema: dereferenced } = await dereference(loaded.filesystem, {
-        onDereference ({ ref, schema }) {
-            dereferenceMap.set(schema, ref);
-        }
-    });
-    const processed = {
-        document: dereferenced,
-        dereferenceMap,
-        downloaded: loaded.specification
-    };
-    if (!disableCache && typeof document === 'string') {
-        cache.set(document, processed);
-    }
-    return processed;
-}
-
-function getUrl(url, variables) {
-    let out = url;
-    for (const [key, value] of Object.entries(variables)){
-        out = out.replaceAll(`{${key}}`, value);
-    }
-    return out;
-}
-
-async function APIPage(props) {
-    const { operations, hasHead = true, webhooks, disableCache = process.env.NODE_ENV === 'development' } = props;
-    const processed = await processDocument(props.document, disableCache);
-    const ctx = await getContext(processed, props);
-    const { document } = processed;
-    return /*#__PURE__*/ jsxs(ctx.renderer.Root, {
-        baseUrl: ctx.baseUrl,
-        servers: ctx.servers,
-        children: [
-            operations?.map((item)=>{
-                const pathItem = document.paths?.[item.path];
-                if (!pathItem) return null;
-                const operation = pathItem[item.method];
-                if (!operation) return null;
-                const method = createMethod(item.method, pathItem, operation);
-                return /*#__PURE__*/ jsx(Operation, {
-                    method: method,
-                    path: item.path,
-                    ctx: ctx,
-                    hasHead: hasHead
-                }, `${item.path}:${item.method}`);
-            }),
-            webhooks?.map((item)=>{
-                const webhook = document.webhooks?.[item.name];
-                if (!webhook) return;
-                const hook = webhook[item.method];
-                if (!hook) return;
-                const method = createMethod(item.method, webhook, hook);
-                return /*#__PURE__*/ jsx(Operation, {
-                    type: "webhook",
-                    method: method,
-                    ctx: {
-                        ...ctx,
-                        baseUrl: 'http://localhost:8080'
-                    },
-                    path: `/${item.name}`,
-                    hasHead: hasHead
-                }, `${item.name}:${item.method}`);
-            })
-        ]
-    });
-}
-async function getContext(schema, options = {}) {
-    const document = schema.document;
-    const servers = document.servers && document.servers.length > 0 ? document.servers : [
-        {
-            url: 'https://example.com'
-        }
-    ];
-    const server = servers[0];
-    return {
-        schema,
-        proxyUrl: options.proxyUrl,
-        showResponseSchema: options.showResponseSchema,
-        renderer: {
-            ...createRenders(options.shikiOptions),
-            ...options.renderer
-        },
-        shikiOptions: options.shikiOptions,
-        generateTypeScriptSchema: options.generateTypeScriptSchema,
-        generateCodeSamples: options.generateCodeSamples,
-        baseUrl: getUrl(server.url, server.variables ? Object.fromEntries(Object.entries(server.variables).map(([k, v])=>[
-                k,
-                v.default
-            ])) : {}),
-        servers,
-        slugger: new Slugger()
-    };
-}
-
-const keys = [
-    'GET',
-    'POST',
-    'PUT',
-    'DELETE',
-    'PATCH',
-    'HEAD'
-];
-function createProxy(allowedUrls) {
-    const handlers = {};
-    async function handler(req) {
-        const url = req.nextUrl.searchParams.get('url');
-        if (!url) {
-            return Response.json('A `url` query parameter is required for proxy url', {
-                status: 400
-            });
-        }
-        if (allowedUrls && allowedUrls.every((allowedUrl)=>!allowedUrl.startsWith(url))) {
-            return Response.json('The given `url` query parameter is not allowed', {
-                status: 400
-            });
-        }
-        const clonedReq = new Request(url, {
-            ...req,
-            cache: 'no-cache',
-            mode: 'cors'
-        });
-        clonedReq.headers.forEach((_value, originalKey)=>{
-            const key = originalKey.toLowerCase();
-            const notAllowed = key === 'origin';
-            if (notAllowed) {
-                clonedReq.headers.delete(originalKey);
-            }
-        });
-        const res = await fetch(clonedReq).catch((e)=>new Error(e.toString()));
-        if (res instanceof Error) {
-            return Response.json(`Failed to proxy request: ${res.message}`, {
-                status: 400
-            });
-        }
-        const headers = new Headers(res.headers);
-        headers.forEach((_value, originalKey)=>{
-            const key = originalKey.toLowerCase();
-            const notAllowed = key.startsWith('access-control-') || key === 'content-encoding';
-            if (notAllowed) {
-                headers.delete(originalKey);
-            }
-        });
-        headers.set('X-Forwarded-Host', res.url);
-        return new Response(res.body, {
-            ...res,
-            headers
-        });
-    }
-    for (const key of keys){
-        handlers[key] = handler;
-    }
-    return handlers;
-}
-
-function createOpenAPI(options = {}) {
-    return {
-        createProxy,
-        APIPage (props) {
-            return /*#__PURE__*/ jsx(APIPage, {
-                ...options,
-                ...props
-            });
-        }
-    };
-}
-
-cva('rounded-xl border px-1.5 py-1 text-xs font-medium leading-[12px]', {
-    variants: {
-        color: {
-            green: 'bg-green-400/20 text-green-600 dark:text-green-400',
-            yellow: 'bg-yellow-400/20 text-yellow-600 dark:text-yellow-400',
-            red: 'bg-red-400/20 text-red-600 dark:text-red-400',
-            blue: 'bg-blue-400/20 text-blue-600 dark:text-blue-400',
-            orange: 'bg-orange-400/20 text-orange-600 dark:text-orange-400'
-        }
-    }
-});
-function getBadgeColor(method) {
-    switch(method){
-        case 'PUT':
-            return 'yellow';
-        case 'PATCH':
-            return 'orange';
-        case 'POST':
-            return 'blue';
-        case 'DELETE':
-            return 'red';
-        default:
-            return 'green';
-    }
-}
-
-/**
- * Source API Integration
- *
- * Add this to page tree builder options
- */ const attachFile = (node, file)=>{
-    if (!file) return node;
-    const data = file.data.data;
-    let method;
-    if ('_openapi' in data && typeof data._openapi === 'object') {
-        const meta = data._openapi;
-        method = meta.method;
-    }
-    if (method) {
-        const color = getBadgeColor(method);
-        node.name = /*#__PURE__*/ jsxs(Fragment, {
-            children: [
-                node.name,
-                ' ',
-                /*#__PURE__*/ jsx("span", {
-                    className: badgeVariants({
-                        className: 'ms-auto text-nowrap',
-                        color
-                    }),
-                    children: method
-                })
-            ]
-        });
-    }
-    return node;
-};
-const badgeVariants = cva('rounded-full border px-1.5 text-xs font-medium', {
-    variants: {
-        color: {
-            green: 'bg-green-400/20 text-green-600 dark:text-green-400',
-            yellow: 'bg-yellow-400/20 text-yellow-600 dark:text-yellow-400',
-            red: 'bg-red-400/20 text-red-600 dark:text-red-400',
-            blue: 'bg-blue-400/20 text-blue-600 dark:text-blue-400',
-            orange: 'bg-orange-400/20 text-orange-600 dark:text-orange-400'
-        }
-    }
-});
-
-export { attachFile, createOpenAPI };
+export * from './create.js';
+export * from './source-api.js';