@stacksjs/ts-cloud 0.1.11 → 0.1.14

package/dist/aws/elbv2.d.ts

@@ -1,248 +0,0 @@
-import { AWSClient } from './client';
-export declare interface LoadBalancer {
-  LoadBalancerArn?: string
-  DNSName?: string
-  CanonicalHostedZoneId?: string
-  CreatedTime?: string
-  LoadBalancerName?: string
-  Scheme?: 'internet-facing' | 'internal'
-  VpcId?: string
-  State?: {
-    Code?: 'active' | 'provisioning' | 'active_impaired' | 'failed'
-    Reason?: string
-  }
-  Type?: 'application' | 'network' | 'gateway'
-  AvailabilityZones?: AvailabilityZone[]
-  SecurityGroups?: string[]
-  IpAddressType?: 'ipv4' | 'dualstack'
-}
-export declare interface AvailabilityZone {
-  ZoneName?: string
-  SubnetId?: string
-  OutpostId?: string
-  LoadBalancerAddresses?: LoadBalancerAddress[]
-}
-export declare interface LoadBalancerAddress {
-  IpAddress?: string
-  AllocationId?: string
-  PrivateIPv4Address?: string
-  IPv6Address?: string
-}
-export declare interface TargetGroup {
-  TargetGroupArn?: string
-  TargetGroupName?: string
-  Protocol?: string
-  Port?: number
-  VpcId?: string
-  HealthCheckProtocol?: string
-  HealthCheckPort?: string
-  HealthCheckEnabled?: boolean
-  HealthCheckIntervalSeconds?: number
-  HealthCheckTimeoutSeconds?: number
-  HealthyThresholdCount?: number
-  UnhealthyThresholdCount?: number
-  HealthCheckPath?: string
-  Matcher?: {
-    HttpCode?: string
-    GrpcCode?: string
-  }
-  LoadBalancerArns?: string[]
-  TargetType?: 'instance' | 'ip' | 'lambda' | 'alb'
-  ProtocolVersion?: string
-  IpAddressType?: 'ipv4' | 'ipv6'
-}
-export declare interface Listener {
-  ListenerArn?: string
-  LoadBalancerArn?: string
-  Port?: number
-  Protocol?: string
-  Certificates?: Certificate[]
-  SslPolicy?: string
-  DefaultActions?: Action[]
-  AlpnPolicy?: string[]
-}
-export declare interface Certificate {
-  CertificateArn?: string
-  IsDefault?: boolean
-}
-export declare interface Action {
-  Type?: 'forward' | 'redirect' | 'fixed-response' | 'authenticate-oidc' | 'authenticate-cognito'
-  TargetGroupArn?: string
-  Order?: number
-  RedirectConfig?: {
-    Protocol?: string
-    Port?: string
-    Host?: string
-    Path?: string
-    Query?: string
-    StatusCode?: 'HTTP_301' | 'HTTP_302'
-  }
-  FixedResponseConfig?: {
-    MessageBody?: string
-    StatusCode?: string
-    ContentType?: string
-  }
-  ForwardConfig?: {
-    TargetGroups?: Array<{
-      TargetGroupArn?: string
-      Weight?: number
-    }>
-    TargetGroupStickinessConfig?: {
-      Enabled?: boolean
-      DurationSeconds?: number
-    }
-  }
-}
-export declare interface Rule {
-  RuleArn?: string
-  Priority?: string
-  Conditions?: Condition[]
-  Actions?: Action[]
-  IsDefault?: boolean
-}
-export declare interface Condition {
-  Field?: string
-  Values?: string[]
-  HostHeaderConfig?: { Values?: string[] }
-  PathPatternConfig?: { Values?: string[] }
-  HttpHeaderConfig?: { HttpHeaderName?: string, Values?: string[] }
-  QueryStringConfig?: { Values?: Array<{ Key?: string, Value?: string }> }
-  HttpRequestMethodConfig?: { Values?: string[] }
-  SourceIpConfig?: { Values?: string[] }
-}
-export declare interface TargetHealthDescription {
-  Target?: {
-    Id?: string
-    Port?: number
-    AvailabilityZone?: string
-  }
-  HealthCheckPort?: string
-  TargetHealth?: {
-    State?: 'initial' | 'healthy' | 'unhealthy' | 'unused' | 'draining' | 'unavailable'
-    Reason?: string
-    Description?: string
-  }
-}
-/**
- * ELBv2 client for managing Application, Network, and Gateway Load Balancers
- */
-export declare class ELBv2Client {
-  private client: AWSClient;
-  private region: string;
-  constructor(region?: string);
-  describeLoadBalancers(options?: {
-    LoadBalancerArns?: string[]
-    Names?: string[]
-    Marker?: string
-    PageSize?: number
-  }): Promise<{ LoadBalancers?: LoadBalancer[], NextMarker?: string }>;
-  describeTargetGroups(options?: {
-    LoadBalancerArn?: string
-    TargetGroupArns?: string[]
-    Names?: string[]
-    Marker?: string
-    PageSize?: number
-  }): Promise<{ TargetGroups?: TargetGroup[], NextMarker?: string }>;
-  describeTargetHealth(options: {
-    TargetGroupArn: string
-    Targets?: Array<{ Id: string, Port?: number, AvailabilityZone?: string }>
-  }): Promise<{ TargetHealthDescriptions?: TargetHealthDescription[] }>;
-  describeListeners(options?: {
-    LoadBalancerArn?: string
-    ListenerArns?: string[]
-    Marker?: string
-    PageSize?: number
-  }): Promise<{ Listeners?: Listener[], NextMarker?: string }>;
-  describeRules(options?: {
-    ListenerArn?: string
-    RuleArns?: string[]
-    Marker?: string
-    PageSize?: number
-  }): Promise<{ Rules?: Rule[], NextMarker?: string }>;
-  describeLoadBalancerAttributes(loadBalancerArn: string): Promise<{ Attributes?: Array<{ Key: string, Value: string }> }>;
-  describeTargetGroupAttributes(targetGroupArn: string): Promise<{ Attributes?: Array<{ Key: string, Value: string }> }>;
-  createLoadBalancer(options: {
-    Name: string
-    Subnets?: string[]
-    SubnetMappings?: Array<{
-      SubnetId: string
-      AllocationId?: string
-      PrivateIPv4Address?: string
-      IPv6Address?: string
-    }>
-    SecurityGroups?: string[]
-    Scheme?: 'internet-facing' | 'internal'
-    Type?: 'application' | 'network' | 'gateway'
-    IpAddressType?: 'ipv4' | 'dualstack'
-    Tags?: Array<{ Key: string, Value: string }>
-  }): Promise<{ LoadBalancers?: LoadBalancer[] }>;
-  deleteLoadBalancer(loadBalancerArn: string): Promise<void>;
-  createTargetGroup(options: {
-    Name: string
-    Protocol?: string
-    ProtocolVersion?: string
-    Port?: number
-    VpcId?: string
-    HealthCheckProtocol?: string
-    HealthCheckPort?: string
-    HealthCheckEnabled?: boolean
-    HealthCheckPath?: string
-    HealthCheckIntervalSeconds?: number
-    HealthCheckTimeoutSeconds?: number
-    HealthyThresholdCount?: number
-    UnhealthyThresholdCount?: number
-    Matcher?: { HttpCode?: string, GrpcCode?: string }
-    TargetType?: 'instance' | 'ip' | 'lambda' | 'alb'
-    Tags?: Array<{ Key: string, Value: string }>
-    IpAddressType?: 'ipv4' | 'ipv6'
-  }): Promise<{ TargetGroups?: TargetGroup[] }>;
-  deleteTargetGroup(targetGroupArn: string): Promise<void>;
-  registerTargets(options: {
-    TargetGroupArn: string
-    Targets: Array<{ Id: string, Port?: number, AvailabilityZone?: string }>
-  }): Promise<void>;
-  deregisterTargets(options: {
-    TargetGroupArn: string
-    Targets: Array<{ Id: string, Port?: number, AvailabilityZone?: string }>
-  }): Promise<void>;
-  createListener(options: {
-    LoadBalancerArn: string
-    Protocol?: string
-    Port: number
-    SslPolicy?: string
-    Certificates?: Array<{ CertificateArn: string }>
-    DefaultActions: Array<{
-      Type: 'forward' | 'redirect' | 'fixed-response'
-      TargetGroupArn?: string
-      Order?: number
-      RedirectConfig?: {
-        Protocol?: string
-        Port?: string
-        Host?: string
-        Path?: string
-        Query?: string
-        StatusCode: 'HTTP_301' | 'HTTP_302'
-      }
-      FixedResponseConfig?: {
-        MessageBody?: string
-        StatusCode: string
-        ContentType?: string
-      }
-    }>
-    AlpnPolicy?: string[]
-    Tags?: Array<{ Key: string, Value: string }>
-  }): Promise<{ Listeners?: Listener[] }>;
-  deleteListener(listenerArn: string): Promise<void>;
-  modifyListener(options: {
-    ListenerArn: string
-    Port?: number
-    Protocol?: string
-    SslPolicy?: string
-    Certificates?: Array<{ CertificateArn: string }>
-    DefaultActions?: Action[]
-    AlpnPolicy?: string[]
-  }): Promise<{ Listeners?: Listener[] }>;
-  private buildFormBody(action: string, params: Record<string, any>): string;
-  private normalizeResult(parsed: any, resultKey: string): any;
-  private normalizeArrays(obj: any): any;
-}

