@checkoutpage/sdk 0.1.14 → 0.1.30

package/dist/index.js

@@ -55,34 +55,109 @@ var APIError = class _APIError extends CheckoutPageError {
   }
 };
 
+// src/resources/invoices/invoices.ts
+var InvoiceResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Retrieve a single invoice by ID. The returned `invoiceUrl` is a freshly
+   * signed link to the hosted PDF and expires an hour later — re-fetch to
+   * mint a new one.
+   *
+   * @example
+   * const { data: invoice } = await client.invoices.get(invoiceId);
+   */
+  async get(id) {
+    if (!id) {
+      throw new Error("Invoice ID is required");
+    }
+    return this.client.request({
+      method: "GET",
+      path: `/v1/invoices/${id}`
+    });
+  }
+  async list(args = {}) {
+    const query = {
+      limit: args.limit?.toString(),
+      starting_after: args.starting_after,
+      ending_before: args.ending_before,
+      search: args.search,
+      status: args.status,
+      customerId: args.customerId,
+      chargeId: args.chargeId,
+      poNumber: args.poNumber,
+      createdAfter: args.createdAfter,
+      createdBefore: args.createdBefore
+    };
+    return this.client.request({
+      method: "GET",
+      path: "/v1/invoices/",
+      query
+    });
+  }
+  async regenerate(id) {
+    const response = await this.client.request({
+      method: "POST",
+      path: `/v1/invoices/${id}/regenerate`
+    });
+    return response.data;
+  }
+};
+
 // src/client.ts
 var CheckoutPageApiClient = class {
   apiKey;
   baseUrl;
+  invoices;
   constructor(options) {
     if (!options.apiKey) {
       throw new Error("API key is required");
     }
     this.apiKey = options.apiKey;
     this.baseUrl = options.baseUrl || "https://api.checkoutpage.com";
+    this.invoices = new InvoiceResource(this);
   }
   async request(options) {
     const url = this.buildUrl(options.path, options.query);
     const headers = {
       Authorization: `Bearer ${this.apiKey}`,
-      "Content-Type": "application/json",
       "User-Agent": "@checkoutpage/sdk/0.1.0"
     };
+    if (!options.formData) {
+      headers["Content-Type"] = "application/json";
+    }
     const fetchOptions = {
       method: options.method,
       headers
     };
-    if (options.body) {
+    if (options.formData) {
+      fetchOptions.body = options.formData;
+    } else if (options.body) {
       fetchOptions.body = JSON.stringify(options.body);
     }
     const response = await fetch(url, fetchOptions);
     return await this.handleResponse(response);
   }
+  /**
+   * Perform a request whose successful response is a binary file rather than
+   * JSON (e.g. a ticket PDF). Errors are parsed and thrown the same way as
+   * request().
+   */
+  async requestRaw(options) {
+    const url = this.buildUrl(options.path, options.query);
+    const response = await fetch(url, {
+      method: options.method,
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`,
+        "User-Agent": "@checkoutpage/sdk/0.1.0"
+      }
+    });
+    if (!response.ok) {
+      await this.handleResponse(response);
+    }
+    return await response.arrayBuffer();
+  }
   buildUrl(path, query) {
     const url = new URL(path, this.baseUrl);
     if (query) {
@@ -137,6 +212,27 @@ var CheckoutPageApiClient = class {
   }
 };
 
+// src/resources/accounts/accounts.ts
+var AccountResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Retrieve the seller account the API key belongs to: store slug, display
+   * name and logo.
+   *
+   * The endpoint wraps the account in a `data` envelope (the OpenAPI spec
+   * documents the bare object); this unwraps it so callers get the account.
+   */
+  async get() {
+    const response = await this.client.request({
+      method: "GET",
+      path: "/v1/account/"
+    });
+    return response.data;
+  }
+};
+
 // src/resources/customers/customers.ts
 var CustomerResource = class {
   constructor(client) {
@@ -164,6 +260,38 @@ var CustomerResource = class {
       path: "/v1/customers/"
     });
   }
+  async update(customerId, params) {
+    if (!customerId) {
+      throw new Error("Customer ID is required");
+    }
+    const body = {};
+    if (params.name !== void 0) {
+      body.name = params.name;
+    }
+    if (params.companyName !== void 0) {
+      body.companyName = params.companyName;
+    }
+    if (params.email !== void 0) {
+      body.email = params.email;
+    }
+    if (params.phone !== void 0) {
+      body.phone = params.phone;
+    }
+    if (params.billingEmail !== void 0) {
+      body.billingEmail = params.billingEmail;
+    }
+    if (params.address !== void 0) {
+      body.address = params.address;
+    }
+    if (params.shipping !== void 0) {
+      body.shipping = params.shipping;
+    }
+    return this.client.request({
+      method: "PATCH",
+      path: `/v1/customers/${customerId}`,
+      body
+    });
+  }
 };
 
 // src/resources/coupons/coupons.ts
@@ -184,6 +312,29 @@ var CouponResource = class {
       path: "/v1/coupons/"
     });
   }
+  /**
+   * Update an existing coupon. Only the fields you supply are changed.
+   *
+   * `pageIds` and `ticketTypeIds` replace the existing lists rather than
+   * merging — pass an empty array to clear one.
+   *
+   * The discount itself (`code`, `amountOff`, `percentOff`, `currency`,
+   * `duration`) is fixed once the coupon is mirrored into Stripe. To change a
+   * discount, soft delete this coupon and create a replacement.
+   *
+   * @example
+   * const { data: coupon } = await client.coupons.update(couponId, { deleted: true });
+   */
+  async update(couponId, params) {
+    if (!couponId) {
+      throw new Error("Coupon ID is required");
+    }
+    return this.client.request({
+      method: "PATCH",
+      path: `/v1/coupons/${couponId}`,
+      body: params
+    });
+  }
   async create(params) {
     const body = {
       label: params.label,
@@ -199,6 +350,9 @@ var CouponResource = class {
     if (params.pageIds !== void 0) {
       body.pageIds = params.pageIds;
     }
+    if (params.ticketTypeIds !== void 0) {
+      body.ticketTypeIds = params.ticketTypeIds;
+    }
     if (params.maxRedemptions !== void 0) {
       body.maxRedemptions = params.maxRedemptions;
     }
@@ -224,11 +378,34 @@ var PaymentResource = class {
   constructor(client) {
     this.client = client;
   }
+  /**
+   * Retrieve a single payment by ID. Only checkout payments are returned —
+   * an event charge is a booking, and 404s here.
+   *
+   * @example
+   * const { data: payment } = await client.payments.get(paymentId);
+   */
+  async get(paymentId) {
+    if (!paymentId) {
+      throw new Error("Payment ID is required");
+    }
+    return this.client.request({
+      method: "GET",
+      path: `/v1/payments/${paymentId}`
+    });
+  }
   async list(args = {}) {
     const query = {
       search: args.search,
       status: args.status,
       pageId: args.pageId,
+      customerId: args.customerId,
+      orderId: args.orderId,
+      couponCode: args.couponCode,
+      productId: args.productId,
+      createdAfter: args.createdAfter,
+      createdBefore: args.createdBefore,
+      abandonmentStatus: args.abandonmentStatus,
       limit: args.limit?.toString(),
       starting_after: args.starting_after,
       ending_before: args.ending_before
@@ -246,6 +423,21 @@ var SubscriptionResource = class {
   constructor(client) {
     this.client = client;
   }
+  /**
+   * Retrieve a single subscription by ID.
+   *
+   * @example
+   * const { data: subscription } = await client.subscriptions.get(subscriptionId);
+   */
+  async get(subscriptionId) {
+    if (!subscriptionId) {
+      throw new Error("Subscription ID is required");
+    }
+    return this.client.request({
+      method: "GET",
+      path: `/v1/subscriptions/${subscriptionId}`
+    });
+  }
   async list(args = {}) {
     const query = {
       search: args.search,
@@ -261,6 +453,71 @@ var SubscriptionResource = class {
       path: "/v1/subscriptions/"
     });
   }
+  /**
+   * Cancel a subscription. Provide exactly one of `cancelImmediately`,
+   * `cancelAtPeriodEnd`, or `cancelAt` — timing is explicit at the API
+   * boundary. Enforced both at the type level via the
+   * {@link SubscriptionCancelParams} discriminated union and at the server
+   * via zod. Cancellation is one-way; a canceled Stripe subscription cannot
+   * be un-canceled.
+   *
+   * @example
+   * await client.subscriptions.cancel(id, { cancelImmediately: true });
+   * await client.subscriptions.cancel(id, { cancelAtPeriodEnd: true, sendCancellationEmail: true });
+   * await client.subscriptions.cancel(id, { cancelAt: '2026-12-31T23:59:59.000Z' });
+   */
+  async cancel(subscriptionId, params) {
+    return this.client.request({
+      method: "POST",
+      path: `/v1/subscriptions/${subscriptionId}/cancel`,
+      body: params
+    });
+  }
+};
+
+// src/resources/subscription-payments/subscription-payments.ts
+var SubscriptionPaymentResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Retrieve a single subscription payment by ID — one charge within a
+   * subscription's billing cycle, not the subscription itself. For every
+   * payment on a subscription, use `list({ subscriptionId })`.
+   *
+   * @example
+   * const { data: payment } = await client.subscriptionPayments.get(paymentId);
+   */
+  async get(subscriptionPaymentId) {
+    if (!subscriptionPaymentId) {
+      throw new Error("Subscription payment ID is required");
+    }
+    return this.client.request({
+      method: "GET",
+      path: `/v1/subscription-payments/${subscriptionPaymentId}`
+    });
+  }
+  async list(args = {}) {
+    const query = {
+      limit: args.limit?.toString(),
+      starting_after: args.starting_after,
+      ending_before: args.ending_before,
+      subscriptionId: args.subscriptionId,
+      customerId: args.customerId,
+      pageId: args.pageId,
+      paymentStatus: args.paymentStatus,
+      paid: args.paid,
+      refunded: args.refunded,
+      billingReason: args.billingReason,
+      createdAfter: args.createdAfter,
+      createdBefore: args.createdBefore
+    };
+    return this.client.request({
+      method: "GET",
+      query,
+      path: "/v1/subscription-payments/"
+    });
+  }
 };
 
 // src/resources/bookings/bookings.ts
@@ -268,14 +525,55 @@ var BookingResource = class {
   constructor(client) {
     this.client = client;
   }
+  /**
+   * Retrieve a single booking by ID. Only event bookings are returned —
+   * a checkout charge is a payment, and 404s here.
+   *
+   * @example
+   * const { data: booking } = await client.bookings.get(bookingId);
+   */
+  async get(bookingId) {
+    if (!bookingId) {
+      throw new Error("Booking ID is required");
+    }
+    return this.client.request({
+      method: "GET",
+      path: `/v1/bookings/${bookingId}`
+    });
+  }
+  /**
+   * Download the booking's ticket PDF (every ticket in the booking) as raw
+   * bytes. The response reflects the current tickets, so attendee updates
+   * appear on the next download. Throws NotFoundError when no PDF exists,
+   * e.g. for unpaid or abandoned bookings.
+   *
+   * @example
+   * const pdf = await client.bookings.downloadTicketPdf(bookingId);
+   * fs.writeFileSync('tickets.pdf', Buffer.from(pdf));
+   */
+  async downloadTicketPdf(bookingId) {
+    if (!bookingId) {
+      throw new Error("Booking ID is required");
+    }
+    return this.client.requestRaw({
+      method: "GET",
+      path: `/v1/bookings/${bookingId}/ticket-pdf`
+    });
+  }
   async list(args = {}) {
     const query = {
       search: args.search,
+      status: args.status,
+      pageId: args.pageId,
+      customerId: args.customerId,
+      orderId: args.orderId,
+      couponCode: args.couponCode,
+      createdAfter: args.createdAfter,
+      createdBefore: args.createdBefore,
+      abandonmentStatus: args.abandonmentStatus,
       limit: args.limit?.toString(),
       starting_after: args.starting_after,
-      ending_before: args.ending_before,
-      status: args.status,
-      pageId: args.pageId
+      ending_before: args.ending_before
     };
     return this.client.request({
       method: "GET",
@@ -285,21 +583,869 @@ var BookingResource = class {
   }
 };
 
+// src/resources/tickets/tickets.ts
+var TicketResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(args = {}) {
+    const query = {
+      pageId: args.pageId,
+      bookingId: args.bookingId,
+      orderId: args.orderId,
+      customerId: args.customerId,
+      ticketTypeId: args.ticketTypeId,
+      status: args.status,
+      checkInStatus: args.checkInStatus,
+      createdAfter: args.createdAfter,
+      createdBefore: args.createdBefore,
+      search: args.search,
+      limit: args.limit?.toString(),
+      starting_after: args.starting_after,
+      ending_before: args.ending_before
+    };
+    return this.client.request({
+      method: "GET",
+      query,
+      path: "/v1/tickets/"
+    });
+  }
+  async update(ticketId, params) {
+    if (!ticketId) {
+      throw new Error("Ticket ID is required");
+    }
+    const body = {};
+    if (params.attendeeName !== void 0) {
+      body.attendeeName = params.attendeeName;
+    }
+    if (params.attendeeEmail !== void 0) {
+      body.attendeeEmail = params.attendeeEmail;
+    }
+    if (params.metadata !== void 0) {
+      body.metadata = params.metadata;
+    }
+    return this.client.request({
+      method: "PATCH",
+      path: `/v1/tickets/${ticketId}`,
+      body
+    });
+  }
+  async validate(qrCode, params) {
+    const body = params || {};
+    const response = await this.client.request({
+      method: "POST",
+      path: `/v1/tickets/validate/${qrCode}`,
+      body
+    });
+    return response.data;
+  }
+};
+
+// src/resources/products/products.ts
+var ProductResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async get(productId) {
+    if (!productId) {
+      throw new Error("Product ID is required");
+    }
+    return this.client.request({
+      method: "GET",
+      path: `/v1/products/${productId}`
+    });
+  }
+  async update(productId, params) {
+    if (!productId) {
+      throw new Error("Product ID is required");
+    }
+    const body = {};
+    if (params.title !== void 0) {
+      body.title = params.title;
+    }
+    if (params.description !== void 0) {
+      body.description = params.description;
+    }
+    if (params.price !== void 0) {
+      body.price = params.price;
+    }
+    if (params.sku !== void 0) {
+      body.sku = params.sku;
+    }
+    if (params.hasUnlimitedStock !== void 0) {
+      body.hasUnlimitedStock = params.hasUnlimitedStock;
+    }
+    if (params.stock !== void 0) {
+      body.stock = params.stock;
+    }
+    if (params.taxBehavior !== void 0) {
+      body.taxBehavior = params.taxBehavior;
+    }
+    if (params.taxCode !== void 0) {
+      body.taxCode = params.taxCode;
+    }
+    if (params.imageIds !== void 0) {
+      body.imageIds = params.imageIds;
+    }
+    if (params.fileIds !== void 0) {
+      body.fileIds = params.fileIds;
+    }
+    if (params.variantsRequired !== void 0) {
+      body.variantsRequired = params.variantsRequired;
+    }
+    if (params.variants !== void 0) {
+      body.variants = params.variants;
+    }
+    if (params.discounts !== void 0) {
+      body.discounts = params.discounts;
+    }
+    if (params.limitSubscriptions !== void 0) {
+      body.limitSubscriptions = params.limitSubscriptions;
+    }
+    if (params.enableFileAccessForInactiveSubscriptions !== void 0) {
+      body.enableFileAccessForInactiveSubscriptions = params.enableFileAccessForInactiveSubscriptions;
+    }
+    if (params.generateLicenseKeys !== void 0) {
+      body.generateLicenseKeys = params.generateLicenseKeys;
+    }
+    if (params.fixedTaxRateIds !== void 0) {
+      body.fixedTaxRateIds = params.fixedTaxRateIds;
+    }
+    if (params.prices !== void 0) {
+      body.prices = params.prices;
+    }
+    if (params.defaultPriceId !== void 0) {
+      body.defaultPriceId = params.defaultPriceId;
+    }
+    return this.client.request({
+      method: "PATCH",
+      path: `/v1/products/${productId}`,
+      body
+    });
+  }
+};
+
+// src/resources/files/files.ts
+var FileResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async upload(params) {
+    if (!params.file) {
+      throw new Error("File is required");
+    }
+    if (!params.purpose) {
+      throw new Error("Purpose is required");
+    }
+    const formData = new FormData();
+    formData.append("file", params.file);
+    formData.append("purpose", params.purpose);
+    return this.client.request({
+      method: "POST",
+      path: "/v1/files/upload",
+      formData
+    });
+  }
+  async delete(fileId) {
+    if (!fileId) {
+      throw new Error("File ID is required");
+    }
+    return this.client.request({
+      method: "DELETE",
+      path: `/v1/files/${fileId}`
+    });
+  }
+  async download(fileId) {
+    if (!fileId) {
+      throw new Error("File ID is required");
+    }
+    return this.client.request({
+      method: "GET",
+      path: `/v1/files/${fileId}/download`
+    });
+  }
+};
+
+// src/resources/checkout-pages/checkout-pages.ts
+var CheckoutPageFieldsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(pageId) {
+    if (!pageId) {
+      throw new Error("Page ID is required");
+    }
+    return this.client.request({
+      method: "GET",
+      path: `/v1/checkout-pages/${pageId}/fields`
+    });
+  }
+  async create(pageId, params) {
+    if (!pageId) {
+      throw new Error("Page ID is required");
+    }
+    return this.client.request({
+      method: "POST",
+      path: `/v1/checkout-pages/${pageId}/fields`,
+      body: params
+    });
+  }
+  async get(pageId, fieldId) {
+    if (!pageId) {
+      throw new Error("Page ID is required");
+    }
+    if (!fieldId) {
+      throw new Error("Field ID is required");
+    }
+    return this.client.request({
+      method: "GET",
+      path: `/v1/checkout-pages/${pageId}/fields/${fieldId}`
+    });
+  }
+  async update(pageId, fieldId, params) {
+    if (!pageId) {
+      throw new Error("Page ID is required");
+    }
+    if (!fieldId) {
+      throw new Error("Field ID is required");
+    }
+    return this.client.request({
+      method: "PATCH",
+      path: `/v1/checkout-pages/${pageId}/fields/${fieldId}`,
+      body: params
+    });
+  }
+  async delete(pageId, fieldId) {
+    if (!pageId) {
+      throw new Error("Page ID is required");
+    }
+    if (!fieldId) {
+      throw new Error("Field ID is required");
+    }
+    const response = await this.client.request({
+      method: "DELETE",
+      path: `/v1/checkout-pages/${pageId}/fields/${fieldId}`
+    });
+    return response;
+  }
+};
+var CheckoutPagesResource = class {
+  fields;
+  client;
+  constructor(client) {
+    this.client = client;
+    this.fields = new CheckoutPageFieldsResource(client);
+  }
+  async list(args = {}) {
+    const query = {
+      limit: args.limit?.toString(),
+      starting_after: args.starting_after,
+      ending_before: args.ending_before,
+      status: args.status,
+      search: args.search
+    };
+    return this.client.request({
+      method: "GET",
+      path: "/v1/checkout-pages/",
+      query
+    });
+  }
+  async create(params) {
+    return this.client.request({
+      method: "POST",
+      path: "/v1/checkout-pages/",
+      body: params
+    });
+  }
+  async get(pageId) {
+    if (!pageId) {
+      throw new Error("Page ID is required");
+    }
+    return this.client.request({
+      method: "GET",
+      path: `/v1/checkout-pages/${pageId}`
+    });
+  }
+  async update(pageId, params) {
+    if (!pageId) {
+      throw new Error("Page ID is required");
+    }
+    return this.client.request({
+      method: "PATCH",
+      path: `/v1/checkout-pages/${pageId}`,
+      body: params
+    });
+  }
+  async delete(pageId) {
+    if (!pageId) {
+      throw new Error("Page ID is required");
+    }
+    return this.client.request({
+      method: "DELETE",
+      path: `/v1/checkout-pages/${pageId}`
+    });
+  }
+};
+
+// src/resources/events/events.ts
+var EventFieldsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(pageId) {
+    if (!pageId) {
+      throw new Error("Page ID is required");
+    }
+    return this.client.request({
+      method: "GET",
+      path: `/v1/events/${pageId}/fields`
+    });
+  }
+  async create(pageId, params) {
+    if (!pageId) {
+      throw new Error("Page ID is required");
+    }
+    return this.client.request({
+      method: "POST",
+      path: `/v1/events/${pageId}/fields`,
+      body: params
+    });
+  }
+  async get(pageId, fieldId) {
+    if (!pageId) {
+      throw new Error("Page ID is required");
+    }
+    if (!fieldId) {
+      throw new Error("Field ID is required");
+    }
+    return this.client.request({
+      method: "GET",
+      path: `/v1/events/${pageId}/fields/${fieldId}`
+    });
+  }
+  async update(pageId, fieldId, params) {
+    if (!pageId) {
+      throw new Error("Page ID is required");
+    }
+    if (!fieldId) {
+      throw new Error("Field ID is required");
+    }
+    return this.client.request({
+      method: "PATCH",
+      path: `/v1/events/${pageId}/fields/${fieldId}`,
+      body: params
+    });
+  }
+  async delete(pageId, fieldId) {
+    if (!pageId) {
+      throw new Error("Page ID is required");
+    }
+    if (!fieldId) {
+      throw new Error("Field ID is required");
+    }
+    return this.client.request({
+      method: "DELETE",
+      path: `/v1/events/${pageId}/fields/${fieldId}`
+    });
+  }
+};
+var EventTicketTypesResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(pageId, ticketGroupId) {
+    if (!pageId) {
+      throw new Error("Page ID is required");
+    }
+    if (!ticketGroupId) {
+      throw new Error("Ticket group ID is required");
+    }
+    return this.client.request({
+      method: "GET",
+      path: `/v1/events/${pageId}/ticket-groups/${ticketGroupId}/ticket-types`
+    });
+  }
+  async create(pageId, ticketGroupId, params) {
+    if (!pageId) {
+      throw new Error("Page ID is required");
+    }
+    if (!ticketGroupId) {
+      throw new Error("Ticket group ID is required");
+    }
+    return this.client.request({
+      method: "POST",
+      path: `/v1/events/${pageId}/ticket-groups/${ticketGroupId}/ticket-types`,
+      body: params
+    });
+  }
+  async get(pageId, ticketGroupId, ticketTypeId) {
+    if (!pageId) {
+      throw new Error("Page ID is required");
+    }
+    if (!ticketGroupId) {
+      throw new Error("Ticket group ID is required");
+    }
+    if (!ticketTypeId) {
+      throw new Error("Ticket type ID is required");
+    }
+    return this.client.request({
+      method: "GET",
+      path: `/v1/events/${pageId}/ticket-groups/${ticketGroupId}/ticket-types/${ticketTypeId}`
+    });
+  }
+  async update(pageId, ticketGroupId, ticketTypeId, params) {
+    if (!pageId) {
+      throw new Error("Page ID is required");
+    }
+    if (!ticketGroupId) {
+      throw new Error("Ticket group ID is required");
+    }
+    if (!ticketTypeId) {
+      throw new Error("Ticket type ID is required");
+    }
+    return this.client.request({
+      method: "PATCH",
+      path: `/v1/events/${pageId}/ticket-groups/${ticketGroupId}/ticket-types/${ticketTypeId}`,
+      body: params
+    });
+  }
+  async delete(pageId, ticketGroupId, ticketTypeId) {
+    if (!pageId) {
+      throw new Error("Page ID is required");
+    }
+    if (!ticketGroupId) {
+      throw new Error("Ticket group ID is required");
+    }
+    if (!ticketTypeId) {
+      throw new Error("Ticket type ID is required");
+    }
+    return this.client.request({
+      method: "DELETE",
+      path: `/v1/events/${pageId}/ticket-groups/${ticketGroupId}/ticket-types/${ticketTypeId}`
+    });
+  }
+};
+var EventTicketGroupsResource = class {
+  constructor(client) {
+    this.client = client;
+    this.ticketTypes = new EventTicketTypesResource(client);
+  }
+  ticketTypes;
+  async list(pageId) {
+    if (!pageId) {
+      throw new Error("Page ID is required");
+    }
+    return this.client.request({
+      method: "GET",
+      path: `/v1/events/${pageId}/ticket-groups`
+    });
+  }
+  async create(pageId, params) {
+    if (!pageId) {
+      throw new Error("Page ID is required");
+    }
+    return this.client.request({
+      method: "POST",
+      path: `/v1/events/${pageId}/ticket-groups`,
+      body: params
+    });
+  }
+  async get(pageId, ticketGroupId) {
+    if (!pageId) {
+      throw new Error("Page ID is required");
+    }
+    if (!ticketGroupId) {
+      throw new Error("Ticket group ID is required");
+    }
+    return this.client.request({
+      method: "GET",
+      path: `/v1/events/${pageId}/ticket-groups/${ticketGroupId}`
+    });
+  }
+  async update(pageId, ticketGroupId, params) {
+    if (!pageId) {
+      throw new Error("Page ID is required");
+    }
+    if (!ticketGroupId) {
+      throw new Error("Ticket group ID is required");
+    }
+    return this.client.request({
+      method: "PATCH",
+      path: `/v1/events/${pageId}/ticket-groups/${ticketGroupId}`,
+      body: params
+    });
+  }
+  async delete(pageId, ticketGroupId) {
+    if (!pageId) {
+      throw new Error("Page ID is required");
+    }
+    if (!ticketGroupId) {
+      throw new Error("Ticket group ID is required");
+    }
+    return this.client.request({
+      method: "DELETE",
+      path: `/v1/events/${pageId}/ticket-groups/${ticketGroupId}`
+    });
+  }
+};
+var EventsResource = class {
+  constructor(client) {
+    this.client = client;
+    this.ticketGroups = new EventTicketGroupsResource(client);
+    this.fields = new EventFieldsResource(client);
+  }
+  ticketGroups;
+  fields;
+  async list(args = {}) {
+    const query = {
+      limit: args.limit?.toString(),
+      starting_after: args.starting_after,
+      ending_before: args.ending_before,
+      status: args.status,
+      search: args.search
+    };
+    return this.client.request({
+      method: "GET",
+      path: "/v1/events/",
+      query
+    });
+  }
+  async create(params) {
+    return this.client.request({
+      method: "POST",
+      path: "/v1/events/",
+      body: params
+    });
+  }
+  async get(pageId) {
+    if (!pageId) {
+      throw new Error("Page ID is required");
+    }
+    return this.client.request({
+      method: "GET",
+      path: `/v1/events/${pageId}`
+    });
+  }
+  async update(pageId, params) {
+    if (!pageId) {
+      throw new Error("Page ID is required");
+    }
+    return this.client.request({
+      method: "PATCH",
+      path: `/v1/events/${pageId}`,
+      body: params
+    });
+  }
+  async delete(pageId) {
+    if (!pageId) {
+      throw new Error("Page ID is required");
+    }
+    return this.client.request({
+      method: "DELETE",
+      path: `/v1/events/${pageId}`
+    });
+  }
+};
+
+// src/resources/forms/forms.ts
+var FormFieldsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(pageId) {
+    if (!pageId) {
+      throw new Error("Page ID is required");
+    }
+    return this.client.request({
+      method: "GET",
+      path: `/v1/forms/${pageId}/fields`
+    });
+  }
+  async create(pageId, params) {
+    if (!pageId) {
+      throw new Error("Page ID is required");
+    }
+    return this.client.request({
+      method: "POST",
+      path: `/v1/forms/${pageId}/fields`,
+      body: params
+    });
+  }
+  async get(pageId, fieldId) {
+    if (!pageId) {
+      throw new Error("Page ID is required");
+    }
+    if (!fieldId) {
+      throw new Error("Field ID is required");
+    }
+    return this.client.request({
+      method: "GET",
+      path: `/v1/forms/${pageId}/fields/${fieldId}`
+    });
+  }
+  async update(pageId, fieldId, params) {
+    if (!pageId) {
+      throw new Error("Page ID is required");
+    }
+    if (!fieldId) {
+      throw new Error("Field ID is required");
+    }
+    return this.client.request({
+      method: "PATCH",
+      path: `/v1/forms/${pageId}/fields/${fieldId}`,
+      body: params
+    });
+  }
+  async delete(pageId, fieldId) {
+    if (!pageId) {
+      throw new Error("Page ID is required");
+    }
+    if (!fieldId) {
+      throw new Error("Field ID is required");
+    }
+    return this.client.request({
+      method: "DELETE",
+      path: `/v1/forms/${pageId}/fields/${fieldId}`
+    });
+  }
+};
+var FormsResource = class {
+  constructor(client) {
+    this.client = client;
+    this.fields = new FormFieldsResource(client);
+  }
+  fields;
+  async list(args = {}) {
+    const query = {
+      limit: args.limit?.toString(),
+      starting_after: args.starting_after,
+      ending_before: args.ending_before,
+      status: args.status,
+      search: args.search
+    };
+    return this.client.request({
+      method: "GET",
+      path: "/v1/forms/",
+      query
+    });
+  }
+  async create(params) {
+    return this.client.request({
+      method: "POST",
+      path: "/v1/forms/",
+      body: params
+    });
+  }
+  async get(pageId) {
+    if (!pageId) {
+      throw new Error("Page ID is required");
+    }
+    return this.client.request({
+      method: "GET",
+      path: `/v1/forms/${pageId}`
+    });
+  }
+  async update(pageId, params) {
+    if (!pageId) {
+      throw new Error("Page ID is required");
+    }
+    return this.client.request({
+      method: "PATCH",
+      path: `/v1/forms/${pageId}`,
+      body: params
+    });
+  }
+  async delete(pageId) {
+    if (!pageId) {
+      throw new Error("Page ID is required");
+    }
+    return this.client.request({
+      method: "DELETE",
+      path: `/v1/forms/${pageId}`
+    });
+  }
+};
+
+// src/resources/submissions/submissions.ts
+var SubmissionResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async get(submissionId) {
+    if (!submissionId) {
+      throw new Error("Submission ID is required");
+    }
+    return this.client.request({
+      method: "GET",
+      path: `/v1/submissions/${submissionId}`
+    });
+  }
+  async list(args = {}) {
+    const query = {
+      search: args.search,
+      pageId: args.pageId,
+      customerId: args.customerId,
+      status: args.status,
+      createdAfter: args.createdAfter,
+      createdBefore: args.createdBefore,
+      limit: args.limit?.toString(),
+      starting_after: args.starting_after,
+      ending_before: args.ending_before
+    };
+    return this.client.request({
+      method: "GET",
+      path: "/v1/submissions/",
+      query
+    });
+  }
+};
+
+// src/resources/tax-rates/tax-rates.ts
+var TaxRateResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list() {
+    return this.client.request({
+      method: "GET",
+      path: "/v1/tax-rates/"
+    });
+  }
+  async create(params) {
+    const body = {
+      displayName: params.displayName,
+      inclusive: params.inclusive,
+      percentage: params.percentage
+    };
+    if (params.default !== void 0) {
+      body.default = params.default;
+    }
+    return this.client.request({
+      method: "POST",
+      path: "/v1/tax-rates/",
+      body
+    });
+  }
+  async update(taxRateId, params) {
+    if (!taxRateId) {
+      throw new Error("Tax rate ID is required");
+    }
+    const body = {};
+    if (params.displayName !== void 0) {
+      body.displayName = params.displayName;
+    }
+    if (params.default !== void 0) {
+      body.default = params.default;
+    }
+    return this.client.request({
+      method: "PATCH",
+      path: `/v1/tax-rates/${taxRateId}`,
+      body
+    });
+  }
+};
+
+// src/resources/webhooks/webhooks.ts
+var WebhookResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List webhook endpoints, newest first. Secrets are never returned.
+   *
+   * @example
+   * const { data, has_more } = await client.webhooks.list({ event: 'payment.paid' });
+   */
+  async list(args = {}) {
+    const query = {
+      status: args.status,
+      event: args.event,
+      limit: args.limit?.toString(),
+      starting_after: args.starting_after,
+      ending_before: args.ending_before
+    };
+    return this.client.request({
+      method: "GET",
+      path: "/v1/webhooks/",
+      query
+    });
+  }
+  /**
+   * Create a webhook endpoint. The `url` must use https.
+   *
+   * The response is the only place the signing `secret` is ever returned —
+   * store it immediately. Omit `secret` to have one generated.
+   *
+   * @example
+   * const { data: webhook } = await client.webhooks.create({
+   *   name: 'CRM sync',
+   *   url: 'https://example.com/hooks/checkoutpage',
+   *   events: ['payment.paid', 'subscription.created'],
+   * });
+   * saveSecret(webhook.secret);
+   */
+  async create(params) {
+    return this.client.request({
+      method: "POST",
+      path: "/v1/webhooks/",
+      body: params
+    });
+  }
+  /**
+   * Delete a webhook endpoint. Deliveries stop immediately; the returned
+   * object is its final state. The webhook no longer appears in `list()`,
+   * and deleting the same id again returns 404.
+   */
+  async delete(webhookId) {
+    if (!webhookId) {
+      throw new Error("Webhook ID is required");
+    }
+    return this.client.request({
+      method: "DELETE",
+      path: `/v1/webhooks/${encodeURIComponent(webhookId)}`
+    });
+  }
+};
+
 // src/index.ts
 var CheckoutPageClient = class {
+  accounts;
   customers;
   coupons;
   payments;
   subscriptions;
+  subscriptionPayments;
   bookings;
+  tickets;
+  products;
+  files;
+  checkoutPages;
+  events;
+  forms;
+  submissions;
+  taxRates;
+  invoices;
+  webhooks;
   client;
   constructor(options) {
     this.client = new CheckoutPageApiClient(options);
+    this.accounts = new AccountResource(this.client);
     this.customers = new CustomerResource(this.client);
     this.coupons = new CouponResource(this.client);
     this.payments = new PaymentResource(this.client);
     this.subscriptions = new SubscriptionResource(this.client);
+    this.subscriptionPayments = new SubscriptionPaymentResource(this.client);
     this.bookings = new BookingResource(this.client);
+    this.tickets = new TicketResource(this.client);
+    this.products = new ProductResource(this.client);
+    this.files = new FileResource(this.client);
+    this.checkoutPages = new CheckoutPagesResource(this.client);
+    this.events = new EventsResource(this.client);
+    this.forms = new FormsResource(this.client);
+    this.submissions = new SubmissionResource(this.client);
+    this.taxRates = new TaxRateResource(this.client);
+    this.invoices = new InvoiceResource(this.client);
+    this.webhooks = new WebhookResource(this.client);
   }
 };
 var createCheckoutPageClient = (options) => {