@stacksjs/ts-cloud 0.7.56 → 0.7.58

package/dist/api/types.d.ts

@@ -0,0 +1,119 @@
+import type { ControlPlaneId, JsonValue } from '../control-plane';
+import type { ApplicationDraftInput, ApplicationDraftRecord, ApplicationPlan, DetectionCandidate, DetectionFile, RegistryConnection } from '../onboarding';
+import type { OperationJob, OperationLogEntry, QueueConcurrencyLimits } from '../queue';
+export interface ApiErrorEnvelope {
+    error: {
+        code: string;
+        message: string;
+        requestId: string;
+        details?: JsonValue;
+    };
+}
+export interface ApiPage<T> {
+    data: T[];
+    page: {
+        nextCursor?: string;
+        hasMore: boolean;
+    };
+    requestId: string;
+}
+export interface ApiDeploymentRequest {
+    projectId: ControlPlaneId;
+    environmentId: ControlPlaneId;
+    serviceId?: ControlPlaneId;
+    action?: 'deploy' | 'rollback';
+    revision?: string;
+}
+export interface ApiOperationResponse {
+    operation: {
+        id: ControlPlaneId;
+        state: string;
+        kind: string;
+        projectId?: ControlPlaneId;
+        environmentId?: ControlPlaneId;
+        resourceId?: ControlPlaneId;
+        correlationId: string;
+        createdAt: string;
+    };
+    idempotentReplay: boolean;
+    requestId: string;
+}
+export interface ApiApplicationDetectionRequest {
+    files: DetectionFile[];
+}
+export interface ApiApplicationDetectionResponse {
+    candidates: DetectionCandidate[];
+    requestId: string;
+}
+export interface ApiApplicationPlanRequest {
+    draft: ApplicationDraftInput;
+    suppliedSecretNames?: string[];
+}
+export interface ApiApplicationPlanResponse {
+    plan: ApplicationPlan;
+    requestId: string;
+}
+export interface ApiApplicationDraftCreateRequest {
+    projectId: ControlPlaneId;
+    name?: string;
+    draft: ApplicationDraftInput;
+    step?: ApplicationDraftRecord['step'];
+    suppliedSecretNames?: string[];
+}
+export interface ApiApplicationDraftUpdateRequest {
+    id: ControlPlaneId;
+    version: number;
+    draft: ApplicationDraftInput;
+    step: ApplicationDraftRecord['step'];
+    suppliedSecretNames?: string[];
+}
+export interface ApiApplicationCreateRequest {
+    draftId: ControlPlaneId;
+    version: number;
+    confirmEnvironment: string;
+}
+export interface ApiApplicationCreateResponse {
+    resource: Record<string, unknown>;
+    operation: ApiOperationResponse['operation'];
+    plan: ApplicationPlan;
+    idempotentReplay: boolean;
+    requestId: string;
+}
+export interface ApiRegistryConnectionCreateRequest {
+    provider: RegistryConnection['provider'];
+    name: string;
+    host: string;
+    username?: string;
+    password?: string;
+    token?: string;
+    credentialExpiresAt?: string;
+}
+export type ApiRegistryConnectionUpdateRequest = {
+    id: ControlPlaneId;
+    action: 'test';
+    image?: string;
+} | {
+    id: ControlPlaneId;
+    action: 'rotate';
+    username?: string;
+    password?: string;
+    token?: string;
+    expiresAt?: string;
+};
+export type ApiQueueOperation = ApiOperationResponse['operation'] & {
+    queue: OperationJob;
+    approximatePosition?: {
+        ahead: number;
+        precision: 'bounded';
+    };
+};
+export interface ApiOperationLogsResponse {
+    data: OperationLogEntry[];
+    cursor: number;
+    hasMore: boolean;
+    requestId: string;
+}
+export interface ApiQueueSettingsResponse {
+    concurrency: QueueConcurrencyLimits;
+    requestId: string;
+}

package/dist/auth/encryption.d.ts

