@b3dotfun/sdk 0.1.68-alpha.3 → 0.1.68-alpha.5

package/dist/cjs/anyspend/platform/client.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Core HTTP client for the AnySpend Platform API.
+ * Handles authentication, retries, error parsing, and idempotency.
+ */
+export interface ClientConfig {
+    baseUrl?: string;
+    timeout?: number;
+    maxRetries?: number;
+    idempotencyKeyGenerator?: () => string;
+}
+export declare const DEFAULT_BASE_URL = "https://platform-api.anyspend.com/api/v1";
+export declare class HttpClient {
+    private apiKey;
+    private baseUrl;
+    private timeout;
+    private maxRetries;
+    private generateIdempotencyKey;
+    constructor(apiKey: string, config?: ClientConfig);
+    get<T>(path: string, params?: object): Promise<T>;
+    post<T>(path: string, body?: object): Promise<T>;
+    patch<T>(path: string, body: object): Promise<T>;
+    delete<T>(path: string, body?: object): Promise<T>;
+    postFormData<T>(path: string, formData: FormData): Promise<T>;
+    private buildUrl;
+    private request;
+    private requestRaw;
+    private executeWithRetry;
+    private sleep;
+}
+/**
+ * Static HTTP client for unauthenticated requests (quick-pay).
+ */
+export declare class StaticHttpClient {
+    static post<T>(baseUrl: string, path: string, body: Record<string, unknown>): Promise<T>;
+}

package/dist/cjs/anyspend/platform/client.js

@@ -0,0 +1,158 @@
+"use strict";
+/**
+ * Core HTTP client for the AnySpend Platform API.
+ * Handles authentication, retries, error parsing, and idempotency.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticHttpClient = exports.HttpClient = exports.DEFAULT_BASE_URL = void 0;
+const errors_1 = require("./errors");
+const idempotency_1 = require("./utils/idempotency");
+exports.DEFAULT_BASE_URL = "https://platform-api.anyspend.com/api/v1";
+const DEFAULT_TIMEOUT = 30000;
+const DEFAULT_MAX_RETRIES = 3;
+class HttpClient {
+    constructor(apiKey, config = {}) {
+        this.apiKey = apiKey;
+        this.baseUrl = (config.baseUrl || exports.DEFAULT_BASE_URL).replace(/\/$/, "");
+        this.timeout = config.timeout || DEFAULT_TIMEOUT;
+        this.maxRetries = config.maxRetries || DEFAULT_MAX_RETRIES;
+        this.generateIdempotencyKey = config.idempotencyKeyGenerator || idempotency_1.generateIdempotencyKey;
+    }
+    async get(path, params) {
+        const url = this.buildUrl(path, params);
+        return this.request("GET", url);
+    }
+    async post(path, body) {
+        const url = this.buildUrl(path);
+        return this.request("POST", url, body);
+    }
+    async patch(path, body) {
+        const url = this.buildUrl(path);
+        return this.request("PATCH", url, body);
+    }
+    async delete(path, body) {
+        const url = this.buildUrl(path);
+        return this.request("DELETE", url, body);
+    }
+    async postFormData(path, formData) {
+        const url = this.buildUrl(path);
+        return this.requestRaw("POST", url, formData);
+    }
+    buildUrl(path, params) {
+        const url = new URL(`${this.baseUrl}${path}`);
+        if (params) {
+            for (const [key, value] of Object.entries(params)) {
+                if (value !== undefined && value !== null)
+                    url.searchParams.set(key, String(value));
+            }
+        }
+        return url.toString();
+    }
+    async request(method, url, body) {
+        const headers = {
+            Authorization: `Bearer ${this.apiKey}`,
+            "Content-Type": "application/json",
+        };
+        // Auto-generate idempotency key for POST/PATCH
+        if (method === "POST" || method === "PATCH") {
+            headers["Idempotency-Key"] = this.generateIdempotencyKey();
+        }
+        return this.executeWithRetry(method, url, headers, body ? JSON.stringify(body) : undefined);
+    }
+    async requestRaw(method, url, body) {
+        const headers = {
+            Authorization: `Bearer ${this.apiKey}`,
+        };
+        return this.executeWithRetry(method, url, headers, body);
+    }
+    async executeWithRetry(method, url, headers, body) {
+        let lastError;
+        for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+            try {
+                const controller = new AbortController();
+                const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+                const response = await fetch(url, {
+                    method,
+                    headers,
+                    body,
+                    signal: controller.signal,
+                });
+                clearTimeout(timeoutId);
+                if (response.ok) {
+                    // Handle CSV/text responses
+                    const contentType = response.headers.get("Content-Type") || "";
+                    if (contentType.includes("text/csv")) {
+                        return (await response.text());
+                    }
+                    return (await response.json());
+                }
+                // Parse error response
+                const errorBody = (await response.json().catch(() => ({
+                    error: { type: "api_error", code: "internal_error", message: "Unknown error" },
+                })));
+                const error = (0, errors_1.parseApiError)(response.status, errorBody, response.headers);
+                // Don't retry 4xx errors (except 429 rate limits)
+                if (response.status < 500 && response.status !== 429) {
+                    throw error;
+                }
+                // For 429, wait the specified retry-after time
+                if (response.status === 429) {
+                    const retryAfter = parseInt(response.headers.get("Retry-After") || "1", 10);
+                    await this.sleep(retryAfter * 1000);
+                    lastError = error;
+                    continue;
+                }
+                // For 5xx, retry with exponential backoff
+                lastError = error;
+                if (attempt < this.maxRetries) {
+                    await this.sleep(Math.pow(2, attempt) * 1000);
+                }
+            }
+            catch (err) {
+                if (err instanceof Error && err.name === "AbortError") {
+                    lastError = new Error(`Request timed out after ${this.timeout}ms`);
+                }
+                else if (err instanceof Error && "type" in err) {
+                    // Already a parsed ApiError, re-throw
+                    throw err;
+                }
+                else {
+                    lastError = err instanceof Error ? err : new Error(String(err));
+                }
+                if (attempt < this.maxRetries) {
+                    await this.sleep(Math.pow(2, attempt) * 1000);
+                }
+            }
+        }
+        throw lastError || new Error("Request failed after retries");
+    }
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+exports.HttpClient = HttpClient;
+/**
+ * Static HTTP client for unauthenticated requests (quick-pay).
+ */
+class StaticHttpClient {
+    static async post(baseUrl, path, body) {
+        const url = `${baseUrl.replace(/\/$/, "")}${path}`;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT);
+        const response = await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+            signal: controller.signal,
+        });
+        clearTimeout(timeoutId);
+        if (response.ok) {
+            return (await response.json());
+        }
+        const errorBody = (await response.json().catch(() => ({
+            error: { type: "api_error", code: "internal_error", message: "Unknown error" },
+        })));
+        throw (0, errors_1.parseApiError)(response.status, errorBody, response.headers);
+    }
+}
+exports.StaticHttpClient = StaticHttpClient;

