@stacksjs/ts-cloud 0.1.3 → 0.1.6

package/dist/aws/elbv2.d.ts

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

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

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