@archildata/api-types 0.0.55 → 0.0.57

package/index.d.ts

@@ -162,6 +162,180 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/billing/subscription-preview": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Preview a purchase, plan change, or the next invoice
+         * @description With a plan, previews subscribing to it (no subscription yet), an immediate upgrade, or a downgrade at the end of the current period. Prices are resolved server-side. Without a plan, previews the current subscription's next invoice, which includes only usage already reported to the payment processor. Read-only: confirming is a separate request that charges current prices. Enterprise is sales-only.
+         */
+        post: operations["previewBillingSubscription"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/billing/subscriptions": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Subscribe to a previewed plan
+         * @description Subscribes to a plan at current prices. Pass a saved paymentMethodId or a completed setupIntentId to charge it; omit both to receive a confirmation secret for entering a new payment method. Retrying with the same operationId returns the same operation instead of starting another purchase, and an unfinished purchase for the same plan is resumed. Accounts that already have a subscription use POST /api/billing/subscription/change.
+         */
+        post: operations["createBillingSubscription"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/billing/subscription/change": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Change plan
+         * @description Applies an upgrade immediately, charging the prorated base price, or schedules a downgrade for the end of the current period. The existing subscription is updated; no second subscription is created. An upgrade whose payment needs authentication stays pending until the confirmation secret is confirmed, and is discarded by the payment processor if it is not completed in time. Retrying with the same operationId returns the same operation.
+         */
+        post: operations["changeBillingSubscription"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/billing/subscription/scheduled-change": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        /** Withdraw a scheduled plan change */
+        delete: operations["withdrawBillingScheduledChange"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/billing/subscription/cancel": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Cancel renewal at the end of the current period
+         * @description The subscription stays active until effectiveEndAt. Usage for the final period is billed on the final invoice at that time. Cancelling an already-cancelling subscription returns its current state. Subscribing again after the subscription ends uses the purchase flow.
+         */
+        post: operations["cancelBillingSubscription"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/billing/subscription/keep": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Undo a scheduled cancellation */
+        post: operations["keepBillingSubscription"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/billing/invoices/{invoiceID}/pay": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Pay an open invoice
+         * @description Charges a saved paymentMethodId, or, when it is omitted, returns the invoice's confirmation secret for entering a new payment method. Paying does not change the default payment method. When the charge needs authentication, the response carries the confirmation secret. Retrying with the same operationId does not charge twice.
+         */
+        post: operations["payBillingInvoice"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/billing/operations/{operationID}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get the state of a billing operation
+         * @description Recovers an operation after a refresh, timeout, or closed tab. The operation ID is the `id` returned by subscribe, change, or pay. State is read live from the payment processor. If the original request's response never arrived, retry that request with the same operationId instead.
+         */
+        get: operations["getBillingOperation"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/billing/credits": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get the account credit balance
+         * @description Returns the customer credit balance and one page of balance transactions, newest first, such as credit notes applied to the balance. Pass nextCursor as cursor to continue.
+         */
+        get: operations["getBillingCredits"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/activity": {
         parameters: {
             query?: never;
@@ -1040,6 +1214,15 @@ export interface components {
             /** Format: int64 */
             amountRemainingCents?: number;
             openInvoiceCurrency?: string;
+            /** Format: int64 */
+            openInvoiceDueDate?: number;
+            /**
+             * Format: int64
+             * @description When the payment processor retries automatically, if scheduled.
+             */
+            openInvoiceNextPaymentAttempt?: number;
+            /** @description Unfinished purchase or plan change awaiting payment; resume it with GET /api/billing/operations/{operationID}. */
+            pendingOperationId?: string;
         };
         BillingSummaryActions: {
             canStartCheckout: boolean;
@@ -1050,6 +1233,7 @@ export interface components {
             canCancel: boolean;
             canKeepSubscription: boolean;
             canPayOpenInvoice: boolean;
+            canWithdrawScheduledChange: boolean;
         };
         BillingSummary: {
             billingOwner: components["schemas"]["BillingOwner"];
@@ -1180,6 +1364,17 @@ export interface components {
             amountPaidCents: number;
             /** Format: int64 */
             amountRemainingCents: number;
+            /** Format: int64 */
+            dueDate?: number;
+            /**
+             * Format: int64
+             * @description When the payment processor retries automatically, if scheduled.
+             */
+            nextPaymentAttempt?: number;
+            /** Format: int64 */
+            attemptCount: number;
+            /** @description Open with an amount remaining; pay with POST /api/billing/invoices/{invoiceID}/pay. */
+            payable: boolean;
         };
         ApiResponse_BillingInvoices: {
             success: boolean;
@@ -1246,120 +1441,354 @@ export interface components {
             success: boolean;
             data: components["schemas"]["BillingInvoiceDetail"];
         };
-        ActivityEvent: {
-            accountId: string;
+        /** @description Client-generated ID for one user action, reused verbatim on retries so the action is applied at most once. */
+        BillingOperationId: string;
+        BillingPreviewRequest: {
             /**
-             * Format: uuid
-             * @description Unique, time-ordered event id.
+             * @description Omit to preview the next invoice of the current subscription.
+             * @enum {string}
              */
-            eventId: string;
-            /** @example dsk-0123456789abcdef */
-            diskId: string;
-            /** @example disk.created */
-            eventType: string;
+            plan?: "developer" | "team";
             /**
-             * @description Event severity.
-             * @example error
+             * @description Defaults to immediate for purchases and upgrades and period_end for downgrades; other combinations are rejected.
              * @enum {string}
              */
-            level: "info" | "warning" | "error";
-            /** Format: date-time */
-            createdAt: string;
-            /** @description Event-specific attributes (e.g. diskName on disk.created; containerId, outcome, exitCode, failureClass on disk.exec). */
-            details: {
-                [key: string]: string;
-            };
-        };
-        ApiResponse_ActivityList: {
-            /** @example true */
-            success: boolean;
-            data: components["schemas"]["ActivityEvent"][];
-            /** @description Set when more events remain beyond this page. Pass it back as the `cursor` query parameter to fetch the next page. Absent on the last page. */
-            nextCursor?: string;
-        };
-        ApiResponse_Empty: {
-            /** @example true */
-            success: boolean;
-        };
-        ApiResponse_Message: {
-            /** @example true */
-            success: boolean;
-            data: {
-                message?: string;
-            };
+            timing?: "immediate" | "period_end";
         };
-        /** @enum {string} */
-        SandboxState: "pending" | "running" | "pausing" | "paused" | "stopping" | "stopped" | "exited" | "failed" | "deleting" | "deleted";
-        /** @enum {string} */
-        SandboxNetworkAction: "allow" | "deny";
-        /** @description Deny targets take precedence when an address or domain matches both lists. When domain rules or drain selectors are present, TCP port 80 is restricted to HTTP/1.1 or HTTP/2 and plaintext HTTP authority is enforced, but requests matching a transformation rule are rejected unless the rule also forwards. Port 443 is relayed without TLS termination. With domain rules, it is evaluated by TLS SNI and connects to an address the runtime resolves for that name, never the address the guest dialed; names need a matching domain rule or default allow, and connections without a hostname SNI are denied. Only rules with header transformations or forwarding, and drain selectors, terminate TLS, which requires clients to trust the sandbox egress CA unless the region serves its sandbox port domain's certificate to egress and the name is exactly one label below that domain; for those, both TLS SNI and HTTP authority are evaluated, and the HTTP authority selects the upstream, any request transformations, and any request forwarding. DNS to the sandbox's configured resolvers is allowed and UDP port 443 is denied. */
-        SandboxEgressPolicy: {
-            default: components["schemas"]["SandboxNetworkAction"];
-            /** @description Allowed IPv4 addresses, CIDR ranges, exact domains, wildcard domains beginning with `*.`, or target objects with optional outbound HTTPS request transformations. A wildcard matches subdomains but not the apex domain, including when applying transformations. */
-            allow?: (string | components["schemas"]["SandboxEgressRule"])[];
-            /** @description Denied IPv4 addresses, CIDR ranges, exact domains, or wildcard domains beginning with `*.`. A wildcard matches subdomains but not the apex domain. */
-            deny?: string[];
-            /** @description Optional hosts whose HTTP(S) requests should finish before pausing, regardless of URL path. Pausing gates new matching requests and waits up to ten minutes by default for active responses, including streams, before taking a snapshot. Errors stop counting, and expiry proceeds with the snapshot. This does not limit requests during normal operation. Selectors do not grant network access. Matching uses the original request host before transformations or forwarding. Only TCP ports 80 and 443 are supported. Connections may need to be retried after resume. */
-            drain_on_pause?: string[];
+        BillingSubscribeRequest: {
+            /** @enum {string} */
+            plan: "developer" | "team";
+            operationId: components["schemas"]["BillingOperationId"];
+            /**
+             * @description The customer accepted the plan's terms.
+             * @enum {boolean}
+             */
+            consent: true;
+            paymentMethodId?: string;
+            setupIntentId?: string;
         };
-        SandboxEgressRule: {
-            /** @description Target allowed by this rule. Effective transformations and forwarding require an exact or wildcard lowercase domain. */
-            target: string;
-            transform?: components["schemas"]["SandboxEgressTransform"];
+        BillingChangeRequest: {
+            /** @enum {string} */
+            plan: "developer" | "team";
             /**
-             * Format: uri
-             * @description Absolute public HTTPS URL that receives this rule's permitted HTTP and HTTPS requests instead of their original upstream. The original path is appended to this URL, and Archil overwrites the archil-forwarded-host, archil-forwarded-scheme, archil-forwarded-port, archil-forwarded-path, and archil-sandbox-id headers with request metadata. A transform on the same rule is applied before forwarding, so the forwarded request carries the transformed headers. URLs containing credentials, a query, or a fragment are rejected. In regions that serve their sandbox port domain's certificate to egress, a target exactly one label below that domain is presented with that publicly trusted certificate, so clients that do not trust the Archil egress CA can use it as a provider base URL.
+             * @description Defaults to immediate for upgrades and period_end for downgrades; other combinations are rejected.
+             * @enum {string}
              */
-            forward_url?: string;
+            timing?: "immediate" | "period_end";
+            operationId: components["schemas"]["BillingOperationId"];
+            /** @enum {boolean} */
+            consent: true;
         };
-        /** @description Optional outbound HTTPS request transformations. An omitted or empty transform leaves the rule as an ordinary allow without request mutations. */
-        SandboxEgressTransform: {
-            /** @description Outbound HTTPS request headers to set, overwriting values supplied by the sandbox. */
-            headers?: {
-                [key: string]: string;
+        BillingCancelRequest: {
+            operationId: components["schemas"]["BillingOperationId"];
+            /** @enum {string} */
+            timing?: "period_end";
+            reason?: {
+                /** @enum {string} */
+                feedback?: "customer_service" | "low_quality" | "missing_features" | "other" | "switched_service" | "too_complex" | "too_expensive" | "unused";
+                comment?: string;
             };
         };
-        /**
-         * @description Sandbox network policy. New sandboxes on free plans receive deny-all
-         *     egress with no allowlist exceptions. Start/resume and forks retain the
-         *     stored policy. For paid accounts, egress is unrestricted when omitted.
-         */
-        SandboxNetwork: {
-            egress?: components["schemas"]["SandboxEgressPolicy"];
+        BillingKeepRequest: {
+            operationId: components["schemas"]["BillingOperationId"];
         };
-        SandboxTimeoutRequest: {
-            /** @description Seconds from now until a running sandbox expires, capped at 24 hours after its session started, and the lifetime budget for its next powered-on session. */
-            timeout?: number;
-            /** @description Seconds without a direct process connection before the sandbox pauses. Zero disables idle expiry. */
-            idle_ttl_seconds?: number;
+        BillingPayInvoiceRequest: {
+            operationId: components["schemas"]["BillingOperationId"];
+            paymentMethodId?: string;
         };
-        Sandbox: {
-            /** Format: uuid */
-            sandbox_id: string;
-            /** @description Sandbox name. */
-            name: string;
-            status: components["schemas"]["SandboxState"];
-            vcpu_count: number;
-            mem_size_mib: number;
-            /** @description Lifetime budget applied independently to each powered-on session. Expiry pauses the sandbox, preserving memory and processes for resume. Defaults to 24 hours. The timeout endpoint can move the deadline, but no session runs longer than 24 hours. */
-            max_ttl_seconds: number;
-            /** @description Seconds without a direct process connection before the sandbox pauses, preserving memory and processes for resume. Zero disables idle expiry. */
-            idle_ttl_seconds: number;
-            /** @description Maximum number of concurrently attached process sessions. Detached processes and one-shot process controls do not count. */
-            max_concurrent_execs: number;
-            /** @description OCI reference requested when the sandbox was created. Empty for a sandbox created from `image_id`. */
-            base_image: string;
-            /** @description Image digest the sandbox was created from, if any. */
-            image_digest?: string;
+        BillingRecurringPrice: {
+            /** @enum {string} */
+            component: "base" | "usage";
+            currency: string;
             /**
-             * @description Sandbox CPU architecture.
-             * @enum {string}
+             * Format: int64
+             * @description Omitted when the price is only expressible in fractional cents.
              */
-            platform?: "arm64" | "amd64";
-            /** @description Public hostnames published by enabled sandbox services. */
-            endpoints?: components["schemas"]["SandboxEndpoint"][];
-            /**
-             * @description Whether services inside the sandbox can expose ingress. Explicit API port exposure remains available regardless of this setting.
+            unitAmountCents?: number;
+            /** @description Price per unit in cents, as a decimal string. */
+            unitAmountDecimal: string;
+            interval: string;
+            /** Format: int64 */
+            intervalCount: number;
+            /** @enum {string} */
+            usageType: "licensed" | "metered";
+        };
+        BillingPreviewLine: {
+            description: string;
+            /** Format: int64 */
+            amountCents: number;
+            currency: string;
+            proration: boolean;
+            period?: components["schemas"]["BillingPeriod"];
+        };
+        BillingSubscriptionPreview: {
+            /** @enum {string} */
+            kind: "subscribe" | "upgrade" | "downgrade" | "next_invoice";
+            /** @enum {string} */
+            currentPlan: "none" | "developer" | "team" | "enterprise" | "unknown";
+            /** @enum {string} */
+            targetPlan?: "developer" | "team";
+            /** @enum {string} */
+            timing: "immediate" | "period_end";
+            /** Format: int64 */
+            effectiveAt: number;
+            currency: string;
+            /**
+             * Format: int64
+             * @description Charged if confirmed now. Usage is billed in arrears and never included.
+             */
+            dueNowCents: number;
+            /** Format: int64 */
+            subtotalCents: number;
+            /** Format: int64 */
+            totalCents: number;
+            /** Format: int64 */
+            taxCents: number;
+            /** Format: int64 */
+            discountCents: number;
+            /**
+             * Format: int64
+             * @description Account credit (negative) or debit (positive) applied to the amount due.
+             */
+            appliedBalanceCents: number;
+            lines: components["schemas"]["BillingPreviewLine"][];
+            recurringPrices: components["schemas"]["BillingRecurringPrice"][];
+            usagePeriod?: components["schemas"]["BillingPeriod"];
+            /** @description Reasons the estimate may differ from the final invoice. */
+            qualifications: ("usage_billed_in_arrears" | "usage_reported_to_date" | "tax_may_change" | "proration_time_sensitive" | "no_charge_until_effective")[];
+        };
+        ApiResponse_BillingSubscriptionPreview: {
+            success: boolean;
+            data: components["schemas"]["BillingSubscriptionPreview"];
+        };
+        BillingSubscriptionState: {
+            /** @enum {string} */
+            plan: "developer" | "team" | "enterprise" | "unknown";
+            /** @description Current subscription status, or `none`. */
+            subscriptionStatus: string;
+            billingPeriod?: components["schemas"]["BillingPeriod"];
+            /** Format: int64 */
+            scheduledCancellationAt?: number;
+            scheduledChange?: components["schemas"]["BillingScheduledChange"];
+        };
+        ApiResponse_BillingSubscriptionState: {
+            success: boolean;
+            data: components["schemas"]["BillingSubscriptionState"];
+        };
+        BillingStateConflict: components["schemas"]["ErrorResponse"] & {
+            data?: components["schemas"]["BillingSubscriptionState"];
+        };
+        BillingNextAction: {
+            /**
+             * @description confirm_payment means confirm confirmationSecret with the payment form (authentication or a new payment method); confirm_setup means confirm the setup client secret to save a payment method for usage billed later; wait means poll the operation.
+             * @enum {string}
+             */
+            type: "confirm_payment" | "confirm_setup" | "wait";
+            confirmationSecret?: string;
+            invoiceId?: string;
+        };
+        BillingOperation: {
+            /** @description Pass to GET /api/billing/operations/{operationID}. */
+            id: string;
+            /** @enum {string} */
+            type: "subscription" | "invoice_payment";
+            /** @enum {string} */
+            status: "pending" | "requires_action" | "processing" | "succeeded" | "failed" | "expired";
+            /**
+             * @description For subscription operations, whether the plan change is in effect.
+             * @enum {string}
+             */
+            state?: "applied" | "pending" | "scheduled";
+            /** @enum {string} */
+            plan?: "developer" | "team" | "enterprise" | "unknown";
+            subscriptionStatus?: string;
+            scheduledChange?: components["schemas"]["BillingScheduledChange"];
+            nextAction?: components["schemas"]["BillingNextAction"];
+            /** @description Payment succeeded but Archil has not yet applied the plan; poll again. */
+            planUpdatePending: boolean;
+            invoice?: {
+                id: string;
+                status: string;
+                currency: string;
+                /** Format: int64 */
+                amountRemainingCents: number;
+            };
+            failure?: {
+                code: string;
+                declineCode?: string;
+            };
+        };
+        ApiResponse_BillingOperation: {
+            success: boolean;
+            data: components["schemas"]["BillingOperation"];
+        };
+        BillingCancellation: {
+            /** Format: int64 */
+            effectiveEndAt: number;
+            subscription: components["schemas"]["BillingSubscriptionState"];
+            settlement: {
+                /** @enum {string} */
+                method: "final_invoice_at_period_end";
+                /** Format: int64 */
+                finalInvoiceAt: number;
+                usagePeriod?: components["schemas"]["BillingPeriod"];
+                openInvoiceId?: string;
+                /** Format: int64 */
+                amountRemainingCents?: number;
+            };
+        };
+        ApiResponse_BillingCancellation: {
+            success: boolean;
+            data: components["schemas"]["BillingCancellation"];
+        };
+        BillingBalanceTransaction: {
+            id: string;
+            type: string;
+            /**
+             * Format: int64
+             * @description Negative values credit the account.
+             */
+            amountCents: number;
+            currency: string;
+            /** Format: int64 */
+            created: number;
+            description: string;
+            invoiceId?: string;
+            creditNoteId?: string;
+        };
+        BillingCredits: {
+            currency: string;
+            /**
+             * Format: int64
+             * @description Credit applied to future invoices.
+             */
+            creditBalanceCents: number;
+            /**
+             * Format: int64
+             * @description Debit balance added to the next invoice.
+             */
+            amountOwedCents: number;
+            transactions: components["schemas"]["BillingBalanceTransaction"][];
+        };
+        ApiResponse_BillingCredits: {
+            success: boolean;
+            data: components["schemas"]["BillingCredits"];
+            nextCursor?: string;
+        };
+        ActivityEvent: {
+            accountId: string;
+            /**
+             * Format: uuid
+             * @description Unique, time-ordered event id.
+             */
+            eventId: string;
+            /** @example dsk-0123456789abcdef */
+            diskId: string;
+            /** @example disk.created */
+            eventType: string;
+            /**
+             * @description Event severity.
+             * @example error
+             * @enum {string}
+             */
+            level: "info" | "warning" | "error";
+            /** Format: date-time */
+            createdAt: string;
+            /** @description Event-specific attributes (e.g. diskName on disk.created; containerId, outcome, exitCode, failureClass on disk.exec). */
+            details: {
+                [key: string]: string;
+            };
+        };
+        ApiResponse_ActivityList: {
+            /** @example true */
+            success: boolean;
+            data: components["schemas"]["ActivityEvent"][];
+            /** @description Set when more events remain beyond this page. Pass it back as the `cursor` query parameter to fetch the next page. Absent on the last page. */
+            nextCursor?: string;
+        };
+        ApiResponse_Empty: {
+            /** @example true */
+            success: boolean;
+        };
+        ApiResponse_Message: {
+            /** @example true */
+            success: boolean;
+            data: {
+                message?: string;
+            };
+        };
+        /** @enum {string} */
+        SandboxState: "pending" | "running" | "pausing" | "paused" | "stopping" | "stopped" | "exited" | "failed" | "deleting" | "deleted";
+        /** @enum {string} */
+        SandboxNetworkAction: "allow" | "deny";
+        /** @description Denied addresses block all traffic to them, and allowed addresses admit all traffic to them regardless of domain rules. Other connections are matched by TLS SNI, or HTTP Host on any port, against domain denies, then domain allows, then the default. When domain rules are present, TCP connections without a hostname are denied; UDP follows the address rules and the default, except that UDP port 443 is denied. Header transforms, forwarding, and drain selectors apply to plaintext HTTP on any port, and to TLS on any port whose handshake offers HTTP through ALPN (or, on port 443, offers no ALPN). */
+        SandboxEgressPolicy: {
+            default: components["schemas"]["SandboxNetworkAction"];
+            /** @description Allowed IPv4 addresses, CIDR ranges, exact domains, wildcard domains beginning with `*.`, or target objects with optional outbound HTTPS request transformations. A wildcard matches subdomains but not the apex domain, including when applying transformations. */
+            allow?: (string | components["schemas"]["SandboxEgressRule"])[];
+            /** @description Denied IPv4 addresses, CIDR ranges, exact domains, or wildcard domains beginning with `*.`. A wildcard matches subdomains but not the apex domain. */
+            deny?: string[];
+            /** @description Optional hosts whose HTTP(S) requests should finish before pausing, regardless of URL path. Pausing gates new matching requests and waits up to ten minutes by default for active responses, including streams, before taking a snapshot. Errors stop counting, and expiry proceeds with the snapshot. This does not limit requests during normal operation. Selectors do not grant network access. Matching uses the original request host before transformations or forwarding. Policies with domain rules apply selectors on any port; policies with only selectors apply them on TCP ports 80 and 443. Connections may need to be retried after resume. */
+            drain_on_pause?: string[];
+        };
+        SandboxEgressRule: {
+            /** @description Target allowed by this rule. Effective transformations and forwarding require an exact or wildcard lowercase domain. */
+            target: string;
+            transform?: components["schemas"]["SandboxEgressTransform"];
+            /**
+             * Format: uri
+             * @description Absolute public HTTPS URL that receives this rule's permitted HTTP and HTTPS requests instead of their original upstream. The original path is appended to this URL, and Archil overwrites the archil-forwarded-host, archil-forwarded-scheme, archil-forwarded-port, archil-forwarded-path, and archil-sandbox-id headers with request metadata. A transform on the same rule is applied before forwarding, so the forwarded request carries the transformed headers. URLs containing credentials, a query, or a fragment are rejected. In regions that serve their sandbox port domain's certificate to egress, a target exactly one label below that domain is presented with that publicly trusted certificate, so clients that do not trust the Archil egress CA can use it as a provider base URL.
+             */
+            forward_url?: string;
+        };
+        /** @description Optional outbound HTTPS request transformations. An omitted or empty transform leaves the rule as an ordinary allow without request mutations. */
+        SandboxEgressTransform: {
+            /** @description Outbound HTTPS request headers to set, overwriting values supplied by the sandbox. */
+            headers?: {
+                [key: string]: string;
+            };
+        };
+        /**
+         * @description Sandbox network policy. New sandboxes on free plans receive deny-all
+         *     egress with no allowlist exceptions. Start/resume and forks retain the
+         *     stored policy. For paid accounts, egress is unrestricted when omitted.
+         */
+        SandboxNetwork: {
+            egress?: components["schemas"]["SandboxEgressPolicy"];
+        };
+        SandboxTimeoutRequest: {
+            /** @description Seconds from now until a running sandbox expires, capped at 24 hours after its session started, and the lifetime budget for its next powered-on session. */
+            timeout?: number;
+            /** @description Seconds without a direct process connection before the sandbox pauses. Zero disables idle expiry. */
+            idle_ttl_seconds?: number;
+        };
+        Sandbox: {
+            /** Format: uuid */
+            sandbox_id: string;
+            /** @description Sandbox name. */
+            name: string;
+            status: components["schemas"]["SandboxState"];
+            vcpu_count: number;
+            mem_size_mib: number;
+            /** @description Lifetime budget applied independently to each powered-on session. Expiry pauses the sandbox, preserving memory and processes for resume. Defaults to 24 hours. The timeout endpoint can move the deadline, but no session runs longer than 24 hours. */
+            max_ttl_seconds: number;
+            /** @description Seconds without a direct process connection before the sandbox pauses, preserving memory and processes for resume. Zero disables idle expiry. */
+            idle_ttl_seconds: number;
+            /** @description Maximum number of concurrently attached process sessions. Detached processes and one-shot process controls do not count. */
+            max_concurrent_execs: number;
+            /** @description OCI reference requested when the sandbox was created. Empty for a sandbox created from `image_id`. */
+            base_image: string;
+            /** @description Image digest the sandbox was created from, if any. */
+            image_digest?: string;
+            /**
+             * @description Sandbox CPU architecture.
+             * @enum {string}
+             */
+            platform?: "arm64" | "amd64";
+            /** @description Public hostnames published by enabled sandbox services. */
+            endpoints?: components["schemas"]["SandboxEndpoint"][];
+            /**
+             * @description Whether services inside the sandbox can expose ingress. Explicit API port exposure remains available regardless of this setting.
              * @default false
              */
             enable_service_ingress: boolean;
@@ -2855,6 +3284,328 @@ export interface operations {
             502: components["responses"]["InternalError"];
         };
     };
+    previewBillingSubscription: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": components["schemas"]["BillingPreviewRequest"];
+            };
+        };
+        responses: {
+            /** @description Previewed amounts, prices, and timing */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiResponse_BillingSubscriptionPreview"];
+                };
+            };
+            400: components["responses"]["ValidationError"];
+            401: components["responses"]["Unauthorized"];
+            /** @description Billing is not served by this region (`billing_unavailable`) */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description The requested change does not apply to the current subscription, with the current state in data (`already_on_plan`, `change_not_allowed`, `sales_managed_plan`, `no_subscription`, `multiple_subscriptions`, `managed_billing`) */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["BillingStateConflict"];
+                };
+            };
+            502: components["responses"]["InternalError"];
+        };
+    };
+    createBillingSubscription: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["BillingSubscribeRequest"];
+            };
+        };
+        responses: {
+            /** @description Purchase operation state */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiResponse_BillingOperation"];
+                };
+            };
+            400: components["responses"]["ValidationError"];
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            /** @description The account already has a subscription (`already_subscribed`), the operationId was used for a different request (`operation_conflict`), or the setup is incomplete (`setup_incomplete`); the current state is in data */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["BillingStateConflict"];
+                };
+            };
+            502: components["responses"]["InternalError"];
+        };
+    };
+    changeBillingSubscription: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["BillingChangeRequest"];
+            };
+        };
+        responses: {
+            /** @description Plan change operation state */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiResponse_BillingOperation"];
+                };
+            };
+            400: components["responses"]["ValidationError"];
+            401: components["responses"]["Unauthorized"];
+            /** @description The subscription cannot change plan now (`already_on_plan`, `change_not_allowed`, `sales_managed_plan`, `no_subscription`), or the operationId was used for a different request (`operation_conflict`); the current state is in data */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["BillingStateConflict"];
+                };
+            };
+            502: components["responses"]["InternalError"];
+        };
+    };
+    withdrawBillingScheduledChange: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Remaining plan and schedule */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiResponse_BillingSubscriptionState"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            /** @description No scheduled change remains, for example because it already took effect (`no_scheduled_change`), or the schedule was not created from the console (`schedule_not_self_serve`); the current state is in data */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["BillingStateConflict"];
+                };
+            };
+            502: components["responses"]["InternalError"];
+        };
+    };
+    cancelBillingSubscription: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["BillingCancelRequest"];
+            };
+        };
+        responses: {
+            /** @description Cancellation and final settlement state */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiResponse_BillingCancellation"];
+                };
+            };
+            400: components["responses"]["ValidationError"];
+            401: components["responses"]["Unauthorized"];
+            /** @description The subscription already ended (`subscription_ended`), a plan change is scheduled (`scheduled_change_pending`), or the subscription is managed by a schedule (`schedule_managed`); the current state is in data */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["BillingStateConflict"];
+                };
+            };
+            502: components["responses"]["InternalError"];
+        };
+    };
+    keepBillingSubscription: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["BillingKeepRequest"];
+            };
+        };
+        responses: {
+            /** @description Subscription state after keeping it */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiResponse_BillingSubscriptionState"];
+                };
+            };
+            400: components["responses"]["ValidationError"];
+            401: components["responses"]["Unauthorized"];
+            /** @description The subscription already ended (`subscription_ended`) or its cancellation is managed by a schedule (`schedule_managed`); the current state is in data */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["BillingStateConflict"];
+                };
+            };
+            502: components["responses"]["InternalError"];
+        };
+    };
+    payBillingInvoice: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                invoiceID: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["BillingPayInvoiceRequest"];
+            };
+        };
+        responses: {
+            /** @description Payment operation state with the verified remaining amount. A declined charge returns status `failed` with the decline code. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiResponse_BillingOperation"];
+                };
+            };
+            400: components["responses"]["ValidationError"];
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            /** @description The invoice cannot be paid (`invoice_not_payable`) */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            502: components["responses"]["InternalError"];
+        };
+    };
+    getBillingOperation: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                operationID: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Current operation state */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiResponse_BillingOperation"];
+                };
+            };
+            400: components["responses"]["ValidationError"];
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            502: components["responses"]["InternalError"];
+        };
+    };
+    getBillingCredits: {
+        parameters: {
+            query?: {
+                limit?: number;
+                /** @description Pagination cursor from a previous response */
+                cursor?: components["parameters"]["Cursor"];
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Credit balance and balance transactions */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiResponse_BillingCredits"];
+                };
+            };
+            400: components["responses"]["ValidationError"];
+            401: components["responses"]["Unauthorized"];
+            /** @description Billing is managed by Archil (`managed_billing`) */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            502: components["responses"]["InternalError"];
+        };
+    };
     listActivity: {
         parameters: {
             query?: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@archildata/api-types",
-  "version": "0.0.55",
+  "version": "0.0.57",
   "description": "API types for the Archil control plane",
   "type": "module",
   "types": "index.d.ts",