@paid-ai/paid-node 1.7.1 → 2.0.0

package/dist/esm/api/resources/customers/client/Client.d.mts

@@ -26,13 +26,14 @@ export declare class Customers {
     listCustomers(request?: Paid.ListCustomersRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerListResponse>;
     private __listCustomers;
     /**
-     * Creates a new customer for the organization
+     * Creates a new customer for the organization. `externalId` shares one set of ids with customer unit ids and aliases, unique across the organization and ignoring letter case: an external id that another customer already holds as a unit id or alias, or as its external id in another case, is refused with `409 EXTERNAL_ID_IN_USE`. The same id in the same case is `400 DUPLICATE_EXTERNAL_ID`, as before.
      *
      * @param {Paid.CreateCustomerRequest} request
      * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Paid.BadRequestError}
      * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.ConflictError}
      * @throws {@link Paid.InternalServerError}
      *
      * @example
@@ -43,7 +44,65 @@ export declare class Customers {
     createCustomer(request: Paid.CreateCustomerRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.Customer>;
     private __createCustomer;
     /**
-     * Get a customer by ID
+     * List alternate external identifiers that resolve to a customer by Paid display ID.
+     *
+     * @param {Paid.ListCustomerAliasesRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.listCustomerAliases({
+     *         id: "cus_abc123"
+     *     })
+     */
+    listCustomerAliases(request: Paid.ListCustomerAliasesRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerAliasListResponse>;
+    private __listCustomerAliases;
+    /**
+     * Create an alternate external identifier for a customer by Paid display ID. The alias shares one set of ids with customer external ids and unit ids, unique within the organization and ignoring letter case: an alias that another customer already holds as its external id, a unit id or an alias is refused with `409 EXTERNAL_ID_IN_USE` (an exact match keeps its older code, `ALIAS_CONFLICTS_WITH_CUSTOMER_EXTERNAL_ID` or `CUSTOMER_ALIAS_ALREADY_EXISTS`).
+     *
+     * @param {Paid.CreateCustomerAliasRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.ConflictError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.createCustomerAlias({
+     *         id: "cus_abc123",
+     *         body: {
+     *             alias: "child-customer-1"
+     *         }
+     *     })
+     */
+    createCustomerAlias(request: Paid.CreateCustomerAliasRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerAlias>;
+    private __createCustomerAlias;
+    /**
+     * Remove an alternate external identifier from a customer by Paid display ID.
+     *
+     * @param {Paid.DeleteCustomerAliasRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.deleteCustomerAlias({
+     *         id: "cus_abc123",
+     *         alias: "child-customer-1"
+     *     })
+     */
+    deleteCustomerAlias(request: Paid.DeleteCustomerAliasRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.EmptyResponse>;
+    private __deleteCustomerAlias;
+    /**
+     * Get a customer by Paid display ID. Use the value returned as `customer.id`, for example `cus_abc123`. If you have your own customer ID, use `GET /api/v2/customers/external/{externalId}`.
      *
      * @param {Paid.GetCustomerByIdRequest} request
      * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
@@ -54,13 +113,13 @@ export declare class Customers {
      *
      * @example
      *     await client.customers.getCustomerById({
-     *         id: "id"
+     *         id: "cus_abc123"
      *     })
      */
     getCustomerById(request: Paid.GetCustomerByIdRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.Customer>;
     private __getCustomerById;
     /**
-     * Update a customer by ID
+     * Update a customer by Paid display ID. Use the value returned as `customer.id`, for example `cus_abc123`. If you have your own customer ID, use `PUT /api/v2/customers/external/{externalId}`. Changing `externalId` follows the organization-wide id rule: a new id that another customer already holds as its external id, a unit id or an alias, ignoring letter case, is refused with `409 EXTERNAL_ID_IN_USE`; the same id in the same case stays `400 DUPLICATE_EXTERNAL_ID`. When the id changes, the previous id is kept as an alias of the customer, so signals that still use it keep resolving to it.
      *
      * @param {Paid.UpdateCustomerByIdRequest} request
      * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
@@ -68,18 +127,19 @@ export declare class Customers {
      * @throws {@link Paid.BadRequestError}
      * @throws {@link Paid.ForbiddenError}
      * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.ConflictError}
      * @throws {@link Paid.InternalServerError}
      *
      * @example
      *     await client.customers.updateCustomerById({
-     *         id: "id",
+     *         id: "cus_abc123",
      *         body: {}
      *     })
      */
     updateCustomerById(request: Paid.UpdateCustomerByIdRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.Customer>;
     private __updateCustomerById;
     /**
-     * Delete a customer by ID
+     * Delete a customer by Paid display ID. Use the value returned as `customer.id`, for example `cus_abc123`. If you have your own customer ID, use `DELETE /api/v2/customers/external/{externalId}`. A customer that still has orders, invoices, payments, contacts, child customers or other linked records is not deleted: the request returns 409 `CUSTOMER_HAS_ASSOCIATIONS` and `details` lists what is linked.
      *
      * @param {Paid.DeleteCustomerByIdRequest} request
      * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
@@ -87,15 +147,91 @@ export declare class Customers {
      * @throws {@link Paid.BadRequestError}
      * @throws {@link Paid.ForbiddenError}
      * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.ConflictError}
      * @throws {@link Paid.InternalServerError}
      *
      * @example
      *     await client.customers.deleteCustomerById({
-     *         id: "id"
+     *         id: "cus_abc123"
      *     })
      */
     deleteCustomerById(request: Paid.DeleteCustomerByIdRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.EmptyResponse>;
     private __deleteCustomerById;
+    /**
+     * Get the current customer state by Paid display ID
+     *
+     * @param {Paid.GetCustomerStateByIdRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.getCustomerStateById({
+     *         id: "cus_abc123"
+     *     })
+     */
+    getCustomerStateById(request: Paid.GetCustomerStateByIdRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerState>;
+    private __getCustomerStateById;
+    /**
+     * List alternate external identifiers that resolve to a customer by external ID.
+     *
+     * @param {Paid.ListCustomerAliasesByExternalIdRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.listCustomerAliasesByExternalId({
+     *         externalId: "customer_123"
+     *     })
+     */
+    listCustomerAliasesByExternalId(request: Paid.ListCustomerAliasesByExternalIdRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerAliasListResponse>;
+    private __listCustomerAliasesByExternalId;
+    /**
+     * Create an alternate external identifier for a customer by external ID. The alias shares one set of ids with customer external ids and unit ids, unique within the organization and ignoring letter case: an alias that another customer already holds as its external id, a unit id or an alias is refused with `409 EXTERNAL_ID_IN_USE` (an exact match keeps its older code, `ALIAS_CONFLICTS_WITH_CUSTOMER_EXTERNAL_ID` or `CUSTOMER_ALIAS_ALREADY_EXISTS`).
+     *
+     * @param {Paid.CreateCustomerAliasByExternalIdRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.ConflictError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.createCustomerAliasByExternalId({
+     *         externalId: "customer_123",
+     *         body: {
+     *             alias: "child-customer-1"
+     *         }
+     *     })
+     */
+    createCustomerAliasByExternalId(request: Paid.CreateCustomerAliasByExternalIdRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerAlias>;
+    private __createCustomerAliasByExternalId;
+    /**
+     * Remove an alternate external identifier from a customer by external ID.
+     *
+     * @param {Paid.DeleteCustomerAliasByExternalIdRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.deleteCustomerAliasByExternalId({
+     *         externalId: "customer_123",
+     *         alias: "child-customer-1"
+     *     })
+     */
+    deleteCustomerAliasByExternalId(request: Paid.DeleteCustomerAliasByExternalIdRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.EmptyResponse>;
+    private __deleteCustomerAliasByExternalId;
     /**
      * Get a customer by external ID
      *
@@ -108,13 +244,13 @@ export declare class Customers {
      *
      * @example
      *     await client.customers.getCustomerByExternalId({
-     *         externalId: "externalId"
+     *         externalId: "customer_123"
      *     })
      */
     getCustomerByExternalId(request: Paid.GetCustomerByExternalIdRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.Customer>;
     private __getCustomerByExternalId;
     /**
-     * Update a customer by external ID
+     * Update a customer by external ID. Changing `externalId` follows the organization-wide id rule: a new id that another customer already holds as its external id, a unit id or an alias, ignoring letter case, is refused with `409 EXTERNAL_ID_IN_USE`; the same id in the same case stays `400 DUPLICATE_EXTERNAL_ID`. When the id changes, the previous id is kept as an alias of the customer, so signals that still use it keep resolving to it.
      *
      * @param {Paid.UpdateCustomerByExternalIdRequest} request
      * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
@@ -122,18 +258,19 @@ export declare class Customers {
      * @throws {@link Paid.BadRequestError}
      * @throws {@link Paid.ForbiddenError}
      * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.ConflictError}
      * @throws {@link Paid.InternalServerError}
      *
      * @example
      *     await client.customers.updateCustomerByExternalId({
-     *         externalId: "externalId",
+     *         externalId: "customer_123",
      *         body: {}
      *     })
      */
     updateCustomerByExternalId(request: Paid.UpdateCustomerByExternalIdRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.Customer>;
     private __updateCustomerByExternalId;
     /**
-     * Delete a customer by external ID
+     * Delete a customer by external ID. A customer that still has orders, invoices, payments, contacts, child customers or other linked records is not deleted: the request returns 409 `CUSTOMER_HAS_ASSOCIATIONS` and `details` lists what is linked.
      *
      * @param {Paid.DeleteCustomerByExternalIdRequest} request
      * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
@@ -141,17 +278,35 @@ export declare class Customers {
      * @throws {@link Paid.BadRequestError}
      * @throws {@link Paid.ForbiddenError}
      * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.ConflictError}
      * @throws {@link Paid.InternalServerError}
      *
      * @example
      *     await client.customers.deleteCustomerByExternalId({
-     *         externalId: "externalId"
+     *         externalId: "customer_123"
      *     })
      */
     deleteCustomerByExternalId(request: Paid.DeleteCustomerByExternalIdRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.EmptyResponse>;
     private __deleteCustomerByExternalId;
     /**
-     * Get current customer credit balances grouped by currency
+     * Primary integration endpoint for agents and programmatic clients using their own customer IDs. Use the value you stored on `customer.externalId`, for example `customer_123`.
+     *
+     * @param {Paid.GetCustomerStateByExternalIdRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.getCustomerStateByExternalId({
+     *         externalId: "customer_123"
+     *     })
+     */
+    getCustomerStateByExternalId(request: Paid.GetCustomerStateByExternalIdRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerState>;
+    private __getCustomerStateByExternalId;
+    /**
+     * Get current customer credit balances grouped by currency for a Paid customer display ID. Use the value returned as `customer.id`, for example `cus_abc123`. If you have your own customer ID, use `/api/v2/customers/external/{externalId}/credits/balances`.
      *
      * @param {Paid.GetCustomerCreditBalancesRequest} request
      * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
@@ -162,11 +317,37 @@ export declare class Customers {
      *
      * @example
      *     await client.customers.getCustomerCreditBalances({
-     *         id: "id"
+     *         id: "cus_abc123"
      *     })
      */
     getCustomerCreditBalances(request: Paid.GetCustomerCreditBalancesRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CreditBalanceListResponse>;
     private __getCustomerCreditBalances;
+    /**
+     * Immediately grant credits to a customer using an active credit currency key.
+     *
+     * @param {Paid.GrantCustomerCreditsRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.ConflictError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.grantCustomerCredits({
+     *         id: "cus_abc123",
+     *         body: {
+     *             creditCurrencyKey: "api_credits",
+     *             amount: 10000,
+     *             startsAt: "2026-06-05T12:00:00Z",
+     *             expiresAt: "2026-12-31T23:59:59Z",
+     *             idempotencyKey: "grant_acme_2026-06-05"
+     *         }
+     *     })
+     */
+    grantCustomerCredits(request: Paid.GrantCustomerCreditsRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.GrantCustomerCreditsResponse>;
+    private __grantCustomerCredits;
     /**
      * Get current customer credit balances grouped by currency, looked up by external ID
      *
@@ -179,11 +360,73 @@ export declare class Customers {
      *
      * @example
      *     await client.customers.getCustomerCreditBalancesByExternalId({
-     *         externalId: "externalId"
+     *         externalId: "customer_123"
      *     })
      */
     getCustomerCreditBalancesByExternalId(request: Paid.GetCustomerCreditBalancesByExternalIdRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CreditBalanceListResponse>;
     private __getCustomerCreditBalancesByExternalId;
+    /**
+     * List credit consumption that was recorded before a matching credit pool existed — for example usage that arrived before an invoice was paid or before a new period's credits were granted. Entries leave this list once they are applied to a pool or settled. Use the value returned as `customer.id`, for example `cus_abc123`. If you have your own customer ID, use `/api/v2/customers/external/{externalId}/credits/pending-consumption`.
+     *
+     * @param {Paid.ListCustomerPendingCreditConsumptionRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.listCustomerPendingCreditConsumption({
+     *         id: "cus_abc123"
+     *     })
+     */
+    listCustomerPendingCreditConsumption(request: Paid.ListCustomerPendingCreditConsumptionRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.PendingCreditConsumptionListResponse>;
+    private __listCustomerPendingCreditConsumption;
+    /**
+     * List credit consumption recorded before a matching credit pool existed, for a customer looked up by external ID.
+     *
+     * @param {Paid.ListCustomerPendingCreditConsumptionByExternalIdRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.listCustomerPendingCreditConsumptionByExternalId({
+     *         externalId: "customer_123"
+     *     })
+     */
+    listCustomerPendingCreditConsumptionByExternalId(request: Paid.ListCustomerPendingCreditConsumptionByExternalIdRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.PendingCreditConsumptionListResponse>;
+    private __listCustomerPendingCreditConsumptionByExternalId;
+    /**
+     * Immediately grant credits to a customer looked up by external ID using an active credit currency key.
+     *
+     * @param {Paid.GrantCustomerCreditsByExternalIdRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.ConflictError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.grantCustomerCreditsByExternalId({
+     *         externalId: "customer_123",
+     *         body: {
+     *             creditCurrencyKey: "api_credits",
+     *             amount: 10000,
+     *             startsAt: "2026-06-05T12:00:00Z",
+     *             expiresAt: "2026-12-31T23:59:59Z",
+     *             idempotencyKey: "grant_acme_2026-06-05"
+     *         }
+     *     })
+     */
+    grantCustomerCreditsByExternalId(request: Paid.GrantCustomerCreditsByExternalIdRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.GrantCustomerCreditsResponse>;
+    private __grantCustomerCreditsByExternalId;
     /**
      * Create or update a customer user using customer and user external IDs
      *
@@ -203,5 +446,796 @@ export declare class Customers {
      */
     upsertCustomerUserByExternalId(request: Paid.UpsertCustomerUserRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerUser>;
     private __upsertCustomerUserByExternalId;
+    /**
+     * Returns the virtual bank account (Stripe funding instructions) a customer can pay by bank transfer into, by Paid display ID.
+     *
+     * @param {Paid.GetCustomerFundingInstructionsRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.getCustomerFundingInstructions({
+     *         id: "cus_abc123",
+     *         currency: "USD"
+     *     })
+     */
+    getCustomerFundingInstructions(request: Paid.GetCustomerFundingInstructionsRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerFundingInstructions>;
+    private __getCustomerFundingInstructions;
+    /**
+     * Creates a dedicated virtual bank account for the customer to pay invoices by bank transfer, by Paid display ID. Returns the existing account if one already exists for the currency. Requires a live-mode organization with Stripe connected and Bank Transfers enabled on the Stripe account.
+     *
+     * @param {Paid.CreateCustomerFundingInstructionsRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.UnprocessableEntityError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.createCustomerFundingInstructions({
+     *         id: "cus_abc123",
+     *         body: {}
+     *     })
+     */
+    createCustomerFundingInstructions(request: Paid.CreateCustomerFundingInstructionsRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerFundingInstructions>;
+    private __createCustomerFundingInstructions;
+    /**
+     * Returns the virtual bank account (Stripe funding instructions) a customer can pay by bank transfer into, by your external ID.
+     *
+     * @param {Paid.GetCustomerFundingInstructionsByExternalIdRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.getCustomerFundingInstructionsByExternalId({
+     *         externalId: "externalId",
+     *         currency: "USD"
+     *     })
+     */
+    getCustomerFundingInstructionsByExternalId(request: Paid.GetCustomerFundingInstructionsByExternalIdRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerFundingInstructions>;
+    private __getCustomerFundingInstructionsByExternalId;
+    /**
+     * Creates a dedicated virtual bank account for the customer to pay invoices by bank transfer, by your external ID. Returns the existing account if one already exists for the currency. Requires a live-mode organization with Stripe connected and Bank Transfers enabled on the Stripe account.
+     *
+     * @param {Paid.CreateCustomerFundingInstructionsByExternalIdRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.UnprocessableEntityError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.createCustomerFundingInstructionsByExternalId({
+     *         externalId: "externalId",
+     *         body: {}
+     *     })
+     */
+    createCustomerFundingInstructionsByExternalId(request: Paid.CreateCustomerFundingInstructionsByExternalIdRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerFundingInstructions>;
+    private __createCustomerFundingInstructionsByExternalId;
+    /**
+     * Lists the customer's units as a flat list, newest last; assemble the tree from `parentExternalId` (`null` on the root unit, `isRoot: true`). Deleted units are hidden unless `status=DELETED` is given, drafts unless `status=DRAFT`. Filter by `externalType`, or by `parentExternalId` for one level of the tree. Addresses the customer by your external customer id.
+     *
+     * @param {Paid.ListCustomerUnitsByExternalIdRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.listCustomerUnitsByExternalId({
+     *         externalId: "customer_123",
+     *         parentExternalId: "dept-rnd"
+     *     })
+     */
+    listCustomerUnitsByExternalId(request: Paid.ListCustomerUnitsByExternalIdRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerUnitListResponse>;
+    private __listCustomerUnitsByExternalId;
+    /**
+     * Creates a unit for this customer. `externalId` is your own key for it: required, immutable, and unique within the organization (no other customer's unit id, external id or alias may be the same, ignoring letter case); every unit route addresses the unit by it, and `name` defaults to it. Omit `parentExternalId` to create the customer's root unit (its first unit; `409 ROOT_EXISTS` if it already has one — a customer created with an external id usable as a unit key already has its root, keyed by that external id, so name it as the parent instead); otherwise the parent must exist (`409 PARENT_NOT_FOUND`) and be ACTIVE. A create whose `externalId` is one of this customer's `DRAFT` units promotes the draft in place: same unit, same id, now ACTIVE with the request's name, type, metadata and parent (`parentExternalId` is required; a draft sits under the root). A signal that names a unit before it exists is accepted; with draft units enabled for your organization it creates a `DRAFT` unit under the customer's root that holds the key, and creating the unit with that key later promotes the draft; otherwise its spend attaches to the unit once you create it with that key. `409` also when the externalId is taken on this customer (`CUSTOMER_UNIT_EXISTS`) or by another customer of the organization (`EXTERNAL_ID_IN_USE`), the tree would get too deep, the customer is on seat-based billing, or a root unit is sent with `billable: false` (`ROOT_UNIT_ALWAYS_BILLABLE`). `403 FEATURE_NOT_ENABLED` for `billable: false` when non-billable units are not enabled for your organization. Addresses the customer by your external customer id.
+     *
+     * @param {Paid.CreateCustomerUnitByExternalIdRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.ConflictError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.createCustomerUnitByExternalId({
+     *         externalId: "customer_123",
+     *         body: {
+     *             externalId: "team-research"
+     *         }
+     *     })
+     */
+    createCustomerUnitByExternalId(request: Paid.CreateCustomerUnitByExternalIdRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerUnit>;
+    private __createCustomerUnitByExternalId;
+    /**
+     * Returns one unit of this customer by its `externalId`, including a deleted one. `404` when the unit does not exist or belongs to another customer. Addresses the customer by your external customer id.
+     *
+     * @param {Paid.GetCustomerUnitByExternalIdRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.getCustomerUnitByExternalId({
+     *         externalId: "customer_123",
+     *         externalCustomerUnitId: "team-research"
+     *     })
+     */
+    getCustomerUnitByExternalId(request: Paid.GetCustomerUnitByExternalIdRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerUnit>;
+    private __getCustomerUnitByExternalId;
+    /**
+     * Soft-deletes a unit: it stays readable with `status: DELETED` and cannot be reactivated. Spend history that references it is kept, and signals that keep naming it are still attributed to it. A `DRAFT` unit is deleted the same way: it stays readable as DELETED, its key stays reserved, and spend already keyed to it stays its own. `409` while the unit has ACTIVE or DRAFT children or a cap in force or scheduled; the root follows the same rules, and once it is deleted a new root can be created. Addresses the customer by your external customer id.
+     *
+     * @param {Paid.DeleteCustomerUnitByExternalIdRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.ConflictError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.deleteCustomerUnitByExternalId({
+     *         externalId: "customer_123",
+     *         externalCustomerUnitId: "team-research"
+     *     })
+     */
+    deleteCustomerUnitByExternalId(request: Paid.DeleteCustomerUnitByExternalIdRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerUnit>;
+    private __deleteCustomerUnitByExternalId;
+    /**
+     * Renames, re-types, re-parents or annotates a unit, the root included. `externalId` cannot change. Re-parenting (`parentExternalId`) moves the unit with everything under it. Spend already recorded keeps naming the unit it landed on; caps are evaluated on the current tree, so from the move on the unit's spend in the running cap period counts toward its new ancestors' caps and no longer toward the old ones. `billable` flips the unit's own setting; moving a unit under a non-billable one makes it non-billable in effect (`effectiveBillable`). `409` for a deleted unit (`CUSTOMER_UNIT_DELETED`), a draft (`CUSTOMER_UNIT_DRAFT`), a parent that does not exist or is not ACTIVE, a move of the root (`ROOT_UNIT_IMMOVABLE`), `billable: false` on the root (`ROOT_UNIT_ALWAYS_BILLABLE`), a move under the unit's own subtree, or a tree that would get too deep. `403 FEATURE_NOT_ENABLED` for `billable: false` when non-billable units are not enabled for your organization. Addresses the customer by your external customer id.
+     *
+     * @param {Paid.UpdateCustomerUnitByExternalIdRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.ConflictError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.updateCustomerUnitByExternalId({
+     *         externalId: "customer_123",
+     *         externalCustomerUnitId: "team-research",
+     *         body: {}
+     *     })
+     */
+    updateCustomerUnitByExternalId(request: Paid.UpdateCustomerUnitByExternalIdRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerUnit>;
+    private __updateCustomerUnitByExternalId;
+    /**
+     * Lists the aliases that land signals on this unit. A customer-level alias (created on the customer routes) points at the customer's root unit, so it is listed under the root. Addresses the customer by your external customer id.
+     *
+     * @param {Paid.ListCustomerUnitAliasesByExternalIdRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.listCustomerUnitAliasesByExternalId({
+     *         externalId: "customer_123",
+     *         externalCustomerUnitId: "team-research"
+     *     })
+     */
+    listCustomerUnitAliasesByExternalId(request: Paid.ListCustomerUnitAliasesByExternalIdRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerAliasListResponse>;
+    private __listCustomerUnitAliasesByExternalId;
+    /**
+     * Creates an alias that lands signals on this unit: a signal whose `externalCustomerId` is the alias resolves to this customer and, when it names no `customerUnit`, to this unit. The alias shares one set of ids with customer external ids and unit ids, unique within the organization and ignoring letter case: an alias another customer holds is refused with `409 EXTERNAL_ID_IN_USE`. Addresses the customer by your external customer id.
+     *
+     * @param {Paid.CreateCustomerUnitAliasByExternalIdRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.ConflictError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.createCustomerUnitAliasByExternalId({
+     *         externalId: "customer_123",
+     *         externalCustomerUnitId: "team-research",
+     *         body: {
+     *             alias: "child-customer-1"
+     *         }
+     *     })
+     */
+    createCustomerUnitAliasByExternalId(request: Paid.CreateCustomerUnitAliasByExternalIdRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerAlias>;
+    private __createCustomerUnitAliasByExternalId;
+    /**
+     * Deletes an alias of this unit. Signals still sent with it then resolve to nothing again. Addresses the customer by your external customer id.
+     *
+     * @param {Paid.DeleteCustomerUnitAliasByExternalIdRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.deleteCustomerUnitAliasByExternalId({
+     *         externalId: "customer_123",
+     *         externalCustomerUnitId: "team-research",
+     *         alias: "tenant-7-sandbox"
+     *     })
+     */
+    deleteCustomerUnitAliasByExternalId(request: Paid.DeleteCustomerUnitAliasByExternalIdRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.DeleteCustomerUnitAliasByExternalIdResponse>;
+    private __deleteCustomerUnitAliasByExternalId;
+    /**
+     * Lists the customer's units as a flat list, newest last; assemble the tree from `parentExternalId` (`null` on the root unit, `isRoot: true`). Deleted units are hidden unless `status=DELETED` is given, drafts unless `status=DRAFT`. Filter by `externalType`, or by `parentExternalId` for one level of the tree. Use the value returned as `customer.id`, for example `cus_abc123`; if you have your own customer ID, use the `/api/v2/customers/external/{externalId}/…` twin.
+     *
+     * @param {Paid.ListCustomerUnitsRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.listCustomerUnits({
+     *         id: "cus_abc123",
+     *         parentExternalId: "dept-rnd"
+     *     })
+     */
+    listCustomerUnits(request: Paid.ListCustomerUnitsRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerUnitListResponse>;
+    private __listCustomerUnits;
+    /**
+     * Creates a unit for this customer. `externalId` is your own key for it: required, immutable, and unique within the organization (no other customer's unit id, external id or alias may be the same, ignoring letter case); every unit route addresses the unit by it, and `name` defaults to it. Omit `parentExternalId` to create the customer's root unit (its first unit; `409 ROOT_EXISTS` if it already has one — a customer created with an external id usable as a unit key already has its root, keyed by that external id, so name it as the parent instead); otherwise the parent must exist (`409 PARENT_NOT_FOUND`) and be ACTIVE. A create whose `externalId` is one of this customer's `DRAFT` units promotes the draft in place: same unit, same id, now ACTIVE with the request's name, type, metadata and parent (`parentExternalId` is required; a draft sits under the root). A signal that names a unit before it exists is accepted; with draft units enabled for your organization it creates a `DRAFT` unit under the customer's root that holds the key, and creating the unit with that key later promotes the draft; otherwise its spend attaches to the unit once you create it with that key. `409` also when the externalId is taken on this customer (`CUSTOMER_UNIT_EXISTS`) or by another customer of the organization (`EXTERNAL_ID_IN_USE`), the tree would get too deep, the customer is on seat-based billing, or a root unit is sent with `billable: false` (`ROOT_UNIT_ALWAYS_BILLABLE`). `403 FEATURE_NOT_ENABLED` for `billable: false` when non-billable units are not enabled for your organization. Use the value returned as `customer.id`, for example `cus_abc123`; if you have your own customer ID, use the `/api/v2/customers/external/{externalId}/…` twin.
+     *
+     * @param {Paid.CreateCustomerUnitRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.ConflictError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.createCustomerUnit({
+     *         id: "cus_abc123",
+     *         body: {
+     *             externalId: "team-research"
+     *         }
+     *     })
+     */
+    createCustomerUnit(request: Paid.CreateCustomerUnitRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerUnit>;
+    private __createCustomerUnit;
+    /**
+     * Returns one unit of this customer by its `externalId`, including a deleted one. `404` when the unit does not exist or belongs to another customer. Use the value returned as `customer.id`, for example `cus_abc123`; if you have your own customer ID, use the `/api/v2/customers/external/{externalId}/…` twin.
+     *
+     * @param {Paid.GetCustomerUnitRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.getCustomerUnit({
+     *         id: "cus_abc123",
+     *         externalCustomerUnitId: "team-research"
+     *     })
+     */
+    getCustomerUnit(request: Paid.GetCustomerUnitRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerUnit>;
+    private __getCustomerUnit;
+    /**
+     * Soft-deletes a unit: it stays readable with `status: DELETED` and cannot be reactivated. Spend history that references it is kept, and signals that keep naming it are still attributed to it. A `DRAFT` unit is deleted the same way: it stays readable as DELETED, its key stays reserved, and spend already keyed to it stays its own. `409` while the unit has ACTIVE or DRAFT children or a cap in force or scheduled; the root follows the same rules, and once it is deleted a new root can be created. Use the value returned as `customer.id`, for example `cus_abc123`; if you have your own customer ID, use the `/api/v2/customers/external/{externalId}/…` twin.
+     *
+     * @param {Paid.DeleteCustomerUnitRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.ConflictError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.deleteCustomerUnit({
+     *         id: "cus_abc123",
+     *         externalCustomerUnitId: "team-research"
+     *     })
+     */
+    deleteCustomerUnit(request: Paid.DeleteCustomerUnitRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerUnit>;
+    private __deleteCustomerUnit;
+    /**
+     * Renames, re-types, re-parents or annotates a unit, the root included. `externalId` cannot change. Re-parenting (`parentExternalId`) moves the unit with everything under it. Spend already recorded keeps naming the unit it landed on; caps are evaluated on the current tree, so from the move on the unit's spend in the running cap period counts toward its new ancestors' caps and no longer toward the old ones. `billable` flips the unit's own setting; moving a unit under a non-billable one makes it non-billable in effect (`effectiveBillable`). `409` for a deleted unit (`CUSTOMER_UNIT_DELETED`), a draft (`CUSTOMER_UNIT_DRAFT`), a parent that does not exist or is not ACTIVE, a move of the root (`ROOT_UNIT_IMMOVABLE`), `billable: false` on the root (`ROOT_UNIT_ALWAYS_BILLABLE`), a move under the unit's own subtree, or a tree that would get too deep. `403 FEATURE_NOT_ENABLED` for `billable: false` when non-billable units are not enabled for your organization. Use the value returned as `customer.id`, for example `cus_abc123`; if you have your own customer ID, use the `/api/v2/customers/external/{externalId}/…` twin.
+     *
+     * @param {Paid.UpdateCustomerUnitRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.ConflictError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.updateCustomerUnit({
+     *         id: "cus_abc123",
+     *         externalCustomerUnitId: "team-research",
+     *         body: {}
+     *     })
+     */
+    updateCustomerUnit(request: Paid.UpdateCustomerUnitRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerUnit>;
+    private __updateCustomerUnit;
+    /**
+     * Lists the aliases that land signals on this unit. A customer-level alias (created on the customer routes) points at the customer's root unit, so it is listed under the root. Use the value returned as `customer.id`, for example `cus_abc123`; if you have your own customer ID, use the `/api/v2/customers/external/{externalId}/…` twin.
+     *
+     * @param {Paid.ListCustomerUnitAliasesRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.listCustomerUnitAliases({
+     *         id: "cus_abc123",
+     *         externalCustomerUnitId: "team-research"
+     *     })
+     */
+    listCustomerUnitAliases(request: Paid.ListCustomerUnitAliasesRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerAliasListResponse>;
+    private __listCustomerUnitAliases;
+    /**
+     * Creates an alias that lands signals on this unit: a signal whose `externalCustomerId` is the alias resolves to this customer and, when it names no `customerUnit`, to this unit. The alias shares one set of ids with customer external ids and unit ids, unique within the organization and ignoring letter case: an alias another customer holds is refused with `409 EXTERNAL_ID_IN_USE`. Use the value returned as `customer.id`, for example `cus_abc123`; if you have your own customer ID, use the `/api/v2/customers/external/{externalId}/…` twin.
+     *
+     * @param {Paid.CreateCustomerUnitAliasRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.ConflictError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.createCustomerUnitAlias({
+     *         id: "cus_abc123",
+     *         externalCustomerUnitId: "team-research",
+     *         body: {
+     *             alias: "child-customer-1"
+     *         }
+     *     })
+     */
+    createCustomerUnitAlias(request: Paid.CreateCustomerUnitAliasRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerAlias>;
+    private __createCustomerUnitAlias;
+    /**
+     * Deletes an alias of this unit. Signals still sent with it then resolve to nothing again. Use the value returned as `customer.id`, for example `cus_abc123`; if you have your own customer ID, use the `/api/v2/customers/external/{externalId}/…` twin.
+     *
+     * @param {Paid.DeleteCustomerUnitAliasRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.deleteCustomerUnitAlias({
+     *         id: "cus_abc123",
+     *         externalCustomerUnitId: "team-research",
+     *         alias: "tenant-7-sandbox"
+     *     })
+     */
+    deleteCustomerUnitAlias(request: Paid.DeleteCustomerUnitAliasRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.DeleteCustomerUnitAliasResponse>;
+    private __deleteCustomerUnitAlias;
+    /**
+     * Returns a unit by its key without naming its customer. The answer carries the customer's ids (`customerId`, `customerExternalId`) so the customer routes are one hop away, but, like the create on this path, not Paid's unit id: a caller of these routes names units by key. The key is looked up across the organization ignoring letter case. When more than one unit carries it in another letter case (legacy duplicates across customers, or case variants on one customer), the exact spelling decides; when that does not single one out either, the answer is `409 CUSTOMER_UNIT_AMBIGUOUS`: use the customer's unit routes, where the key is exact.
+     *
+     * @param {Paid.GetCustomerUnitByKeyRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.ConflictError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.getCustomerUnitByKey({
+     *         externalCustomerUnitId: "team-research"
+     *     })
+     */
+    getCustomerUnitByKey(request: Paid.GetCustomerUnitByKeyRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerUnitByKey>;
+    private __getCustomerUnitByKey;
+    /**
+     * Lists the aliases that land signals on this unit, without naming its customer. The key is looked up across the organization ignoring letter case. When more than one unit carries it in another letter case (legacy duplicates across customers, or case variants on one customer), the exact spelling decides; when that does not single one out either, the answer is `409 CUSTOMER_UNIT_AMBIGUOUS`: use the customer's unit routes, where the key is exact.
+     *
+     * @param {Paid.ListCustomerUnitAliasesByKeyRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.ConflictError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.listCustomerUnitAliasesByKey({
+     *         externalCustomerUnitId: "team-research"
+     *     })
+     */
+    listCustomerUnitAliasesByKey(request: Paid.ListCustomerUnitAliasesByKeyRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerAliasListResponse>;
+    private __listCustomerUnitAliasesByKey;
+    /**
+     * Creates an alias that lands signals on this unit, without naming its customer: a signal whose `externalCustomerId` is the alias resolves to the unit's customer and is attributed to this unit. The alias must be unique within the organization ignoring letter case (`409 EXTERNAL_ID_IN_USE`). The key is looked up across the organization ignoring letter case. When more than one unit carries it in another letter case (legacy duplicates across customers, or case variants on one customer), the exact spelling decides; when that does not single one out either, the answer is `409 CUSTOMER_UNIT_AMBIGUOUS`: use the customer's unit routes, where the key is exact.
+     *
+     * @param {Paid.CreateCustomerUnitAliasByKeyRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.ConflictError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.createCustomerUnitAliasByKey({
+     *         externalCustomerUnitId: "team-research",
+     *         body: {
+     *             alias: "child-customer-1"
+     *         }
+     *     })
+     */
+    createCustomerUnitAliasByKey(request: Paid.CreateCustomerUnitAliasByKeyRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerAlias>;
+    private __createCustomerUnitAliasByKey;
+    /**
+     * Deletes an alias of this unit, without naming its customer. Signals still sent with it then resolve to nothing again. The key is looked up across the organization ignoring letter case. When more than one unit carries it in another letter case (legacy duplicates across customers, or case variants on one customer), the exact spelling decides; when that does not single one out either, the answer is `409 CUSTOMER_UNIT_AMBIGUOUS`: use the customer's unit routes, where the key is exact.
+     *
+     * @param {Paid.DeleteCustomerUnitAliasByKeyRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.ConflictError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.deleteCustomerUnitAliasByKey({
+     *         externalCustomerUnitId: "team-research",
+     *         alias: "tenant-7"
+     *     })
+     */
+    deleteCustomerUnitAliasByKey(request: Paid.DeleteCustomerUnitAliasByKeyRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.DeleteCustomerUnitAliasByKeyResponse>;
+    private __deleteCustomerUnitAliasByKey;
+    /**
+     * Creates a unit by naming its parent alone; the customer is whoever the parent belongs to, so a caller that only knows its own ids never needs the customer routes. `parentExternalId` is looked up across the organization, ignoring letter case, among unit ids, customer external ids and aliases: a unit becomes the parent; a customer (by external id or alias) stands for the top of its tree, so the new unit goes under the root unit, or becomes the root when the customer has none. The parent is only ever named by your id, never by a Paid id, so a customer with no external id takes its units through the customer's unit routes. The answer carries the unit's `externalId` and its customer's ids, not Paid's unit id. `externalId` follows the same rules as on the customer-scoped create: required, immutable, unique within the organization ignoring letter case. `409 PARENT_NOT_FOUND` when nothing matches, `PARENT_NOT_ACTIVE` for a deleted or draft parent, `PARENT_AMBIGUOUS` when legacy rows let the id name more than one customer (use that customer's unit routes), `PARENT_CHANGED` when the reference pointed elsewhere by the time the create ran (send it again), and otherwise the customer-scoped create's 409s (`CUSTOMER_UNIT_EXISTS`, `EXTERNAL_ID_IN_USE`, `DEPTH_EXCEEDED`, `SEAT_BILLING`, and `ROOT_UNIT_ALWAYS_BILLABLE` for `billable: false` on a unit that would become the root). `403 FEATURE_NOT_ENABLED` for `billable: false` when non-billable units are not enabled for your organization.
+     *
+     * @param {Paid.CustomerUnitCreateUnderParent} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.ConflictError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.createCustomerUnitUnderParent({
+     *         externalId: "team-research",
+     *         parentExternalId: "dept-rnd"
+     *     })
+     */
+    createCustomerUnitUnderParent(request: Paid.CustomerUnitCreateUnderParent, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerUnitCreatedUnderParent>;
+    private __createCustomerUnitUnderParent;
+    /**
+     * Lists this customer's API keys, newest first and paginated, revoked and expired ones included. The secret is never returned; `keyPrefix` and `last4` identify each key. Addresses the customer by your external customer id.
+     *
+     * @param {Paid.ListCustomerApiKeysByExternalIdRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.listCustomerApiKeysByExternalId({
+     *         externalId: "customer_123"
+     *     })
+     */
+    listCustomerApiKeysByExternalId(request: Paid.ListCustomerApiKeysByExternalIdRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerApiKeyList>;
+    private __listCustomerApiKeysByExternalId;
+    /**
+     * Creates an API key bound to this customer. The response carries the secret in `key`, returned only this once: store it immediately, as Paid keeps only its hash. The key acts for this customer alone: it can send signals for this customer through `POST /api/v2/signals/bulk`, and every other route refuses it. Requires `write:api-keys`, which full-access keys hold; a restricted key needs the scope granted explicitly. Addresses the customer by your external customer id.
+     *
+     * @param {Paid.CreateCustomerApiKeyByExternalIdRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.createCustomerApiKeyByExternalId({
+     *         externalId: "customer_123",
+     *         body: {
+     *             name: "Tenant runtime (production)"
+     *         }
+     *     })
+     */
+    createCustomerApiKeyByExternalId(request: Paid.CreateCustomerApiKeyByExternalIdRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerApiKeyCreated>;
+    private __createCustomerApiKeyByExternalId;
+    /**
+     * Revokes one of this customer's keys, which then stops authenticating. Keys are never deleted: a revoked key stays listed with `revokedAt` set, and deleting the customer revokes its keys too. Revoking an already revoked key returns it unchanged. `404` when the key does not belong to this customer. Addresses the customer by your external customer id.
+     *
+     * @param {Paid.RevokeCustomerApiKeyByExternalIdRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.revokeCustomerApiKeyByExternalId({
+     *         externalId: "customer_123",
+     *         apiKeyId: "apiKeyId"
+     *     })
+     */
+    revokeCustomerApiKeyByExternalId(request: Paid.RevokeCustomerApiKeyByExternalIdRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerApiKey>;
+    private __revokeCustomerApiKeyByExternalId;
+    /**
+     * Lists this customer's API keys, newest first and paginated, revoked and expired ones included. The secret is never returned; `keyPrefix` and `last4` identify each key. Use the value returned as `customer.id`, for example `cus_abc123`; if you have your own customer ID, use the `/api/v2/customers/external/{externalId}/…` twin.
+     *
+     * @param {Paid.ListCustomerApiKeysRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.listCustomerApiKeys({
+     *         id: "cus_abc123"
+     *     })
+     */
+    listCustomerApiKeys(request: Paid.ListCustomerApiKeysRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerApiKeyList>;
+    private __listCustomerApiKeys;
+    /**
+     * Creates an API key bound to this customer. The response carries the secret in `key`, returned only this once: store it immediately, as Paid keeps only its hash. The key acts for this customer alone: it can send signals for this customer through `POST /api/v2/signals/bulk`, and every other route refuses it. Requires `write:api-keys`, which full-access keys hold; a restricted key needs the scope granted explicitly. Use the value returned as `customer.id`, for example `cus_abc123`; if you have your own customer ID, use the `/api/v2/customers/external/{externalId}/…` twin.
+     *
+     * @param {Paid.CreateCustomerApiKeyRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.createCustomerApiKey({
+     *         id: "cus_abc123",
+     *         body: {
+     *             name: "Tenant runtime (production)"
+     *         }
+     *     })
+     */
+    createCustomerApiKey(request: Paid.CreateCustomerApiKeyRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerApiKeyCreated>;
+    private __createCustomerApiKey;
+    /**
+     * Revokes one of this customer's keys, which then stops authenticating. Keys are never deleted: a revoked key stays listed with `revokedAt` set, and deleting the customer revokes its keys too. Revoking an already revoked key returns it unchanged. `404` when the key does not belong to this customer. Use the value returned as `customer.id`, for example `cus_abc123`; if you have your own customer ID, use the `/api/v2/customers/external/{externalId}/…` twin.
+     *
+     * @param {Paid.RevokeCustomerApiKeyRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.revokeCustomerApiKey({
+     *         id: "cus_abc123",
+     *         apiKeyId: "apiKeyId"
+     *     })
+     */
+    revokeCustomerApiKey(request: Paid.RevokeCustomerApiKeyRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerApiKey>;
+    private __revokeCustomerApiKey;
+    /**
+     * Returns the cap in force on this customer unit for one credits currency, with usage in the current period when available. Select the currency with `creditsCurrencyId`; it may be omitted only when the organization has exactly one credits currency, which is then used and echoed back. `404` when the customer or the unit does not exist, or the unit has no cap in force for that currency. The usage figures are advisory: other spend may land between this read and the next burn. Addresses the customer by your external customer id.
+     *
+     * @param {Paid.GetCustomerUnitCapByExternalIdRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.getCustomerUnitCapByExternalId({
+     *         externalId: "customer_123",
+     *         externalCustomerUnitId: "tenant-a",
+     *         creditsCurrencyId: "7f4f5d4c-55e9-4d5b-a3e7-c9eb3d2d01bf"
+     *     })
+     */
+    getCustomerUnitCapByExternalId(request: Paid.GetCustomerUnitCapByExternalIdRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerUnitCapResponse>;
+    private __getCustomerUnitCapByExternalId;
+    /**
+     * Sets the cap on this customer unit for one credits currency. Returns `changed: false` without creating a version when the effective timeline is unchanged; otherwise records a new version, preserving earlier rows. The newest version wins where they overlap. `effectiveFrom` controls applicability; `schedule` defines monthly UTC boundaries independently. Omit schedule to inherit the version covering effectiveFrom, or use the creation-time UTC day if none applies. Select the currency with `creditsCurrencyId` in the body; it may be omitted only when the organization has exactly one credits currency. A cap covers the unit and every unit beneath it, so a cap on the customer's root unit covers every unit of that customer; spend from a signal that names no unit counts toward no cap. `404` when the customer or the unit does not exist. `409` for customers on seat-based billing, a deleted unit (`CUSTOMER_UNIT_DELETED`) or a draft (`CUSTOMER_UNIT_DRAFT`). Addresses the customer by your external customer id.
+     *
+     * @param {Paid.SetCustomerUnitCapByExternalIdRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.ConflictError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.setCustomerUnitCapByExternalId({
+     *         externalId: "customer_123",
+     *         externalCustomerUnitId: "tenant-a",
+     *         body: {
+     *             amount: 10000
+     *         }
+     *     })
+     */
+    setCustomerUnitCapByExternalId(request: Paid.SetCustomerUnitCapByExternalIdRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerUnitCapSetResponse>;
+    private __setCustomerUnitCapByExternalId;
+    /**
+     * Ends the cap on this customer unit for one credits currency by setting `effectiveUntil` to now on every open version — the one in force, older overlapping versions still open, and versions scheduled to start later — so nothing can resurface or activate afterwards; nothing is deleted and history is kept. Select the currency with `creditsCurrencyId`; it may be omitted only when the organization has exactly one credits currency. `404` when the customer or the unit does not exist, or there is no open version for that currency. Addresses the customer by your external customer id.
+     *
+     * @param {Paid.EndCustomerUnitCapByExternalIdRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.ConflictError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.endCustomerUnitCapByExternalId({
+     *         externalId: "customer_123",
+     *         externalCustomerUnitId: "tenant-a",
+     *         creditsCurrencyId: "7f4f5d4c-55e9-4d5b-a3e7-c9eb3d2d01bf"
+     *     })
+     */
+    endCustomerUnitCapByExternalId(request: Paid.EndCustomerUnitCapByExternalIdRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerUnitCapEndResponse>;
+    private __endCustomerUnitCapByExternalId;
+    /**
+     * Returns the credits of one credits currency spent by this customer unit and every unit beneath it during a window, whether or not the unit has a cap. The window runs from `start` (inclusive) to `end` (exclusive), at most 366 days; omit both for the current calendar month (UTC). For a capped unit over its cap's current period, `spent` equals the cap's `used`. Spend from a signal that names no unit counts toward no unit. Select the currency with `creditsCurrencyId`; it may be omitted only when the organization has exactly one credits currency, which is then used and echoed back. `404` when the customer or the unit does not exist. Addresses the customer by your external customer id.
+     *
+     * @param {Paid.GetCustomerUnitSpendByExternalIdRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.getCustomerUnitSpendByExternalId({
+     *         externalId: "customer_123",
+     *         externalCustomerUnitId: "tenant-a",
+     *         creditsCurrencyId: "7f4f5d4c-55e9-4d5b-a3e7-c9eb3d2d01bf",
+     *         start: "2026-10-01T00:00:00Z",
+     *         end: "2026-11-01T00:00:00Z"
+     *     })
+     */
+    getCustomerUnitSpendByExternalId(request: Paid.GetCustomerUnitSpendByExternalIdRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerUnitSpendResponse>;
+    private __getCustomerUnitSpendByExternalId;
+    /**
+     * Returns the cap in force on this customer unit for one credits currency, with usage in the current period when available. Select the currency with `creditsCurrencyId`; it may be omitted only when the organization has exactly one credits currency, which is then used and echoed back. `404` when the customer or the unit does not exist, or the unit has no cap in force for that currency. The usage figures are advisory: other spend may land between this read and the next burn. Use the value returned as `customer.id`, for example `cus_abc123`; if you have your own customer ID, use the `/api/v2/customers/external/{externalId}/…` twin.
+     *
+     * @param {Paid.GetCustomerUnitCapRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.getCustomerUnitCap({
+     *         id: "cus_abc123",
+     *         externalCustomerUnitId: "tenant-a",
+     *         creditsCurrencyId: "7f4f5d4c-55e9-4d5b-a3e7-c9eb3d2d01bf"
+     *     })
+     */
+    getCustomerUnitCap(request: Paid.GetCustomerUnitCapRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerUnitCapResponse>;
+    private __getCustomerUnitCap;
+    /**
+     * Sets the cap on this customer unit for one credits currency. Returns `changed: false` without creating a version when the effective timeline is unchanged; otherwise records a new version, preserving earlier rows. The newest version wins where they overlap. `effectiveFrom` controls applicability; `schedule` defines monthly UTC boundaries independently. Omit schedule to inherit the version covering effectiveFrom, or use the creation-time UTC day if none applies. Select the currency with `creditsCurrencyId` in the body; it may be omitted only when the organization has exactly one credits currency. A cap covers the unit and every unit beneath it, so a cap on the customer's root unit covers every unit of that customer; spend from a signal that names no unit counts toward no cap. `404` when the customer or the unit does not exist. `409` for customers on seat-based billing, a deleted unit (`CUSTOMER_UNIT_DELETED`) or a draft (`CUSTOMER_UNIT_DRAFT`). Use the value returned as `customer.id`, for example `cus_abc123`; if you have your own customer ID, use the `/api/v2/customers/external/{externalId}/…` twin.
+     *
+     * @param {Paid.SetCustomerUnitCapRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.ConflictError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.setCustomerUnitCap({
+     *         id: "cus_abc123",
+     *         externalCustomerUnitId: "tenant-a",
+     *         body: {
+     *             amount: 10000
+     *         }
+     *     })
+     */
+    setCustomerUnitCap(request: Paid.SetCustomerUnitCapRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerUnitCapSetResponse>;
+    private __setCustomerUnitCap;
+    /**
+     * Ends the cap on this customer unit for one credits currency by setting `effectiveUntil` to now on every open version — the one in force, older overlapping versions still open, and versions scheduled to start later — so nothing can resurface or activate afterwards; nothing is deleted and history is kept. Select the currency with `creditsCurrencyId`; it may be omitted only when the organization has exactly one credits currency. `404` when the customer or the unit does not exist, or there is no open version for that currency. Use the value returned as `customer.id`, for example `cus_abc123`; if you have your own customer ID, use the `/api/v2/customers/external/{externalId}/…` twin.
+     *
+     * @param {Paid.EndCustomerUnitCapRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.ConflictError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.endCustomerUnitCap({
+     *         id: "cus_abc123",
+     *         externalCustomerUnitId: "tenant-a",
+     *         creditsCurrencyId: "7f4f5d4c-55e9-4d5b-a3e7-c9eb3d2d01bf"
+     *     })
+     */
+    endCustomerUnitCap(request: Paid.EndCustomerUnitCapRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerUnitCapEndResponse>;
+    private __endCustomerUnitCap;
+    /**
+     * Returns the credits of one credits currency spent by this customer unit and every unit beneath it during a window, whether or not the unit has a cap. The window runs from `start` (inclusive) to `end` (exclusive), at most 366 days; omit both for the current calendar month (UTC). For a capped unit over its cap's current period, `spent` equals the cap's `used`. Spend from a signal that names no unit counts toward no unit. Select the currency with `creditsCurrencyId`; it may be omitted only when the organization has exactly one credits currency, which is then used and echoed back. `404` when the customer or the unit does not exist. Use the value returned as `customer.id`, for example `cus_abc123`; if you have your own customer ID, use the `/api/v2/customers/external/{externalId}/…` twin.
+     *
+     * @param {Paid.GetCustomerUnitSpendRequest} request
+     * @param {Customers.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Paid.BadRequestError}
+     * @throws {@link Paid.ForbiddenError}
+     * @throws {@link Paid.NotFoundError}
+     * @throws {@link Paid.InternalServerError}
+     *
+     * @example
+     *     await client.customers.getCustomerUnitSpend({
+     *         id: "cus_abc123",
+     *         externalCustomerUnitId: "tenant-a",
+     *         creditsCurrencyId: "7f4f5d4c-55e9-4d5b-a3e7-c9eb3d2d01bf",
+     *         start: "2026-10-01T00:00:00Z",
+     *         end: "2026-11-01T00:00:00Z"
+     *     })
+     */
+    getCustomerUnitSpend(request: Paid.GetCustomerUnitSpendRequest, requestOptions?: Customers.RequestOptions): core.HttpResponsePromise<Paid.CustomerUnitSpendResponse>;
+    private __getCustomerUnitSpend;
     protected _getAuthorizationHeader(): Promise<string>;
 }