@stacksjs/ts-cloud 0.1.2 → 0.1.5

package/dist/aws/ec2.d.ts

@@ -0,0 +1,272 @@
+import { AWSClient } from './client';
+export declare interface Instance {
+  InstanceId?: string
+  ImageId?: string
+  InstanceType?: string
+  State?: {
+    Code?: number
+    Name?: 'pending' | 'running' | 'shutting-down' | 'terminated' | 'stopping' | 'stopped'
+  }
+  PrivateIpAddress?: string
+  PublicIpAddress?: string
+  SubnetId?: string
+  VpcId?: string
+  SecurityGroups?: { GroupId?: string, GroupName?: string }[]
+  Tags?: { Key?: string, Value?: string }[]
+  LaunchTime?: string
+  Placement?: {
+    AvailabilityZone?: string
+    Tenancy?: string
+  }
+  Architecture?: string
+  RootDeviceType?: string
+  RootDeviceName?: string
+  BlockDeviceMappings?: {
+    DeviceName?: string
+    Ebs?: {
+      VolumeId?: string
+      Status?: string
+      AttachTime?: string
+      DeleteOnTermination?: boolean
+    }
+  }[]
+  IamInstanceProfile?: {
+    Arn?: string
+    Id?: string
+  }
+}
+export declare interface Vpc {
+  VpcId?: string
+  CidrBlock?: string
+  State?: 'pending' | 'available'
+  DhcpOptionsId?: string
+  InstanceTenancy?: string
+  IsDefault?: boolean
+  Tags?: { Key?: string, Value?: string }[]
+}
+export declare interface Subnet {
+  SubnetId?: string
+  VpcId?: string
+  CidrBlock?: string
+  AvailabilityZone?: string
+  AvailableIpAddressCount?: number
+  State?: 'pending' | 'available'
+  MapPublicIpOnLaunch?: boolean
+  Tags?: { Key?: string, Value?: string }[]
+}
+export declare interface SecurityGroup {
+  GroupId?: string
+  GroupName?: string
+  Description?: string
+  VpcId?: string
+  IpPermissions?: IpPermission[]
+  IpPermissionsEgress?: IpPermission[]
+  Tags?: { Key?: string, Value?: string }[]
+}
+export declare interface IpPermission {
+  IpProtocol?: string
+  FromPort?: number
+  ToPort?: number
+  IpRanges?: { CidrIp?: string, Description?: string }[]
+  Ipv6Ranges?: { CidrIpv6?: string, Description?: string }[]
+  UserIdGroupPairs?: { GroupId?: string, UserId?: string, Description?: string }[]
+}
+export declare interface InternetGateway {
+  InternetGatewayId?: string
+  Attachments?: { VpcId?: string, State?: string }[]
+  Tags?: { Key?: string, Value?: string }[]
+}
+export declare interface RouteTable {
+  RouteTableId?: string
+  VpcId?: string
+  Routes?: {
+    DestinationCidrBlock?: string
+    GatewayId?: string
+    NatGatewayId?: string
+    State?: string
+  }[]
+  Associations?: {
+    RouteTableAssociationId?: string
+    SubnetId?: string
+    Main?: boolean
+  }[]
+  Tags?: { Key?: string, Value?: string }[]
+}
+export declare interface Address {
+  PublicIp?: string
+  AllocationId?: string
+  AssociationId?: string
+  InstanceId?: string
+  NetworkInterfaceId?: string
+  PrivateIpAddress?: string
+  Domain?: 'vpc' | 'standard'
+  Tags?: { Key?: string, Value?: string }[]
+}
+export declare interface ConsoleOutput {
+  InstanceId?: string
+  Output?: string
+  Timestamp?: string
+}
+export declare interface InstanceStatus {
+  InstanceId?: string
+  InstanceState?: {
+    Code?: number
+    Name?: string
+  }
+  InstanceStatus?: {
+    Status?: string
+    Details?: { Name?: string, Status?: string }[]
+  }
+  SystemStatus?: {
+    Status?: string
+    Details?: { Name?: string, Status?: string }[]
+  }
+}
+/**
+ * EC2 client using direct API calls
+ */
+export declare class EC2Client {
+  private client: AWSClient;
+  private region: string;
+  constructor(region?: string);
+  describeInstances(options?: {
+    InstanceIds?: string[]
+    Filters?: { Name: string, Values: string[] }[]
+    MaxResults?: number
+    NextToken?: string
+  }): Promise<{
+    Reservations?: {
+      ReservationId?: string
+      Instances?: Instance[]
+    }[]
+    NextToken?: string
+  }>;
+  getInstance(instanceId: string): Promise<Instance | undefined>;
+  getConsoleOutput(instanceId: string, latest?: boolean): Promise<ConsoleOutput>;
+  getConsoleOutputDecoded(instanceId: string, options?: {
+    latest?: boolean
+    tailLines?: number
+  }): Promise<string>;
+  describeInstanceStatus(options?: {
+    InstanceIds?: string[]
+    IncludeAllInstances?: boolean
+    Filters?: { Name: string, Values: string[] }[]
+  }): Promise<{
+    InstanceStatuses?: InstanceStatus[]
+  }>;
+  startInstances(instanceIds: string[]): Promise<{
+    StartingInstances?: { InstanceId?: string, CurrentState?: { Name?: string }, PreviousState?: { Name?: string } }[]
+  }>;
+  stopInstances(instanceIds: string[], force?: boolean): Promise<{
+    StoppingInstances?: { InstanceId?: string, CurrentState?: { Name?: string }, PreviousState?: { Name?: string } }[]
+  }>;
+  rebootInstances(instanceIds: string[]): Promise<void>;
+  terminateInstances(instanceIds: string[]): Promise<{
+    TerminatingInstances?: { InstanceId?: string, CurrentState?: { Name?: string }, PreviousState?: { Name?: string } }[]
+  }>;
+  describeVpcs(options?: {
+    VpcIds?: string[]
+    Filters?: { Name: string, Values: string[] }[]
+  }): Promise<{
+    Vpcs?: Vpc[]
+  }>;
+  describeSubnets(options?: {
+    SubnetIds?: string[]
+    Filters?: { Name: string, Values: string[] }[]
+  }): Promise<{
+    Subnets?: Subnet[]
+  }>;
+  describeSecurityGroups(options?: {
+    GroupIds?: string[]
+    GroupNames?: string[]
+    Filters?: { Name: string, Values: string[] }[]
+  }): Promise<{
+    SecurityGroups?: SecurityGroup[]
+  }>;
+  describeInternetGateways(options?: {
+    InternetGatewayIds?: string[]
+    Filters?: { Name: string, Values: string[] }[]
+  }): Promise<{
+    InternetGateways?: InternetGateway[]
+  }>;
+  describeAddresses(options?: {
+    AllocationIds?: string[]
+    PublicIps?: string[]
+    Filters?: { Name: string, Values: string[] }[]
+  }): Promise<{
+    Addresses?: Address[]
+  }>;
+  allocateAddress(options?: {
+    Domain?: 'vpc' | 'standard'
+    TagSpecifications?: { ResourceType: string, Tags: { Key: string, Value: string }[] }[]
+  }): Promise<{
+    AllocationId?: string
+    PublicIp?: string
+    Domain?: string
+  }>;
+  associateAddress(options: {
+    AllocationId?: string
+    PublicIp?: string
+    InstanceId?: string
+    NetworkInterfaceId?: string
+    PrivateIpAddress?: string
+    AllowReassociation?: boolean
+  }): Promise<{
+    AssociationId?: string
+  }>;
+  createTags(options: {
+    Resources: string[]
+    Tags: { Key: string, Value: string }[]
+  }): Promise<void>;
+  waitForInstanceState(instanceId: string, targetState: 'running' | 'stopped' | 'terminated', options?: {
+      maxWaitMs?: number
+      pollIntervalMs?: number
+    }): Promise<Instance | undefined>;
+  createVpc(options: {
+    CidrBlock: string
+    InstanceTenancy?: string
+    TagSpecifications?: { ResourceType: string, Tags: { Key: string, Value: string }[] }[]
+  }): Promise<{
+    Vpc?: Vpc
+  }>;
+  createSubnet(options: {
+    VpcId: string
+    CidrBlock: string
+    AvailabilityZone?: string
+    TagSpecifications?: { ResourceType: string, Tags: { Key: string, Value: string }[] }[]
+  }): Promise<{
+    Subnet?: Subnet
+  }>;
+  modifySubnetAttribute(options: {
+    SubnetId: string
+    MapPublicIpOnLaunch?: { Value: boolean }
+  }): Promise<void>;
+  createSecurityGroup(options: {
+    GroupName: string
+    Description: string
+    VpcId?: string
+    TagSpecifications?: { ResourceType: string, Tags: { Key: string, Value: string }[] }[]
+  }): Promise<{
+    GroupId?: string
+  }>;
+  authorizeSecurityGroupIngress(options: {
+    GroupId: string
+    IpPermissions: IpPermission[]
+  }): Promise<void>;
+  authorizeSecurityGroupEgress(options: {
+    GroupId: string
+    IpPermissions: IpPermission[]
+  }): Promise<void>;
+  describeRouteTables(options?: {
+    RouteTableIds?: string[]
+    Filters?: { Name: string, Values: string[] }[]
+  }): Promise<{
+    RouteTables?: RouteTable[]
+  }>;
+  private encodeIpPermissions(params: Record<string, string>, permissions: IpPermission[]): void;
+  private parseArray(item: any): any[];
+  private parseTags(item: any): { Key?: string, Value?: string }[];
+  private parseReservations(item: any): { ReservationId?: string, Instances?: Instance[] }[];
+  private parseInstances(item: any): Instance[];
+  private parseIpPermissions(item: any): IpPermission[];
+}

package/dist/aws/ecr.d.ts

@@ -0,0 +1,149 @@
+import { AWSClient } from './client';
+export declare 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 declare interface AuthorizationData {
+  authorizationToken?: string
+  expiresAt?: string
+  proxyEndpoint?: string
+}
+export declare 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 declare interface CreateRepositoryOptions {
+  repositoryName: string
+  tags?: { Key: string, Value: string }[]
+  imageTagMutability?: 'MUTABLE' | 'IMMUTABLE'
+  imageScanningConfiguration?: {
+    scanOnPush?: boolean
+  }
+  encryptionConfiguration?: {
+    encryptionType?: 'AES256' | 'KMS'
+    kmsKey?: string
+  }
+}
+export declare 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: AWSClient;
+  private region: string;
+  constructor(region?: string, profile?: string);
+  createRepository(options: CreateRepositoryOptions): Promise<{ repository?: Repository }>;
+  describeRepositories(options?: {
+    repositoryNames?: string[]
+    registryId?: string
+    maxResults?: number
+    nextToken?: string
+  }): Promise<{ repositories?: Repository[], nextToken?: string }>;
+  getAuthorizationToken(registryIds?: string[]): Promise<{
+    authorizationData?: AuthorizationData[]
+  }>;
+  deleteRepository(options: {
+    repositoryName: string
+    registryId?: string
+    force?: boolean
+  }): Promise<{ repository?: 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 }>;
+  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 }[]
+  }>;
+  putLifecyclePolicy(options: {
+    repositoryName: string
+    registryId?: string
+    lifecyclePolicyText: string
+  }): Promise<{
+    registryId?: string
+    repositoryName?: string
+    lifecyclePolicyText?: string
+  }>;
+  getLifecyclePolicy(options: {
+    repositoryName: string
+    registryId?: string
+  }): Promise<{
+    registryId?: string
+    repositoryName?: string
+    lifecyclePolicyText?: string
+    lastEvaluatedAt?: string
+  }>;
+  setRepositoryPolicy(options: {
+    repositoryName: string
+    policyText: string
+    registryId?: string
+    force?: boolean
+  }): Promise<{
+    registryId?: string
+    repositoryName?: string
+    policyText?: string
+  }>;
+  getRepositoryPolicy(options: {
+    repositoryName: string
+    registryId?: string
+  }): Promise<{
+    registryId?: string
+    repositoryName?: string
+    policyText?: string
+  }>;
+  tagResource(options: {
+    resourceArn: string
+    tags: { Key: string, Value: string }[]
+  }): Promise<void>;
+  listTagsForResource(resourceArn: string): Promise<{
+    tags?: { Key: string, Value: string }[]
+  }>;
+  createLifecyclePolicyText(rules: LifecyclePolicy[]): string;
+  getDockerLoginCommand(): Promise<string>;
+  getRegistryUri(accountId: string): string;
+  private parseRepository(repo: any): Repository;
+  private parseImageDetail(img: any): ImageDetail;
+}

