@fern-api/fdr-sdk 1.0.4-92b8658c63 → 1.0.4-cab13ddd2d

package/dist/client/visitWriteNavigationConfig.d.ts

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,615 @@
+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