package/dist/cjs/anyspend/platform/errors.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Typed error classes for the AnySpend Platform API client.
+ */
+export interface ApiErrorResponse {
+    error: {
+        type: string;
+        code: string;
+        message: string;
+        param?: string;
+    };
+}
+export declare class ApiError extends Error {
+    readonly type: string;
+    readonly code: string;
+    readonly status: number;
+    readonly param?: string;
+    constructor(status: number, body: ApiErrorResponse);
+}
+export declare class AuthenticationError extends ApiError {
+    constructor(status: number, body: ApiErrorResponse);
+}
+export declare class PermissionError extends ApiError {
+    constructor(status: number, body: ApiErrorResponse);
+}
+export declare class RateLimitError extends ApiError {
+    readonly retryAfter: number;
+    constructor(status: number, body: ApiErrorResponse, retryAfter: number);
+}
+export declare class NotFoundError extends ApiError {
+    constructor(status: number, body: ApiErrorResponse);
+}
+export declare class IdempotencyError extends ApiError {
+    constructor(status: number, body: ApiErrorResponse);
+}
+/**
+ * Parse an API error response into the appropriate typed error class.
+ */
+export declare function parseApiError(status: number, body: ApiErrorResponse, headers?: Headers): ApiError;

package/dist/cjs/anyspend/platform/errors.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * Typed error classes for the AnySpend Platform API client.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdempotencyError = exports.NotFoundError = exports.RateLimitError = exports.PermissionError = exports.AuthenticationError = exports.ApiError = void 0;
+exports.parseApiError = parseApiError;
+class ApiError extends Error {
+    constructor(status, body) {
+        super(body.error.message);
+        this.name = "ApiError";
+        this.type = body.error.type;
+        this.code = body.error.code;
+        this.status = status;
+        this.param = body.error.param;
+    }
+}
+exports.ApiError = ApiError;
+class AuthenticationError extends ApiError {
+    constructor(status, body) {
+        super(status, body);
+        this.name = "AuthenticationError";
+    }
+}
+exports.AuthenticationError = AuthenticationError;
+class PermissionError extends ApiError {
+    constructor(status, body) {
+        super(status, body);
+        this.name = "PermissionError";
+    }
+}
+exports.PermissionError = PermissionError;
+class RateLimitError extends ApiError {
+    constructor(status, body, retryAfter) {
+        super(status, body);
+        this.name = "RateLimitError";
+        this.retryAfter = retryAfter;
+    }
+}
+exports.RateLimitError = RateLimitError;
+class NotFoundError extends ApiError {
+    constructor(status, body) {
+        super(status, body);
+        this.name = "NotFoundError";
+    }
+}
+exports.NotFoundError = NotFoundError;
+class IdempotencyError extends ApiError {
+    constructor(status, body) {
+        super(status, body);
+        this.name = "IdempotencyError";
+    }
+}
+exports.IdempotencyError = IdempotencyError;
+/**
+ * Parse an API error response into the appropriate typed error class.
+ */
+function parseApiError(status, body, headers) {
+    const type = body.error?.type;
+    if (status === 401 || type === "authentication_error") {
+        return new AuthenticationError(status, body);
+    }
+    if (status === 403 || type === "permission_error") {
+        return new PermissionError(status, body);
+    }
+    if (status === 429 || type === "rate_limit_error") {
+        const retryAfter = parseInt(headers?.get("Retry-After") || "60", 10);
+        return new RateLimitError(status, body, retryAfter);
+    }
+    if (status === 404 || type === "not_found_error") {
+        return new NotFoundError(status, body);
+    }
+    if (type === "idempotency_error") {
+        return new IdempotencyError(status, body);
+    }
+    return new ApiError(status, body);
+}

