@fern-api/fdr-sdk 0.147.2-ced5c8e88b → 0.147.3-cf2efdb460

package/dist/client/visitWriteNavigationConfig.d.ts

@@ -1,13 +0,0 @@
-import type { DocsV1Write } from ".";
-export interface WriteNavigationConfigVisitor<T> {
-    versioned: (config: DocsV1Write.VersionedNavigationConfig) => T;
-    unversioned: (config: DocsV1Write.UnversionedNavigationConfig) => T;
-}
-export interface WriteUnversionedNavigationConfigVisitor<T> {
-    tabbed: (config: DocsV1Write.UnversionedTabbedNavigationConfig) => T;
-    untabbed: (config: DocsV1Write.UnversionedUntabbedNavigationConfig) => T;
-}
-export declare function visitWriteNavigationConfig<T>(config: DocsV1Write.NavigationConfig, visitor: WriteNavigationConfigVisitor<T>): T;
-export declare function visitUnversionedWriteNavigationConfig<T>(config: DocsV1Write.UnversionedNavigationConfig, visitor: WriteUnversionedNavigationConfigVisitor<T>): T;
-export declare function isTabbedNavigationConfig(config: DocsV1Write.UnversionedNavigationConfig): config is DocsV1Write.UnversionedTabbedNavigationConfig;
-//# sourceMappingURL=visitWriteNavigationConfig.d.ts.map

package/dist/client/visitWriteNavigationConfig.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"visitWriteNavigationConfig.d.ts","sourceRoot":"","sources":["../../src/client/visitWriteNavigationConfig.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,GAAG,CAAC;AAErC,MAAM,WAAW,4BAA4B,CAAC,CAAC;IAC3C,SAAS,EAAE,CAAC,MAAM,EAAE,WAAW,CAAC,yBAAyB,KAAK,CAAC,CAAC;IAChE,WAAW,EAAE,CAAC,MAAM,EAAE,WAAW,CAAC,2BAA2B,KAAK,CAAC,CAAC;CACvE;AAED,MAAM,WAAW,uCAAuC,CAAC,CAAC;IACtD,MAAM,EAAE,CAAC,MAAM,EAAE,WAAW,CAAC,iCAAiC,KAAK,CAAC,CAAC;IACrE,QAAQ,EAAE,CAAC,MAAM,EAAE,WAAW,CAAC,mCAAmC,KAAK,CAAC,CAAC;CAC5E;AAED,wBAAgB,0BAA0B,CAAC,CAAC,EACxC,MAAM,EAAE,WAAW,CAAC,gBAAgB,EACpC,OAAO,EAAE,4BAA4B,CAAC,CAAC,CAAC,GACzC,CAAC,CAMH;AAED,wBAAgB,qCAAqC,CAAC,CAAC,EACnD,MAAM,EAAE,WAAW,CAAC,2BAA2B,EAC/C,OAAO,EAAE,uCAAuC,CAAC,CAAC,CAAC,GACpD,CAAC,CAMH;AAQD,wBAAgB,wBAAwB,CACpC,MAAM,EAAE,WAAW,CAAC,2BAA2B,GAChD,MAAM,IAAI,WAAW,CAAC,iCAAiC,CAKzD"}

package/dist/client/visitWriteNavigationConfig.js

@@ -1,24 +0,0 @@
-export function visitWriteNavigationConfig(config, visitor) {
-    if (isVersionedNavigationConfig(config)) {
-        return visitor.versioned(config);
-    }
-    else {
-        return visitor.unversioned(config);
-    }
-}
-export function visitUnversionedWriteNavigationConfig(config, visitor) {
-    if (isTabbedNavigationConfig(config)) {
-        return visitor.tabbed(config);
-    }
-    else {
-        return visitor.untabbed(config);
-    }
-}
-function isVersionedNavigationConfig(config) {
-    return Array.isArray(config.versions);
-}
-export function isTabbedNavigationConfig(config) {
-    return (Array.isArray(config.tabs) ||
-        Array.isArray(config.tabsV2));
-}
-//# sourceMappingURL=visitWriteNavigationConfig.js.map

