@dodopayments/hono 0.1.1

package/dist/index.cjs

@@ -0,0 +1,3617 @@
+'use strict';
+
+var zod = require('zod');
+
+const VERSION = '1.42.0'; // x-release-please-version
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class DodoPaymentsError extends Error {
+}
+class APIError extends DodoPaymentsError {
+    constructor(status, error, message, headers) {
+        super(`${APIError.makeMessage(status, error, message)}`);
+        this.status = status;
+        this.headers = headers;
+        this.error = error;
+    }
+    static makeMessage(status, error, message) {
+        const msg = error?.message ?
+            typeof error.message === 'string' ?
+                error.message
+                : JSON.stringify(error.message)
+            : error ? JSON.stringify(error)
+                : message;
+        if (status && msg) {
+            return `${status} ${msg}`;
+        }
+        if (status) {
+            return `${status} status code (no body)`;
+        }
+        if (msg) {
+            return msg;
+        }
+        return '(no status code or body)';
+    }
+    static generate(status, errorResponse, message, headers) {
+        if (!status || !headers) {
+            return new APIConnectionError({ message, cause: castToError(errorResponse) });
+        }
+        const error = errorResponse;
+        if (status === 400) {
+            return new BadRequestError(status, error, message, headers);
+        }
+        if (status === 401) {
+            return new AuthenticationError(status, error, message, headers);
+        }
+        if (status === 403) {
+            return new PermissionDeniedError(status, error, message, headers);
+        }
+        if (status === 404) {
+            return new NotFoundError(status, error, message, headers);
+        }
+        if (status === 409) {
+            return new ConflictError(status, error, message, headers);
+        }
+        if (status === 422) {
+            return new UnprocessableEntityError(status, error, message, headers);
+        }
+        if (status === 429) {
+            return new RateLimitError(status, error, message, headers);
+        }
+        if (status >= 500) {
+            return new InternalServerError(status, error, message, headers);
+        }
+        return new APIError(status, error, message, headers);
+    }
+}
+class APIUserAbortError extends APIError {
+    constructor({ message } = {}) {
+        super(undefined, undefined, message || 'Request was aborted.', undefined);
+    }
+}
+class APIConnectionError extends APIError {
+    constructor({ message, cause }) {
+        super(undefined, undefined, message || 'Connection error.', undefined);
+        // in some environments the 'cause' property is already declared
+        // @ts-ignore
+        if (cause)
+            this.cause = cause;
+    }
+}
+class APIConnectionTimeoutError extends APIConnectionError {
+    constructor({ message } = {}) {
+        super({ message: message ?? 'Request timed out.' });
+    }
+}
+class BadRequestError extends APIError {
+}
+class AuthenticationError extends APIError {
+}
+class PermissionDeniedError extends APIError {
+}
+class NotFoundError extends APIError {
+}
+class ConflictError extends APIError {
+}
+class UnprocessableEntityError extends APIError {
+}
+class RateLimitError extends APIError {
+}
+class InternalServerError extends APIError {
+}
+
+let auto = false;
+let kind = undefined;
+let fetch$1 = undefined;
+let File$1 = undefined;
+let getDefaultAgent = undefined;
+let fileFromPath = undefined;
+function setShims(shims, options = { auto: false }) {
+    if (auto) {
+        throw new Error(`you must \`import 'dodopayments/shims/${shims.kind}'\` before importing anything else from dodopayments`);
+    }
+    if (kind) {
+        throw new Error(`can't \`import 'dodopayments/shims/${shims.kind}'\` after \`import 'dodopayments/shims/${kind}'\``);
+    }
+    auto = options.auto;
+    kind = shims.kind;
+    fetch$1 = shims.fetch;
+    File$1 = shims.File;
+    getDefaultAgent = shims.getDefaultAgent;
+    fileFromPath = shims.fileFromPath;
+}
+
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+class MultipartBody {
+    constructor(body) {
+        this.body = body;
+    }
+    get [Symbol.toStringTag]() {
+        return 'MultipartBody';
+    }
+}
+
+function getRuntime({ manuallyImported } = {}) {
+    const recommendation = manuallyImported ?
+        `You may need to use polyfills`
+        : `Add one of these imports before your first \`import … from 'dodopayments'\`:
+- \`import 'dodopayments/shims/node'\` (if you're running on Node)
+- \`import 'dodopayments/shims/web'\` (otherwise)
+`;
+    let _fetch, _Request, _Response, _Headers;
+    try {
+        // @ts-ignore
+        _fetch = fetch;
+        // @ts-ignore
+        _Request = Request;
+        // @ts-ignore
+        _Response = Response;
+        // @ts-ignore
+        _Headers = Headers;
+    }
+    catch (error) {
+        throw new Error(`this environment is missing the following Web Fetch API type: ${error.message}. ${recommendation}`);
+    }
+    return {
+        kind: 'web',
+        fetch: _fetch,
+        Request: _Request,
+        Response: _Response,
+        Headers: _Headers,
+        FormData: 
+        // @ts-ignore
+        typeof FormData !== 'undefined' ? FormData : (class FormData {
+            // @ts-ignore
+            constructor() {
+                throw new Error(`file uploads aren't supported in this environment yet as 'FormData' is undefined. ${recommendation}`);
+            }
+        }),
+        Blob: typeof Blob !== 'undefined' ? Blob : (class Blob {
+            constructor() {
+                throw new Error(`file uploads aren't supported in this environment yet as 'Blob' is undefined. ${recommendation}`);
+            }
+        }),
+        File: 
+        // @ts-ignore
+        typeof File !== 'undefined' ? File : (class File {
+            // @ts-ignore
+            constructor() {
+                throw new Error(`file uploads aren't supported in this environment yet as 'File' is undefined. ${recommendation}`);
+            }
+        }),
+        ReadableStream: 
+        // @ts-ignore
+        typeof ReadableStream !== 'undefined' ? ReadableStream : (class ReadableStream {
+            // @ts-ignore
+            constructor() {
+                throw new Error(`streaming isn't supported in this environment yet as 'ReadableStream' is undefined. ${recommendation}`);
+            }
+        }),
+        getMultipartRequestOptions: async (
+        // @ts-ignore
+        form, opts) => ({
+            ...opts,
+            body: new MultipartBody(form),
+        }),
+        getDefaultAgent: (url) => undefined,
+        fileFromPath: () => {
+            throw new Error('The `fileFromPath` function is only supported in Node. See the README for more details: https://www.github.com/dodopayments/dodopayments-node#file-uploads');
+        },
+        isFsReadStream: (value) => false,
+    };
+}
+
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+const init = () => {
+  if (!kind) setShims(getRuntime(), { auto: true });
+};
+
+init();
+
+const isResponseLike = (value) => value != null &&
+    typeof value === 'object' &&
+    typeof value.url === 'string' &&
+    typeof value.blob === 'function';
+const isFileLike = (value) => value != null &&
+    typeof value === 'object' &&
+    typeof value.name === 'string' &&
+    typeof value.lastModified === 'number' &&
+    isBlobLike(value);
+/**
+ * The BlobLike type omits arrayBuffer() because @types/node-fetch@^2.6.4 lacks it; but this check
+ * adds the arrayBuffer() method type because it is available and used at runtime
+ */
+const isBlobLike = (value) => value != null &&
+    typeof value === 'object' &&
+    typeof value.size === 'number' &&
+    typeof value.type === 'string' &&
+    typeof value.text === 'function' &&
+    typeof value.slice === 'function' &&
+    typeof value.arrayBuffer === 'function';
+/**
+ * Helper for creating a {@link File} to pass to an SDK upload method from a variety of different data formats
+ * @param value the raw content of the file.  Can be an {@link Uploadable}, {@link BlobLikePart}, or {@link AsyncIterable} of {@link BlobLikePart}s
+ * @param {string=} name the name of the file. If omitted, toFile will try to determine a file name from bits if possible
+ * @param {Object=} options additional properties
+ * @param {string=} options.type the MIME type of the content
+ * @param {number=} options.lastModified the last modified timestamp
+ * @returns a {@link File} with the given properties
+ */
+async function toFile(value, name, options) {
+    // If it's a promise, resolve it.
+    value = await value;
+    // If we've been given a `File` we don't need to do anything
+    if (isFileLike(value)) {
+        return value;
+    }
+    if (isResponseLike(value)) {
+        const blob = await value.blob();
+        name || (name = new URL(value.url).pathname.split(/[\\/]/).pop() ?? 'unknown_file');
+        // we need to convert the `Blob` into an array buffer because the `Blob` class
+        // that `node-fetch` defines is incompatible with the web standard which results
+        // in `new File` interpreting it as a string instead of binary data.
+        const data = isBlobLike(blob) ? [(await blob.arrayBuffer())] : [blob];
+        return new File$1(data, name, options);
+    }
+    const bits = await getBytes(value);
+    name || (name = getName(value) ?? 'unknown_file');
+    if (!options?.type) {
+        const type = bits[0]?.type;
+        if (typeof type === 'string') {
+            options = { ...options, type };
+        }
+    }
+    return new File$1(bits, name, options);
+}
+async function getBytes(value) {
+    let parts = [];
+    if (typeof value === 'string' ||
+        ArrayBuffer.isView(value) || // includes Uint8Array, Buffer, etc.
+        value instanceof ArrayBuffer) {
+        parts.push(value);
+    }
+    else if (isBlobLike(value)) {
+        parts.push(await value.arrayBuffer());
+    }
+    else if (isAsyncIterableIterator(value) // includes Readable, ReadableStream, etc.
+    ) {
+        for await (const chunk of value) {
+            parts.push(chunk); // TODO, consider validating?
+        }
+    }
+    else {
+        throw new Error(`Unexpected data type: ${typeof value}; constructor: ${value?.constructor
+            ?.name}; props: ${propsForError(value)}`);
+    }
+    return parts;
+}
+function propsForError(value) {
+    const props = Object.getOwnPropertyNames(value);
+    return `[${props.map((p) => `"${p}"`).join(', ')}]`;
+}
+function getName(value) {
+    return (getStringFromMaybeBuffer(value.name) ||
+        getStringFromMaybeBuffer(value.filename) ||
+        // For fs.ReadStream
+        getStringFromMaybeBuffer(value.path)?.split(/[\\/]/).pop());
+}
+const getStringFromMaybeBuffer = (x) => {
+    if (typeof x === 'string')
+        return x;
+    if (typeof Buffer !== 'undefined' && x instanceof Buffer)
+        return String(x);
+    return undefined;
+};
+const isAsyncIterableIterator = (value) => value != null && typeof value === 'object' && typeof value[Symbol.asyncIterator] === 'function';
+const isMultipartBody = (body) => body && typeof body === 'object' && body.body && body[Symbol.toStringTag] === 'MultipartBody';
+
+var __classPrivateFieldSet = (undefined && undefined.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (undefined && undefined.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _APIClient_baseURLOverridden, _AbstractPage_client;
+// try running side effects outside of _shims/index to workaround https://github.com/vercel/next.js/issues/76881
+init();
+async function defaultParseResponse(props) {
+    const { response } = props;
+    // fetch refuses to read the body when the status code is 204.
+    if (response.status === 204) {
+        return null;
+    }
+    if (props.options.__binaryResponse) {
+        return response;
+    }
+    const contentType = response.headers.get('content-type');
+    const mediaType = contentType?.split(';')[0]?.trim();
+    const isJSON = mediaType?.includes('application/json') || mediaType?.endsWith('+json');
+    if (isJSON) {
+        const json = await response.json();
+        debug('response', response.status, response.url, response.headers, json);
+        return json;
+    }
+    const text = await response.text();
+    debug('response', response.status, response.url, response.headers, text);
+    // TODO handle blob, arraybuffer, other content types, etc.
+    return text;
+}
+/**
+ * A subclass of `Promise` providing additional helper methods
+ * for interacting with the SDK.
+ */
+class APIPromise extends Promise {
+    constructor(responsePromise, parseResponse = defaultParseResponse) {
+        super((resolve) => {
+            // this is maybe a bit weird but this has to be a no-op to not implicitly
+            // parse the response body; instead .then, .catch, .finally are overridden
+            // to parse the response
+            resolve(null);
+        });
+        this.responsePromise = responsePromise;
+        this.parseResponse = parseResponse;
+    }
+    _thenUnwrap(transform) {
+        return new APIPromise(this.responsePromise, async (props) => transform(await this.parseResponse(props), props));
+    }
+    /**
+     * Gets the raw `Response` instance instead of parsing the response
+     * data.
+     *
+     * If you want to parse the response body but still get the `Response`
+     * instance, you can use {@link withResponse()}.
+     *
+     * 👋 Getting the wrong TypeScript type for `Response`?
+     * Try setting `"moduleResolution": "NodeNext"` if you can,
+     * or add one of these imports before your first `import … from 'dodopayments'`:
+     * - `import 'dodopayments/shims/node'` (if you're running on Node)
+     * - `import 'dodopayments/shims/web'` (otherwise)
+     */
+    asResponse() {
+        return this.responsePromise.then((p) => p.response);
+    }
+    /**
+     * Gets the parsed response data and the raw `Response` instance.
+     *
+     * If you just want to get the raw `Response` instance without parsing it,
+     * you can use {@link asResponse()}.
+     *
+     *
+     * 👋 Getting the wrong TypeScript type for `Response`?
+     * Try setting `"moduleResolution": "NodeNext"` if you can,
+     * or add one of these imports before your first `import … from 'dodopayments'`:
+     * - `import 'dodopayments/shims/node'` (if you're running on Node)
+     * - `import 'dodopayments/shims/web'` (otherwise)
+     */
+    async withResponse() {
+        const [data, response] = await Promise.all([this.parse(), this.asResponse()]);
+        return { data, response };
+    }
+    parse() {
+        if (!this.parsedPromise) {
+            this.parsedPromise = this.responsePromise.then(this.parseResponse);
+        }
+        return this.parsedPromise;
+    }
+    then(onfulfilled, onrejected) {
+        return this.parse().then(onfulfilled, onrejected);
+    }
+    catch(onrejected) {
+        return this.parse().catch(onrejected);
+    }
+    finally(onfinally) {
+        return this.parse().finally(onfinally);
+    }
+}
+class APIClient {
+    constructor({ baseURL, baseURLOverridden, maxRetries = 2, timeout = 60000, // 1 minute
+    httpAgent, fetch: overriddenFetch, }) {
+        _APIClient_baseURLOverridden.set(this, void 0);
+        this.baseURL = baseURL;
+        __classPrivateFieldSet(this, _APIClient_baseURLOverridden, baseURLOverridden, "f");
+        this.maxRetries = validatePositiveInteger('maxRetries', maxRetries);
+        this.timeout = validatePositiveInteger('timeout', timeout);
+        this.httpAgent = httpAgent;
+        this.fetch = overriddenFetch ?? fetch$1;
+    }
+    authHeaders(opts) {
+        return {};
+    }
+    /**
+     * Override this to add your own default headers, for example:
+     *
+     *  {
+     *    ...super.defaultHeaders(),
+     *    Authorization: 'Bearer 123',
+     *  }
+     */
+    defaultHeaders(opts) {
+        return {
+            Accept: 'application/json',
+            ...(['head', 'get'].includes(opts.method) ? {} : { 'Content-Type': 'application/json' }),
+            'User-Agent': this.getUserAgent(),
+            ...getPlatformHeaders(),
+            ...this.authHeaders(opts),
+        };
+    }
+    /**
+     * Override this to add your own headers validation:
+     */
+    validateHeaders(headers, customHeaders) { }
+    defaultIdempotencyKey() {
+        return `stainless-node-retry-${uuid4()}`;
+    }
+    get(path, opts) {
+        return this.methodRequest('get', path, opts);
+    }
+    post(path, opts) {
+        return this.methodRequest('post', path, opts);
+    }
+    patch(path, opts) {
+        return this.methodRequest('patch', path, opts);
+    }
+    put(path, opts) {
+        return this.methodRequest('put', path, opts);
+    }
+    delete(path, opts) {
+        return this.methodRequest('delete', path, opts);
+    }
+    methodRequest(method, path, opts) {
+        return this.request(Promise.resolve(opts).then(async (opts) => {
+            const body = opts && isBlobLike(opts?.body) ? new DataView(await opts.body.arrayBuffer())
+                : opts?.body instanceof DataView ? opts.body
+                    : opts?.body instanceof ArrayBuffer ? new DataView(opts.body)
+                        : opts && ArrayBuffer.isView(opts?.body) ? new DataView(opts.body.buffer)
+                            : opts?.body;
+            return { method, path, ...opts, body };
+        }));
+    }
+    getAPIList(path, Page, opts) {
+        return this.requestAPIList(Page, { method: 'get', path, ...opts });
+    }
+    calculateContentLength(body) {
+        if (typeof body === 'string') {
+            if (typeof Buffer !== 'undefined') {
+                return Buffer.byteLength(body, 'utf8').toString();
+            }
+            if (typeof TextEncoder !== 'undefined') {
+                const encoder = new TextEncoder();
+                const encoded = encoder.encode(body);
+                return encoded.length.toString();
+            }
+        }
+        else if (ArrayBuffer.isView(body)) {
+            return body.byteLength.toString();
+        }
+        return null;
+    }
+    async buildRequest(inputOptions, { retryCount = 0 } = {}) {
+        const options = { ...inputOptions };
+        const { method, path, query, defaultBaseURL, headers: headers = {} } = options;
+        const body = ArrayBuffer.isView(options.body) || (options.__binaryRequest && typeof options.body === 'string') ?
+            options.body
+            : isMultipartBody(options.body) ? options.body.body
+                : options.body ? JSON.stringify(options.body, null, 2)
+                    : null;
+        const contentLength = this.calculateContentLength(body);
+        const url = this.buildURL(path, query, defaultBaseURL);
+        if ('timeout' in options)
+            validatePositiveInteger('timeout', options.timeout);
+        options.timeout = options.timeout ?? this.timeout;
+        const httpAgent = options.httpAgent ?? this.httpAgent ?? getDefaultAgent(url);
+        const minAgentTimeout = options.timeout + 1000;
+        if (typeof httpAgent?.options?.timeout === 'number' &&
+            minAgentTimeout > (httpAgent.options.timeout ?? 0)) {
+            // Allow any given request to bump our agent active socket timeout.
+            // This may seem strange, but leaking active sockets should be rare and not particularly problematic,
+            // and without mutating agent we would need to create more of them.
+            // This tradeoff optimizes for performance.
+            httpAgent.options.timeout = minAgentTimeout;
+        }
+        if (this.idempotencyHeader && method !== 'get') {
+            if (!inputOptions.idempotencyKey)
+                inputOptions.idempotencyKey = this.defaultIdempotencyKey();
+            headers[this.idempotencyHeader] = inputOptions.idempotencyKey;
+        }
+        const reqHeaders = this.buildHeaders({ options, headers, contentLength, retryCount });
+        const req = {
+            method,
+            ...(body && { body: body }),
+            headers: reqHeaders,
+            ...(httpAgent && { agent: httpAgent }),
+            // @ts-ignore node-fetch uses a custom AbortSignal type that is
+            // not compatible with standard web types
+            signal: options.signal ?? null,
+        };
+        return { req, url, timeout: options.timeout };
+    }
+    buildHeaders({ options, headers, contentLength, retryCount, }) {
+        const reqHeaders = {};
+        if (contentLength) {
+            reqHeaders['content-length'] = contentLength;
+        }
+        const defaultHeaders = this.defaultHeaders(options);
+        applyHeadersMut(reqHeaders, defaultHeaders);
+        applyHeadersMut(reqHeaders, headers);
+        // let builtin fetch set the Content-Type for multipart bodies
+        if (isMultipartBody(options.body) && kind !== 'node') {
+            delete reqHeaders['content-type'];
+        }
+        // Don't set theses headers if they were already set or removed through default headers or by the caller.
+        // We check `defaultHeaders` and `headers`, which can contain nulls, instead of `reqHeaders` to account
+        // for the removal case.
+        if (getHeader(defaultHeaders, 'x-stainless-retry-count') === undefined &&
+            getHeader(headers, 'x-stainless-retry-count') === undefined) {
+            reqHeaders['x-stainless-retry-count'] = String(retryCount);
+        }
+        if (getHeader(defaultHeaders, 'x-stainless-timeout') === undefined &&
+            getHeader(headers, 'x-stainless-timeout') === undefined &&
+            options.timeout) {
+            reqHeaders['x-stainless-timeout'] = String(Math.trunc(options.timeout / 1000));
+        }
+        this.validateHeaders(reqHeaders, headers);
+        return reqHeaders;
+    }
+    /**
+     * Used as a callback for mutating the given `FinalRequestOptions` object.
+     */
+    async prepareOptions(options) { }
+    /**
+     * 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`.
+     */
+    async prepareRequest(request, { url, options }) { }
+    parseHeaders(headers) {
+        return (!headers ? {}
+            : Symbol.iterator in headers ?
+                Object.fromEntries(Array.from(headers).map((header) => [...header]))
+                : { ...headers });
+    }
+    makeStatusError(status, error, message, headers) {
+        return APIError.generate(status, error, message, headers);
+    }
+    request(options, remainingRetries = null) {
+        return new APIPromise(this.makeRequest(options, remainingRetries));
+    }
+    async makeRequest(optionsInput, retriesRemaining) {
+        const options = await optionsInput;
+        const maxRetries = options.maxRetries ?? this.maxRetries;
+        if (retriesRemaining == null) {
+            retriesRemaining = maxRetries;
+        }
+        await this.prepareOptions(options);
+        const { req, url, timeout } = await this.buildRequest(options, {
+            retryCount: maxRetries - retriesRemaining,
+        });
+        await this.prepareRequest(req, { url, options });
+        debug('request', url, options, req.headers);
+        if (options.signal?.aborted) {
+            throw new APIUserAbortError();
+        }
+        const controller = new AbortController();
+        const response = await this.fetchWithTimeout(url, req, timeout, controller).catch(castToError);
+        if (response instanceof Error) {
+            if (options.signal?.aborted) {
+                throw new APIUserAbortError();
+            }
+            if (retriesRemaining) {
+                return this.retryRequest(options, retriesRemaining);
+            }
+            if (response.name === 'AbortError') {
+                throw new APIConnectionTimeoutError();
+            }
+            throw new APIConnectionError({ cause: response });
+        }
+        const responseHeaders = createResponseHeaders(response.headers);
+        if (!response.ok) {
+            if (retriesRemaining && this.shouldRetry(response)) {
+                const retryMessage = `retrying, ${retriesRemaining} attempts remaining`;
+                debug(`response (error; ${retryMessage})`, response.status, url, responseHeaders);
+                return this.retryRequest(options, retriesRemaining, responseHeaders);
+            }
+            const errText = await response.text().catch((e) => castToError(e).message);
+            const errJSON = safeJSON(errText);
+            const errMessage = errJSON ? undefined : errText;
+            const retryMessage = retriesRemaining ? `(error; no more retries left)` : `(error; not retryable)`;
+            debug(`response (error; ${retryMessage})`, response.status, url, responseHeaders, errMessage);
+            const err = this.makeStatusError(response.status, errJSON, errMessage, responseHeaders);
+            throw err;
+        }
+        return { response, options, controller };
+    }
+    requestAPIList(Page, options) {
+        const request = this.makeRequest(options, null);
+        return new PagePromise(this, request, Page);
+    }
+    buildURL(path, query, defaultBaseURL) {
+        const baseURL = (!__classPrivateFieldGet(this, _APIClient_baseURLOverridden, "f") && defaultBaseURL) || this.baseURL;
+        const url = isAbsoluteURL(path) ?
+            new URL(path)
+            : new URL(baseURL + (baseURL.endsWith('/') && path.startsWith('/') ? path.slice(1) : path));
+        const defaultQuery = this.defaultQuery();
+        if (!isEmptyObj(defaultQuery)) {
+            query = { ...defaultQuery, ...query };
+        }
+        if (typeof query === 'object' && query && !Array.isArray(query)) {
+            url.search = this.stringifyQuery(query);
+        }
+        return url.toString();
+    }
+    stringifyQuery(query) {
+        return Object.entries(query)
+            .filter(([_, value]) => typeof value !== 'undefined')
+            .map(([key, value]) => {
+            if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+                return `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
+            }
+            if (value === null) {
+                return `${encodeURIComponent(key)}=`;
+            }
+            throw new DodoPaymentsError(`Cannot stringify type ${typeof value}; Expected string, number, boolean, or null. If you need to pass nested query parameters, you can manually encode them, e.g. { query: { 'foo[key1]': value1, 'foo[key2]': value2 } }, and please open a GitHub issue requesting better support for your use case.`);
+        })
+            .join('&');
+    }
+    async fetchWithTimeout(url, init, ms, controller) {
+        const { signal, ...options } = init || {};
+        if (signal)
+            signal.addEventListener('abort', () => controller.abort());
+        const timeout = setTimeout(() => controller.abort(), ms);
+        const fetchOptions = {
+            signal: controller.signal,
+            ...options,
+        };
+        if (fetchOptions.method) {
+            // Custom methods like 'patch' need to be uppercased
+            // See https://github.com/nodejs/undici/issues/2294
+            fetchOptions.method = fetchOptions.method.toUpperCase();
+        }
+        return (
+        // use undefined this binding; fetch errors if bound to something else in browser/cloudflare
+        this.fetch.call(undefined, url, fetchOptions).finally(() => {
+            clearTimeout(timeout);
+        }));
+    }
+    shouldRetry(response) {
+        // Note this is not a standard header.
+        const shouldRetryHeader = response.headers.get('x-should-retry');
+        // If the server explicitly says whether or not to retry, obey.
+        if (shouldRetryHeader === 'true')
+            return true;
+        if (shouldRetryHeader === 'false')
+            return false;
+        // Retry on request timeouts.
+        if (response.status === 408)
+            return true;
+        // Retry on lock timeouts.
+        if (response.status === 409)
+            return true;
+        // Retry on rate limits.
+        if (response.status === 429)
+            return true;
+        // Retry internal errors.
+        if (response.status >= 500)
+            return true;
+        return false;
+    }
+    async retryRequest(options, retriesRemaining, responseHeaders) {
+        let timeoutMillis;
+        // Note the `retry-after-ms` header may not be standard, but is a good idea and we'd like proactive support for it.
+        const retryAfterMillisHeader = responseHeaders?.['retry-after-ms'];
+        if (retryAfterMillisHeader) {
+            const timeoutMs = parseFloat(retryAfterMillisHeader);
+            if (!Number.isNaN(timeoutMs)) {
+                timeoutMillis = timeoutMs;
+            }
+        }
+        // About the Retry-After header: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After
+        const retryAfterHeader = responseHeaders?.['retry-after'];
+        if (retryAfterHeader && !timeoutMillis) {
+            const timeoutSeconds = parseFloat(retryAfterHeader);
+            if (!Number.isNaN(timeoutSeconds)) {
+                timeoutMillis = timeoutSeconds * 1000;
+            }
+            else {
+                timeoutMillis = Date.parse(retryAfterHeader) - Date.now();
+            }
+        }
+        // If the API asks us to wait a certain amount of time (and it's a reasonable amount),
+        // just do what it says, but otherwise calculate a default
+        if (!(timeoutMillis && 0 <= timeoutMillis && timeoutMillis < 60 * 1000)) {
+            const maxRetries = options.maxRetries ?? this.maxRetries;
+            timeoutMillis = this.calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries);
+        }
+        await sleep(timeoutMillis);
+        return this.makeRequest(options, retriesRemaining - 1);
+    }
+    calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries) {
+        const initialRetryDelay = 0.5;
+        const maxRetryDelay = 8.0;
+        const numRetries = maxRetries - retriesRemaining;
+        // Apply exponential backoff, but not more than the max.
+        const sleepSeconds = Math.min(initialRetryDelay * Math.pow(2, numRetries), maxRetryDelay);
+        // Apply some jitter, take up to at most 25 percent of the retry time.
+        const jitter = 1 - Math.random() * 0.25;
+        return sleepSeconds * jitter * 1000;
+    }
+    getUserAgent() {
+        return `${this.constructor.name}/JS ${VERSION}`;
+    }
+}
+_APIClient_baseURLOverridden = new WeakMap();
+class AbstractPage {
+    constructor(client, response, body, options) {
+        _AbstractPage_client.set(this, void 0);
+        __classPrivateFieldSet(this, _AbstractPage_client, client, "f");
+        this.options = options;
+        this.response = response;
+        this.body = body;
+    }
+    hasNextPage() {
+        const items = this.getPaginatedItems();
+        if (!items.length)
+            return false;
+        return this.nextPageInfo() != null;
+    }
+    async getNextPage() {
+        const nextInfo = this.nextPageInfo();
+        if (!nextInfo) {
+            throw new DodoPaymentsError('No next page expected; please check `.hasNextPage()` before calling `.getNextPage()`.');
+        }
+        const nextOptions = { ...this.options };
+        if ('params' in nextInfo && typeof nextOptions.query === 'object') {
+            nextOptions.query = { ...nextOptions.query, ...nextInfo.params };
+        }
+        else if ('url' in nextInfo) {
+            const params = [...Object.entries(nextOptions.query || {}), ...nextInfo.url.searchParams.entries()];
+            for (const [key, value] of params) {
+                nextInfo.url.searchParams.set(key, value);
+            }
+            nextOptions.query = undefined;
+            nextOptions.path = nextInfo.url.toString();
+        }
+        return await __classPrivateFieldGet(this, _AbstractPage_client, "f").requestAPIList(this.constructor, nextOptions);
+    }
+    async *iterPages() {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        let page = this;
+        yield page;
+        while (page.hasNextPage()) {
+            page = await page.getNextPage();
+            yield page;
+        }
+    }
+    async *[(_AbstractPage_client = new WeakMap(), Symbol.asyncIterator)]() {
+        for await (const page of this.iterPages()) {
+            for (const item of page.getPaginatedItems()) {
+                yield item;
+            }
+        }
+    }
+}
+/**
+ * This subclass of Promise will resolve to an instantiated Page once the request completes.
+ *
+ * It also implements AsyncIterable to allow auto-paginating iteration on an unawaited list call, eg:
+ *
+ *    for await (const item of client.items.list()) {
+ *      console.log(item)
+ *    }
+ */
+class PagePromise extends APIPromise {
+    constructor(client, request, Page) {
+        super(request, async (props) => new Page(client, props.response, await defaultParseResponse(props), props.options));
+    }
+    /**
+     * Allow auto-paginating iteration on an unawaited list call, eg:
+     *
+     *    for await (const item of client.items.list()) {
+     *      console.log(item)
+     *    }
+     */
+    async *[Symbol.asyncIterator]() {
+        const page = await this;
+        for await (const item of page) {
+            yield item;
+        }
+    }
+}
+const createResponseHeaders = (headers) => {
+    return new Proxy(Object.fromEntries(
+    // @ts-ignore
+    headers.entries()), {
+        get(target, name) {
+            const key = name.toString();
+            return target[key.toLowerCase()] || target[key];
+        },
+    });
+};
+// This is required so that we can determine if a given object matches the RequestOptions
+// type at runtime. While this requires duplication, it is enforced by the TypeScript
+// compiler such that any missing / extraneous keys will cause an error.
+const requestOptionsKeys = {
+    method: true,
+    path: true,
+    query: true,
+    body: true,
+    headers: true,
+    defaultBaseURL: true,
+    maxRetries: true,
+    stream: true,
+    timeout: true,
+    httpAgent: true,
+    signal: true,
+    idempotencyKey: true,
+    __binaryRequest: true,
+    __binaryResponse: true,
+};
+const isRequestOptions = (obj) => {
+    return (typeof obj === 'object' &&
+        obj !== null &&
+        !isEmptyObj(obj) &&
+        Object.keys(obj).every((k) => hasOwn(requestOptionsKeys, k)));
+};
+const getPlatformProperties = () => {
+    if (typeof Deno !== 'undefined' && Deno.build != null) {
+        return {
+            'X-Stainless-Lang': 'js',
+            'X-Stainless-Package-Version': VERSION,
+            'X-Stainless-OS': normalizePlatform(Deno.build.os),
+            'X-Stainless-Arch': normalizeArch(Deno.build.arch),
+            'X-Stainless-Runtime': 'deno',
+            'X-Stainless-Runtime-Version': typeof Deno.version === 'string' ? Deno.version : Deno.version?.deno ?? 'unknown',
+        };
+    }
+    if (typeof EdgeRuntime !== 'undefined') {
+        return {
+            'X-Stainless-Lang': 'js',
+            'X-Stainless-Package-Version': VERSION,
+            'X-Stainless-OS': 'Unknown',
+            'X-Stainless-Arch': `other:${EdgeRuntime}`,
+            'X-Stainless-Runtime': 'edge',
+            'X-Stainless-Runtime-Version': process.version,
+        };
+    }
+    // Check if Node.js
+    if (Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]') {
+        return {
+            'X-Stainless-Lang': 'js',
+            'X-Stainless-Package-Version': VERSION,
+            'X-Stainless-OS': normalizePlatform(process.platform),
+            'X-Stainless-Arch': normalizeArch(process.arch),
+            'X-Stainless-Runtime': 'node',
+            'X-Stainless-Runtime-Version': process.version,
+        };
+    }
+    const browserInfo = getBrowserInfo();
+    if (browserInfo) {
+        return {
+            'X-Stainless-Lang': 'js',
+            'X-Stainless-Package-Version': VERSION,
+            'X-Stainless-OS': 'Unknown',
+            'X-Stainless-Arch': 'unknown',
+            'X-Stainless-Runtime': `browser:${browserInfo.browser}`,
+            'X-Stainless-Runtime-Version': browserInfo.version,
+        };
+    }
+    // TODO add support for Cloudflare workers, etc.
+    return {
+        'X-Stainless-Lang': 'js',
+        'X-Stainless-Package-Version': VERSION,
+        'X-Stainless-OS': 'Unknown',
+        'X-Stainless-Arch': 'unknown',
+        'X-Stainless-Runtime': 'unknown',
+        'X-Stainless-Runtime-Version': 'unknown',
+    };
+};
+// Note: modified from https://github.com/JS-DevTools/host-environment/blob/b1ab79ecde37db5d6e163c050e54fe7d287d7c92/src/isomorphic.browser.ts
+function getBrowserInfo() {
+    if (typeof navigator === 'undefined' || !navigator) {
+        return null;
+    }
+    // NOTE: The order matters here!
+    const browserPatterns = [
+        { key: 'edge', pattern: /Edge(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+        { key: 'ie', pattern: /MSIE(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+        { key: 'ie', pattern: /Trident(?:.*rv\:(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+        { key: 'chrome', pattern: /Chrome(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+        { key: 'firefox', pattern: /Firefox(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+        { key: 'safari', pattern: /(?:Version\W+(\d+)\.(\d+)(?:\.(\d+))?)?(?:\W+Mobile\S*)?\W+Safari/ },
+    ];
+    // Find the FIRST matching browser
+    for (const { key, pattern } of browserPatterns) {
+        const match = pattern.exec(navigator.userAgent);
+        if (match) {
+            const major = match[1] || 0;
+            const minor = match[2] || 0;
+            const patch = match[3] || 0;
+            return { browser: key, version: `${major}.${minor}.${patch}` };
+        }
+    }
+    return null;
+}
+const normalizeArch = (arch) => {
+    // Node docs:
+    // - https://nodejs.org/api/process.html#processarch
+    // Deno docs:
+    // - https://doc.deno.land/deno/stable/~/Deno.build
+    if (arch === 'x32')
+        return 'x32';
+    if (arch === 'x86_64' || arch === 'x64')
+        return 'x64';
+    if (arch === 'arm')
+        return 'arm';
+    if (arch === 'aarch64' || arch === 'arm64')
+        return 'arm64';
+    if (arch)
+        return `other:${arch}`;
+    return 'unknown';
+};
+const normalizePlatform = (platform) => {
+    // Node platforms:
+    // - https://nodejs.org/api/process.html#processplatform
+    // Deno platforms:
+    // - https://doc.deno.land/deno/stable/~/Deno.build
+    // - https://github.com/denoland/deno/issues/14799
+    platform = platform.toLowerCase();
+    // NOTE: this iOS check is untested and may not work
+    // Node does not work natively on IOS, there is a fork at
+    // https://github.com/nodejs-mobile/nodejs-mobile
+    // however it is unknown at the time of writing how to detect if it is running
+    if (platform.includes('ios'))
+        return 'iOS';
+    if (platform === 'android')
+        return 'Android';
+    if (platform === 'darwin')
+        return 'MacOS';
+    if (platform === 'win32')
+        return 'Windows';
+    if (platform === 'freebsd')
+        return 'FreeBSD';
+    if (platform === 'openbsd')
+        return 'OpenBSD';
+    if (platform === 'linux')
+        return 'Linux';
+    if (platform)
+        return `Other:${platform}`;
+    return 'Unknown';
+};
+let _platformHeaders;
+const getPlatformHeaders = () => {
+    return (_platformHeaders ?? (_platformHeaders = getPlatformProperties()));
+};
+const safeJSON = (text) => {
+    try {
+        return JSON.parse(text);
+    }
+    catch (err) {
+        return undefined;
+    }
+};
+// https://url.spec.whatwg.org/#url-scheme-string
+const startsWithSchemeRegexp = /^[a-z][a-z0-9+.-]*:/i;
+const isAbsoluteURL = (url) => {
+    return startsWithSchemeRegexp.test(url);
+};
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const validatePositiveInteger = (name, n) => {
+    if (typeof n !== 'number' || !Number.isInteger(n)) {
+        throw new DodoPaymentsError(`${name} must be an integer`);
+    }
+    if (n < 0) {
+        throw new DodoPaymentsError(`${name} must be a positive integer`);
+    }
+    return n;
+};
+const castToError = (err) => {
+    if (err instanceof Error)
+        return err;
+    if (typeof err === 'object' && err !== null) {
+        try {
+            return new Error(JSON.stringify(err));
+        }
+        catch { }
+    }
+    return new Error(err);
+};
+/**
+ * Read an environment variable.
+ *
+ * Trims beginning and trailing whitespace.
+ *
+ * Will return undefined if the environment variable doesn't exist or cannot be accessed.
+ */
+const readEnv = (env) => {
+    if (typeof process !== 'undefined') {
+        return process.env?.[env]?.trim() ?? undefined;
+    }
+    if (typeof Deno !== 'undefined') {
+        return Deno.env?.get?.(env)?.trim();
+    }
+    return undefined;
+};
+// https://stackoverflow.com/a/34491287
+function isEmptyObj(obj) {
+    if (!obj)
+        return true;
+    for (const _k in obj)
+        return false;
+    return true;
+}
+// https://eslint.org/docs/latest/rules/no-prototype-builtins
+function hasOwn(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+}
+/**
+ * Copies headers from "newHeaders" onto "targetHeaders",
+ * using lower-case for all properties,
+ * ignoring any keys with undefined values,
+ * and deleting any keys with null values.
+ */
+function applyHeadersMut(targetHeaders, newHeaders) {
+    for (const k in newHeaders) {
+        if (!hasOwn(newHeaders, k))
+            continue;
+        const lowerKey = k.toLowerCase();
+        if (!lowerKey)
+            continue;
+        const val = newHeaders[k];
+        if (val === null) {
+            delete targetHeaders[lowerKey];
+        }
+        else if (val !== undefined) {
+            targetHeaders[lowerKey] = val;
+        }
+    }
+}
+function debug(action, ...args) {
+    if (typeof process !== 'undefined' && process?.env?.['DEBUG'] === 'true') {
+        console.log(`DodoPayments:DEBUG:${action}`, ...args);
+    }
+}
+/**
+ * https://stackoverflow.com/a/2117523
+ */
+const uuid4 = () => {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+        const r = (Math.random() * 16) | 0;
+        const v = c === 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+};
+const isHeadersProtocol = (headers) => {
+    return typeof headers?.get === 'function';
+};
+const getHeader = (headers, header) => {
+    const lowerCasedHeader = header.toLowerCase();
+    if (isHeadersProtocol(headers)) {
+        // to deal with the case where the header looks like Stainless-Event-Id
+        const intercapsHeader = header[0]?.toUpperCase() +
+            header.substring(1).replace(/([^\w])(\w)/g, (_m, g1, g2) => g1 + g2.toUpperCase());
+        for (const key of [header, lowerCasedHeader, header.toUpperCase(), intercapsHeader]) {
+            const value = headers.get(key);
+            if (value) {
+                return value;
+            }
+        }
+    }
+    for (const [key, value] of Object.entries(headers)) {
+        if (key.toLowerCase() === lowerCasedHeader) {
+            if (Array.isArray(value)) {
+                if (value.length <= 1)
+                    return value[0];
+                console.warn(`Received ${value.length} entries for the ${header} header, using the first entry.`);
+                return value[0];
+            }
+            return value;
+        }
+    }
+    return undefined;
+};
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class DefaultPageNumberPagination extends AbstractPage {
+    constructor(client, response, body, options) {
+        super(client, response, body, options);
+        this.items = body.items || [];
+    }
+    getPaginatedItems() {
+        return this.items ?? [];
+    }
+    // @deprecated Please use `nextPageInfo()` instead
+    nextPageParams() {
+        const info = this.nextPageInfo();
+        if (!info)
+            return null;
+        if ('params' in info)
+            return info.params;
+        const params = Object.fromEntries(info.url.searchParams);
+        if (!Object.keys(params).length)
+            return null;
+        return params;
+    }
+    nextPageInfo() {
+        const query = this.options.query;
+        const currentPage = query?.page_number ?? 1;
+        return { params: { page_number: currentPage + 1 } };
+    }
+}
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class APIResource {
+    constructor(client) {
+        this._client = client;
+    }
+}
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class Addons extends APIResource {
+    create(body, options) {
+        return this._client.post('/addons', { body, ...options });
+    }
+    retrieve(id, options) {
+        return this._client.get(`/addons/${id}`, options);
+    }
+    update(id, body, options) {
+        return this._client.patch(`/addons/${id}`, { body, ...options });
+    }
+    list(query = {}, options) {
+        if (isRequestOptions(query)) {
+            return this.list({}, query);
+        }
+        return this._client.getAPIList('/addons', AddonResponsesDefaultPageNumberPagination, {
+            query,
+            ...options,
+        });
+    }
+    updateImages(id, options) {
+        return this._client.put(`/addons/${id}/images`, options);
+    }
+}
+class AddonResponsesDefaultPageNumberPagination extends DefaultPageNumberPagination {
+}
+Addons.AddonResponsesDefaultPageNumberPagination = AddonResponsesDefaultPageNumberPagination;
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class Brands extends APIResource {
+    create(body, options) {
+        return this._client.post('/brands', { body, ...options });
+    }
+    /**
+     * Thin handler just calls `get_brand` and wraps in `Json(...)`
+     */
+    retrieve(id, options) {
+        return this._client.get(`/brands/${id}`, options);
+    }
+    update(id, body, options) {
+        return this._client.patch(`/brands/${id}`, { body, ...options });
+    }
+    list(options) {
+        return this._client.get('/brands', options);
+    }
+    updateImages(id, options) {
+        return this._client.put(`/brands/${id}/images`, options);
+    }
+}
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+let CustomerPortal$1 = class CustomerPortal extends APIResource {
+    create(customerId, params = {}, options) {
+        if (isRequestOptions(params)) {
+            return this.create(customerId, {}, params);
+        }
+        const { send_email } = params;
+        return this._client.post(`/customers/${customerId}/customer-portal/session`, {
+            query: { send_email },
+            ...options,
+        });
+    }
+};
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class Customers extends APIResource {
+    constructor() {
+        super(...arguments);
+        this.customerPortal = new CustomerPortal$1(this._client);
+    }
+    create(body, options) {
+        return this._client.post('/customers', { body, ...options });
+    }
+    retrieve(customerId, options) {
+        return this._client.get(`/customers/${customerId}`, options);
+    }
+    update(customerId, body, options) {
+        return this._client.patch(`/customers/${customerId}`, { body, ...options });
+    }
+    list(query = {}, options) {
+        if (isRequestOptions(query)) {
+            return this.list({}, query);
+        }
+        return this._client.getAPIList('/customers', CustomersDefaultPageNumberPagination, { query, ...options });
+    }
+}
+class CustomersDefaultPageNumberPagination extends DefaultPageNumberPagination {
+}
+Customers.CustomersDefaultPageNumberPagination = CustomersDefaultPageNumberPagination;
+Customers.CustomerPortal = CustomerPortal$1;
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class Discounts extends APIResource {
+    /**
+     * POST /discounts If `code` is omitted or empty, a random 16-char uppercase code
+     * is generated.
+     */
+    create(body, options) {
+        return this._client.post('/discounts', { body, ...options });
+    }
+    /**
+     * GET /discounts/{discount_id}
+     */
+    retrieve(discountId, options) {
+        return this._client.get(`/discounts/${discountId}`, options);
+    }
+    /**
+     * PATCH /discounts/{discount_id}
+     */
+    update(discountId, body, options) {
+        return this._client.patch(`/discounts/${discountId}`, { body, ...options });
+    }
+    list(query = {}, options) {
+        if (isRequestOptions(query)) {
+            return this.list({}, query);
+        }
+        return this._client.getAPIList('/discounts', DiscountsDefaultPageNumberPagination, { query, ...options });
+    }
+    /**
+     * DELETE /discounts/{discount_id}
+     */
+    delete(discountId, options) {
+        return this._client.delete(`/discounts/${discountId}`, {
+            ...options,
+            headers: { Accept: '*/*', ...options?.headers },
+        });
+    }
+}
+class DiscountsDefaultPageNumberPagination extends DefaultPageNumberPagination {
+}
+Discounts.DiscountsDefaultPageNumberPagination = DiscountsDefaultPageNumberPagination;
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class Disputes extends APIResource {
+    retrieve(disputeId, options) {
+        return this._client.get(`/disputes/${disputeId}`, options);
+    }
+    list(query = {}, options) {
+        if (isRequestOptions(query)) {
+            return this.list({}, query);
+        }
+        return this._client.getAPIList('/disputes', DisputeListResponsesDefaultPageNumberPagination, {
+            query,
+            ...options,
+        });
+    }
+}
+class DisputeListResponsesDefaultPageNumberPagination extends DefaultPageNumberPagination {
+}
+Disputes.DisputeListResponsesDefaultPageNumberPagination = DisputeListResponsesDefaultPageNumberPagination;
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+let Payments$1 = class Payments extends APIResource {
+    retrieve(paymentId, options) {
+        return this._client.get(`/invoices/payments/${paymentId}`, {
+            ...options,
+            headers: { Accept: 'application/pdf', ...options?.headers },
+            __binaryResponse: true,
+        });
+    }
+};
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class Invoices extends APIResource {
+    constructor() {
+        super(...arguments);
+        this.payments = new Payments$1(this._client);
+    }
+}
+Invoices.Payments = Payments$1;
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class LicenseKeyInstances extends APIResource {
+    /**
+     * @example
+     * ```ts
+     * const licenseKeyInstance =
+     *   await client.licenseKeyInstances.retrieve('lki_123');
+     * ```
+     */
+    retrieve(id, options) {
+        return this._client.get(`/license_key_instances/${id}`, options);
+    }
+    /**
+     * @example
+     * ```ts
+     * const licenseKeyInstance =
+     *   await client.licenseKeyInstances.update('lki_123', {
+     *     name: 'name',
+     *   });
+     * ```
+     */
+    update(id, body, options) {
+        return this._client.patch(`/license_key_instances/${id}`, { body, ...options });
+    }
+    list(query = {}, options) {
+        if (isRequestOptions(query)) {
+            return this.list({}, query);
+        }
+        return this._client.getAPIList('/license_key_instances', LicenseKeyInstancesDefaultPageNumberPagination, {
+            query,
+            ...options,
+        });
+    }
+}
+class LicenseKeyInstancesDefaultPageNumberPagination extends DefaultPageNumberPagination {
+}
+LicenseKeyInstances.LicenseKeyInstancesDefaultPageNumberPagination =
+    LicenseKeyInstancesDefaultPageNumberPagination;
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class LicenseKeys extends APIResource {
+    /**
+     * @example
+     * ```ts
+     * const licenseKey = await client.licenseKeys.retrieve(
+     *   'lic_123',
+     * );
+     * ```
+     */
+    retrieve(id, options) {
+        return this._client.get(`/license_keys/${id}`, options);
+    }
+    /**
+     * @example
+     * ```ts
+     * const licenseKey = await client.licenseKeys.update(
+     *   'lic_123',
+     * );
+     * ```
+     */
+    update(id, body, options) {
+        return this._client.patch(`/license_keys/${id}`, { body, ...options });
+    }
+    list(query = {}, options) {
+        if (isRequestOptions(query)) {
+            return this.list({}, query);
+        }
+        return this._client.getAPIList('/license_keys', LicenseKeysDefaultPageNumberPagination, {
+            query,
+            ...options,
+        });
+    }
+}
+class LicenseKeysDefaultPageNumberPagination extends DefaultPageNumberPagination {
+}
+LicenseKeys.LicenseKeysDefaultPageNumberPagination = LicenseKeysDefaultPageNumberPagination;
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class Licenses extends APIResource {
+    /**
+     * @example
+     * ```ts
+     * const licenseKeyInstance = await client.licenses.activate({
+     *   license_key: 'license_key',
+     *   name: 'name',
+     * });
+     * ```
+     */
+    activate(body, options) {
+        return this._client.post('/licenses/activate', { body, ...options });
+    }
+    /**
+     * @example
+     * ```ts
+     * await client.licenses.deactivate({
+     *   license_key: 'license_key',
+     *   license_key_instance_id: 'license_key_instance_id',
+     * });
+     * ```
+     */
+    deactivate(body, options) {
+        return this._client.post('/licenses/deactivate', {
+            body,
+            ...options,
+            headers: { Accept: '*/*', ...options?.headers },
+        });
+    }
+    /**
+     * @example
+     * ```ts
+     * const response = await client.licenses.validate({
+     *   license_key: '2b1f8e2d-c41e-4e8f-b2d3-d9fd61c38f43',
+     * });
+     * ```
+     */
+    validate(body, options) {
+        return this._client.post('/licenses/validate', { body, ...options });
+    }
+}
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class Misc extends APIResource {
+    listSupportedCountries(options) {
+        return this._client.get('/checkout/supported_countries', options);
+    }
+}
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class Payments extends APIResource {
+    create(body, options) {
+        return this._client.post('/payments', { body, ...options });
+    }
+    retrieve(paymentId, options) {
+        return this._client.get(`/payments/${paymentId}`, options);
+    }
+    list(query = {}, options) {
+        if (isRequestOptions(query)) {
+            return this.list({}, query);
+        }
+        return this._client.getAPIList('/payments', PaymentListResponsesDefaultPageNumberPagination, {
+            query,
+            ...options,
+        });
+    }
+    retrieveLineItems(paymentId, options) {
+        return this._client.get(`/payments/${paymentId}/line-items`, options);
+    }
+}
+class PaymentListResponsesDefaultPageNumberPagination extends DefaultPageNumberPagination {
+}
+Payments.PaymentListResponsesDefaultPageNumberPagination = PaymentListResponsesDefaultPageNumberPagination;
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class Payouts extends APIResource {
+    list(query = {}, options) {
+        if (isRequestOptions(query)) {
+            return this.list({}, query);
+        }
+        return this._client.getAPIList('/payouts', PayoutListResponsesDefaultPageNumberPagination, {
+            query,
+            ...options,
+        });
+    }
+}
+class PayoutListResponsesDefaultPageNumberPagination extends DefaultPageNumberPagination {
+}
+Payouts.PayoutListResponsesDefaultPageNumberPagination = PayoutListResponsesDefaultPageNumberPagination;
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class Images extends APIResource {
+    update(id, params = {}, options) {
+        if (isRequestOptions(params)) {
+            return this.update(id, {}, params);
+        }
+        const { force_update } = params;
+        return this._client.put(`/products/${id}/images`, { query: { force_update }, ...options });
+    }
+}
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class Products extends APIResource {
+    constructor() {
+        super(...arguments);
+        this.images = new Images(this._client);
+    }
+    create(body, options) {
+        return this._client.post('/products', { body, ...options });
+    }
+    retrieve(id, options) {
+        return this._client.get(`/products/${id}`, options);
+    }
+    update(id, body, options) {
+        return this._client.patch(`/products/${id}`, {
+            body,
+            ...options,
+            headers: { Accept: '*/*', ...options?.headers },
+        });
+    }
+    list(query = {}, options) {
+        if (isRequestOptions(query)) {
+            return this.list({}, query);
+        }
+        return this._client.getAPIList('/products', ProductListResponsesDefaultPageNumberPagination, {
+            query,
+            ...options,
+        });
+    }
+    delete(id, options) {
+        return this._client.delete(`/products/${id}`, {
+            ...options,
+            headers: { Accept: '*/*', ...options?.headers },
+        });
+    }
+    unarchive(id, options) {
+        return this._client.post(`/products/${id}/unarchive`, {
+            ...options,
+            headers: { Accept: '*/*', ...options?.headers },
+        });
+    }
+    updateFiles(id, body, options) {
+        return this._client.put(`/products/${id}/files`, { body, ...options });
+    }
+}
+class ProductListResponsesDefaultPageNumberPagination extends DefaultPageNumberPagination {
+}
+Products.ProductListResponsesDefaultPageNumberPagination = ProductListResponsesDefaultPageNumberPagination;
+Products.Images = Images;
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class Refunds extends APIResource {
+    create(body, options) {
+        return this._client.post('/refunds', { body, ...options });
+    }
+    retrieve(refundId, options) {
+        return this._client.get(`/refunds/${refundId}`, options);
+    }
+    list(query = {}, options) {
+        if (isRequestOptions(query)) {
+            return this.list({}, query);
+        }
+        return this._client.getAPIList('/refunds', RefundsDefaultPageNumberPagination, { query, ...options });
+    }
+}
+class RefundsDefaultPageNumberPagination extends DefaultPageNumberPagination {
+}
+Refunds.RefundsDefaultPageNumberPagination = RefundsDefaultPageNumberPagination;
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class Subscriptions extends APIResource {
+    create(body, options) {
+        return this._client.post('/subscriptions', { body, ...options });
+    }
+    retrieve(subscriptionId, options) {
+        return this._client.get(`/subscriptions/${subscriptionId}`, options);
+    }
+    update(subscriptionId, body, options) {
+        return this._client.patch(`/subscriptions/${subscriptionId}`, { body, ...options });
+    }
+    list(query = {}, options) {
+        if (isRequestOptions(query)) {
+            return this.list({}, query);
+        }
+        return this._client.getAPIList('/subscriptions', SubscriptionListResponsesDefaultPageNumberPagination, {
+            query,
+            ...options,
+        });
+    }
+    changePlan(subscriptionId, body, options) {
+        return this._client.post(`/subscriptions/${subscriptionId}/change-plan`, {
+            body,
+            ...options,
+            headers: { Accept: '*/*', ...options?.headers },
+        });
+    }
+    charge(subscriptionId, body, options) {
+        return this._client.post(`/subscriptions/${subscriptionId}/charge`, { body, ...options });
+    }
+}
+class SubscriptionListResponsesDefaultPageNumberPagination extends DefaultPageNumberPagination {
+}
+Subscriptions.SubscriptionListResponsesDefaultPageNumberPagination =
+    SubscriptionListResponsesDefaultPageNumberPagination;
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class WebhookEvents extends APIResource {
+    /**
+     * @deprecated
+     */
+    retrieve(webhookEventId, options) {
+        return this._client.get(`/webhook_events/${webhookEventId}`, options);
+    }
+    list(query = {}, options) {
+        if (isRequestOptions(query)) {
+            return this.list({}, query);
+        }
+        return this._client.getAPIList('/webhook_events', WebhookEventsDefaultPageNumberPagination, {
+            query,
+            ...options,
+        });
+    }
+}
+class WebhookEventsDefaultPageNumberPagination extends DefaultPageNumberPagination {
+}
+WebhookEvents.WebhookEventsDefaultPageNumberPagination = WebhookEventsDefaultPageNumberPagination;
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+var _DodoPayments_instances, _a;
+const environments = {
+    live_mode: 'https://live.dodopayments.com',
+    test_mode: 'https://test.dodopayments.com',
+};
+/**
+ * API Client for interfacing with the Dodo Payments API.
+ */
+class DodoPayments extends APIClient {
+    /**
+     * 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 {number} [opts.httpAgent] - An HTTP agent used to manage HTTP(s) connections.
+     * @param {Core.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 {Core.Headers} opts.defaultHeaders - Default headers to include with every request to the API.
+     * @param {Core.DefaultQuery} opts.defaultQuery - Default query parameters to include with every request to the API.
+     */
+    constructor({ baseURL = readEnv('DODO_PAYMENTS_BASE_URL'), bearerToken = readEnv('DODO_PAYMENTS_API_KEY'), ...opts } = {}) {
+        if (bearerToken === undefined) {
+            throw new DodoPaymentsError("The DODO_PAYMENTS_API_KEY environment variable is missing or empty; either provide it, or instantiate the DodoPayments client with an bearerToken option, like new DodoPayments({ bearerToken: 'My Bearer Token' }).");
+        }
+        const options = {
+            bearerToken,
+            ...opts,
+            baseURL,
+            environment: opts.environment ?? 'live_mode',
+        };
+        if (baseURL && opts.environment) {
+            throw new DodoPaymentsError('Ambiguous URL; The `baseURL` option (or DODO_PAYMENTS_BASE_URL env var) and the `environment` option are given. If you want to use the environment you must pass baseURL: null');
+        }
+        super({
+            baseURL: options.baseURL || environments[options.environment || 'live_mode'],
+            baseURLOverridden: baseURL ? baseURL !== environments[options.environment || 'live_mode'] : false,
+            timeout: options.timeout ?? 60000 /* 1 minute */,
+            httpAgent: options.httpAgent,
+            maxRetries: options.maxRetries,
+            fetch: options.fetch,
+        });
+        _DodoPayments_instances.add(this);
+        this.payments = new Payments(this);
+        this.subscriptions = new Subscriptions(this);
+        this.invoices = new Invoices(this);
+        this.licenses = new Licenses(this);
+        this.licenseKeys = new LicenseKeys(this);
+        this.licenseKeyInstances = new LicenseKeyInstances(this);
+        this.customers = new Customers(this);
+        this.refunds = new Refunds(this);
+        this.disputes = new Disputes(this);
+        this.payouts = new Payouts(this);
+        this.webhookEvents = new WebhookEvents(this);
+        this.products = new Products(this);
+        this.misc = new Misc(this);
+        this.discounts = new Discounts(this);
+        this.addons = new Addons(this);
+        this.brands = new Brands(this);
+        this._options = options;
+        this.bearerToken = bearerToken;
+    }
+    defaultQuery() {
+        return this._options.defaultQuery;
+    }
+    defaultHeaders(opts) {
+        return {
+            ...super.defaultHeaders(opts),
+            ...this._options.defaultHeaders,
+        };
+    }
+    authHeaders(opts) {
+        return { Authorization: `Bearer ${this.bearerToken}` };
+    }
+}
+_a = DodoPayments, _DodoPayments_instances = new WeakSet();
+DodoPayments.DodoPayments = _a;
+DodoPayments.DEFAULT_TIMEOUT = 60000; // 1 minute
+DodoPayments.DodoPaymentsError = DodoPaymentsError;
+DodoPayments.APIError = APIError;
+DodoPayments.APIConnectionError = APIConnectionError;
+DodoPayments.APIConnectionTimeoutError = APIConnectionTimeoutError;
+DodoPayments.APIUserAbortError = APIUserAbortError;
+DodoPayments.NotFoundError = NotFoundError;
+DodoPayments.ConflictError = ConflictError;
+DodoPayments.RateLimitError = RateLimitError;
+DodoPayments.BadRequestError = BadRequestError;
+DodoPayments.AuthenticationError = AuthenticationError;
+DodoPayments.InternalServerError = InternalServerError;
+DodoPayments.PermissionDeniedError = PermissionDeniedError;
+DodoPayments.UnprocessableEntityError = UnprocessableEntityError;
+DodoPayments.toFile = toFile;
+DodoPayments.fileFromPath = fileFromPath;
+DodoPayments.Payments = Payments;
+DodoPayments.PaymentListResponsesDefaultPageNumberPagination =
+    PaymentListResponsesDefaultPageNumberPagination;
+DodoPayments.Subscriptions = Subscriptions;
+DodoPayments.SubscriptionListResponsesDefaultPageNumberPagination =
+    SubscriptionListResponsesDefaultPageNumberPagination;
+DodoPayments.Invoices = Invoices;
+DodoPayments.Licenses = Licenses;
+DodoPayments.LicenseKeys = LicenseKeys;
+DodoPayments.LicenseKeysDefaultPageNumberPagination = LicenseKeysDefaultPageNumberPagination;
+DodoPayments.LicenseKeyInstances = LicenseKeyInstances;
+DodoPayments.LicenseKeyInstancesDefaultPageNumberPagination = LicenseKeyInstancesDefaultPageNumberPagination;
+DodoPayments.Customers = Customers;
+DodoPayments.CustomersDefaultPageNumberPagination = CustomersDefaultPageNumberPagination;
+DodoPayments.Refunds = Refunds;
+DodoPayments.RefundsDefaultPageNumberPagination = RefundsDefaultPageNumberPagination;
+DodoPayments.Disputes = Disputes;
+DodoPayments.DisputeListResponsesDefaultPageNumberPagination =
+    DisputeListResponsesDefaultPageNumberPagination;
+DodoPayments.Payouts = Payouts;
+DodoPayments.PayoutListResponsesDefaultPageNumberPagination = PayoutListResponsesDefaultPageNumberPagination;
+DodoPayments.WebhookEvents = WebhookEvents;
+DodoPayments.WebhookEventsDefaultPageNumberPagination = WebhookEventsDefaultPageNumberPagination;
+DodoPayments.Products = Products;
+DodoPayments.ProductListResponsesDefaultPageNumberPagination =
+    ProductListResponsesDefaultPageNumberPagination;
+DodoPayments.Misc = Misc;
+DodoPayments.Discounts = Discounts;
+DodoPayments.DiscountsDefaultPageNumberPagination = DiscountsDefaultPageNumberPagination;
+DodoPayments.Addons = Addons;
+DodoPayments.AddonResponsesDefaultPageNumberPagination = AddonResponsesDefaultPageNumberPagination;
+DodoPayments.Brands = Brands;
+
+var __awaiter$1 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator$1 = (undefined && undefined.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var checkoutQuerySchema = zod.z.object({
+    productId: zod.z.string(),
+    quantity: zod.z.string().optional(),
+    // Customer fields
+    fullName: zod.z.string().optional(),
+    firstName: zod.z.string().optional(),
+    lastName: zod.z.string().optional(),
+    email: zod.z.string().optional(),
+    country: zod.z.string().optional(),
+    addressLine: zod.z.string().optional(),
+    city: zod.z.string().optional(),
+    state: zod.z.string().optional(),
+    zipCode: zod.z.string().optional(),
+    // Disable flags
+    disableFullName: zod.z.string().optional(),
+    disableFirstName: zod.z.string().optional(),
+    disableLastName: zod.z.string().optional(),
+    disableEmail: zod.z.string().optional(),
+    disableCountry: zod.z.string().optional(),
+    disableAddressLine: zod.z.string().optional(),
+    disableCity: zod.z.string().optional(),
+    disableState: zod.z.string().optional(),
+    disableZipCode: zod.z.string().optional(),
+    // Advanced controls
+    paymentCurrency: zod.z.string().optional(),
+    showCurrencySelector: zod.z.string().optional(),
+    paymentAmount: zod.z.string().optional(),
+    showDiscounts: zod.z.string().optional(),
+    // Metadata (allow any key starting with metadata_)
+    // We'll handle metadata separately in the handler
+});
+// Add Zod schema for dynamic checkout body
+var dynamicCheckoutBodySchema = zod.z
+    .object({
+    // For subscription
+    product_id: zod.z.string().optional(),
+    quantity: zod.z.number().optional(),
+    // For one-time payment
+    product_cart: zod.z
+        .array(zod.z.object({
+        product_id: zod.z.string(),
+        quantity: zod.z.number(),
+    }))
+        .optional(),
+    // Common fields
+    billing: zod.z.object({
+        city: zod.z.string(),
+        country: zod.z.string(),
+        state: zod.z.string(),
+        street: zod.z.string(),
+        zipcode: zod.z.string(),
+    }),
+    customer: zod.z.object({
+        customer_id: zod.z.string().optional(),
+        email: zod.z.string().optional(),
+        name: zod.z.string().optional(),
+    }),
+    discount_id: zod.z.string().optional(),
+    addons: zod.z
+        .array(zod.z.object({
+        addon_id: zod.z.string(),
+        quantity: zod.z.number(),
+    }))
+        .optional(),
+    metadata: zod.z.record(zod.z.string(), zod.z.string()).optional(),
+    currency: zod.z.string().optional(),
+    // Allow any additional fields (for future compatibility)
+})
+    .catchall(zod.z.unknown());
+var buildCheckoutUrl = function (_a) { return __awaiter$1(void 0, [_a], void 0, function (_b) {
+    var inputData, parseResult, success, data, error, _c, productId, quantity_1, fullName, firstName, lastName, email, country, addressLine, city, state, zipCode, disableFullName, disableFirstName, disableLastName, disableEmail, disableCountry, disableAddressLine, disableCity, disableState, disableZipCode, paymentCurrency, showCurrencySelector, paymentAmount, showDiscounts, dodopayments_1, err_1, url, _i, _d, _e, key, value, dyn, product_id, product_cart, quantity, billing, customer, addons, metadata, allowed_payment_method_types, billing_currency, discount_code, on_demand, bodyReturnUrl, show_saved_payment_methods, tax_id, trial_period_days, dodopayments, isSubscription, productIdToFetch, product, err_2, subscriptionPayload, subscription, err_3, cart, paymentPayload, payment, err_4;
+    var queryParams = _b.queryParams, body = _b.body, returnUrl = _b.returnUrl, bearerToken = _b.bearerToken, environment = _b.environment, _f = _b.type, type = _f === void 0 ? "static" : _f;
+    return __generator$1(this, function (_g) {
+        switch (_g.label) {
+            case 0:
+                inputData = type === "dynamic" ? body : queryParams;
+                if (type === "dynamic") {
+                    parseResult = dynamicCheckoutBodySchema.safeParse(inputData);
+                }
+                else {
+                    parseResult = checkoutQuerySchema.safeParse(inputData);
+                }
+                success = parseResult.success, data = parseResult.data, error = parseResult.error;
+                if (!success) {
+                    throw new Error("Invalid ".concat(type === "dynamic" ? "body" : "query parameters", ".\n ").concat(error.message));
+                }
+                if (!(type !== "dynamic")) return [3 /*break*/, 5];
+                _c = data, productId = _c.productId, quantity_1 = _c.quantity, fullName = _c.fullName, firstName = _c.firstName, lastName = _c.lastName, email = _c.email, country = _c.country, addressLine = _c.addressLine, city = _c.city, state = _c.state, zipCode = _c.zipCode, disableFullName = _c.disableFullName, disableFirstName = _c.disableFirstName, disableLastName = _c.disableLastName, disableEmail = _c.disableEmail, disableCountry = _c.disableCountry, disableAddressLine = _c.disableAddressLine, disableCity = _c.disableCity, disableState = _c.disableState, disableZipCode = _c.disableZipCode, paymentCurrency = _c.paymentCurrency, showCurrencySelector = _c.showCurrencySelector, paymentAmount = _c.paymentAmount, showDiscounts = _c.showDiscounts;
+                dodopayments_1 = new DodoPayments({
+                    bearerToken: bearerToken,
+                    environment: environment,
+                });
+                // Check that the product exists for this merchant
+                if (!productId)
+                    throw new Error("Missing required field: productId");
+                _g.label = 1;
+            case 1:
+                _g.trys.push([1, 3, , 4]);
+                return [4 /*yield*/, dodopayments_1.products.retrieve(productId)];
+            case 2:
+                _g.sent();
+                return [3 /*break*/, 4];
+            case 3:
+                err_1 = _g.sent();
+                console.error(err_1);
+                throw new Error("Product not found");
+            case 4:
+                url = new URL("".concat(environment === "test_mode" ? "https://test.checkout.dodopayments.com" : "https://checkout.dodopayments.com", "/buy/").concat(productId));
+                url.searchParams.set("quantity", quantity_1 ? String(quantity_1) : "1");
+                if (returnUrl)
+                    url.searchParams.set("redirect_url", returnUrl);
+                // Customer/billing fields
+                if (fullName)
+                    url.searchParams.set("fullName", String(fullName));
+                if (firstName)
+                    url.searchParams.set("firstName", String(firstName));
+                if (lastName)
+                    url.searchParams.set("lastName", String(lastName));
+                if (email)
+                    url.searchParams.set("email", String(email));
+                if (country)
+                    url.searchParams.set("country", String(country));
+                if (addressLine)
+                    url.searchParams.set("addressLine", String(addressLine));
+                if (city)
+                    url.searchParams.set("city", String(city));
+                if (state)
+                    url.searchParams.set("state", String(state));
+                if (zipCode)
+                    url.searchParams.set("zipCode", String(zipCode));
+                // Disable flags (must be set to 'true' to disable)
+                if (disableFullName === "true")
+                    url.searchParams.set("disableFullName", "true");
+                if (disableFirstName === "true")
+                    url.searchParams.set("disableFirstName", "true");
+                if (disableLastName === "true")
+                    url.searchParams.set("disableLastName", "true");
+                if (disableEmail === "true")
+                    url.searchParams.set("disableEmail", "true");
+                if (disableCountry === "true")
+                    url.searchParams.set("disableCountry", "true");
+                if (disableAddressLine === "true")
+                    url.searchParams.set("disableAddressLine", "true");
+                if (disableCity === "true")
+                    url.searchParams.set("disableCity", "true");
+                if (disableState === "true")
+                    url.searchParams.set("disableState", "true");
+                if (disableZipCode === "true")
+                    url.searchParams.set("disableZipCode", "true");
+                // Advanced controls
+                if (paymentCurrency)
+                    url.searchParams.set("paymentCurrency", String(paymentCurrency));
+                if (showCurrencySelector)
+                    url.searchParams.set("showCurrencySelector", String(showCurrencySelector));
+                if (paymentAmount)
+                    url.searchParams.set("paymentAmount", String(paymentAmount));
+                if (showDiscounts)
+                    url.searchParams.set("showDiscounts", String(showDiscounts));
+                // Metadata: add all query params starting with metadata_
+                for (_i = 0, _d = Object.entries(queryParams || {}); _i < _d.length; _i++) {
+                    _e = _d[_i], key = _e[0], value = _e[1];
+                    if (key.startsWith("metadata_") && value && typeof value !== "object") {
+                        url.searchParams.set(key, String(value));
+                    }
+                }
+                return [2 /*return*/, url.toString()];
+            case 5:
+                dyn = data;
+                product_id = dyn.product_id, product_cart = dyn.product_cart, quantity = dyn.quantity, billing = dyn.billing, customer = dyn.customer, addons = dyn.addons, metadata = dyn.metadata, allowed_payment_method_types = dyn.allowed_payment_method_types, billing_currency = dyn.billing_currency, discount_code = dyn.discount_code, on_demand = dyn.on_demand, bodyReturnUrl = dyn.return_url, show_saved_payment_methods = dyn.show_saved_payment_methods, tax_id = dyn.tax_id, trial_period_days = dyn.trial_period_days;
+                dodopayments = new DodoPayments({
+                    bearerToken: bearerToken,
+                    environment: environment,
+                });
+                isSubscription = false;
+                productIdToFetch = product_id;
+                if (!product_id && product_cart && product_cart.length > 0) {
+                    productIdToFetch = product_cart[0].product_id;
+                }
+                if (!productIdToFetch)
+                    throw new Error("Missing required field: product_id or product_cart[0].product_id");
+                _g.label = 6;
+            case 6:
+                _g.trys.push([6, 8, , 9]);
+                return [4 /*yield*/, dodopayments.products.retrieve(productIdToFetch)];
+            case 7:
+                product = _g.sent();
+                return [3 /*break*/, 9];
+            case 8:
+                err_2 = _g.sent();
+                console.error(err_2);
+                throw new Error("Product not found");
+            case 9:
+                isSubscription = Boolean(product.is_recurring);
+                // Required field validation
+                if (isSubscription && !product_id)
+                    throw new Error("Missing required field: product_id for subscription");
+                if (!billing)
+                    throw new Error("Missing required field: billing");
+                if (!customer)
+                    throw new Error("Missing required field: customer");
+                if (!isSubscription) return [3 /*break*/, 14];
+                subscriptionPayload = {
+                    billing: billing,
+                    customer: customer,
+                    product_id: product_id,
+                    quantity: quantity ? Number(quantity) : 1,
+                };
+                if (metadata)
+                    subscriptionPayload.metadata = metadata;
+                if (discount_code)
+                    subscriptionPayload.discount_code = discount_code;
+                if (addons)
+                    subscriptionPayload.addons = addons;
+                if (allowed_payment_method_types)
+                    subscriptionPayload.allowed_payment_method_types =
+                        allowed_payment_method_types;
+                if (billing_currency)
+                    subscriptionPayload.billing_currency = billing_currency;
+                if (on_demand)
+                    subscriptionPayload.on_demand = on_demand;
+                subscriptionPayload.payment_link = true;
+                // Use bodyReturnUrl if present, otherwise use top-level returnUrl
+                if (bodyReturnUrl) {
+                    subscriptionPayload.return_url = bodyReturnUrl;
+                }
+                else if (returnUrl) {
+                    subscriptionPayload.return_url = returnUrl;
+                }
+                if (show_saved_payment_methods)
+                    subscriptionPayload.show_saved_payment_methods =
+                        show_saved_payment_methods;
+                if (tax_id)
+                    subscriptionPayload.tax_id = tax_id;
+                if (trial_period_days)
+                    subscriptionPayload.trial_period_days = trial_period_days;
+                subscription = void 0;
+                _g.label = 10;
+            case 10:
+                _g.trys.push([10, 12, , 13]);
+                return [4 /*yield*/, dodopayments.subscriptions.create(subscriptionPayload)];
+            case 11:
+                subscription =
+                    _g.sent();
+                return [3 /*break*/, 13];
+            case 12:
+                err_3 = _g.sent();
+                console.error("Error when creating subscription", err_3);
+                throw new Error(err_3 instanceof Error ? err_3.message : String(err_3));
+            case 13:
+                if (!subscription || !subscription.payment_link) {
+                    throw new Error("No payment link returned from Dodo Payments API (subscription). Make sure to set payment_link as true in payload");
+                }
+                return [2 /*return*/, subscription.payment_link];
+            case 14:
+                cart = product_cart;
+                if (!cart && product_id) {
+                    cart = [
+                        { product_id: product_id, quantity: quantity ? Number(quantity) : 1 },
+                    ];
+                }
+                if (!cart || cart.length === 0)
+                    throw new Error("Missing required field: product_cart or product_id");
+                paymentPayload = {
+                    billing: billing,
+                    customer: customer,
+                    product_cart: cart,
+                };
+                if (metadata)
+                    paymentPayload.metadata = metadata;
+                paymentPayload.payment_link = true;
+                if (allowed_payment_method_types)
+                    paymentPayload.allowed_payment_method_types =
+                        allowed_payment_method_types;
+                if (billing_currency)
+                    paymentPayload.billing_currency = billing_currency;
+                if (discount_code)
+                    paymentPayload.discount_code = discount_code;
+                // Use bodyReturnUrl if present, otherwise use top-level returnUrl
+                if (bodyReturnUrl) {
+                    paymentPayload.return_url = bodyReturnUrl;
+                }
+                else if (returnUrl) {
+                    paymentPayload.return_url = returnUrl;
+                }
+                if (show_saved_payment_methods)
+                    paymentPayload.show_saved_payment_methods = show_saved_payment_methods;
+                if (tax_id)
+                    paymentPayload.tax_id = tax_id;
+                payment = void 0;
+                _g.label = 15;
+            case 15:
+                _g.trys.push([15, 17, , 18]);
+                return [4 /*yield*/, dodopayments.payments.create(paymentPayload)];
+            case 16:
+                payment = _g.sent();
+                return [3 /*break*/, 18];
+            case 17:
+                err_4 = _g.sent();
+                console.error("Error when creating payment link", err_4);
+                throw new Error(err_4 instanceof Error ? err_4.message : String(err_4));
+            case 18:
+                if (!payment || !payment.payment_link) {
+                    throw new Error("No payment link returned from Dodo Payments API. Make sure to set payment_link as true in payload.");
+                }
+                return [2 /*return*/, payment.payment_link];
+        }
+    });
+}); };
+
+const Checkout = (config) => {
+    const getHandler = async (c) => {
+        const queryParams = c.req.query();
+        if (!queryParams.productId) {
+            return c.text("Please provide productId query parameter", 400);
+        }
+        const { success, data, error } = checkoutQuerySchema.safeParse(queryParams);
+        if (!success) {
+            if (error.errors.some((e) => e.path.toString() === "productId")) {
+                return c.text("Please provide productId query parameter", 400);
+            }
+            return c.text(`Invalid query parameters.\n ${error.message}`, 400);
+        }
+        let url = "";
+        try {
+            url = await buildCheckoutUrl({ queryParams: data, ...config });
+        }
+        catch (error) {
+            return c.text(error.message, 400);
+        }
+        return c.redirect(url);
+    };
+    const postHandler = async (c) => {
+        let body;
+        try {
+            body = await c.req.json();
+        }
+        catch (e) {
+            return c.text("Invalid JSON body", 400);
+        }
+        const { success, data, error } = dynamicCheckoutBodySchema.safeParse(body);
+        if (!success) {
+            return c.text(`Invalid request body.\n ${error.message}`, 400);
+        }
+        let url = "";
+        try {
+            url = await buildCheckoutUrl({ body: data, ...config });
+        }
+        catch (error) {
+            return c.text(error.message, 400);
+        }
+        return c.redirect(url);
+    };
+    return (c) => {
+        if (c.req.method === "POST") {
+            return postHandler(c);
+        }
+        return getHandler(c);
+    };
+};
+
+const CustomerPortal = ({ bearerToken, environment, }) => {
+    const getHandler = async (c) => {
+        // Extract customerId from query parameters
+        const customerId = c.req.query("customer_id");
+        const sendEmail = c.req.query("send_email");
+        const params = {
+            send_email: false,
+        };
+        if (sendEmail === "true") {
+            params.send_email = true;
+        }
+        if (!customerId) {
+            return c.text("Missing customerId in query parameters", 400);
+        }
+        const dodopayments = new DodoPayments({
+            bearerToken,
+            environment,
+        });
+        try {
+            const session = await dodopayments.customers.customerPortal.create(customerId, params);
+            return c.redirect(session.link);
+        }
+        catch (error) {
+            console.error("Error creating customer portal session:", error);
+            return c.text(`Failed to create customer portal session: ${error.message}`, 500);
+        }
+    };
+    return getHandler;
+};
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+var dist = {};
+
+var timing_safe_equal = {};
+
+Object.defineProperty(timing_safe_equal, "__esModule", { value: true });
+timing_safe_equal.timingSafeEqual = void 0;
+function assert(expr, msg = "") {
+    if (!expr) {
+        throw new Error(msg);
+    }
+}
+function timingSafeEqual(a, b) {
+    if (a.byteLength !== b.byteLength) {
+        return false;
+    }
+    if (!(a instanceof DataView)) {
+        a = new DataView(ArrayBuffer.isView(a) ? a.buffer : a);
+    }
+    if (!(b instanceof DataView)) {
+        b = new DataView(ArrayBuffer.isView(b) ? b.buffer : b);
+    }
+    assert(a instanceof DataView);
+    assert(b instanceof DataView);
+    const length = a.byteLength;
+    let out = 0;
+    let i = -1;
+    while (++i < length) {
+        out |= a.getUint8(i) ^ b.getUint8(i);
+    }
+    return out === 0;
+}
+timing_safe_equal.timingSafeEqual = timingSafeEqual;
+
+var base64$1 = {};
+
+// Copyright (C) 2016 Dmitry Chestnykh
+// MIT License. See LICENSE file for details.
+var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(base64$1, "__esModule", { value: true });
+/**
+ * Package base64 implements Base64 encoding and decoding.
+ */
+// Invalid character used in decoding to indicate
+// that the character to decode is out of range of
+// alphabet and cannot be decoded.
+var INVALID_BYTE = 256;
+/**
+ * Implements standard Base64 encoding.
+ *
+ * Operates in constant time.
+ */
+var Coder = /** @class */ (function () {
+    // TODO(dchest): methods to encode chunk-by-chunk.
+    function Coder(_paddingCharacter) {
+        if (_paddingCharacter === void 0) { _paddingCharacter = "="; }
+        this._paddingCharacter = _paddingCharacter;
+    }
+    Coder.prototype.encodedLength = function (length) {
+        if (!this._paddingCharacter) {
+            return (length * 8 + 5) / 6 | 0;
+        }
+        return (length + 2) / 3 * 4 | 0;
+    };
+    Coder.prototype.encode = function (data) {
+        var out = "";
+        var i = 0;
+        for (; i < data.length - 2; i += 3) {
+            var c = (data[i] << 16) | (data[i + 1] << 8) | (data[i + 2]);
+            out += this._encodeByte((c >>> 3 * 6) & 63);
+            out += this._encodeByte((c >>> 2 * 6) & 63);
+            out += this._encodeByte((c >>> 1 * 6) & 63);
+            out += this._encodeByte((c >>> 0 * 6) & 63);
+        }
+        var left = data.length - i;
+        if (left > 0) {
+            var c = (data[i] << 16) | (left === 2 ? data[i + 1] << 8 : 0);
+            out += this._encodeByte((c >>> 3 * 6) & 63);
+            out += this._encodeByte((c >>> 2 * 6) & 63);
+            if (left === 2) {
+                out += this._encodeByte((c >>> 1 * 6) & 63);
+            }
+            else {
+                out += this._paddingCharacter || "";
+            }
+            out += this._paddingCharacter || "";
+        }
+        return out;
+    };
+    Coder.prototype.maxDecodedLength = function (length) {
+        if (!this._paddingCharacter) {
+            return (length * 6 + 7) / 8 | 0;
+        }
+        return length / 4 * 3 | 0;
+    };
+    Coder.prototype.decodedLength = function (s) {
+        return this.maxDecodedLength(s.length - this._getPaddingLength(s));
+    };
+    Coder.prototype.decode = function (s) {
+        if (s.length === 0) {
+            return new Uint8Array(0);
+        }
+        var paddingLength = this._getPaddingLength(s);
+        var length = s.length - paddingLength;
+        var out = new Uint8Array(this.maxDecodedLength(length));
+        var op = 0;
+        var i = 0;
+        var haveBad = 0;
+        var v0 = 0, v1 = 0, v2 = 0, v3 = 0;
+        for (; i < length - 4; i += 4) {
+            v0 = this._decodeChar(s.charCodeAt(i + 0));
+            v1 = this._decodeChar(s.charCodeAt(i + 1));
+            v2 = this._decodeChar(s.charCodeAt(i + 2));
+            v3 = this._decodeChar(s.charCodeAt(i + 3));
+            out[op++] = (v0 << 2) | (v1 >>> 4);
+            out[op++] = (v1 << 4) | (v2 >>> 2);
+            out[op++] = (v2 << 6) | v3;
+            haveBad |= v0 & INVALID_BYTE;
+            haveBad |= v1 & INVALID_BYTE;
+            haveBad |= v2 & INVALID_BYTE;
+            haveBad |= v3 & INVALID_BYTE;
+        }
+        if (i < length - 1) {
+            v0 = this._decodeChar(s.charCodeAt(i));
+            v1 = this._decodeChar(s.charCodeAt(i + 1));
+            out[op++] = (v0 << 2) | (v1 >>> 4);
+            haveBad |= v0 & INVALID_BYTE;
+            haveBad |= v1 & INVALID_BYTE;
+        }
+        if (i < length - 2) {
+            v2 = this._decodeChar(s.charCodeAt(i + 2));
+            out[op++] = (v1 << 4) | (v2 >>> 2);
+            haveBad |= v2 & INVALID_BYTE;
+        }
+        if (i < length - 3) {
+            v3 = this._decodeChar(s.charCodeAt(i + 3));
+            out[op++] = (v2 << 6) | v3;
+            haveBad |= v3 & INVALID_BYTE;
+        }
+        if (haveBad !== 0) {
+            throw new Error("Base64Coder: incorrect characters for decoding");
+        }
+        return out;
+    };
+    // Standard encoding have the following encoded/decoded ranges,
+    // which we need to convert between.
+    //
+    // ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 0123456789  +   /
+    // Index:   0 - 25                    26 - 51              52 - 61   62  63
+    // ASCII:  65 - 90                    97 - 122             48 - 57   43  47
+    //
+    // Encode 6 bits in b into a new character.
+    Coder.prototype._encodeByte = function (b) {
+        // Encoding uses constant time operations as follows:
+        //
+        // 1. Define comparison of A with B using (A - B) >>> 8:
+        //          if A > B, then result is positive integer
+        //          if A <= B, then result is 0
+        //
+        // 2. Define selection of C or 0 using bitwise AND: X & C:
+        //          if X == 0, then result is 0
+        //          if X != 0, then result is C
+        //
+        // 3. Start with the smallest comparison (b >= 0), which is always
+        //    true, so set the result to the starting ASCII value (65).
+        //
+        // 4. Continue comparing b to higher ASCII values, and selecting
+        //    zero if comparison isn't true, otherwise selecting a value
+        //    to add to result, which:
+        //
+        //          a) undoes the previous addition
+        //          b) provides new value to add
+        //
+        var result = b;
+        // b >= 0
+        result += 65;
+        // b > 25
+        result += ((25 - b) >>> 8) & ((0 - 65) - 26 + 97);
+        // b > 51
+        result += ((51 - b) >>> 8) & ((26 - 97) - 52 + 48);
+        // b > 61
+        result += ((61 - b) >>> 8) & ((52 - 48) - 62 + 43);
+        // b > 62
+        result += ((62 - b) >>> 8) & ((62 - 43) - 63 + 47);
+        return String.fromCharCode(result);
+    };
+    // Decode a character code into a byte.
+    // Must return 256 if character is out of alphabet range.
+    Coder.prototype._decodeChar = function (c) {
+        // Decoding works similar to encoding: using the same comparison
+        // function, but now it works on ranges: result is always incremented
+        // by value, but this value becomes zero if the range is not
+        // satisfied.
+        //
+        // Decoding starts with invalid value, 256, which is then
+        // subtracted when the range is satisfied. If none of the ranges
+        // apply, the function returns 256, which is then checked by
+        // the caller to throw error.
+        var result = INVALID_BYTE; // start with invalid character
+        // c == 43 (c > 42 and c < 44)
+        result += (((42 - c) & (c - 44)) >>> 8) & (-INVALID_BYTE + c - 43 + 62);
+        // c == 47 (c > 46 and c < 48)
+        result += (((46 - c) & (c - 48)) >>> 8) & (-INVALID_BYTE + c - 47 + 63);
+        // c > 47 and c < 58
+        result += (((47 - c) & (c - 58)) >>> 8) & (-INVALID_BYTE + c - 48 + 52);
+        // c > 64 and c < 91
+        result += (((64 - c) & (c - 91)) >>> 8) & (-INVALID_BYTE + c - 65 + 0);
+        // c > 96 and c < 123
+        result += (((96 - c) & (c - 123)) >>> 8) & (-INVALID_BYTE + c - 97 + 26);
+        return result;
+    };
+    Coder.prototype._getPaddingLength = function (s) {
+        var paddingLength = 0;
+        if (this._paddingCharacter) {
+            for (var i = s.length - 1; i >= 0; i--) {
+                if (s[i] !== this._paddingCharacter) {
+                    break;
+                }
+                paddingLength++;
+            }
+            if (s.length < 4 || paddingLength > 2) {
+                throw new Error("Base64Coder: incorrect padding");
+            }
+        }
+        return paddingLength;
+    };
+    return Coder;
+}());
+base64$1.Coder = Coder;
+var stdCoder = new Coder();
+function encode(data) {
+    return stdCoder.encode(data);
+}
+base64$1.encode = encode;
+function decode(s) {
+    return stdCoder.decode(s);
+}
+base64$1.decode = decode;
+/**
+ * Implements URL-safe Base64 encoding.
+ * (Same as Base64, but '+' is replaced with '-', and '/' with '_').
+ *
+ * Operates in constant time.
+ */
+var URLSafeCoder = /** @class */ (function (_super) {
+    __extends(URLSafeCoder, _super);
+    function URLSafeCoder() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    // URL-safe encoding have the following encoded/decoded ranges:
+    //
+    // ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 0123456789  -   _
+    // Index:   0 - 25                    26 - 51              52 - 61   62  63
+    // ASCII:  65 - 90                    97 - 122             48 - 57   45  95
+    //
+    URLSafeCoder.prototype._encodeByte = function (b) {
+        var result = b;
+        // b >= 0
+        result += 65;
+        // b > 25
+        result += ((25 - b) >>> 8) & ((0 - 65) - 26 + 97);
+        // b > 51
+        result += ((51 - b) >>> 8) & ((26 - 97) - 52 + 48);
+        // b > 61
+        result += ((61 - b) >>> 8) & ((52 - 48) - 62 + 45);
+        // b > 62
+        result += ((62 - b) >>> 8) & ((62 - 45) - 63 + 95);
+        return String.fromCharCode(result);
+    };
+    URLSafeCoder.prototype._decodeChar = function (c) {
+        var result = INVALID_BYTE;
+        // c == 45 (c > 44 and c < 46)
+        result += (((44 - c) & (c - 46)) >>> 8) & (-INVALID_BYTE + c - 45 + 62);
+        // c == 95 (c > 94 and c < 96)
+        result += (((94 - c) & (c - 96)) >>> 8) & (-INVALID_BYTE + c - 95 + 63);
+        // c > 47 and c < 58
+        result += (((47 - c) & (c - 58)) >>> 8) & (-INVALID_BYTE + c - 48 + 52);
+        // c > 64 and c < 91
+        result += (((64 - c) & (c - 91)) >>> 8) & (-INVALID_BYTE + c - 65 + 0);
+        // c > 96 and c < 123
+        result += (((96 - c) & (c - 123)) >>> 8) & (-INVALID_BYTE + c - 97 + 26);
+        return result;
+    };
+    return URLSafeCoder;
+}(Coder));
+base64$1.URLSafeCoder = URLSafeCoder;
+var urlSafeCoder = new URLSafeCoder();
+function encodeURLSafe(data) {
+    return urlSafeCoder.encode(data);
+}
+base64$1.encodeURLSafe = encodeURLSafe;
+function decodeURLSafe(s) {
+    return urlSafeCoder.decode(s);
+}
+base64$1.decodeURLSafe = decodeURLSafe;
+base64$1.encodedLength = function (length) {
+    return stdCoder.encodedLength(length);
+};
+base64$1.maxDecodedLength = function (length) {
+    return stdCoder.maxDecodedLength(length);
+};
+base64$1.decodedLength = function (s) {
+    return stdCoder.decodedLength(s);
+};
+
+var sha256$1 = {exports: {}};
+
+(function (module) {
+	(function (root, factory) {
+	    // Hack to make all exports of this module sha256 function object properties.
+	    var exports = {};
+	    factory(exports);
+	    var sha256 = exports["default"];
+	    for (var k in exports) {
+	        sha256[k] = exports[k];
+	    }
+	        
+	    {
+	        module.exports = sha256;
+	    }
+	})(commonjsGlobal, function(exports) {
+	exports.__esModule = true;
+	// SHA-256 (+ HMAC and PBKDF2) for JavaScript.
+	//
+	// Written in 2014-2016 by Dmitry Chestnykh.
+	// Public domain, no warranty.
+	//
+	// Functions (accept and return Uint8Arrays):
+	//
+	//   sha256(message) -> hash
+	//   sha256.hmac(key, message) -> mac
+	//   sha256.pbkdf2(password, salt, rounds, dkLen) -> dk
+	//
+	//  Classes:
+	//
+	//   new sha256.Hash()
+	//   new sha256.HMAC(key)
+	//
+	exports.digestLength = 32;
+	exports.blockSize = 64;
+	// SHA-256 constants
+	var K = new Uint32Array([
+	    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b,
+	    0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01,
+	    0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7,
+	    0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
+	    0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152,
+	    0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,
+	    0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc,
+	    0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+	    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819,
+	    0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08,
+	    0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f,
+	    0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+	    0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+	]);
+	function hashBlocks(w, v, p, pos, len) {
+	    var a, b, c, d, e, f, g, h, u, i, j, t1, t2;
+	    while (len >= 64) {
+	        a = v[0];
+	        b = v[1];
+	        c = v[2];
+	        d = v[3];
+	        e = v[4];
+	        f = v[5];
+	        g = v[6];
+	        h = v[7];
+	        for (i = 0; i < 16; i++) {
+	            j = pos + i * 4;
+	            w[i] = (((p[j] & 0xff) << 24) | ((p[j + 1] & 0xff) << 16) |
+	                ((p[j + 2] & 0xff) << 8) | (p[j + 3] & 0xff));
+	        }
+	        for (i = 16; i < 64; i++) {
+	            u = w[i - 2];
+	            t1 = (u >>> 17 | u << (32 - 17)) ^ (u >>> 19 | u << (32 - 19)) ^ (u >>> 10);
+	            u = w[i - 15];
+	            t2 = (u >>> 7 | u << (32 - 7)) ^ (u >>> 18 | u << (32 - 18)) ^ (u >>> 3);
+	            w[i] = (t1 + w[i - 7] | 0) + (t2 + w[i - 16] | 0);
+	        }
+	        for (i = 0; i < 64; i++) {
+	            t1 = (((((e >>> 6 | e << (32 - 6)) ^ (e >>> 11 | e << (32 - 11)) ^
+	                (e >>> 25 | e << (32 - 25))) + ((e & f) ^ (~e & g))) | 0) +
+	                ((h + ((K[i] + w[i]) | 0)) | 0)) | 0;
+	            t2 = (((a >>> 2 | a << (32 - 2)) ^ (a >>> 13 | a << (32 - 13)) ^
+	                (a >>> 22 | a << (32 - 22))) + ((a & b) ^ (a & c) ^ (b & c))) | 0;
+	            h = g;
+	            g = f;
+	            f = e;
+	            e = (d + t1) | 0;
+	            d = c;
+	            c = b;
+	            b = a;
+	            a = (t1 + t2) | 0;
+	        }
+	        v[0] += a;
+	        v[1] += b;
+	        v[2] += c;
+	        v[3] += d;
+	        v[4] += e;
+	        v[5] += f;
+	        v[6] += g;
+	        v[7] += h;
+	        pos += 64;
+	        len -= 64;
+	    }
+	    return pos;
+	}
+	// Hash implements SHA256 hash algorithm.
+	var Hash = /** @class */ (function () {
+	    function Hash() {
+	        this.digestLength = exports.digestLength;
+	        this.blockSize = exports.blockSize;
+	        // Note: Int32Array is used instead of Uint32Array for performance reasons.
+	        this.state = new Int32Array(8); // hash state
+	        this.temp = new Int32Array(64); // temporary state
+	        this.buffer = new Uint8Array(128); // buffer for data to hash
+	        this.bufferLength = 0; // number of bytes in buffer
+	        this.bytesHashed = 0; // number of total bytes hashed
+	        this.finished = false; // indicates whether the hash was finalized
+	        this.reset();
+	    }
+	    // Resets hash state making it possible
+	    // to re-use this instance to hash other data.
+	    Hash.prototype.reset = function () {
+	        this.state[0] = 0x6a09e667;
+	        this.state[1] = 0xbb67ae85;
+	        this.state[2] = 0x3c6ef372;
+	        this.state[3] = 0xa54ff53a;
+	        this.state[4] = 0x510e527f;
+	        this.state[5] = 0x9b05688c;
+	        this.state[6] = 0x1f83d9ab;
+	        this.state[7] = 0x5be0cd19;
+	        this.bufferLength = 0;
+	        this.bytesHashed = 0;
+	        this.finished = false;
+	        return this;
+	    };
+	    // Cleans internal buffers and re-initializes hash state.
+	    Hash.prototype.clean = function () {
+	        for (var i = 0; i < this.buffer.length; i++) {
+	            this.buffer[i] = 0;
+	        }
+	        for (var i = 0; i < this.temp.length; i++) {
+	            this.temp[i] = 0;
+	        }
+	        this.reset();
+	    };
+	    // Updates hash state with the given data.
+	    //
+	    // Optionally, length of the data can be specified to hash
+	    // fewer bytes than data.length.
+	    //
+	    // Throws error when trying to update already finalized hash:
+	    // instance must be reset to use it again.
+	    Hash.prototype.update = function (data, dataLength) {
+	        if (dataLength === void 0) { dataLength = data.length; }
+	        if (this.finished) {
+	            throw new Error("SHA256: can't update because hash was finished.");
+	        }
+	        var dataPos = 0;
+	        this.bytesHashed += dataLength;
+	        if (this.bufferLength > 0) {
+	            while (this.bufferLength < 64 && dataLength > 0) {
+	                this.buffer[this.bufferLength++] = data[dataPos++];
+	                dataLength--;
+	            }
+	            if (this.bufferLength === 64) {
+	                hashBlocks(this.temp, this.state, this.buffer, 0, 64);
+	                this.bufferLength = 0;
+	            }
+	        }
+	        if (dataLength >= 64) {
+	            dataPos = hashBlocks(this.temp, this.state, data, dataPos, dataLength);
+	            dataLength %= 64;
+	        }
+	        while (dataLength > 0) {
+	            this.buffer[this.bufferLength++] = data[dataPos++];
+	            dataLength--;
+	        }
+	        return this;
+	    };
+	    // Finalizes hash state and puts hash into out.
+	    //
+	    // If hash was already finalized, puts the same value.
+	    Hash.prototype.finish = function (out) {
+	        if (!this.finished) {
+	            var bytesHashed = this.bytesHashed;
+	            var left = this.bufferLength;
+	            var bitLenHi = (bytesHashed / 0x20000000) | 0;
+	            var bitLenLo = bytesHashed << 3;
+	            var padLength = (bytesHashed % 64 < 56) ? 64 : 128;
+	            this.buffer[left] = 0x80;
+	            for (var i = left + 1; i < padLength - 8; i++) {
+	                this.buffer[i] = 0;
+	            }
+	            this.buffer[padLength - 8] = (bitLenHi >>> 24) & 0xff;
+	            this.buffer[padLength - 7] = (bitLenHi >>> 16) & 0xff;
+	            this.buffer[padLength - 6] = (bitLenHi >>> 8) & 0xff;
+	            this.buffer[padLength - 5] = (bitLenHi >>> 0) & 0xff;
+	            this.buffer[padLength - 4] = (bitLenLo >>> 24) & 0xff;
+	            this.buffer[padLength - 3] = (bitLenLo >>> 16) & 0xff;
+	            this.buffer[padLength - 2] = (bitLenLo >>> 8) & 0xff;
+	            this.buffer[padLength - 1] = (bitLenLo >>> 0) & 0xff;
+	            hashBlocks(this.temp, this.state, this.buffer, 0, padLength);
+	            this.finished = true;
+	        }
+	        for (var i = 0; i < 8; i++) {
+	            out[i * 4 + 0] = (this.state[i] >>> 24) & 0xff;
+	            out[i * 4 + 1] = (this.state[i] >>> 16) & 0xff;
+	            out[i * 4 + 2] = (this.state[i] >>> 8) & 0xff;
+	            out[i * 4 + 3] = (this.state[i] >>> 0) & 0xff;
+	        }
+	        return this;
+	    };
+	    // Returns the final hash digest.
+	    Hash.prototype.digest = function () {
+	        var out = new Uint8Array(this.digestLength);
+	        this.finish(out);
+	        return out;
+	    };
+	    // Internal function for use in HMAC for optimization.
+	    Hash.prototype._saveState = function (out) {
+	        for (var i = 0; i < this.state.length; i++) {
+	            out[i] = this.state[i];
+	        }
+	    };
+	    // Internal function for use in HMAC for optimization.
+	    Hash.prototype._restoreState = function (from, bytesHashed) {
+	        for (var i = 0; i < this.state.length; i++) {
+	            this.state[i] = from[i];
+	        }
+	        this.bytesHashed = bytesHashed;
+	        this.finished = false;
+	        this.bufferLength = 0;
+	    };
+	    return Hash;
+	}());
+	exports.Hash = Hash;
+	// HMAC implements HMAC-SHA256 message authentication algorithm.
+	var HMAC = /** @class */ (function () {
+	    function HMAC(key) {
+	        this.inner = new Hash();
+	        this.outer = new Hash();
+	        this.blockSize = this.inner.blockSize;
+	        this.digestLength = this.inner.digestLength;
+	        var pad = new Uint8Array(this.blockSize);
+	        if (key.length > this.blockSize) {
+	            (new Hash()).update(key).finish(pad).clean();
+	        }
+	        else {
+	            for (var i = 0; i < key.length; i++) {
+	                pad[i] = key[i];
+	            }
+	        }
+	        for (var i = 0; i < pad.length; i++) {
+	            pad[i] ^= 0x36;
+	        }
+	        this.inner.update(pad);
+	        for (var i = 0; i < pad.length; i++) {
+	            pad[i] ^= 0x36 ^ 0x5c;
+	        }
+	        this.outer.update(pad);
+	        this.istate = new Uint32Array(8);
+	        this.ostate = new Uint32Array(8);
+	        this.inner._saveState(this.istate);
+	        this.outer._saveState(this.ostate);
+	        for (var i = 0; i < pad.length; i++) {
+	            pad[i] = 0;
+	        }
+	    }
+	    // Returns HMAC state to the state initialized with key
+	    // to make it possible to run HMAC over the other data with the same
+	    // key without creating a new instance.
+	    HMAC.prototype.reset = function () {
+	        this.inner._restoreState(this.istate, this.inner.blockSize);
+	        this.outer._restoreState(this.ostate, this.outer.blockSize);
+	        return this;
+	    };
+	    // Cleans HMAC state.
+	    HMAC.prototype.clean = function () {
+	        for (var i = 0; i < this.istate.length; i++) {
+	            this.ostate[i] = this.istate[i] = 0;
+	        }
+	        this.inner.clean();
+	        this.outer.clean();
+	    };
+	    // Updates state with provided data.
+	    HMAC.prototype.update = function (data) {
+	        this.inner.update(data);
+	        return this;
+	    };
+	    // Finalizes HMAC and puts the result in out.
+	    HMAC.prototype.finish = function (out) {
+	        if (this.outer.finished) {
+	            this.outer.finish(out);
+	        }
+	        else {
+	            this.inner.finish(out);
+	            this.outer.update(out, this.digestLength).finish(out);
+	        }
+	        return this;
+	    };
+	    // Returns message authentication code.
+	    HMAC.prototype.digest = function () {
+	        var out = new Uint8Array(this.digestLength);
+	        this.finish(out);
+	        return out;
+	    };
+	    return HMAC;
+	}());
+	exports.HMAC = HMAC;
+	// Returns SHA256 hash of data.
+	function hash(data) {
+	    var h = (new Hash()).update(data);
+	    var digest = h.digest();
+	    h.clean();
+	    return digest;
+	}
+	exports.hash = hash;
+	// Function hash is both available as module.hash and as default export.
+	exports["default"] = hash;
+	// Returns HMAC-SHA256 of data under the key.
+	function hmac(key, data) {
+	    var h = (new HMAC(key)).update(data);
+	    var digest = h.digest();
+	    h.clean();
+	    return digest;
+	}
+	exports.hmac = hmac;
+	// Fills hkdf buffer like this:
+	// T(1) = HMAC-Hash(PRK, T(0) | info | 0x01)
+	function fillBuffer(buffer, hmac, info, counter) {
+	    // Counter is a byte value: check if it overflowed.
+	    var num = counter[0];
+	    if (num === 0) {
+	        throw new Error("hkdf: cannot expand more");
+	    }
+	    // Prepare HMAC instance for new data with old key.
+	    hmac.reset();
+	    // Hash in previous output if it was generated
+	    // (i.e. counter is greater than 1).
+	    if (num > 1) {
+	        hmac.update(buffer);
+	    }
+	    // Hash in info if it exists.
+	    if (info) {
+	        hmac.update(info);
+	    }
+	    // Hash in the counter.
+	    hmac.update(counter);
+	    // Output result to buffer and clean HMAC instance.
+	    hmac.finish(buffer);
+	    // Increment counter inside typed array, this works properly.
+	    counter[0]++;
+	}
+	var hkdfSalt = new Uint8Array(exports.digestLength); // Filled with zeroes.
+	function hkdf(key, salt, info, length) {
+	    if (salt === void 0) { salt = hkdfSalt; }
+	    if (length === void 0) { length = 32; }
+	    var counter = new Uint8Array([1]);
+	    // HKDF-Extract uses salt as HMAC key, and key as data.
+	    var okm = hmac(salt, key);
+	    // Initialize HMAC for expanding with extracted key.
+	    // Ensure no collisions with `hmac` function.
+	    var hmac_ = new HMAC(okm);
+	    // Allocate buffer.
+	    var buffer = new Uint8Array(hmac_.digestLength);
+	    var bufpos = buffer.length;
+	    var out = new Uint8Array(length);
+	    for (var i = 0; i < length; i++) {
+	        if (bufpos === buffer.length) {
+	            fillBuffer(buffer, hmac_, info, counter);
+	            bufpos = 0;
+	        }
+	        out[i] = buffer[bufpos++];
+	    }
+	    hmac_.clean();
+	    buffer.fill(0);
+	    counter.fill(0);
+	    return out;
+	}
+	exports.hkdf = hkdf;
+	// Derives a key from password and salt using PBKDF2-HMAC-SHA256
+	// with the given number of iterations.
+	//
+	// The number of bytes returned is equal to dkLen.
+	//
+	// (For better security, avoid dkLen greater than hash length - 32 bytes).
+	function pbkdf2(password, salt, iterations, dkLen) {
+	    var prf = new HMAC(password);
+	    var len = prf.digestLength;
+	    var ctr = new Uint8Array(4);
+	    var t = new Uint8Array(len);
+	    var u = new Uint8Array(len);
+	    var dk = new Uint8Array(dkLen);
+	    for (var i = 0; i * len < dkLen; i++) {
+	        var c = i + 1;
+	        ctr[0] = (c >>> 24) & 0xff;
+	        ctr[1] = (c >>> 16) & 0xff;
+	        ctr[2] = (c >>> 8) & 0xff;
+	        ctr[3] = (c >>> 0) & 0xff;
+	        prf.reset();
+	        prf.update(salt);
+	        prf.update(ctr);
+	        prf.finish(u);
+	        for (var j = 0; j < len; j++) {
+	            t[j] = u[j];
+	        }
+	        for (var j = 2; j <= iterations; j++) {
+	            prf.reset();
+	            prf.update(u).finish(u);
+	            for (var k = 0; k < len; k++) {
+	                t[k] ^= u[k];
+	            }
+	        }
+	        for (var j = 0; j < len && i * len + j < dkLen; j++) {
+	            dk[i * len + j] = t[j];
+	        }
+	    }
+	    for (var i = 0; i < len; i++) {
+	        t[i] = u[i] = 0;
+	    }
+	    for (var i = 0; i < 4; i++) {
+	        ctr[i] = 0;
+	    }
+	    prf.clean();
+	    return dk;
+	}
+	exports.pbkdf2 = pbkdf2;
+	}); 
+} (sha256$1));
+
+var sha256Exports = sha256$1.exports;
+
+Object.defineProperty(dist, "__esModule", { value: true });
+var Webhook_1 = dist.Webhook = WebhookVerificationError_1 = dist.WebhookVerificationError = void 0;
+const timing_safe_equal_1 = timing_safe_equal;
+const base64 = base64$1;
+const sha256 = sha256Exports;
+const WEBHOOK_TOLERANCE_IN_SECONDS = 5 * 60;
+class ExtendableError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, ExtendableError.prototype);
+        this.name = "ExtendableError";
+        this.stack = new Error(message).stack;
+    }
+}
+class WebhookVerificationError extends ExtendableError {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, WebhookVerificationError.prototype);
+        this.name = "WebhookVerificationError";
+    }
+}
+var WebhookVerificationError_1 = dist.WebhookVerificationError = WebhookVerificationError;
+class Webhook {
+    constructor(secret, options) {
+        if (!secret) {
+            throw new Error("Secret can't be empty.");
+        }
+        if ((options === null || options === void 0 ? void 0 : options.format) === "raw") {
+            if (secret instanceof Uint8Array) {
+                this.key = secret;
+            }
+            else {
+                this.key = Uint8Array.from(secret, (c) => c.charCodeAt(0));
+            }
+        }
+        else {
+            if (typeof secret !== "string") {
+                throw new Error("Expected secret to be of type string");
+            }
+            if (secret.startsWith(Webhook.prefix)) {
+                secret = secret.substring(Webhook.prefix.length);
+            }
+            this.key = base64.decode(secret);
+        }
+    }
+    verify(payload, headers_) {
+        const headers = {};
+        for (const key of Object.keys(headers_)) {
+            headers[key.toLowerCase()] = headers_[key];
+        }
+        const msgId = headers["webhook-id"];
+        const msgSignature = headers["webhook-signature"];
+        const msgTimestamp = headers["webhook-timestamp"];
+        if (!msgSignature || !msgId || !msgTimestamp) {
+            throw new WebhookVerificationError("Missing required headers");
+        }
+        const timestamp = this.verifyTimestamp(msgTimestamp);
+        const computedSignature = this.sign(msgId, timestamp, payload);
+        const expectedSignature = computedSignature.split(",")[1];
+        const passedSignatures = msgSignature.split(" ");
+        const encoder = new globalThis.TextEncoder();
+        for (const versionedSignature of passedSignatures) {
+            const [version, signature] = versionedSignature.split(",");
+            if (version !== "v1") {
+                continue;
+            }
+            if ((0, timing_safe_equal_1.timingSafeEqual)(encoder.encode(signature), encoder.encode(expectedSignature))) {
+                return JSON.parse(payload.toString());
+            }
+        }
+        throw new WebhookVerificationError("No matching signature found");
+    }
+    sign(msgId, timestamp, payload) {
+        if (typeof payload === "string") ;
+        else if (payload.constructor.name === "Buffer") {
+            payload = payload.toString();
+        }
+        else {
+            throw new Error("Expected payload to be of type string or Buffer.");
+        }
+        const encoder = new TextEncoder();
+        const timestampNumber = Math.floor(timestamp.getTime() / 1000);
+        const toSign = encoder.encode(`${msgId}.${timestampNumber}.${payload}`);
+        const expectedSignature = base64.encode(sha256.hmac(this.key, toSign));
+        return `v1,${expectedSignature}`;
+    }
+    verifyTimestamp(timestampHeader) {
+        const now = Math.floor(Date.now() / 1000);
+        const timestamp = parseInt(timestampHeader, 10);
+        if (isNaN(timestamp)) {
+            throw new WebhookVerificationError("Invalid Signature Headers");
+        }
+        if (now - timestamp > WEBHOOK_TOLERANCE_IN_SECONDS) {
+            throw new WebhookVerificationError("Message timestamp too old");
+        }
+        if (timestamp > now + WEBHOOK_TOLERANCE_IN_SECONDS) {
+            throw new WebhookVerificationError("Message timestamp too new");
+        }
+        return new Date(timestamp * 1000);
+    }
+}
+Webhook_1 = dist.Webhook = Webhook;
+Webhook.prefix = "whsec_";
+
+var PaymentSchema = zod.z.object({
+    payload_type: zod.z.literal("Payment"),
+    billing: zod.z.object({
+        city: zod.z.string().nullable(),
+        country: zod.z.string().nullable(),
+        state: zod.z.string().nullable(),
+        street: zod.z.string().nullable(),
+        zipcode: zod.z.string().nullable(),
+    }),
+    brand_id: zod.z.string(),
+    business_id: zod.z.string(),
+    card_issuing_country: zod.z.string().nullable(),
+    card_last_four: zod.z.string().nullable(),
+    card_network: zod.z.string().nullable(),
+    card_type: zod.z.string().nullable(),
+    created_at: zod.z.string().transform(function (d) { return new Date(d); }),
+    currency: zod.z.string(),
+    customer: zod.z.object({
+        customer_id: zod.z.string(),
+        email: zod.z.string(),
+        name: zod.z.string().nullable(),
+    }),
+    digital_products_delivered: zod.z.boolean(),
+    discount_id: zod.z.string().nullable(),
+    disputes: zod.z
+        .array(zod.z.object({
+        amount: zod.z.string(),
+        business_id: zod.z.string(),
+        created_at: zod.z.string().transform(function (d) { return new Date(d); }),
+        currency: zod.z.string(),
+        dispute_id: zod.z.string(),
+        dispute_stage: zod.z.enum([
+            "pre_dispute",
+            "dispute_opened",
+            "dispute_won",
+            "dispute_lost",
+        ]),
+        dispute_status: zod.z.enum([
+            "dispute_opened",
+            "dispute_won",
+            "dispute_lost",
+            "dispute_accepted",
+            "dispute_cancelled",
+            "dispute_challenged",
+        ]),
+        payment_id: zod.z.string(),
+        remarks: zod.z.string().nullable(),
+    }))
+        .nullable(),
+    error_code: zod.z.string().nullable(),
+    error_message: zod.z.string().nullable(),
+    metadata: zod.z.record(zod.z.any()).nullable(),
+    payment_id: zod.z.string(),
+    payment_link: zod.z.string().nullable(),
+    payment_method: zod.z.string().nullable(),
+    payment_method_type: zod.z.string().nullable(),
+    product_cart: zod.z
+        .array(zod.z.object({
+        product_id: zod.z.string(),
+        quantity: zod.z.number(),
+    }))
+        .nullable(),
+    refunds: zod.z
+        .array(zod.z.object({
+        amount: zod.z.number(),
+        business_id: zod.z.string(),
+        created_at: zod.z.string().transform(function (d) { return new Date(d); }),
+        currency: zod.z.string(),
+        is_partial: zod.z.boolean(),
+        payment_id: zod.z.string(),
+        reason: zod.z.string().nullable(),
+        refund_id: zod.z.string(),
+        status: zod.z.enum(["succeeded", "failed", "pending"]),
+    }))
+        .nullable(),
+    settlement_amount: zod.z.number(),
+    settlement_currency: zod.z.string(),
+    settlement_tax: zod.z.number().nullable(),
+    status: zod.z.enum(["succeeded", "failed", "pending", "processing", "cancelled"]),
+    subscription_id: zod.z.string().nullable(),
+    tax: zod.z.number().nullable(),
+    total_amount: zod.z.number(),
+    updated_at: zod.z
+        .string()
+        .transform(function (d) { return new Date(d); })
+        .nullable(),
+});
+var SubscriptionSchema = zod.z.object({
+    payload_type: zod.z.literal("Subscription"),
+    addons: zod.z
+        .array(zod.z.object({
+        addon_id: zod.z.string(),
+        quantity: zod.z.number(),
+    }))
+        .nullable(),
+    billing: zod.z.object({
+        city: zod.z.string().nullable(),
+        country: zod.z.string().nullable(),
+        state: zod.z.string().nullable(),
+        street: zod.z.string().nullable(),
+        zipcode: zod.z.string().nullable(),
+    }),
+    cancel_at_next_billing_date: zod.z.boolean(),
+    cancelled_at: zod.z
+        .string()
+        .transform(function (d) { return new Date(d); })
+        .nullable(),
+    created_at: zod.z.string().transform(function (d) { return new Date(d); }),
+    currency: zod.z.string(),
+    customer: zod.z.object({
+        customer_id: zod.z.string(),
+        email: zod.z.string(),
+        name: zod.z.string().nullable(),
+    }),
+    discount_id: zod.z.string().nullable(),
+    metadata: zod.z.record(zod.z.any()).nullable(),
+    next_billing_date: zod.z
+        .string()
+        .transform(function (d) { return new Date(d); })
+        .nullable(),
+    on_demand: zod.z.boolean(),
+    payment_frequency_count: zod.z.number(),
+    payment_frequency_interval: zod.z.enum(["Day", "Week", "Month", "Year"]),
+    previous_billing_date: zod.z
+        .string()
+        .transform(function (d) { return new Date(d); })
+        .nullable(),
+    product_id: zod.z.string(),
+    quantity: zod.z.number(),
+    recurring_pre_tax_amount: zod.z.number(),
+    status: zod.z.enum([
+        "pending",
+        "active",
+        "on_hold",
+        "paused",
+        "cancelled",
+        "expired",
+        "failed",
+    ]),
+    subscription_id: zod.z.string(),
+    subscription_period_count: zod.z.number(),
+    subscription_period_interval: zod.z.enum(["Day", "Week", "Month", "Year"]),
+    tax_inclusive: zod.z.boolean(),
+    trial_period_days: zod.z.number(),
+});
+var RefundSchema = zod.z.object({
+    payload_type: zod.z.literal("Refund"),
+    amount: zod.z.number(),
+    business_id: zod.z.string(),
+    created_at: zod.z.string().transform(function (d) { return new Date(d); }),
+    currency: zod.z.string(),
+    is_partial: zod.z.boolean(),
+    payment_id: zod.z.string(),
+    reason: zod.z.string().nullable(),
+    refund_id: zod.z.string(),
+    status: zod.z.enum(["succeeded", "failed", "pending"]),
+});
+var DisputeSchema = zod.z.object({
+    payload_type: zod.z.literal("Dispute"),
+    amount: zod.z.string(),
+    business_id: zod.z.string(),
+    created_at: zod.z.string().transform(function (d) { return new Date(d); }),
+    currency: zod.z.string(),
+    dispute_id: zod.z.string(),
+    dispute_stage: zod.z.enum([
+        "pre_dispute",
+        "dispute_opened",
+        "dispute_won",
+        "dispute_lost",
+    ]),
+    dispute_status: zod.z.enum([
+        "dispute_opened",
+        "dispute_won",
+        "dispute_lost",
+        "dispute_accepted",
+        "dispute_cancelled",
+        "dispute_challenged",
+    ]),
+    payment_id: zod.z.string(),
+    remarks: zod.z.string().nullable(),
+});
+var LicenseKeySchema = zod.z.object({
+    payload_type: zod.z.literal("LicenseKey"),
+    activations_limit: zod.z.number(),
+    business_id: zod.z.string(),
+    created_at: zod.z.string().transform(function (d) { return new Date(d); }),
+    customer_id: zod.z.string(),
+    expires_at: zod.z
+        .string()
+        .transform(function (d) { return new Date(d); })
+        .nullable(),
+    id: zod.z.string(),
+    instances_count: zod.z.number(),
+    key: zod.z.string(),
+    payment_id: zod.z.string(),
+    product_id: zod.z.string(),
+    status: zod.z.enum(["active", "inactive", "expired"]),
+    subscription_id: zod.z.string().nullable(),
+});
+var PaymentSucceededPayloadSchema = zod.z.object({
+    business_id: zod.z.string(),
+    type: zod.z.literal("payment.succeeded"),
+    timestamp: zod.z.string().transform(function (d) { return new Date(d); }),
+    data: PaymentSchema,
+});
+var PaymentFailedPayloadSchema = zod.z.object({
+    business_id: zod.z.string(),
+    type: zod.z.literal("payment.failed"),
+    timestamp: zod.z.string().transform(function (d) { return new Date(d); }),
+    data: PaymentSchema,
+});
+var PaymentProcessingPayloadSchema = zod.z.object({
+    business_id: zod.z.string(),
+    type: zod.z.literal("payment.processing"),
+    timestamp: zod.z.string().transform(function (d) { return new Date(d); }),
+    data: PaymentSchema,
+});
+var PaymentCancelledPayloadSchema = zod.z.object({
+    business_id: zod.z.string(),
+    type: zod.z.literal("payment.cancelled"),
+    timestamp: zod.z.string().transform(function (d) { return new Date(d); }),
+    data: PaymentSchema,
+});
+var RefundSucceededPayloadSchema = zod.z.object({
+    business_id: zod.z.string(),
+    type: zod.z.literal("refund.succeeded"),
+    timestamp: zod.z.string().transform(function (d) { return new Date(d); }),
+    data: RefundSchema,
+});
+var RefundFailedPayloadSchema = zod.z.object({
+    business_id: zod.z.string(),
+    type: zod.z.literal("refund.failed"),
+    timestamp: zod.z.string().transform(function (d) { return new Date(d); }),
+    data: RefundSchema,
+});
+var DisputeOpenedPayloadSchema = zod.z.object({
+    business_id: zod.z.string(),
+    type: zod.z.literal("dispute.opened"),
+    timestamp: zod.z.string().transform(function (d) { return new Date(d); }),
+    data: DisputeSchema,
+});
+var DisputeExpiredPayloadSchema = zod.z.object({
+    business_id: zod.z.string(),
+    type: zod.z.literal("dispute.expired"),
+    timestamp: zod.z.string().transform(function (d) { return new Date(d); }),
+    data: DisputeSchema,
+});
+var DisputeAcceptedPayloadSchema = zod.z.object({
+    business_id: zod.z.string(),
+    type: zod.z.literal("dispute.accepted"),
+    timestamp: zod.z.string().transform(function (d) { return new Date(d); }),
+    data: DisputeSchema,
+});
+var DisputeCancelledPayloadSchema = zod.z.object({
+    business_id: zod.z.string(),
+    type: zod.z.literal("dispute.cancelled"),
+    timestamp: zod.z.string().transform(function (d) { return new Date(d); }),
+    data: DisputeSchema,
+});
+var DisputeChallengedPayloadSchema = zod.z.object({
+    business_id: zod.z.string(),
+    type: zod.z.literal("dispute.challenged"),
+    timestamp: zod.z.string().transform(function (d) { return new Date(d); }),
+    data: DisputeSchema,
+});
+var DisputeWonPayloadSchema = zod.z.object({
+    business_id: zod.z.string(),
+    type: zod.z.literal("dispute.won"),
+    timestamp: zod.z.string().transform(function (d) { return new Date(d); }),
+    data: DisputeSchema,
+});
+var DisputeLostPayloadSchema = zod.z.object({
+    business_id: zod.z.string(),
+    type: zod.z.literal("dispute.lost"),
+    timestamp: zod.z.string().transform(function (d) { return new Date(d); }),
+    data: DisputeSchema,
+});
+var SubscriptionActivePayloadSchema = zod.z.object({
+    business_id: zod.z.string(),
+    type: zod.z.literal("subscription.active"),
+    timestamp: zod.z.string().transform(function (d) { return new Date(d); }),
+    data: SubscriptionSchema,
+});
+var SubscriptionOnHoldPayloadSchema = zod.z.object({
+    business_id: zod.z.string(),
+    type: zod.z.literal("subscription.on_hold"),
+    timestamp: zod.z.string().transform(function (d) { return new Date(d); }),
+    data: SubscriptionSchema,
+});
+var SubscriptionRenewedPayloadSchema = zod.z.object({
+    business_id: zod.z.string(),
+    type: zod.z.literal("subscription.renewed"),
+    timestamp: zod.z.string().transform(function (d) { return new Date(d); }),
+    data: SubscriptionSchema,
+});
+var SubscriptionPausedPayloadSchema = zod.z.object({
+    business_id: zod.z.string(),
+    type: zod.z.literal("subscription.paused"),
+    timestamp: zod.z.string().transform(function (d) { return new Date(d); }),
+    data: SubscriptionSchema,
+});
+var SubscriptionPlanChangedPayloadSchema = zod.z.object({
+    business_id: zod.z.string(),
+    type: zod.z.literal("subscription.plan_changed"),
+    timestamp: zod.z.string().transform(function (d) { return new Date(d); }),
+    data: SubscriptionSchema,
+});
+var SubscriptionCancelledPayloadSchema = zod.z.object({
+    business_id: zod.z.string(),
+    type: zod.z.literal("subscription.cancelled"),
+    timestamp: zod.z.string().transform(function (d) { return new Date(d); }),
+    data: SubscriptionSchema,
+});
+var SubscriptionFailedPayloadSchema = zod.z.object({
+    business_id: zod.z.string(),
+    type: zod.z.literal("subscription.failed"),
+    timestamp: zod.z.string().transform(function (d) { return new Date(d); }),
+    data: SubscriptionSchema,
+});
+var SubscriptionExpiredPayloadSchema = zod.z.object({
+    business_id: zod.z.string(),
+    type: zod.z.literal("subscription.expired"),
+    timestamp: zod.z.string().transform(function (d) { return new Date(d); }),
+    data: SubscriptionSchema,
+});
+var LicenseKeyCreatedPayloadSchema = zod.z.object({
+    business_id: zod.z.string(),
+    type: zod.z.literal("license_key.created"),
+    timestamp: zod.z.string().transform(function (d) { return new Date(d); }),
+    data: LicenseKeySchema,
+});
+var WebhookPayloadSchema = zod.z.discriminatedUnion("type", [
+    PaymentSucceededPayloadSchema,
+    PaymentFailedPayloadSchema,
+    PaymentProcessingPayloadSchema,
+    PaymentCancelledPayloadSchema,
+    RefundSucceededPayloadSchema,
+    RefundFailedPayloadSchema,
+    DisputeOpenedPayloadSchema,
+    DisputeExpiredPayloadSchema,
+    DisputeAcceptedPayloadSchema,
+    DisputeCancelledPayloadSchema,
+    DisputeChallengedPayloadSchema,
+    DisputeWonPayloadSchema,
+    DisputeLostPayloadSchema,
+    SubscriptionActivePayloadSchema,
+    SubscriptionOnHoldPayloadSchema,
+    SubscriptionRenewedPayloadSchema,
+    SubscriptionPausedPayloadSchema,
+    SubscriptionPlanChangedPayloadSchema,
+    SubscriptionCancelledPayloadSchema,
+    SubscriptionFailedPayloadSchema,
+    SubscriptionExpiredPayloadSchema,
+    LicenseKeyCreatedPayloadSchema,
+]);
+
+var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (undefined && undefined.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var handleWebhookPayload = function (payload, config) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (!config.onPayload) return [3 /*break*/, 2];
+                return [4 /*yield*/, config.onPayload(payload)];
+            case 1:
+                _a.sent();
+                _a.label = 2;
+            case 2:
+                if (!(payload.type === "payment.succeeded" && config.onPaymentSucceeded)) return [3 /*break*/, 4];
+                return [4 /*yield*/, config.onPaymentSucceeded(payload)];
+            case 3:
+                _a.sent();
+                _a.label = 4;
+            case 4:
+                if (!(payload.type === "payment.failed" && config.onPaymentFailed)) return [3 /*break*/, 6];
+                return [4 /*yield*/, config.onPaymentFailed(payload)];
+            case 5:
+                _a.sent();
+                _a.label = 6;
+            case 6:
+                if (!(payload.type === "payment.processing" && config.onPaymentProcessing)) return [3 /*break*/, 8];
+                return [4 /*yield*/, config.onPaymentProcessing(payload)];
+            case 7:
+                _a.sent();
+                _a.label = 8;
+            case 8:
+                if (!(payload.type === "payment.cancelled" && config.onPaymentCancelled)) return [3 /*break*/, 10];
+                return [4 /*yield*/, config.onPaymentCancelled(payload)];
+            case 9:
+                _a.sent();
+                _a.label = 10;
+            case 10:
+                if (!(payload.type === "refund.succeeded" && config.onRefundSucceeded)) return [3 /*break*/, 12];
+                return [4 /*yield*/, config.onRefundSucceeded(payload)];
+            case 11:
+                _a.sent();
+                _a.label = 12;
+            case 12:
+                if (!(payload.type === "refund.failed" && config.onRefundFailed)) return [3 /*break*/, 14];
+                return [4 /*yield*/, config.onRefundFailed(payload)];
+            case 13:
+                _a.sent();
+                _a.label = 14;
+            case 14:
+                if (!(payload.type === "dispute.opened" && config.onDisputeOpened)) return [3 /*break*/, 16];
+                return [4 /*yield*/, config.onDisputeOpened(payload)];
+            case 15:
+                _a.sent();
+                _a.label = 16;
+            case 16:
+                if (!(payload.type === "dispute.expired" && config.onDisputeExpired)) return [3 /*break*/, 18];
+                return [4 /*yield*/, config.onDisputeExpired(payload)];
+            case 17:
+                _a.sent();
+                _a.label = 18;
+            case 18:
+                if (!(payload.type === "dispute.accepted" && config.onDisputeAccepted)) return [3 /*break*/, 20];
+                return [4 /*yield*/, config.onDisputeAccepted(payload)];
+            case 19:
+                _a.sent();
+                _a.label = 20;
+            case 20:
+                if (!(payload.type === "dispute.cancelled" && config.onDisputeCancelled)) return [3 /*break*/, 22];
+                return [4 /*yield*/, config.onDisputeCancelled(payload)];
+            case 21:
+                _a.sent();
+                _a.label = 22;
+            case 22:
+                if (!(payload.type === "dispute.challenged" && config.onDisputeChallenged)) return [3 /*break*/, 24];
+                return [4 /*yield*/, config.onDisputeChallenged(payload)];
+            case 23:
+                _a.sent();
+                _a.label = 24;
+            case 24:
+                if (!(payload.type === "dispute.won" && config.onDisputeWon)) return [3 /*break*/, 26];
+                return [4 /*yield*/, config.onDisputeWon(payload)];
+            case 25:
+                _a.sent();
+                _a.label = 26;
+            case 26:
+                if (!(payload.type === "dispute.lost" && config.onDisputeLost)) return [3 /*break*/, 28];
+                return [4 /*yield*/, config.onDisputeLost(payload)];
+            case 27:
+                _a.sent();
+                _a.label = 28;
+            case 28:
+                if (!(payload.type === "subscription.active" && config.onSubscriptionActive)) return [3 /*break*/, 30];
+                return [4 /*yield*/, config.onSubscriptionActive(payload)];
+            case 29:
+                _a.sent();
+                _a.label = 30;
+            case 30:
+                if (!(payload.type === "subscription.on_hold" && config.onSubscriptionOnHold)) return [3 /*break*/, 32];
+                return [4 /*yield*/, config.onSubscriptionOnHold(payload)];
+            case 31:
+                _a.sent();
+                _a.label = 32;
+            case 32:
+                if (!(payload.type === "subscription.renewed" && config.onSubscriptionRenewed)) return [3 /*break*/, 34];
+                return [4 /*yield*/, config.onSubscriptionRenewed(payload)];
+            case 33:
+                _a.sent();
+                _a.label = 34;
+            case 34:
+                if (!(payload.type === "subscription.paused" && config.onSubscriptionPaused)) return [3 /*break*/, 36];
+                return [4 /*yield*/, config.onSubscriptionPaused(payload)];
+            case 35:
+                _a.sent();
+                _a.label = 36;
+            case 36:
+                if (!(payload.type === "subscription.plan_changed" &&
+                    config.onSubscriptionPlanChanged)) return [3 /*break*/, 38];
+                return [4 /*yield*/, config.onSubscriptionPlanChanged(payload)];
+            case 37:
+                _a.sent();
+                _a.label = 38;
+            case 38:
+                if (!(payload.type === "subscription.cancelled" &&
+                    config.onSubscriptionCancelled)) return [3 /*break*/, 40];
+                return [4 /*yield*/, config.onSubscriptionCancelled(payload)];
+            case 39:
+                _a.sent();
+                _a.label = 40;
+            case 40:
+                if (!(payload.type === "subscription.failed" && config.onSubscriptionFailed)) return [3 /*break*/, 42];
+                return [4 /*yield*/, config.onSubscriptionFailed(payload)];
+            case 41:
+                _a.sent();
+                _a.label = 42;
+            case 42:
+                if (!(payload.type === "subscription.expired" && config.onSubscriptionExpired)) return [3 /*break*/, 44];
+                return [4 /*yield*/, config.onSubscriptionExpired(payload)];
+            case 43:
+                _a.sent();
+                _a.label = 44;
+            case 44:
+                if (!(payload.type === "license_key.created" && config.onLicenseKeyCreated)) return [3 /*break*/, 46];
+                return [4 /*yield*/, config.onLicenseKeyCreated(payload)];
+            case 45:
+                _a.sent();
+                _a.label = 46;
+            case 46: return [2 /*return*/];
+        }
+    });
+}); };
+
+const Webhooks = ({ webhookKey, ...eventHandlers }) => {
+    const standardWebhook = new Webhook_1(webhookKey);
+    return async (c) => {
+        if (c.req.method !== "POST") {
+            return c.text("Method not allowed. Use POST", 405);
+        }
+        const headers = {
+            "webhook-id": c.req.header("webhook-id") ?? "",
+            "webhook-timestamp": c.req.header("webhook-timestamp") ?? "",
+            "webhook-signature": c.req.header("webhook-signature") ?? "",
+        };
+        const rawBody = await c.req.text();
+        try {
+            standardWebhook.verify(rawBody, headers);
+        }
+        catch (err) {
+            if (err instanceof WebhookVerificationError_1) {
+                return c.text(err.message, 401);
+            }
+            return c.text("Error while verifying webhook", 500);
+        }
+        const { success, data: payload, error, } = WebhookPayloadSchema.safeParse(JSON.parse(rawBody));
+        if (!success) {
+            console.error("Error parsing webhook payload", error.issues);
+            return c.text(`Error parsing webhook payload: ${error.message}`, 400);
+        }
+        // do not catch errors here, let them bubble up to the user
+        // as they will originate from the handlers passed by the user
+        await handleWebhookPayload(payload, {
+            webhookKey,
+            ...eventHandlers,
+        });
+        return c.text("", 200);
+    };
+};
+
+exports.Checkout = Checkout;
+exports.CustomerPortal = CustomerPortal;
+exports.Webhooks = Webhooks;
+//# sourceMappingURL=index.cjs.map