package/dist/aws/ecs.d.ts

@@ -0,0 +1,162 @@
+import { AWSClient } from './client';
+export declare 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 declare interface Deployment {
+  id?: string
+  status?: string
+  taskDefinition?: string
+  desiredCount?: number
+  runningCount?: number
+  pendingCount?: number
+  createdAt?: string
+  updatedAt?: string
+}
+export declare interface ServiceEvent {
+  id?: string
+  createdAt?: string
+  message?: string
+}
+export declare interface DescribeServicesOptions {
+  cluster: string
+  services: string[]
+}
+export declare interface Task {
+  taskArn?: string
+  taskDefinitionArn?: string
+  clusterArn?: string
+  lastStatus?: string
+  desiredStatus?: string
+  containers?: Container[]
+  createdAt?: string
+  startedAt?: string
+  stoppedAt?: string
+}
+export declare 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: AWSClient;
+  private region: string;
+  constructor(region?: string, profile?: string);
+  describeServices(options: DescribeServicesOptions): Promise<{ services?: Service[], failures?: any[] }>;
+  listServices(cluster: string): Promise<{ serviceArns?: string[] }>;
+  listTasks(cluster: string, serviceName?: string): Promise<{ taskArns?: string[] }>;
+  describeTasks(cluster: string, tasks: string[]): Promise<{ tasks?: Task[], failures?: any[] }>;
+  updateService(options: {
+    cluster: string
+    service: string
+    forceNewDeployment?: boolean
+    desiredCount?: number
+    taskDefinition?: string
+  }): Promise<{ service?: 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 }>;
+  deleteService(options: {
+    cluster: string
+    service: string
+    force?: boolean
+  }): Promise<{ service?: Service }>;
+  listClusters(): Promise<{ clusterArns?: string[] }>;
+  describeClusters(clusters: string[]): Promise<{ clusters?: any[], failures?: any[] }>;
+  stopTask(options: {
+    cluster: string
+    task: string
+    reason?: string
+  }): Promise<{ task?: 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[] }>;
+  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 }>;
+  deregisterTaskDefinition(taskDefinition: string): Promise<{ taskDefinition?: any }>;
+  describeTaskDefinition(taskDefinition: string): Promise<{ taskDefinition?: any, tags?: any[] }>;
+  listTaskDefinitionFamilies(options?: {
+    familyPrefix?: string
+    status?: 'ACTIVE' | 'INACTIVE' | 'ALL'
+  }): Promise<{ families?: string[] }>;
+  waitForServiceStable(cluster: string, service: string, maxAttempts?: any, delayMs?: any): Promise<boolean>;
+  forceNewDeployment(cluster: string, service: string): Promise<{ service?: Service }>;
+  scaleService(cluster: string, service: string, desiredCount: number): Promise<{ service?: Service }>;
+}

