@phpsandbox/sdk 0.3.5 → 0.4.0

package/dist/index.d.ts

@@ -18,6 +18,8 @@ import { PublicationApi } from './publication/index.js';
 import { ServerApi } from './servers.js';
 import { Feedback } from './feedback.js';
 import { IntegrationApi, SandboxIntegrationApi } from './integrations/index.js';
+import { PaymentsApi, NotebookPayments } from './payments.js';
+export * from './payments.js';
 export type { Disposable } from './types.js';
 export { LspConnection } from './lsp.js';
 export { FileChangeFilter, FileChangeType, FileType } from './filesystem.js';
@@ -329,6 +331,7 @@ declare class ClientImplementation {
     readonly publications: PublicationApi;
     readonly servers: ServerApi;
     readonly integrations: IntegrationApi;
+    readonly payments: PaymentsApi;
     readonly options: PHPSandboxClientOptions;
     private readonly runtimeTransportValue;
     get runtimeTransport(): RuntimeTransport;
@@ -364,6 +367,7 @@ export declare class PHPSandbox {
     readonly publications: PublicationApi;
     readonly servers: ServerApi;
     readonly integrations: IntegrationApi;
+    readonly payments: PaymentsApi;
     private constructor();
     whoami(): Promise<Identity>;
     get runtimeTransport(): RuntimeTransport;
@@ -399,6 +403,7 @@ export declare class NotebookInstance {
     readonly config: Config;
     readonly secrets: NotebookSecrets;
     readonly integrations: SandboxIntegrationApi;
+    readonly payments: NotebookPayments;
     readonly preview: NotebookPreview;
     readonly mail: NotebookMail;
     readonly feedback: Feedback;

package/dist/index.js

@@ -31,6 +31,8 @@ import { RestRuntimeInvoker } from './runtime/rest.js';
 import { Feedback } from './feedback.js';
 import { IntegrationApi, SandboxIntegrationApi } from './integrations/index.js';
 import { authenticatedRequest } from './http.js';
+import { PaymentsApi, NotebookPayments } from './payments.js';
+export * from './payments.js';
 export { LspConnection } from './lsp.js';
 export { FileChangeFilter, FileChangeType, FileType } from './filesystem.js';
 export { notebookBuiltinServices, notebookKnownServices } from './services.js';
@@ -86,6 +88,7 @@ class ClientImplementation {
         this.notebook = new NotebookApi(this);
         this.servers = new ServerApi(this);
         this.integrations = new IntegrationApi(this);
+        this.payments = new PaymentsApi(this);
         this.options = { ...options };
         this.runtimeTransportValue = runtimeTransport;
         this.baseUrl = normalizeApiBaseUrl(url);
@@ -220,6 +223,7 @@ export class PHPSandbox {
         this.publications = client.publications;
         this.servers = client.servers;
         this.integrations = client.integrations;
+        this.payments = client.payments;
     }
     async whoami() {
         const { data } = await this.client.get('/auth/whoami');
@@ -287,6 +291,7 @@ export 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);

package/dist/payments.d.ts

@@ -0,0 +1,347 @@
+import { z } from 'zod';
+import type { Client } from './index.js';
+export declare const DEFAULT_PAYMENT_CALLBACK_PATH = "/api/phpsandbox-payments/events";
+export declare const paymentModeSchema: z.ZodEnum<{
+    test: "test";
+    live: "live";
+}>;
+export type PaymentMode = z.infer<typeof paymentModeSchema>;
+declare const accountSchema: z.ZodObject<{
+    id: z.ZodString;
+    mode: z.ZodEnum<{
+        test: "test";
+        live: "live";
+    }>;
+    chargesEnabled: z.ZodBoolean;
+    payoutsEnabled: z.ZodBoolean;
+    detailsSubmitted: z.ZodBoolean;
+    requirements: z.ZodArray<z.ZodString>;
+    disabledReason: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type PaymentAccountData = z.infer<typeof accountSchema>;
+declare const accessSchema: z.ZodObject<{
+    subscribed: z.ZodBoolean;
+    liveAllowed: z.ZodBoolean;
+    testConfigured: z.ZodBoolean;
+    liveConfigured: z.ZodBoolean;
+    feeBasisPoints: z.ZodNullable<z.ZodNumber>;
+    canRead: z.ZodBoolean;
+    canManage: z.ZodBoolean;
+    canRefund: z.ZodBoolean;
+    recoveryEndsAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type PaymentsAccess = z.infer<typeof accessSchema>;
+declare const applicationsSchema: z.ZodObject<{
+    notebookId: z.ZodString;
+    applications: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        url: z.ZodNullable<z.ZodString>;
+        healthy: z.ZodBoolean;
+        passwordProtected: z.ZodBoolean;
+        deployedAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PaymentApplicationsData = z.infer<typeof applicationsSchema>;
+declare const bindingSchema: z.ZodObject<{
+    id: z.ZodString;
+    notebookId: z.ZodString;
+    applicationId: z.ZodNullable<z.ZodString>;
+    mode: z.ZodEnum<{
+        test: "test";
+        live: "live";
+    }>;
+    revision: z.ZodNumber;
+    accountId: z.ZodString;
+    enabled: z.ZodBoolean;
+    callbackUrl: z.ZodNullable<z.ZodString>;
+    originUrl: z.ZodNullable<z.ZodString>;
+    runtimeConfigured: z.ZodBoolean;
+}, z.core.$strip>;
+export type PaymentBindingData = z.infer<typeof bindingSchema>;
+declare const priceSchema: z.ZodObject<{
+    billingInterval: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+        month: "month";
+        year: "year";
+    }>>>;
+    id: z.ZodString;
+    name: z.ZodString;
+    amount: z.ZodNumber;
+    currency: z.ZodString;
+    bindingId: z.ZodString;
+}, z.core.$strip>;
+export type PaymentPriceData = z.infer<typeof priceSchema>;
+declare const transactionSchema: z.ZodObject<{
+    subscriptionId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    periodStart: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    periodEnd: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    id: z.ZodString;
+    bindingId: z.ZodString;
+    orderId: z.ZodString;
+    priceId: z.ZodString;
+    amount: z.ZodNumber;
+    currency: z.ZodString;
+    feeAmount: z.ZodNumber;
+    revision: z.ZodNumber;
+    refundedAmount: z.ZodNumber;
+    status: z.ZodEnum<{
+        pending: "pending";
+        failed: "failed";
+        paid: "paid";
+        refunded: "refunded";
+        partially_refunded: "partially_refunded";
+    }>;
+    checkoutUrl: z.ZodNullable<z.ZodString>;
+    deliveredAt: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type PaymentTransactionData = z.infer<typeof transactionSchema>;
+declare const subscriptionSchema: z.ZodObject<{
+    id: z.ZodString;
+    bindingId: z.ZodString;
+    priceId: z.ZodString;
+    orderId: z.ZodString;
+    status: z.ZodEnum<{
+        pending: "pending";
+        incomplete: "incomplete";
+        incomplete_expired: "incomplete_expired";
+        trialing: "trialing";
+        active: "active";
+        past_due: "past_due";
+        canceled: "canceled";
+        unpaid: "unpaid";
+        paused: "paused";
+    }>;
+    billingInterval: z.ZodEnum<{
+        month: "month";
+        year: "year";
+    }>;
+    paidThrough: z.ZodNullable<z.ZodString>;
+    cancelAtPeriodEnd: z.ZodBoolean;
+    checkoutUrl: z.ZodNullable<z.ZodString>;
+    revision: z.ZodNumber;
+}, z.core.$strip>;
+export type PaymentSubscriptionData = z.infer<typeof subscriptionSchema>;
+export interface PaymentSubscriptionPortalInput {
+    returnPath: string;
+}
+declare const refundResultSchema: z.ZodObject<{
+    subscriptionId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    periodStart: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    periodEnd: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    id: z.ZodString;
+    bindingId: z.ZodString;
+    orderId: z.ZodString;
+    priceId: z.ZodString;
+    amount: z.ZodNumber;
+    currency: z.ZodString;
+    feeAmount: z.ZodNumber;
+    revision: z.ZodNumber;
+    refundedAmount: z.ZodNumber;
+    status: z.ZodEnum<{
+        pending: "pending";
+        failed: "failed";
+        paid: "paid";
+        refunded: "refunded";
+        partially_refunded: "partially_refunded";
+    }>;
+    checkoutUrl: z.ZodNullable<z.ZodString>;
+    deliveredAt: z.ZodNullable<z.ZodString>;
+    refund: z.ZodObject<{
+        id: z.ZodString;
+        amount: z.ZodNumber;
+        status: z.ZodEnum<{
+            pending: "pending";
+            failed: "failed";
+            succeeded: "succeeded";
+            canceled: "canceled";
+            requires_action: "requires_action";
+        }>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type PaymentRefundResult = z.infer<typeof refundResultSchema>;
+declare const activationSchema: z.ZodObject<{
+    revision: z.ZodNumber;
+    reviewId: z.ZodString;
+    expiresAt: z.ZodString;
+    blockers: z.ZodArray<z.ZodString>;
+    binding: z.ZodObject<{
+        id: z.ZodString;
+        notebookId: z.ZodString;
+        applicationId: z.ZodNullable<z.ZodString>;
+        mode: z.ZodEnum<{
+            test: "test";
+            live: "live";
+        }>;
+        revision: z.ZodNumber;
+        accountId: z.ZodString;
+        enabled: z.ZodBoolean;
+        callbackUrl: z.ZodNullable<z.ZodString>;
+        originUrl: z.ZodNullable<z.ZodString>;
+        runtimeConfigured: z.ZodBoolean;
+    }, z.core.$strip>;
+    account: z.ZodObject<{
+        id: z.ZodString;
+        mode: z.ZodEnum<{
+            test: "test";
+            live: "live";
+        }>;
+        chargesEnabled: z.ZodBoolean;
+        payoutsEnabled: z.ZodBoolean;
+        detailsSubmitted: z.ZodBoolean;
+        requirements: z.ZodArray<z.ZodString>;
+        disabledReason: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    feeBasisPoints: z.ZodNullable<z.ZodNumber>;
+    prices: z.ZodArray<z.ZodObject<{
+        billingInterval: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+            month: "month";
+            year: "year";
+        }>>>;
+        id: z.ZodString;
+        name: z.ZodString;
+        amount: z.ZodNumber;
+        currency: z.ZodString;
+        bindingId: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PaymentActivationReview = z.infer<typeof activationSchema>;
+export interface ConfigurePaymentsInput {
+    expectedRevision: number;
+    applicationId?: string | null;
+    callbackPath?: string;
+}
+export interface CreatePaymentPriceInput {
+    billingInterval?: 'month' | 'year';
+    requestId: string;
+    name: string;
+    amount: number;
+    currency: string;
+}
+export interface CreatePaymentCheckoutInput {
+    requestId: string;
+    orderId: string;
+    priceId: string;
+    successPath: string;
+    cancelPath: string;
+}
+export interface RefundPaymentInput {
+    requestId: string;
+    amount?: number;
+}
+export declare class PaymentsApi {
+    private readonly client;
+    readonly runtime: PaymentRuntime;
+    constructor(client: Client);
+    forNotebook(notebookId: string): NotebookPayments;
+    applications(notebookId: string): Promise<PaymentApplicationsData>;
+    access(): Promise<PaymentsAccess>;
+    accounts(): Promise<PaymentAccountData[]>;
+    createAccount(mode: PaymentMode, country?: string): Promise<PaymentAccountData>;
+    onboarding(mode: PaymentMode): Promise<{
+        url: string;
+        expiresAt: string;
+    }>;
+}
+export declare class NotebookPayments {
+    private readonly notebookId;
+    private readonly client;
+    constructor(notebookId: string, client: Client);
+    private path;
+    get(mode?: PaymentMode): Promise<PaymentBindingData | null>;
+    configure(input: ConfigurePaymentsInput, mode?: PaymentMode): Promise<PaymentBindingData>;
+    provision(mode?: PaymentMode): Promise<PaymentBindingData>;
+    prices(mode?: PaymentMode): Promise<PaymentPriceData[]>;
+    createPrice(input: CreatePaymentPriceInput, mode?: PaymentMode): Promise<PaymentPriceData>;
+    prepareActivation(mode?: PaymentMode): Promise<PaymentActivationReview>;
+    activate(reviewId: string, mode?: PaymentMode): Promise<PaymentBindingData>;
+    disable(mode?: PaymentMode): Promise<PaymentBindingData>;
+    checkout(input: CreatePaymentCheckoutInput, mode?: PaymentMode): Promise<PaymentTransactionData>;
+    subscribe(input: CreatePaymentCheckoutInput, mode?: PaymentMode): Promise<PaymentSubscriptionData>;
+    subscriptions(mode?: PaymentMode): Promise<PaymentSubscriptionData[]>;
+    subscription(id: string, mode?: PaymentMode): Promise<PaymentSubscriptionData>;
+    cancelSubscription(id: string, mode?: PaymentMode): Promise<PaymentSubscriptionData>;
+    subscriptionPortal(id: string, input: PaymentSubscriptionPortalInput, mode?: PaymentMode): Promise<{
+        url: string;
+    }>;
+    transactions(mode?: PaymentMode): Promise<PaymentTransactionData[]>;
+    refund(id: string, input: RefundPaymentInput, mode?: PaymentMode): Promise<PaymentRefundResult>;
+}
+declare const paymentEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"payment.updated">;
+    mode: z.ZodEnum<{
+        test: "test";
+        live: "live";
+    }>;
+    transaction: z.ZodObject<{
+        subscriptionId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        periodStart: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        periodEnd: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        id: z.ZodString;
+        bindingId: z.ZodString;
+        orderId: z.ZodString;
+        priceId: z.ZodString;
+        amount: z.ZodNumber;
+        currency: z.ZodString;
+        feeAmount: z.ZodNumber;
+        revision: z.ZodNumber;
+        refundedAmount: z.ZodNumber;
+        status: z.ZodEnum<{
+            pending: "pending";
+            failed: "failed";
+            paid: "paid";
+            refunded: "refunded";
+            partially_refunded: "partially_refunded";
+        }>;
+        checkoutUrl: z.ZodNullable<z.ZodString>;
+        deliveredAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"subscription.updated">;
+    mode: z.ZodEnum<{
+        test: "test";
+        live: "live";
+    }>;
+    subscription: z.ZodObject<{
+        id: z.ZodString;
+        bindingId: z.ZodString;
+        priceId: z.ZodString;
+        orderId: z.ZodString;
+        status: z.ZodEnum<{
+            pending: "pending";
+            incomplete: "incomplete";
+            incomplete_expired: "incomplete_expired";
+            trialing: "trialing";
+            active: "active";
+            past_due: "past_due";
+            canceled: "canceled";
+            unpaid: "unpaid";
+            paused: "paused";
+        }>;
+        billingInterval: z.ZodEnum<{
+            month: "month";
+            year: "year";
+        }>;
+        paidThrough: z.ZodNullable<z.ZodString>;
+        cancelAtPeriodEnd: z.ZodBoolean;
+        checkoutUrl: z.ZodNullable<z.ZodString>;
+        revision: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>], "type">;
+export type PaymentEvent = z.infer<typeof paymentEventSchema>;
+/** Verify the original bytes before parsing JSON. Use only in trusted server code. */
+export declare function verifyPaymentEvent(body: string, signature: string, token: string, mode: PaymentMode, now?: number): Promise<PaymentEvent>;
+export declare class PaymentRuntime {
+    private readonly client;
+    constructor(client: Client);
+    checkout(input: CreatePaymentCheckoutInput): Promise<PaymentTransactionData>;
+    transaction(id: string): Promise<PaymentTransactionData>;
+    subscribe(input: CreatePaymentCheckoutInput): Promise<PaymentSubscriptionData>;
+    subscription(id: string): Promise<PaymentSubscriptionData>;
+    cancelSubscription(id: string): Promise<PaymentSubscriptionData>;
+    subscriptionPortal(id: string, input: PaymentSubscriptionPortalInput): Promise<{
+        url: string;
+    }>;
+    prices(): Promise<PaymentPriceData[]>;
+}
+export {};

package/dist/payments.js

@@ -0,0 +1,256 @@
+import { z } from 'zod';
+export const DEFAULT_PAYMENT_CALLBACK_PATH = '/api/phpsandbox-payments/events';
+export const paymentModeSchema = z.enum(['test', 'live']);
+const accountSchema = z.object({
+    id: z.string(),
+    mode: paymentModeSchema,
+    chargesEnabled: z.boolean(),
+    payoutsEnabled: z.boolean(),
+    detailsSubmitted: z.boolean(),
+    requirements: z.array(z.string()),
+    disabledReason: z.string().nullable(),
+});
+const accessSchema = z.object({
+    subscribed: z.boolean(),
+    liveAllowed: z.boolean(),
+    testConfigured: z.boolean(),
+    liveConfigured: z.boolean(),
+    feeBasisPoints: z.number().int().min(0).max(10000).nullable(),
+    canRead: z.boolean(),
+    canManage: z.boolean(),
+    canRefund: z.boolean(),
+    recoveryEndsAt: z.string().nullable().default(null),
+});
+const applicationsSchema = z.object({
+    notebookId: z.string(),
+    applications: z.array(z.object({
+        id: z.string(),
+        url: z.string().nullable(),
+        healthy: z.boolean(),
+        passwordProtected: z.boolean(),
+        deployedAt: z.string().datetime().nullable(),
+    })),
+});
+const bindingSchema = z.object({
+    id: z.string(),
+    notebookId: z.string(),
+    applicationId: z.string().nullable(),
+    mode: paymentModeSchema,
+    revision: z.number().int(),
+    accountId: z.string(),
+    enabled: z.boolean(),
+    callbackUrl: z.string().nullable(),
+    originUrl: z.string().nullable(),
+    runtimeConfigured: z.boolean(),
+});
+const priceSchema = z.object({
+    billingInterval: z.enum(['month', 'year']).nullable().default(null),
+    id: z.string(),
+    name: z.string(),
+    amount: z.number().int(),
+    currency: z.string(),
+    bindingId: z.string(),
+});
+const transactionSchema = z.object({
+    subscriptionId: z.string().nullable().default(null),
+    periodStart: z.string().datetime({ offset: true }).nullable().default(null),
+    periodEnd: z.string().datetime({ offset: true }).nullable().default(null),
+    id: z.string(),
+    bindingId: z.string(),
+    orderId: z.string(),
+    priceId: z.string(),
+    amount: z.number().int(),
+    currency: z.string(),
+    feeAmount: z.number().int(),
+    revision: z.number().int(),
+    refundedAmount: z.number().int(),
+    status: z.enum(['pending', 'paid', 'failed', 'refunded', 'partially_refunded']),
+    checkoutUrl: z.string().nullable(),
+    deliveredAt: z.string().nullable(),
+});
+const subscriptionSchema = z.object({
+    id: z.string(),
+    bindingId: z.string(),
+    priceId: z.string(),
+    orderId: z.string(),
+    status: z.enum([
+        'pending',
+        'incomplete',
+        'incomplete_expired',
+        'trialing',
+        'active',
+        'past_due',
+        'canceled',
+        'unpaid',
+        'paused',
+    ]),
+    billingInterval: z.enum(['month', 'year']),
+    paidThrough: z.string().datetime({ offset: true }).nullable(),
+    cancelAtPeriodEnd: z.boolean(),
+    checkoutUrl: z.string().nullable(),
+    revision: z.number().int(),
+});
+const portalSchema = z.object({ url: z.string().url() });
+const refundResultSchema = transactionSchema.extend({
+    refund: z.object({
+        id: z.string(),
+        amount: z.number().int().positive(),
+        status: z.enum(['pending', 'succeeded', 'failed', 'canceled', 'requires_action']),
+    }),
+});
+const activationSchema = z.object({
+    revision: z.number().int(),
+    reviewId: z.string(),
+    expiresAt: z.string(),
+    blockers: z.array(z.string()),
+    binding: bindingSchema,
+    account: accountSchema,
+    feeBasisPoints: z.number().int().nullable(),
+    prices: z.array(priceSchema),
+});
+export class PaymentsApi {
+    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 z.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 z
+            .object({ url: z.string().url(), expiresAt: z.string() })
+            .parse((await this.client.post(`/platform/payments/accounts/${mode}/onboarding`, {})).data);
+    }
+}
+export class NotebookPayments {
+    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 z.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 z.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 z.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);
+    }
+}
+const paymentEventSchema = z.discriminatedUnion('type', [
+    z.object({
+        id: z.string(),
+        type: z.literal('payment.updated'),
+        mode: paymentModeSchema,
+        transaction: transactionSchema,
+    }),
+    z.object({
+        id: z.string(),
+        type: z.literal('subscription.updated'),
+        mode: paymentModeSchema,
+        subscription: subscriptionSchema,
+    }),
+]);
+/** Verify the original bytes before parsing JSON. Use only in trusted server code. */
+export async function verifyPaymentEvent(body, signature, token, mode, now = Date.now()) {
+    if (!/^hpay_[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) * 1000) > 300000 || 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;
+}
+export class PaymentRuntime {
+    constructor(client) {
+        this.client = client;
+    }
+    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 z.array(priceSchema).parse((await this.client.get('/platform/payments/runtime/prices')).data);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phpsandbox/sdk",
-  "version": "0.3.5",
+  "version": "0.4.0",
   "description": "The TypeScript SDK for PHPSandbox cloud development environments",
   "keywords": [
     "cloud",