api/spec/packages/aip-client-javascript/src/sdk/customers.ts

// Code generated by @openmeter/typespec-typescript. DO NOT EDIT.

import { type Client } from '../core.js'
import { unwrap, type RequestOptions } from '../lib/types.js'
import { paginateCursor, paginatePages } from '../lib/paginate.js'
import {
  createCustomer,
  getCustomer,
  listCustomers,
  upsertCustomer,
  deleteCustomer,
  getCustomerBilling,
  updateCustomerBilling,
  updateCustomerBillingAppData,
  createCustomerStripeCheckoutSession,
  createCustomerStripePortalSession,
  createCreditGrant,
  getCreditGrant,
  listCreditGrants,
  getCustomerCreditBalance,
  createCreditAdjustment,
  voidCreditGrant,
  updateCreditGrantExternalSettlement,
  listCreditTransactions,
  listCustomerCharges,
  createCustomerCharges,
} from '../funcs/customers.js'
import type {
  CreateCustomerRequest,
  CreateCustomerResponse,
  GetCustomerRequest,
  GetCustomerResponse,
  ListCustomersRequest,
  ListCustomersResponse,
  UpsertCustomerRequest,
  UpsertCustomerResponse,
  DeleteCustomerRequest,
  DeleteCustomerResponse,
  GetCustomerBillingRequest,
  GetCustomerBillingResponse,
  UpdateCustomerBillingRequest,
  UpdateCustomerBillingResponse,
  UpdateCustomerBillingAppDataRequest,
  UpdateCustomerBillingAppDataResponse,
  CreateCustomerStripeCheckoutSessionRequest,
  CreateCustomerStripeCheckoutSessionResponse,
  CreateCustomerStripePortalSessionRequest,
  CreateCustomerStripePortalSessionResponse,
  CreateCreditGrantRequest,
  CreateCreditGrantResponse,
  GetCreditGrantRequest,
  GetCreditGrantResponse,
  ListCreditGrantsRequest,
  ListCreditGrantsResponse,
  GetCustomerCreditBalanceRequest,
  GetCustomerCreditBalanceResponse,
  CreateCreditAdjustmentRequest,
  CreateCreditAdjustmentResponse,
  VoidCreditGrantRequest,
  VoidCreditGrantResponse,
  UpdateCreditGrantExternalSettlementRequest,
  UpdateCreditGrantExternalSettlementResponse,
  ListCreditTransactionsRequest,
  ListCreditTransactionsResponse,
  ListCustomerChargesRequest,
  ListCustomerChargesResponse,
  CreateCustomerChargesRequest,
  CreateCustomerChargesResponse,
} from '../models/operations/customers.js'
import type {
  Charge,
  CreditGrant,
  CreditTransaction,
  Customer,
} from '../models/types.js'

export class Customers {
  constructor(private readonly _client: Client) {}

  /**
   * Create customer
   *
   * POST /openmeter/customers
   */
  async create(
    request: CreateCustomerRequest,
    options?: RequestOptions,
  ): Promise<CreateCustomerResponse> {
    return unwrap(await createCustomer(this._client, request, options))
  }

  /**
   * Get customer
   *
   * GET /openmeter/customers/{customerId}
   */
  async get(
    request: GetCustomerRequest,
    options?: RequestOptions,
  ): Promise<GetCustomerResponse> {
    return unwrap(await getCustomer(this._client, request, options))
  }

  /**
   * List customers
   *
   * GET /openmeter/customers
   */
  async list(
    request?: ListCustomersRequest,
    options?: RequestOptions,
  ): Promise<ListCustomersResponse> {
    return unwrap(await listCustomers(this._client, request, options))
  }

  /**
   * List customers
   *
   * Iterates every item across all pages, fetching more as the returned iterable is consumed.
   *
   * GET /openmeter/customers
   */
  listAll(
    request?: ListCustomersRequest,
    options?: RequestOptions,
  ): AsyncIterable<Customer> {
    return paginatePages(
      (req, opts) => listCustomers(this._client, req, opts),
      request ?? {},
      options,
    )
  }