@@ -0,0 +1,3 @@
+export declare const AUTH_ENCRYPTION_KEY_FILE: string;
+/** Keep MFA encryption independent from legacy session-signing-key rotation. */
+export declare function resolveAuthEncryptionKey(cwd: string): string;

package/dist/auth/index.d.ts

@@ -0,0 +1,8 @@
+export { AUTH_ACTION_TOKEN_TTL_MS, AUTH_MFA_CHALLENGE_TTL_MS, AUTH_OIDC_TRANSACTION_TTL_MS, AUTH_SESSION_ABSOLUTE_TTL_MS, AUTH_SESSION_IDLE_TTL_MS, AuthenticationStore, } from './store';
+export * from './types';
+export { sendAuthenticationEmail } from './mailer';
+export type { AuthenticationEmail } from './mailer';
+export { AUTH_ENCRYPTION_KEY_FILE, resolveAuthEncryptionKey } from './encryption';
+export { decodeBase32, encodeBase32, hotp, matchTotpCounter, totp, totpUri, verifyTotp } from './totp';
+export { beginOidcAuthorization, completeOidcAuthorization, discoverOidcProvider, sanitizeOidcReturnPath } from './oidc';
+export type { OidcDiscoveryDocument, OidcFetch, VerifiedOidcIdentity } from './oidc';

package/dist/auth/mailer.d.ts

@@ -0,0 +1,9 @@
+import type { CloudConfig } from '@ts-cloud/core';
+export interface AuthenticationEmail {
+    to: string;
+    subject: string;
+    text: string;
+    html?: string;
+}
+/** Deliver authentication mail through ts-cloud's existing SES client. */
+export declare function sendAuthenticationEmail(config: CloudConfig, message: AuthenticationEmail): Promise<boolean>;

package/dist/auth/oidc.d.ts

@@ -0,0 +1,36 @@
+import type { AuthenticationStore } from './store';
+import type { AuthOidcProvider } from './types';
+export interface OidcDiscoveryDocument {
+    issuer: string;
+    authorization_endpoint: string;
+    token_endpoint: string;
+    jwks_uri: string;
+    response_types_supported?: string[];
+    id_token_signing_alg_values_supported?: string[];
+    code_challenge_methods_supported?: string[];
+    token_endpoint_auth_methods_supported?: string[];
+}
+export interface VerifiedOidcIdentity {
+    provider: AuthOidcProvider;
+    subject: string;
+    email: string;
+    name?: string;
+    claims: Record<string, unknown>;
+}
+export type OidcFetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+export declare function sanitizeOidcReturnPath(value: string | undefined): string;
+export declare function discoverOidcProvider(provider: AuthOidcProvider, fetchFn?: OidcFetch): Promise<OidcDiscoveryDocument>;
+export declare function beginOidcAuthorization(auth: AuthenticationStore, providerSlug: string, origin: string, returnPath?: string, fetchFn?: OidcFetch): Promise<{
+    authorizationUrl: string;
+    expiresAt: string;
+}>;
+export declare function completeOidcAuthorization(auth: AuthenticationStore, input: {
+    providerSlug: string;
+    state: string;
+    code: string;
+    origin: string;
+    now?: Date;
+}, fetchFn?: OidcFetch): Promise<{
+    identity: VerifiedOidcIdentity;
+    returnPath: string;
+}>;

package/dist/auth/oidc.test.d.ts

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

package/dist/auth/store.d.ts

