@phpsandbox/sdk 0.3.5 → 0.5.0

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

@@ -29,14 +29,22 @@ var PHPSandbox = (() => {
   // src/index.ts
   var index_exports = {};
   __export(index_exports, {
+    AppRuntime: () => AppRuntime,
+    CustomerRuntime: () => CustomerRuntime,
+    CustomersApi: () => CustomersApi,
+    DEFAULT_PAYMENT_CALLBACK_PATH: () => DEFAULT_PAYMENT_CALLBACK_PATH,
     FileChangeFilter: () => FileChangeFilter,
     FileChangeType: () => FileChangeType,
     FileType: () => FileType,
     LspConnection: () => LspConnection,
+    NotebookCustomers: () => NotebookCustomers,
     NotebookInstance: () => NotebookInstance,
+    NotebookPayments: () => NotebookPayments,
     NotebookPublication: () => NotebookPublication,
     PHPSandbox: () => PHPSandbox,
     PHPSandboxError: () => PHPSandboxError,
+    PaymentRuntime: () => PaymentRuntime,
+    PaymentsApi: () => PaymentsApi,
     PublicationApi: () => PublicationApi,
     PublicationDomains: () => PublicationDomains,
     PublicationInstance: () => PublicationInstance,
@@ -45,10 +53,14 @@ var PHPSandbox = (() => {
     RemoteError: () => RemoteError,
     TransportError: () => TransportError,
     createPublicationStreamResponse: () => createPublicationStreamResponse,
+    customerModeSchema: () => customerModeSchema,
+    customerSchema: () => customerSchema,
     laravelCloudSetupForRepublish: () => laravelCloudSetupForRepublish,
     notebookBuiltinServices: () => notebookBuiltinServices,
     notebookKnownServices: () => notebookKnownServices,
-    readPublicationStream: () => readPublicationStream
+    paymentModeSchema: () => paymentModeSchema,
+    readPublicationStream: () => readPublicationStream,
+    verifyPaymentEvent: () => verifyPaymentEvent
   });
 
   // node_modules/zod/v4/classic/external.js
@@ -557,7 +569,7 @@ var PHPSandbox = (() => {
     parse: () => parse,
     parseAsync: () => parseAsync,
     prettifyError: () => prettifyError,
-    process: () => process,
+    process: () => process2,
     regexes: () => regexes_exports,
     registry: () => registry,
     safeDecode: () => safeDecode,
@@ -11482,7 +11494,7 @@ var PHPSandbox = (() => {
       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);
@@ -11519,7 +11531,7 @@ var PHPSandbox = (() => {
       if (parent) {
         if (!result.ref)
           result.ref = parent;
-        process(parent, ctx, params);
+        process2(parent, ctx, params);
         ctx.seen.get(parent).isParent = true;
       }
     }
@@ -11807,14 +11819,14 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   }
   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);
   };
@@ -12060,7 +12072,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     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"]
     });
@@ -12072,7 +12084,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     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]
       });
@@ -12095,7 +12107,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       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"]
       });
@@ -12104,7 +12116,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   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]
     }));
@@ -12116,11 +12128,11 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   };
   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]
     });
@@ -12137,11 +12149,11 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     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;
@@ -12181,7 +12193,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     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", "*"]
       });
@@ -12191,12 +12203,12 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       }
     } 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"]
       });
@@ -12211,7 +12223,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   };
   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;
@@ -12222,20 +12234,20 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   };
   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")
@@ -12243,7 +12255,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   };
   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;
@@ -12258,32 +12270,32 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     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;
   };
@@ -12335,7 +12347,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       const defs = {};
       for (const entry of registry2._idmap.entries()) {
         const [_, schema] = entry;
-        process(schema, ctx2);
+        process2(schema, ctx2);
       }
       const schemas = {};
       const external = {
@@ -12358,7 +12370,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       return { schemas };
     }
     const ctx = initializeContext({ ...params, processors: allProcessors });
-    process(input, ctx);
+    process2(input, ctx);
     extractDefs(ctx, input);
     return finalize(ctx, input);
   }
@@ -12416,7 +12428,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      * 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.
@@ -14565,6 +14577,466 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   // 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(),
@@ -20241,6 +20713,8 @@ ${JSON.stringify(metadata, null, 2)}` : "";
       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);
@@ -20381,6 +20855,8 @@ ${JSON.stringify(metadata, null, 2)}` : "";
       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");
@@ -20393,6 +20869,10 @@ ${JSON.stringify(metadata, null, 2)}` : "";
     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));
     }
@@ -20447,6 +20927,7 @@ ${JSON.stringify(metadata, null, 2)}` : "";
       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);
@@ -20750,6 +21231,11 @@ ${JSON.stringify(metadata, null, 2)}` : "";
       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;