@checkoutpage/sdk 0.1.21 → 0.1.30

package/dist/index.js

@@ -55,16 +55,68 @@ 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);
@@ -87,6 +139,25 @@ var CheckoutPageApiClient = class {
     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) {
@@ -141,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) {
@@ -168,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
@@ -188,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,
@@ -231,6 +378,22 @@ 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,
@@ -260,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,
@@ -275,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
@@ -282,6 +525,41 @@ 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,
@@ -310,6 +588,48 @@ 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({
@@ -382,9 +702,21 @@ var ProductResource = class {
     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}`,
@@ -1013,12 +1345,76 @@ var TaxRateResource = class {
   }
 };
 
+// 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;
@@ -1028,13 +1424,17 @@ var CheckoutPageClient = class {
   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);
@@ -1044,6 +1444,8 @@ var CheckoutPageClient = class {
     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) => {