@phpsandbox/sdk 0.3.5 → 0.5.0

package/dist/payments.d.ts

@@ -0,0 +1,363 @@
+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<{
+    target: z.ZodOptional<z.ZodEnum<{
+        preview: "preview";
+        publication: "publication";
+    }>>;
+    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<{
+        target: z.ZodOptional<z.ZodEnum<{
+            preview: "preview";
+            publication: "publication";
+        }>>;
+        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 {
+    target?: 'preview' | 'publication';
+    expectedRevision: number;
+    applicationId?: string | null;
+    callbackPath?: string;
+}
+export interface CreatePaymentPriceInput {
+    billingInterval?: 'month' | 'year';
+    requestId: string;
+    name: string;
+    amount: number;
+    currency: string;
+}
+export interface CreatePaymentCheckoutInput {
+    customerId?: string;
+    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;
+    private readonly appCredential?;
+    constructor(client: Client, appCredential?: {
+        token: string;
+        mode: PaymentMode;
+    } | undefined);
+    /** Verify the phpsandbox-signature header against the configured app environment. */
+    verifyEvent(body: string, signature: string): Promise<PaymentEvent>;
+    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,265 @@
+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({
+    target: z.enum(['preview', 'publication']).optional(),
+    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|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) * 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, 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 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.5.0",
   "description": "The TypeScript SDK for PHPSandbox cloud development environments",
   "keywords": [
     "cloud",