@@ -0,0 +1,121 @@
+import type { ControlPlaneStore } from '../control-plane/store';
+import type { JsonValue } from '../control-plane/types';
+import type { AuthActionToken, AuthActionTokenType, AuthenticationStoreOptions, AuthIdentity, AuthMfaChallenge, AuthMfaFactor, AuthOidcProvider, AuthOidcSubject, AuthOidcTransaction, AuthSession, CreateAuthIdentityInput, CreateAuthSessionInput, UpsertAuthOidcProviderInput } from './types';
+export declare const AUTH_SESSION_IDLE_TTL_MS: number;
+export declare const AUTH_SESSION_ABSOLUTE_TTL_MS: number;
+export declare const AUTH_ACTION_TOKEN_TTL_MS: number;
+export declare const AUTH_MFA_CHALLENGE_TTL_MS: number;
+export declare const AUTH_OIDC_TRANSACTION_TTL_MS: number;
+export declare class AuthenticationStore {
+    private readonly controlPlane;
+    private readonly nowFn;
+    private readonly idFn;
+    private readonly encryptionKey?;
+    constructor(controlPlane: ControlPlaneStore, options?: AuthenticationStoreOptions);
+    private now;
+    private run;
+    private encrypt;
+    private decrypt;
+    createIdentity(input: CreateAuthIdentityInput): AuthIdentity;
+    getIdentity(id: string): AuthIdentity | undefined;
+    getIdentityByActor(actorId: string): AuthIdentity | undefined;
+    getIdentityByUsername(username: string): AuthIdentity | undefined;
+    getIdentityByEmail(email: string): AuthIdentity | undefined;
+    listIdentities(): AuthIdentity[];
+    updatePassword(identityId: string, passwordHash: string, options?: {
+        requiresUpgrade?: boolean;
+        revokeSessions?: boolean;
+    }): AuthIdentity;
+    /** Upgrade password-hash parameters without treating it as a credential change. */
+    rehashPassword(identityId: string, passwordHash: string): AuthIdentity;
+    setVerifiedEmail(identityId: string, email: string): AuthIdentity;
+    recordLogin(identityId: string): AuthIdentity;
+    setDisabled(identityId: string, disabled: boolean): AuthIdentity;
+    createActionToken(identityId: string, type: AuthActionTokenType, options?: {
+        ttlMs?: number;
+        metadata?: JsonValue;
+    }): {
+        actionToken: AuthActionToken;
+        token: string;
+    };
+    getActionToken(id: string): AuthActionToken | undefined;
+    consumeActionToken(token: string, type: AuthActionTokenType): AuthActionToken;
+    revokeActionTokens(identityId: string, type: AuthActionTokenType): number;
+    createSession(input: CreateAuthSessionInput): {
+        session: AuthSession;
+        token: string;
+    };
+    getSession(id: string): AuthSession | undefined;
+    verifySessionToken(token: string): {
+        identity: AuthIdentity;
+        session: AuthSession;
+    } | undefined;
+    listSessions(identityId: string, options?: {
+        includeInactive?: boolean;
+    }): AuthSession[];
+    revokeSession(identityId: string, sessionId: string): boolean;
+    revokeOtherSessions(identityId: string, currentSessionId: string): number;
+    getMfaFactor(identityId: string): AuthMfaFactor | undefined;
+    beginTotpEnrollment(identityId: string, options?: {
+        label?: string;
+        issuer?: string;
+    }): {
+        factor: AuthMfaFactor;
+        secret: string;
+        uri: string;
+    };
+    verifyTotpEnrollment(identityId: string, code: string): {
+        factor: AuthMfaFactor;
+        recoveryCodes: string[];
+    };
+    verifyMfaCode(identityId: string, code: string, options?: {
+        consumeRecovery?: boolean;
+    }): {
+        valid: boolean;
+        method?: 'totp' | 'recovery';
+    };
+    remainingRecoveryCodes(identityId: string): number;
+    disableMfa(identityId: string): void;
+    createMfaChallenge(identityId: string, purpose: AuthMfaChallenge['purpose']): {
+        challenge: AuthMfaChallenge;
+        token: string;
+    };
+    getMfaChallenge(id: string): AuthMfaChallenge | undefined;
+    inspectMfaChallengeToken(token: string, purpose: AuthMfaChallenge['purpose']): AuthMfaChallenge | undefined;
+    completeMfaChallenge(token: string, code: string, purpose: AuthMfaChallenge['purpose']): {
+        identity: AuthIdentity;
+        challenge: AuthMfaChallenge;
+        method: 'totp' | 'recovery';
+    };
+    markSessionStepUp(sessionId: string, mfa?: boolean): AuthSession;
+    isRecentlyAuthenticated(session: AuthSession, maxAgeMs?: number): boolean;
+    upsertOidcProvider(input: UpsertAuthOidcProviderInput): AuthOidcProvider;
+    getOidcProvider(id: string): AuthOidcProvider | undefined;
+    getOidcProviderBySlug(slug: string): AuthOidcProvider | undefined;
+    listOidcProviders(organizationId?: string, options?: {
+        includeDisabled?: boolean;
+    }): AuthOidcProvider[];
+    setOidcProviderEnabled(providerId: string, enabled: boolean): AuthOidcProvider;
+    getOidcProviderCredentials(providerId: string): {
+        provider: AuthOidcProvider;
+        clientSecret: string;
+    };
+    beginOidcTransaction(providerId: string, redirectUri: string, returnPath: string): {
+        transaction: AuthOidcTransaction;
+        state: string;
+        nonce: string;
+        verifier: string;
+    };
+    getOidcTransaction(id: string): AuthOidcTransaction | undefined;
+    consumeOidcTransaction(providerId: string, state: string): {
+        transaction: AuthOidcTransaction;
+        nonce: string;
+        verifier: string;
+    };
+    getOidcSubject(providerId: string, subject: string): AuthOidcSubject | undefined;
+    linkOidcSubject(providerId: string, identityId: string, subject: string, email: string): AuthOidcSubject;
+    purgeExpired(): {
+        actionTokens: number;
+        sessions: number;
+    };
+}

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

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