  /**
   * Upsert customer
   *
   * PUT /openmeter/customers/{customerId}
   */
  async upsert(
    request: UpsertCustomerRequest,
    options?: RequestOptions,
  ): Promise<UpsertCustomerResponse> {
    return unwrap(await upsertCustomer(this._client, request, options))
  }

  /**
   * Delete customer
   *
   * DELETE /openmeter/customers/{customerId}
   */
  async delete(
    request: DeleteCustomerRequest,
    options?: RequestOptions,
  ): Promise<DeleteCustomerResponse> {
    return unwrap(await deleteCustomer(this._client, request, options))
  }

  private _billing?: CustomersBilling
  get billing(): CustomersBilling {
    return (this._billing ??= new CustomersBilling(this._client))
  }

  private _credits?: CustomersCredits
  get credits(): CustomersCredits {
    return (this._credits ??= new CustomersCredits(this._client))
  }

  private _charges?: CustomersCharges
  get charges(): CustomersCharges {
    return (this._charges ??= new CustomersCharges(this._client))
  }
}

export class CustomersBilling {
  constructor(private readonly _client: Client) {}

  /**
   * Get customer billing data
   *
   * GET /openmeter/customers/{customerId}/billing
   */
  async get(
    request: GetCustomerBillingRequest,
    options?: RequestOptions,
  ): Promise<GetCustomerBillingResponse> {
    return unwrap(await getCustomerBilling(this._client, request, options))
  }

  /**
   * Update customer billing data
   *
   * PUT /openmeter/customers/{customerId}/billing
   */
  async update(
    request: UpdateCustomerBillingRequest,
    options?: RequestOptions,
  ): Promise<UpdateCustomerBillingResponse> {
    return unwrap(await updateCustomerBilling(this._client, request, options))
  }

  /**
   * Update customer billing app data
   *
   * PUT /openmeter/customers/{customerId}/billing/app-data
   */
  async updateAppData(
    request: UpdateCustomerBillingAppDataRequest,
    options?: RequestOptions,
  ): Promise<UpdateCustomerBillingAppDataResponse> {
    return unwrap(
      await updateCustomerBillingAppData(this._client, request, options),
    )
  }

  /**
   * Create Stripe Checkout Session
   *
   * Create a [Stripe Checkout Session](https://docs.stripe.com/payments/checkout)
   * for the customer.
   *
   * Creates a Checkout Session for collecting payment method information from
   * customers. The session operates in "setup" mode, which collects payment details
   * without charging the customer immediately. The collected payment method can be
   * used for future subscription billing.
   *
   * For hosted checkout sessions, redirect customers to the returned URL. For
   * embedded sessions, use the client_secret to initialize Stripe.js in your
   * application.
   *
   * POST /openmeter/customers/{customerId}/billing/stripe/checkout-sessions
   */
  async createStripeCheckoutSession(
    request: CreateCustomerStripeCheckoutSessionRequest,
    options?: RequestOptions,
  ): Promise<CreateCustomerStripeCheckoutSessionResponse> {
    return unwrap(
      await createCustomerStripeCheckoutSession(this._client, request, options),
    )
  }

  /**
   * Create Stripe customer portal session
   *
   * Create Stripe Customer Portal Session.
   *
   * Useful to redirect the customer to the Stripe Customer Portal to manage their
   * payment methods, change their billing address and access their invoice history.
   * Only returns URL if the customer billing profile is linked to a stripe app and
   * customer.
   *
   * POST /openmeter/customers/{customerId}/billing/stripe/portal-sessions
   */
  async createStripePortalSession(
    request: CreateCustomerStripePortalSessionRequest,
    options?: RequestOptions,
  ): Promise<CreateCustomerStripePortalSessionResponse> {
    return unwrap(
      await createCustomerStripePortalSession(this._client, request, options),
    )
  }
}

