@stacksjs/ts-cloud-aws-types 0.1.5 → 0.1.7

package/dist/index.d.ts

@@ -0,0 +1,310 @@
+/**
+ * AWS CloudFormation Resource Type Definitions
+ * These types are lightweight definitions without AWS SDK dependencies
+ */
+// CloudFormation Template Structure
+export declare interface CloudFormationTemplate {
+  AWSTemplateFormatVersion?: '2010-09-09'
+  Description?: string
+  Parameters?: Record<string, CloudFormationParameter>
+  Mappings?: Record<string, unknown>
+  Conditions?: Record<string, unknown>
+  Resources: Record<string, CloudFormationResource>
+  Outputs?: Record<string, CloudFormationOutput>
+}
+export declare interface CloudFormationParameter {
+  Type: 'String' | 'Number' | 'List<Number>' | 'CommaDelimitedList'
+  Default?: unknown
+  Description?: string
+  AllowedValues?: unknown[]
+  AllowedPattern?: string
+  MinLength?: number
+  MaxLength?: number
+  MinValue?: number
+  MaxValue?: number
+}
+export declare interface CloudFormationResource {
+  Type: string
+  Properties?: Record<string, unknown>
+  DependsOn?: string | string[]
+  Condition?: string
+  DeletionPolicy?: 'Delete' | 'Retain' | 'Snapshot'
+  UpdateReplacePolicy?: 'Delete' | 'Retain' | 'Snapshot'
+}
+export declare interface CloudFormationOutput {
+  Description?: string
+  Value: unknown
+  Export?: {
+    Name: string
+  }
+}
+// CloudFormation Intrinsic Functions
+export declare interface IntrinsicFunctions {
+  Ref: (logicalName: string) => { Ref: string }
+  GetAtt: (logicalName: string, attributeName: string) => { 'Fn::GetAtt': [string, string] }
+  Sub: (template: string, variables?: Record<string, unknown>) => { 'Fn::Sub': string | [string, Record<string, unknown>] }
+  Join: (delimiter: string, values: unknown[]) => { 'Fn::Join': [string, unknown[]] }
+  Select: (index: number, list: unknown[]) => { 'Fn::Select': [number, unknown[]] }
+  Split: (delimiter: string, source: string) => { 'Fn::Split': [string, string] }
+  GetAZs: (region?: string) => { 'Fn::GetAZs': string }
+  ImportValue: (name: string) => { 'Fn::ImportValue': string }
+  If: (condition: string, trueValue: unknown, falseValue: unknown) => { 'Fn::If': [string, unknown, unknown] }
+}
+// S3 Types
+export declare interface S3Bucket extends CloudFormationResource {
+  Type: 'AWS::S3::Bucket'
+  Properties?: {
+    BucketName?: string
+    AccessControl?: 'Private' | 'PublicRead' | 'PublicReadWrite' | 'AuthenticatedRead'
+    BucketEncryption?: {
+      ServerSideEncryptionConfiguration: Array<{
+        ServerSideEncryptionByDefault: {
+          SSEAlgorithm: 'AES256' | 'aws:kms'
+          KMSMasterKeyID?: string
+        }
+      }>
+    }
+    VersioningConfiguration?: {
+      Status: 'Enabled' | 'Suspended'
+    }
+    WebsiteConfiguration?: {
+      IndexDocument?: string
+      ErrorDocument?: string
+      RedirectAllRequestsTo?: {
+        HostName: string
+        Protocol?: string
+      }
+    }
+    Tags?: Array<{
+      Key: string
+      Value: string
+    }>
+    LifecycleConfiguration?: {
+      Rules: Array<{
+        Id: string
+        Status: 'Enabled' | 'Disabled'
+        ExpirationInDays?: number
+        Transitions?: Array<{
+          TransitionInDays: number
+          StorageClass: string
+        }>
+      }>
+    }
+    PublicAccessBlockConfiguration?: {
+      BlockPublicAcls?: boolean
+      BlockPublicPolicy?: boolean
+      IgnorePublicAcls?: boolean
+      RestrictPublicBuckets?: boolean
+    }
+    CorsConfiguration?: {
+      CorsRules: Array<{
+        AllowedOrigins: string[]
+        AllowedMethods: string[]
+        AllowedHeaders?: string[]
+        MaxAge?: number
+      }>
+    }
+    NotificationConfiguration?: {
+      LambdaConfigurations?: Array<{
+        Event: string
+        Function: string
+        Filter?: {
+          S3Key?: {
+            Rules?: Array<{
+              Name: string
+              Value: string
+            }>
+          }
+        }
+      }>
+    }
+  }
+}
+export declare interface S3BucketPolicy extends CloudFormationResource {
+  Type: 'AWS::S3::BucketPolicy'
+  Properties: {
+    Bucket: string | { Ref: string }
+    PolicyDocument: {
+      Version: '2012-10-17'
+      Statement: Array<{
+        Sid?: string
+        Effect: 'Allow' | 'Deny'
+        Principal: unknown
+        Action: string | string[]
+        Resource: string | string[]
+        Condition?: unknown
+      }>
+    }
+  }
+}
+// CloudFront Cache Behavior Type
+export declare interface CloudFrontCacheBehavior {
+  TargetOriginId: string
+  ViewerProtocolPolicy: 'allow-all' | 'https-only' | 'redirect-to-https'
+  AllowedMethods?: string[]
+  CachedMethods?: string[]
+  CachePolicyId?: string
+  Compress?: boolean
+  LambdaFunctionAssociations?: Array<{
+    EventType: 'origin-request' | 'origin-response' | 'viewer-request' | 'viewer-response'
+    LambdaFunctionARN: string
+  }>
+  DefaultTTL?: number
+  MaxTTL?: number
+  MinTTL?: number
+  ForwardedValues?: {
+    QueryString?: boolean
+    Headers?: string[]
+    Cookies?: {
+      Forward: string
+      WhitelistedNames?: string[]
+    }
+  }
+  PathPattern?: string
+}
+// CloudFront Origin Type
+export declare interface CloudFrontOrigin {
+  Id: string
+  DomainName: string
+  OriginPath?: string
+  S3OriginConfig?: {
+    OriginAccessIdentity?: string
+  }
+  CustomOriginConfig?: {
+    HTTPPort?: number
+    HTTPSPort?: number
+    OriginProtocolPolicy: 'http-only' | 'https-only' | 'match-viewer'
+    OriginSSLProtocols?: string[]
+    OriginReadTimeout?: number
+    OriginKeepaliveTimeout?: number
+  }
+  OriginAccessControlId?: string
+  OriginCustomHeaders?: Array<{
+    HeaderName: string
+    HeaderValue: string
+  }>
+}
+// CloudFront Types
+export declare interface CloudFrontDistribution extends CloudFormationResource {
+  Type: 'AWS::CloudFront::Distribution'
+  Properties: {
+    DistributionConfig: {
+      Enabled: boolean
+      Comment?: string
+      DefaultRootObject?: string
+      Origins: CloudFrontOrigin[]
+      DefaultCacheBehavior: CloudFrontCacheBehavior
+      CacheBehaviors?: CloudFrontCacheBehavior[]
+      PriceClass?: string
+      ViewerCertificate?: {
+        AcmCertificateArn?: string
+        CloudFrontDefaultCertificate?: boolean
+        MinimumProtocolVersion?: string
+        SslSupportMethod?: string
+      }
+      Aliases?: string[]
+      CustomErrorResponses?: Array<{
+        ErrorCode: number
+        ResponseCode?: number
+        ResponsePagePath?: string
+      }>
+      HttpVersion?: 'http1.1' | 'http2' | 'http2and3' | 'http3'
+    }
+  }
+}
+export declare interface CloudFrontOriginAccessControl extends CloudFormationResource {
+  Type: 'AWS::CloudFront::OriginAccessControl'
+  Properties: {
+    OriginAccessControlConfig: {
+      Name: string
+      Description?: string
+      OriginAccessControlOriginType: 's3' | 'mediastore'
+      SigningBehavior: 'always' | 'never' | 'no-override'
+      SigningProtocol: 'sigv4'
+    }
+  }
+}
+export declare interface CloudFrontFunction extends CloudFormationResource {
+  Type: 'AWS::CloudFront::Function'
+  Properties: {
+    Name: string
+    FunctionCode: string
+    FunctionConfig: {
+      Comment?: string
+      Runtime: 'cloudfront-js-1.0' | 'cloudfront-js-2.0'
+      KeyValueStoreAssociations?: Array<{
+        KeyValueStoreARN: string
+      }>
+    }
+    AutoPublish?: boolean
+  }
+}
+// Step Functions Types
+export declare interface StepFunctionsStateMachine extends CloudFormationResource {
+  Type: 'AWS::StepFunctions::StateMachine'
+  Properties: {
+    StateMachineName?: string
+    StateMachineType?: 'STANDARD' | 'EXPRESS'
+    Definition?: Record<string, unknown>
+    DefinitionString?: string
+    DefinitionS3Location?: {
+      Bucket: string
+      Key: string
+      Version?: string
+    }
+    DefinitionSubstitutions?: Record<string, string>
+    RoleArn: string | { 'Fn::GetAtt': [string, string] } | { Ref: string }
+    LoggingConfiguration?: {
+      Destinations?: Array<{
+        CloudWatchLogsLogGroup?: {
+          LogGroupArn: string | { 'Fn::GetAtt': [string, string] }
+        }
+      }>
+      IncludeExecutionData?: boolean
+      Level?: 'ALL' | 'ERROR' | 'FATAL' | 'OFF'
+    }
+    TracingConfiguration?: {
+      Enabled?: boolean
+    }
+    Tags?: Array<{
+      Key: string
+      Value: string
+    }>
+  }
+}
+export * from './route53';
+export * from './ec2';
+export * from './iam';
+export * from './lambda';
+export * from './ecs';
+export * from './ecr';
+export * from './alb';
+export * from './rds';
+export * from './dynamodb';
+export * from './apigateway';
+export * from './sns';
+export * from './ses';
+export * from './sqs';
+export * from './eventbridge';
+export * from './cloudwatch';
+export * from './kms';
+export * from './acm';
+export * from './efs';
+export * from './waf';
+export * from './elasticache';
+export * from './secrets-manager';
+export * from './autoscaling';
+export * from './ssm';
+export * from './backup';
+export * from './opensearch';
+export * from './rds-proxy';
+export * from './globalaccelerator';
+export * from './appsync';
+export * from './athena';
+export * from './kinesis';
+export * from './glue';
+export * from './connect';
+export * from './pinpoint';
+export * from './common';
+export * from './cognito';
+export * from './codedeploy';

