@geekapps/billing-fastify 0.13.0 → 0.16.1

package/dist/index.js

@@ -141,13 +141,22 @@ var BillingApiError = class extends Error {
 
 // src/http.ts
 var DEFAULT_MODE = "prod";
-var HttpClient = class {
+var HttpClient = class _HttpClient {
   constructor(options) {
+    this.options = options;
     this.baseUrl = options.baseUrl.replace(/\/$/, "");
     this.token = options.token;
     this.organizationId = options.organizationId;
     this.mode = options.mode ?? DEFAULT_MODE;
   }
+  /**
+   * Cliente com as mesmas credenciais e o modo sobrescrito por `opts.mode` — sem override,
+   * devolve a própria instância (modo geral).
+   */
+  with(opts) {
+    if (!opts?.mode) return this;
+    return new _HttpClient({ ...this.options, mode: opts.mode });
+  }
   async resolveToken() {
     return typeof this.token === "function" ? await this.token() : this.token;
   }
@@ -155,6 +164,10 @@ var HttpClient = class {
     if (!this.organizationId) return void 0;
     return typeof this.organizationId === "function" ? await this.organizationId() : this.organizationId;
   }
+  /** Modo efetivo desta instância (geral ou sobrescrito via `with`). */
+  currentMode() {
+    return this.resolveMode();
+  }
   async resolveMode() {
     return typeof this.mode === "function" ? await this.mode() : this.mode;
   }
@@ -207,9 +220,9 @@ var ChargesResource = class {
   constructor(http) {
     this.http = http;
   }
-  list(params) {
+  list(params, opts) {
     const qs = params?.installment_group_id ? `?installment_group_id=${encodeURIComponent(params.installment_group_id)}` : "";
-    return this.http.get(`/charges${qs}`);
+    return this.http.with(opts).get(`/charges${qs}`);
   }
   /**
    * Cria uma cobrança (PIX, boleto ou cartão). A geração de fato acontece de forma
@@ -217,8 +230,8 @@ var ChargesResource = class {
    * do método (QR code, boleto, etc) ainda preenchidos. Use `get`/`getStatus` para
    * acompanhar até que estejam prontos.
    */
-  create(input) {
-    return this.http.post("/charges", input);
+  create(input, opts) {
+    return this.http.with(opts).post("/charges", input);
   }
   /**
    * Cobrança avulsa simples, sempre em cartão — cobra direto no cartão padrão já
@@ -233,24 +246,24 @@ var ChargesResource = class {
    * }
    * ```
    */
-  charge(customerId, amountCents, options) {
-    return this.http.post("/charges/quick", {
+  charge(customerId, amountCents, options, opts) {
+    return this.http.with(opts).post("/charges/quick", {
       customer_id: customerId,
       amount: amountCents,
       ...options
     });
   }
-  get(id) {
-    return this.http.get(`/charges/${id}`);
+  get(id, opts) {
+    return this.http.with(opts).get(`/charges/${id}`);
   }
-  getStatus(id) {
-    return this.http.get(`/charges/${id}/status`);
+  getStatus(id, opts) {
+    return this.http.with(opts).get(`/charges/${id}/status`);
   }
-  cancel(id) {
-    return this.http.patch(`/charges/${id}/cancel`);
+  cancel(id, opts) {
+    return this.http.with(opts).patch(`/charges/${id}/cancel`);
   }
-  refund(id) {
-    return this.http.post(`/charges/${id}/refund`);
+  refund(id, opts) {
+    return this.http.with(opts).post(`/charges/${id}/refund`);
   }
 };
 
@@ -262,8 +275,8 @@ var CheckoutResource = class {
   /** Consulta o status atual de uma cobrança/checkout pelo `checkout_token` retornado
    * por `plans.checkout()` (ou qualquer outro fluxo de cobrança do SDK). Sincroniza com
    * o provedor de pagamento sob o capô quando ainda está PENDING. */
-  getStatus(checkoutToken) {
-    return this.http.get(`/checkout/${checkoutToken}/status`);
+  getStatus(checkoutToken, opts) {
+    return this.http.with(opts).get(`/checkout/${checkoutToken}/status`);
   }
   /**
    * Faz polling de `getStatus` até o pagamento ser confirmado (ou falhar/expirar) — é
@@ -278,7 +291,7 @@ var CheckoutResource = class {
     const timeoutMs = options.timeoutMs ?? 5 * 60 * 1e3;
     const deadline = Date.now() + timeoutMs;
     for (; ; ) {
-      const result = await this.getStatus(checkoutToken);
+      const result = await this.getStatus(checkoutToken, { mode: options.mode });
       if (result.status !== "PENDING" && result.status !== "PROCESSING") {
         return result;
       }
@@ -295,14 +308,14 @@ var CouponsResource = class {
   constructor(http) {
     this.http = http;
   }
-  list() {
-    return this.http.get("/coupons");
+  list(opts) {
+    return this.http.with(opts).get("/coupons");
   }
   /** `idOrCode` aceita tanto o id interno (`coupon.id`) quanto o `code` legível que você
    * escolheu na criação (ex: `"BEMVINDO20"`) — normalmente é mais prático guardar/usar o
    * `code`, já que é você quem o define e é o que aparece para o cliente final. */
-  get(idOrCode) {
-    return this.http.get(`/coupons/${idOrCode}`);
+  get(idOrCode, opts) {
+    return this.http.with(opts).get(`/coupons/${idOrCode}`);
   }
   /**
    * Cria um cupom de desconto — o `code` é o que o cliente final informa no checkout
@@ -318,19 +331,19 @@ var CouponsResource = class {
    * });
    * ```
    */
-  create(input) {
-    return this.http.post("/coupons", input);
+  create(input, opts) {
+    return this.http.with(opts).post("/coupons", input);
   }
   /** Só permite editar limites/validade/ativação — o desconto em si (type/value/duration)
    * de um cupom já criado é imutável; crie um novo código para mudar o valor do desconto.
    * `idOrCode` aceita id interno ou `code` (ver `get`). */
-  update(idOrCode, input) {
-    return this.http.patch(`/coupons/${idOrCode}`, input);
+  update(idOrCode, input, opts) {
+    return this.http.with(opts).patch(`/coupons/${idOrCode}`, input);
   }
   /** Desativa o cupom (soft-delete) — códigos já resgatados continuam no histórico.
    * `idOrCode` aceita id interno ou `code` (ver `get`). */
-  remove(idOrCode) {
-    return this.http.delete(`/coupons/${idOrCode}`);
+  remove(idOrCode, opts) {
+    return this.http.with(opts).delete(`/coupons/${idOrCode}`);
   }
 };
 
@@ -340,24 +353,26 @@ var CustomersResource = class {
     this.http = http;
   }
   /** Lista clientes — opcionalmente filtrando por `external_ref`, `tax_id` ou `customer_type`. */
-  list(filters = {}) {
+  list(filters = {}, opts) {
     const qs = new URLSearchParams(Object.entries(filters).filter(([, v]) => v)).toString();
-    return this.http.get(qs ? `/customers?${qs}` : "/customers");
+    return this.http.with(opts).get(qs ? `/customers?${qs}` : "/customers");
   }
   /**
    * Busca o cliente de cobrança pela referência do seu app (ex: `"company:456"`). Use ao
    * trocar de conta (pessoal ↔ empresa) para operar nos cartões da conta ativa.
    */
-  async findByExternalRef(externalRef) {
-    const [c] = await this.list({ external_ref: externalRef });
+  async findByExternalRef(externalRef, opts) {
+    const [c] = await this.list({ external_ref: externalRef }, opts);
     return c ?? null;
   }
   /**
    * Valida um CPF/CNPJ e, para CNPJ, retorna razão social, nome fantasia e endereço da
    * Receita Federal — use para pré-preencher o cadastro assim que o usuário digitar.
+   * Consulta em cascata (Minha Receita → BrasilAPI → CNPJá → CNPJ.ws → ReceitaWS); 404
+   * quando nenhuma base encontra o CNPJ, 502 quando todas falham.
    */
-  lookupTaxId(taxId) {
-    return this.http.get(`/customers/tax-id-lookup/${encodeURIComponent(taxId.replace(/\D/g, ""))}`);
+  lookupTaxId(taxId, opts) {
+    return this.http.with(opts).get(`/customers/tax-id-lookup/${encodeURIComponent(taxId.replace(/\D/g, ""))}`);
   }
   /**
    * Cria um cliente pessoa física (CPF) ou empresa (CNPJ). Para CNPJ, os campos não
@@ -368,22 +383,36 @@ var CustomersResource = class {
    * await client.customers.create({ tax_id: "11.222.333/0001-81", email: "fin@acme.com", external_ref: "company:456" });
    * ```
    */
-  create(input) {
-    return this.http.post("/customers", input);
+  /**
+   * Busca o endereço de um CEP (ViaCEP → BrasilAPI → OpenCEP → AwesomeAPI → ApiCEP, em
+   * cascata). 404 quando nenhuma base conhece o CEP, 502 quando todas falham.
+   */
+  lookupCep(cep, opts) {
+    return this.http.with(opts).get(`/customers/cep-lookup/${encodeURIComponent(cep.replace(/\D/g, ""))}`);
+  }
+  /**
+   * Ressincroniza razão social, nome fantasia e endereço de um cliente empresa com o
+   * registro atual da Receita Federal — único jeito de alterar esses campos.
+   */
+  refreshRegistry(id, opts) {
+    return this.http.with(opts).post(`/customers/${id}/refresh-registry`);
   }
-  get(id) {
-    return this.http.get(`/customers/${id}`);
+  create(input, opts) {
+    return this.http.with(opts).post("/customers", input);
+  }
+  get(id, opts) {
+    return this.http.with(opts).get(`/customers/${id}`);
   }
   /** Atualiza dados de cobrança do cliente (nome, e-mail, endereço, CPF/CNPJ, razão social...). */
-  update(id, input) {
-    return this.http.patch(`/customers/${id}`, input);
+  update(id, input, opts) {
+    return this.http.with(opts).patch(`/customers/${id}`, input);
   }
   /**
    * Lista os métodos de pagamento salvos do cliente — nunca expõe o número completo do
    * cartão, só os 4 últimos dígitos, bandeira e validade.
    */
-  listPaymentMethods(id) {
-    return this.http.get(`/customers/${id}/payment-methods`);
+  listPaymentMethods(id, opts) {
+    return this.http.with(opts).get(`/customers/${id}/payment-methods`);
   }
   /**
    * Cria um SetupIntent para o cliente cadastrar um novo cartão — use o `clientSecret`
@@ -395,16 +424,16 @@ var CustomersResource = class {
    * // no frontend: stripe.confirmCardSetup(clientSecret, { payment_method: {...} })
    * ```
    */
-  createPaymentMethodSetupIntent(id) {
-    return this.http.post(`/customers/${id}/payment-methods/setup-intent`);
+  createPaymentMethodSetupIntent(id, opts) {
+    return this.http.with(opts).post(`/customers/${id}/payment-methods/setup-intent`);
   }
   /** Define um método de pagamento salvo como o padrão do cliente (usado em cobranças off-session). */
-  setDefaultPaymentMethod(id, paymentMethodId) {
-    return this.http.patch(`/customers/${id}/payment-methods/${paymentMethodId}/default`);
+  setDefaultPaymentMethod(id, paymentMethodId, opts) {
+    return this.http.with(opts).patch(`/customers/${id}/payment-methods/${paymentMethodId}/default`);
   }
   /** Remove um método de pagamento salvo do cliente. */
-  deletePaymentMethod(id, paymentMethodId) {
-    return this.http.delete(`/customers/${id}/payment-methods/${paymentMethodId}`);
+  deletePaymentMethod(id, paymentMethodId, opts) {
+    return this.http.with(opts).delete(`/customers/${id}/payment-methods/${paymentMethodId}`);
   }
 };
 
@@ -413,17 +442,17 @@ var ItemsResource = class {
   constructor(http) {
     this.http = http;
   }
-  list() {
-    return this.http.get("/items");
+  list(opts) {
+    return this.http.with(opts).get("/items");
   }
-  create(input) {
-    return this.http.post("/items", input);
+  create(input, opts) {
+    return this.http.with(opts).post("/items", input);
   }
-  get(id) {
-    return this.http.get(`/items/${id}`);
+  get(id, opts) {
+    return this.http.with(opts).get(`/items/${id}`);
   }
-  update(id, input) {
-    return this.http.patch(`/items/${id}`, input);
+  update(id, input, opts) {
+    return this.http.with(opts).patch(`/items/${id}`, input);
   }
 };
 
@@ -438,14 +467,14 @@ var OrdersResource = class {
    * confirmar via Stripe Elements — as parcelas seguintes são cobradas
    * automaticamente pelo backend no cartão salvo.
    */
-  create(input) {
-    return this.http.post("/orders", input);
+  create(input, opts) {
+    return this.http.with(opts).post("/orders", input);
   }
-  list() {
-    return this.http.get("/orders");
+  list(opts) {
+    return this.http.with(opts).get("/orders");
   }
-  get(id) {
-    return this.http.get(`/orders/${id}`);
+  get(id, opts) {
+    return this.http.with(opts).get(`/orders/${id}`);
   }
 };
 
@@ -454,30 +483,30 @@ var PlansResource = class {
   constructor(http) {
     this.http = http;
   }
-  list() {
-    return this.http.get("/billing-plans");
+  list(opts) {
+    return this.http.with(opts).get("/billing-plans");
   }
-  get(id) {
-    return this.http.get(`/billing-plans/${id}`);
+  get(id, opts) {
+    return this.http.with(opts).get(`/billing-plans/${id}`);
   }
-  create(input) {
-    return this.http.post("/billing-plans", input);
+  create(input, opts) {
+    return this.http.with(opts).post("/billing-plans", input);
   }
-  update(id, input) {
-    return this.http.patch(`/billing-plans/${id}`, input);
+  update(id, input, opts) {
+    return this.http.with(opts).patch(`/billing-plans/${id}`, input);
   }
   /** Não há hard-delete de planos (assinaturas existentes ainda referenciam) — para
    * remover um plano do catálogo público, arquive-o. */
-  archive(id) {
-    return this.http.patch(`/billing-plans/${id}`, { active: false });
+  archive(id, opts) {
+    return this.http.with(opts).patch(`/billing-plans/${id}`, { active: false });
   }
   /** Vincula um plano avulso a uma página de planos existente (mesma org). */
-  attachToPage(planId, pageId) {
-    return this.http.patch(`/billing-plans/${planId}`, { plan_page_id: pageId });
+  attachToPage(planId, pageId, opts) {
+    return this.http.with(opts).patch(`/billing-plans/${planId}`, { plan_page_id: pageId });
   }
   /** Desvincula um plano da sua página, tornando-o avulso (sem página pública). */
-  detachFromPage(planId) {
-    return this.http.patch(`/billing-plans/${planId}`, { plan_page_id: null });
+  detachFromPage(planId, opts) {
+    return this.http.with(opts).patch(`/billing-plans/${planId}`, { plan_page_id: null });
   }
   /**
    * Fluxo simplificado de assinatura para um `Customer` já cadastrado na sua org
@@ -497,8 +526,8 @@ var PlansResource = class {
    * }
    * ```
    */
-  checkoutPlan(planId, customerId, input) {
-    return this.http.post(`/billing-plans/${planId}/checkout-for-customer`, {
+  checkoutPlan(planId, customerId, input, opts) {
+    return this.http.with(opts).post(`/billing-plans/${planId}/checkout-for-customer`, {
       customer_id: customerId,
       ...input?.return_url ? { return_url: input.return_url } : {},
       ...input?.expires_in ? { expires_in: input.expires_in } : {},
@@ -507,18 +536,18 @@ var PlansResource = class {
   }
   /** Verifica se um `Customer` tem uma assinatura ativa deste plano (a mais recente),
    * contraparte de `checkoutPlan` no fluxo simplificado autenticado. */
-  confirmPlanSubscription(planId, customerId) {
-    return this.http.get(`/billing-plans/${planId}/subscription-status?customer_id=${encodeURIComponent(customerId)}`);
+  confirmPlanSubscription(planId, customerId, opts) {
+    return this.http.with(opts).get(`/billing-plans/${planId}/subscription-status?customer_id=${encodeURIComponent(customerId)}`);
   }
   // ─── Rotas públicas (sem auth — usadas para montar sua própria página de preços) ──
   /** Lista os planos ativos de uma org pelo slug público — página fixa legada, sem
    * suporte a múltiplas páginas. Prefira `getPublicPage` para orgs com várias páginas. */
-  listPublic(orgSlug) {
-    return this.http.get(`/public/orgs/${orgSlug}/billing-plans`);
+  listPublic(orgSlug, opts) {
+    return this.http.with(opts).get(`/public/orgs/${orgSlug}/billing-plans`);
   }
   /** Busca uma página de planos pública específica pelo slug da org + slug da página. */
-  getPublicPage(orgSlug, pageSlug) {
-    return this.http.get(`/public/orgs/${orgSlug}/plan-pages/${pageSlug}`);
+  getPublicPage(orgSlug, pageSlug, opts) {
+    return this.http.with(opts).get(`/public/orgs/${orgSlug}/plan-pages/${pageSlug}`);
   }
   /**
    * Inicia a assinatura de um plano para um cliente final: cria (ou reaproveita) o
@@ -542,8 +571,9 @@ var PlansResource = class {
    * Não requer autenticação — pode ser chamado a partir do backend do dev sem token de
    * service account, ou do próprio SDK server-side usando qualquer token válido.
    */
-  checkout(planId, input) {
-    return this.http.post(`/public/billing-plans/${planId}/checkout`, input);
+  async checkout(planId, input, opts) {
+    const http = this.http.with(opts);
+    return http.post(`/public/billing-plans/${planId}/checkout`, { ...input, mode: await http.currentMode() });
   }
 };
 
@@ -553,8 +583,8 @@ var SubscriptionsResource = class {
     this.http = http;
   }
   /** Requer autenticação (service account) — lista todas as assinaturas da sua org. */
-  list() {
-    return this.http.get("/billing-subscriptions");
+  list(opts) {
+    return this.http.with(opts).get("/billing-subscriptions");
   }
   /**
    * Fluxo legado de assinatura por `BillingItem` avulso (sem `BillingPlan`) — requer
@@ -567,12 +597,12 @@ var SubscriptionsResource = class {
    * });
    * ```
    */
-  create(input) {
-    return this.http.post("/billing-subscriptions", input);
+  create(input, opts) {
+    return this.http.with(opts).post("/billing-subscriptions", input);
   }
   /** Requer autenticação (service account). */
-  get(id) {
-    return this.http.get(`/billing-subscriptions/${id}`);
+  get(id, opts) {
+    return this.http.with(opts).get(`/billing-subscriptions/${id}`);
   }
   /**
    * Cancela uma assinatura — requer autenticação (service account). Cancela no provedor
@@ -587,8 +617,8 @@ var SubscriptionsResource = class {
    * await client.subscriptions.cancel(subId, { policy: "END_OF_PERIOD" });
    * ```
    */
-  cancel(id, input) {
-    return this.http.patch(`/billing-subscriptions/${id}/cancel`, {
+  cancel(id, input, opts) {
+    return this.http.with(opts).patch(`/billing-subscriptions/${id}/cancel`, {
       policy: input.policy,
       ...input.fixedRefundAmount !== void 0 ? { fixed_refund_amount: input.fixedRefundAmount } : {}
     });
@@ -600,8 +630,8 @@ var SubscriptionsResource = class {
    * uma vez CANCELLED de fato, a Subscription já foi encerrada no Stripe e não há o que
    * reverter — chame `cancel`/checkout novamente para recomeçar.
    */
-  resume(id) {
-    return this.http.patch(`/billing-subscriptions/${id}/resume`);
+  resume(id, opts) {
+    return this.http.with(opts).patch(`/billing-subscriptions/${id}/resume`);
   }
   /**
    * Calcula o preview de uma troca de plano (não muta nada) — requer autenticação
@@ -614,11 +644,11 @@ var SubscriptionsResource = class {
    * });
    * ```
    */
-  previewPlanSwap(id, input) {
+  previewPlanSwap(id, input, opts) {
     const params = new URLSearchParams({ new_plan_id: input.newPlanId, policy: input.policy });
     if (input.manualAmount !== void 0) params.set("manual_amount", String(input.manualAmount));
     if (input.couponCode) params.set("coupon_code", input.couponCode);
-    return this.http.get(`/billing-subscriptions/${id}/swap-preview?${params.toString()}`);
+    return this.http.with(opts).get(`/billing-subscriptions/${id}/swap-preview?${params.toString()}`);
   }
   /**
    * Executa a troca de plano/item de uma assinatura já existente (upgrade/downgrade de
@@ -652,8 +682,8 @@ var SubscriptionsResource = class {
    * }
    * ```
    */
-  swapPlan(id, input) {
-    return this.http.patch(`/billing-subscriptions/${id}/swap`, {
+  swapPlan(id, input, opts) {
+    return this.http.with(opts).patch(`/billing-subscriptions/${id}/swap`, {
       new_plan_id: input.newPlanId,
       policy: input.policy,
       ...input.manualAmount !== void 0 ? { manual_amount: input.manualAmount } : {},
@@ -674,8 +704,8 @@ var SubscriptionsResource = class {
    * await client.subscriptions.cancelPendingPlanSwap(subId);
    * ```
    */
-  cancelPendingPlanSwap(id) {
-    return this.http.delete(`/billing-subscriptions/${id}/swap`);
+  cancelPendingPlanSwap(id, opts) {
+    return this.http.with(opts).delete(`/billing-subscriptions/${id}/swap`);
   }
   /**
    * Verifica se uma assinatura está ativa e qual item ela cobre, usando o
@@ -690,8 +720,8 @@ var SubscriptionsResource = class {
    * }
    * ```
    */
-  checkByToken(managementToken) {
-    return this.http.get(`/public/plan-management/${managementToken}`);
+  checkByToken(managementToken, opts) {
+    return this.http.with(opts).get(`/public/plan-management/${managementToken}`);
   }
 };
 
@@ -701,8 +731,8 @@ var WebhooksResource = class {
     this.http = http;
   }
   /** Lista os webhooks outbound cadastrados na sua org (secret sempre mascarado). */
-  list() {
-    return this.http.get("/webhook-endpoints");
+  list(opts) {
+    return this.http.with(opts).get("/webhook-endpoints");
   }
   /**
    * Registra um webhook outbound — idempotente por (org, url): chamar de novo com a
@@ -711,33 +741,39 @@ var WebhooksResource = class {
    * `X-Geekapps-Signature` nas entregas recebidas. Passe `secret` para definir o seu
    * próprio signing secret; se omitido, um valor aleatório é gerado automaticamente.
    */
-  register(input) {
-    return this.http.post("/webhook-endpoints", {
+  register(input, opts) {
+    return this.http.with(opts).post("/webhook-endpoints", {
       url: input.url,
       event_types: input.eventTypes,
       ...input.secret ? { secret: input.secret } : {}
     });
   }
   /** Edita um webhook existente — URL, eventos assinados e/ou status ativo/inativo. */
-  update(id, input) {
-    return this.http.patch(`/webhook-endpoints/${id}`, {
+  update(id, input, opts) {
+    return this.http.with(opts).patch(`/webhook-endpoints/${id}`, {
       ...input.url ? { url: input.url } : {},
       ...input.eventTypes ? { event_types: input.eventTypes } : {},
       ...input.active !== void 0 ? { active: input.active } : {}
     });
   }
   /** Gera um novo secret e substitui o atual — a versão antiga deixa de validar imediatamente. */
-  rotateSecret(id) {
-    return this.http.post(`/webhook-endpoints/${id}/rotate-secret`);
+  rotateSecret(id, opts) {
+    return this.http.with(opts).post(`/webhook-endpoints/${id}/rotate-secret`);
   }
-  remove(id) {
-    return this.http.delete(`/webhook-endpoints/${id}`);
+  remove(id, opts) {
+    return this.http.with(opts).delete(`/webhook-endpoints/${id}`);
   }
 };
 
 // src/client.ts
-var BillingClient = class {
+var BillingClient = class _BillingClient {
+  /**
+   * O `mode` passado aqui é o modo geral (default "prod"). Qualquer método aceita um
+   * override por chamada no último parâmetro — ex.: `charges.create(input, { mode: "dev" })`
+   * — ou use `withMode("dev")` para um bloco inteiro de chamadas.
+   */
   constructor(options) {
+    this.options = options;
     this.http = new HttpClient(options);
     this.charges = new ChargesResource(this.http);
     this.checkout = new CheckoutResource(this.http);
@@ -749,6 +785,19 @@ var BillingClient = class {
     this.subscriptions = new SubscriptionsResource(this.http);
     this.webhooks = new WebhooksResource(this.http);
   }
+  /**
+   * Cópia do cliente com outro modo (mesmas credenciais) — útil para várias chamadas
+   * seguidas em dev sem repetir `{ mode: "dev" }` em cada uma.
+   *
+   * ```ts
+   * const dev = billing.withMode("dev");
+   * const customer = await dev.customers.create({ ... });
+   * await dev.charges.create({ customer_id: customer.id, ... });
+   * ```
+   */
+  withMode(mode) {
+    return new _BillingClient({ ...this.options, mode });
+  }
 };
 
 // src/plugin.ts