@stacksjs/ts-cloud 0.7.108 → 0.7.110

package/dist/alerts/delivery.d.ts

@@ -15,6 +15,15 @@ export type NotificationEmail = (input: {
     subject: string;
     text: string;
 }) => Promise<unknown>;
+/**
+ * Send one SMS. Injected rather than imported so the router stays testable and
+ * so a deployment that does not use SMS pays nothing for it.
+ */
+export type NotificationSms = (input: {
+    to: string;
+    from?: string;
+    text: string;
+}) => Promise<unknown>;
 export declare function isQuietHours(route: NotificationRoute, at: Date): boolean;
 export declare class NotificationRouter {
     private readonly store;
@@ -23,6 +32,7 @@ export declare class NotificationRouter {
     constructor(store: AlertStore, options?: {
         fetchImpl?: NotificationFetch;
         emailImpl?: NotificationEmail;
+        smsImpl?: NotificationSms;
         now?: () => Date;
     });
     private now;

package/dist/alerts/model.d.ts

@@ -3,7 +3,7 @@ export type HealthCheckKind = 'http' | 'tcp' | 'command';
 export type HealthStatus = 'healthy' | 'unhealthy' | 'no_data';
 export type AlertState = 'pending' | 'firing' | 'resolved' | 'silenced';
 export type AlertSeverity = 'info' | 'warning' | 'critical';
-export type NotificationChannelKind = 'slack' | 'discord' | 'teams' | 'telegram' | 'email' | 'webhook';
+export type NotificationChannelKind = 'slack' | 'discord' | 'teams' | 'telegram' | 'email' | 'webhook' | 'sms';
 export interface HealthCheck {
     id: string;
     projectId: string;

package/dist/api/client.d.ts

@@ -194,4 +194,57 @@ export declare class TsCloudClient {
         operation: ApiOperationResponse['operation'];
         requestId: string;
     }>;
+    /**
+     * Current usage, cost, and budget headroom.
+     *
+     * The call a pipeline makes before doing something expensive. Every budget
+     * carries `remainingCents`, `projectedCents`, and `projectionConfidence`, so
+     * the caller can decide rather than guess.
+     */
+    usage(options?: {
+        projectId?: string;
+        environmentId?: string;
+        period?: 'daily' | 'weekly' | 'monthly';
+        timezone?: string;
+    }): Promise<Record<string, unknown>>;
+    /** Itemized hourly usage rollups for a window. */
+    usageRollups(options: {
+        from: string;
+        to: string;
+        projectId?: string;
+        environmentId?: string;
+        meters?: string[];
+        limit?: number;
+    }): Promise<{
+        data: Array<Record<string, unknown>>;
+    }>;
+    /**
+     * Whether an operation is allowed under current spend enforcement.
+     *
+     * One boolean and a reason, deliberately - the caller is a script deciding
+     * whether to continue, not a dashboard rendering a page.
+     */
+    allowance(operation?: 'build' | 'deploy' | 'function_invoke' | 'request', options?: {
+        projectId?: string;
+        environmentId?: string;
+    }): Promise<{
+        allowed: boolean;
+        blockedBy: string | null;
+        reason: string | null;
+    }>;
+    /** Budgets governing a scope. */
+    budgets(options?: {
+        projectId?: string;
+        environmentId?: string;
+    }): Promise<{
+        data: Array<Record<string, unknown>>;
+    }>;
+    /** Detected spend anomalies. */
+    anomalies(options?: {
+        projectId?: string;
+        since?: string;
+        unacknowledged?: boolean;
+    }): Promise<{
+        data: Array<Record<string, unknown>>;
+    }>;
 }

package/dist/api/handler.d.ts

@@ -2,6 +2,7 @@ import type { AutomationIdentityStore } from '../automation';
 import type { ControlPlaneStore } from '../control-plane';
 import type { ApplicationArtifactStore, ApplicationDraftStore, RegistryConnectionStore } from '../onboarding';
 import type { SourceConnectionStore } from '../source';
+import { SpendService, SpendStore } from '../spend';
 interface ApiV1HandlerOptions {
     controlPlane: ControlPlaneStore;
     identities: AutomationIdentityStore;
@@ -13,6 +14,15 @@ interface ApiV1HandlerOptions {
     };
     now?: () => Date;
     rateLimit?: number;
+    /**
+     * Spend management. Supplied by default from the control plane, so the
+     * billing endpoints work without extra wiring; pass one to share a store
+     * (and therefore a counter tracker) with a running evaluation loop.
+     */
+    spend?: {
+        store: SpendStore;
+        service: SpendService;
+    };
 }
 export declare function createApiV1Handler(options: ApiV1HandlerOptions): (request: Request, networkHint?: string) => Promise<Response | undefined>;
 export {};

package/dist/api/service.d.ts

@@ -12,6 +12,7 @@ export declare class AutomationApiService {
     private readonly controlPlane;
     private readonly identities;
     private readonly queue;
+    private readonly spendGate;
     constructor(controlPlane: ControlPlaneStore, identities: AutomationIdentityStore);
     target(principal: ApiTokenPrincipal, requested: AuthorizationScope): AuthorizationTarget;
     authorize(principal: ApiTokenPrincipal, capability: AuthorizationCapability, requested: AuthorizationScope): AuthorizationTarget;

package/dist/aws/index.js

@@ -86,7 +86,13 @@ import {
   trackEvent,
   translate,
   translateToMultiple
-} from "../chunk-ybcz6sxc.js";
+} from "../chunk-x6yzgv7y.js";
+import {
+  EmailClient,
+  IAMClient,
+  SESClient,
+  email
+} from "../chunk-hpv68b4a.js";
 import {
   CloudFrontClient
 } from "../chunk-01d86gt1.js";
@@ -112,6 +118,9 @@ import {
   detectDnsProvider,
   dnsProviders
 } from "../chunk-gttvakpv.js";
+import {
+  Route53Client
+} from "../chunk-32e7ya18.js";
 import {
   EC2Client,
   SSMClient
@@ -119,15 +128,6 @@ import {
 import {
   CloudFormationClient
 } from "../chunk-4cjrg98a.js";
-import {
-  EmailClient,
-  IAMClient,
-  SESClient,
-  email
-} from "../chunk-hpv68b4a.js";
-import {
-  Route53Client
-} from "../chunk-32e7ya18.js";
 import {
   S3Client
 } from "../chunk-wj3s95p9.js";

package/dist/aws/lambda.d.ts

@@ -217,6 +217,25 @@ export declare class LambdaClient {
         Status?: string;
         RequestedProvisionedConcurrentExecutions?: number;
     }>;
+    /**
+     * Read the reserved-concurrency limit. Returns null when none is set.
+     *
+     * Reserved concurrency is not the same as provisioned concurrency above: it
+     * is a ceiling on how many executions may run at once, and setting it to 0 is
+     * the supported way to stop a function being invoked at all without deleting
+     * it or breaking its triggers.
+     */
+    getFunctionConcurrency(functionName: string): Promise<number | null>;
+    /**
+     * Set the reserved-concurrency ceiling.
+     *
+     * Zero throttles every invocation: the trigger still fires, Lambda rejects it,
+     * and nothing runs. That is reversible in one call, which is what makes it
+     * usable as a spend cap rather than a deletion.
+     */
+    putFunctionConcurrency(functionName: string, reservedConcurrentExecutions: number): Promise<void>;
+    /** Remove the reserved-concurrency ceiling, returning the function to the account pool. */
+    deleteFunctionConcurrency(functionName: string): Promise<void>;
     /** Remove a provisioned-concurrency config from a function version/alias. */
     deleteProvisionedConcurrencyConfig(functionName: string, qualifier: string): Promise<void>;
     /**