@stacksjs/ts-cloud 0.7.56 → 0.7.57

package/dist/queue/types.d.ts

@@ -0,0 +1,93 @@
+import type { ControlPlaneOperation, CreateOperationInput, JsonValue, OperationState } from '../control-plane';
+export interface QueueConcurrencyLimits {
+    project: number;
+    environment: number;
+    provider: number;
+    builds: number;
+}
+export interface EnqueueOperationInput extends CreateOperationInput {
+    lockKey?: string;
+    providerKey?: string;
+    buildSlot?: boolean;
+    maxAttempts?: number;
+    availableAt?: string;
+    timeoutSeconds?: number;
+    retryClasses?: string[];
+    resumePolicy?: 'fail' | 'requeue';
+    cancellationMode?: 'cooperative' | 'provider_non_cancellable';
+    retentionDays?: number;
+}
+export interface OperationJob {
+    operationId: string;
+    lockKey?: string;
+    providerKey?: string;
+    buildSlot: boolean;
+    maxAttempts: number;
+    availableAt: string;
+    timeoutSeconds: number;
+    heartbeatAt?: string;
+    currentStep?: string;
+    blockedReason?: string;
+    retryClasses: string[];
+    resumePolicy: 'fail' | 'requeue';
+    cancellationMode: 'cooperative' | 'provider_non_cancellable';
+    retentionUntil: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface OperationLogEntry {
+    sequence: number;
+    id: string;
+    operationId: string;
+    stream: 'stdout' | 'stderr' | 'system' | 'step';
+    step?: string;
+    message: string;
+    redacted: boolean;
+    truncated: boolean;
+    createdAt: string;
+}
+export interface QueueOperationView {
+    operation: ControlPlaneOperation;
+    job: OperationJob;
+    approximatePosition?: {
+        ahead: number;
+        precision: 'bounded';
+    };
+}
+export interface QueueLogInput {
+    stream?: OperationLogEntry['stream'];
+    step?: string;
+    secrets?: string[];
+}
+export interface QueueExecutionContext {
+    operation: ControlPlaneOperation;
+    signal: AbortSignal;
+    log: (message: string, input?: QueueLogInput) => OperationLogEntry;
+    checkpoint: (step: string, message?: string) => void;
+    heartbeat: () => void;
+    cancellationRequested: () => boolean;
+    throwIfCancellationRequested: () => void;
+}
+export type QueueOperationHandler = (context: QueueExecutionContext) => Promise<JsonValue | void>;
+export interface QueueRunResult {
+    operation?: ControlPlaneOperation;
+    handled: boolean;
+    terminalState?: Extract<OperationState, 'succeeded' | 'failed' | 'cancelled' | 'timed_out'>;
+    requeued?: boolean;
+}
+export interface QueueRecoveryResult {
+    requeued: number;
+    failed: number;
+    cancelled: number;
+}
+export declare class QueueCancellationError extends Error {
+    constructor();
+}
+export declare class QueueTimeoutError extends Error {
+    readonly timeoutSeconds: number;
+    constructor(timeoutSeconds: number);
+}
+export declare class RetryableOperationError extends Error {
+    readonly errorClass: string;
+    constructor(message: string, errorClass: string);
+}

package/dist/queue/worker.d.ts

@@ -0,0 +1,32 @@
+import type { DurableOperationQueue } from './queue';
+import type { QueueOperationHandler, QueueRunResult } from './types';
+export interface DurableQueueWorkerOptions {
+    parallelism?: number;
+    pollIntervalMs?: number;
+    onResult?: (result: QueueRunResult) => void;
+    onError?: (error: unknown) => void;
+}
+/**
+ * Runs a fixed number of durable polling lanes. The database queue remains the
+ * source of truth for claims, resource locks, and per-scope concurrency.
+ */
+export declare class DurableQueueWorker {
+    private readonly queue;
+    private readonly handlers;
+    private readonly parallelism;
+    private readonly pollIntervalMs;
+    private readonly onResult?;
+    private readonly onError?;
+    private readonly waits;
+    private lanes;
+    private running;
+    constructor(queue: DurableOperationQueue, handlers: Record<string, QueueOperationHandler>, options?: DurableQueueWorkerOptions);
+    get active(): boolean;
+    start(): this;
+    stop(): void;
+    settled(): Promise<void>;
+    /** Execute all currently claimable work, using the configured lane bound. */
+    drain(): Promise<QueueRunResult[]>;
+    private wait;
+    private runLane;
+}

package/dist/queue/worker.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/regions/drivers.d.ts

@@ -0,0 +1,139 @@
+import type { JsonValue } from '../control-plane';
+import type { RegionalProviderDriver, RegionalTarget, RegionalTopology, RegionalTrafficRoute, ReplicationChannel } from './types';
+export interface AwsRegionalTransport {
+    applyCloudFormation(input: {
+        region: string;
+        stackId?: string;
+        revision: string;
+        manifest: JsonValue;
+    }): Promise<{
+        stackId: string;
+    }>;
+    deleteCloudFormation(input: {
+        region: string;
+        stackId: string;
+        retainData: boolean;
+    }): Promise<void>;
+    stackHealth(input: {
+        region: string;
+        stackId: string;
+    }): Promise<{
+        healthy: boolean;
+        evidence: Record<string, JsonValue>;
+    }>;
+    configureS3Replication(input: {
+        sourceRegion: string;
+        targetRegion: string;
+        config: Record<string, JsonValue>;
+    }): Promise<{
+        checkpoint: string;
+        lagSeconds: number;
+    }>;
+    configureDynamoGlobalTable(input: {
+        sourceRegion: string;
+        targetRegion: string;
+        config: Record<string, JsonValue>;
+    }): Promise<{
+        checkpoint: string;
+        lagSeconds: number;
+    }>;
+    replicateSecrets(input: {
+        sourceRegion: string;
+        targetRegion: string;
+        config: Record<string, JsonValue>;
+    }): Promise<{
+        checkpoint: string;
+        lagSeconds: number;
+    }>;
+    verifyReplication(input: {
+        kind: ReplicationChannel['kind'];
+        sourceRegion: string;
+        targetRegion: string;
+        checkpoint?: string;
+    }): Promise<{
+        healthy: boolean;
+        checkpoint: string;
+        lagSeconds: number;
+    }>;
+    applyEdge(input: {
+        hostname: string;
+        weights: Record<string, number>;
+        route53: boolean;
+        cloudFront: boolean;
+        waf: boolean;
+    }): Promise<{
+        providerState: Record<string, JsonValue>;
+    }>;
+}
+export declare class AwsRegionalDriver implements RegionalProviderDriver {
+    private transport;
+    readonly provider = "aws";
+    constructor(transport: AwsRegionalTransport);
+    applyStack({ target, revision, manifest, }: {
+        target: RegionalTarget;
+        revision: string;
+        manifest: JsonValue;
+        signal: AbortSignal;
+    }): Promise<{
+        stackId: string;
+    }>;
+    deleteStack({ target, retainData, }: {
+        target: RegionalTarget;
+        retainData: boolean;
+        signal: AbortSignal;
+    }): Promise<void>;
+    health({ target, }: {
+        target: RegionalTarget;
+    }): Promise<{
+        healthy: boolean;
+        evidence: Record<string, JsonValue>;
+    }>;
+    configureReplication({ channel, }: {
+        channel: ReplicationChannel;
+        topology: RegionalTopology;
+    }): Promise<{
+        checkpoint: string;
+        lagSeconds: number;
+    }>;
+    verifyReplication({ channel, }: {
+        channel: ReplicationChannel;
+        topology: RegionalTopology;
+    }): Promise<{
+        healthy: boolean;
+        checkpoint: string;
+        lagSeconds: number;
+    }>;
+    applyTraffic({ route, weights, }: {
+        route: RegionalTrafficRoute;
+        topology: RegionalTopology;
+        weights: Record<string, number>;
+    }): Promise<{
+        providerState: Record<string, JsonValue>;
+    }>;
+}
+export declare class UnavailableRegionalDriver implements RegionalProviderDriver {
+    readonly provider: string;
+    private reason;
+    constructor(provider: string, reason?: string);
+    private fail;
+    applyStack(): Promise<{
+        stackId: string;
+    }>;
+    deleteStack(): Promise<void>;
+    health(): Promise<{
+        healthy: boolean;
+        evidence: Record<string, JsonValue>;
+    }>;
+    configureReplication(): Promise<{
+        checkpoint: string;
+        lagSeconds: number;
+    }>;
+    verifyReplication(): Promise<{
+        healthy: boolean;
+        checkpoint: string;
+        lagSeconds: number;
+    }>;
+    applyTraffic(): Promise<{
+        providerState: Record<string, JsonValue>;
+    }>;
+}

package/dist/regions/index.d.ts

@@ -0,0 +1,5 @@
+export * from './types';
+export * from './store';
+export * from './service';
+export * from './queue';
+export * from './drivers';

package/dist/regions/queue.d.ts

@@ -0,0 +1,4 @@
+import type { QueueOperationHandler } from '../queue';
+import type { RegionalProviderDriver } from './types';
+import { RegionStore } from './store';
+export declare function createRegionQueueHandlers(store: RegionStore, drivers: readonly RegionalProviderDriver[]): Record<string, QueueOperationHandler>;

package/dist/regions/regions.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/regions/service.d.ts

@@ -0,0 +1,23 @@
+import type { ControlPlaneOperation, JsonValue } from '../control-plane';
+import type { RegionalExecution, RegionalOperationKind, RegionalTopology } from './types';
+import { DurableOperationQueue } from '../queue';
+import { RegionStore } from './store';
+export declare class RegionService {
+    readonly store: RegionStore;
+    readonly queue: DurableOperationQueue;
+    constructor(store: RegionStore, queue?: DurableOperationQueue);
+    create(input: Parameters<RegionStore['create']>[0]): RegionalTopology;
+    plan(id: string, kind: RegionalOperationKind, target?: string): string[];
+    enqueue(input: {
+        topologyId: string;
+        kind: RegionalOperationKind;
+        targetRegion?: string;
+        revision?: string;
+        manifest?: JsonValue;
+        confirmation?: string;
+        deleteData?: boolean;
+    }): {
+        execution: RegionalExecution;
+        operation: ControlPlaneOperation;
+    };
+}

package/dist/regions/store.d.ts

@@ -0,0 +1,41 @@
+import type { ControlPlaneStore } from '../control-plane';
+import type { RegionalExecution, RegionalOperationKind, RegionalTarget, RegionalTopology, RegionalTrafficRoute, ReplicationChannel } from './types';
+export declare class RegionStore {
+    readonly control: ControlPlaneStore;
+    private now;
+    private id;
+    constructor(control: ControlPlaneStore, now?: () => Date, id?: () => string);
+    create(input: {
+        organizationId: string;
+        projectId: string;
+        environmentId?: string;
+        name: string;
+        hostname: string;
+        regions: RegionalTopology['regions'];
+        trafficPolicy: RegionalTopology['trafficPolicy'];
+        dataPolicy: RegionalTopology['dataPolicy'];
+        dnsProvider?: string;
+        cdnEnabled?: boolean;
+        wafEnabled?: boolean;
+    }): RegionalTopology;
+    get(id: string): RegionalTopology | undefined;
+    list(projectId: string): RegionalTopology[];
+    targets(id: string): RegionalTarget[];
+    channels(id: string): ReplicationChannel[];
+    route(id: string): RegionalTrafficRoute | undefined;
+    updateTopology(id: string, patch: Partial<Pick<RegionalTopology, 'status' | 'activeRegion' | 'revision' | 'regions'>>): RegionalTopology;
+    updateTarget(id: string, patch: Partial<Pick<RegionalTarget, 'role' | 'stackId' | 'stackRevision' | 'status' | 'health' | 'lastHealthyAt'>>): RegionalTarget;
+    updateChannel(id: string, patch: Partial<Pick<ReplicationChannel, 'status' | 'checkpoint' | 'lagSeconds' | 'lastVerifiedAt'>>): ReplicationChannel;
+    updateRoute(id: string, patch: Partial<Pick<RegionalTrafficRoute, 'weights' | 'desiredWeights' | 'status' | 'providerState'>>): RegionalTrafficRoute;
+    createExecution(input: {
+        topologyId: string;
+        operationId?: string;
+        kind: RegionalOperationKind;
+        requestedRegion?: string;
+        revision?: string;
+        plan: string[];
+    }): RegionalExecution;
+    execution(id: string): RegionalExecution | undefined;
+    executions(id: string): RegionalExecution[];
+    updateExecution(id: string, patch: Partial<Pick<RegionalExecution, 'operationId' | 'currentStep' | 'completedSteps' | 'status' | 'error'>>): RegionalExecution;
+}

package/dist/regions/types.d.ts

@@ -0,0 +1,132 @@
+import type { JsonValue } from '../control-plane';
+export type RegionalOperationKind = 'rollout' | 'failover' | 'failback' | 'destroy' | 'reconcile';
+export interface RegionalTarget {
+    id: string;
+    topologyId: string;
+    region: string;
+    role: 'primary' | 'secondary';
+    provider: string;
+    stackId?: string;
+    stackRevision?: string;
+    status: 'pending' | 'provisioning' | 'ready' | 'degraded' | 'failed' | 'deleting' | 'deleted';
+    health: Record<string, JsonValue>;
+    lastHealthyAt?: string;
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ReplicationChannel {
+    id: string;
+    topologyId: string;
+    kind: 's3' | 'dynamodb' | 'secrets';
+    sourceRegion: string;
+    targetRegion: string;
+    config: Record<string, JsonValue>;
+    status: 'pending' | 'configuring' | 'in_sync' | 'lagging' | 'failed' | 'disabled';
+    checkpoint?: string;
+    lagSeconds?: number;
+    lastVerifiedAt?: string;
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface RegionalTrafficRoute {
+    id: string;
+    topologyId: string;
+    hostname: string;
+    dnsProvider: string;
+    cdnEnabled: boolean;
+    wafEnabled: boolean;
+    weights: Record<string, number>;
+    desiredWeights: Record<string, number>;
+    status: 'pending' | 'applying' | 'in_sync' | 'failed' | 'drained';
+    providerState: Record<string, JsonValue>;
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface RegionalTopology {
+    id: string;
+    organizationId: string;
+    projectId: string;
+    environmentId?: string;
+    name: string;
+    hostname: string;
+    homeRegion: string;
+    regions: Array<{
+        region: string;
+        role: 'primary' | 'secondary';
+        provider: string;
+    }>;
+    trafficPolicy: 'active_passive' | 'weighted' | 'latency';
+    dataPolicy: {
+        replicate: Array<'s3' | 'dynamodb' | 'secrets'>;
+        maxLagSeconds: number;
+        retainOnDestroy: boolean;
+    };
+    status: 'draft' | 'provisioning' | 'ready' | 'degraded' | 'failing_over' | 'failed_over' | 'failing_back' | 'destroying' | 'destroyed' | 'failed';
+    activeRegion: string;
+    revision?: string;
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface RegionalExecution {
+    id: string;
+    topologyId: string;
+    operationId?: string;
+    kind: RegionalOperationKind;
+    requestedRegion?: string;
+    revision?: string;
+    plan: string[];
+    currentStep?: string;
+    completedSteps: string[];
+    status: 'queued' | 'running' | 'succeeded' | 'failed' | 'cancelled';
+    error?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface RegionalProviderDriver {
+    provider: string;
+    applyStack(input: {
+        target: RegionalTarget;
+        revision: string;
+        manifest: JsonValue;
+        signal: AbortSignal;
+    }): Promise<{
+        stackId: string;
+    }>;
+    deleteStack(input: {
+        target: RegionalTarget;
+        retainData: boolean;
+        signal: AbortSignal;
+    }): Promise<void>;
+    health(input: {
+        target: RegionalTarget;
+    }): Promise<{
+        healthy: boolean;
+        evidence: Record<string, JsonValue>;
+    }>;
+    configureReplication(input: {
+        channel: ReplicationChannel;
+        topology: RegionalTopology;
+    }): Promise<{
+        checkpoint: string;
+        lagSeconds: number;
+    }>;
+    verifyReplication(input: {
+        channel: ReplicationChannel;
+        topology: RegionalTopology;
+    }): Promise<{
+        healthy: boolean;
+        checkpoint: string;
+        lagSeconds: number;
+    }>;
+    applyTraffic(input: {
+        route: RegionalTrafficRoute;
+        topology: RegionalTopology;
+        weights: Record<string, number>;
+    }): Promise<{
+        providerState: Record<string, JsonValue>;
+    }>;
+}

package/dist/release/index.d.ts

@@ -0,0 +1,6 @@
+export * from './types';
+export * from './strategy';
+export * from './store';
+export * from './service';
+export * from './runtime';
+export * from './queue';

package/dist/release/queue.d.ts

@@ -0,0 +1,15 @@
+import type { ControlPlaneStore, JsonValue } from '../control-plane';
+import type { QueueOperationHandler } from '../queue';
+import type { ReleaseActivationDriver } from './runtime';
+import type { ReleaseRecord } from './types';
+export declare const RELEASE_QUEUE_KINDS: readonly ['release.activate', 'release.rollback'];
+export type ReleaseDriverResolver = (release: ReleaseRecord) => ReleaseActivationDriver | Promise<ReleaseActivationDriver>;
+export declare function createReleaseQueueHandlers(input: {
+    store: ControlPlaneStore;
+    resolveDriver: ReleaseDriverResolver;
+    resolveHealthGate?: (name: string, release: ReleaseRecord) => Promise<{
+        healthy: boolean;
+        evidence?: JsonValue;
+        message?: string;
+    }>;
+}): Record<string, QueueOperationHandler>;

package/dist/release/queue.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/release/runtime.d.ts

@@ -0,0 +1,35 @@
+import type { JsonValue } from '../control-plane';
+import type { ReleaseArtifact, ReleaseRecord, ReleaseStrategyCapability } from './types';
+export interface ReleaseTrafficTransition {
+    step: string;
+    trafficPercent: number;
+    waitSeconds: number;
+    requiresHealth: boolean;
+}
+export interface ReleaseActivationContext {
+    release: ReleaseRecord;
+    artifact: ReleaseArtifact;
+    previous?: ReleaseRecord;
+    transitions: ReleaseTrafficTransition[];
+}
+export interface ReleaseActivationResult {
+    activated: boolean;
+    healthy: boolean;
+    providerVersion?: string;
+    resourceVersions: Record<string, string>;
+    transitions: Array<{
+        trafficPercent: number;
+        healthy: boolean;
+        observed: JsonValue;
+    }>;
+    error?: string;
+}
+export interface ReleaseActivationDriver {
+    name: string;
+    capability: (context: Pick<ReleaseActivationContext, 'release' | 'artifact' | 'previous'>) => ReleaseStrategyCapability;
+    activate: (context: ReleaseActivationContext) => Promise<ReleaseActivationResult>;
+    rollback: (context: ReleaseActivationContext) => Promise<ReleaseActivationResult>;
+}
+export declare function releaseTrafficPlan(release: ReleaseRecord): ReleaseTrafficTransition[];
+export declare function activateImmutableRelease(driver: ReleaseActivationDriver, input: Omit<ReleaseActivationContext, 'transitions'>): Promise<ReleaseActivationResult>;
+export declare function rollbackImmutableRelease(driver: ReleaseActivationDriver, input: Omit<ReleaseActivationContext, 'transitions'>): Promise<ReleaseActivationResult>;

package/dist/release/runtime.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/release/service.d.ts

@@ -0,0 +1,28 @@
+import type { ControlPlaneOperation, ControlPlaneStore, JsonValue } from '../control-plane';
+import type { ReleaseRecord } from './types';
+import { DurableOperationQueue } from '../queue';
+import { ReleaseStore } from './store';
+export declare class ReleaseService {
+    readonly controlPlane: ControlPlaneStore;
+    readonly releases: ReleaseStore;
+    readonly queue: DurableOperationQueue;
+    constructor(controlPlane: ControlPlaneStore);
+    enqueueActivation(release: ReleaseRecord, input?: {
+        actorId?: string;
+        action?: 'activate' | 'rollback';
+        targetReleaseId?: string;
+    }): ControlPlaneOperation;
+    completeHealthGate(releaseId: string, input: {
+        healthy: boolean;
+        operationId?: string;
+        health?: JsonValue;
+        message?: string;
+    }): {
+        release: ReleaseRecord;
+        rollbackOperation?: ControlPlaneOperation;
+    };
+    enqueueRollback(release: ReleaseRecord, input?: {
+        actorId?: string;
+        targetReleaseId?: string;
+    }): ControlPlaneOperation;
+}

package/dist/release/store.d.ts

@@ -0,0 +1,88 @@
+import type { ControlPlaneStore, JsonValue } from '../control-plane';
+import type { ReleaseApproval, ReleaseArtifact, ReleaseCompare, ReleaseDeployableKind, ReleaseHealthGate, ReleaseHookCompatibility, ReleaseRecord, ReleaseStatus, ReleaseStrategy, ReleaseTransition } from './types';
+export declare class ReleaseStore {
+    readonly controlPlane: ControlPlaneStore;
+    private readonly now;
+    private readonly id;
+    constructor(controlPlane: ControlPlaneStore, options?: {
+        now?: () => Date;
+        id?: () => string;
+    });
+    registerArtifact(input: {
+        organizationId: string;
+        digest: string;
+        kind: ReleaseDeployableKind;
+        uri: string;
+        size: number;
+        mediaType?: string;
+        provenance?: JsonValue;
+        attestation?: JsonValue;
+    }): ReleaseArtifact;
+    getArtifact(id: string): ReleaseArtifact | undefined;
+    create(input: {
+        organizationId: string;
+        projectId: string;
+        environmentId: string;
+        resourceId: string;
+        artifactId: string;
+        kind: ReleaseDeployableKind;
+        sourceSha?: string;
+        config: JsonValue;
+        manifest: JsonValue;
+        provenance?: JsonValue;
+        strategy: ReleaseStrategy;
+        healthGate?: ReleaseHealthGate;
+        hooks?: ReleaseHookCompatibility;
+        drainSeconds?: number;
+        graceSeconds?: number;
+        automaticRollback?: boolean;
+        promotedFromReleaseId?: string;
+        actorId?: string;
+        trigger?: string;
+        approvalRequired?: boolean;
+        replicas?: number;
+    }): ReleaseRecord;
+    get(id: string): ReleaseRecord | undefined;
+    list(input?: {
+        projectId?: string;
+        environmentId?: string;
+        resourceId?: string;
+        status?: ReleaseStatus;
+    }): ReleaseRecord[];
+    active(resourceId: string): ReleaseRecord | undefined;
+    transitions(releaseId: string): ReleaseTransition[];
+    private recordTransition;
+    progress(id: string, input: {
+        message: string;
+        trafficPercent?: number;
+        health?: JsonValue;
+        operationId?: string;
+    }): ReleaseTransition;
+    transition(id: string, toStatus: ReleaseStatus, input: {
+        message: string;
+        trafficPercent?: number;
+        health?: JsonValue;
+        operationId?: string;
+    }): ReleaseRecord;
+    approve(id: string, input: {
+        actorId: string;
+        decision: 'approved' | 'rejected';
+        comment?: string;
+    }): ReleaseRecord;
+    approvals(id: string): ReleaseApproval[];
+    promote(sourceId: string, input: {
+        targetEnvironmentId: string;
+        targetResourceId: string;
+        config: JsonValue;
+        strategy?: ReleaseStrategy;
+        healthGate?: ReleaseHealthGate;
+        actorId?: string;
+        approvalRequired?: boolean;
+    }): ReleaseRecord;
+    compare(leftId: string, rightId: string): ReleaseCompare;
+    pin(id: string, pinned: boolean, reason?: string): ReleaseRecord;
+    retentionCandidates(input: {
+        before: Date;
+        keepPerResource?: number;
+    }): ReleaseRecord[];
+}

package/dist/release/store.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/release/strategy.d.ts

@@ -0,0 +1,8 @@
+import type { ReleaseDeployableKind, ReleaseStrategy, ReleaseStrategyCapability } from './types';
+export declare function releaseStrategyCapabilities(input: {
+    kind: ReleaseDeployableKind;
+    provider?: string;
+    hasHealthGate: boolean;
+    replicas?: number;
+}): ReleaseStrategyCapability[];
+export declare function assertReleaseStrategy(input: Parameters<typeof releaseStrategyCapabilities>[0], strategy: ReleaseStrategy): ReleaseStrategyCapability;