@stacksjs/ts-cloud 0.2.3 → 0.2.5

package/dist/aws/ecr.d.ts

@@ -0,0 +1,240 @@
+/**
+ * AWS ECR (Elastic Container Registry) Client
+ * Manages Docker container image repositories using direct API calls
+ */
+export interface Repository {
+    repositoryArn?: string;
+    registryId?: string;
+    repositoryName?: string;
+    repositoryUri?: string;
+    createdAt?: string;
+    imageTagMutability?: 'MUTABLE' | 'IMMUTABLE';
+    imageScanningConfiguration?: {
+        scanOnPush?: boolean;
+    };
+    encryptionConfiguration?: {
+        encryptionType?: 'AES256' | 'KMS';
+        kmsKey?: string;
+    };
+}
+export interface AuthorizationData {
+    authorizationToken?: string;
+    expiresAt?: string;
+    proxyEndpoint?: string;
+}
+export interface ImageDetail {
+    registryId?: string;
+    repositoryName?: string;
+    imageDigest?: string;
+    imageTags?: string[];
+    imageSizeInBytes?: number;
+    imagePushedAt?: string;
+    imageScanStatus?: {
+        status?: string;
+        description?: string;
+    };
+    imageScanFindingsSummary?: {
+        findingSeverityCounts?: Record<string, number>;
+    };
+}
+export interface CreateRepositoryOptions {
+    repositoryName: string;
+    tags?: {
+        Key: string;
+        Value: string;
+    }[];
+    imageTagMutability?: 'MUTABLE' | 'IMMUTABLE';
+    imageScanningConfiguration?: {
+        scanOnPush?: boolean;
+    };
+    encryptionConfiguration?: {
+        encryptionType?: 'AES256' | 'KMS';
+        kmsKey?: string;
+    };
+}
+export interface LifecyclePolicy {
+    rulePriority: number;
+    description?: string;
+    selection: {
+        tagStatus: 'tagged' | 'untagged' | 'any';
+        tagPrefixList?: string[];
+        countType: 'imageCountMoreThan' | 'sinceImagePushed';
+        countNumber?: number;
+        countUnit?: 'days';
+    };
+    action: {
+        type: 'expire';
+    };
+}
+/**
+ * ECR service management using direct API calls
+ */
+export declare class ECRClient {
+    private client;
+    private region;
+    constructor(region?: string, profile?: string);
+    /**
+     * Create a new ECR repository
+     */
+    createRepository(options: CreateRepositoryOptions): Promise<{
+        repository?: Repository;
+    }>;
+    /**
+     * Describe ECR repositories
+     */
+    describeRepositories(options?: {
+        repositoryNames?: string[];
+        registryId?: string;
+        maxResults?: number;
+        nextToken?: string;
+    }): Promise<{
+        repositories?: Repository[];
+        nextToken?: string;
+    }>;
+    /**
+     * Get authorization token for Docker login
+     */
+    getAuthorizationToken(registryIds?: string[]): Promise<{
+        authorizationData?: AuthorizationData[];
+    }>;
+    /**
+     * Delete an ECR repository
+     */
+    deleteRepository(options: {
+        repositoryName: string;
+        registryId?: string;
+        force?: boolean;
+    }): Promise<{
+        repository?: Repository;
+    }>;
+    /**
+     * Describe images in a repository
+     */
+    describeImages(options: {
+        repositoryName: string;
+        registryId?: string;
+        imageIds?: {
+            imageTag?: string;
+            imageDigest?: string;
+        }[];
+        filter?: {
+            tagStatus?: 'TAGGED' | 'UNTAGGED' | 'ANY';
+        };
+        maxResults?: number;
+        nextToken?: string;
+    }): Promise<{
+        imageDetails?: ImageDetail[];
+        nextToken?: string;
+    }>;
+    /**
+     * Batch delete images from a repository
+     */
+    batchDeleteImage(options: {
+        repositoryName: string;
+        registryId?: string;
+        imageIds: {
+            imageTag?: string;
+            imageDigest?: string;
+        }[];
+    }): Promise<{
+        imageIds?: {
+            imageTag?: string;
+            imageDigest?: string;
+        }[];
+        failures?: {
+            imageId?: {
+                imageTag?: string;
+                imageDigest?: string;
+            };
+            failureCode?: string;
+            failureReason?: string;
+        }[];
+    }>;
+    /**
+     * Put lifecycle policy on a repository
+     */
+    putLifecyclePolicy(options: {
+        repositoryName: string;
+        registryId?: string;
+        lifecyclePolicyText: string;
+    }): Promise<{
+        registryId?: string;
+        repositoryName?: string;
+        lifecyclePolicyText?: string;
+    }>;
+    /**
+     * Get lifecycle policy for a repository
+     */
+    getLifecyclePolicy(options: {
+        repositoryName: string;
+        registryId?: string;
+    }): Promise<{
+        registryId?: string;
+        repositoryName?: string;
+        lifecyclePolicyText?: string;
+        lastEvaluatedAt?: string;
+    }>;
+    /**
+     * Set repository policy
+     */
+    setRepositoryPolicy(options: {
+        repositoryName: string;
+        policyText: string;
+        registryId?: string;
+        force?: boolean;
+    }): Promise<{
+        registryId?: string;
+        repositoryName?: string;
+        policyText?: string;
+    }>;
+    /**
+     * Get repository policy
+     */
+    getRepositoryPolicy(options: {
+        repositoryName: string;
+        registryId?: string;
+    }): Promise<{
+        registryId?: string;
+        repositoryName?: string;
+        policyText?: string;
+    }>;
+    /**
+     * Tag a repository resource
+     */
+    tagResource(options: {
+        resourceArn: string;
+        tags: {
+            Key: string;
+            Value: string;
+        }[];
+    }): Promise<void>;
+    /**
+     * List tags for a resource
+     */
+    listTagsForResource(resourceArn: string): Promise<{
+        tags?: {
+            Key: string;
+            Value: string;
+        }[];
+    }>;
+    /**
+     * Helper: Create a standard lifecycle policy to keep only N images
+     */
+    createLifecyclePolicyText(rules: LifecyclePolicy[]): string;
+    /**
+     * Helper: Get docker login command
+     */
+    getDockerLoginCommand(): Promise<string>;
+    /**
+     * Helper: Get the registry URI for this region
+     */
+    getRegistryUri(accountId: string): string;
+    /**
+     * Parse repository response
+     */
+    private parseRepository;
+    /**
+     * Parse image detail response
+     */
+    private parseImageDetail;
+}