package/dist/cjs/anyspend/platform/index.d.ts

@@ -0,0 +1,87 @@
+/**
+ * AnySpend Platform API Client
+ *
+ * A headless TypeScript client for the AnySpend Platform REST API.
+ * Works in any runtime with `fetch` (Node.js, browsers, Cloudflare Workers, Deno, Bun).
+ *
+ * @example
+ * ```typescript
+ * import { AnySpendPlatformClient } from '../../anyspend/platform';
+ *
+ * const platform = new AnySpendPlatformClient('asp_your_api_key_here');
+ *
+ * // Create a payment link
+ * const link = await platform.paymentLinks.create({
+ *   name: 'Summer Sale',
+ *   amount: '10000000',
+ *   token_address: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
+ *   chain_id: 8453,
+ *   recipient_address: '0x...',
+ * });
+ *
+ * // Quick pay (no API key needed)
+ * const quickLink = await AnySpendPlatformClient.quickPay({
+ *   recipient_address: '0x...',
+ *   amount: '5000000',
+ * });
+ * ```
+ */
+import { type ClientConfig } from "./client";
+import { PaymentLinksResource } from "./resources/payment-links";
+import { ProductsResource } from "./resources/products";
+import { CustomersResource } from "./resources/customers";
+import { TransactionsResource } from "./resources/transactions";
+import { CheckoutSessionsResource } from "./resources/checkout-sessions";
+import { WebhooksResource } from "./resources/webhooks";
+import { DiscountCodesResource } from "./resources/discount-codes";
+import { NotificationsResource } from "./resources/notifications";
+import { WidgetsResource } from "./resources/widgets";
+import { OrganizationResource } from "./resources/organization";
+import { AnalyticsResource } from "./resources/analytics";
+import { EventsResource } from "./resources/events";
+import type { QuickPayParams, PaymentLink } from "./types";
+export declare class AnySpendPlatformClient {
+    private client;
+    /** Payment Links - Create, manage, and track payment links */
+    readonly paymentLinks: PaymentLinksResource;
+    /** Products - Manage your product catalog */
+    readonly products: ProductsResource;
+    /** Customers - Manage customer records */
+    readonly customers: CustomersResource;
+    /** Transactions - View transaction history and stats */
+    readonly transactions: TransactionsResource;
+    /** Checkout Sessions - Server-side checkout management */
+    readonly checkoutSessions: CheckoutSessionsResource;
+    /** Webhooks - Configure webhook endpoints */
+    readonly webhooks: WebhooksResource;
+    /** Discount Codes - Create and validate discounts */
+    readonly discountCodes: DiscountCodesResource;
+    /** Notifications - Email and Telegram settings */
+    readonly notifications: NotificationsResource;
+    /** Widgets - Embeddable widget configurations */
+    readonly widgets: WidgetsResource;
+    /** Organization - Org settings and defaults */
+    readonly organization: OrganizationResource;
+    /** Analytics - Revenue and conversion analytics */
+    readonly analytics: AnalyticsResource;
+    /** Events - API audit trail */
+    readonly events: EventsResource;
+    /**
+     * Create a new AnySpend Platform API client.
+     *
+     * @param apiKey - Your API key (starts with `asp_`)
+     * @param config - Optional configuration
+     */
+    constructor(apiKey: string, config?: ClientConfig);
+    /**
+     * Create a quick payment link without authentication.
+     * Rate limited to 5 requests per minute per IP.
+     *
+     * @param params - Quick pay parameters
+     * @param baseUrl - Optional API base URL (defaults to production)
+     */
+    static quickPay(params: QuickPayParams, baseUrl?: string): Promise<PaymentLink>;
+}
+export type { ClientConfig } from "./client";
+export { ApiError, AuthenticationError, PermissionError, RateLimitError, NotFoundError, IdempotencyError, } from "./errors";
+export type * from "./types";