package/dist/aws/email.d.ts

@@ -1,175 +0,0 @@
-import { IAMClient } from './iam';
-import { Route53Client } from './route53';
-import { S3Client } from './s3';
-import { SESClient } from './ses';
-// Export a default instance for convenience
-export declare const email: EmailClient;
-export declare interface EmailConfig {
-  domain: string
-  region?: string
-  mailboxes?: string[]
-  storage?: {
-    bucket?: string
-    prefix?: string
-    retentionDays?: number
-  }
-  smtp?: {
-    enabled?: boolean
-    username?: string
-  }
-}
-export declare interface EmailSetupResult {
-  domainVerified: boolean
-  dkimStatus: string
-  dkimTokens?: string[]
-  mailFromStatus?: string
-  receiptRuleSet?: string
-  storageBucket?: string
-  smtpCredentials?: {
-    username: string
-    server: string
-    port: number
-  }
-}
-export declare interface SendEmailOptions {
-  from?: string
-  fromName?: string
-  to: string | string[]
-  cc?: string | string[]
-  bcc?: string | string[]
-  subject: string
-  text?: string
-  html?: string
-  replyTo?: string | string[]
-  attachments?: Array<{
-    filename: string
-    content: string // Base64 encoded
-    contentType?: string
-  }>
-}
-export declare interface EmailDeploymentConfig {
-  domain: string
-  accountId: string
-  region?: string
-  appName: string
-  environment: string
-  mailboxes?: string[]
-  catchAll?: boolean
-  storage?: {
-    bucketName?: string
-    prefix?: string
-  }
-  notifications?: {
-    bounces?: boolean
-    complaints?: boolean
-    newEmail?: boolean
-  }
-}
-/**
- * High-level Email client for serverless and server deployments
- */
-export declare class EmailClient {
-  private ses: SESClient;
-  private s3: S3Client;
-  private iam: IAMClient;
-  private route53: Route53Client;
-  private region: string;
-  private domain?: string;
-  private defaultFrom?: string;
-  constructor(options?: {
-    region?: string
-    domain?: string
-    defaultFrom?: string
-  });
-  send(options: SendEmailOptions): Promise<{ messageId: string }>;
-  sendTemplate(options: {
-    from?: string
-    fromName?: string
-    to: string | string[]
-    templateName: string
-    templateData: Record<string, any>
-    replyTo?: string | string[]
-  }): Promise<{ messageId: string }>;
-  sendBulk(options: {
-    from?: string
-    templateName: string
-    defaultTemplateData: Record<string, any>
-    recipients: Array<{
-      to: string | string[]
-      templateData?: Record<string, any>
-    }>
-  }): Promise<{ results: Array<{ status: string; messageId?: string; error?: string }> }>;
-  setupDomain(domain: string): Promise<EmailSetupResult>;
-  getDnsRecords(domain: string): Promise<Array<{
-    type: string
-    name: string
-    value: string
-    priority?: number
-    ttl?: number
-  }>>;
-  isDomainReady(domain: string): Promise<boolean>;
-  setupReceiving(config: {
-    domain: string
-    ruleSetName: string
-    ruleName: string
-    bucketName: string
-    prefix?: string
-    accountId: string
-    recipients?: string[] // If not provided, catches all domain emails
-    scanEnabled?: boolean
-    lambdaArn?: string
-  }): Promise<void>;
-  getIncomingEmails(options: {
-    bucket: string
-    prefix?: string
-    maxResults?: number
-  }): Promise<Array<{ key: string; lastModified: string; size: number }>>;
-  readEmail(options: {
-    bucket: string
-    key: string
-  }): Promise<string>;
-  createSmtpCredentials(options: {
-    username: string
-    domain: string
-  }): Promise<{
-    username: string
-    password: string
-    server: string
-    port: number
-  }>;
-  private deriveSmtpPassword(secretAccessKey: string): string;
-  createTemplate(options: {
-    name: string
-    subject: string
-    text?: string
-    html?: string
-  }): Promise<void>;
-  getTemplate(name: string): Promise<{
-    name: string
-    subject?: string
-    text?: string
-    html?: string
-  } | null>;
-  deleteTemplate(name: string): Promise<void>;
-  listTemplates(): Promise<Array<{ name: string; createdAt?: string }>>;
-  deploy(config: EmailDeploymentConfig): Promise<{
-    success: boolean
-    domainVerified: boolean
-    dkimStatus: string
-    receiptRuleSet: string
-    storageBucket: string
-    dnsRecords: Array<{ type: string; name: string; value: string }>
-  }>;
-  undeploy(config: {
-    appName: string
-    environment: string
-    domain: string
-    deleteBucket?: boolean
-  }): Promise<void>;
-  getSendingStats(): Promise<{
-    sentLast24Hours: number
-    maxSendRate: number
-    max24HourSend: number
-  }>;
-  private buildRawEmail(options: SendEmailOptions, from: string, to: string[]): string;
-}