package/dist/client/visitWriteNavigationConfig.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"visitWriteNavigationConfig.js","sourceRoot":"","sources":["../../src/client/visitWriteNavigationConfig.ts"],"names":[],"mappings":"AAYA,MAAM,UAAU,0BAA0B,CACtC,MAAoC,EACpC,OAAwC;IAExC,IAAI,2BAA2B,CAAC,MAAM,CAAC,EAAE,CAAC;QACtC,OAAO,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;IACrC,CAAC;SAAM,CAAC;QACJ,OAAO,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;IACvC,CAAC;AACL,CAAC;AAED,MAAM,UAAU,qCAAqC,CACjD,MAA+C,EAC/C,OAAmD;IAEnD,IAAI,wBAAwB,CAAC,MAAM,CAAC,EAAE,CAAC;QACnC,OAAO,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAClC,CAAC;SAAM,CAAC;QACJ,OAAO,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;IACpC,CAAC;AACL,CAAC;AAED,SAAS,2BAA2B,CAChC,MAAoC;IAEpC,OAAO,KAAK,CAAC,OAAO,CAAE,MAAgD,CAAC,QAAQ,CAAC,CAAC;AACrF,CAAC;AAED,MAAM,UAAU,wBAAwB,CACpC,MAA+C;IAE/C,OAAO,CACH,KAAK,CAAC,OAAO,CAAE,MAAwD,CAAC,IAAI,CAAC;QAC7E,KAAK,CAAC,OAAO,CAAE,MAAwD,CAAC,MAAM,CAAC,CAClF,CAAC;AACN,CAAC"}

package/dist/converters/db/convertAPIDefinitionToDb.d.ts

@@ -1,9 +0,0 @@
-import { type APIV1Db, type APIV1Read, type APIV1Write, FdrAPI } from "../../client";
-import type { SDKSnippetHolder } from "./snippets/SDKSnippetHolder";
-export declare function convertAPIDefinitionToDb(writeShape: APIV1Write.ApiDefinition, id: FdrAPI.ApiDefinitionId, snippets: SDKSnippetHolder): APIV1Db.DbApiDefinition;
-export declare function transformExampleEndpointCall({ writeShape, endpointDefinition, snippets }: {
-    writeShape: APIV1Write.ExampleEndpointCall;
-    endpointDefinition: APIV1Write.EndpointDefinition;
-    snippets: SDKSnippetHolder;
-}): APIV1Read.ExampleEndpointCall;
-//# sourceMappingURL=convertAPIDefinitionToDb.d.ts.map

package/dist/converters/db/convertAPIDefinitionToDb.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"convertAPIDefinitionToDb.d.ts","sourceRoot":"","sources":["../../../src/converters/db/convertAPIDefinitionToDb.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,UAAU,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAQrF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAEpE,wBAAgB,wBAAwB,CACpC,UAAU,EAAE,UAAU,CAAC,aAAa,EACpC,EAAE,EAAE,MAAM,CAAC,eAAe,EAC1B,QAAQ,EAAE,gBAAgB,GAC3B,OAAO,CAAC,eAAe,CA6DzB;AAmbD,wBAAgB,4BAA4B,CAAC,EACzC,UAAU,EACV,kBAAkB,EAClB,QAAQ,EACX,EAAE;IACC,UAAU,EAAE,UAAU,CAAC,mBAAmB,CAAC;IAC3C,kBAAkB,EAAE,UAAU,CAAC,kBAAkB,CAAC;IAClD,QAAQ,EAAE,gBAAgB,CAAC;CAC9B,GAAG,SAAS,CAAC,mBAAmB,CAqChC"}

package/dist/converters/db/convertAPIDefinitionToDb.js

