@coinbase/cdp-sdk 1.51.2 → 1.52.0

package/src/_vendor/api/errors/NotFoundError.ts

@@ -0,0 +1,22 @@
+// This file was auto-generated by Fern from our API Definition.
+
+import type * as core from "../../core/index.js";
+import * as errors from "../../errors/index.js";
+import type * as CoinbaseApi from "../index.js";
+
+export class NotFoundError extends errors.CoinbaseApiError {
+    constructor(body: CoinbaseApi.Error_, rawResponse?: core.RawResponse) {
+        super({
+            message: "NotFoundError",
+            statusCode: 404,
+            body: body,
+            rawResponse: rawResponse,
+        });
+        Object.setPrototypeOf(this, new.target.prototype);
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+
+        this.name = this.constructor.name;
+    }
+}

package/src/_vendor/api/errors/ServiceUnavailableError.ts

@@ -0,0 +1,22 @@
+// This file was auto-generated by Fern from our API Definition.
+
+import type * as core from "../../core/index.js";
+import * as errors from "../../errors/index.js";
+import type * as CoinbaseApi from "../index.js";
+
+export class ServiceUnavailableError extends errors.CoinbaseApiError {
+    constructor(body: CoinbaseApi.Error_, rawResponse?: core.RawResponse) {
+        super({
+            message: "ServiceUnavailableError",
+            statusCode: 503,
+            body: body,
+            rawResponse: rawResponse,
+        });
+        Object.setPrototypeOf(this, new.target.prototype);
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+
+        this.name = this.constructor.name;
+    }
+}

package/src/_vendor/api/errors/TooManyRequestsError.ts

@@ -0,0 +1,22 @@
+// This file was auto-generated by Fern from our API Definition.
+
+import type * as core from "../../core/index.js";
+import * as errors from "../../errors/index.js";
+import type * as CoinbaseApi from "../index.js";
+
+export class TooManyRequestsError extends errors.CoinbaseApiError {
+    constructor(body: CoinbaseApi.Error_, rawResponse?: core.RawResponse) {
+        super({
+            message: "TooManyRequestsError",
+            statusCode: 429,
+            body: body,
+            rawResponse: rawResponse,
+        });
+        Object.setPrototypeOf(this, new.target.prototype);
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+
+        this.name = this.constructor.name;
+    }
+}

package/src/_vendor/api/errors/UnauthorizedError.ts

@@ -0,0 +1,22 @@
+// This file was auto-generated by Fern from our API Definition.
+
+import type * as core from "../../core/index.js";
+import * as errors from "../../errors/index.js";
+import type * as CoinbaseApi from "../index.js";
+
+export class UnauthorizedError extends errors.CoinbaseApiError {
+    constructor(body: CoinbaseApi.Error_, rawResponse?: core.RawResponse) {
+        super({
+            message: "UnauthorizedError",
+            statusCode: 401,
+            body: body,
+            rawResponse: rawResponse,
+        });
+        Object.setPrototypeOf(this, new.target.prototype);
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+
+        this.name = this.constructor.name;
+    }
+}

package/src/_vendor/api/errors/UnprocessableEntityError.ts

@@ -0,0 +1,22 @@
+// This file was auto-generated by Fern from our API Definition.
+
+import type * as core from "../../core/index.js";
+import * as errors from "../../errors/index.js";
+import type * as CoinbaseApi from "../index.js";
+
+export class UnprocessableEntityError extends errors.CoinbaseApiError {
+    constructor(body: CoinbaseApi.Error_, rawResponse?: core.RawResponse) {
+        super({
+            message: "UnprocessableEntityError",
+            statusCode: 422,
+            body: body,
+            rawResponse: rawResponse,
+        });
+        Object.setPrototypeOf(this, new.target.prototype);
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+
+        this.name = this.constructor.name;
+    }
+}

package/src/_vendor/api/errors/index.ts

@@ -0,0 +1,9 @@
+export * from "./BadGatewayError.js";
+export * from "./BadRequestError.js";
+export * from "./ForbiddenError.js";
+export * from "./InternalServerError.js";
+export * from "./NotFoundError.js";
+export * from "./ServiceUnavailableError.js";
+export * from "./TooManyRequestsError.js";
+export * from "./UnauthorizedError.js";
+export * from "./UnprocessableEntityError.js";

package/src/_vendor/api/index.ts

@@ -0,0 +1,3 @@
+export * from "./errors/index.js";
+export * from "./resources/index.js";
+export * from "./types/index.js";

package/src/_vendor/api/resources/accounts/client/Client.ts

@@ -0,0 +1,558 @@
+/**
+ * @module Accounts
+ */
+
+// This file was auto-generated by Fern from our API Definition.
+
+import type { BaseClientOptions, BaseRequestOptions } from "../../../../BaseClient.js";
+import { type NormalizedClientOptionsWithAuth, normalizeClientOptionsWithAuth } from "../../../../BaseClient.js";
+import { mergeHeaders, mergeOnlyDefinedHeaders } from "../../../../core/headers.js";
+import * as core from "../../../../core/index.js";
+import * as environments from "../../../../environments.js";
+import { handleNonStatusCodeError } from "../../../../errors/handleNonStatusCodeError.js";
+import * as errors from "../../../../errors/index.js";
+import * as CoinbaseApi from "../../../index.js";
+
+export declare namespace AccountsClient {
+    export type Options = BaseClientOptions;
+
+    export interface RequestOptions extends BaseRequestOptions {}
+}
+
+/**
+ * The Accounts APIs enable developers to create and manage accounts for their Entity. An Account is a container that holds assets and can be used for transacting. Accounts can be of different types including entity accounts, prime accounts, and business accounts. Support for Customer-owned accounts is in development.
+ */
+export class AccountsClient {
+    protected readonly _options: NormalizedClientOptionsWithAuth<AccountsClient.Options>;
+
+    constructor(options: AccountsClient.Options) {
+        this._options = normalizeClientOptionsWithAuth(options);
+    }
+
+    /**
+     * List all accounts. The API will return all accounts that the API Key has Permissions to access. You can filter the results by using query parameters, which will be treated as a single conjunction (i.e. AND). Results are sorted by creation date in descending order (newest first).
+     *
+     * @param {CoinbaseApi.ListAccountsRequest} request
+     * @param {AccountsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws CoinbaseApi.BadRequestError
+     *
+     * @example
+     * ```ts
+     * await client.accounts.listAccounts({
+     *     pageToken: "eyJsYXN0X2lkIjogImFiYzEyMyIsICJ0aW1lc3RhbXAiOiAxNzA3ODIzNzAxfQ=="
+     * })
+     * ```
+     */
+    public listAccounts(
+        request: CoinbaseApi.ListAccountsRequest = {},
+        requestOptions?: AccountsClient.RequestOptions,
+    ): core.HttpResponsePromise<CoinbaseApi.ListAccountsResponse> {
+        return core.HttpResponsePromise.fromPromise(this.__listAccounts(request, requestOptions));
+    }
+
+    private async __listAccounts(
+        request: CoinbaseApi.ListAccountsRequest = {},
+        requestOptions?: AccountsClient.RequestOptions,
+    ): Promise<core.WithRawResponse<CoinbaseApi.ListAccountsResponse>> {
+        const _metadata: core.EndpointMetadata = {
+            security: [{ apiKeyAuth: [] }],
+            method: "GET",
+            path: "v2/accounts",
+            operationId: "endpoint_accounts.listAccounts",
+        };
+        const { pageSize, pageToken, type: type_ } = request;
+        const _queryParams: Record<string, unknown> = {
+            pageSize,
+            pageToken,
+            type: type_ != null ? type_ : undefined,
+        };
+        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest({
+            endpointMetadata: _metadata,
+            clientOptions: this._options,
+            request: {
+                method: "GET",
+            },
+        });
+        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
+            _authRequest.headers,
+            this._options?.headers,
+            requestOptions?.headers,
+        );
+        const _response = await core.fetcher({
+            url: core.url.join(
+                (await core.Supplier.get(this._options.baseUrl)) ??
+                    (await core.Supplier.get(this._options.environment)) ??
+                    environments.CoinbaseApiEnvironment.Default,
+                "v2/accounts",
+            ),
+            method: "GET",
+            headers: _headers,
+            queryString: core.url
+                .queryBuilder()
+                .addMany(_queryParams)
+                .mergeAdditional(requestOptions?.queryParams)
+                .build(),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            endpointMetadata: _metadata,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return { data: _response.body as CoinbaseApi.ListAccountsResponse, rawResponse: _response.rawResponse };
+        }
+
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 400:
+                    throw new CoinbaseApi.BadRequestError(
+                        _response.error.body as CoinbaseApi.Error_,
+                        _response.rawResponse,
+                    );
+                default:
+                    throw new errors.CoinbaseApiError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v2/accounts");
+    }
+
+    /**
+     * Create an account for your Entity. Support for creating Customer-owned accounts is in development.
+     *
+     * @param {CoinbaseApi.CreateAccountRequest} request
+     * @param {AccountsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws CoinbaseApi.BadRequestError
+     * @throws CoinbaseApi.UnprocessableEntityError
+     * @throws CoinbaseApi.ServiceUnavailableError
+     *
+     * @example
+     * ```ts
+     * await client.accounts.createAccount({
+     *     idempotencyKey: "8e03978e-40d5-43e8-bc93-6894a57f9324",
+     *     name: "My Business Account"
+     * })
+     * ```
+     */
+    public createAccount(
+        request: CoinbaseApi.CreateAccountRequest = {},
+        requestOptions?: AccountsClient.RequestOptions,
+    ): core.HttpResponsePromise<CoinbaseApi.Account> {
+        return core.HttpResponsePromise.fromPromise(this.__createAccount(request, requestOptions));
+    }
+
+    private async __createAccount(
+        request: CoinbaseApi.CreateAccountRequest = {},
+        requestOptions?: AccountsClient.RequestOptions,
+    ): Promise<core.WithRawResponse<CoinbaseApi.Account>> {
+        const _metadata: core.EndpointMetadata = {
+            security: [{ apiKeyAuth: [] }],
+            method: "POST",
+            path: "v2/accounts",
+            operationId: "endpoint_accounts.createAccount",
+            headers: ["X-Idempotency-Key"],
+        };
+        const { idempotencyKey, ..._body } = request;
+        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest({
+            endpointMetadata: _metadata,
+            clientOptions: this._options,
+            request: {
+                method: "POST",
+                body: _body,
+            },
+        });
+        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
+            _authRequest.headers,
+            this._options?.headers,
+            mergeOnlyDefinedHeaders({ "X-Idempotency-Key": idempotencyKey }),
+            requestOptions?.headers,
+        );
+        const _response = await core.fetcher({
+            url: core.url.join(
+                (await core.Supplier.get(this._options.baseUrl)) ??
+                    (await core.Supplier.get(this._options.environment)) ??
+                    environments.CoinbaseApiEnvironment.Default,
+                "v2/accounts",
+            ),
+            method: "POST",
+            headers: _headers,
+            contentType: "application/json",
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            requestType: "json",
+            body: _body,
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            endpointMetadata: _metadata,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return { data: _response.body as CoinbaseApi.Account, rawResponse: _response.rawResponse };
+        }
+
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 400:
+                    throw new CoinbaseApi.BadRequestError(
+                        _response.error.body as CoinbaseApi.Error_,
+                        _response.rawResponse,
+                    );
+                case 422:
+                    throw new CoinbaseApi.UnprocessableEntityError(
+                        _response.error.body as CoinbaseApi.Error_,
+                        _response.rawResponse,
+                    );
+                case 503:
+                    throw new CoinbaseApi.ServiceUnavailableError(
+                        _response.error.body as CoinbaseApi.Error_,
+                        _response.rawResponse,
+                    );
+                default:
+                    throw new errors.CoinbaseApiError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/v2/accounts");
+    }
+
+    /**
+     * Get an account by its ID.
+     *
+     * @param {CoinbaseApi.GetAccountByIdRequest} request
+     * @param {AccountsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws CoinbaseApi.BadRequestError
+     * @throws CoinbaseApi.NotFoundError
+     *
+     * @example
+     * ```ts
+     * await client.accounts.getAccountById({
+     *     accountId: "account_af2937b0-9846-4fe7-bfe9-ccc22d935114"
+     * })
+     * ```
+     */
+    public getAccountById(
+        request: CoinbaseApi.GetAccountByIdRequest,
+        requestOptions?: AccountsClient.RequestOptions,
+    ): core.HttpResponsePromise<CoinbaseApi.Account> {
+        return core.HttpResponsePromise.fromPromise(this.__getAccountById(request, requestOptions));
+    }
+
+    private async __getAccountById(
+        request: CoinbaseApi.GetAccountByIdRequest,
+        requestOptions?: AccountsClient.RequestOptions,
+    ): Promise<core.WithRawResponse<CoinbaseApi.Account>> {
+        const _metadata: core.EndpointMetadata = {
+            security: [{ apiKeyAuth: [] }],
+            method: "GET",
+            path: "v2/accounts/{accountId}",
+            operationId: "endpoint_accounts.getAccountById",
+        };
+        const { accountId } = request;
+        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest({
+            endpointMetadata: _metadata,
+            clientOptions: this._options,
+            request: {
+                method: "GET",
+            },
+        });
+        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
+            _authRequest.headers,
+            this._options?.headers,
+            requestOptions?.headers,
+        );
+        const _response = await core.fetcher({
+            url: core.url.join(
+                (await core.Supplier.get(this._options.baseUrl)) ??
+                    (await core.Supplier.get(this._options.environment)) ??
+                    environments.CoinbaseApiEnvironment.Default,
+                `v2/accounts/${core.url.encodePathParam(accountId)}`,
+            ),
+            method: "GET",
+            headers: _headers,
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            endpointMetadata: _metadata,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return { data: _response.body as CoinbaseApi.Account, rawResponse: _response.rawResponse };
+        }
+
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 400:
+                    throw new CoinbaseApi.BadRequestError(
+                        _response.error.body as CoinbaseApi.Error_,
+                        _response.rawResponse,
+                    );
+                case 404:
+                    throw new CoinbaseApi.NotFoundError(
+                        _response.error.body as CoinbaseApi.Error_,
+                        _response.rawResponse,
+                    );
+                default:
+                    throw new errors.CoinbaseApiError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v2/accounts/{accountId}");
+    }
+
+    /**
+     * List the balances for an account. Results are sorted by native-fiat equivalent balance in descending order.
+     *
+     * @param {CoinbaseApi.ListBalancesRequest} request
+     * @param {AccountsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws CoinbaseApi.BadRequestError
+     * @throws CoinbaseApi.UnauthorizedError
+     * @throws CoinbaseApi.NotFoundError
+     * @throws CoinbaseApi.InternalServerError
+     * @throws CoinbaseApi.ServiceUnavailableError
+     *
+     * @example
+     * ```ts
+     * await client.accounts.listBalances({
+     *     accountId: "account_af2937b0-9846-4fe7-bfe9-ccc22d935114",
+     *     pageToken: "eyJsYXN0X2lkIjogImFiYzEyMyIsICJ0aW1lc3RhbXAiOiAxNzA3ODIzNzAxfQ=="
+     * })
+     * ```
+     */
+    public listBalances(
+        request: CoinbaseApi.ListBalancesRequest,
+        requestOptions?: AccountsClient.RequestOptions,
+    ): core.HttpResponsePromise<CoinbaseApi.ListBalancesResponse> {
+        return core.HttpResponsePromise.fromPromise(this.__listBalances(request, requestOptions));
+    }
+
+    private async __listBalances(
+        request: CoinbaseApi.ListBalancesRequest,
+        requestOptions?: AccountsClient.RequestOptions,
+    ): Promise<core.WithRawResponse<CoinbaseApi.ListBalancesResponse>> {
+        const _metadata: core.EndpointMetadata = {
+            security: [{ apiKeyAuth: [] }],
+            method: "GET",
+            path: "v2/accounts/{accountId}/balances",
+            operationId: "endpoint_accounts.listBalances",
+        };
+        const { accountId, pageSize, pageToken } = request;
+        const _queryParams: Record<string, unknown> = {
+            pageSize,
+            pageToken,
+        };
+        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest({
+            endpointMetadata: _metadata,
+            clientOptions: this._options,
+            request: {
+                method: "GET",
+            },
+        });
+        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
+            _authRequest.headers,
+            this._options?.headers,
+            requestOptions?.headers,
+        );
+        const _response = await core.fetcher({
+            url: core.url.join(
+                (await core.Supplier.get(this._options.baseUrl)) ??
+                    (await core.Supplier.get(this._options.environment)) ??
+                    environments.CoinbaseApiEnvironment.Default,
+                `v2/accounts/${core.url.encodePathParam(accountId)}/balances`,
+            ),
+            method: "GET",
+            headers: _headers,
+            queryString: core.url
+                .queryBuilder()
+                .addMany(_queryParams)
+                .mergeAdditional(requestOptions?.queryParams)
+                .build(),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            endpointMetadata: _metadata,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return { data: _response.body as CoinbaseApi.ListBalancesResponse, rawResponse: _response.rawResponse };
+        }
+
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 400:
+                    throw new CoinbaseApi.BadRequestError(
+                        _response.error.body as CoinbaseApi.Error_,
+                        _response.rawResponse,
+                    );
+                case 401:
+                    throw new CoinbaseApi.UnauthorizedError(
+                        _response.error.body as CoinbaseApi.Error_,
+                        _response.rawResponse,
+                    );
+                case 404:
+                    throw new CoinbaseApi.NotFoundError(
+                        _response.error.body as CoinbaseApi.Error_,
+                        _response.rawResponse,
+                    );
+                case 500:
+                    throw new CoinbaseApi.InternalServerError(
+                        _response.error.body as CoinbaseApi.Error_,
+                        _response.rawResponse,
+                    );
+                case 503:
+                    throw new CoinbaseApi.ServiceUnavailableError(
+                        _response.error.body as CoinbaseApi.Error_,
+                        _response.rawResponse,
+                    );
+                default:
+                    throw new errors.CoinbaseApiError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+
+        return handleNonStatusCodeError(
+            _response.error,
+            _response.rawResponse,
+            "GET",
+            "/v2/accounts/{accountId}/balances",
+        );
+    }
+
+    /**
+     * Get the balance for an account by asset.
+     *
+     * @param {CoinbaseApi.GetBalanceByAssetRequest} request
+     * @param {AccountsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws CoinbaseApi.BadRequestError
+     * @throws CoinbaseApi.UnauthorizedError
+     * @throws CoinbaseApi.NotFoundError
+     * @throws CoinbaseApi.InternalServerError
+     * @throws CoinbaseApi.ServiceUnavailableError
+     *
+     * @example
+     * ```ts
+     * await client.accounts.getBalanceByAsset({
+     *     accountId: "account_af2937b0-9846-4fe7-bfe9-ccc22d935114",
+     *     asset: "usd"
+     * })
+     * ```
+     */
+    public getBalanceByAsset(
+        request: CoinbaseApi.GetBalanceByAssetRequest,
+        requestOptions?: AccountsClient.RequestOptions,
+    ): core.HttpResponsePromise<CoinbaseApi.Balance> {
+        return core.HttpResponsePromise.fromPromise(this.__getBalanceByAsset(request, requestOptions));
+    }
+
+    private async __getBalanceByAsset(
+        request: CoinbaseApi.GetBalanceByAssetRequest,
+        requestOptions?: AccountsClient.RequestOptions,
+    ): Promise<core.WithRawResponse<CoinbaseApi.Balance>> {
+        const _metadata: core.EndpointMetadata = {
+            security: [{ apiKeyAuth: [] }],
+            method: "GET",
+            path: "v2/accounts/{accountId}/balances/{asset}",
+            operationId: "endpoint_accounts.getBalanceByAsset",
+        };
+        const { accountId, asset } = request;
+        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest({
+            endpointMetadata: _metadata,
+            clientOptions: this._options,
+            request: {
+                method: "GET",
+            },
+        });
+        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
+            _authRequest.headers,
+            this._options?.headers,
+            requestOptions?.headers,
+        );
+        const _response = await core.fetcher({
+            url: core.url.join(
+                (await core.Supplier.get(this._options.baseUrl)) ??
+                    (await core.Supplier.get(this._options.environment)) ??
+                    environments.CoinbaseApiEnvironment.Default,
+                `v2/accounts/${core.url.encodePathParam(accountId)}/balances/${core.url.encodePathParam(asset)}`,
+            ),
+            method: "GET",
+            headers: _headers,
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            endpointMetadata: _metadata,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return { data: _response.body as CoinbaseApi.Balance, rawResponse: _response.rawResponse };
+        }
+
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 400:
+                    throw new CoinbaseApi.BadRequestError(
+                        _response.error.body as CoinbaseApi.Error_,
+                        _response.rawResponse,
+                    );
+                case 401:
+                    throw new CoinbaseApi.UnauthorizedError(
+                        _response.error.body as CoinbaseApi.Error_,
+                        _response.rawResponse,
+                    );
+                case 404:
+                    throw new CoinbaseApi.NotFoundError(
+                        _response.error.body as CoinbaseApi.Error_,
+                        _response.rawResponse,
+                    );
+                case 500:
+                    throw new CoinbaseApi.InternalServerError(
+                        _response.error.body as CoinbaseApi.Error_,
+                        _response.rawResponse,
+                    );
+                case 503:
+                    throw new CoinbaseApi.ServiceUnavailableError(
+                        _response.error.body as CoinbaseApi.Error_,
+                        _response.rawResponse,
+                    );
+                default:
+                    throw new errors.CoinbaseApiError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+
+        return handleNonStatusCodeError(
+            _response.error,
+            _response.rawResponse,
+            "GET",
+            "/v2/accounts/{accountId}/balances/{asset}",
+        );
+    }
+}