package/dist/cjs/anyspend/platform/index.js

@@ -0,0 +1,85 @@
+"use strict";
+/**
+ * AnySpend Platform API Client
+ *
+ * A headless TypeScript client for the AnySpend Platform REST API.
+ * Works in any runtime with `fetch` (Node.js, browsers, Cloudflare Workers, Deno, Bun).
+ *
+ * @example
+ * ```typescript
+ * import { AnySpendPlatformClient } from '../../anyspend/platform';
+ *
+ * const platform = new AnySpendPlatformClient('asp_your_api_key_here');
+ *
+ * // Create a payment link
+ * const link = await platform.paymentLinks.create({
+ *   name: 'Summer Sale',
+ *   amount: '10000000',
+ *   token_address: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
+ *   chain_id: 8453,
+ *   recipient_address: '0x...',
+ * });
+ *
+ * // Quick pay (no API key needed)
+ * const quickLink = await AnySpendPlatformClient.quickPay({
+ *   recipient_address: '0x...',
+ *   amount: '5000000',
+ * });
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdempotencyError = exports.NotFoundError = exports.RateLimitError = exports.PermissionError = exports.AuthenticationError = exports.ApiError = exports.AnySpendPlatformClient = void 0;
+const client_1 = require("./client");
+const payment_links_1 = require("./resources/payment-links");
+const products_1 = require("./resources/products");
+const customers_1 = require("./resources/customers");
+const transactions_1 = require("./resources/transactions");
+const checkout_sessions_1 = require("./resources/checkout-sessions");
+const webhooks_1 = require("./resources/webhooks");
+const discount_codes_1 = require("./resources/discount-codes");
+const notifications_1 = require("./resources/notifications");
+const widgets_1 = require("./resources/widgets");
+const organization_1 = require("./resources/organization");
+const analytics_1 = require("./resources/analytics");
+const events_1 = require("./resources/events");
+class AnySpendPlatformClient {
+    /**
+     * Create a new AnySpend Platform API client.
+     *
+     * @param apiKey - Your API key (starts with `asp_`)
+     * @param config - Optional configuration
+     */
+    constructor(apiKey, config) {
+        this.client = new client_1.HttpClient(apiKey, config);
+        this.paymentLinks = new payment_links_1.PaymentLinksResource(this.client);
+        this.products = new products_1.ProductsResource(this.client);
+        this.customers = new customers_1.CustomersResource(this.client);
+        this.transactions = new transactions_1.TransactionsResource(this.client);
+        this.checkoutSessions = new checkout_sessions_1.CheckoutSessionsResource(this.client);
+        this.webhooks = new webhooks_1.WebhooksResource(this.client);
+        this.discountCodes = new discount_codes_1.DiscountCodesResource(this.client);
+        this.notifications = new notifications_1.NotificationsResource(this.client);
+        this.widgets = new widgets_1.WidgetsResource(this.client);
+        this.organization = new organization_1.OrganizationResource(this.client);
+        this.analytics = new analytics_1.AnalyticsResource(this.client);
+        this.events = new events_1.EventsResource(this.client);
+    }
+    /**
+     * Create a quick payment link without authentication.
+     * Rate limited to 5 requests per minute per IP.
+     *
+     * @param params - Quick pay parameters
+     * @param baseUrl - Optional API base URL (defaults to production)
+     */
+    static async quickPay(params, baseUrl = client_1.DEFAULT_BASE_URL) {
+        return client_1.StaticHttpClient.post(baseUrl, "/quick-pay", params);
+    }
+}
+exports.AnySpendPlatformClient = AnySpendPlatformClient;
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "ApiError", { enumerable: true, get: function () { return errors_1.ApiError; } });
+Object.defineProperty(exports, "AuthenticationError", { enumerable: true, get: function () { return errors_1.AuthenticationError; } });
+Object.defineProperty(exports, "PermissionError", { enumerable: true, get: function () { return errors_1.PermissionError; } });
+Object.defineProperty(exports, "RateLimitError", { enumerable: true, get: function () { return errors_1.RateLimitError; } });
+Object.defineProperty(exports, "NotFoundError", { enumerable: true, get: function () { return errors_1.NotFoundError; } });
+Object.defineProperty(exports, "IdempotencyError", { enumerable: true, get: function () { return errors_1.IdempotencyError; } });