export class CustomersCredits {
  constructor(private readonly _client: Client) {}

  private _grants?: CustomersCreditsGrants
  get grants(): CustomersCreditsGrants {
    return (this._grants ??= new CustomersCreditsGrants(this._client))
  }

  private _balance?: CustomersCreditsBalance
  get balance(): CustomersCreditsBalance {
    return (this._balance ??= new CustomersCreditsBalance(this._client))
  }

  private _adjustments?: CustomersCreditsAdjustments
  get adjustments(): CustomersCreditsAdjustments {
    return (this._adjustments ??= new CustomersCreditsAdjustments(this._client))
  }

  private _transactions?: CustomersCreditsTransactions
  get transactions(): CustomersCreditsTransactions {
    return (this._transactions ??= new CustomersCreditsTransactions(
      this._client,
    ))
  }
}

export class CustomersCreditsGrants {
  constructor(private readonly _client: Client) {}

  /**
   * Create a new credit grant
   *
   * Create a new credit grant. A credit grant represents an allocation of prepaid
   * credits to a customer.
   *
   * POST /openmeter/customers/{customerId}/credits/grants
   */
  async create(
    request: CreateCreditGrantRequest,
    options?: RequestOptions,
  ): Promise<CreateCreditGrantResponse> {
    return unwrap(await createCreditGrant(this._client, request, options))
  }

  /**
   * Get a credit grant
   *
   * Get a credit grant.
   *
   * GET /openmeter/customers/{customerId}/credits/grants/{creditGrantId}
   */
  async get(
    request: GetCreditGrantRequest,
    options?: RequestOptions,
  ): Promise<GetCreditGrantResponse> {
    return unwrap(await getCreditGrant(this._client, request, options))
  }

  /**
   * List credit grants
   *
   * List credit grants.
   *
   * GET /openmeter/customers/{customerId}/credits/grants
   */
  async list(
    request: ListCreditGrantsRequest,
    options?: RequestOptions,
  ): Promise<ListCreditGrantsResponse> {
    return unwrap(await listCreditGrants(this._client, request, options))
  }

  /**
   * List credit grants
   *
   * List credit grants.
   *
   * Iterates every item across all pages, fetching more as the returned iterable is consumed.
   *
   * GET /openmeter/customers/{customerId}/credits/grants
   */
  listAll(
    request: ListCreditGrantsRequest,
    options?: RequestOptions,
  ): AsyncIterable<CreditGrant> {
    return paginatePages(
      (req, opts) => listCreditGrants(this._client, req, opts),
      request,
      options,
    )
  }

  /**
   * Void credit grant
   *
   * Void a credit grant, forfeiting the remaining unused balance.
   *
   * Voiding is a forward-looking, irreversible operation. Credits already consumed
   * by usage remain unaffected — only the remaining balance is forfeited. The grant
   * reads as `voided` status afterwards. Payment state is not adjusted when
   * `payment_adjustment` is `none`, so invoice-backed or externally collected
   * payments may still collect the original amount. Only `active` grants can be
   * voided; voiding a pending, expired, or fully consumed grant returns a conflict.
   * Retrying a successful void is an idempotent success.
   *
   * POST /openmeter/customers/{customerId}/credits/grants/{creditGrantId}/void
   */
  async void(
    request: VoidCreditGrantRequest,
    options?: RequestOptions,
  ): Promise<VoidCreditGrantResponse> {
    return unwrap(await voidCreditGrant(this._client, request, options))
  }

  /**
   * Update credit grant external settlement status
   *
   * Update the payment settlement status of an externally funded credit grant.
   *
   * Use this endpoint to synchronize the payment state of an external payment with
   * the system so that revenue recognition and credit availability work as expected.
   *
   * POST /openmeter/customers/{customerId}/credits/grants/{creditGrantId}/settlement/external
   */
  async updateExternalSettlement(
    request: UpdateCreditGrantExternalSettlementRequest,
    options?: RequestOptions,
  ): Promise<UpdateCreditGrantExternalSettlementResponse> {
    return unwrap(
      await updateCreditGrantExternalSettlement(this._client, request, options),
    )
  }
}

