dodopayments 1.53.2 → 2.0.0

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 2.0.0 (2025-09-13)
+
+Full Changelog: [v1.53.2...v2.0.0](https://github.com/dodopayments/dodopayments-typescript/compare/v1.53.2...v2.0.0)
+
+### Features
+
+* **api:** added typescript sdk for migration and updated org info ([3806e38](https://github.com/dodopayments/dodopayments-typescript/commit/3806e38ac7f1aab12d728357201f9c37d704e2e2))
+* **api:** changed target version for typescript sdk to 2.0.0 ([eedbc6f](https://github.com/dodopayments/dodopayments-typescript/commit/eedbc6f492fdfe9cba6ce592f57570a7e6a36233))
+* **api:** manual updates ([cce60af](https://github.com/dodopayments/dodopayments-typescript/commit/cce60af560973e4cd56bd3d8f07a0a6f088964b5))
+
 ## 1.53.2 (2025-09-13)
 
 Full Changelog: [v1.52.6...v1.53.2](https://github.com/dodopayments/dodopayments-node/compare/v1.52.6...v1.53.2)

package/README.md

@@ -1,10 +1,10 @@
-# Dodo Payments Node API Library
+# Dodo Payments TypeScript API Library
 
-[![NPM version](https://img.shields.io/npm/v/dodopayments.svg)](https://npmjs.org/package/dodopayments) ![npm bundle size](https://img.shields.io/bundlephobia/minzip/dodopayments)
+[![NPM version](<https://img.shields.io/npm/v/dodopayments.svg?label=npm%20(stable)>)](https://npmjs.org/package/dodopayments) ![npm bundle size](https://img.shields.io/bundlephobia/minzip/dodopayments)
 
 This library provides convenient access to the [Dodo Payments](https://dodopayments.com) REST API from server-side TypeScript or JavaScript.
 
-The REST API documentation can be found on [docs.dodopayments.com](https://docs.dodopayments.com). The full API of this library can be found in [api.md](api.md).
+The REST API documentation can be found on [docs.dodopayments.com](https://docs.dodopayments.com/api-reference/introduction). The full API of this library can be found in [api.md](api.md).
 
 It is generated with [Stainless](https://www.stainless.com/).
 
@@ -169,8 +169,10 @@ while (page.hasNextPage()) {
 ### Accessing raw Response data (e.g., headers)
 
 The "raw" `Response` returned by `fetch()` can be accessed through the `.asResponse()` method on the `APIPromise` type that all methods return.
+This method returns as soon as the headers for a successful response are received and does not consume the response body, so you are free to write custom parsing or streaming logic.
 
 You can also use the `.withResponse()` method to get the raw `Response` along with the parsed data.
+Unlike `.asResponse()` this method consumes the body, returning once it is parsed.
 
 <!-- prettier-ignore -->
 ```ts
@@ -189,6 +191,59 @@ console.log(raw.headers.get('X-My-Header'));
 console.log(checkoutSessionResponse.session_id);
 ```
 
+### Logging
+
+> [!IMPORTANT]
+> All log messages are intended for debugging only. The format and content of log messages
+> may change between releases.
+
+#### Log levels
+
+The log level can be configured in two ways:
+
+1. Via the `DODO_PAYMENTS_LOG` environment variable
+2. Using the `logLevel` client option (overrides the environment variable if set)
+
+```ts
+import DodoPayments from 'dodopayments';
+
+const client = new DodoPayments({
+  logLevel: 'debug', // Show all log messages
+});
+```
+
+Available log levels, from most to least verbose:
+
+- `'debug'` - Show debug messages, info, warnings, and errors
+- `'info'` - Show info messages, warnings, and errors
+- `'warn'` - Show warnings and errors (default)
+- `'error'` - Show only errors
+- `'off'` - Disable all logging
+
+At the `'debug'` level, all HTTP requests and responses are logged, including headers and bodies.
+Some authentication-related headers are redacted, but sensitive data in request and response bodies
+may still be visible.
+
+#### Custom logger
+
+By default, this library logs to `globalThis.console`. You can also provide a custom logger.
+Most logging libraries are supported, including [pino](https://www.npmjs.com/package/pino), [winston](https://www.npmjs.com/package/winston), [bunyan](https://www.npmjs.com/package/bunyan), [consola](https://www.npmjs.com/package/consola), [signale](https://www.npmjs.com/package/signale), and [@std/log](https://jsr.io/@std/log). If your logger doesn't work, please open an issue.
+
+When providing a custom logger, the `logLevel` option still controls which messages are emitted, messages
+below the configured level will not be sent to your logger.
+
+```ts
+import DodoPayments from 'dodopayments';
+import pino from 'pino';
+
+const logger = pino();
+
+const client = new DodoPayments({
+  logger: logger.child({ name: 'DodoPayments' }),
+  logLevel: 'debug', // Send all messages to pino, allowing it to filter
+});
+```
+
 ### Making custom/undocumented requests
 
 This library is typed for convenient access to the documented API. If you need to access undocumented
@@ -213,9 +268,8 @@ parameter. This library doesn't validate at runtime that the request matches the
 send will be sent as-is.
 
 ```ts
-client.foo.create({
-  foo: 'my_param',
-  bar: 12,
+client.checkoutSessions.create({
+  // ...
   // @ts-expect-error baz is not yet public
   baz: 'undocumented option',
 });
@@ -235,69 +289,85 @@ validate or strip extra properties from the response from the API.
 
 ### Customizing the fetch client
 
-By default, this library uses `node-fetch` in Node, and expects a global `fetch` function in other environments.
+By default, this library expects a global `fetch` function is defined.
 
-If you would prefer to use a global, web-standards-compliant `fetch` function even in a Node environment,
-(for example, if you are running Node with `--experimental-fetch` or using NextJS which polyfills with `undici`),
-add the following import before your first import `from "DodoPayments"`:
+If you want to use a different `fetch` function, you can either polyfill the global:
 
 ```ts
-// Tell TypeScript and the package to use the global web fetch instead of node-fetch.
-// Note, despite the name, this does not add any polyfills, but expects them to be provided if needed.
-import 'dodopayments/shims/web';
-import DodoPayments from 'dodopayments';
+import fetch from 'my-fetch';
+
+globalThis.fetch = fetch;
 ```
 
-To do the inverse, add `import "dodopayments/shims/node"` (which does import polyfills).
-This can also be useful if you are getting the wrong TypeScript types for `Response` ([more details](https://github.com/dodopayments/dodopayments-node/tree/main/src/_shims#readme)).
+Or pass it to the client:
 
-### Logging and middleware
+```ts
+import DodoPayments from 'dodopayments';
+import fetch from 'my-fetch';
 
-You may also provide a custom `fetch` function when instantiating the client,
-which can be used to inspect or alter the `Request` or `Response` before/after each request:
+const client = new DodoPayments({ fetch });
+```
+
+### Fetch options
+
+If you want to set custom `fetch` options without overriding the `fetch` function, you can provide a `fetchOptions` object when instantiating the client or making a request. (Request-specific options override client options.)
 
 ```ts
-import { fetch } from 'undici'; // as one example
 import DodoPayments from 'dodopayments';
 
 const client = new DodoPayments({
-  fetch: async (url: RequestInfo, init?: RequestInit): Promise<Response> => {
-    console.log('About to make a request', url, init);
-    const response = await fetch(url, init);
-    console.log('Got response', response);
-    return response;
+  fetchOptions: {
+    // `RequestInit` options
   },
 });
 ```
 
-Note that if given a `DEBUG=true` environment variable, this library will log all requests and responses automatically.
-This is intended for debugging purposes only and may change in the future without notice.
+#### Configuring proxies
+
+To modify proxy behavior, you can provide custom `fetchOptions` that add runtime-specific proxy
+options to requests:
 
-### Configuring an HTTP(S) Agent (e.g., for proxies)
+<img src="https://raw.githubusercontent.com/stainless-api/sdk-assets/refs/heads/main/node.svg" align="top" width="18" height="21"> **Node** <sup>[[docs](https://github.com/nodejs/undici/blob/main/docs/docs/api/ProxyAgent.md#example---proxyagent-with-fetch)]</sup>
 
-By default, this library uses a stable agent for all http/https requests to reuse TCP connections, eliminating many TCP & TLS handshakes and shaving around 100ms off most requests.
+```ts
+import DodoPayments from 'dodopayments';
+import * as undici from 'undici';
 
-If you would like to disable or customize this behavior, for example to use the API behind a proxy, you can pass an `httpAgent` which is used for all requests (be they http or https), for example:
+const proxyAgent = new undici.ProxyAgent('http://localhost:8888');
+const client = new DodoPayments({
+  fetchOptions: {
+    dispatcher: proxyAgent,
+  },
+});
+```
+
+<img src="https://raw.githubusercontent.com/stainless-api/sdk-assets/refs/heads/main/bun.svg" align="top" width="18" height="21"> **Bun** <sup>[[docs](https://bun.sh/guides/http/proxy)]</sup>
 
-<!-- prettier-ignore -->
 ```ts
-import http from 'http';
-import { HttpsProxyAgent } from 'https-proxy-agent';
+import DodoPayments from 'dodopayments';
 
-// Configure the default for all requests:
 const client = new DodoPayments({
-  httpAgent: new HttpsProxyAgent(process.env.PROXY_URL),
+  fetchOptions: {
+    proxy: 'http://localhost:8888',
+  },
 });
+```
 
-// Override per-request:
-await client.checkoutSessions.create(
-  { product_cart: [{ product_id: 'product_id', quantity: 0 }] },
-  {
-    httpAgent: new http.Agent({ keepAlive: false }),
+<img src="https://raw.githubusercontent.com/stainless-api/sdk-assets/refs/heads/main/deno.svg" align="top" width="18" height="21"> **Deno** <sup>[[docs](https://docs.deno.com/api/deno/~/Deno.createHttpClient)]</sup>
+
+```ts
+import DodoPayments from 'npm:dodopayments';
+
+const httpClient = Deno.createHttpClient({ proxy: { url: 'http://localhost:8888' } });
+const client = new DodoPayments({
+  fetchOptions: {
+    client: httpClient,
   },
-);
+});
 ```
 
+## Frequently Asked Questions
+
 ## Semantic versioning
 
 This package generally follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions, though certain backwards-incompatible changes may be released as minor versions:
@@ -308,16 +378,16 @@ This package generally follows [SemVer](https://semver.org/spec/v2.0.0.html) con
 
 We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience.
 
-We are keen for your feedback; please open an [issue](https://www.github.com/dodopayments/dodopayments-node/issues) with questions, bugs, or suggestions.
+We are keen for your feedback; please open an [issue](https://www.github.com/dodopayments/dodopayments-typescript/issues) with questions, bugs, or suggestions.
 
 ## Requirements
 
-TypeScript >= 4.5 is supported.
+TypeScript >= 4.9 is supported.
 
 The following runtimes are supported:
 
 - Web browsers (Up-to-date Chrome, Firefox, Safari, Edge, and more)
-- Node.js 18 LTS or later ([non-EOL](https://endoflife.date/nodejs)) versions.
+- Node.js 20 LTS or later ([non-EOL](https://endoflife.date/nodejs)) versions.
 - Deno v1.28.0 or higher.
 - Bun 1.0 or later.
 - Cloudflare Workers.

package/api-promise.d.mts

@@ -0,0 +1,2 @@
+export * from "./core/api-promise.mjs";
+//# sourceMappingURL=api-promise.d.mts.map

package/api-promise.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-promise.d.mts","sourceRoot":"","sources":["src/api-promise.ts"],"names":[],"mappings":""}

package/api-promise.d.ts

@@ -0,0 +1,2 @@
+export * from "./core/api-promise.js";
+//# sourceMappingURL=api-promise.d.ts.map

package/api-promise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-promise.d.ts","sourceRoot":"","sources":["src/api-promise.ts"],"names":[],"mappings":""}

package/api-promise.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("./internal/tslib.js");
+/** @deprecated Import from ./core/api-promise instead */
+tslib_1.__exportStar(require("./core/api-promise.js"), exports);
+//# sourceMappingURL=api-promise.js.map

package/api-promise.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-promise.js","sourceRoot":"","sources":["src/api-promise.ts"],"names":[],"mappings":";;;AAAA,yDAAyD;AACzD,gEAAmC"}

package/api-promise.mjs

@@ -0,0 +1,2 @@
+export * from "./core/api-promise.mjs";
+//# sourceMappingURL=api-promise.mjs.map

package/api-promise.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-promise.mjs","sourceRoot":"","sources":["src/api-promise.ts"],"names":[],"mappings":""}

package/bin/cli

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+
+const { spawnSync } = require('child_process');
+
+const commands = {
+  migrate: {
+    description:
+      'Run migrations to update your code using dodopayments@1.53.2 to be compatible with dodopayments@2.0.0',
+    fn: () => {
+      const result = spawnSync(
+        'npx',
+        [
+          '-y',
+          'https://github.com/stainless-api/migrate-ts/releases/download/0.0.2/stainless-api-migrate-0.0.2-6.tgz',
+          '--migrationConfig',
+          require.resolve('./migration-config.json'),
+          ...process.argv.slice(3),
+        ],
+        { stdio: 'inherit' },
+      );
+      if (result.status !== 0) {
+        process.exit(result.status);
+      }
+    },
+  },
+};
+
+function exitWithHelp() {
+  console.log(`Usage: dodopayments <subcommand>`);
+  console.log();
+  console.log('Subcommands:');
+
+  for (const [name, info] of Object.entries(commands)) {
+    console.log(`  ${name}  ${info.description}`);
+  }
+
+  console.log();
+  process.exit(1);
+}
+
+if (process.argv.length < 3) {
+  exitWithHelp();
+}
+
+const commandName = process.argv[2];
+
+const command = commands[commandName];
+if (!command) {
+  console.log(`Unknown subcommand ${commandName}.`);
+  exitWithHelp();
+}
+
+command.fn();

package/bin/migration-config.json

@@ -0,0 +1,6 @@
+{
+  "pkg": "dodopayments",
+  "githubRepo": "https://github.com/dodopayments/dodopayments-typescript",
+  "clientClass": "DodoPayments",
+  "methods": []
+}

package/client.d.mts

@@ -0,0 +1,259 @@
+import type { RequestInit, RequestInfo } from "./internal/builtin-types.mjs";
+import type { PromiseOrValue, MergedRequestInit, FinalizedRequestInit } from "./internal/types.mjs";
+export type { Logger, LogLevel } from "./internal/utils/log.mjs";
+import * as Opts from "./internal/request-options.mjs";
+import * as Errors from "./core/error.mjs";
+import * as Pagination from "./core/pagination.mjs";
+import { type CursorPagePaginationParams, CursorPagePaginationResponse, type DefaultPageNumberPaginationParams, DefaultPageNumberPaginationResponse } from "./core/pagination.mjs";
+import * as Uploads from "./core/uploads.mjs";
+import * as API from "./resources/index.mjs";
+import { APIPromise } from "./core/api-promise.mjs";
+import { AddonCreateParams, AddonListParams, AddonResponse, AddonResponsesDefaultPageNumberPagination, AddonUpdateImagesResponse, AddonUpdateParams, Addons } from "./resources/addons.mjs";
+import { Brand, BrandCreateParams, BrandListResponse, BrandUpdateImagesResponse, BrandUpdateParams, Brands } from "./resources/brands.mjs";
+import { CheckoutSessionCreateParams, CheckoutSessionRequest, CheckoutSessionResponse, CheckoutSessions } from "./resources/checkout-sessions.mjs";
+import { Discount, DiscountCreateParams, DiscountListParams, DiscountType, DiscountUpdateParams, Discounts, DiscountsDefaultPageNumberPagination } from "./resources/discounts.mjs";
+import { Dispute, DisputeListParams, DisputeListResponse, DisputeListResponsesDefaultPageNumberPagination, DisputeStage, DisputeStatus, Disputes, GetDispute } from "./resources/disputes.mjs";
+import { LicenseKeyInstance, LicenseKeyInstanceListParams, LicenseKeyInstanceUpdateParams, LicenseKeyInstances, LicenseKeyInstancesDefaultPageNumberPagination } from "./resources/license-key-instances.mjs";
+import { LicenseKey, LicenseKeyListParams, LicenseKeyStatus, LicenseKeyUpdateParams, LicenseKeys, LicenseKeysDefaultPageNumberPagination } from "./resources/license-keys.mjs";
+import { LicenseActivateParams, LicenseActivateResponse, LicenseDeactivateParams, LicenseValidateParams, LicenseValidateResponse, Licenses } from "./resources/licenses.mjs";
+import { Meter, MeterAggregation, MeterCreateParams, MeterFilter, MeterListParams, Meters, MetersDefaultPageNumberPagination } from "./resources/meters.mjs";
+import { CountryCode, Currency, Misc, MiscListSupportedCountriesResponse, TaxCategory } from "./resources/misc.mjs";
+import { AttachExistingCustomer, BillingAddress, CreateNewCustomer, CustomerLimitedDetails, CustomerRequest, IntentStatus, NewCustomer, OneTimeProductCartItem, Payment, PaymentCreateParams, PaymentCreateResponse, PaymentListParams, PaymentListResponse, PaymentListResponsesDefaultPageNumberPagination, PaymentMethodTypes, PaymentRetrieveLineItemsResponse, Payments } from "./resources/payments.mjs";
+import { PayoutListParams, PayoutListResponse, PayoutListResponsesDefaultPageNumberPagination, Payouts } from "./resources/payouts.mjs";
+import { Refund, RefundCreateParams, RefundListParams, RefundListResponse, RefundListResponsesDefaultPageNumberPagination, RefundStatus, Refunds } from "./resources/refunds.mjs";
+import { AddonCartResponseItem, AttachAddon, OnDemandSubscription, Subscription, SubscriptionChangePlanParams, SubscriptionChargeParams, SubscriptionChargeResponse, SubscriptionCreateParams, SubscriptionCreateResponse, SubscriptionListParams, SubscriptionListResponse, SubscriptionListResponsesDefaultPageNumberPagination, SubscriptionRetrieveUsageHistoryParams, SubscriptionRetrieveUsageHistoryResponse, SubscriptionRetrieveUsageHistoryResponsesDefaultPageNumberPagination, SubscriptionStatus, SubscriptionUpdateParams, Subscriptions, TimeInterval } from "./resources/subscriptions.mjs";
+import { Event, EventInput, EventsDefaultPageNumberPagination, UsageEventIngestParams, UsageEventIngestResponse, UsageEventListParams, UsageEvents } from "./resources/usage-events.mjs";
+import { WebhookEventType, WebhookEvents, WebhookPayload } from "./resources/webhook-events.mjs";
+import { Customer, CustomerCreateParams, CustomerListParams, CustomerPortalSession, CustomerUpdateParams, Customers, CustomersDefaultPageNumberPagination } from "./resources/customers/customers.mjs";
+import { Invoices } from "./resources/invoices/invoices.mjs";
+import { AddMeterToPrice, LicenseKeyDuration, Price, Product, ProductCreateParams, ProductListParams, ProductListResponse, ProductListResponsesDefaultPageNumberPagination, ProductUpdateFilesParams, ProductUpdateFilesResponse, ProductUpdateParams, Products } from "./resources/products/products.mjs";
+import { WebhookCreateParams, WebhookDetails, WebhookDetailsCursorPagePagination, WebhookListParams, WebhookRetrieveSecretResponse, WebhookUpdateParams, Webhooks } from "./resources/webhooks/webhooks.mjs";
+import { type Fetch } from "./internal/builtin-types.mjs";
+import { HeadersLike, NullableHeaders } from "./internal/headers.mjs";
+import { FinalRequestOptions, RequestOptions } from "./internal/request-options.mjs";
+import { type LogLevel, type Logger } from "./internal/utils/log.mjs";
+declare const environments: {
+    live_mode: string;
+    test_mode: string;
+};
+type Environment = keyof typeof environments;
+export interface ClientOptions {
+    /**
+     * Bearer Token for API authentication
+     */
+    bearerToken?: string | undefined;
+    /**
+     * Specifies the environment to use for the API.
+     *
+     * Each environment maps to a different base URL:
+     * - `live_mode` corresponds to `https://live.dodopayments.com`
+     * - `test_mode` corresponds to `https://test.dodopayments.com`
+     */
+    environment?: Environment | undefined;
+    /**
+     * Override the default base URL for the API, e.g., "https://api.example.com/v2/"
+     *
+     * Defaults to process.env['DODO_PAYMENTS_BASE_URL'].
+     */
+    baseURL?: string | null | undefined;
+    /**
+     * The maximum amount of time (in milliseconds) that the client should wait for a response
+     * from the server before timing out a single request.
+     *
+     * Note that request timeouts are retried by default, so in a worst-case scenario you may wait
+     * much longer than this timeout before the promise succeeds or fails.
+     *
+     * @unit milliseconds
+     */
+    timeout?: number | undefined;
+    /**
+     * Additional `RequestInit` options to be passed to `fetch` calls.
+     * Properties will be overridden by per-request `fetchOptions`.
+     */
+    fetchOptions?: MergedRequestInit | undefined;
+    /**
+     * Specify a custom `fetch` function implementation.
+     *
+     * If not provided, we expect that `fetch` is defined globally.
+     */
+    fetch?: Fetch | undefined;
+    /**
+     * The maximum number of times that the client will retry a request in case of a
+     * temporary failure, like a network error or a 5XX error from the server.
+     *
+     * @default 2
+     */
+    maxRetries?: number | undefined;
+    /**
+     * Default headers to include with every request to the API.
+     *
+     * These can be removed in individual requests by explicitly setting the
+     * header to `null` in request options.
+     */
+    defaultHeaders?: HeadersLike | undefined;
+    /**
+     * Default query parameters to include with every request to the API.
+     *
+     * These can be removed in individual requests by explicitly setting the
+     * param to `undefined` in request options.
+     */
+    defaultQuery?: Record<string, string | undefined> | undefined;
+    /**
+     * Set the log level.
+     *
+     * Defaults to process.env['DODO_PAYMENTS_LOG'] or 'warn' if it isn't set.
+     */
+    logLevel?: LogLevel | undefined;
+    /**
+     * Set the logger.
+     *
+     * Defaults to globalThis.console.
+     */
+    logger?: Logger | undefined;
+}
+/**
+ * API Client for interfacing with the Dodo Payments API.
+ */
+export declare class DodoPayments {
+    #private;
+    bearerToken: string;
+    baseURL: string;
+    maxRetries: number;
+    timeout: number;
+    logger: Logger | undefined;
+    logLevel: LogLevel | undefined;
+    fetchOptions: MergedRequestInit | undefined;
+    private fetch;
+    protected idempotencyHeader?: string;
+    private _options;
+    /**
+     * API Client for interfacing with the Dodo Payments API.
+     *
+     * @param {string | undefined} [opts.bearerToken=process.env['DODO_PAYMENTS_API_KEY'] ?? undefined]
+     * @param {Environment} [opts.environment=live_mode] - Specifies the environment URL to use for the API.
+     * @param {string} [opts.baseURL=process.env['DODO_PAYMENTS_BASE_URL'] ?? https://live.dodopayments.com] - Override the default base URL for the API.
+     * @param {number} [opts.timeout=1 minute] - The maximum amount of time (in milliseconds) the client will wait for a response before timing out.
+     * @param {MergedRequestInit} [opts.fetchOptions] - Additional `RequestInit` options to be passed to `fetch` calls.
+     * @param {Fetch} [opts.fetch] - Specify a custom `fetch` function implementation.
+     * @param {number} [opts.maxRetries=2] - The maximum number of times the client will retry a request.
+     * @param {HeadersLike} opts.defaultHeaders - Default headers to include with every request to the API.
+     * @param {Record<string, string | undefined>} opts.defaultQuery - Default query parameters to include with every request to the API.
+     */
+    constructor({ baseURL, bearerToken, ...opts }?: ClientOptions);
+    /**
+     * Create a new client instance re-using the same options given to the current client with optional overriding.
+     */
+    withOptions(options: Partial<ClientOptions>): this;
+    protected defaultQuery(): Record<string, string | undefined> | undefined;
+    protected validateHeaders({ values, nulls }: NullableHeaders): void;
+    protected authHeaders(opts: FinalRequestOptions): Promise<NullableHeaders | undefined>;
+    /**
+     * Basic re-implementation of `qs.stringify` for primitive types.
+     */
+    protected stringifyQuery(query: Record<string, unknown>): string;
+    private getUserAgent;
+    protected defaultIdempotencyKey(): string;
+    protected makeStatusError(status: number, error: Object, message: string | undefined, headers: Headers): Errors.APIError;
+    buildURL(path: string, query: Record<string, unknown> | null | undefined, defaultBaseURL?: string | undefined): string;
+    /**
+     * Used as a callback for mutating the given `FinalRequestOptions` object.
+     */
+    protected prepareOptions(options: FinalRequestOptions): Promise<void>;
+    /**
+     * Used as a callback for mutating the given `RequestInit` object.
+     *
+     * This is useful for cases where you want to add certain headers based off of
+     * the request properties, e.g. `method` or `url`.
+     */
+    protected prepareRequest(request: RequestInit, { url, options }: {
+        url: string;
+        options: FinalRequestOptions;
+    }): Promise<void>;
+    get<Rsp>(path: string, opts?: PromiseOrValue<RequestOptions>): APIPromise<Rsp>;
+    post<Rsp>(path: string, opts?: PromiseOrValue<RequestOptions>): APIPromise<Rsp>;
+    patch<Rsp>(path: string, opts?: PromiseOrValue<RequestOptions>): APIPromise<Rsp>;
+    put<Rsp>(path: string, opts?: PromiseOrValue<RequestOptions>): APIPromise<Rsp>;
+    delete<Rsp>(path: string, opts?: PromiseOrValue<RequestOptions>): APIPromise<Rsp>;
+    private methodRequest;
+    request<Rsp>(options: PromiseOrValue<FinalRequestOptions>, remainingRetries?: number | null): APIPromise<Rsp>;
+    private makeRequest;
+    getAPIList<Item, PageClass extends Pagination.AbstractPage<Item> = Pagination.AbstractPage<Item>>(path: string, Page: new (...args: any[]) => PageClass, opts?: RequestOptions): Pagination.PagePromise<PageClass, Item>;
+    requestAPIList<Item = unknown, PageClass extends Pagination.AbstractPage<Item> = Pagination.AbstractPage<Item>>(Page: new (...args: ConstructorParameters<typeof Pagination.AbstractPage>) => PageClass, options: FinalRequestOptions): Pagination.PagePromise<PageClass, Item>;
+    fetchWithTimeout(url: RequestInfo, init: RequestInit | undefined, ms: number, controller: AbortController): Promise<Response>;
+    private shouldRetry;
+    private retryRequest;
+    private calculateDefaultRetryTimeoutMillis;
+    buildRequest(inputOptions: FinalRequestOptions, { retryCount }?: {
+        retryCount?: number;
+    }): Promise<{
+        req: FinalizedRequestInit;
+        url: string;
+        timeout: number;
+    }>;
+    private buildHeaders;
+    private buildBody;
+    static DodoPayments: typeof DodoPayments;
+    static DEFAULT_TIMEOUT: number;
+    static DodoPaymentsError: typeof Errors.DodoPaymentsError;
+    static APIError: typeof Errors.APIError;
+    static APIConnectionError: typeof Errors.APIConnectionError;
+    static APIConnectionTimeoutError: typeof Errors.APIConnectionTimeoutError;
+    static APIUserAbortError: typeof Errors.APIUserAbortError;
+    static NotFoundError: typeof Errors.NotFoundError;
+    static ConflictError: typeof Errors.ConflictError;
+    static RateLimitError: typeof Errors.RateLimitError;
+    static BadRequestError: typeof Errors.BadRequestError;
+    static AuthenticationError: typeof Errors.AuthenticationError;
+    static InternalServerError: typeof Errors.InternalServerError;
+    static PermissionDeniedError: typeof Errors.PermissionDeniedError;
+    static UnprocessableEntityError: typeof Errors.UnprocessableEntityError;
+    static toFile: typeof Uploads.toFile;
+    checkoutSessions: API.CheckoutSessions;
+    payments: API.Payments;
+    subscriptions: API.Subscriptions;
+    invoices: API.Invoices;
+    licenses: API.Licenses;
+    licenseKeys: API.LicenseKeys;
+    licenseKeyInstances: API.LicenseKeyInstances;
+    customers: API.Customers;
+    refunds: API.Refunds;
+    disputes: API.Disputes;
+    payouts: API.Payouts;
+    webhookEvents: API.WebhookEvents;
+    products: API.Products;
+    misc: API.Misc;
+    discounts: API.Discounts;
+    addons: API.Addons;
+    brands: API.Brands;
+    webhooks: API.Webhooks;
+    usageEvents: API.UsageEvents;
+    meters: API.Meters;
+}
+export declare namespace DodoPayments {
+    export type RequestOptions = Opts.RequestOptions;
+    export import DefaultPageNumberPagination = Pagination.DefaultPageNumberPagination;
+    export { type DefaultPageNumberPaginationParams as DefaultPageNumberPaginationParams, type DefaultPageNumberPaginationResponse as DefaultPageNumberPaginationResponse, };
+    export import CursorPagePagination = Pagination.CursorPagePagination;
+    export { type CursorPagePaginationParams as CursorPagePaginationParams, type CursorPagePaginationResponse as CursorPagePaginationResponse, };
+    export { CheckoutSessions as CheckoutSessions, type CheckoutSessionRequest as CheckoutSessionRequest, type CheckoutSessionResponse as CheckoutSessionResponse, type CheckoutSessionCreateParams as CheckoutSessionCreateParams, };
+    export { Payments as Payments, type AttachExistingCustomer as AttachExistingCustomer, type BillingAddress as BillingAddress, type CreateNewCustomer as CreateNewCustomer, type CustomerLimitedDetails as CustomerLimitedDetails, type CustomerRequest as CustomerRequest, type IntentStatus as IntentStatus, type NewCustomer as NewCustomer, type OneTimeProductCartItem as OneTimeProductCartItem, type Payment as Payment, type PaymentMethodTypes as PaymentMethodTypes, type PaymentCreateResponse as PaymentCreateResponse, type PaymentListResponse as PaymentListResponse, type PaymentRetrieveLineItemsResponse as PaymentRetrieveLineItemsResponse, type PaymentListResponsesDefaultPageNumberPagination as PaymentListResponsesDefaultPageNumberPagination, type PaymentCreateParams as PaymentCreateParams, type PaymentListParams as PaymentListParams, };
+    export { Subscriptions as Subscriptions, type AddonCartResponseItem as AddonCartResponseItem, type AttachAddon as AttachAddon, type OnDemandSubscription as OnDemandSubscription, type Subscription as Subscription, type SubscriptionStatus as SubscriptionStatus, type TimeInterval as TimeInterval, type SubscriptionCreateResponse as SubscriptionCreateResponse, type SubscriptionListResponse as SubscriptionListResponse, type SubscriptionChargeResponse as SubscriptionChargeResponse, type SubscriptionRetrieveUsageHistoryResponse as SubscriptionRetrieveUsageHistoryResponse, type SubscriptionListResponsesDefaultPageNumberPagination as SubscriptionListResponsesDefaultPageNumberPagination, type SubscriptionRetrieveUsageHistoryResponsesDefaultPageNumberPagination as SubscriptionRetrieveUsageHistoryResponsesDefaultPageNumberPagination, type SubscriptionCreateParams as SubscriptionCreateParams, type SubscriptionUpdateParams as SubscriptionUpdateParams, type SubscriptionListParams as SubscriptionListParams, type SubscriptionChangePlanParams as SubscriptionChangePlanParams, type SubscriptionChargeParams as SubscriptionChargeParams, type SubscriptionRetrieveUsageHistoryParams as SubscriptionRetrieveUsageHistoryParams, };
+    export { Invoices as Invoices };
+    export { Licenses as Licenses, type LicenseActivateResponse as LicenseActivateResponse, type LicenseValidateResponse as LicenseValidateResponse, type LicenseActivateParams as LicenseActivateParams, type LicenseDeactivateParams as LicenseDeactivateParams, type LicenseValidateParams as LicenseValidateParams, };
+    export { LicenseKeys as LicenseKeys, type LicenseKey as LicenseKey, type LicenseKeyStatus as LicenseKeyStatus, type LicenseKeysDefaultPageNumberPagination as LicenseKeysDefaultPageNumberPagination, type LicenseKeyUpdateParams as LicenseKeyUpdateParams, type LicenseKeyListParams as LicenseKeyListParams, };
+    export { LicenseKeyInstances as LicenseKeyInstances, type LicenseKeyInstance as LicenseKeyInstance, type LicenseKeyInstancesDefaultPageNumberPagination as LicenseKeyInstancesDefaultPageNumberPagination, type LicenseKeyInstanceUpdateParams as LicenseKeyInstanceUpdateParams, type LicenseKeyInstanceListParams as LicenseKeyInstanceListParams, };
+    export { Customers as Customers, type Customer as Customer, type CustomerPortalSession as CustomerPortalSession, type CustomersDefaultPageNumberPagination as CustomersDefaultPageNumberPagination, type CustomerCreateParams as CustomerCreateParams, type CustomerUpdateParams as CustomerUpdateParams, type CustomerListParams as CustomerListParams, };
+    export { Refunds as Refunds, type Refund as Refund, type RefundStatus as RefundStatus, type RefundListResponse as RefundListResponse, type RefundListResponsesDefaultPageNumberPagination as RefundListResponsesDefaultPageNumberPagination, type RefundCreateParams as RefundCreateParams, type RefundListParams as RefundListParams, };
+    export { Disputes as Disputes, type Dispute as Dispute, type DisputeStage as DisputeStage, type DisputeStatus as DisputeStatus, type GetDispute as GetDispute, type DisputeListResponse as DisputeListResponse, type DisputeListResponsesDefaultPageNumberPagination as DisputeListResponsesDefaultPageNumberPagination, type DisputeListParams as DisputeListParams, };
+    export { Payouts as Payouts, type PayoutListResponse as PayoutListResponse, type PayoutListResponsesDefaultPageNumberPagination as PayoutListResponsesDefaultPageNumberPagination, type PayoutListParams as PayoutListParams, };
+    export { WebhookEvents as WebhookEvents, type WebhookEventType as WebhookEventType, type WebhookPayload as WebhookPayload, };
+    export { Products as Products, type AddMeterToPrice as AddMeterToPrice, type LicenseKeyDuration as LicenseKeyDuration, type Price as Price, type Product as Product, type ProductListResponse as ProductListResponse, type ProductUpdateFilesResponse as ProductUpdateFilesResponse, type ProductListResponsesDefaultPageNumberPagination as ProductListResponsesDefaultPageNumberPagination, type ProductCreateParams as ProductCreateParams, type ProductUpdateParams as ProductUpdateParams, type ProductListParams as ProductListParams, type ProductUpdateFilesParams as ProductUpdateFilesParams, };
+    export { Misc as Misc, type CountryCode as CountryCode, type Currency as Currency, type TaxCategory as TaxCategory, type MiscListSupportedCountriesResponse as MiscListSupportedCountriesResponse, };
+    export { Discounts as Discounts, type Discount as Discount, type DiscountType as DiscountType, type DiscountsDefaultPageNumberPagination as DiscountsDefaultPageNumberPagination, type DiscountCreateParams as DiscountCreateParams, type DiscountUpdateParams as DiscountUpdateParams, type DiscountListParams as DiscountListParams, };
+    export { Addons as Addons, type AddonResponse as AddonResponse, type AddonUpdateImagesResponse as AddonUpdateImagesResponse, type AddonResponsesDefaultPageNumberPagination as AddonResponsesDefaultPageNumberPagination, type AddonCreateParams as AddonCreateParams, type AddonUpdateParams as AddonUpdateParams, type AddonListParams as AddonListParams, };
+    export { Brands as Brands, type Brand as Brand, type BrandListResponse as BrandListResponse, type BrandUpdateImagesResponse as BrandUpdateImagesResponse, type BrandCreateParams as BrandCreateParams, type BrandUpdateParams as BrandUpdateParams, };
+    export { Webhooks as Webhooks, type WebhookDetails as WebhookDetails, type WebhookRetrieveSecretResponse as WebhookRetrieveSecretResponse, type WebhookDetailsCursorPagePagination as WebhookDetailsCursorPagePagination, type WebhookCreateParams as WebhookCreateParams, type WebhookUpdateParams as WebhookUpdateParams, type WebhookListParams as WebhookListParams, };
+    export { UsageEvents as UsageEvents, type Event as Event, type EventInput as EventInput, type UsageEventIngestResponse as UsageEventIngestResponse, type EventsDefaultPageNumberPagination as EventsDefaultPageNumberPagination, type UsageEventListParams as UsageEventListParams, type UsageEventIngestParams as UsageEventIngestParams, };
+    export { Meters as Meters, type Meter as Meter, type MeterAggregation as MeterAggregation, type MeterFilter as MeterFilter, type MetersDefaultPageNumberPagination as MetersDefaultPageNumberPagination, type MeterCreateParams as MeterCreateParams, type MeterListParams as MeterListParams, };
+}
+//# sourceMappingURL=client.d.mts.map