Client.ts

/**
 * This file was auto-generated by Fern from our API Definition.
 */

import * as environments from "./environments";
import * as core from "./core";
import * as Gooey from "./api/index";
import * as serializers from "./serialization/index";
import urlJoin from "url-join";
import * as errors from "./errors/index";
import * as fs from "fs";
import { Blob } from "buffer";
import { Copilot } from "./api/resources/copilot/client/Client";

export declare namespace GooeyClient {
    interface Options {
        environment?: core.Supplier<environments.GooeyEnvironment | string>;
        apiKey?: core.Supplier<core.BearerToken | undefined>;
        fetcher?: core.FetchFunction;
    }

    interface RequestOptions {
        /** The maximum time to wait for a response in seconds. */
        timeoutInSeconds?: number;
        /** The number of times to retry the request. Defaults to 2. */
        maxRetries?: number;
        /** A hook to abort the request. */
        abortSignal?: AbortSignal;
    }
}

export class GooeyClient {
    constructor(protected readonly _options: GooeyClient.Options = {}) {}

    /**
     * @param {Gooey.DeforumSdPageRequest} request
     * @param {GooeyClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Gooey.PaymentRequiredError}
     * @throws {@link Gooey.UnprocessableEntityError}
     * @throws {@link Gooey.TooManyRequestsError}
     *
     * @example
     *     await client.animate({
     *         animationPrompts: [{
     *                 frame: "frame",
     *                 prompt: "prompt"
     *             }]
     *     })
     */
    public async animate(
        request: Gooey.DeforumSdPageRequest,
        requestOptions?: GooeyClient.RequestOptions
    ): Promise<Gooey.DeforumSdPageOutput> {
        const { exampleId, ..._body } = request;
        const _queryParams: Record<string, string | string[] | object | object[]> = {};
        if (exampleId != null) {
            _queryParams["example_id"] = exampleId;
        }

        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.environment)) ?? environments.GooeyEnvironment.Default,
                "v3/DeforumSD/async"
            ),
            method: "POST",
            headers: {
                Authorization: await this._getAuthorizationHeader(),
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "gooeyai",
                "X-Fern-SDK-Version": "0.0.1-beta25",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
            },
            contentType: "application/json",
            queryParameters: _queryParams,
            requestType: "json",
            body: serializers.DeforumSdPageRequest.jsonOrThrow(_body, { unrecognizedObjectKeys: "strip" }),
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.DeforumSdPageOutput.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 402:
                    throw new Gooey.PaymentRequiredError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 422:
                    throw new Gooey.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 429:
                    throw new Gooey.TooManyRequestsError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                default:
                    throw new errors.GooeyError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.GooeyError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.GooeyTimeoutError();
            case "unknown":
                throw new errors.GooeyError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * @param {File | fs.ReadStream | Blob | undefined} qrCodeInputImage
     * @param {File | fs.ReadStream | Blob | undefined} qrCodeFile
     * @param {Gooey.QrCodeRequest} request
     * @param {GooeyClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Gooey.PaymentRequiredError}
     * @throws {@link Gooey.UnprocessableEntityError}
     * @throws {@link Gooey.TooManyRequestsError}
     *
     * @example
     *     await client.qrCode(fs.createReadStream("/path/to/your/file"), fs.createReadStream("/path/to/your/file"), {
     *         textPrompt: "text_prompt"
     *     })
     */
    public async qrCode(
        qrCodeInputImage: File | fs.ReadStream | Blob | undefined,
        qrCodeFile: File | fs.ReadStream | Blob | undefined,
        request: Gooey.QrCodeRequest,
        requestOptions?: GooeyClient.RequestOptions
    ): Promise<Gooey.QrCodeGeneratorPageOutput> {
        const _queryParams: Record<string, string | string[] | object | object[]> = {};
        if (request.exampleId != null) {
            _queryParams["example_id"] = request.exampleId;
        }

        const _request = await core.newFormData();
        if (request.functions != null) {
            for (const _item of request.functions) {
                await _request.append("functions", JSON.stringify(_item));
            }
        }

        if (request.variables != null) {
            await _request.append("variables", JSON.stringify(request.variables));
        }

        if (request.qrCodeData != null) {
            await _request.append("qr_code_data", request.qrCodeData);
        }

        if (qrCodeInputImage != null) {
            await _request.appendFile("qr_code_input_image", qrCodeInputImage);
        }

        if (request.qrCodeVcard != null) {
            await _request.append("qr_code_vcard", JSON.stringify(request.qrCodeVcard));
        }

        if (qrCodeFile != null) {
            await _request.appendFile("qr_code_file", qrCodeFile);
        }

        if (request.useUrlShortener != null) {
            await _request.append("use_url_shortener", request.useUrlShortener.toString());
        }

        await _request.append("text_prompt", request.textPrompt);
        if (request.negativePrompt != null) {
            await _request.append("negative_prompt", request.negativePrompt);
        }

        if (request.imagePrompt != null) {
            await _request.append("image_prompt", request.imagePrompt);
        }

        if (request.imagePromptControlnetModels != null) {
            for (const _item of request.imagePromptControlnetModels) {
                await _request.append("image_prompt_controlnet_models", _item);
            }
        }

        if (request.imagePromptStrength != null) {
            await _request.append("image_prompt_strength", request.imagePromptStrength.toString());
        }

        if (request.imagePromptScale != null) {
            await _request.append("image_prompt_scale", request.imagePromptScale.toString());
        }

        if (request.imagePromptPosX != null) {
            await _request.append("image_prompt_pos_x", request.imagePromptPosX.toString());
        }

        if (request.imagePromptPosY != null) {
            await _request.append("image_prompt_pos_y", request.imagePromptPosY.toString());
        }

        if (request.selectedModel != null) {
            await _request.append("selected_model", request.selectedModel);
        }

        if (request.selectedControlnetModel != null) {
            for (const _item of request.selectedControlnetModel) {
                await _request.append("selected_controlnet_model", _item);
            }
        }

        if (request.outputWidth != null) {
            await _request.append("output_width", request.outputWidth.toString());
        }

        if (request.outputHeight != null) {
            await _request.append("output_height", request.outputHeight.toString());
        }

        if (request.guidanceScale != null) {
            await _request.append("guidance_scale", request.guidanceScale.toString());
        }

        if (request.controlnetConditioningScale != null) {
            for (const _item of request.controlnetConditioningScale) {
                await _request.append("controlnet_conditioning_scale", _item.toString());
            }
        }

        if (request.numOutputs != null) {
            await _request.append("num_outputs", request.numOutputs.toString());
        }

        if (request.quality != null) {
            await _request.append("quality", request.quality.toString());
        }

        if (request.scheduler != null) {
            await _request.append("scheduler", request.scheduler);
        }

        if (request.seed != null) {
            await _request.append("seed", request.seed.toString());
        }

        if (request.objScale != null) {
            await _request.append("obj_scale", request.objScale.toString());
        }

        if (request.objPosX != null) {
            await _request.append("obj_pos_x", request.objPosX.toString());
        }

        if (request.objPosY != null) {
            await _request.append("obj_pos_y", request.objPosY.toString());
        }

        if (request.settings != null) {
            await _request.append("settings", JSON.stringify(request.settings));
        }

        const _maybeEncodedRequest = await _request.getRequest();
        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.environment)) ?? environments.GooeyEnvironment.Default,
                "v3/art-qr-code/async"
            ),
            method: "POST",
            headers: {
                Authorization: await this._getAuthorizationHeader(),
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "gooeyai",
                "X-Fern-SDK-Version": "0.0.1-beta25",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
                ..._maybeEncodedRequest.headers,
            },
            queryParameters: _queryParams,
            requestType: "file",
            duplex: _maybeEncodedRequest.duplex,
            body: _maybeEncodedRequest.body,
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.QrCodeGeneratorPageOutput.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 402:
                    throw new Gooey.PaymentRequiredError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 422:
                    throw new Gooey.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 429:
                    throw new Gooey.TooManyRequestsError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                default:
                    throw new errors.GooeyError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.GooeyError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.GooeyTimeoutError();
            case "unknown":
                throw new errors.GooeyError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * @param {Gooey.RelatedQnAPageRequest} request
     * @param {GooeyClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Gooey.PaymentRequiredError}
     * @throws {@link Gooey.UnprocessableEntityError}
     * @throws {@link Gooey.TooManyRequestsError}
     *
     * @example
     *     await client.seoPeopleAlsoAsk({
     *         searchQuery: "search_query",
     *         siteFilter: "site_filter"
     *     })
     */
    public async seoPeopleAlsoAsk(
        request: Gooey.RelatedQnAPageRequest,
        requestOptions?: GooeyClient.RequestOptions
    ): Promise<Gooey.RelatedQnAPageOutput> {
        const { exampleId, ..._body } = request;
        const _queryParams: Record<string, string | string[] | object | object[]> = {};
        if (exampleId != null) {
            _queryParams["example_id"] = exampleId;
        }

        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.environment)) ?? environments.GooeyEnvironment.Default,
                "v3/related-qna-maker/async"
            ),
            method: "POST",
            headers: {
                Authorization: await this._getAuthorizationHeader(),
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "gooeyai",
                "X-Fern-SDK-Version": "0.0.1-beta25",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
            },
            contentType: "application/json",
            queryParameters: _queryParams,
            requestType: "json",
            body: serializers.RelatedQnAPageRequest.jsonOrThrow(_body, { unrecognizedObjectKeys: "strip" }),
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.RelatedQnAPageOutput.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 402:
                    throw new Gooey.PaymentRequiredError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 422:
                    throw new Gooey.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 429:
                    throw new Gooey.TooManyRequestsError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                default:
                    throw new errors.GooeyError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.GooeyError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.GooeyTimeoutError();
            case "unknown":
                throw new errors.GooeyError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * @param {Gooey.SeoSummaryPageRequest} request
     * @param {GooeyClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Gooey.PaymentRequiredError}
     * @throws {@link Gooey.UnprocessableEntityError}
     * @throws {@link Gooey.TooManyRequestsError}
     *
     * @example
     *     await client.seoContent({
     *         searchQuery: "search_query",
     *         keywords: "keywords",
     *         title: "title",
     *         companyUrl: "company_url"
     *     })
     */
    public async seoContent(
        request: Gooey.SeoSummaryPageRequest,
        requestOptions?: GooeyClient.RequestOptions
    ): Promise<Gooey.SeoSummaryPageOutput> {
        const { exampleId, ..._body } = request;
        const _queryParams: Record<string, string | string[] | object | object[]> = {};
        if (exampleId != null) {
            _queryParams["example_id"] = exampleId;
        }

        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.environment)) ?? environments.GooeyEnvironment.Default,
                "v3/SEOSummary/async"
            ),
            method: "POST",
            headers: {
                Authorization: await this._getAuthorizationHeader(),
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "gooeyai",
                "X-Fern-SDK-Version": "0.0.1-beta25",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
            },
            contentType: "application/json",
            queryParameters: _queryParams,
            requestType: "json",
            body: serializers.SeoSummaryPageRequest.jsonOrThrow(_body, { unrecognizedObjectKeys: "strip" }),
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.SeoSummaryPageOutput.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 402:
                    throw new Gooey.PaymentRequiredError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 422:
                    throw new Gooey.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 429:
                    throw new Gooey.TooManyRequestsError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                default:
                    throw new errors.GooeyError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.GooeyError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.GooeyTimeoutError();
            case "unknown":
                throw new errors.GooeyError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * @param {Gooey.GoogleGptPageRequest} request
     * @param {GooeyClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Gooey.PaymentRequiredError}
     * @throws {@link Gooey.UnprocessableEntityError}
     * @throws {@link Gooey.TooManyRequestsError}
     *
     * @example
     *     await client.webSearchLlm({
     *         searchQuery: "search_query",
     *         siteFilter: "site_filter"
     *     })
     */
    public async webSearchLlm(
        request: Gooey.GoogleGptPageRequest,
        requestOptions?: GooeyClient.RequestOptions
    ): Promise<Gooey.GoogleGptPageOutput> {
        const { exampleId, ..._body } = request;
        const _queryParams: Record<string, string | string[] | object | object[]> = {};
        if (exampleId != null) {
            _queryParams["example_id"] = exampleId;
        }

        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.environment)) ?? environments.GooeyEnvironment.Default,
                "v3/google-gpt/async"
            ),
            method: "POST",
            headers: {
                Authorization: await this._getAuthorizationHeader(),
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "gooeyai",
                "X-Fern-SDK-Version": "0.0.1-beta25",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
            },
            contentType: "application/json",
            queryParameters: _queryParams,
            requestType: "json",
            body: serializers.GoogleGptPageRequest.jsonOrThrow(_body, { unrecognizedObjectKeys: "strip" }),
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.GoogleGptPageOutput.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 402:
                    throw new Gooey.PaymentRequiredError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 422:
                    throw new Gooey.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 429:
                    throw new Gooey.TooManyRequestsError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                default:
                    throw new errors.GooeyError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.GooeyError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.GooeyTimeoutError();
            case "unknown":
                throw new errors.GooeyError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * @param {Gooey.SocialLookupEmailPageRequest} request
     * @param {GooeyClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Gooey.PaymentRequiredError}
     * @throws {@link Gooey.UnprocessableEntityError}
     * @throws {@link Gooey.TooManyRequestsError}
     *
     * @example
     *     await client.personalizeEmail({
     *         emailAddress: "email_address"
     *     })
     */
    public async personalizeEmail(
        request: Gooey.SocialLookupEmailPageRequest,
        requestOptions?: GooeyClient.RequestOptions
    ): Promise<Gooey.SocialLookupEmailPageOutput> {
        const { exampleId, ..._body } = request;
        const _queryParams: Record<string, string | string[] | object | object[]> = {};
        if (exampleId != null) {
            _queryParams["example_id"] = exampleId;
        }

        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.environment)) ?? environments.GooeyEnvironment.Default,
                "v3/SocialLookupEmail/async"
            ),
            method: "POST",
            headers: {
                Authorization: await this._getAuthorizationHeader(),
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "gooeyai",
                "X-Fern-SDK-Version": "0.0.1-beta25",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
            },
            contentType: "application/json",
            queryParameters: _queryParams,
            requestType: "json",
            body: serializers.SocialLookupEmailPageRequest.jsonOrThrow(_body, { unrecognizedObjectKeys: "strip" }),
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.SocialLookupEmailPageOutput.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 402:
                    throw new Gooey.PaymentRequiredError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 422:
                    throw new Gooey.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 429:
                    throw new Gooey.TooManyRequestsError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                default:
                    throw new errors.GooeyError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.GooeyError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.GooeyTimeoutError();
            case "unknown":
                throw new errors.GooeyError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * @param {File[] | fs.ReadStream[] | Blob[]} documents
     * @param {Gooey.BulkRunRequest} request
     * @param {GooeyClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Gooey.PaymentRequiredError}
     * @throws {@link Gooey.UnprocessableEntityError}
     * @throws {@link Gooey.TooManyRequestsError}
     *
     * @example
     *     await client.bulkRun([fs.createReadStream("/path/to/your/file")], {
     *         runUrls: ["run_urls"],
     *         inputColumns: {
     *             "key": "value"
     *         },
     *         outputColumns: {
     *             "key": "value"
     *         }
     *     })
     */
    public async bulkRun(
        documents: File[] | fs.ReadStream[] | Blob[],
        request: Gooey.BulkRunRequest,
        requestOptions?: GooeyClient.RequestOptions
    ): Promise<Gooey.BulkRunnerPageOutput> {
        const _queryParams: Record<string, string | string[] | object | object[]> = {};
        if (request.exampleId != null) {
            _queryParams["example_id"] = request.exampleId;
        }

        const _request = await core.newFormData();
        if (request.functions != null) {
            for (const _item of request.functions) {
                await _request.append("functions", JSON.stringify(_item));
            }
        }

        if (request.variables != null) {
            await _request.append("variables", JSON.stringify(request.variables));
        }

        for (const _file of documents) {
            await _request.append("documents", _file);
        }

        for (const _item of request.runUrls) {
            await _request.append("run_urls", _item);
        }

        await _request.append("input_columns", JSON.stringify(request.inputColumns));
        await _request.append("output_columns", JSON.stringify(request.outputColumns));
        if (request.evalUrls != null) {
            for (const _item of request.evalUrls) {
                await _request.append("eval_urls", _item);
            }
        }

        if (request.settings != null) {
            await _request.append("settings", JSON.stringify(request.settings));
        }

        const _maybeEncodedRequest = await _request.getRequest();
        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.environment)) ?? environments.GooeyEnvironment.Default,
                "v3/bulk-runner/async"
            ),
            method: "POST",
            headers: {
                Authorization: await this._getAuthorizationHeader(),
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "gooeyai",
                "X-Fern-SDK-Version": "0.0.1-beta25",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
                ..._maybeEncodedRequest.headers,
            },
            queryParameters: _queryParams,
            requestType: "file",
            duplex: _maybeEncodedRequest.duplex,
            body: _maybeEncodedRequest.body,
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.BulkRunnerPageOutput.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 402:
                    throw new Gooey.PaymentRequiredError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 422:
                    throw new Gooey.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 429:
                    throw new Gooey.TooManyRequestsError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                default:
                    throw new errors.GooeyError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.GooeyError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.GooeyTimeoutError();
            case "unknown":
                throw new errors.GooeyError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * @param {Gooey.BulkEvalPageRequest} request
     * @param {GooeyClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Gooey.PaymentRequiredError}
     * @throws {@link Gooey.UnprocessableEntityError}
     * @throws {@link Gooey.TooManyRequestsError}
     *
     * @example
     *     await client.eval({
     *         documents: ["documents"]
     *     })
     */
    public async eval(
        request: Gooey.BulkEvalPageRequest,
        requestOptions?: GooeyClient.RequestOptions
    ): Promise<Gooey.BulkEvalPageOutput> {
        const { exampleId, ..._body } = request;
        const _queryParams: Record<string, string | string[] | object | object[]> = {};
        if (exampleId != null) {
            _queryParams["example_id"] = exampleId;
        }

        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.environment)) ?? environments.GooeyEnvironment.Default,
                "v3/bulk-eval/async"
            ),
            method: "POST",
            headers: {
                Authorization: await this._getAuthorizationHeader(),
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "gooeyai",
                "X-Fern-SDK-Version": "0.0.1-beta25",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
            },
            contentType: "application/json",
            queryParameters: _queryParams,
            requestType: "json",
            body: serializers.BulkEvalPageRequest.jsonOrThrow(_body, { unrecognizedObjectKeys: "strip" }),
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.BulkEvalPageOutput.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 402:
                    throw new Gooey.PaymentRequiredError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 422:
                    throw new Gooey.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 429:
                    throw new Gooey.TooManyRequestsError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                default:
                    throw new errors.GooeyError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.GooeyError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.GooeyTimeoutError();
            case "unknown":
                throw new errors.GooeyError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * @param {File[] | fs.ReadStream[] | Blob[]} documents
     * @param {File | fs.ReadStream | Blob | undefined} sheetUrl
     * @param {File | fs.ReadStream | Blob | undefined} glossaryDocument
     * @param {Gooey.SynthesizeDataRequest} request
     * @param {GooeyClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Gooey.PaymentRequiredError}
     * @throws {@link Gooey.UnprocessableEntityError}
     * @throws {@link Gooey.TooManyRequestsError}
     *
     * @example
     *     await client.synthesizeData([fs.createReadStream("/path/to/your/file")], fs.createReadStream("/path/to/your/file"), fs.createReadStream("/path/to/your/file"), {})
     */
    public async synthesizeData(
        documents: File[] | fs.ReadStream[] | Blob[],
        sheetUrl: File | fs.ReadStream | Blob | undefined,
        glossaryDocument: File | fs.ReadStream | Blob | undefined,
        request: Gooey.SynthesizeDataRequest,
        requestOptions?: GooeyClient.RequestOptions
    ): Promise<Gooey.DocExtractPageOutput> {
        const _queryParams: Record<string, string | string[] | object | object[]> = {};
        if (request.exampleId != null) {
            _queryParams["example_id"] = request.exampleId;
        }

        const _request = await core.newFormData();
        if (request.functions != null) {
            for (const _item of request.functions) {
                await _request.append("functions", JSON.stringify(_item));
            }
        }

        if (request.variables != null) {
            await _request.append("variables", JSON.stringify(request.variables));
        }

        for (const _file of documents) {
            await _request.append("documents", _file);
        }

        if (sheetUrl != null) {
            await _request.appendFile("sheet_url", sheetUrl);
        }

        if (request.selectedAsrModel != null) {
            await _request.append("selected_asr_model", request.selectedAsrModel);
        }

        if (request.googleTranslateTarget != null) {
            await _request.append("google_translate_target", request.googleTranslateTarget);
        }

        if (glossaryDocument != null) {
            await _request.appendFile("glossary_document", glossaryDocument);
        }

        if (request.taskInstructions != null) {
            await _request.append("task_instructions", request.taskInstructions);
        }

        if (request.selectedModel != null) {
            await _request.append("selected_model", request.selectedModel);
        }

        if (request.avoidRepetition != null) {
            await _request.append("avoid_repetition", request.avoidRepetition.toString());
        }

        if (request.numOutputs != null) {
            await _request.append("num_outputs", request.numOutputs.toString());
        }

        if (request.quality != null) {
            await _request.append("quality", request.quality.toString());
        }

        if (request.maxTokens != null) {
            await _request.append("max_tokens", request.maxTokens.toString());
        }

        if (request.samplingTemperature != null) {
            await _request.append("sampling_temperature", request.samplingTemperature.toString());
        }

        if (request.responseFormatType != null) {
            await _request.append("response_format_type", request.responseFormatType);
        }

        if (request.settings != null) {
            await _request.append("settings", JSON.stringify(request.settings));
        }

        const _maybeEncodedRequest = await _request.getRequest();
        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.environment)) ?? environments.GooeyEnvironment.Default,
                "v3/doc-extract/async"
            ),
            method: "POST",
            headers: {
                Authorization: await this._getAuthorizationHeader(),
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "gooeyai",
                "X-Fern-SDK-Version": "0.0.1-beta25",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
                ..._maybeEncodedRequest.headers,
            },
            queryParameters: _queryParams,
            requestType: "file",
            duplex: _maybeEncodedRequest.duplex,
            body: _maybeEncodedRequest.body,
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.DocExtractPageOutput.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 402:
                    throw new Gooey.PaymentRequiredError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 422:
                    throw new Gooey.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 429:
                    throw new Gooey.TooManyRequestsError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                default:
                    throw new errors.GooeyError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.GooeyError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.GooeyTimeoutError();
            case "unknown":
                throw new errors.GooeyError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * @param {Gooey.CompareLlmPageRequest} request
     * @param {GooeyClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Gooey.PaymentRequiredError}
     * @throws {@link Gooey.UnprocessableEntityError}
     * @throws {@link Gooey.TooManyRequestsError}
     *
     * @example
     *     await client.llm()
     */
    public async llm(
        request: Gooey.CompareLlmPageRequest = {},
        requestOptions?: GooeyClient.RequestOptions
    ): Promise<Gooey.CompareLlmPageOutput> {
        const { exampleId, ..._body } = request;
        const _queryParams: Record<string, string | string[] | object | object[]> = {};
        if (exampleId != null) {
            _queryParams["example_id"] = exampleId;
        }

        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.environment)) ?? environments.GooeyEnvironment.Default,
                "v3/CompareLLM/async"
            ),
            method: "POST",
            headers: {
                Authorization: await this._getAuthorizationHeader(),
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "gooeyai",
                "X-Fern-SDK-Version": "0.0.1-beta25",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
            },
            contentType: "application/json",
            queryParameters: _queryParams,
            requestType: "json",
            body: serializers.CompareLlmPageRequest.jsonOrThrow(_body, { unrecognizedObjectKeys: "strip" }),
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.CompareLlmPageOutput.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 402:
                    throw new Gooey.PaymentRequiredError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 422:
                    throw new Gooey.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 429:
                    throw new Gooey.TooManyRequestsError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                default:
                    throw new errors.GooeyError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.GooeyError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.GooeyTimeoutError();
            case "unknown":
                throw new errors.GooeyError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * @param {Gooey.DocSearchPageRequest} request
     * @param {GooeyClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Gooey.PaymentRequiredError}
     * @throws {@link Gooey.UnprocessableEntityError}
     * @throws {@link Gooey.TooManyRequestsError}
     *
     * @example
     *     await client.rag({
     *         searchQuery: "search_query"
     *     })
     */
    public async rag(
        request: Gooey.DocSearchPageRequest,
        requestOptions?: GooeyClient.RequestOptions
    ): Promise<Gooey.DocSearchPageOutput> {
        const { exampleId, ..._body } = request;
        const _queryParams: Record<string, string | string[] | object | object[]> = {};
        if (exampleId != null) {
            _queryParams["example_id"] = exampleId;
        }

        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.environment)) ?? environments.GooeyEnvironment.Default,
                "v3/doc-search/async"
            ),
            method: "POST",
            headers: {
                Authorization: await this._getAuthorizationHeader(),
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "gooeyai",
                "X-Fern-SDK-Version": "0.0.1-beta25",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
            },
            contentType: "application/json",
            queryParameters: _queryParams,
            requestType: "json",
            body: serializers.DocSearchPageRequest.jsonOrThrow(_body, { unrecognizedObjectKeys: "strip" }),
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.DocSearchPageOutput.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 402:
                    throw new Gooey.PaymentRequiredError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 422:
                    throw new Gooey.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 429:
                    throw new Gooey.TooManyRequestsError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                default:
                    throw new errors.GooeyError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.GooeyError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.GooeyTimeoutError();
            case "unknown":
                throw new errors.GooeyError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * @param {Gooey.SmartGptPageRequest} request
     * @param {GooeyClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Gooey.PaymentRequiredError}
     * @throws {@link Gooey.UnprocessableEntityError}
     * @throws {@link Gooey.TooManyRequestsError}
     *
     * @example
     *     await client.smartGpt({
     *         inputPrompt: "input_prompt"
     *     })
     */
    public async smartGpt(
        request: Gooey.SmartGptPageRequest,
        requestOptions?: GooeyClient.RequestOptions
    ): Promise<Gooey.SmartGptPageOutput> {
        const { exampleId, ..._body } = request;
        const _queryParams: Record<string, string | string[] | object | object[]> = {};
        if (exampleId != null) {
            _queryParams["example_id"] = exampleId;
        }

        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.environment)) ?? environments.GooeyEnvironment.Default,
                "v3/SmartGPT/async"
            ),
            method: "POST",
            headers: {
                Authorization: await this._getAuthorizationHeader(),
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "gooeyai",
                "X-Fern-SDK-Version": "0.0.1-beta25",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
            },
            contentType: "application/json",
            queryParameters: _queryParams,
            requestType: "json",
            body: serializers.SmartGptPageRequest.jsonOrThrow(_body, { unrecognizedObjectKeys: "strip" }),
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.SmartGptPageOutput.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 402:
                    throw new Gooey.PaymentRequiredError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 422:
                    throw new Gooey.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 429:
                    throw new Gooey.TooManyRequestsError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                default:
                    throw new errors.GooeyError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.GooeyError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.GooeyTimeoutError();
            case "unknown":
                throw new errors.GooeyError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * @param {File[] | fs.ReadStream[] | Blob[]} documents
     * @param {Gooey.DocSummaryRequest} request
     * @param {GooeyClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Gooey.PaymentRequiredError}
     * @throws {@link Gooey.UnprocessableEntityError}
     * @throws {@link Gooey.TooManyRequestsError}
     *
     * @example
     *     await client.docSummary([fs.createReadStream("/path/to/your/file")], {})
     */
    public async docSummary(
        documents: File[] | fs.ReadStream[] | Blob[],
        request: Gooey.DocSummaryRequest,
        requestOptions?: GooeyClient.RequestOptions
    ): Promise<Gooey.DocSummaryPageOutput> {
        const _queryParams: Record<string, string | string[] | object | object[]> = {};
        if (request.exampleId != null) {
            _queryParams["example_id"] = request.exampleId;
        }

        const _request = await core.newFormData();
        if (request.functions != null) {
            for (const _item of request.functions) {
                await _request.append("functions", JSON.stringify(_item));
            }
        }

        if (request.variables != null) {
            await _request.append("variables", JSON.stringify(request.variables));
        }

        for (const _file of documents) {
            await _request.append("documents", _file);
        }

        if (request.taskInstructions != null) {
            await _request.append("task_instructions", request.taskInstructions);
        }

        if (request.mergeInstructions != null) {
            await _request.append("merge_instructions", request.mergeInstructions);
        }

        if (request.selectedModel != null) {
            await _request.append("selected_model", request.selectedModel);
        }

        if (request.chainType != null) {
            await _request.append("chain_type", request.chainType);
        }

        if (request.selectedAsrModel != null) {
            await _request.append("selected_asr_model", request.selectedAsrModel);
        }

        if (request.googleTranslateTarget != null) {
            await _request.append("google_translate_target", request.googleTranslateTarget);
        }

        if (request.avoidRepetition != null) {
            await _request.append("avoid_repetition", request.avoidRepetition.toString());
        }

        if (request.numOutputs != null) {
            await _request.append("num_outputs", request.numOutputs.toString());
        }

        if (request.quality != null) {
            await _request.append("quality", request.quality.toString());
        }

        if (request.maxTokens != null) {
            await _request.append("max_tokens", request.maxTokens.toString());
        }

        if (request.samplingTemperature != null) {
            await _request.append("sampling_temperature", request.samplingTemperature.toString());
        }

        if (request.responseFormatType != null) {
            await _request.append("response_format_type", request.responseFormatType);
        }

        if (request.settings != null) {
            await _request.append("settings", JSON.stringify(request.settings));
        }

        const _maybeEncodedRequest = await _request.getRequest();
        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.environment)) ?? environments.GooeyEnvironment.Default,
                "v3/doc-summary/async"
            ),
            method: "POST",
            headers: {
                Authorization: await this._getAuthorizationHeader(),
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "gooeyai",
                "X-Fern-SDK-Version": "0.0.1-beta25",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
                ..._maybeEncodedRequest.headers,
            },
            queryParameters: _queryParams,
            requestType: "file",
            duplex: _maybeEncodedRequest.duplex,
            body: _maybeEncodedRequest.body,
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.DocSummaryPageOutput.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 402:
                    throw new Gooey.PaymentRequiredError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 422:
                    throw new Gooey.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 429:
                    throw new Gooey.TooManyRequestsError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                default:
                    throw new errors.GooeyError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.GooeyError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.GooeyTimeoutError();
            case "unknown":
                throw new errors.GooeyError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * @param {Gooey.FunctionsPageRequest} request
     * @param {GooeyClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Gooey.PaymentRequiredError}
     * @throws {@link Gooey.UnprocessableEntityError}
     * @throws {@link Gooey.TooManyRequestsError}
     *
     * @example
     *     await client.functions()
     */
    public async functions(
        request: Gooey.FunctionsPageRequest = {},
        requestOptions?: GooeyClient.RequestOptions
    ): Promise<Gooey.FunctionsPageOutput> {
        const { exampleId, ..._body } = request;
        const _queryParams: Record<string, string | string[] | object | object[]> = {};
        if (exampleId != null) {
            _queryParams["example_id"] = exampleId;
        }

        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.environment)) ?? environments.GooeyEnvironment.Default,
                "v3/functions/async"
            ),
            method: "POST",
            headers: {
                Authorization: await this._getAuthorizationHeader(),
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "gooeyai",
                "X-Fern-SDK-Version": "0.0.1-beta25",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
            },
            contentType: "application/json",
            queryParameters: _queryParams,
            requestType: "json",
            body: serializers.FunctionsPageRequest.jsonOrThrow(_body, { unrecognizedObjectKeys: "strip" }),
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.FunctionsPageOutput.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 402:
                    throw new Gooey.PaymentRequiredError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 422:
                    throw new Gooey.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 429:
                    throw new Gooey.TooManyRequestsError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                default:
                    throw new errors.GooeyError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.GooeyError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.GooeyTimeoutError();
            case "unknown":
                throw new errors.GooeyError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * @param {File | fs.ReadStream | Blob | undefined} inputFace
     * @param {File | fs.ReadStream | Blob | undefined} inputAudio
     * @param {Gooey.LipsyncRequest} request
     * @param {GooeyClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Gooey.PaymentRequiredError}
     * @throws {@link Gooey.UnprocessableEntityError}
     * @throws {@link Gooey.TooManyRequestsError}
     *
     * @example
     *     await client.lipsync(fs.createReadStream("/path/to/your/file"), fs.createReadStream("/path/to/your/file"), {})
     */
    public async lipsync(
        inputFace: File | fs.ReadStream | Blob | undefined,
        inputAudio: File | fs.ReadStream | Blob | undefined,
        request: Gooey.LipsyncRequest,
        requestOptions?: GooeyClient.RequestOptions
    ): Promise<Gooey.LipsyncPageOutput> {
        const _queryParams: Record<string, string | string[] | object | object[]> = {};
        if (request.exampleId != null) {
            _queryParams["example_id"] = request.exampleId;
        }

        const _request = await core.newFormData();
        if (request.functions != null) {
            for (const _item of request.functions) {
                await _request.append("functions", JSON.stringify(_item));
            }
        }

        if (request.variables != null) {
            await _request.append("variables", JSON.stringify(request.variables));
        }

        if (inputFace != null) {
            await _request.appendFile("input_face", inputFace);
        }

        if (request.facePaddingTop != null) {
            await _request.append("face_padding_top", request.facePaddingTop.toString());
        }

        if (request.facePaddingBottom != null) {
            await _request.append("face_padding_bottom", request.facePaddingBottom.toString());
        }

        if (request.facePaddingLeft != null) {
            await _request.append("face_padding_left", request.facePaddingLeft.toString());
        }

        if (request.facePaddingRight != null) {
            await _request.append("face_padding_right", request.facePaddingRight.toString());
        }

        if (request.sadtalkerSettings != null) {
            await _request.append("sadtalker_settings", JSON.stringify(request.sadtalkerSettings));
        }

        if (request.selectedModel != null) {
            await _request.append("selected_model", request.selectedModel);
        }

        if (inputAudio != null) {
            await _request.appendFile("input_audio", inputAudio);
        }

        if (request.settings != null) {
            await _request.append("settings", JSON.stringify(request.settings));
        }

        const _maybeEncodedRequest = await _request.getRequest();
        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.environment)) ?? environments.GooeyEnvironment.Default,
                "v3/Lipsync/async"
            ),
            method: "POST",
            headers: {
                Authorization: await this._getAuthorizationHeader(),
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "gooeyai",
                "X-Fern-SDK-Version": "0.0.1-beta25",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
                ..._maybeEncodedRequest.headers,
            },
            queryParameters: _queryParams,
            requestType: "file",
            duplex: _maybeEncodedRequest.duplex,
            body: _maybeEncodedRequest.body,
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.LipsyncPageOutput.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 402:
                    throw new Gooey.PaymentRequiredError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 422:
                    throw new Gooey.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 429:
                    throw new Gooey.TooManyRequestsError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                default:
                    throw new errors.GooeyError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.GooeyError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.GooeyTimeoutError();
            case "unknown":
                throw new errors.GooeyError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * @param {File | fs.ReadStream | Blob | undefined} inputFace
     * @param {Gooey.LipsyncTtsRequest} request
     * @param {GooeyClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Gooey.PaymentRequiredError}
     * @throws {@link Gooey.UnprocessableEntityError}
     * @throws {@link Gooey.TooManyRequestsError}
     *
     * @example
     *     await client.lipsyncTts(fs.createReadStream("/path/to/your/file"), {
     *         textPrompt: "text_prompt"
     *     })
     */
    public async lipsyncTts(
        inputFace: File | fs.ReadStream | Blob | undefined,
        request: Gooey.LipsyncTtsRequest,
        requestOptions?: GooeyClient.RequestOptions
    ): Promise<Gooey.LipsyncTtsPageOutput> {
        const _queryParams: Record<string, string | string[] | object | object[]> = {};
        if (request.exampleId != null) {
            _queryParams["example_id"] = request.exampleId;
        }

        const _request = await core.newFormData();
        if (request.functions != null) {
            for (const _item of request.functions) {
                await _request.append("functions", JSON.stringify(_item));
            }
        }

        if (request.variables != null) {
            await _request.append("variables", JSON.stringify(request.variables));
        }

        await _request.append("text_prompt", request.textPrompt);
        if (request.ttsProvider != null) {
            await _request.append("tts_provider", request.ttsProvider);
        }

        if (request.uberduckVoiceName != null) {
            await _request.append("uberduck_voice_name", request.uberduckVoiceName);
        }

        if (request.uberduckSpeakingRate != null) {
            await _request.append("uberduck_speaking_rate", request.uberduckSpeakingRate.toString());
        }

        if (request.googleVoiceName != null) {
            await _request.append("google_voice_name", request.googleVoiceName);
        }

        if (request.googleSpeakingRate != null) {
            await _request.append("google_speaking_rate", request.googleSpeakingRate.toString());
        }

        if (request.googlePitch != null) {
            await _request.append("google_pitch", request.googlePitch.toString());
        }

        if (request.barkHistoryPrompt != null) {
            await _request.append("bark_history_prompt", request.barkHistoryPrompt);
        }

        if (request.elevenlabsVoiceName != null) {
            await _request.append("elevenlabs_voice_name", request.elevenlabsVoiceName);
        }

        if (request.elevenlabsApiKey != null) {
            await _request.append("elevenlabs_api_key", request.elevenlabsApiKey);
        }

        if (request.elevenlabsVoiceId != null) {
            await _request.append("elevenlabs_voice_id", request.elevenlabsVoiceId);
        }

        if (request.elevenlabsModel != null) {
            await _request.append("elevenlabs_model", request.elevenlabsModel);
        }

        if (request.elevenlabsStability != null) {
            await _request.append("elevenlabs_stability", request.elevenlabsStability.toString());
        }

        if (request.elevenlabsSimilarityBoost != null) {
            await _request.append("elevenlabs_similarity_boost", request.elevenlabsSimilarityBoost.toString());
        }

        if (request.elevenlabsStyle != null) {
            await _request.append("elevenlabs_style", request.elevenlabsStyle.toString());
        }

        if (request.elevenlabsSpeakerBoost != null) {
            await _request.append("elevenlabs_speaker_boost", request.elevenlabsSpeakerBoost.toString());
        }

        if (request.azureVoiceName != null) {
            await _request.append("azure_voice_name", request.azureVoiceName);
        }

        if (request.openaiVoiceName != null) {
            await _request.append("openai_voice_name", request.openaiVoiceName);
        }

        if (request.openaiTtsModel != null) {
            await _request.append("openai_tts_model", request.openaiTtsModel);
        }

        if (inputFace != null) {
            await _request.appendFile("input_face", inputFace);
        }

        if (request.facePaddingTop != null) {
            await _request.append("face_padding_top", request.facePaddingTop.toString());
        }

        if (request.facePaddingBottom != null) {
            await _request.append("face_padding_bottom", request.facePaddingBottom.toString());
        }

        if (request.facePaddingLeft != null) {
            await _request.append("face_padding_left", request.facePaddingLeft.toString());
        }

        if (request.facePaddingRight != null) {
            await _request.append("face_padding_right", request.facePaddingRight.toString());
        }

        if (request.sadtalkerSettings != null) {
            await _request.append("sadtalker_settings", JSON.stringify(request.sadtalkerSettings));
        }

        if (request.selectedModel != null) {
            await _request.append("selected_model", request.selectedModel);
        }

        if (request.settings != null) {
            await _request.append("settings", JSON.stringify(request.settings));
        }

        const _maybeEncodedRequest = await _request.getRequest();
        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.environment)) ?? environments.GooeyEnvironment.Default,
                "v3/LipsyncTTS/async"
            ),
            method: "POST",
            headers: {
                Authorization: await this._getAuthorizationHeader(),
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "gooeyai",
                "X-Fern-SDK-Version": "0.0.1-beta25",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
                ..._maybeEncodedRequest.headers,
            },
            queryParameters: _queryParams,
            requestType: "file",
            duplex: _maybeEncodedRequest.duplex,
            body: _maybeEncodedRequest.body,
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.LipsyncTtsPageOutput.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 402:
                    throw new Gooey.PaymentRequiredError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 422:
                    throw new Gooey.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 429:
                    throw new Gooey.TooManyRequestsError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                default:
                    throw new errors.GooeyError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.GooeyError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.GooeyTimeoutError();
            case "unknown":
                throw new errors.GooeyError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * @param {Gooey.TextToSpeechPageRequest} request
     * @param {GooeyClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Gooey.PaymentRequiredError}
     * @throws {@link Gooey.UnprocessableEntityError}
     * @throws {@link Gooey.TooManyRequestsError}
     *
     * @example
     *     await client.textToSpeech({
     *         textPrompt: "text_prompt"
     *     })
     */
    public async textToSpeech(
        request: Gooey.TextToSpeechPageRequest,
        requestOptions?: GooeyClient.RequestOptions
    ): Promise<Gooey.TextToSpeechPageOutput> {
        const { exampleId, ..._body } = request;
        const _queryParams: Record<string, string | string[] | object | object[]> = {};
        if (exampleId != null) {
            _queryParams["example_id"] = exampleId;
        }

        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.environment)) ?? environments.GooeyEnvironment.Default,
                "v3/TextToSpeech/async"
            ),
            method: "POST",
            headers: {
                Authorization: await this._getAuthorizationHeader(),
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "gooeyai",
                "X-Fern-SDK-Version": "0.0.1-beta25",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
            },
            contentType: "application/json",
            queryParameters: _queryParams,
            requestType: "json",
            body: serializers.TextToSpeechPageRequest.jsonOrThrow(_body, { unrecognizedObjectKeys: "strip" }),
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.TextToSpeechPageOutput.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 402:
                    throw new Gooey.PaymentRequiredError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 422:
                    throw new Gooey.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 429:
                    throw new Gooey.TooManyRequestsError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                default:
                    throw new errors.GooeyError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.GooeyError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.GooeyTimeoutError();
            case "unknown":
                throw new errors.GooeyError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * @param {File[] | fs.ReadStream[] | Blob[]} documents
     * @param {File | fs.ReadStream | Blob | undefined} glossaryDocument
     * @param {Gooey.SpeechRecognitionRequest} request
     * @param {GooeyClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Gooey.PaymentRequiredError}
     * @throws {@link Gooey.UnprocessableEntityError}
     * @throws {@link Gooey.TooManyRequestsError}
     *
     * @example
     *     await client.speechRecognition([fs.createReadStream("/path/to/your/file")], fs.createReadStream("/path/to/your/file"), {})
     */
    public async speechRecognition(
        documents: File[] | fs.ReadStream[] | Blob[],
        glossaryDocument: File | fs.ReadStream | Blob | undefined,
        request: Gooey.SpeechRecognitionRequest,
        requestOptions?: GooeyClient.RequestOptions
    ): Promise<Gooey.AsrPageOutput> {
        const _queryParams: Record<string, string | string[] | object | object[]> = {};
        if (request.exampleId != null) {
            _queryParams["example_id"] = request.exampleId;
        }

        const _request = await core.newFormData();
        if (request.functions != null) {
            for (const _item of request.functions) {
                await _request.append("functions", JSON.stringify(_item));
            }
        }

        if (request.variables != null) {
            await _request.append("variables", JSON.stringify(request.variables));
        }

        for (const _file of documents) {
            await _request.append("documents", _file);
        }

        if (request.selectedModel != null) {
            await _request.append("selected_model", request.selectedModel);
        }

        if (request.language != null) {
            await _request.append("language", request.language);
        }

        if (request.translationModel != null) {
            await _request.append("translation_model", request.translationModel);
        }

        if (request.outputFormat != null) {
            await _request.append("output_format", request.outputFormat);
        }

        if (request.googleTranslateTarget != null) {
            await _request.append("google_translate_target", request.googleTranslateTarget);
        }

        if (request.translationSource != null) {
            await _request.append("translation_source", request.translationSource);
        }

        if (request.translationTarget != null) {
            await _request.append("translation_target", request.translationTarget);
        }

        if (glossaryDocument != null) {
            await _request.appendFile("glossary_document", glossaryDocument);
        }

        if (request.settings != null) {
            await _request.append("settings", JSON.stringify(request.settings));
        }

        const _maybeEncodedRequest = await _request.getRequest();
        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.environment)) ?? environments.GooeyEnvironment.Default,
                "v3/asr/async"
            ),
            method: "POST",
            headers: {
                Authorization: await this._getAuthorizationHeader(),
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "gooeyai",
                "X-Fern-SDK-Version": "0.0.1-beta25",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
                ..._maybeEncodedRequest.headers,
            },
            queryParameters: _queryParams,
            requestType: "file",
            duplex: _maybeEncodedRequest.duplex,
            body: _maybeEncodedRequest.body,
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.AsrPageOutput.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 402:
                    throw new Gooey.PaymentRequiredError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 422:
                    throw new Gooey.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 429:
                    throw new Gooey.TooManyRequestsError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                default:
                    throw new errors.GooeyError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.GooeyError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.GooeyTimeoutError();
            case "unknown":
                throw new errors.GooeyError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * @param {Gooey.Text2AudioPageRequest} request
     * @param {GooeyClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Gooey.PaymentRequiredError}
     * @throws {@link Gooey.UnprocessableEntityError}
     * @throws {@link Gooey.TooManyRequestsError}
     *
     * @example
     *     await client.textToMusic({
     *         textPrompt: "text_prompt"
     *     })
     */
    public async textToMusic(
        request: Gooey.Text2AudioPageRequest,
        requestOptions?: GooeyClient.RequestOptions
    ): Promise<Gooey.Text2AudioPageOutput> {
        const { exampleId, ..._body } = request;
        const _queryParams: Record<string, string | string[] | object | object[]> = {};
        if (exampleId != null) {
            _queryParams["example_id"] = exampleId;
        }

        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.environment)) ?? environments.GooeyEnvironment.Default,
                "v3/text2audio/async"
            ),
            method: "POST",
            headers: {
                Authorization: await this._getAuthorizationHeader(),
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "gooeyai",
                "X-Fern-SDK-Version": "0.0.1-beta25",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
            },
            contentType: "application/json",
            queryParameters: _queryParams,
            requestType: "json",
            body: serializers.Text2AudioPageRequest.jsonOrThrow(_body, { unrecognizedObjectKeys: "strip" }),
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.Text2AudioPageOutput.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 402:
                    throw new Gooey.PaymentRequiredError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 422:
                    throw new Gooey.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 429:
                    throw new Gooey.TooManyRequestsError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                default:
                    throw new errors.GooeyError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.GooeyError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.GooeyTimeoutError();
            case "unknown":
                throw new errors.GooeyError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * @param {File | fs.ReadStream | Blob | undefined} glossaryDocument
     * @param {Gooey.TranslateRequest} request
     * @param {GooeyClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Gooey.PaymentRequiredError}
     * @throws {@link Gooey.UnprocessableEntityError}
     * @throws {@link Gooey.TooManyRequestsError}
     *
     * @example
     *     await client.translate(fs.createReadStream("/path/to/your/file"), {})
     */
    public async translate(
        glossaryDocument: File | fs.ReadStream | Blob | undefined,
        request: Gooey.TranslateRequest,
        requestOptions?: GooeyClient.RequestOptions
    ): Promise<Gooey.TranslationPageOutput> {
        const _queryParams: Record<string, string | string[] | object | object[]> = {};
        if (request.exampleId != null) {
            _queryParams["example_id"] = request.exampleId;
        }

        const _request = await core.newFormData();
        if (request.functions != null) {
            for (const _item of request.functions) {
                await _request.append("functions", JSON.stringify(_item));
            }
        }

        if (request.variables != null) {
            await _request.append("variables", JSON.stringify(request.variables));
        }

        if (request.texts != null) {
            for (const _item of request.texts) {
                await _request.append("texts", _item);
            }
        }

        if (request.selectedModel != null) {
            await _request.append("selected_model", request.selectedModel);
        }

        if (request.translationSource != null) {
            await _request.append("translation_source", request.translationSource);
        }

        if (request.translationTarget != null) {
            await _request.append("translation_target", request.translationTarget);
        }

        if (glossaryDocument != null) {
            await _request.appendFile("glossary_document", glossaryDocument);
        }

        if (request.settings != null) {
            await _request.append("settings", JSON.stringify(request.settings));
        }

        const _maybeEncodedRequest = await _request.getRequest();
        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.environment)) ?? environments.GooeyEnvironment.Default,
                "v3/translate/async"
            ),
            method: "POST",
            headers: {
                Authorization: await this._getAuthorizationHeader(),
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "gooeyai",
                "X-Fern-SDK-Version": "0.0.1-beta25",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
                ..._maybeEncodedRequest.headers,
            },
            queryParameters: _queryParams,
            requestType: "file",
            duplex: _maybeEncodedRequest.duplex,
            body: _maybeEncodedRequest.body,
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.TranslationPageOutput.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 402:
                    throw new Gooey.PaymentRequiredError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 422:
                    throw new Gooey.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 429:
                    throw new Gooey.TooManyRequestsError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                default:
                    throw new errors.GooeyError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.GooeyError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.GooeyTimeoutError();
            case "unknown":
                throw new errors.GooeyError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * @param {File | fs.ReadStream | Blob} inputImage
     * @param {Gooey.RemixImageRequest} request
     * @param {GooeyClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Gooey.PaymentRequiredError}
     * @throws {@link Gooey.UnprocessableEntityError}
     * @throws {@link Gooey.TooManyRequestsError}
     *
     * @example
     *     await client.remixImage(fs.createReadStream("/path/to/your/file"), {})
     */
    public async remixImage(
        inputImage: File | fs.ReadStream | Blob,
        request: Gooey.RemixImageRequest,
        requestOptions?: GooeyClient.RequestOptions
    ): Promise<Gooey.Img2ImgPageOutput> {
        const _queryParams: Record<string, string | string[] | object | object[]> = {};
        if (request.exampleId != null) {
            _queryParams["example_id"] = request.exampleId;
        }

        const _request = await core.newFormData();
        if (request.functions != null) {
            for (const _item of request.functions) {
                await _request.append("functions", JSON.stringify(_item));
            }
        }

        if (request.variables != null) {
            await _request.append("variables", JSON.stringify(request.variables));
        }

        await _request.appendFile("input_image", inputImage);
        if (request.textPrompt != null) {
            await _request.append("text_prompt", request.textPrompt);
        }

        if (request.selectedModel != null) {
            await _request.append("selected_model", request.selectedModel);
        }

        if (request.selectedControlnetModel != null) {
            if (Array.isArray(request.selectedControlnetModel))
                for (const _item of request.selectedControlnetModel) {
                    await _request.append(
                        "selected_controlnet_model",
                        typeof _item === "string" ? _item : JSON.stringify(_item)
                    );
                }
        }

        if (request.negativePrompt != null) {
            await _request.append("negative_prompt", request.negativePrompt);
        }

        if (request.numOutputs != null) {
            await _request.append("num_outputs", request.numOutputs.toString());
        }

        if (request.quality != null) {
            await _request.append("quality", request.quality.toString());
        }

        if (request.outputWidth != null) {
            await _request.append("output_width", request.outputWidth.toString());
        }

        if (request.outputHeight != null) {
            await _request.append("output_height", request.outputHeight.toString());
        }

        if (request.guidanceScale != null) {
            await _request.append("guidance_scale", request.guidanceScale.toString());
        }

        if (request.promptStrength != null) {
            await _request.append("prompt_strength", request.promptStrength.toString());
        }

        if (request.controlnetConditioningScale != null) {
            for (const _item of request.controlnetConditioningScale) {
                await _request.append("controlnet_conditioning_scale", _item.toString());
            }
        }

        if (request.seed != null) {
            await _request.append("seed", request.seed.toString());
        }

        if (request.imageGuidanceScale != null) {
            await _request.append("image_guidance_scale", request.imageGuidanceScale.toString());
        }

        if (request.settings != null) {
            await _request.append("settings", JSON.stringify(request.settings));
        }

        const _maybeEncodedRequest = await _request.getRequest();
        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.environment)) ?? environments.GooeyEnvironment.Default,
                "v3/Img2Img/async"
            ),
            method: "POST",
            headers: {
                Authorization: await this._getAuthorizationHeader(),
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "gooeyai",
                "X-Fern-SDK-Version": "0.0.1-beta25",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
                ..._maybeEncodedRequest.headers,
            },
            queryParameters: _queryParams,
            requestType: "file",
            duplex: _maybeEncodedRequest.duplex,
            body: _maybeEncodedRequest.body,
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.Img2ImgPageOutput.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 402:
                    throw new Gooey.PaymentRequiredError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 422:
                    throw new Gooey.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 429:
                    throw new Gooey.TooManyRequestsError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                default:
                    throw new errors.GooeyError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.GooeyError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.GooeyTimeoutError();
            case "unknown":
                throw new errors.GooeyError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * @param {Gooey.CompareText2ImgPageRequest} request
     * @param {GooeyClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Gooey.PaymentRequiredError}
     * @throws {@link Gooey.UnprocessableEntityError}
     * @throws {@link Gooey.TooManyRequestsError}
     *
     * @example
     *     await client.textToImage({
     *         textPrompt: "text_prompt"
     *     })
     */
    public async textToImage(
        request: Gooey.CompareText2ImgPageRequest,
        requestOptions?: GooeyClient.RequestOptions
    ): Promise<Gooey.CompareText2ImgPageOutput> {
        const { exampleId, ..._body } = request;
        const _queryParams: Record<string, string | string[] | object | object[]> = {};
        if (exampleId != null) {
            _queryParams["example_id"] = exampleId;
        }

        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.environment)) ?? environments.GooeyEnvironment.Default,
                "v3/CompareText2Img/async"
            ),
            method: "POST",
            headers: {
                Authorization: await this._getAuthorizationHeader(),
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "gooeyai",
                "X-Fern-SDK-Version": "0.0.1-beta25",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
            },
            contentType: "application/json",
            queryParameters: _queryParams,
            requestType: "json",
            body: serializers.CompareText2ImgPageRequest.jsonOrThrow(_body, { unrecognizedObjectKeys: "strip" }),
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.CompareText2ImgPageOutput.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 402:
                    throw new Gooey.PaymentRequiredError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 422:
                    throw new Gooey.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 429:
                    throw new Gooey.TooManyRequestsError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                default:
                    throw new errors.GooeyError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.GooeyError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.GooeyTimeoutError();
            case "unknown":
                throw new errors.GooeyError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * @param {File | fs.ReadStream | Blob} inputImage
     * @param {Gooey.ProductImageRequest} request
     * @param {GooeyClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Gooey.PaymentRequiredError}
     * @throws {@link Gooey.UnprocessableEntityError}
     * @throws {@link Gooey.TooManyRequestsError}
     *
     * @example
     *     await client.productImage(fs.createReadStream("/path/to/your/file"), {
     *         textPrompt: "text_prompt"
     *     })
     */
    public async productImage(
        inputImage: File | fs.ReadStream | Blob,
        request: Gooey.ProductImageRequest,
        requestOptions?: GooeyClient.RequestOptions
    ): Promise<Gooey.ObjectInpaintingPageOutput> {
        const _queryParams: Record<string, string | string[] | object | object[]> = {};
        if (request.exampleId != null) {
            _queryParams["example_id"] = request.exampleId;
        }

        const _request = await core.newFormData();
        if (request.functions != null) {
            for (const _item of request.functions) {
                await _request.append("functions", JSON.stringify(_item));
            }
        }

        if (request.variables != null) {
            await _request.append("variables", JSON.stringify(request.variables));
        }

        await _request.appendFile("input_image", inputImage);
        await _request.append("text_prompt", request.textPrompt);
        if (request.objScale != null) {
            await _request.append("obj_scale", request.objScale.toString());
        }

        if (request.objPosX != null) {
            await _request.append("obj_pos_x", request.objPosX.toString());
        }

        if (request.objPosY != null) {
            await _request.append("obj_pos_y", request.objPosY.toString());
        }

        if (request.maskThreshold != null) {
            await _request.append("mask_threshold", request.maskThreshold.toString());
        }

        if (request.selectedModel != null) {
            await _request.append("selected_model", request.selectedModel);
        }

        if (request.negativePrompt != null) {
            await _request.append("negative_prompt", request.negativePrompt);
        }

        if (request.numOutputs != null) {
            await _request.append("num_outputs", request.numOutputs.toString());
        }

        if (request.quality != null) {
            await _request.append("quality", request.quality.toString());
        }

        if (request.outputWidth != null) {
            await _request.append("output_width", request.outputWidth.toString());
        }

        if (request.outputHeight != null) {
            await _request.append("output_height", request.outputHeight.toString());
        }

        if (request.guidanceScale != null) {
            await _request.append("guidance_scale", request.guidanceScale.toString());
        }

        if (request.sd2Upscaling != null) {
            await _request.append("sd_2_upscaling", request.sd2Upscaling.toString());
        }

        if (request.seed != null) {
            await _request.append("seed", request.seed.toString());
        }

        if (request.settings != null) {
            await _request.append("settings", JSON.stringify(request.settings));
        }

        const _maybeEncodedRequest = await _request.getRequest();
        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.environment)) ?? environments.GooeyEnvironment.Default,
                "v3/ObjectInpainting/async"
            ),
            method: "POST",
            headers: {
                Authorization: await this._getAuthorizationHeader(),
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "gooeyai",
                "X-Fern-SDK-Version": "0.0.1-beta25",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
                ..._maybeEncodedRequest.headers,
            },
            queryParameters: _queryParams,
            requestType: "file",
            duplex: _maybeEncodedRequest.duplex,
            body: _maybeEncodedRequest.body,
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.ObjectInpaintingPageOutput.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 402:
                    throw new Gooey.PaymentRequiredError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 422:
                    throw new Gooey.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 429:
                    throw new Gooey.TooManyRequestsError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                default:
                    throw new errors.GooeyError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.GooeyError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.GooeyTimeoutError();
            case "unknown":
                throw new errors.GooeyError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * @param {File | fs.ReadStream | Blob} inputImage
     * @param {Gooey.PortraitRequest} request
     * @param {GooeyClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Gooey.PaymentRequiredError}
     * @throws {@link Gooey.UnprocessableEntityError}
     * @throws {@link Gooey.TooManyRequestsError}
     *
     * @example
     *     await client.portrait(fs.createReadStream("/path/to/your/file"), {
     *         textPrompt: "text_prompt"
     *     })
     */
    public async portrait(
        inputImage: File | fs.ReadStream | Blob,
        request: Gooey.PortraitRequest,
        requestOptions?: GooeyClient.RequestOptions
    ): Promise<Gooey.FaceInpaintingPageOutput> {
        const _queryParams: Record<string, string | string[] | object | object[]> = {};
        if (request.exampleId != null) {
            _queryParams["example_id"] = request.exampleId;
        }

        const _request = await core.newFormData();
        if (request.functions != null) {
            for (const _item of request.functions) {
                await _request.append("functions", JSON.stringify(_item));
            }
        }

        if (request.variables != null) {
            await _request.append("variables", JSON.stringify(request.variables));
        }

        await _request.appendFile("input_image", inputImage);
        await _request.append("text_prompt", request.textPrompt);
        if (request.faceScale != null) {
            await _request.append("face_scale", request.faceScale.toString());
        }

        if (request.facePosX != null) {
            await _request.append("face_pos_x", request.facePosX.toString());
        }

        if (request.facePosY != null) {
            await _request.append("face_pos_y", request.facePosY.toString());
        }

        if (request.selectedModel != null) {
            await _request.append("selected_model", request.selectedModel);
        }

        if (request.negativePrompt != null) {
            await _request.append("negative_prompt", request.negativePrompt);
        }

        if (request.numOutputs != null) {
            await _request.append("num_outputs", request.numOutputs.toString());
        }

        if (request.quality != null) {
            await _request.append("quality", request.quality.toString());
        }

        if (request.upscaleFactor != null) {
            await _request.append("upscale_factor", request.upscaleFactor.toString());
        }

        if (request.outputWidth != null) {
            await _request.append("output_width", request.outputWidth.toString());
        }

        if (request.outputHeight != null) {
            await _request.append("output_height", request.outputHeight.toString());
        }

        if (request.guidanceScale != null) {
            await _request.append("guidance_scale", request.guidanceScale.toString());
        }

        if (request.seed != null) {
            await _request.append("seed", request.seed.toString());
        }

        if (request.settings != null) {
            await _request.append("settings", JSON.stringify(request.settings));
        }

        const _maybeEncodedRequest = await _request.getRequest();
        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.environment)) ?? environments.GooeyEnvironment.Default,
                "v3/FaceInpainting/async"
            ),
            method: "POST",
            headers: {
                Authorization: await this._getAuthorizationHeader(),
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "gooeyai",
                "X-Fern-SDK-Version": "0.0.1-beta25",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
                ..._maybeEncodedRequest.headers,
            },
            queryParameters: _queryParams,
            requestType: "file",
            duplex: _maybeEncodedRequest.duplex,
            body: _maybeEncodedRequest.body,
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.FaceInpaintingPageOutput.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 402:
                    throw new Gooey.PaymentRequiredError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 422:
                    throw new Gooey.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 429:
                    throw new Gooey.TooManyRequestsError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                default:
                    throw new errors.GooeyError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.GooeyError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.GooeyTimeoutError();
            case "unknown":
                throw new errors.GooeyError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * @param {Gooey.EmailFaceInpaintingPageRequest} request
     * @param {GooeyClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Gooey.PaymentRequiredError}
     * @throws {@link Gooey.UnprocessableEntityError}
     * @throws {@link Gooey.TooManyRequestsError}
     *
     * @example
     *     await client.imageFromEmail({
     *         emailAddress: "sean@dara.network",
     *         textPrompt: "winter's day in paris"
     *     })
     */
    public async imageFromEmail(
        request: Gooey.EmailFaceInpaintingPageRequest,
        requestOptions?: GooeyClient.RequestOptions
    ): Promise<Gooey.EmailFaceInpaintingPageOutput> {
        const { exampleId, ..._body } = request;
        const _queryParams: Record<string, string | string[] | object | object[]> = {};
        if (exampleId != null) {
            _queryParams["example_id"] = exampleId;
        }

        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.environment)) ?? environments.GooeyEnvironment.Default,
                "v3/EmailFaceInpainting/async"
            ),
            method: "POST",
            headers: {
                Authorization: await this._getAuthorizationHeader(),
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "gooeyai",
                "X-Fern-SDK-Version": "0.0.1-beta25",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
            },
            contentType: "application/json",
            queryParameters: _queryParams,
            requestType: "json",
            body: serializers.EmailFaceInpaintingPageRequest.jsonOrThrow(_body, { unrecognizedObjectKeys: "strip" }),
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.EmailFaceInpaintingPageOutput.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 402:
                    throw new Gooey.PaymentRequiredError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 422:
                    throw new Gooey.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 429:
                    throw new Gooey.TooManyRequestsError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                default:
                    throw new errors.GooeyError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.GooeyError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.GooeyTimeoutError();
            case "unknown":
                throw new errors.GooeyError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * @param {Gooey.GoogleImageGenPageRequest} request
     * @param {GooeyClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Gooey.PaymentRequiredError}
     * @throws {@link Gooey.UnprocessableEntityError}
     * @throws {@link Gooey.TooManyRequestsError}
     *
     * @example
     *     await client.imageFromWebSearch({
     *         searchQuery: "search_query",
     *         textPrompt: "text_prompt"
     *     })
     */
    public async imageFromWebSearch(
        request: Gooey.GoogleImageGenPageRequest,
        requestOptions?: GooeyClient.RequestOptions
    ): Promise<Gooey.GoogleImageGenPageOutput> {
        const { exampleId, ..._body } = request;
        const _queryParams: Record<string, string | string[] | object | object[]> = {};
        if (exampleId != null) {
            _queryParams["example_id"] = exampleId;
        }

        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.environment)) ?? environments.GooeyEnvironment.Default,
                "v3/GoogleImageGen/async"
            ),
            method: "POST",
            headers: {
                Authorization: await this._getAuthorizationHeader(),
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "gooeyai",
                "X-Fern-SDK-Version": "0.0.1-beta25",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
            },
            contentType: "application/json",
            queryParameters: _queryParams,
            requestType: "json",
            body: serializers.GoogleImageGenPageRequest.jsonOrThrow(_body, { unrecognizedObjectKeys: "strip" }),
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.GoogleImageGenPageOutput.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 402:
                    throw new Gooey.PaymentRequiredError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 422:
                    throw new Gooey.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 429:
                    throw new Gooey.TooManyRequestsError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                default:
                    throw new errors.GooeyError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.GooeyError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.GooeyTimeoutError();
            case "unknown":
                throw new errors.GooeyError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * @param {File | fs.ReadStream | Blob} inputImage
     * @param {Gooey.RemoveBackgroundRequest} request
     * @param {GooeyClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Gooey.PaymentRequiredError}
     * @throws {@link Gooey.UnprocessableEntityError}
     * @throws {@link Gooey.TooManyRequestsError}
     *
     * @example
     *     await client.removeBackground(fs.createReadStream("/path/to/your/file"), {})
     */
    public async removeBackground(
        inputImage: File | fs.ReadStream | Blob,
        request: Gooey.RemoveBackgroundRequest,
        requestOptions?: GooeyClient.RequestOptions
    ): Promise<Gooey.ImageSegmentationPageOutput> {
        const _queryParams: Record<string, string | string[] | object | object[]> = {};
        if (request.exampleId != null) {
            _queryParams["example_id"] = request.exampleId;
        }

        const _request = await core.newFormData();
        if (request.functions != null) {
            for (const _item of request.functions) {
                await _request.append("functions", JSON.stringify(_item));
            }
        }

        if (request.variables != null) {
            await _request.append("variables", JSON.stringify(request.variables));
        }

        await _request.appendFile("input_image", inputImage);
        if (request.selectedModel != null) {
            await _request.append("selected_model", request.selectedModel);
        }

        if (request.maskThreshold != null) {
            await _request.append("mask_threshold", request.maskThreshold.toString());
        }

        if (request.rectPersepectiveTransform != null) {
            await _request.append("rect_persepective_transform", request.rectPersepectiveTransform.toString());
        }

        if (request.reflectionOpacity != null) {
            await _request.append("reflection_opacity", request.reflectionOpacity.toString());
        }

        if (request.objScale != null) {
            await _request.append("obj_scale", request.objScale.toString());
        }

        if (request.objPosX != null) {
            await _request.append("obj_pos_x", request.objPosX.toString());
        }

        if (request.objPosY != null) {
            await _request.append("obj_pos_y", request.objPosY.toString());
        }

        if (request.settings != null) {
            await _request.append("settings", JSON.stringify(request.settings));
        }

        const _maybeEncodedRequest = await _request.getRequest();
        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.environment)) ?? environments.GooeyEnvironment.Default,
                "v3/ImageSegmentation/async"
            ),
            method: "POST",
            headers: {
                Authorization: await this._getAuthorizationHeader(),
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "gooeyai",
                "X-Fern-SDK-Version": "0.0.1-beta25",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
                ..._maybeEncodedRequest.headers,
            },
            queryParameters: _queryParams,
            requestType: "file",
            duplex: _maybeEncodedRequest.duplex,
            body: _maybeEncodedRequest.body,
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.ImageSegmentationPageOutput.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 402:
                    throw new Gooey.PaymentRequiredError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 422:
                    throw new Gooey.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 429:
                    throw new Gooey.TooManyRequestsError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                default:
                    throw new errors.GooeyError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.GooeyError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.GooeyTimeoutError();
            case "unknown":
                throw new errors.GooeyError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * @param {File | fs.ReadStream | Blob | undefined} inputImage
     * @param {File | fs.ReadStream | Blob | undefined} inputVideo
     * @param {Gooey.UpscaleRequest} request
     * @param {GooeyClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Gooey.PaymentRequiredError}
     * @throws {@link Gooey.UnprocessableEntityError}
     * @throws {@link Gooey.TooManyRequestsError}
     *
     * @example
     *     await client.upscale(fs.createReadStream("/path/to/your/file"), fs.createReadStream("/path/to/your/file"), {
     *         scale: 1
     *     })
     */
    public async upscale(
        inputImage: File | fs.ReadStream | Blob | undefined,
        inputVideo: File | fs.ReadStream | Blob | undefined,
        request: Gooey.UpscaleRequest,
        requestOptions?: GooeyClient.RequestOptions
    ): Promise<Gooey.CompareUpscalerPageOutput> {
        const _queryParams: Record<string, string | string[] | object | object[]> = {};
        if (request.exampleId != null) {
            _queryParams["example_id"] = request.exampleId;
        }

        const _request = await core.newFormData();
        if (request.functions != null) {
            for (const _item of request.functions) {
                await _request.append("functions", JSON.stringify(_item));
            }
        }

        if (request.variables != null) {
            await _request.append("variables", JSON.stringify(request.variables));
        }

        if (inputImage != null) {
            await _request.appendFile("input_image", inputImage);
        }

        if (inputVideo != null) {
            await _request.appendFile("input_video", inputVideo);
        }

        await _request.append("scale", request.scale.toString());
        if (request.selectedModels != null) {
            for (const _item of request.selectedModels) {
                await _request.append("selected_models", _item);
            }
        }

        if (request.selectedBgModel != null) {
            await _request.append("selected_bg_model", request.selectedBgModel);
        }

        if (request.settings != null) {
            await _request.append("settings", JSON.stringify(request.settings));
        }

        const _maybeEncodedRequest = await _request.getRequest();
        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.environment)) ?? environments.GooeyEnvironment.Default,
                "v3/compare-ai-upscalers/async"
            ),
            method: "POST",
            headers: {
                Authorization: await this._getAuthorizationHeader(),
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "gooeyai",
                "X-Fern-SDK-Version": "0.0.1-beta25",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
                ..._maybeEncodedRequest.headers,
            },
            queryParameters: _queryParams,
            requestType: "file",
            duplex: _maybeEncodedRequest.duplex,
            body: _maybeEncodedRequest.body,
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.CompareUpscalerPageOutput.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 402:
                    throw new Gooey.PaymentRequiredError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 422:
                    throw new Gooey.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 429:
                    throw new Gooey.TooManyRequestsError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                default:
                    throw new errors.GooeyError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.GooeyError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.GooeyTimeoutError();
            case "unknown":
                throw new errors.GooeyError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * @param {Gooey.EmbeddingsPageRequest} request
     * @param {GooeyClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Gooey.PaymentRequiredError}
     * @throws {@link Gooey.UnprocessableEntityError}
     * @throws {@link Gooey.TooManyRequestsError}
     *
     * @example
     *     await client.embed({
     *         texts: ["texts"]
     *     })
     */
    public async embed(
        request: Gooey.EmbeddingsPageRequest,
        requestOptions?: GooeyClient.RequestOptions
    ): Promise<Gooey.EmbeddingsPageOutput> {
        const { exampleId, ..._body } = request;
        const _queryParams: Record<string, string | string[] | object | object[]> = {};
        if (exampleId != null) {
            _queryParams["example_id"] = exampleId;
        }

        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.environment)) ?? environments.GooeyEnvironment.Default,
                "v3/embeddings/async"
            ),
            method: "POST",
            headers: {
                Authorization: await this._getAuthorizationHeader(),
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "gooeyai",
                "X-Fern-SDK-Version": "0.0.1-beta25",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
            },
            contentType: "application/json",
            queryParameters: _queryParams,
            requestType: "json",
            body: serializers.EmbeddingsPageRequest.jsonOrThrow(_body, { unrecognizedObjectKeys: "strip" }),
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.EmbeddingsPageOutput.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 402:
                    throw new Gooey.PaymentRequiredError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 422:
                    throw new Gooey.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 429:
                    throw new Gooey.TooManyRequestsError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                default:
                    throw new errors.GooeyError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.GooeyError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.GooeyTimeoutError();
            case "unknown":
                throw new errors.GooeyError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * @param {Gooey.RelatedQnADocPageRequest} request
     * @param {GooeyClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Gooey.PaymentRequiredError}
     * @throws {@link Gooey.UnprocessableEntityError}
     * @throws {@link Gooey.TooManyRequestsError}
     *
     * @example
     *     await client.seoPeopleAlsoAskDoc({
     *         searchQuery: "search_query"
     *     })
     */
    public async seoPeopleAlsoAskDoc(
        request: Gooey.RelatedQnADocPageRequest,
        requestOptions?: GooeyClient.RequestOptions
    ): Promise<Gooey.RelatedQnADocPageOutput> {
        const { exampleId, ..._body } = request;
        const _queryParams: Record<string, string | string[] | object | object[]> = {};
        if (exampleId != null) {
            _queryParams["example_id"] = exampleId;
        }

        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.environment)) ?? environments.GooeyEnvironment.Default,
                "v3/related-qna-maker-doc/async"
            ),
            method: "POST",
            headers: {
                Authorization: await this._getAuthorizationHeader(),
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "gooeyai",
                "X-Fern-SDK-Version": "0.0.1-beta25",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
            },
            contentType: "application/json",
            queryParameters: _queryParams,
            requestType: "json",
            body: serializers.RelatedQnADocPageRequest.jsonOrThrow(_body, { unrecognizedObjectKeys: "strip" }),
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.RelatedQnADocPageOutput.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 402:
                    throw new Gooey.PaymentRequiredError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 422:
                    throw new Gooey.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                case 429:
                    throw new Gooey.TooManyRequestsError(
                        serializers.GenericErrorResponse.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        })
                    );
                default:
                    throw new errors.GooeyError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.GooeyError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.GooeyTimeoutError();
            case "unknown":
                throw new errors.GooeyError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * @param {GooeyClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @example
     *     await client.getBalance()
     */
    public async getBalance(requestOptions?: GooeyClient.RequestOptions): Promise<Gooey.BalanceResponse> {
        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.environment)) ?? environments.GooeyEnvironment.Default,
                "v1/balance/"
            ),
            method: "GET",
            headers: {
                Authorization: await this._getAuthorizationHeader(),
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "gooeyai",
                "X-Fern-SDK-Version": "0.0.1-beta25",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
            },
            contentType: "application/json",
            requestType: "json",
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.BalanceResponse.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            throw new errors.GooeyError({
                statusCode: _response.error.statusCode,
                body: _response.error.body,
            });
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.GooeyError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.GooeyTimeoutError();
            case "unknown":
                throw new errors.GooeyError({
                    message: _response.error.errorMessage,
                });
        }
    }

    protected _copilot: Copilot | undefined;

    public get copilot(): Copilot {
        return (this._copilot ??= new Copilot(this._options));
    }

    protected async _getAuthorizationHeader(): Promise<string> {
        const bearer = (await core.Supplier.get(this._options.apiKey)) ?? process?.env["GOOEY_API_KEY"];
        if (bearer == null) {
            throw new errors.GooeyError({
                message: "Please specify GOOEY_API_KEY when instantiating the client.",
            });
        }

        return `Bearer ${bearer}`;
    }
}