export class CustomersCreditsBalance {
  constructor(private readonly _client: Client) {}

  /**
   * Get a customer's credit balance
   *
   * Get a credit balance.
   *
   * GET /openmeter/customers/{customerId}/credits/balance
   */
  async get(
    request: GetCustomerCreditBalanceRequest,
    options?: RequestOptions,
  ): Promise<GetCustomerCreditBalanceResponse> {
    return unwrap(
      await getCustomerCreditBalance(this._client, request, options),
    )
  }
}

export class CustomersCreditsAdjustments {
  constructor(private readonly _client: Client) {}

  /**
   * Create a credit adjustment
   *
   * A credit adjustment can be used to make manual adjustments to a customer's
   * credit balance.
   *
   * Supported use-cases:
   *
   * - Usage correction
   *
   * POST /openmeter/customers/{customerId}/credits/adjustments
   */
  async create(
    request: CreateCreditAdjustmentRequest,
    options?: RequestOptions,
  ): Promise<CreateCreditAdjustmentResponse> {
    return unwrap(await createCreditAdjustment(this._client, request, options))
  }
}

export class CustomersCreditsTransactions {
  constructor(private readonly _client: Client) {}

  /**
   * List credit transactions
   *
   * List credit transactions for a customer.
   *
   * Returns an immutable, chronological record of credit movements: funded credits
   * and consumed credits. Transactions are returned in reverse chronological order
   * by default.
   *
   * GET /openmeter/customers/{customerId}/credits/transactions
   */
  async list(
    request: ListCreditTransactionsRequest,
    options?: RequestOptions,
  ): Promise<ListCreditTransactionsResponse> {
    return unwrap(await listCreditTransactions(this._client, request, options))
  }

  /**
   * List credit transactions
   *
   * List credit transactions for a customer.
   *
   * Returns an immutable, chronological record of credit movements: funded credits
   * and consumed credits. Transactions are returned in reverse chronological order
   * by default.
   *
   * Iterates every item across all pages, fetching more as the returned iterable is consumed.
   *
   * GET /openmeter/customers/{customerId}/credits/transactions
   */
  listAll(
    request: ListCreditTransactionsRequest,
    options?: RequestOptions,
  ): AsyncIterable<CreditTransaction> {
    return paginateCursor(
      (req, opts) => listCreditTransactions(this._client, req, opts),
      request,
      options,
    )
  }
}

export class CustomersCharges {
  constructor(private readonly _client: Client) {}

  /**
   * List customer charges
   *
   * List customer charges.
   *
   * Returns the customer's charges that are represented as either flat fee or
   * usage-based charges.
   *
   * GET /openmeter/customers/{customerId}/charges
   */
  async list(
    request: ListCustomerChargesRequest,
    options?: RequestOptions,
  ): Promise<ListCustomerChargesResponse> {
    return unwrap(await listCustomerCharges(this._client, request, options))
  }

  /**
   * List customer charges
   *
   * List customer charges.
   *
   * Returns the customer's charges that are represented as either flat fee or
   * usage-based charges.
   *
   * Iterates every item across all pages, fetching more as the returned iterable is consumed.
   *
   * GET /openmeter/customers/{customerId}/charges
   */
  listAll(
    request: ListCustomerChargesRequest,
    options?: RequestOptions,
  ): AsyncIterable<Charge> {
    return paginatePages(
      (req, opts) => listCustomerCharges(this._client, req, opts),
      request,
      options,
    )
  }

  /**
   * Create customer charge
   *
   * Create customer charge.
   *
   * POST /openmeter/customers/{customerId}/charges
   */
  async create(
    request: CreateCustomerChargesRequest,
    options?: RequestOptions,
  ): Promise<CreateCustomerChargesResponse> {
    return unwrap(await createCustomerCharges(this._client, request, options))
  }
}