package/dist/kinesis.d.ts

@@ -0,0 +1,252 @@
+import type { Tag } from './common';
+export declare interface Stream {
+  Type: 'AWS::Kinesis::Stream'
+  Properties: {
+    Name?: string
+    ShardCount?: number
+    RetentionPeriodHours?: number // 24-8760 (1-365 days)
+
+    // Stream mode
+    StreamModeDetails?: {
+      StreamMode: 'PROVISIONED' | 'ON_DEMAND'
+    }
+
+    // Encryption
+    StreamEncryption?: {
+      EncryptionType: 'KMS'
+      KeyId: string | { Ref: string }
+    }
+
+    Tags?: Tag[]
+  }
+  DeletionPolicy?: 'Delete' | 'Retain'
+  UpdateReplacePolicy?: 'Delete' | 'Retain'
+}
+export declare interface StreamConsumer {
+  Type: 'AWS::Kinesis::StreamConsumer'
+  Properties: {
+    StreamARN: string | { 'Fn::GetAtt': [string, string] }
+    ConsumerName: string
+  }
+  DependsOn?: string | string[]
+}
+// Kinesis Data Firehose
+export declare interface DeliveryStream {
+  Type: 'AWS::KinesisFirehose::DeliveryStream'
+  Properties: {
+    DeliveryStreamName?: string
+    DeliveryStreamType?: 'DirectPut' | 'KinesisStreamAsSource'
+
+    // Source configuration (if Type = KinesisStreamAsSource)
+    KinesisStreamSourceConfiguration?: {
+      KinesisStreamARN: string | { 'Fn::GetAtt': [string, string] }
+      RoleARN: string | { Ref: string }
+    }
+
+    // S3 destination
+    S3DestinationConfiguration?: {
+      BucketARN: string | { 'Fn::GetAtt': [string, string] }
+      RoleARN: string | { Ref: string }
+      Prefix?: string
+      ErrorOutputPrefix?: string
+      BufferingHints?: {
+        IntervalInSeconds?: number
+        SizeInMBs?: number
+      }
+      CompressionFormat?: 'UNCOMPRESSED' | 'GZIP' | 'ZIP' | 'Snappy' | 'HADOOP_SNAPPY'
+      EncryptionConfiguration?: {
+        NoEncryptionConfig?: 'NoEncryption'
+        KMSEncryptionConfig?: {
+          AWSKMSKeyARN: string | { Ref: string }
+        }
+      }
+      CloudWatchLoggingOptions?: {
+        Enabled?: boolean
+        LogGroupName?: string
+        LogStreamName?: string
+      }
+    }
+
+    // Extended S3 destination
+    ExtendedS3DestinationConfiguration?: {
+      BucketARN: string | { 'Fn::GetAtt': [string, string] }
+      RoleARN: string | { Ref: string }
+      Prefix?: string
+      ErrorOutputPrefix?: string
+      BufferingHints?: {
+        IntervalInSeconds?: number
+        SizeInMBs?: number
+      }
+      CompressionFormat?: 'UNCOMPRESSED' | 'GZIP' | 'ZIP' | 'Snappy' | 'HADOOP_SNAPPY'
+      EncryptionConfiguration?: {
+        NoEncryptionConfig?: 'NoEncryption'
+        KMSEncryptionConfig?: {
+          AWSKMSKeyARN: string | { Ref: string }
+        }
+      }
+      CloudWatchLoggingOptions?: {
+        Enabled?: boolean
+        LogGroupName?: string
+        LogStreamName?: string
+      }
+      DataFormatConversionConfiguration?: {
+        Enabled?: boolean
+        SchemaConfiguration?: {
+          DatabaseName?: string
+          TableName?: string
+          Region?: string
+          RoleARN?: string | { Ref: string }
+        }
+        InputFormatConfiguration?: {
+          Deserializer?: {
+            OpenXJsonSerDe?: Record<string, any>
+            HiveJsonSerDe?: Record<string, any>
+          }
+        }
+        OutputFormatConfiguration?: {
+          Serializer?: {
+            ParquetSerDe?: Record<string, any>
+            OrcSerDe?: Record<string, any>
+          }
+        }
+      }
+      DynamicPartitioningConfiguration?: {
+        Enabled?: boolean
+        RetryOptions?: {
+          DurationInSeconds?: number
+        }
+      }
+      ProcessingConfiguration?: {
+        Enabled?: boolean
+        Processors?: Array<{
+          Type: 'Lambda'
+          Parameters?: Array<{
+            ParameterName: string
+            ParameterValue: string
+          }>
+        }>
+      }
+    }
+
+    // Elasticsearch destination
+    ElasticsearchDestinationConfiguration?: {
+      DomainARN: string | { 'Fn::GetAtt': [string, string] }
+      IndexName: string
+      RoleARN: string | { Ref: string }
+      TypeName?: string
+      IndexRotationPeriod?: 'NoRotation' | 'OneHour' | 'OneDay' | 'OneWeek' | 'OneMonth'
+      BufferingHints?: {
+        IntervalInSeconds?: number
+        SizeInMBs?: number
+      }
+      RetryOptions?: {
+        DurationInSeconds?: number
+      }
+      S3BackupMode?: 'FailedDocumentsOnly' | 'AllDocuments'
+      S3Configuration: {
+        BucketARN: string | { 'Fn::GetAtt': [string, string] }
+        RoleARN: string | { Ref: string }
+        Prefix?: string
+      }
+      CloudWatchLoggingOptions?: {
+        Enabled?: boolean
+        LogGroupName?: string
+        LogStreamName?: string
+      }
+    }
+
+    // OpenSearch destination
+    AmazonopensearchserviceDestinationConfiguration?: {
+      DomainARN: string | { 'Fn::GetAtt': [string, string] }
+      IndexName: string
+      RoleARN: string | { Ref: string }
+      TypeName?: string
+      IndexRotationPeriod?: 'NoRotation' | 'OneHour' | 'OneDay' | 'OneWeek' | 'OneMonth'
+      BufferingHints?: {
+        IntervalInSeconds?: number
+        SizeInMBs?: number
+      }
+      RetryOptions?: {
+        DurationInSeconds?: number
+      }
+      S3BackupMode?: 'FailedDocumentsOnly' | 'AllDocuments'
+      S3Configuration: {
+        BucketARN: string | { 'Fn::GetAtt': [string, string] }
+        RoleARN: string | { Ref: string }
+        Prefix?: string
+      }
+      CloudWatchLoggingOptions?: {
+        Enabled?: boolean
+        LogGroupName?: string
+        LogStreamName?: string
+      }
+    }
+
+    // Redshift destination
+    RedshiftDestinationConfiguration?: {
+      ClusterJDBCURL: string
+      CopyCommand: {
+        DataTableName: string
+        CopyOptions?: string
+        DataTableColumns?: string
+      }
+      Username: string
+      Password: string
+      RoleARN: string | { Ref: string }
+      S3Configuration: {
+        BucketARN: string | { 'Fn::GetAtt': [string, string] }
+        RoleARN: string | { Ref: string }
+        Prefix?: string
+      }
+      CloudWatchLoggingOptions?: {
+        Enabled?: boolean
+        LogGroupName?: string
+        LogStreamName?: string
+      }
+    }
+
+    Tags?: Tag[]
+  }
+  DeletionPolicy?: 'Delete' | 'Retain'
+  UpdateReplacePolicy?: 'Delete' | 'Retain'
+}
+// Kinesis Data Analytics
+export declare interface Application {
+  Type: 'AWS::KinesisAnalytics::Application'
+  Properties: {
+    ApplicationName?: string
+    ApplicationDescription?: string
+    ApplicationCode?: string
+    Inputs: Array<{
+      NamePrefix: string
+      InputSchema: {
+        RecordColumns: Array<{
+          Name: string
+          SqlType: string
+          Mapping?: string
+        }>
+        RecordFormat: {
+          RecordFormatType: 'CSV' | 'JSON'
+          MappingParameters?: {
+            CSVMappingParameters?: {
+              RecordRowDelimiter: string
+              RecordColumnDelimiter: string
+            }
+            JSONMappingParameters?: {
+              RecordRowPath: string
+            }
+          }
+        }
+        RecordEncoding?: string
+      }
+      KinesisStreamsInput?: {
+        ResourceARN: string | { 'Fn::GetAtt': [string, string] }
+        RoleARN: string | { Ref: string }
+      }
+      KinesisFirehoseInput?: {
+        ResourceARN: string | { 'Fn::GetAtt': [string, string] }
+        RoleARN: string | { Ref: string }
+      }
+    }>
+  }
+}