@@ -1,615 +0,0 @@
-import assertNever from "@fern-api/ui-core-utils/assertNever";
-import titleCase from "@fern-api/ui-core-utils/titleCase";
-import { kebabCase } from "es-toolkit/string";
-import isEqual from "fast-deep-equal";
-import { FdrAPI } from "../../client";
-import { generateEndpointErrorExample, generateEndpointNonStreamResponseExample, generateEndpointStreamResponseExample, generateEndpointSuccessExample } from "./examples/generateEndpointExampleCall";
-import { generateWebhookExample } from "./examples/generateWebhookExample";
-export function convertAPIDefinitionToDb(writeShape, id, snippets) {
-    const subpackageToParent = {};
-    for (const [parentId, parentContents] of entries(writeShape.subpackages)) {
-        for (const subpackageId of parentContents.subpackages) {
-            subpackageToParent[subpackageId] = parentId;
-        }
-    }
-    const context = new ApiDefinitionTransformationContext();
-    return {
-        id,
-        apiName: writeShape.apiName,
-        rootPackage: {
-            endpoints: writeShape.rootPackage.endpoints.map((endpoint) => transformEndpoint({
-                writeShape: endpoint,
-                apiDefinition: writeShape,
-                context,
-                snippets
-            }) ?? []),
-            webhooks: writeShape.rootPackage.webhooks?.map((webhook) => transformWebhook({
-                writeShape: webhook,
-                apiDefinition: writeShape
-            })) ?? [],
-            websockets: writeShape.rootPackage.websockets?.map((websocket) => transformWebsocket({ writeShape: websocket })) ??
-                [],
-            graphqlOperations: writeShape.rootPackage.graphqlOperations ?? [],
-            subpackages: writeShape.rootPackage.subpackages,
-            types: writeShape.rootPackage.types,
-            pointsTo: undefined
-        },
-        types: Object.fromEntries(Object.entries(writeShape.types).map(([typeId, typeDefinition]) => {
-            return [typeId, transformTypeDefinition({ writeShape: typeDefinition })];
-        })),
-        subpackages: entries(writeShape.subpackages).reduce((subpackages, [subpackageId, subpackage]) => {
-            subpackages[subpackageId] = transformSubpackage({
-                writeShape: subpackage,
-                id: subpackageId,
-                subpackageToParent,
-                apiDefinition: writeShape,
-                context,
-                snippets
-            });
-            return subpackages;
-        }, {}),
-        snippetsConfiguration: writeShape.snippetsConfiguration,
-        auth: writeShape.auth,
-        authSchemes: writeShape.authSchemes,
-        globalHeaders: writeShape.globalHeaders,
-        hasMultipleBaseUrls: context.hasMultipleBaseUrls(),
-        navigation: writeShape.navigation
-    };
-}
-function transformSubpackage({ writeShape, id, subpackageToParent, apiDefinition, context, snippets }) {
-    const parent = subpackageToParent[id];
-    const endpoints = writeShape.endpoints.map((endpoint) => transformEndpoint({
-        writeShape: endpoint,
-        apiDefinition,
-        context,
-        snippets
-    }));
-    const webhooks = writeShape.webhooks?.map((webhook) => transformWebhook({ writeShape: webhook, apiDefinition }));
-    const websockets = writeShape.websockets?.map((websocket) => transformWebsocket({ writeShape: websocket }));
-    const graphqlOperations = writeShape.graphqlOperations;
-    // const htmlDescription = getHtmlDescription(writeShape.description);
-    return {
-        subpackageId: id,
-        parent,
-        name: writeShape.name,
-        endpoints,
-        websockets: websockets ?? [],
-        graphqlOperations: graphqlOperations ?? [],
-        types: writeShape.types,
-        subpackages: writeShape.subpackages,
-        pointsTo: writeShape.pointsTo,
-        urlSlug: kebabCase(writeShape.name),
-        description: writeShape.description,
-        displayName: writeShape.displayName,
-        // htmlDescription,
-        // descriptionContainsMarkdown: true,
-        webhooks: webhooks ?? []
-    };
-}
-function transformWebsocket({ writeShape }) {
-    // const htmlDescription = getHtmlDescription(writeShape.description);
-    const urlSlug = kebabCase(writeShape.id);
-    return {
-        urlSlug,
-        auth: writeShape.auth,
-        headers: writeShape.headers,
-        messages: writeShape.messages,
-        availability: writeShape.availability,
-        defaultEnvironment: writeShape.defaultEnvironment,
-        environments: writeShape.environments,
-        description: writeShape.description,
-        // htmlDescription,
-        // descriptionContainsMarkdown: true,
-        id: writeShape.id,
-        name: writeShape.name,
-        path: writeShape.path,
-        queryParameters: writeShape.queryParameters,
-        examples: writeShape.examples
-    };
-}
-function transformWebhook({ apiDefinition, writeShape }) {
-    // const htmlDescription = getHtmlDescription(writeShape.description);
-    const urlSlug = kebabCase(writeShape.id);
-    const oldUrlSlug = kebabCase(writeShape.name ?? writeShape.id);
-    return {
-        urlSlug,
-        migratedFromUrlSlugs: !isEqual(oldUrlSlug, urlSlug) ? [oldUrlSlug] : undefined,
-        description: writeShape.description,
-        availability: writeShape.availability,
-        // htmlDescription,
-        // descriptionContainsMarkdown: true,
-        method: writeShape.method,
-        id: writeShape.id,
-        name: writeShape.name,
-        path: writeShape.path,
-        headers: writeShape.headers,
-        responses: writeShape.responses?.map(convertWebhookResponseToDb),
-        payload: writeShape.payload,
-        examples: writeShape.examples.length > 0
-            ? writeShape.examples
-            : [
-                generateWebhookExample({
-                    webhookDefinition: writeShape,
-                    apiDefinition
-                })
-            ]
-    };
-}
-function convertWebhookResponseToDb(writeShape) {
-    const writeShapeType = writeShape.type;
-    switch (writeShapeType.type) {
-        case "fileDownload":
-        case "object":
-        case "reference":
-        case "streamingText":
-        case "stream":
-            return {
-                ...writeShape,
-                type: writeShapeType
-            };
-        case "streamCondition":
-            // Webhook responses shouldn't have streamCondition, but handle it gracefully
-            // by converting to a simple reference type if the non-stream response has a shape
-            return {
-                ...writeShape,
-                type: writeShapeType.response.shape
-            };
-    }
-}
-function transformEndpoint({ writeShape, apiDefinition, context, snippets }) {
-    context.registerEnvironments(writeShape.environments ?? []);
-    // const htmlDescription = getHtmlDescription(writeShape.description);
-    const urlSlug = kebabCase(writeShape.id);
-    const oldUrlSlug = kebabCase(writeShape.name ?? writeShape.id);
-    return {
-        availability: writeShape.availability,
-        environments: writeShape.environments,
-        defaultEnvironment: writeShape.defaultEnvironment,
-        urlSlug: writeShape.slug ?? urlSlug,
-        // id is more unique than name, so we use that as the url slug
-        // keep name as a fallback for backwards compatibility (via redirects)
-        migratedFromUrlSlugs: !isEqual(oldUrlSlug, urlSlug) ? [oldUrlSlug] : undefined,
-        method: writeShape.method,
-        id: writeShape.id,
-        originalEndpointId: writeShape.originalEndpointId,
-        name: writeShape.name,
-        path: writeShape.path,
-        queryParameters: writeShape.queryParameters,
-        headers: writeShape.headers,
-        responseHeaders: writeShape.responseHeaders,
-        request: writeShape.request != null ? transformHttpRequestToDb({ writeShape: writeShape.request }) : undefined,
-        requestsV2: writeShape.requestsV2 != null
-            ? {
-                requests: writeShape.requestsV2.requests?.map((request) => transformHttpRequestToDb({ writeShape: request }))
-            }
-            : undefined,
-        response: writeShape.response != null
-            ? convertResponseToDb({
-                writeShape: writeShape.response,
-                apiDefinition,
-                sdkSnippetHolder: snippets,
-                endpointDefinition: writeShape
-            })
-            : undefined,
-        responsesV2: writeShape.responsesV2 != null
-            ? {
-                responses: writeShape.responsesV2.responses?.map((response) => convertResponseToDb({
-                    writeShape: response,
-                    apiDefinition,
-                    sdkSnippetHolder: snippets,
-                    endpointDefinition: writeShape
-                }))
-            }
-            : undefined,
-        errors: writeShape.errors ?? [],
-        errorsV2: transformErrorsV2(writeShape),
-        examples: getExampleEndpointCalls({
-            writeShape,
-            apiDefinition,
-            snippets
-        }),
-        description: writeShape.description,
-        // htmlDescription,
-        authed: writeShape.auth,
-        authV2: writeShape.authV2,
-        multiAuth: writeShape.multiAuth,
-        // descriptionContainsMarkdown: true,
-        snippetTemplates: snippets.getSnippetTemplateForEndpoint({
-            endpointPath: getEndpointPathAsString(writeShape),
-            endpointMethod: writeShape.method,
-            endpointId: writeShape.originalEndpointId ?? undefined
-        }),
-        protocol: writeShape.protocol,
-        includeInApiExplorer: writeShape.includeInApiExplorer
-    };
-}
-function transformErrorsV2(writeShape) {
-    if (writeShape.errorsV2 != null) {
-        return writeShape.errorsV2.map((errorV2) => {
-            return {
-                ...errorV2,
-                name: errorV2.name != null ? titleCase(errorV2.name) : undefined,
-                type: errorV2.type != null ? transformShape({ writeShape: errorV2.type }) : undefined
-            };
-        });
-    }
-    if (writeShape.errors != null) {
-        return writeShape.errors.map((error) => {
-            return {
-                name: undefined,
-                isWildcard: undefined,
-                examples: undefined,
-                headers: undefined,
-                ...error,
-                type: error.type != null
-                    ? {
-                        type: "alias",
-                        value: error.type
-                    }
-                    : undefined
-            };
-        });
-    }
-    return undefined;
-}
-function convertResponseToDb({ writeShape, apiDefinition, endpointDefinition, sdkSnippetHolder }) {
-    const writeShapeType = writeShape.type;
-    switch (writeShapeType.type) {
-        case "fileDownload":
-        case "object":
-        case "reference":
-        case "streamingText":
-        case "stream":
-            return {
-                ...writeShape,
-                type: writeShapeType
-            };
-        case "streamCondition":
-            return {
-                ...writeShape,
-                type: {
-                    type: "streamCondition",
-                    ...convertStreamConditionToDb({
-                        writeShape: writeShapeType,
-                        apiDefinition,
-                        endpointDefinition,
-                        sdkSnippetHolder
-                    })
-                }
-            };
-    }
-}
-function convertStreamConditionToDb({ writeShape, apiDefinition, endpointDefinition, sdkSnippetHolder }) {
-    const nonStreamExamples = writeShape.response.examples ??
-        generateEndpointNonStreamResponseExample({
-            apiDefinition,
-            nonStreamResponse: writeShape.response,
-            endpointDefinition
-        });
-    const streamExamples = writeShape.response.examples ??
-        generateEndpointStreamResponseExample({
-            apiDefinition,
-            streamResponse: writeShape.response,
-            endpointDefinition
-        });
-    return {
-        ...writeShape,
-        response: {
-            ...writeShape.response,
-            examples: nonStreamExamples.map((example) => {
-                return transformExampleEndpointCall({
-                    writeShape: example,
-                    endpointDefinition,
-                    snippets: sdkSnippetHolder
-                });
-            })
-        },
-        streamResponse: {
-            ...writeShape.streamResponse,
-            examples: streamExamples.map((example) => {
-                return transformExampleEndpointCall({
-                    writeShape: example,
-                    endpointDefinition,
-                    snippets: sdkSnippetHolder
-                });
-            })
-        }
-    };
-}
-function getExampleEndpointCalls({ writeShape, apiDefinition, snippets }) {
-    const examples = [];
-    const { successExamples: registeredSuccessExamples, errorExamples: registeredErrorExamples } = groupExamplesByStatusCode(writeShape.examples);
-    if (registeredSuccessExamples.length > 0) {
-        examples.push(...registeredSuccessExamples);
-    }
-    else {
-        const generatedSuccessExample = generateEndpointSuccessExample({
-            endpointDefinition: writeShape,
-            apiDefinition
-        });
-        examples.push(generatedSuccessExample);
-    }
-    const registeredErrorExampleStatusCodes = new Set(registeredErrorExamples.map((e) => e.responseStatusCode));
-    const errorsMissingAnExample = (writeShape.errorsV2 ?? []).filter((e) => !registeredErrorExampleStatusCodes.has(e.statusCode));
-    const generatedErrorExamples = errorsMissingAnExample.map((errorDeclaration) => generateEndpointErrorExample({
-        endpointDefinition: writeShape,
-        apiDefinition,
-        errorDeclaration
-    }));
-    examples.push(...registeredErrorExamples, ...generatedErrorExamples);
-    return examples.map((example) => transformExampleEndpointCall({
-        writeShape: example,
-        endpointDefinition: writeShape,
-        snippets
-    }));
-}
-function groupExamplesByStatusCode(examples) {
-    const successExamples = [];
-    const errorExamples = [];
-    examples.forEach((example) => {
-        if (example.responseStatusCode < 400) {
-            successExamples.push(example);
-        }
-        else {
-            errorExamples.push(example);
-        }
-    });
-    return { successExamples, errorExamples };
-}
-function transformHttpRequestToDb({ writeShape }) {
-    // const htmlDescription = getHtmlDescription(writeShape.description);
-    switch (writeShape.type.type) {
-        case "object":
-        case "reference":
-            return {
-                contentType: "application/json",
-                description: writeShape.description,
-                type: writeShape.type
-            };
-        case "fileUpload": // deprecated
-        case "formData":
-            return {
-                contentType: "multipart/form-data",
-                description: writeShape.description,
-                type: writeShape.type
-            };
-        case "json":
-            return {
-                contentType: writeShape.type.contentType,
-                description: writeShape.description,
-                type: writeShape.type.shape
-            };
-        case "bytes":
-            return {
-                contentType: writeShape.type.contentType ?? "application/octet-stream",
-                description: writeShape.description,
-                type: {
-                    type: "bytes",
-                    isOptional: writeShape.type.isOptional,
-                    contentType: writeShape.type.contentType
-                }
-            };
-        default:
-            assertNever(writeShape.type);
-    }
-}
-// exported for testing
-export function transformExampleEndpointCall({ writeShape, endpointDefinition, snippets }) {
-    // const htmlDescription = getHtmlDescription(writeShape.description);
-    return {
-        name: writeShape.name,
-        description: writeShape.description,
-        // htmlDescription,
-        // descriptionContainsMarkdown: true,
-        path: writeShape.path,
-        pathParameters: writeShape.pathParameters,
-        queryParameters: writeShape.queryParameters,
-        headers: writeShape.headers,
-        requestBody: writeShape.requestBody,
-        responseStatusCode: writeShape.responseStatusCode,
-        responseBody: writeShape.responseBody,
-        codeExamples: transformCodeExamples({
-            endpointDefinition,
-            snippets,
-            exampleId: writeShape.name ?? undefined
-        }),
-        requestBodyV3: writeShape.requestBodyV3 ??
-            (writeShape.requestBody != null
-                ? {
-                    type: "json",
-                    value: writeShape.requestBody
-                }
-                : undefined),
-        responseBodyV3: writeShape.responseBodyV3 ??
-            (writeShape.responseBody != null
-                ? {
-                    type: "json",
-                    value: writeShape.responseBody
-                }
-                : undefined),
-        codeSamples: writeShape.codeSamples ?? []
-    };
-}
-function transformCodeExamples({ exampleId, endpointDefinition, snippets }) {
-    const maybePythonSnippet = snippets.getPythonCodeSnippetForEndpoint({
-        endpointMethod: endpointDefinition.method,
-        endpointPath: getEndpointPathAsString(endpointDefinition),
-        endpointId: endpointDefinition.originalEndpointId ?? undefined,
-        exampleId
-    });
-    const maybeTypescriptSnippet = snippets.getTypeScriptCodeSnippetForEndpoint({
-        endpointMethod: endpointDefinition.method,
-        endpointPath: getEndpointPathAsString(endpointDefinition),
-        endpointId: endpointDefinition.originalEndpointId ?? undefined,
-        exampleId
-    });
-    const maybeGoSnippet = snippets.getGoCodeSnippetForEndpoint({
-        endpointMethod: endpointDefinition.method,
-        endpointPath: getEndpointPathAsString(endpointDefinition),
-        endpointId: endpointDefinition.originalEndpointId ?? undefined,
-        exampleId
-    });
-    const maybeRubySnippet = snippets.getRubyCodeSnippetForEndpoint({
-        endpointMethod: endpointDefinition.method,
-        endpointPath: getEndpointPathAsString(endpointDefinition),
-        endpointId: endpointDefinition.originalEndpointId ?? undefined,
-        exampleId
-    });
-    const maybeCsharpSnippet = snippets.getCsharpCodeSnippetForEndpoint({
-        endpointMethod: endpointDefinition.method,
-        endpointPath: getEndpointPathAsString(endpointDefinition),
-        endpointId: endpointDefinition.originalEndpointId ?? undefined,
-        exampleId
-    });
-    return {
-        nodeAxios: "",
-        pythonSdk: maybePythonSnippet,
-        typescriptSdk: maybeTypescriptSnippet,
-        goSdk: maybeGoSnippet,
-        rubySdk: maybeRubySnippet,
-        csharpSdk: maybeCsharpSnippet
-    };
-}
-function getEndpointPathAsString(endpoint) {
-    let endpointPath = "";
-    for (const part of endpoint.path.parts) {
-        if (part.type === "literal") {
-            endpointPath += part.value;
-        }
-        else {
-            endpointPath += `{${part.value}}`;
-        }
-    }
-    return FdrAPI.EndpointPathLiteral(endpointPath);
-}
-function transformTypeDefinition({ writeShape }) {
-    // const htmlDescription = getHtmlDescription(writeShape.description);
-    return {
-        description: writeShape.description,
-        availability: writeShape.availability,
-        // htmlDescription,
-        name: writeShape.name,
-        displayName: writeShape.displayName,
-        shape: transformShape({ writeShape: writeShape.shape })
-        // descriptionContainsMarkdown: true,
-    };
-}
-function transformShape({ writeShape }) {
-    switch (writeShape.type) {
-        case "object":
-            return {
-                type: "object",
-                extends: writeShape.extends,
-                properties: writeShape.properties.map((property) => transformProperty({ writeShape: property })),
-                extraProperties: writeShape.extraProperties
-            };
-        case "alias":
-            return {
-                type: "alias",
-                value: writeShape.value
-            };
-        case "enum":
-            return {
-                type: "enum",
-                default: writeShape.default,
-                values: writeShape.values.map((enumValue) => transformEnumValue({ writeShape: enumValue }))
-            };
-        case "discriminatedUnion":
-            return {
-                type: "discriminatedUnion",
-                discriminant: writeShape.discriminant,
-                variants: writeShape.variants.map((variant) => transformDiscriminatedVariant({ writeShape: variant }))
-            };
-        case "undiscriminatedUnion":
-            return {
-                type: "undiscriminatedUnion",
-                variants: writeShape.variants.map((variant) => transformUnDiscriminatedVariant({ writeShape: variant }))
-            };
-        default:
-            assertNever(writeShape);
-    }
-}
-function transformProperty({ writeShape }) {
-    // const htmlDescription = getHtmlDescription(writeShape.description);
-    return {
-        description: writeShape.description,
-        availability: writeShape.availability,
-        // htmlDescription,
-        key: writeShape.key,
-        valueType: writeShape.valueType,
-        propertyAccess: writeShape.propertyAccess
-        // descriptionContainsMarkdown: true,
-    };
-}
-function transformEnumValue({ writeShape }) {
-    // const htmlDescription = getHtmlDescription(writeShape.description);
-    return {
-        availability: writeShape.availability,
-        description: writeShape.description,
-        // htmlDescription,
-        value: writeShape.value
-        // descriptionContainsMarkdown: true,
-    };
-}
-function transformDiscriminatedVariant({ writeShape }) {
-    // const htmlDescription = getHtmlDescription(writeShape.description);
-    return {
-        description: writeShape.description,
-        availability: writeShape.availability,
-        displayName: writeShape.displayName,
-        // htmlDescription,
-        // descriptionContainsMarkdown: true,
-        discriminantValue: writeShape.discriminantValue,
-        additionalProperties: {
-            extends: writeShape.additionalProperties.extends,
-            properties: writeShape.additionalProperties.properties.map((property) => transformProperty({ writeShape: property })),
-            extraProperties: writeShape.additionalProperties.extraProperties
-        }
-    };
-}
-function transformUnDiscriminatedVariant({ writeShape }) {
-    // const htmlDescription = getHtmlDescription(writeShape.description);
-    return {
-        description: writeShape.description,
-        availability: writeShape.availability,
-        // htmlDescription,
-        type: writeShape.type,
-        displayName: writeShape.displayName
-        // descriptionContainsMarkdown: true,
-    };
-}
-function entries(obj) {
-    return Object.entries(obj);
-}
-class ApiDefinitionTransformationContext {
-    uniqueBaseUrls = {};
-    registerEnvironments(environments) {
-        for (const environment of environments) {
-            const entry = this.uniqueBaseUrls[environment.id];
-            if (entry != null) {
-                entry.add(this.getHost(environment.baseUrl));
-            }
-            else {
-                this.uniqueBaseUrls[environment.id] = new Set([this.getHost(environment.baseUrl)]);
-            }
-        }
-    }
-    hasMultipleBaseUrls() {
-        for (const [, hosts] of Object.entries(this.uniqueBaseUrls)) {
-            if (hosts.size > 1) {
-                return true;
-            }
-        }
-        return false;
-    }
-    getHost(url) {
-        try {
-            const parsedBaseUrl = new URL(url);
-            return parsedBaseUrl.host;
-        }
-        catch (_err) {
-            return "";
-        }
-    }
-}
-//# sourceMappingURL=convertAPIDefinitionToDb.js.map