package/dist/cjs/anyspend/platform/resources/analytics.d.ts

@@ -0,0 +1,7 @@
+import type { HttpClient } from "../client";
+import type { AnalyticsOverview } from "../types";
+export declare class AnalyticsResource {
+    private client;
+    constructor(client: HttpClient);
+    overview(period?: "7d" | "30d" | "90d" | "all"): Promise<AnalyticsOverview>;
+}

package/dist/cjs/anyspend/platform/resources/analytics.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnalyticsResource = void 0;
+class AnalyticsResource {
+    constructor(client) {
+        this.client = client;
+    }
+    async overview(period) {
+        return this.client.get("/analytics/overview", period !== undefined ? { period } : undefined);
+    }
+}
+exports.AnalyticsResource = AnalyticsResource;

package/dist/cjs/anyspend/platform/resources/checkout-sessions.d.ts

@@ -0,0 +1,17 @@
+import type { HttpClient } from "../client";
+import type { CheckoutSession, ListResponse, CreateCheckoutSessionParams, PaginationParams } from "../types";
+export interface ListCheckoutSessionsParams extends PaginationParams {
+    status?: "open" | "processing" | "completed" | "expired" | "failed";
+    payment_link_id?: string;
+    from?: number;
+    to?: number;
+}
+export declare class CheckoutSessionsResource {
+    private client;
+    constructor(client: HttpClient);
+    list(params?: ListCheckoutSessionsParams): Promise<ListResponse<CheckoutSession>>;
+    listAutoPaginate(params?: Omit<ListCheckoutSessionsParams, "page">): AsyncGenerator<CheckoutSession>;
+    create(params: CreateCheckoutSessionParams): Promise<CheckoutSession>;
+    get(id: string): Promise<CheckoutSession>;
+    expire(id: string): Promise<CheckoutSession>;
+}

package/dist/cjs/anyspend/platform/resources/checkout-sessions.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckoutSessionsResource = void 0;
+const pagination_1 = require("../utils/pagination");
+class CheckoutSessionsResource {
+    constructor(client) {
+        this.client = client;
+    }
+    async list(params) {
+        return this.client.get("/checkout-sessions", params);
+    }
+    async *listAutoPaginate(params) {
+        yield* (0, pagination_1.autoPaginate)((page, limit) => this.list({ ...params, page, limit }), {
+            limit: params?.limit,
+        });
+    }
+    async create(params) {
+        return this.client.post("/checkout-sessions", params);
+    }
+    async get(id) {
+        return this.client.get(`/checkout-sessions/${id}`);
+    }
+    async expire(id) {
+        return this.client.post(`/checkout-sessions/${id}/expire`);
+    }
+}
+exports.CheckoutSessionsResource = CheckoutSessionsResource;

package/dist/cjs/anyspend/platform/resources/customers.d.ts