package/dist/auth/totp.d.ts

@@ -0,0 +1,11 @@
+export declare function encodeBase32(value: Uint8Array): string;
+export declare function decodeBase32(value: string): Buffer;
+export declare function hotp(secret: string, counter: number, digits?: number): string;
+export declare function totp(secret: string, timeMs?: number, stepSeconds?: number): string;
+export declare function verifyTotp(secret: string, code: string, timeMs?: number, window?: number): boolean;
+export declare function matchTotpCounter(secret: string, code: string, timeMs?: number, window?: number): number | undefined;
+export declare function totpUri(input: {
+    secret: string;
+    account: string;
+    issuer?: string;
+}): string;

package/dist/auth/totp.test.d.ts

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

package/dist/auth/types.d.ts

@@ -0,0 +1,138 @@
+import type { ControlPlaneId, JsonValue } from '../control-plane/types';
+export type AuthActionTokenType = 'activation' | 'password_reset' | 'email_verification';
+export type AuthMethod = 'local' | 'oidc';
+export interface AuthIdentity {
+    id: ControlPlaneId;
+    actorId: ControlPlaneId;
+    username: string;
+    email?: string;
+    emailVerifiedAt?: string;
+    passwordHash: string;
+    credentialVersion: number;
+    requiresPasswordUpgrade: boolean;
+    disabledAt?: string;
+    lastLoginAt?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface AuthActionToken {
+    id: ControlPlaneId;
+    identityId: ControlPlaneId;
+    type: AuthActionTokenType;
+    metadata: JsonValue;
+    expiresAt: string;
+    consumedAt?: string;
+    createdAt: string;
+    state: 'pending' | 'consumed' | 'expired';
+}
+export interface AuthSession {
+    id: ControlPlaneId;
+    identityId: ControlPlaneId;
+    credentialVersion: number;
+    authMethod: AuthMethod;
+    userAgent?: string;
+    networkHint?: string;
+    createdAt: string;
+    lastUsedAt: string;
+    idleExpiresAt: string;
+    absoluteExpiresAt: string;
+    recentAuthAt: string;
+    mfaAt?: string;
+    revokedAt?: string;
+    state: 'active' | 'revoked' | 'expired';
+}
+export interface CreateAuthIdentityInput {
+    id?: ControlPlaneId;
+    actorId: ControlPlaneId;
+    username: string;
+    email?: string;
+    emailVerified?: boolean;
+    passwordHash: string;
+    requiresPasswordUpgrade?: boolean;
+}
+export interface CreateAuthSessionInput {
+    identityId: ControlPlaneId;
+    authMethod?: AuthMethod;
+    userAgent?: string;
+    networkHint?: string;
+    idleTtlMs?: number;
+    absoluteTtlMs?: number;
+    recentAuthAt?: string;
+    mfaAt?: string;
+}
+export interface AuthenticationStoreOptions {
+    now?: () => Date;
+    id?: () => string;
+    /** Secret used to encrypt MFA seeds at rest. MFA methods require it. */
+    encryptionKey?: string;
+}
+export type AuthOidcRole = 'admin' | 'deployer' | 'operator' | 'viewer' | 'auditor';
+export interface AuthOidcProvider {
+    id: ControlPlaneId;
+    organizationId: ControlPlaneId;
+    slug: string;
+    name: string;
+    issuer: string;
+    clientId: string;
+    hasClientSecret: boolean;
+    scopes: string[];
+    allowedDomains: string[];
+    defaultRole: AuthOidcRole;
+    enabled: boolean;
+    enforceSso: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface UpsertAuthOidcProviderInput {
+    id?: ControlPlaneId;
+    organizationId: ControlPlaneId;
+    slug: string;
+    name: string;
+    issuer: string;
+    clientId: string;
+    clientSecret?: string;
+    scopes?: string[];
+    allowedDomains: string[];
+    defaultRole?: AuthOidcRole;
+    enabled?: boolean;
+    enforceSso?: boolean;
+}
+export interface AuthOidcTransaction {
+    id: ControlPlaneId;
+    providerId: ControlPlaneId;
+    redirectUri: string;
+    returnPath: string;
+    expiresAt: string;
+    consumedAt?: string;
+    createdAt: string;
+    state: 'pending' | 'consumed' | 'expired';
+}
+export interface AuthOidcSubject {
+    id: ControlPlaneId;
+    providerId: ControlPlaneId;
+    identityId: ControlPlaneId;
+    subject: string;
+    email: string;
+    linkedAt: string;
+    lastLoginAt: string;
+}
+export interface AuthMfaFactor {
+    id: ControlPlaneId;
+    identityId: ControlPlaneId;
+    type: 'totp';
+    label: string;
+    createdAt: string;
+    verifiedAt?: string;
+    disabledAt?: string;
+    state: 'pending' | 'active' | 'disabled';
+}
+export interface AuthMfaChallenge {
+    id: ControlPlaneId;
+    identityId: ControlPlaneId;
+    purpose: 'login' | 'step_up';
+    attempts: number;
+    expiresAt: string;
+    consumedAt?: string;
+    createdAt: string;
+    state: 'pending' | 'consumed' | 'expired' | 'locked';
+}

package/dist/automation/index.d.ts

@@ -0,0 +1,2 @@
+export { API_IDEMPOTENCY_TTL_MS, API_TOKEN_DEFAULT_TTL_MS, API_TOKEN_MAX_TTL_MS, AutomationIdentityStore, } from './store';
+export * from './types';

package/dist/automation/store.d.ts

@@ -0,0 +1,46 @@
+import type { ControlPlaneStore } from '../control-plane';
+import type { ApiIdempotencyRecord, ApiToken, ApiTokenPrincipal, CreateApiTokenInput, CreateServiceAccountInput, ServiceAccount } from './types';
+export declare const API_TOKEN_DEFAULT_TTL_MS: number;
+export declare const API_TOKEN_MAX_TTL_MS: number;
+export declare const API_IDEMPOTENCY_TTL_MS: number;
+export declare class AutomationIdentityStore {
+    private readonly controlPlane;
+    private readonly nowFn;
+    private readonly idFn;
+    constructor(controlPlane: ControlPlaneStore, options?: {
+        now?: () => Date;
+        id?: () => string;
+    });
+    private now;
+    private run;
+    createServiceAccount(input: CreateServiceAccountInput): {
+        serviceAccount: ServiceAccount;
+        membership: ApiTokenPrincipal['membership'];
+    };
+    getServiceAccount(id: string): ServiceAccount | undefined;
+    getServiceAccountBySlug(organizationId: string, slug: string): ServiceAccount | undefined;
+    listServiceAccounts(organizationId: string, options?: {
+        includeDisabled?: boolean;
+    }): ServiceAccount[];
+    disableServiceAccount(id: string, actorId?: string): ServiceAccount;
+    createToken(input: CreateApiTokenInput): {
+        token: ApiToken;
+        secret: string;
+    };
+    getToken(id: string): ApiToken | undefined;
+    listTokens(serviceAccountId: string, options?: {
+        includeInactive?: boolean;
+    }): ApiToken[];
+    verifyToken(secret: string, networkHint?: string): ApiTokenPrincipal | undefined;
+    rotateToken(tokenId: string, createdByActorId?: string): {
+        token: ApiToken;
+        secret: string;
+    };
+    revokeToken(tokenId: string, actorId?: string): ApiToken;
+    getIdempotency(tokenId: string, key: string): ApiIdempotencyRecord | undefined;
+    saveIdempotency(input: Omit<ApiIdempotencyRecord, 'id' | 'createdAt' | 'expiresAt'>): ApiIdempotencyRecord;
+    purgeExpired(): {
+        tokens: number;
+        idempotency: number;
+    };
+}

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

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

package/dist/automation/types.d.ts

@@ -0,0 +1,66 @@
+import type { AuthorizationCapability, AuthorizationScope, ControlPlaneActor, ControlPlaneId, OrganizationMembership, OrganizationRoleTemplate } from '../control-plane';
+export interface ServiceAccount {
+    id: ControlPlaneId;
+    organizationId: ControlPlaneId;
+    actorId: ControlPlaneId;
+    slug: string;
+    name: string;
+    description?: string;
+    createdByActorId?: ControlPlaneId;
+    disabledAt?: string;
+    createdAt: string;
+    updatedAt: string;
+    state: 'active' | 'disabled';
+}
+export interface ApiToken {
+    id: ControlPlaneId;
+    serviceAccountId: ControlPlaneId;
+    name: string;
+    prefix: string;
+    capabilities: AuthorizationCapability[];
+    scope: AuthorizationScope;
+    expiresAt: string;
+    lastUsedAt?: string;
+    lastNetworkHint?: string;
+    revokedAt?: string;
+    rotatedFromTokenId?: string;
+    createdByActorId?: ControlPlaneId;
+    createdAt: string;
+    updatedAt: string;
+    state: 'active' | 'expired' | 'revoked';
+}
+export interface CreateServiceAccountInput {
+    organizationId: ControlPlaneId;
+    slug: string;
+    name: string;
+    description?: string;
+    roleTemplate: Exclude<OrganizationRoleTemplate, 'owner'>;
+    scope?: AuthorizationScope;
+    createdByActorId?: ControlPlaneId;
+}
+export interface CreateApiTokenInput {
+    serviceAccountId: ControlPlaneId;
+    name: string;
+    capabilities: AuthorizationCapability[];
+    scope?: AuthorizationScope;
+    expiresAt?: string;
+    createdByActorId?: ControlPlaneId;
+    rotatedFromTokenId?: ControlPlaneId;
+}
+export interface ApiTokenPrincipal {
+    serviceAccount: ServiceAccount;
+    token: ApiToken;
+    actor: ControlPlaneActor;
+    membership: OrganizationMembership;
+}
+export interface ApiIdempotencyRecord {
+    id: ControlPlaneId;
+    tokenId: ControlPlaneId;
+    key: string;
+    requestHash: string;
+    operationId?: ControlPlaneId;
+    responseStatus: number;
+    responseBody: unknown;
+    expiresAt: string;
+    createdAt: string;
+}

package/dist/aws/acm.d.ts

@@ -1,7 +1,3 @@
-/**
- * ACM (AWS Certificate Manager) Client
- * For requesting and managing SSL/TLS certificates
- */
 export interface CertificateDetail {
     CertificateArn: string;
     DomainName: string;

package/dist/aws/application-autoscaling.d.ts

@@ -1,8 +1,3 @@
-/**
- * AWS Application Auto Scaling Client
- * Supports auto-scaling for ECS services, DynamoDB tables, and other AWS resources
- * Direct API calls without AWS CLI dependency
- */
 export type ScalableDimension = 'ecs:service:DesiredCount' | 'dynamodb:table:ReadCapacityUnits' | 'dynamodb:table:WriteCapacityUnits' | 'dynamodb:index:ReadCapacityUnits' | 'dynamodb:index:WriteCapacityUnits' | 'rds:cluster:ReadReplicaCount' | 'lambda:function:ProvisionedConcurrency' | 'elasticache:replication-group:NodeGroups' | 'elasticache:replication-group:Replicas';
 export type ServiceNamespace = 'ecs' | 'dynamodb' | 'rds' | 'lambda' | 'elasticache' | 'custom-resource' | 'comprehend' | 'kafka' | 'sagemaker';
 export type MetricType = 'ECSServiceAverageCPUUtilization' | 'ECSServiceAverageMemoryUtilization' | 'ALBRequestCountPerTarget' | 'DynamoDBReadCapacityUtilization' | 'DynamoDBWriteCapacityUtilization' | 'RDSReaderAverageCPUUtilization' | 'RDSReaderAverageDatabaseConnections' | 'EC2SpotFleetRequestAverageCPUUtilization' | 'EC2SpotFleetRequestAverageNetworkIn' | 'EC2SpotFleetRequestAverageNetworkOut' | 'SageMakerVariantInvocationsPerInstance' | 'SageMakerVariantProvisionedConcurrencyUtilization' | 'ElastiCachePrimaryEngineCPUUtilization' | 'ElastiCacheReplicaEngineCPUUtilization' | 'ElastiCacheDatabaseMemoryUsageCountedForEvictPercentage' | 'LambdaProvisionedConcurrencyUtilization' | 'CassandraReadCapacityUtilization' | 'CassandraWriteCapacityUtilization';

package/dist/aws/backup.d.ts

@@ -0,0 +1,42 @@
+import { AWSClient } from './client';
+export interface AwsBackupJob {
+    BackupJobId?: string;
+    State?: string;
+    StatusMessage?: string;
+    RecoveryPointArn?: string;
+    BackupSizeInBytes?: number;
+    ResourceArn?: string;
+    BackupVaultName?: string;
+}
+export interface AwsRestoreJob {
+    RestoreJobId?: string;
+    Status?: string;
+    StatusMessage?: string;
+    CreatedResourceArn?: string;
+    RecoveryPointArn?: string;
+}
+export declare class AwsBackupClient {
+    private readonly region;
+    private readonly client;
+    constructor(region?: string, client?: AWSClient);
+    private request;
+    startBackupJob(input: {
+        BackupVaultName: string;
+        ResourceArn: string;
+        IamRoleArn: string;
+        IdempotencyToken: string;
+    }): Promise<{
+        BackupJobId: string;
+    }>;
+    describeBackupJob(BackupJobId: string): Promise<AwsBackupJob>;
+    startRestoreJob(input: {
+        RecoveryPointArn: string;
+        IamRoleArn: string;
+        Metadata: Record<string, string>;
+        IdempotencyToken: string;
+    }): Promise<{
+        RestoreJobId: string;
+    }>;
+    describeRestoreJob(RestoreJobId: string): Promise<AwsRestoreJob>;
+    deleteRecoveryPoint(BackupVaultName: string, RecoveryPointArn: string): Promise<void>;
+}

package/dist/aws/bedrock.d.ts

@@ -1,8 +1,3 @@
-/**
- * AWS Bedrock Client
- * Direct API calls for Bedrock AI model invocations and management
- * No external SDK dependencies - implements AWS Signature V4 directly
- */
 export interface BedrockMessage {
     role: 'user' | 'assistant';
     content: string | BedrockContentBlock[];