@stacksjs/ts-cloud 0.1.9 → 0.1.14

package/dist/aws/ec2.d.ts

@@ -1,272 +0,0 @@
-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

@@ -1,149 +0,0 @@
-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

@@ -1,162 +0,0 @@
-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

@@ -1,71 +0,0 @@
-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;
-}