package/dist/aws/elasticache.d.ts

@@ -0,0 +1,71 @@
+import { AWSClient } from './client';
+export declare 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 declare interface ReplicationGroup {
+  ReplicationGroupId: string
+  Status: string
+  Description?: string
+  MemberClusters?: string[]
+  NodeGroups?: Array<{
+    NodeGroupId: string
+    Status: string
+    PrimaryEndpoint?: {
+      Address: string
+      Port: number
+    }
+  }>
+}
+export declare interface CacheEngineVersion {
+  Engine: string
+  EngineVersion: string
+  CacheParameterGroupFamily: string
+}
+/**
+ * ElastiCache management using direct API calls
+ */
+export declare class ElastiCacheClient {
+  private client: AWSClient;
+  private region: string;
+  constructor(region?: string, profile?: string);
+  describeCacheClusters(cacheClusterId?: string): Promise<{ CacheClusters: CacheCluster[] }>;
+  describeReplicationGroups(replicationGroupId?: string): Promise<{ ReplicationGroups: ReplicationGroup[] }>;
+  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 }>;
+  deleteCacheCluster(cacheClusterId: string, finalSnapshotId?: string): Promise<void>;
+  rebootCacheCluster(cacheClusterId: string, nodeIds: string[]): Promise<void>;
+  describeCacheEngineVersions(engine?: string): Promise<{ CacheEngineVersions: CacheEngineVersion[] }>;
+  getCacheStatistics(cacheClusterId: string): Promise<{
+    cpuUtilization?: number
+    evictions?: number
+    hits?: number
+    misses?: number
+    connections?: number
+  }>;
+  private parseCacheClusters(result: any): CacheCluster[];
+  private parseCacheCluster(result: any): CacheCluster;
+}