@suqo/sdk 1.1.0 → 2.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.js CHANGED
@@ -24,6 +24,8 @@ var KycRequiredError = class extends SuqoError {
24
24
  if (options.kycStatus !== void 0) this.kycStatus = options.kycStatus;
25
25
  }
26
26
  };
27
+ var PermissionDeniedError = class extends SuqoError {
28
+ };
27
29
  var ValidationError = class extends SuqoError {
28
30
  constructor(message, options = {}) {
29
31
  super(message, options);
@@ -48,7 +50,20 @@ function isRecord(value) {
48
50
  return typeof value === "object" && value !== null;
49
51
  }
50
52
 
53
+ // src/utils/assertPathId.ts
54
+ function assertPathId(id, method, reserved = []) {
55
+ if (!id || id === "." || id === "..") {
56
+ throw new SuqoConfigError(`${method}() requires a non-empty id other than "." or ".."`);
57
+ }
58
+ if (reserved.includes(id)) {
59
+ throw new SuqoConfigError(`${method}() was given "${id}", which is a route name, not an id`);
60
+ }
61
+ }
62
+
51
63
  // src/errors/mapHttpError.ts
64
+ function isMessageList(body) {
65
+ return Array.isArray(body) && body.length > 0 && body.every((item) => typeof item === "string");
66
+ }
52
67
  function isDetailShaped(body) {
53
68
  return isRecord(body) && typeof body.detail === "string" && body.detail.length > 0;
54
69
  }
@@ -83,14 +98,19 @@ function mapHttpError(input) {
83
98
  case 401:
84
99
  return new AuthenticationError(messageFrom(body, fallbackMessage), base);
85
100
  case 403: {
86
- const kycStatus = isRecord(body) && typeof body.status_code === "string" ? body.status_code : void 0;
87
- const message = messageFrom(body, "KYC verification needed to perform this action.");
88
- return new KycRequiredError(message, { ...base, ...kycStatus !== void 0 ? { kycStatus } : {} });
101
+ if (isRecord(body) && typeof body.status_code === "string") {
102
+ const message = messageFrom(body, "KYC verification needed to perform this action.");
103
+ return new KycRequiredError(message, { ...base, kycStatus: body.status_code });
104
+ }
105
+ return new PermissionDeniedError(messageFrom(body, "You do not have permission to perform this action."), base);
89
106
  }
90
107
  case 400: {
91
108
  if (isDetailShaped(body)) {
92
109
  return new ValidationError(body.detail, base);
93
110
  }
111
+ if (isMessageList(body)) {
112
+ return new ValidationError(body.join(" "), { ...base, fieldErrors: {} });
113
+ }
94
114
  return new ValidationError("Validation failed.", { ...base, fieldErrors: fieldErrorsFrom(body) });
95
115
  }
96
116
  case 404:
@@ -210,6 +230,12 @@ function parseRetryAfterMs(headerValue, now = Date.now()) {
210
230
  const delta = Math.max(dateMs - now, 0);
211
231
  return Math.min(delta, MAX_RETRY_AFTER_MS);
212
232
  }
233
+ function parseRetryAfterDetailMs(body) {
234
+ if (!isRecord(body) || typeof body.detail !== "string") return void 0;
235
+ const match = /available in (\d+(?:\.\d+)?) seconds?/i.exec(body.detail);
236
+ if (!match) return void 0;
237
+ return Math.min(Number(match[1]) * 1e3, MAX_RETRY_AFTER_MS);
238
+ }
213
239
 
214
240
  // src/http/signals.ts
215
241
  function combineSignals(signals) {
@@ -274,8 +300,8 @@ var HttpClient = class {
274
300
  * send, not just `unknown`.
275
301
  */
276
302
  async request(options) {
277
- if (options.method === "GET" && options.body !== void 0) {
278
- throw new TypeError("HttpClient.request: a GET request cannot carry a body.");
303
+ if ((options.method === "GET" || options.method === "DELETE") && options.body !== void 0) {
304
+ throw new TypeError(`HttpClient.request: a ${options.method} request cannot carry a body.`);
279
305
  }
280
306
  let url;
281
307
  try {
@@ -300,7 +326,7 @@ var HttpClient = class {
300
326
  return await parseJsonBody(response);
301
327
  }
302
328
  const body = await parseJsonBody(response);
303
- const retryAfter = parseRetryAfterMs(response.headers.get("Retry-After"));
329
+ const retryAfter = parseRetryAfterMs(response.headers.get("Retry-After")) ?? (response.status === 429 ? parseRetryAfterDetailMs(body) : void 0);
304
330
  if (!isLastAttempt && retryable && isRetryableFailure({ networkError: false, status: response.status })) {
305
331
  await this.#sleepOrAbort(retryAfter ?? backoffDelayMs(attempt - 1), options.signal, timeoutMs);
306
332
  continue;
@@ -358,7 +384,7 @@ var HttpClient = class {
358
384
  if (isWrite) {
359
385
  headers["Content-Type"] = "application/json";
360
386
  }
361
- const body = options.method !== "GET" ? options.body : void 0;
387
+ const body = "body" in options ? options.body : void 0;
362
388
  const { signal, cleanup } = combineSignals([AbortSignal.timeout(timeoutMs), options.signal]);
363
389
  try {
364
390
  const init = {
@@ -428,14 +454,23 @@ function deserializeBillingPeriod(wire) {
428
454
  isCurrent: wire.is_current,
429
455
  isLimited: wire.is_limited,
430
456
  isArchived: wire.is_archived,
431
- offers: wire.offers
457
+ offers: (wire.offers ?? []).map(deserializeOffer)
458
+ };
459
+ }
460
+ function deserializeOffer(wire) {
461
+ return {
462
+ id: wire.id,
463
+ discountAmount: wire.discount_amount,
464
+ startsAt: wire.starts_at ?? null,
465
+ validUntil: wire.valid_until ?? null,
466
+ isActive: wire.is_active
432
467
  };
433
468
  }
434
469
  function deserializePlan(wire) {
435
470
  return {
436
471
  planId: wire.plan_id,
437
472
  planName: wire.plan_name,
438
- description: wire.description,
473
+ description: wire.description ?? null,
439
474
  // `openapi.yaml`'s Product schema has no `required` list at all, so `billing_periods` being
440
475
  // omitted entirely (not just an empty array) is spec-legal — `?? []` degrades to an empty
441
476
  // list instead of `.map` throwing on `undefined` (found in review, reproduced).
@@ -445,19 +480,19 @@ function deserializePlan(wire) {
445
480
  function deserializeProductVat(wire) {
446
481
  return {
447
482
  isVatActive: wire.is_vat_active,
448
- vatType: wire.vat_type,
449
- vatPercentage: wire.vat_percentage
483
+ vatType: wire.vat_type ?? null,
484
+ vatPercentage: wire.vat_percentage ?? null
450
485
  };
451
486
  }
452
487
  function deserializeProduct(wire) {
453
488
  return {
454
489
  productId: wire.product_id,
455
490
  name: wire.name,
456
- description: wire.description,
491
+ description: wire.description ?? null,
457
492
  type: wire.type,
458
493
  isActive: wire.is_active,
459
- termsAndConditions: wire.terms_and_conditions,
460
- featuresAndBenefits: wire.features_and_benefits,
494
+ termsAndConditions: wire.terms_and_conditions ?? null,
495
+ featuresAndBenefits: wire.features_and_benefits ?? null,
461
496
  // `== null` (not `=== null`) is deliberate — it catches both an explicit `null` and an
462
497
  // entirely omitted `vat` key. `openapi.yaml` has no `required` list for Product, so omitting
463
498
  // `vat` is spec-legal, and the old `=== null` check crashed on `deserializeProductVat(undefined)`
@@ -571,18 +606,26 @@ function deserializeSubscriptionCustomer(wire) {
571
606
  }
572
607
  return customer;
573
608
  }
609
+ function deserializeCheckoutSessionResponse(wire) {
610
+ return {
611
+ publicId: wire.public_id,
612
+ expiresAt: wire.expires_at,
613
+ checkoutUrl: wire.checkout_url
614
+ };
615
+ }
574
616
 
575
617
  // src/resources/subscriptions.ts
576
618
  var SUBSCRIPTIONS_PATH = "/api/v1/subscriptions";
619
+ var RENEW_PATH = "/api/v1/subscription/renew";
577
620
  function deserializeSubscriptionProduct(wire) {
578
621
  return {
579
- productId: wire.product_id,
580
- name: wire.name,
581
- planName: wire.plan_name,
582
- pbpId: wire.pbp_id,
583
- label: wire.label,
584
- price: wire.price,
585
- currency: wire.currency
622
+ productId: wire.product_id ?? null,
623
+ name: wire.name ?? null,
624
+ planName: wire.plan_name ?? null,
625
+ pbpId: wire.pbp_id ?? null,
626
+ label: wire.label ?? null,
627
+ price: wire.price ?? null,
628
+ currency: wire.currency ?? null
586
629
  };
587
630
  }
588
631
  function deserializeSubscription(wire) {
@@ -654,13 +697,28 @@ var SubscriptionsResource = class {
654
697
  });
655
698
  }
656
699
  /**
700
+ * Retrieves one of your own subscriptions by id. Built from Swagger's schema; not yet checked
701
+ * against a captured response.
702
+ */
703
+ async retrieve(id) {
704
+ assertPathId(id, "subscriptions.retrieve");
705
+ const wire = await this.#http.request({
706
+ method: "GET",
707
+ path: `${SUBSCRIPTIONS_PATH}/${encodeURIComponent(id)}`
708
+ });
709
+ return deserializeSubscription(wire);
710
+ }
711
+ /**
712
+ * **Legacy** — prefer `checkoutSessions.create()`, which takes up to ten items in one payment
713
+ * and doesn't need a full customer object. Still supported; existing integrations keep working.
714
+ *
657
715
  * Creates a subscription in `pending_checkout` state and returns a checkout URL for the buyer
658
716
  * to pay (SDK-SPEC.md §5). Redirect the buyer to `checkoutUrl`; the return is **not** proof of
659
717
  * payment — learn the real outcome via the `checkout.succeeded`/`checkout.failed` webhooks.
660
718
  *
661
- * Reuse behavior: an inactive/expired subscription for the same buyer + product + billing
662
- * period is reactivated rather than duplicated; only a currently `active` one triggers the
663
- * duplicate-subscription `ValidationError`.
719
+ * `customer.email` identifies the buyer. A buyer may hold only one live recurring subscription
720
+ * per product: a second one on any billing period of the same product throws `ValidationError`.
721
+ * To restart an inactive subscription, use `renew()` rather than creating a new one.
664
722
  *
665
723
  * Not auto-retryable — writes never retry until idempotency ships (SDK-SPEC.md §8, §12).
666
724
  */
@@ -680,11 +738,14 @@ var SubscriptionsResource = class {
680
738
  /**
681
739
  * Schedules cancellation for the end of the current billing period — **not** immediate
682
740
  * (confirmed with backend 2026-08-17; immediate cancellation is a future capability). Status
683
- * moves to `pending_cancellation`; the subscription stays active until the period ends.
741
+ * moves to `pending_cancellation`; the subscription stays active until the period ends. Calling
742
+ * it on a subscription already cancelled or pending cancellation returns it unchanged, so a
743
+ * retry by the caller is safe.
684
744
  *
685
745
  * Not auto-retryable — writes never retry until idempotency ships (SDK-SPEC.md §8, §12).
686
746
  */
687
747
  async cancel(id) {
748
+ assertPathId(id, "subscriptions.cancel");
688
749
  return this.#http.request({
689
750
  method: "POST",
690
751
  path: `${SUBSCRIPTIONS_PATH}/${encodeURIComponent(id)}/cancel`
@@ -707,18 +768,37 @@ var SubscriptionsResource = class {
707
768
  });
708
769
  }
709
770
  /**
710
- * Resumes a subscription. Confirmed public with backend (2026-08-18); the response shape
711
- * follows Swagger's `{ message }` example but — unlike Customers — isn't independently
712
- * confirmed, so treat it as likely-correct-but-unverified (docs/implementation-plan.md Ticket 4).
771
+ * Undoes a scheduled cancellation and returns the subscription to `active`. An already-active
772
+ * subscription is returned unchanged. Once a subscription is `cancelled` there is nothing to
773
+ * resume — use `renew()`.
713
774
  *
714
775
  * Not auto-retryable — writes never retry until idempotency ships (SDK-SPEC.md §8, §12).
715
776
  */
716
777
  async resume(id) {
778
+ assertPathId(id, "subscriptions.resume");
717
779
  return this.#http.request({
718
780
  method: "POST",
719
781
  path: `${SUBSCRIPTIONS_PATH}/${encodeURIComponent(id)}/resume`
720
782
  });
721
783
  }
784
+ /**
785
+ * Opens a checkout session for the next payment on one of your own subscriptions, reusing its
786
+ * customer and billing period (or partner-priced item) rather than resubmitting them — how an
787
+ * inactive subscription is restarted. Send the buyer to the returned `checkoutUrl`, and learn
788
+ * the outcome from the `checkout.*` webhooks, matched on `publicId`.
789
+ *
790
+ * A cancelled or archived subscription, or a paid one-time purchase, can't be renewed: that
791
+ * throws `ValidationError`. Not auto-retryable — writes never retry until idempotency ships
792
+ * (SDK-SPEC.md §8, §12).
793
+ */
794
+ async renew(subscriptionId) {
795
+ const wire = await this.#http.request({
796
+ method: "POST",
797
+ path: RENEW_PATH,
798
+ body: { subscription_id: subscriptionId }
799
+ });
800
+ return deserializeCheckoutSessionResponse(wire);
801
+ }
722
802
  };
723
803
 
724
804
  // src/resources/customers.ts
@@ -742,11 +822,6 @@ function serializeCustomerFields(params) {
742
822
  if (params.address !== void 0) wire.address = params.address;
743
823
  return wire;
744
824
  }
745
- function assertCustomerId(id, method) {
746
- if (!id || id === "." || id === "..") {
747
- throw new SuqoConfigError(`customers.${method}() requires a non-empty id other than "." or ".."`);
748
- }
749
- }
750
825
  var CustomersResource = class {
751
826
  #http;
752
827
  constructor(http) {
@@ -778,7 +853,7 @@ var CustomersResource = class {
778
853
  * wrong `number` type/doc claim here).
779
854
  */
780
855
  async retrieve(id) {
781
- assertCustomerId(id, "retrieve");
856
+ assertPathId(id, "customers.retrieve");
782
857
  const wire = await this.#http.request({
783
858
  method: "GET",
784
859
  path: `${CUSTOMERS_PATH}/${encodeURIComponent(id)}`
@@ -786,20 +861,24 @@ var CustomersResource = class {
786
861
  return deserializeCustomer(wire);
787
862
  }
788
863
  /**
789
- * Records a customer on the seller's account without opening a subscription. `phone` identifies
790
- * the buyer; the name, email and address are the seller's own copy and aren't shared with other
791
- * sellers.
864
+ * Records a customer on the seller's account without opening a subscription. `email` identifies
865
+ * the buyer and is required; `phone` is optional. The name and address are the seller's own copy
866
+ * and aren't shared with other sellers. Pass the returned `id` to `checkoutSessions.create()` as
867
+ * `customerId` to send the buyer straight to payment.
792
868
  *
793
- * A phone the seller already holds updates that existing customer instead of creating a second
794
- * one (the API answers `200` rather than `201`; both resolve to the `Customer` here). That makes
795
- * this call safe for the caller to retry — but, like every write, the SDK never retries it
796
- * automatically (SDK-SPEC.md §8, §12).
869
+ * An email or phone the seller already holds updates that existing customer instead of creating
870
+ * a second one (the API answers `200` rather than `201`; both resolve to the `Customer` here).
871
+ * That makes this call safe for the caller to retry — but, like every write, the SDK never
872
+ * retries it automatically (SDK-SPEC.md §8, §12).
797
873
  */
798
874
  async create(params) {
799
875
  const wire = await this.#http.request({
800
876
  method: "POST",
801
877
  path: CUSTOMERS_PATH,
802
- body: { phone: params.phone, ...serializeCustomerFields(params) }
878
+ body: {
879
+ ...serializeCustomerFields(params),
880
+ ...params.phone !== void 0 ? { phone: params.phone } : {}
881
+ }
803
882
  });
804
883
  return deserializeCustomer(wire);
805
884
  }
@@ -810,7 +889,7 @@ var CustomersResource = class {
810
889
  * Not auto-retryable — writes never retry until idempotency ships (SDK-SPEC.md §8, §12).
811
890
  */
812
891
  async update(id, params) {
813
- assertCustomerId(id, "update");
892
+ assertPathId(id, "customers.update");
814
893
  const wire = await this.#http.request({
815
894
  method: "PATCH",
816
895
  path: `${CUSTOMERS_PATH}/${encodeURIComponent(id)}`,
@@ -819,10 +898,210 @@ var CustomersResource = class {
819
898
  return deserializeCustomer(wire);
820
899
  }
821
900
  };
901
+
902
+ // src/resources/checkoutSessions.ts
903
+ var CHECKOUT_SESSIONS_PATH = "/api/v1/checkout-sessions";
904
+ function deserializeLineItem(wire) {
905
+ return {
906
+ name: wire.name,
907
+ amount: wire.amount,
908
+ pbpId: wire.pbp_id ?? null,
909
+ currency: wire.currency,
910
+ vatType: wire.vat_type ?? null,
911
+ vatPercentage: wire.vat_percentage ?? null,
912
+ discountAmount: wire.discount_amount ?? null,
913
+ intervalType: wire.interval_type,
914
+ intervalCount: wire.interval_count,
915
+ displayLabel: wire.display_label,
916
+ currentPeriodEnd: wire.current_period_end ?? null,
917
+ extendsTo: wire.extends_to ?? null,
918
+ nextPaymentDue: wire.next_payment_due ?? null,
919
+ // Each kind carries one of these and not the other, so they stay absent rather than null.
920
+ ...wire.image_urls !== void 0 ? { imageUrls: wire.image_urls } : {},
921
+ ...wire.plan_name !== void 0 ? { planName: wire.plan_name } : {}
922
+ };
923
+ }
924
+ function deserializeCheckoutSession(wire) {
925
+ return {
926
+ publicId: wire.public_id,
927
+ lineItems: (wire.line_items ?? []).map(deserializeLineItem),
928
+ customerId: wire.customer_id ?? null,
929
+ sellerDetails: {
930
+ id: wire.seller_details.id,
931
+ phone: wire.seller_details.phone,
932
+ businessLogo: wire.seller_details.business_logo ?? null,
933
+ businessName: wire.seller_details.business_name
934
+ },
935
+ returnUrl: wire.return_url,
936
+ expiresAt: wire.expires_at,
937
+ completedAt: wire.completed_at ?? null,
938
+ isExpired: wire.is_expired,
939
+ sessionType: wire.session_type ?? null
940
+ };
941
+ }
942
+ function serializeItem(item) {
943
+ if (item.pbpId !== void 0) return { pbp_id: item.pbpId };
944
+ return {
945
+ name: item.name,
946
+ amount: item.amount,
947
+ interval_type: item.intervalType,
948
+ interval_count: item.intervalCount
949
+ };
950
+ }
951
+ var CheckoutSessionsResource = class {
952
+ #http;
953
+ constructor(http) {
954
+ this.#http = http;
955
+ }
956
+ /**
957
+ * Opens a checkout session for one to ten items and returns a URL for the buyer to pay. Prices
958
+ * are snapshotted now, so a plan edited later can't change what the buyer was shown. Redirect
959
+ * the buyer to `checkoutUrl`; the return to `returnUrl` is **not** proof of payment — learn the
960
+ * outcome from `checkout.succeeded`/`checkout.failed`, matched on `publicId` (`session_id`).
961
+ *
962
+ * The API's one rate-limited endpoint: 20 sessions a minute per account. Past that it throws
963
+ * `RateLimitError` with `retryAfter` set. Never retried automatically — writes don't retry until
964
+ * idempotency ships (SDK-SPEC.md §8, §12) — so open a session when the buyer commits to paying,
965
+ * not on page load.
966
+ */
967
+ async create(params) {
968
+ const wire = await this.#http.request({
969
+ method: "POST",
970
+ path: CHECKOUT_SESSIONS_PATH,
971
+ body: {
972
+ items: params.items.map(serializeItem),
973
+ return_url: params.returnUrl,
974
+ ...params.customerId !== void 0 ? { customer_id: params.customerId } : {}
975
+ }
976
+ });
977
+ return deserializeCheckoutSessionResponse(wire);
978
+ }
979
+ /**
980
+ * Reads one of your own open sessions: its line items, customer, seller and expiry. Once paid,
981
+ * expired, unknown or someone else's, it throws `NotFoundError`.
982
+ */
983
+ async retrieve(id) {
984
+ assertPathId(id, "checkoutSessions.retrieve");
985
+ const wire = await this.#http.request({
986
+ method: "GET",
987
+ path: `${CHECKOUT_SESSIONS_PATH}/${encodeURIComponent(id)}`
988
+ });
989
+ return deserializeCheckoutSession(wire);
990
+ }
991
+ };
992
+ var WEBHOOKS_PATH = "/api/v1/webhooks";
993
+ var RESERVED_SEGMENTS = ["secret"];
994
+ function deserializeWebhook(wire) {
995
+ return {
996
+ id: wire.id,
997
+ event: wire.event,
998
+ endpointUrl: wire.endpoint_url,
999
+ isActive: wire.is_active,
1000
+ createdAt: wire.created_at
1001
+ };
1002
+ }
1003
+ function serializeWebhookWrite(params) {
1004
+ const wire = {};
1005
+ if (params.event !== void 0) wire.event = params.event;
1006
+ if (params.endpointUrl !== void 0) wire.endpoint_url = params.endpointUrl;
1007
+ if (params.isActive !== void 0) wire.is_active = params.isActive;
1008
+ return wire;
1009
+ }
822
1010
  var DEFAULT_TOLERANCE_SEC = 300;
823
1011
  var SIGNATURE_PREFIX = "sha256=";
824
1012
  var HEX_DIGEST_RE = /^[0-9a-f]{64}$/i;
825
1013
  var WebhooksResource = class {
1014
+ #http;
1015
+ constructor(http) {
1016
+ this.#http = http;
1017
+ }
1018
+ /** Every webhook registered by your account. Not paginated — the API returns them all. */
1019
+ async list() {
1020
+ const wire = await this.#http.request({ method: "GET", path: WEBHOOKS_PATH });
1021
+ return wire.map(deserializeWebhook);
1022
+ }
1023
+ /**
1024
+ * Subscribes an `https` endpoint to one event. An account holds at most one webhook per event,
1025
+ * and the endpoint must resolve only to public addresses — either failing throws
1026
+ * `ValidationError`. Not auto-retryable (SDK-SPEC.md §8, §12).
1027
+ */
1028
+ async create(params) {
1029
+ const wire = await this.#http.request({
1030
+ method: "POST",
1031
+ path: WEBHOOKS_PATH,
1032
+ body: serializeWebhookWrite(params)
1033
+ });
1034
+ return deserializeWebhook(wire);
1035
+ }
1036
+ /** Retrieves one of your own webhooks by id (`whk_…`). */
1037
+ async retrieve(id) {
1038
+ assertPathId(id, "webhooks.retrieve", RESERVED_SEGMENTS);
1039
+ const wire = await this.#http.request({
1040
+ method: "GET",
1041
+ path: `${WEBHOOKS_PATH}/${encodeURIComponent(id)}`
1042
+ });
1043
+ return deserializeWebhook(wire);
1044
+ }
1045
+ /**
1046
+ * Overwrites a webhook's event, endpoint and active flag (`PUT`). `event` and `endpointUrl` are
1047
+ * both required; to change one field on its own, use {@link WebhooksResource.update}. Not
1048
+ * auto-retryable (SDK-SPEC.md §8, §12).
1049
+ */
1050
+ async replace(id, params) {
1051
+ assertPathId(id, "webhooks.replace", RESERVED_SEGMENTS);
1052
+ const wire = await this.#http.request({
1053
+ method: "PUT",
1054
+ path: `${WEBHOOKS_PATH}/${encodeURIComponent(id)}`,
1055
+ body: serializeWebhookWrite(params)
1056
+ });
1057
+ return deserializeWebhook(wire);
1058
+ }
1059
+ /**
1060
+ * Changes only the fields you send (`PATCH`) — e.g. `{ isActive: false }` pauses deliveries
1061
+ * without deleting the webhook. Not auto-retryable (SDK-SPEC.md §8, §12).
1062
+ */
1063
+ async update(id, params) {
1064
+ assertPathId(id, "webhooks.update", RESERVED_SEGMENTS);
1065
+ const wire = await this.#http.request({
1066
+ method: "PATCH",
1067
+ path: `${WEBHOOKS_PATH}/${encodeURIComponent(id)}`,
1068
+ body: serializeWebhookWrite(params)
1069
+ });
1070
+ return deserializeWebhook(wire);
1071
+ }
1072
+ /** Removes a webhook. Past delivery records are kept for debugging. Not auto-retryable (SDK-SPEC.md §8, §12). */
1073
+ async delete(id) {
1074
+ assertPathId(id, "webhooks.delete", RESERVED_SEGMENTS);
1075
+ await this.#http.request({
1076
+ method: "DELETE",
1077
+ path: `${WEBHOOKS_PATH}/${encodeURIComponent(id)}`
1078
+ });
1079
+ }
1080
+ /**
1081
+ * Returns the account's signing secret — the `secret` to pass to {@link WebhooksResource.verify}.
1082
+ * The API creates it on the first call; it can't be rotated through the API. Treat it like a
1083
+ * password: never log it.
1084
+ */
1085
+ async retrieveSecret() {
1086
+ const wire = await this.#http.request({
1087
+ method: "GET",
1088
+ path: `${WEBHOOKS_PATH}/secret`
1089
+ });
1090
+ return { signingSecret: wire.signing_secret };
1091
+ }
1092
+ /**
1093
+ * Queues a signed test delivery to the webhook's endpoint so you can check your receiver. It
1094
+ * resolves once the job is queued; the delivery itself arrives asynchronously. Note a test
1095
+ * delivery's body differs from a real event's (fields under `data`) — use it to check
1096
+ * `verify()`, not your payload parsing. Not auto-retryable (SDK-SPEC.md §8, §12).
1097
+ */
1098
+ async testDelivery(id) {
1099
+ assertPathId(id, "webhooks.testDelivery", RESERVED_SEGMENTS);
1100
+ await this.#http.request({
1101
+ method: "POST",
1102
+ path: `${WEBHOOKS_PATH}/${encodeURIComponent(id)}/test-delivery`
1103
+ });
1104
+ }
826
1105
  /**
827
1106
  * Verifies an inbound webhook delivery's signature. Returns `false` for any failure mode —
828
1107
  * malformed signature, expired timestamp, or a genuine mismatch — never throws, so a caller
@@ -872,7 +1151,8 @@ var SuqoClient = class {
872
1151
  this.products = new ProductsResource(http);
873
1152
  this.subscriptions = new SubscriptionsResource(http);
874
1153
  this.customers = new CustomersResource(http);
875
- this.webhooks = new WebhooksResource();
1154
+ this.checkoutSessions = new CheckoutSessionsResource(http);
1155
+ this.webhooks = new WebhooksResource(http);
876
1156
  }
877
1157
  /** `"sandbox" | "live"` — inferred from the key prefix, never selected explicitly (SDK-SPEC.md §2). */
878
1158
  get environment() {
@@ -901,8 +1181,8 @@ var SuqoClient = class {
901
1181
  };
902
1182
 
903
1183
  // src/index.ts
904
- var VERSION = "1.1.0";
1184
+ var VERSION = "2.0.0";
905
1185
 
906
- export { AuthenticationError, KycRequiredError, NetworkError, NotFoundError, RateLimitError, ServerError, SubscriptionStatus, SuqoClient, SuqoConfigError, SuqoError, VERSION, ValidationError, bridgeAutoPaging, deserializePage, listAll, mapHttpError, toPageQuery };
1186
+ export { AuthenticationError, KycRequiredError, NetworkError, NotFoundError, PermissionDeniedError, RateLimitError, ServerError, SubscriptionStatus, SuqoClient, SuqoConfigError, SuqoError, VERSION, ValidationError, bridgeAutoPaging, deserializePage, listAll, mapHttpError, toPageQuery };
907
1187
  //# sourceMappingURL=index.js.map
908
1188
  //# sourceMappingURL=index.js.map