package/dist/aws/eventbridge.d.ts

@@ -1,142 +0,0 @@
-import { AWSClient } from './client';
-export declare interface EventBridgeRule {
-  Name: string
-  Arn?: string
-  EventPattern?: string
-  ScheduleExpression?: string
-  State?: 'ENABLED' | 'DISABLED'
-  Description?: string
-  RoleArn?: string
-  EventBusName?: string
-}
-export declare interface EventBus {
-  Name?: string
-  Arn?: string
-  Policy?: string
-}
-export declare interface EventBridgeTarget {
-  Id: string
-  Arn: string
-  RoleArn?: string
-  Input?: string
-  InputPath?: string
-  InputTransformer?: {
-    InputPathsMap?: Record<string, string>
-    InputTemplate: string
-  }
-  RetryPolicy?: {
-    MaximumRetryAttempts?: number
-    MaximumEventAgeInSeconds?: number
-  }
-}
-/**
- * EventBridge client for direct API calls
- */
-export declare class EventBridgeClient {
-  private client: AWSClient;
-  private region: string;
-  constructor(region?: string);
-  private request<T>(action: string, params: Record<string, any>): Promise<T>;
-  putRule(params: {
-    Name: string
-    ScheduleExpression?: string
-    EventPattern?: string
-    State?: 'ENABLED' | 'DISABLED'
-    Description?: string
-    RoleArn?: string
-    Tags?: Array<{ Key: string; Value: string }>
-    EventBusName?: string
-  }): Promise<{ RuleArn: string }>;
-  deleteRule(params: {
-    Name: string
-    EventBusName?: string
-    Force?: boolean
-  }): Promise<void>;
-  describeRule(params: {
-    Name: string
-    EventBusName?: string
-  }): Promise<EventBridgeRule>;
-  listRules(params?: {
-    NamePrefix?: string
-    EventBusName?: string
-    NextToken?: string
-    Limit?: number
-  }): Promise<{ Rules: EventBridgeRule[]; NextToken?: string }>;
-  listEventBuses(params?: {
-    NamePrefix?: string
-    NextToken?: string
-    Limit?: number
-  }): Promise<{ EventBuses: EventBus[]; NextToken?: string }>;
-  enableRule(params: {
-    Name: string
-    EventBusName?: string
-  }): Promise<void>;
-  disableRule(params: {
-    Name: string
-    EventBusName?: string
-  }): Promise<void>;
-  putTargets(params: {
-    Rule: string
-    EventBusName?: string
-    Targets: EventBridgeTarget[]
-  }): Promise<{
-    FailedEntryCount: number
-    FailedEntries: Array<{
-      TargetId: string
-      ErrorCode: string
-      ErrorMessage: string
-    }>
-  }>;
-  removeTargets(params: {
-    Rule: string
-    EventBusName?: string
-    Ids: string[]
-    Force?: boolean
-  }): Promise<{
-    FailedEntryCount: number
-    FailedEntries: Array<{
-      TargetId: string
-      ErrorCode: string
-      ErrorMessage: string
-    }>
-  }>;
-  listTargetsByRule(params: {
-    Rule: string
-    EventBusName?: string
-    NextToken?: string
-    Limit?: number
-  }): Promise<{ Targets: EventBridgeTarget[]; NextToken?: string }>;
-  putEvents(params: {
-    Entries: Array<{
-      Time?: string
-      Source: string
-      Resources?: string[]
-      DetailType: string
-      Detail: string
-      EventBusName?: string
-    }>
-  }): Promise<{
-    FailedEntryCount: number
-    Entries: Array<{
-      EventId?: string
-      ErrorCode?: string
-      ErrorMessage?: string
-    }>
-  }>;
-  createSchedule(params: {
-    Name: string
-    ScheduleExpression: string
-    FlexibleTimeWindow: {
-      Mode: 'OFF' | 'FLEXIBLE'
-      MaximumWindowInMinutes?: number
-    }
-    Target: {
-      Arn: string
-      RoleArn: string
-      Input?: string
-    }
-    Description?: string
-    State?: 'ENABLED' | 'DISABLED'
-    GroupName?: string
-  }): Promise<{ ScheduleArn: string }>;
-}