@@ -0,0 +1,19 @@
+import type { HttpClient } from "../client";
+import type { Customer, Transaction, ListResponse, DeletedResponse, CreateCustomerParams, UpdateCustomerParams, ExportCustomersParams, PaginationParams } from "../types";
+export interface ListCustomersParams extends PaginationParams {
+    search?: string;
+    sort?: "created_at" | "updated_at" | "total_paid" | "transaction_count";
+    order?: "asc" | "desc";
+}
+export declare class CustomersResource {
+    private client;
+    constructor(client: HttpClient);
+    list(params?: ListCustomersParams): Promise<ListResponse<Customer>>;
+    listAutoPaginate(params?: Omit<ListCustomersParams, "page">): AsyncGenerator<Customer>;
+    create(params: CreateCustomerParams): Promise<Customer>;
+    get(id: string): Promise<Customer>;
+    update(id: string, params: UpdateCustomerParams): Promise<Customer>;
+    delete(id: string): Promise<DeletedResponse>;
+    transactions(id: string, params?: PaginationParams): Promise<ListResponse<Transaction>>;
+    export(params?: ExportCustomersParams): Promise<string>;
+}

package/dist/cjs/anyspend/platform/resources/customers.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomersResource = void 0;
+const pagination_1 = require("../utils/pagination");
+class CustomersResource {
+    constructor(client) {
+        this.client = client;
+    }
+    async list(params) {
+        return this.client.get("/customers", params);
+    }
+    async *listAutoPaginate(params) {
+        yield* (0, pagination_1.autoPaginate)((page, limit) => this.list({ ...params, page, limit }), { limit: params?.limit });
+    }
+    async create(params) {
+        return this.client.post("/customers", params);
+    }
+    async get(id) {
+        return this.client.get(`/customers/${id}`);
+    }
+    async update(id, params) {
+        return this.client.patch(`/customers/${id}`, params);
+    }
+    async delete(id) {
+        return this.client.delete(`/customers/${id}`);
+    }
+    async transactions(id, params) {
+        return this.client.get(`/customers/${id}/transactions`, params);
+    }
+    async export(params) {
+        return this.client.get("/customers/export", params);
+    }
+}
+exports.CustomersResource = CustomersResource;

package/dist/cjs/anyspend/platform/resources/discount-codes.d.ts

@@ -0,0 +1,29 @@
+import type { HttpClient } from "../client";
+import type { DiscountCode, ListResponse, DeletedResponse, CreateDiscountCodeParams, BatchCreateDiscountCodesParams, ValidateDiscountResult, BatchCreateResult, PaginationParams } from "../types";
+export interface ListDiscountCodesParams extends PaginationParams {
+    payment_link_id?: string;
+    active?: "true" | "false";
+    search?: string;
+}
+export interface UpdateDiscountCodeParams {
+    is_active?: boolean;
+    max_uses?: number;
+    min_order_amount?: string;
+    expires_at?: number;
+}
+export interface ValidateDiscountParams {
+    code: string;
+    payment_link_id?: string;
+    amount?: string;
+}
+export declare class DiscountCodesResource {
+    private client;
+    constructor(client: HttpClient);
+    list(params?: ListDiscountCodesParams): Promise<ListResponse<DiscountCode>>;
+    listAutoPaginate(params?: Omit<ListDiscountCodesParams, "page">): AsyncGenerator<DiscountCode>;
+    create(params: CreateDiscountCodeParams): Promise<DiscountCode>;
+    update(id: string, params: UpdateDiscountCodeParams): Promise<DiscountCode>;
+    delete(id: string): Promise<DeletedResponse>;
+    validate(params: ValidateDiscountParams): Promise<ValidateDiscountResult>;
+    batchCreate(params: BatchCreateDiscountCodesParams): Promise<BatchCreateResult>;
+}

package/dist/cjs/anyspend/platform/resources/discount-codes.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscountCodesResource = void 0;
+const pagination_1 = require("../utils/pagination");
+class DiscountCodesResource {
+    constructor(client) {
+        this.client = client;
+    }
+    async list(params) {
+        return this.client.get("/discount-codes", params);
+    }
+    async *listAutoPaginate(params) {
+        yield* (0, pagination_1.autoPaginate)((page, limit) => this.list({ ...params, page, limit }), { limit: params?.limit });
+    }
+    async create(params) {
+        return this.client.post("/discount-codes", params);
+    }
+    async update(id, params) {
+        return this.client.patch(`/discount-codes/${id}`, params);
+    }
+    async delete(id) {
+        return this.client.delete(`/discount-codes/${id}`);
+    }
+    async validate(params) {
+        return this.client.post("/discount-codes/validate", params);
+    }
+    async batchCreate(params) {
+        return this.client.post("/discount-codes/batch", params);
+    }
+}
+exports.DiscountCodesResource = DiscountCodesResource;