package/dist/kms.d.ts

@@ -0,0 +1,33 @@
+import type { CloudFormationResource } from './index';
+export declare interface KMSKey extends CloudFormationResource {
+  Type: 'AWS::KMS::Key'
+  Properties: {
+    Description?: string
+    Enabled?: boolean
+    EnableKeyRotation?: boolean
+    KeyPolicy: {
+      Version: '2012-10-17'
+      Statement: Array<{
+        Sid?: string
+        Effect: 'Allow' | 'Deny'
+        Principal: unknown
+        Action: string | string[]
+        Resource: string | string[]
+      }>
+    }
+    KeySpec?: 'SYMMETRIC_DEFAULT' | 'RSA_2048' | 'RSA_3072' | 'RSA_4096' | 'ECC_NIST_P256' | 'ECC_NIST_P384' | 'ECC_NIST_P521' | 'ECC_SECG_P256K1'
+    KeyUsage?: 'ENCRYPT_DECRYPT' | 'SIGN_VERIFY'
+    MultiRegion?: boolean
+    Tags?: Array<{
+      Key: string
+      Value: string
+    }>
+  }
+}
+export declare interface KMSAlias extends CloudFormationResource {
+  Type: 'AWS::KMS::Alias'
+  Properties: {
+    AliasName: string
+    TargetKeyId: string | { Ref: string }
+  }
+}

package/dist/lambda.d.ts

@@ -0,0 +1,40 @@
+import type { CloudFormationResource } from './index';
+export declare interface LambdaFunction extends CloudFormationResource {
+  Type: 'AWS::Lambda::Function'
+  Properties: {
+    FunctionName?: string
+    Description?: string
+    Runtime: string
+    Role: string | { 'Fn::GetAtt': [string, string] }
+    Handler: string
+    Code: {
+      S3Bucket?: string
+      S3Key?: string
+      ZipFile?: string
+    }
+    Timeout?: number
+    MemorySize?: number
+    Environment?: {
+      Variables: Record<string, string>
+    }
+    VpcConfig?: {
+      SecurityGroupIds: string[]
+      SubnetIds: string[]
+    }
+    Layers?: string[]
+    Tags?: Array<{
+      Key: string
+      Value: string
+    }>
+  }
+}
+export declare interface LambdaPermission extends CloudFormationResource {
+  Type: 'AWS::Lambda::Permission'
+  Properties: {
+    FunctionName: string | { Ref: string }
+    Action: string
+    Principal: string
+    SourceArn?: string
+    SourceAccount?: string
+  }
+}