package/dist/aws/ecs.d.ts

@@ -0,0 +1,267 @@
+/**
+ * AWS ECS Operations
+ * Direct API calls without AWS CLI dependency
+ */
+export interface Service {
+    serviceArn?: string;
+    serviceName?: string;
+    clusterArn?: string;
+    status?: string;
+    desiredCount?: number;
+    runningCount?: number;
+    pendingCount?: number;
+    launchType?: string;
+    taskDefinition?: string;
+    deployments?: Deployment[];
+    events?: ServiceEvent[];
+}
+export interface Deployment {
+    id?: string;
+    status?: string;
+    taskDefinition?: string;
+    desiredCount?: number;
+    runningCount?: number;
+    pendingCount?: number;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export interface ServiceEvent {
+    id?: string;
+    createdAt?: string;
+    message?: string;
+}
+export interface DescribeServicesOptions {
+    cluster: string;
+    services: string[];
+}
+export interface Task {
+    taskArn?: string;
+    taskDefinitionArn?: string;
+    clusterArn?: string;
+    lastStatus?: string;
+    desiredStatus?: string;
+    containers?: Container[];
+    createdAt?: string;
+    startedAt?: string;
+    stoppedAt?: string;
+}
+export interface Container {
+    containerArn?: string;
+    name?: string;
+    lastStatus?: string;
+    exitCode?: number;
+    reason?: string;
+}
+/**
+ * ECS service management using direct API calls
+ */
+export declare class ECSClient {
+    private client;
+    private region;
+    constructor(region?: string, profile?: string);
+    /**
+     * Describe ECS services
+     */
+    describeServices(options: DescribeServicesOptions): Promise<{
+        services?: Service[];
+        failures?: any[];
+    }>;
+    /**
+     * List ECS services in a cluster
+     */
+    listServices(cluster: string): Promise<{
+        serviceArns?: string[];
+    }>;
+    /**
+     * List tasks in a cluster
+     */
+    listTasks(cluster: string, serviceName?: string): Promise<{
+        taskArns?: string[];
+    }>;
+    /**
+     * Describe ECS tasks
+     */
+    describeTasks(cluster: string, tasks: string[]): Promise<{
+        tasks?: Task[];
+        failures?: any[];
+    }>;
+    /**
+     * Update ECS service (e.g., force new deployment)
+     */
+    updateService(options: {
+        cluster: string;
+        service: string;
+        forceNewDeployment?: boolean;
+        desiredCount?: number;
+        taskDefinition?: string;
+    }): Promise<{
+        service?: Service;
+    }>;
+    /**
+     * Create a new ECS service
+     */
+    createService(options: {
+        cluster: string;
+        serviceName: string;
+        taskDefinition: string;
+        desiredCount: number;
+        launchType?: 'EC2' | 'FARGATE' | 'EXTERNAL';
+        networkConfiguration?: {
+            awsvpcConfiguration: {
+                subnets: string[];
+                securityGroups?: string[];
+                assignPublicIp?: 'ENABLED' | 'DISABLED';
+            };
+        };
+        loadBalancers?: Array<{
+            targetGroupArn: string;
+            containerName: string;
+            containerPort: number;
+        }>;
+        healthCheckGracePeriodSeconds?: number;
+        deploymentConfiguration?: {
+            minimumHealthyPercent?: number;
+            maximumPercent?: number;
+        };
+    }): Promise<{
+        service?: Service;
+    }>;
+    /**
+     * Delete an ECS service
+     */
+    deleteService(options: {
+        cluster: string;
+        service: string;
+        force?: boolean;
+    }): Promise<{
+        service?: Service;
+    }>;
+    /**
+     * List ECS clusters
+     */
+    listClusters(): Promise<{
+        clusterArns?: string[];
+    }>;
+    /**
+     * Describe ECS clusters
+     */
+    describeClusters(clusters: string[]): Promise<{
+        clusters?: any[];
+        failures?: any[];
+    }>;
+    /**
+     * Stop a running task
+     */
+    stopTask(options: {
+        cluster: string;
+        task: string;
+        reason?: string;
+    }): Promise<{
+        task?: Task;
+    }>;
+    /**
+     * Run a one-off task
+     */
+    runTask(options: {
+        cluster: string;
+        taskDefinition: string;
+        count?: number;
+        launchType?: 'EC2' | 'FARGATE' | 'EXTERNAL';
+        networkConfiguration?: {
+            awsvpcConfiguration: {
+                subnets: string[];
+                securityGroups?: string[];
+                assignPublicIp?: 'ENABLED' | 'DISABLED';
+            };
+        };
+        overrides?: {
+            containerOverrides?: Array<{
+                name: string;
+                command?: string[];
+                environment?: Array<{
+                    name: string;
+                    value: string;
+                }>;
+            }>;
+        };
+    }): Promise<{
+        tasks?: Task[];
+        failures?: any[];
+    }>;
+    /**
+     * Register a new task definition
+     */
+    registerTaskDefinition(options: {
+        family: string;
+        containerDefinitions: Array<{
+            name: string;
+            image: string;
+            memory?: number;
+            cpu?: number;
+            essential?: boolean;
+            portMappings?: Array<{
+                containerPort: number;
+                hostPort?: number;
+                protocol?: 'tcp' | 'udp';
+            }>;
+            environment?: Array<{
+                name: string;
+                value: string;
+            }>;
+            secrets?: Array<{
+                name: string;
+                valueFrom: string;
+            }>;
+            logConfiguration?: {
+                logDriver: string;
+                options?: Record<string, string>;
+            };
+        }>;
+        cpu?: string;
+        memory?: string;
+        networkMode?: 'bridge' | 'host' | 'awsvpc' | 'none';
+        requiresCompatibilities?: Array<'EC2' | 'FARGATE' | 'EXTERNAL'>;
+        executionRoleArn?: string;
+        taskRoleArn?: string;
+    }): Promise<{
+        taskDefinition?: any;
+    }>;
+    /**
+     * Deregister a task definition
+     */
+    deregisterTaskDefinition(taskDefinition: string): Promise<{
+        taskDefinition?: any;
+    }>;
+    /**
+     * Describe task definitions
+     */
+    describeTaskDefinition(taskDefinition: string): Promise<{
+        taskDefinition?: any;
+        tags?: any[];
+    }>;
+    /**
+     * List task definition families
+     */
+    listTaskDefinitionFamilies(options?: {
+        familyPrefix?: string;
+        status?: 'ACTIVE' | 'INACTIVE' | 'ALL';
+    }): Promise<{
+        families?: string[];
+    }>;
+    /**
+     * Wait for service to become stable
+     */
+    waitForServiceStable(cluster: string, service: string, maxAttempts?: number, delayMs?: number): Promise<boolean>;
+    /**
+     * Helper: Force new deployment
+     */
+    forceNewDeployment(cluster: string, service: string): Promise<{
+        service?: Service;
+    }>;
+    /**
+     * Helper: Scale service
+     */
+    scaleService(cluster: string, service: string, desiredCount: number): Promise<{
+        service?: Service;
+    }>;
+}

package/dist/aws/efs.d.ts

@@ -0,0 +1,36 @@
+/**
+ * AWS EFS (Elastic File System) Client
+ * Manages EFS file systems using direct API calls
+ */
+export interface FileSystem {
+    FileSystemId?: string;
+    Name?: string;
+    CreationTime?: string;
+    LifeCycleState?: 'creating' | 'available' | 'updating' | 'deleting' | 'deleted' | 'error';
+    NumberOfMountTargets?: number;
+    SizeInBytes?: {
+        Value?: number;
+        Timestamp?: string;
+    };
+    PerformanceMode?: 'generalPurpose' | 'maxIO';
+    Encrypted?: boolean;
+    ThroughputMode?: 'bursting' | 'provisioned' | 'elastic';
+    Tags?: {
+        Key?: string;
+        Value?: string;
+    }[];
+}
+export declare class EFSClient {
+    private client;
+    private region;
+    constructor(region?: string);
+    /**
+     * Describe EFS file systems
+     */
+    describeFileSystems(options?: {
+        FileSystemId?: string;
+        CreationToken?: string;
+    }): Promise<{
+        FileSystems?: FileSystem[];
+    }>;
+}

package/dist/aws/elasticache.d.ts

@@ -0,0 +1,112 @@
+/**
+ * AWS ElastiCache Operations
+ * Direct API calls without AWS CLI dependency
+ */
+export interface CacheCluster {
+    CacheClusterId: string;
+    CacheClusterStatus: string;
+    Engine: string;
+    EngineVersion: string;
+    CacheNodeType: string;
+    NumCacheNodes: number;
+    PreferredAvailabilityZone?: string;
+    CacheClusterCreateTime: string;
+    CacheNodes?: Array<{
+        CacheNodeId: string;
+        CacheNodeStatus: string;
+        Endpoint?: {
+            Address: string;
+            Port: number;
+        };
+    }>;
+}
+export interface ReplicationGroup {
+    ReplicationGroupId: string;
+    Status: string;
+    Description?: string;
+    MemberClusters?: string[];
+    NodeGroups?: Array<{
+        NodeGroupId: string;
+        Status: string;
+        PrimaryEndpoint?: {
+            Address: string;
+            Port: number;
+        };
+    }>;
+}
+export interface CacheEngineVersion {
+    Engine: string;
+    EngineVersion: string;
+    CacheParameterGroupFamily: string;
+}
+/**
+ * ElastiCache management using direct API calls
+ */
+export declare class ElastiCacheClient {
+    private client;
+    private region;
+    constructor(region?: string, profile?: string);
+    /**
+     * List all cache clusters
+     */
+    describeCacheClusters(cacheClusterId?: string): Promise<{
+        CacheClusters: CacheCluster[];
+    }>;
+    /**
+     * List all replication groups (Redis clusters)
+     */
+    describeReplicationGroups(replicationGroupId?: string): Promise<{
+        ReplicationGroups: ReplicationGroup[];
+    }>;
+    /**
+     * Create a cache cluster
+     */
+    createCacheCluster(options: {
+        cacheClusterId: string;
+        engine: 'memcached' | 'redis';
+        cacheNodeType: string;
+        numCacheNodes?: number;
+        engineVersion?: string;
+        port?: number;
+        securityGroupIds?: string[];
+        subnetGroupName?: string;
+        tags?: Array<{
+            Key: string;
+            Value: string;
+        }>;
+    }): Promise<{
+        CacheCluster: CacheCluster;
+    }>;
+    /**
+     * Delete a cache cluster
+     */
+    deleteCacheCluster(cacheClusterId: string, finalSnapshotId?: string): Promise<void>;
+    /**
+     * Reboot cache cluster nodes
+     */
+    rebootCacheCluster(cacheClusterId: string, nodeIds: string[]): Promise<void>;
+    /**
+     * List available cache engine versions
+     */
+    describeCacheEngineVersions(engine?: string): Promise<{
+        CacheEngineVersions: CacheEngineVersion[];
+    }>;
+    /**
+     * Get cache cluster statistics (mock for now)
+     */
+    getCacheStatistics(cacheClusterId: string): Promise<{
+        cpuUtilization?: number;
+        evictions?: number;
+        hits?: number;
+        misses?: number;
+        connections?: number;
+    }>;
+    /**
+     * Parse cache clusters from response
+     */
+    private parseCacheClusters;
+    /**
+     * Parse single cache cluster from response
+     */
+    private parseCacheCluster;
+}