@phpsandbox/sdk 0.3.5 → 0.5.0

package/dist/browser/phpsandbox-sdk.esm.js

@@ -518,7 +518,7 @@ __export(core_exports2, {
   parse: () => parse,
   parseAsync: () => parseAsync,
   prettifyError: () => prettifyError,
-  process: () => process,
+  process: () => process2,
   regexes: () => regexes_exports,
   registry: () => registry,
   safeDecode: () => safeDecode,
@@ -11443,7 +11443,7 @@ function initializeContext(params) {
     external: params?.external ?? void 0
   };
 }
-function process(schema, ctx, _params = { path: [], schemaPath: [] }) {
+function process2(schema, ctx, _params = { path: [], schemaPath: [] }) {
   var _a3;
   const def = schema._zod.def;
   const seen = ctx.seen.get(schema);
@@ -11480,7 +11480,7 @@ function process(schema, ctx, _params = { path: [], schemaPath: [] }) {
     if (parent) {
       if (!result.ref)
         result.ref = parent;
-      process(parent, ctx, params);
+      process2(parent, ctx, params);
       ctx.seen.get(parent).isParent = true;
     }
   }
@@ -11768,14 +11768,14 @@ function isTransforming(_schema, _ctx) {
 }
 var createToJSONSchemaMethod = (schema, processors = {}) => (params) => {
   const ctx = initializeContext({ ...params, processors });
-  process(schema, ctx);
+  process2(schema, ctx);
   extractDefs(ctx, schema);
   return finalize(ctx, schema);
 };
 var createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => {
   const { libraryOptions, target } = params ?? {};
   const ctx = initializeContext({ ...libraryOptions ?? {}, target, io, processors });
-  process(schema, ctx);
+  process2(schema, ctx);
   extractDefs(ctx, schema);
   return finalize(ctx, schema);
 };
@@ -12021,7 +12021,7 @@ var arrayProcessor = (schema, ctx, _json, params) => {
   if (typeof maximum === "number")
     json2.maxItems = maximum;
   json2.type = "array";
-  json2.items = process(def.element, ctx, {
+  json2.items = process2(def.element, ctx, {
     ...params,
     path: [...params.path, "items"]
   });
@@ -12033,7 +12033,7 @@ var objectProcessor = (schema, ctx, _json, params) => {
   json2.properties = {};
   const shape = def.shape;
   for (const key in shape) {
-    json2.properties[key] = process(shape[key], ctx, {
+    json2.properties[key] = process2(shape[key], ctx, {
       ...params,
       path: [...params.path, "properties", key]
     });
@@ -12056,7 +12056,7 @@ var objectProcessor = (schema, ctx, _json, params) => {
     if (ctx.io === "output")
       json2.additionalProperties = false;
   } else if (def.catchall) {
-    json2.additionalProperties = process(def.catchall, ctx, {
+    json2.additionalProperties = process2(def.catchall, ctx, {
       ...params,
       path: [...params.path, "additionalProperties"]
     });
@@ -12065,7 +12065,7 @@ var objectProcessor = (schema, ctx, _json, params) => {
 var unionProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
   const isExclusive = def.inclusive === false;
-  const options = def.options.map((x, i) => process(x, ctx, {
+  const options = def.options.map((x, i) => process2(x, ctx, {
     ...params,
     path: [...params.path, isExclusive ? "oneOf" : "anyOf", i]
   }));
@@ -12077,11 +12077,11 @@ var unionProcessor = (schema, ctx, json2, params) => {
 };
 var intersectionProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
-  const a = process(def.left, ctx, {
+  const a = process2(def.left, ctx, {
     ...params,
     path: [...params.path, "allOf", 0]
   });
-  const b = process(def.right, ctx, {
+  const b = process2(def.right, ctx, {
     ...params,
     path: [...params.path, "allOf", 1]
   });
@@ -12098,11 +12098,11 @@ var tupleProcessor = (schema, ctx, _json, params) => {
   json2.type = "array";
   const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
   const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
-  const prefixItems = def.items.map((x, i) => process(x, ctx, {
+  const prefixItems = def.items.map((x, i) => process2(x, ctx, {
     ...params,
     path: [...params.path, prefixPath, i]
   }));
-  const rest = def.rest ? process(def.rest, ctx, {
+  const rest = def.rest ? process2(def.rest, ctx, {
     ...params,
     path: [...params.path, restPath, ...ctx.target === "openapi-3.0" ? [def.items.length] : []]
   }) : null;
@@ -12142,7 +12142,7 @@ var recordProcessor = (schema, ctx, _json, params) => {
   const keyBag = keyType._zod.bag;
   const patterns = keyBag?.patterns;
   if (def.mode === "loose" && patterns && patterns.size > 0) {
-    const valueSchema = process(def.valueType, ctx, {
+    const valueSchema = process2(def.valueType, ctx, {
       ...params,
       path: [...params.path, "patternProperties", "*"]
     });
@@ -12152,12 +12152,12 @@ var recordProcessor = (schema, ctx, _json, params) => {
     }
   } else {
     if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
-      json2.propertyNames = process(def.keyType, ctx, {
+      json2.propertyNames = process2(def.keyType, ctx, {
         ...params,
         path: [...params.path, "propertyNames"]
       });
     }
-    json2.additionalProperties = process(def.valueType, ctx, {
+    json2.additionalProperties = process2(def.valueType, ctx, {
       ...params,
       path: [...params.path, "additionalProperties"]
     });
@@ -12172,7 +12172,7 @@ var recordProcessor = (schema, ctx, _json, params) => {
 };
 var nullableProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
-  const inner = process(def.innerType, ctx, params);
+  const inner = process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   if (ctx.target === "openapi-3.0") {
     seen.ref = def.innerType;
@@ -12183,20 +12183,20 @@ var nullableProcessor = (schema, ctx, json2, params) => {
 };
 var nonoptionalProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
 };
 var defaultProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   json2.default = JSON.parse(JSON.stringify(def.defaultValue));
 };
 var prefaultProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   if (ctx.io === "input")
@@ -12204,7 +12204,7 @@ var prefaultProcessor = (schema, ctx, json2, params) => {
 };
 var catchProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   let catchValue;
@@ -12219,32 +12219,32 @@ var pipeProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
   const inIsTransform = def.in._zod.traits.has("$ZodTransform");
   const innerType = ctx.io === "input" ? inIsTransform ? def.out : def.in : def.out;
-  process(innerType, ctx, params);
+  process2(innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = innerType;
 };
 var readonlyProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   json2.readOnly = true;
 };
 var promiseProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
 };
 var optionalProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
 };
 var lazyProcessor = (schema, ctx, _json, params) => {
   const innerType = schema._zod.innerType;
-  process(innerType, ctx, params);
+  process2(innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = innerType;
 };
@@ -12296,7 +12296,7 @@ function toJSONSchema(input, params) {
     const defs = {};
     for (const entry of registry2._idmap.entries()) {
       const [_, schema] = entry;
-      process(schema, ctx2);
+      process2(schema, ctx2);
     }
     const schemas = {};
     const external = {
@@ -12319,7 +12319,7 @@ function toJSONSchema(input, params) {
     return { schemas };
   }
   const ctx = initializeContext({ ...params, processors: allProcessors });
-  process(input, ctx);
+  process2(input, ctx);
   extractDefs(ctx, input);
   return finalize(ctx, input);
 }
@@ -12377,7 +12377,7 @@ var JSONSchemaGenerator = class {
    * This must be called before emit().
    */
   process(schema, _params = { path: [], schemaPath: [] }) {
-    return process(schema, this.ctx, _params);
+    return process2(schema, this.ctx, _params);
   }
   /**
    * Emit the final JSON Schema after processing.
@@ -14526,6 +14526,466 @@ function date4(params) {
 // node_modules/zod/v4/classic/external.js
 config(en_default());
 
+// src/customers.ts
+var customerModeSchema = external_exports.enum(["test", "live"]);
+var customerSchema = external_exports.object({
+  id: external_exports.string(),
+  externalId: external_exports.string(),
+  email: external_exports.string(),
+  name: external_exports.string().nullable(),
+  source: external_exports.string().nullable(),
+  marketingSubscribed: external_exports.boolean(),
+  suppressionReason: external_exports.string().nullable(),
+  activatedAt: external_exports.string().nullable(),
+  createdAt: external_exports.string().nullable()
+});
+var spaceSchema = external_exports.object({
+  id: external_exports.string(),
+  mode: customerModeSchema,
+  enabled: external_exports.boolean(),
+  senderName: external_exports.string().nullable(),
+  senderEmail: external_exports.string().nullable(),
+  replyTo: external_exports.string().nullable(),
+  senderVerified: external_exports.boolean(),
+  domainRecords: external_exports.string().nullable(),
+  provisionedAt: external_exports.string().nullable().optional(),
+  lastRequestAt: external_exports.string().nullable().optional(),
+  processedAt: external_exports.string().nullable().optional()
+});
+var journeyInputSchema = external_exports.object({
+  enabled: external_exports.boolean(),
+  subject: external_exports.string(),
+  body: external_exports.string(),
+  delayMinutes: external_exports.number(),
+  activationEvent: external_exports.string()
+});
+var journeySchema = journeyInputSchema.extend({
+  kind: external_exports.enum(["welcome", "setup", "purchase"]),
+  version: external_exports.number().int().optional(),
+  startsAt: external_exports.string().nullable().optional(),
+  draft: journeyInputSchema.nullable().optional()
+});
+var messageSchema = external_exports.object({
+  id: external_exports.string(),
+  customerId: external_exports.string().nullable(),
+  recipient: external_exports.string(),
+  subject: external_exports.string(),
+  body: external_exports.string(),
+  status: external_exports.string(),
+  error: external_exports.string().nullable(),
+  dueAt: external_exports.string().nullable().optional(),
+  attemptedAt: external_exports.string().nullable().optional(),
+  receivedAt: external_exports.string().nullable().optional(),
+  journeyKind: external_exports.enum(["welcome", "setup", "purchase"]).nullable().optional(),
+  journeyVersion: external_exports.number().int().nullable().optional(),
+  category: external_exports.enum(["marketing", "service"]).optional(),
+  from: external_exports.string().nullable().optional(),
+  replyTo: external_exports.string().nullable().optional(),
+  renderedText: external_exports.string().nullable().optional(),
+  unsubscribeUrl: external_exports.string().nullable().optional(),
+  createdAt: external_exports.string().nullable()
+});
+var overviewSchema = external_exports.object({
+  space: spaceSchema.nullable(),
+  customers: external_exports.array(customerSchema),
+  journeys: external_exports.array(journeySchema),
+  messages: external_exports.array(messageSchema),
+  total: external_exports.number(),
+  messageTotal: external_exports.number().optional(),
+  events: external_exports.array(external_exports.string()).optional()
+});
+var CustomerRuntime = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async identify(input) {
+    return customerSchema.parse((await this.client.post("/platform/customers/runtime/identify", input)).data);
+  }
+  async linkIdentity(customerId, externalId) {
+    return customerSchema.parse(
+      (await this.client.post(`/platform/customers/runtime/${encodeURIComponent(customerId)}/identities`, {
+        externalId
+      })).data
+    );
+  }
+  async get(customerId) {
+    return customerSchema.parse(
+      (await this.client.get(`/platform/customers/runtime/${encodeURIComponent(customerId)}`)).data
+    );
+  }
+  async event(customerId, input) {
+    return external_exports.object({ id: external_exports.string(), name: external_exports.string() }).parse(
+      (await this.client.post(`/platform/customers/runtime/${encodeURIComponent(customerId)}/events`, input)).data
+    );
+  }
+  async preferences(customerId, input) {
+    return customerSchema.parse(
+      (await this.client.put(`/platform/customers/runtime/${encodeURIComponent(customerId)}/preferences`, input)).data
+    );
+  }
+  async send(customerId, input) {
+    return messageSchema.parse(
+      (await this.client.post(`/platform/customers/runtime/${encodeURIComponent(customerId)}/messages`, input)).data
+    );
+  }
+};
+var CustomersApi = class {
+  constructor(client) {
+    this.client = client;
+    this.runtime = new CustomerRuntime(client);
+  }
+  forNotebook(notebookId) {
+    return new NotebookCustomers(notebookId, this.client);
+  }
+};
+var NotebookCustomers = class {
+  constructor(notebookId, client) {
+    this.notebookId = notebookId;
+    this.client = client;
+  }
+  async list(mode = "test", query = {}) {
+    return overviewSchema.parse(
+      (await this.client.get(
+        `${this.path(mode)}?${new URLSearchParams(Object.entries(query).map(([key, value]) => [key, String(value)])).toString()}`
+      )).data
+    );
+  }
+  async connect(mode = "test") {
+    return spaceSchema.parse((await this.client.put(this.path(mode), {})).data);
+  }
+  async provision(mode = "test") {
+    return spaceSchema.parse((await this.client.post(`${this.path(mode)}/provision`, {})).data);
+  }
+  async disable(mode = "test") {
+    return spaceSchema.parse((await this.client.post(`${this.path(mode)}/disable`, {})).data);
+  }
+  async resume(mode = "test") {
+    return spaceSchema.parse((await this.client.post(`${this.path(mode)}/resume`, {})).data);
+  }
+  async rotate(mode = "test") {
+    return spaceSchema.parse((await this.client.post(`${this.path(mode)}/rotate`, {})).data);
+  }
+  async sender(input, mode = "test") {
+    return spaceSchema.parse((await this.client.put(`${this.path(mode)}/sender`, input)).data);
+  }
+  async verifySender(mode = "test") {
+    return spaceSchema.parse((await this.client.post(`${this.path(mode)}/sender/verify`, {})).data);
+  }
+  async journey(kind, input, mode = "test") {
+    return journeySchema.parse((await this.client.put(`${this.path(mode)}/journeys/${kind}`, input)).data);
+  }
+  path(mode) {
+    return `/platform/customers/sandboxes/${encodeURIComponent(this.notebookId)}/${mode}`;
+  }
+};
+
+// src/payments.ts
+var DEFAULT_PAYMENT_CALLBACK_PATH = "/api/phpsandbox-payments/events";
+var paymentModeSchema = external_exports.enum(["test", "live"]);
+var accountSchema = external_exports.object({
+  id: external_exports.string(),
+  mode: paymentModeSchema,
+  chargesEnabled: external_exports.boolean(),
+  payoutsEnabled: external_exports.boolean(),
+  detailsSubmitted: external_exports.boolean(),
+  requirements: external_exports.array(external_exports.string()),
+  disabledReason: external_exports.string().nullable()
+});
+var accessSchema = external_exports.object({
+  subscribed: external_exports.boolean(),
+  liveAllowed: external_exports.boolean(),
+  testConfigured: external_exports.boolean(),
+  liveConfigured: external_exports.boolean(),
+  feeBasisPoints: external_exports.number().int().min(0).max(1e4).nullable(),
+  canRead: external_exports.boolean(),
+  canManage: external_exports.boolean(),
+  canRefund: external_exports.boolean(),
+  recoveryEndsAt: external_exports.string().nullable().default(null)
+});
+var applicationsSchema = external_exports.object({
+  notebookId: external_exports.string(),
+  applications: external_exports.array(
+    external_exports.object({
+      id: external_exports.string(),
+      url: external_exports.string().nullable(),
+      healthy: external_exports.boolean(),
+      passwordProtected: external_exports.boolean(),
+      deployedAt: external_exports.string().datetime().nullable()
+    })
+  )
+});
+var bindingSchema = external_exports.object({
+  target: external_exports.enum(["preview", "publication"]).optional(),
+  id: external_exports.string(),
+  notebookId: external_exports.string(),
+  applicationId: external_exports.string().nullable(),
+  mode: paymentModeSchema,
+  revision: external_exports.number().int(),
+  accountId: external_exports.string(),
+  enabled: external_exports.boolean(),
+  callbackUrl: external_exports.string().nullable(),
+  originUrl: external_exports.string().nullable(),
+  runtimeConfigured: external_exports.boolean()
+});
+var priceSchema = external_exports.object({
+  billingInterval: external_exports.enum(["month", "year"]).nullable().default(null),
+  id: external_exports.string(),
+  name: external_exports.string(),
+  amount: external_exports.number().int(),
+  currency: external_exports.string(),
+  bindingId: external_exports.string()
+});
+var transactionSchema = external_exports.object({
+  subscriptionId: external_exports.string().nullable().default(null),
+  periodStart: external_exports.string().datetime({ offset: true }).nullable().default(null),
+  periodEnd: external_exports.string().datetime({ offset: true }).nullable().default(null),
+  id: external_exports.string(),
+  bindingId: external_exports.string(),
+  orderId: external_exports.string(),
+  priceId: external_exports.string(),
+  amount: external_exports.number().int(),
+  currency: external_exports.string(),
+  feeAmount: external_exports.number().int(),
+  revision: external_exports.number().int(),
+  refundedAmount: external_exports.number().int(),
+  status: external_exports.enum(["pending", "paid", "failed", "refunded", "partially_refunded"]),
+  checkoutUrl: external_exports.string().nullable(),
+  deliveredAt: external_exports.string().nullable()
+});
+var subscriptionSchema = external_exports.object({
+  id: external_exports.string(),
+  bindingId: external_exports.string(),
+  priceId: external_exports.string(),
+  orderId: external_exports.string(),
+  status: external_exports.enum([
+    "pending",
+    "incomplete",
+    "incomplete_expired",
+    "trialing",
+    "active",
+    "past_due",
+    "canceled",
+    "unpaid",
+    "paused"
+  ]),
+  billingInterval: external_exports.enum(["month", "year"]),
+  paidThrough: external_exports.string().datetime({ offset: true }).nullable(),
+  cancelAtPeriodEnd: external_exports.boolean(),
+  checkoutUrl: external_exports.string().nullable(),
+  revision: external_exports.number().int()
+});
+var portalSchema = external_exports.object({ url: external_exports.string().url() });
+var refundResultSchema = transactionSchema.extend({
+  refund: external_exports.object({
+    id: external_exports.string(),
+    amount: external_exports.number().int().positive(),
+    status: external_exports.enum(["pending", "succeeded", "failed", "canceled", "requires_action"])
+  })
+});
+var activationSchema = external_exports.object({
+  revision: external_exports.number().int(),
+  reviewId: external_exports.string(),
+  expiresAt: external_exports.string(),
+  blockers: external_exports.array(external_exports.string()),
+  binding: bindingSchema,
+  account: accountSchema,
+  feeBasisPoints: external_exports.number().int().nullable(),
+  prices: external_exports.array(priceSchema)
+});
+var PaymentsApi = class {
+  constructor(client) {
+    this.client = client;
+    this.runtime = new PaymentRuntime(client);
+  }
+  forNotebook(notebookId) {
+    return new NotebookPayments(notebookId, this.client);
+  }
+  async applications(notebookId) {
+    return applicationsSchema.parse(
+      (await this.client.get(`/notebook/${encodeURIComponent(notebookId)}/payments/applications`)).data
+    );
+  }
+  async access() {
+    return accessSchema.parse((await this.client.get("/platform/payments/access")).data);
+  }
+  async accounts() {
+    return external_exports.array(accountSchema).parse((await this.client.get("/platform/payments/accounts")).data);
+  }
+  async createAccount(mode, country) {
+    return accountSchema.parse((await this.client.put(`/platform/payments/accounts/${mode}`, { country })).data);
+  }
+  async onboarding(mode) {
+    return external_exports.object({ url: external_exports.string().url(), expiresAt: external_exports.string() }).parse((await this.client.post(`/platform/payments/accounts/${mode}/onboarding`, {})).data);
+  }
+};
+var NotebookPayments = class {
+  constructor(notebookId, client) {
+    this.notebookId = notebookId;
+    this.client = client;
+  }
+  path(mode) {
+    return `/platform/payments/sandboxes/${encodeURIComponent(this.notebookId)}/${mode}`;
+  }
+  async get(mode = "test") {
+    return bindingSchema.nullable().parse((await this.client.get(this.path(mode))).data);
+  }
+  async configure(input, mode = "test") {
+    return bindingSchema.parse((await this.client.put(this.path(mode), input)).data);
+  }
+  async provision(mode = "test") {
+    return bindingSchema.parse((await this.client.post(`${this.path(mode)}/provision`, {})).data);
+  }
+  async prices(mode = "test") {
+    return external_exports.array(priceSchema).parse((await this.client.get(`${this.path(mode)}/prices`)).data);
+  }
+  async createPrice(input, mode = "test") {
+    return priceSchema.parse((await this.client.post(`${this.path(mode)}/prices`, input)).data);
+  }
+  async prepareActivation(mode = "test") {
+    return activationSchema.parse((await this.client.post(`${this.path(mode)}/activation`, {})).data);
+  }
+  async activate(reviewId, mode = "test") {
+    return bindingSchema.parse((await this.client.post(`${this.path(mode)}/activate`, { reviewId })).data);
+  }
+  async disable(mode = "test") {
+    return bindingSchema.parse((await this.client.post(`${this.path(mode)}/disable`, {})).data);
+  }
+  async checkout(input, mode = "test") {
+    return transactionSchema.parse((await this.client.post(`${this.path(mode)}/checkouts`, input)).data);
+  }
+  async subscribe(input, mode = "test") {
+    return subscriptionSchema.parse((await this.client.post(`${this.path(mode)}/subscriptions`, input)).data);
+  }
+  async subscriptions(mode = "test") {
+    return external_exports.array(subscriptionSchema).parse((await this.client.get(`${this.path(mode)}/subscriptions`)).data);
+  }
+  async subscription(id, mode = "test") {
+    return subscriptionSchema.parse(
+      (await this.client.get(`${this.path(mode)}/subscriptions/${encodeURIComponent(id)}`)).data
+    );
+  }
+  async cancelSubscription(id, mode = "test") {
+    return subscriptionSchema.parse(
+      (await this.client.post(`${this.path(mode)}/subscriptions/${encodeURIComponent(id)}/cancel`, {})).data
+    );
+  }
+  async subscriptionPortal(id, input, mode = "test") {
+    return portalSchema.parse(
+      (await this.client.post(`${this.path(mode)}/subscriptions/${encodeURIComponent(id)}/portal`, input)).data
+    );
+  }
+  async transactions(mode = "test") {
+    return external_exports.array(transactionSchema).parse((await this.client.get(`${this.path(mode)}/transactions`)).data);
+  }
+  async refund(id, input, mode = "test") {
+    return refundResultSchema.parse(
+      (await this.client.post(`${this.path(mode)}/transactions/${encodeURIComponent(id)}/refund`, input)).data
+    );
+  }
+};
+var paymentEventSchema = external_exports.discriminatedUnion("type", [
+  external_exports.object({
+    id: external_exports.string(),
+    type: external_exports.literal("payment.updated"),
+    mode: paymentModeSchema,
+    transaction: transactionSchema
+  }),
+  external_exports.object({
+    id: external_exports.string(),
+    type: external_exports.literal("subscription.updated"),
+    mode: paymentModeSchema,
+    subscription: subscriptionSchema
+  })
+]);
+async function verifyPaymentEvent(body, signature, token, mode, now = Date.now()) {
+  if (!/^(?:hpay|happ)_[a-f0-9]{64}$/.test(token)) {
+    throw new Error("Invalid application payment credential.");
+  }
+  const match = /^t=(\d+),v1=([a-f0-9]{64})$/.exec(signature);
+  const timestamp = match?.[1];
+  const digest = match?.[2];
+  if (!timestamp || !digest || Math.abs(now - Number(timestamp) * 1e3) > 3e5 || body.length > 262144) {
+    throw new Error("Invalid or expired payment signature.");
+  }
+  const encoder = new TextEncoder();
+  const key = await crypto.subtle.importKey("raw", encoder.encode(token), { name: "HMAC", hash: "SHA-256" }, false, ["verify"]);
+  const bytes = Uint8Array.from(digest.match(/../g) ?? [], (byte) => Number.parseInt(byte, 16));
+  if (!await crypto.subtle.verify("HMAC", key, bytes, encoder.encode(`${timestamp}.${body}`))) {
+    throw new Error("Invalid payment signature.");
+  }
+  const event = paymentEventSchema.parse(JSON.parse(body));
+  if (event.mode !== mode) {
+    throw new Error("Payment event mode does not match this application.");
+  }
+  return event;
+}
+var PaymentRuntime = class {
+  constructor(client, appCredential) {
+    this.client = client;
+    this.appCredential = appCredential;
+  }
+  /** Verify the phpsandbox-signature header against the configured app environment. */
+  async verifyEvent(body, signature) {
+    if (!this.appCredential) {
+      throw new Error("Initialize the server app client with PHPSandbox.app() to verify payment events.");
+    }
+    return verifyPaymentEvent(body, signature, this.appCredential.token, this.appCredential.mode);
+  }
+  async checkout(input) {
+    return transactionSchema.parse((await this.client.post("/platform/payments/runtime/checkouts", input)).data);
+  }
+  async transaction(id) {
+    return transactionSchema.parse(
+      (await this.client.get(`/platform/payments/runtime/transactions/${encodeURIComponent(id)}`)).data
+    );
+  }
+  async subscribe(input) {
+    return subscriptionSchema.parse((await this.client.post("/platform/payments/runtime/subscriptions", input)).data);
+  }
+  async subscription(id) {
+    return subscriptionSchema.parse(
+      (await this.client.get(`/platform/payments/runtime/subscriptions/${encodeURIComponent(id)}`)).data
+    );
+  }
+  async cancelSubscription(id) {
+    return subscriptionSchema.parse(
+      (await this.client.post(`/platform/payments/runtime/subscriptions/${encodeURIComponent(id)}/cancel`, {})).data
+    );
+  }
+  async subscriptionPortal(id, input) {
+    return portalSchema.parse(
+      (await this.client.post(`/platform/payments/runtime/subscriptions/${encodeURIComponent(id)}/portal`, input)).data
+    );
+  }
+  async prices() {
+    return external_exports.array(priceSchema).parse((await this.client.get("/platform/payments/runtime/prices")).data);
+  }
+};
+
+// src/app.ts
+function resolveAppConfiguration(options) {
+  if (typeof window !== "undefined" && typeof document !== "undefined") {
+    throw new Error("Application credentials must only be used on a trusted server.");
+  }
+  const environment = options.env ?? (typeof process === "undefined" ? {} : process.env);
+  const mode = options.mode ?? (environment.NODE_ENV === "production" ? "live" : "test");
+  const token = environment[`PHPSANDBOX_APP_${mode.toUpperCase()}_TOKEN`];
+  const url2 = environment.PHPSANDBOX_APP_API_URL;
+  if (!token || !/^happ_[a-f0-9]{64}$/.test(token) || !url2) {
+    throw new Error(
+      `Connect your app's ${mode === "live" ? "production" : "development"} platform environment before using Customers or Payments.`
+    );
+  }
+  return { mode, token, url: url2 };
+}
+var AppRuntime = class {
+  constructor(client, token, mode) {
+    this.mode = mode;
+    this.customers = new CustomerRuntime(client);
+    this.payments = new PaymentRuntime(client, { token, mode });
+  }
+};
+
 // src/identity.ts
 var identitySchema = external_exports.object({
   user: external_exports.object({ id: external_exports.string(), name: external_exports.string() }).nullable(),
@@ -20202,6 +20662,8 @@ var ClientImplementation = class {
     this.notebook = new NotebookApi(this);
     this.servers = new ServerApi(this);
     this.integrations = new IntegrationApi(this);
+    this.payments = new PaymentsApi(this);
+    this.customers = new CustomersApi(this);
     this.options = { ...options };
     this.runtimeTransportValue = runtimeTransport;
     this.baseUrl = normalizeApiBaseUrl(url2);
@@ -20342,6 +20804,8 @@ var PHPSandbox = class _PHPSandbox {
     this.publications = client.publications;
     this.servers = client.servers;
     this.integrations = client.integrations;
+    this.payments = client.payments;
+    this.customers = client.customers;
   }
   async whoami() {
     const { data } = await this.client.get("/auth/whoami");
@@ -20354,6 +20818,10 @@ var PHPSandbox = class _PHPSandbox {
   get runtimeTransport() {
     return this.client.runtimeTransport;
   }
+  static app(options = {}) {
+    const { token, url: url2, mode } = resolveAppConfiguration(options);
+    return new AppRuntime(new ClientImplementation(token, url2, {}, "rest"), token, mode);
+  }
   static realtime(token, url2 = "https://api.phpsandbox.io/v1", options = {}) {
     return new _PHPSandbox(new ClientImplementation(token, url2, options));
   }
@@ -20408,6 +20876,7 @@ var _NotebookInstance = class _NotebookInstance {
     this.config = new Config(this);
     this.secrets = new NotebookSecrets(client, this.data.id);
     this.integrations = new SandboxIntegrationApi(this.data.id, client);
+    this.payments = new NotebookPayments(this.data.id, client);
     this.preview = new NotebookPreview(client, this.data.id);
     this.mail = new NotebookMail(client, this.data.id);
     this.feedback = new Feedback(client, this.data.id);
@@ -20711,6 +21180,11 @@ var NotebookMail = class {
     const response = await this.client.get(`/notebook/${this.notebookId}/mail`);
     return response.data;
   }
+  /** Capture a platform-generated development email in the notebook inbox. Never sends externally. */
+  async capture(input) {
+    const response = await this.client.post(`/notebook/${this.notebookId}/mails`, input);
+    return response.data;
+  }
   async enable() {
     const response = await this.client.put(`/notebook/${this.notebookId}/mail`);
     return response.data;
@@ -20740,14 +21214,22 @@ function formatQueryString(params) {
   return query === "" ? "" : `?${query}`;
 }
 export {
+  AppRuntime,
+  CustomerRuntime,
+  CustomersApi,
+  DEFAULT_PAYMENT_CALLBACK_PATH,
   FileChangeFilter,
   FileChangeType,
   FileType,
   LspConnection,
+  NotebookCustomers,
   NotebookInstance,
+  NotebookPayments,
   NotebookPublication,
   PHPSandbox,
   PHPSandboxError,
+  PaymentRuntime,
+  PaymentsApi,
   PublicationApi,
   PublicationDomains,
   PublicationInstance,
@@ -20756,10 +21238,14 @@ export {
   RemoteError,
   TransportError,
   createPublicationStreamResponse,
+  customerModeSchema,
+  customerSchema,
   laravelCloudSetupForRepublish,
   notebookBuiltinServices,
   notebookKnownServices,
-  readPublicationStream
+  paymentModeSchema,
+  readPublicationStream,
+  verifyPaymentEvent
 };
 /*! Bundled license information: