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

package/dist/acm.d.ts

@@ -0,0 +1,19 @@
+import type { CloudFormationResource } from './index';
+export declare interface ACMCertificate extends CloudFormationResource {
+  Type: 'AWS::CertificateManager::Certificate'
+  Properties: {
+    DomainName: string
+    SubjectAlternativeNames?: string[]
+    DomainValidationOptions?: Array<{
+      DomainName: string
+      HostedZoneId?: string
+      ValidationDomain?: string
+    }>
+    ValidationMethod?: 'DNS' | 'EMAIL'
+    CertificateTransparencyLoggingPreference?: 'ENABLED' | 'DISABLED'
+    Tags?: Array<{
+      Key: string
+      Value: string
+    }>
+  }
+}

package/dist/alb.d.ts

@@ -0,0 +1,70 @@
+import type { CloudFormationResource } from './index';
+export declare interface ApplicationLoadBalancer extends CloudFormationResource {
+  Type: 'AWS::ElasticLoadBalancingV2::LoadBalancer'
+  Properties: {
+    Name?: string
+    Scheme?: 'internet-facing' | 'internal'
+    Type?: 'application' | 'network' | 'gateway'
+    IpAddressType?: 'ipv4' | 'dualstack'
+    Subnets?: string[]
+    SecurityGroups?: string[]
+    Tags?: Array<{
+      Key: string
+      Value: string
+    }>
+  }
+}
+export declare interface TargetGroup extends CloudFormationResource {
+  Type: 'AWS::ElasticLoadBalancingV2::TargetGroup'
+  Properties: {
+    Name?: string
+    Port: number
+    Protocol: 'HTTP' | 'HTTPS' | 'TCP' | 'TLS' | 'UDP' | 'TCP_UDP'
+    VpcId: string | { Ref: string }
+    TargetType?: 'instance' | 'ip' | 'lambda' | 'alb'
+    HealthCheckEnabled?: boolean
+    HealthCheckProtocol?: 'HTTP' | 'HTTPS' | 'TCP' | 'TLS' | 'UDP' | 'TCP_UDP'
+    HealthCheckPath?: string
+    HealthCheckIntervalSeconds?: number
+    HealthCheckTimeoutSeconds?: number
+    HealthyThresholdCount?: number
+    UnhealthyThresholdCount?: number
+    Matcher?: {
+      HttpCode?: string
+      GrpcCode?: string
+    }
+    Tags?: Array<{
+      Key: string
+      Value: string
+    }>
+  }
+}
+export declare interface Listener extends CloudFormationResource {
+  Type: 'AWS::ElasticLoadBalancingV2::Listener'
+  Properties: {
+    LoadBalancerArn: string | { Ref: string }
+    Port: number
+    Protocol: 'HTTP' | 'HTTPS' | 'TCP' | 'TLS' | 'UDP' | 'TCP_UDP'
+    Certificates?: Array<{
+      CertificateArn: string
+    }>
+    SslPolicy?: string
+    DefaultActions: Array<{
+      Type: 'forward' | 'redirect' | 'fixed-response' | 'authenticate-cognito' | 'authenticate-oidc'
+      TargetGroupArn?: string | { Ref: string }
+      RedirectConfig?: {
+        Protocol?: string
+        Port?: string
+        Host?: string
+        Path?: string
+        Query?: string
+        StatusCode: 'HTTP_301' | 'HTTP_302'
+      }
+      FixedResponseConfig?: {
+        StatusCode: string
+        ContentType?: string
+        MessageBody?: string
+      }
+    }>
+  }
+}

package/dist/apigateway.d.ts

@@ -0,0 +1,80 @@
+import type { CloudFormationResource } from './index';
+export declare interface ApiGatewayRestApi extends CloudFormationResource {
+  Type: 'AWS::ApiGateway::RestApi'
+  Properties: {
+    Name: string
+    Description?: string
+    EndpointConfiguration?: {
+      Types: ('EDGE' | 'REGIONAL' | 'PRIVATE')[]
+    }
+    Policy?: unknown
+    BinaryMediaTypes?: string[]
+    MinimumCompressionSize?: number
+    Tags?: Array<{
+      Key: string
+      Value: string
+    }>
+  }
+}
+export declare interface ApiGatewayHttpApi extends CloudFormationResource {
+  Type: 'AWS::ApiGatewayV2::Api'
+  Properties: {
+    Name: string
+    Description?: string
+    ProtocolType: 'HTTP' | 'WEBSOCKET'
+    CorsConfiguration?: {
+      AllowOrigins?: string[]
+      AllowMethods?: string[]
+      AllowHeaders?: string[]
+      ExposeHeaders?: string[]
+      MaxAge?: number
+      AllowCredentials?: boolean
+    }
+    Tags?: Record<string, string>
+  }
+}
+export declare interface ApiGatewayStage extends CloudFormationResource {
+  Type: 'AWS::ApiGateway::Stage'
+  Properties: {
+    StageName: string
+    RestApiId: string | { Ref: string }
+    DeploymentId: string | { Ref: string }
+    Description?: string
+    CacheClusterEnabled?: boolean
+    CacheClusterSize?: string
+    Variables?: Record<string, string>
+    MethodSettings?: Array<{
+      HttpMethod: string
+      ResourcePath: string
+      CachingEnabled?: boolean
+      CacheTtlInSeconds?: number
+      ThrottlingBurstLimit?: number
+      ThrottlingRateLimit?: number
+    }>
+    Tags?: Array<{
+      Key: string
+      Value: string
+    }>
+  }
+}
+export declare interface ApiGatewayDeployment extends CloudFormationResource {
+  Type: 'AWS::ApiGateway::Deployment'
+  Properties: {
+    RestApiId: string | { Ref: string }
+    Description?: string
+    StageName?: string
+  }
+}
+export declare interface ApiGatewayAuthorizer extends CloudFormationResource {
+  Type: 'AWS::ApiGateway::Authorizer'
+  Properties: {
+    Name: string
+    Type: 'TOKEN' | 'REQUEST' | 'COGNITO_USER_POOLS'
+    RestApiId: string | { Ref: string }
+    AuthorizerUri?: string
+    AuthorizerCredentials?: string
+    IdentitySource?: string
+    ProviderARNs?: string[]
+    AuthorizerResultTtlInSeconds?: number
+  }
+}

package/dist/appsync.d.ts

@@ -0,0 +1,233 @@
+import type { Tag } from './common';
+export declare interface GraphQLApi {
+  Type: 'AWS::AppSync::GraphQLApi'
+  Properties: {
+    Name: string
+    AuthenticationType: 'API_KEY' | 'AWS_IAM' | 'AMAZON_COGNITO_USER_POOLS' | 'OPENID_CONNECT' | 'AWS_LAMBDA'
+
+    // Optional authentication providers
+    AdditionalAuthenticationProviders?: Array<{
+      AuthenticationType: 'API_KEY' | 'AWS_IAM' | 'AMAZON_COGNITO_USER_POOLS' | 'OPENID_CONNECT' | 'AWS_LAMBDA'
+      UserPoolConfig?: {
+        UserPoolId: string | { Ref: string }
+        AwsRegion?: string
+        AppIdClientRegex?: string
+      }
+      OpenIDConnectConfig?: {
+        Issuer: string
+        ClientId?: string
+        IatTTL?: number
+        AuthTTL?: number
+      }
+      LambdaAuthorizerConfig?: {
+        AuthorizerUri: string | { Ref: string }
+        AuthorizerResultTtlInSeconds?: number
+        IdentityValidationExpression?: string
+      }
+    }>
+
+    // Cognito User Pool config (if using AMAZON_COGNITO_USER_POOLS)
+    UserPoolConfig?: {
+      UserPoolId: string | { Ref: string }
+      AwsRegion?: string
+      DefaultAction: 'ALLOW' | 'DENY'
+      AppIdClientRegex?: string
+    }
+
+    // OpenID Connect config (if using OPENID_CONNECT)
+    OpenIDConnectConfig?: {
+      Issuer: string
+      ClientId?: string
+      IatTTL?: number
+      AuthTTL?: number
+    }
+
+    // Lambda authorizer config (if using AWS_LAMBDA)
+    LambdaAuthorizerConfig?: {
+      AuthorizerUri: string | { Ref: string }
+      AuthorizerResultTtlInSeconds?: number
+      IdentityValidationExpression?: string
+    }
+
+    // Logging
+    LogConfig?: {
+      CloudWatchLogsRoleArn: string | { Ref: string }
+      FieldLogLevel: 'NONE' | 'ERROR' | 'ALL'
+      ExcludeVerboseContent?: boolean
+    }
+
+    // X-Ray tracing
+    XrayEnabled?: boolean
+
+    Tags?: Tag[]
+  }
+  DeletionPolicy?: 'Delete' | 'Retain'
+  UpdateReplacePolicy?: 'Delete' | 'Retain'
+}
+export declare interface GraphQLSchema {
+  Type: 'AWS::AppSync::GraphQLSchema'
+  Properties: {
+    ApiId: string | { Ref: string }
+    Definition?: string
+    DefinitionS3Location?: string
+  }
+  DependsOn?: string | string[]
+}
+export declare interface DataSource {
+  Type: 'AWS::AppSync::DataSource'
+  Properties: {
+    ApiId: string | { Ref: string }
+    Name: string
+    Type: 'AWS_LAMBDA' | 'AMAZON_DYNAMODB' | 'AMAZON_ELASTICSEARCH' | 'AMAZON_OPENSEARCH_SERVICE' | 'HTTP' | 'RELATIONAL_DATABASE' | 'NONE'
+    ServiceRoleArn?: string | { Ref: string }
+
+    // Lambda config (if Type = AWS_LAMBDA)
+    LambdaConfig?: {
+      LambdaFunctionArn: string | { Ref: string }
+    }
+
+    // DynamoDB config (if Type = AMAZON_DYNAMODB)
+    DynamoDBConfig?: {
+      TableName: string | { Ref: string }
+      AwsRegion: string
+      UseCallerCredentials?: boolean
+      DeltaSyncConfig?: {
+        BaseTableTTL: number
+        DeltaSyncTableName: string | { Ref: string }
+        DeltaSyncTableTTL: number
+      }
+      Versioned?: boolean
+    }
+
+    // OpenSearch config (if Type = AMAZON_OPENSEARCH_SERVICE)
+    OpenSearchServiceConfig?: {
+      AwsRegion: string
+      Endpoint: string | { 'Fn::GetAtt': [string, string] }
+    }
+
+    // HTTP config (if Type = HTTP)
+    HttpConfig?: {
+      Endpoint: string
+      AuthorizationConfig?: {
+        AuthorizationType: 'AWS_IAM'
+        AwsIamConfig?: {
+          SigningRegion?: string
+          SigningServiceName?: string
+        }
+      }
+    }
+
+    // RDS config (if Type = RELATIONAL_DATABASE)
+    RelationalDatabaseConfig?: {
+      RelationalDatabaseSourceType: 'RDS_HTTP_ENDPOINT'
+      RdsHttpEndpointConfig?: {
+        AwsRegion: string
+        DbClusterIdentifier: string | { Ref: string }
+        DatabaseName?: string
+        Schema?: string
+        AwsSecretStoreArn: string | { Ref: string }
+      }
+    }
+
+    Description?: string
+  }
+  DependsOn?: string | string[]
+}
+export declare interface Resolver {
+  Type: 'AWS::AppSync::Resolver'
+  Properties: {
+    ApiId: string | { Ref: string }
+    TypeName: string // e.g., 'Query', 'Mutation', 'Subscription'
+    FieldName: string
+    DataSourceName?: string | { Ref: string }
+
+    // Request/Response mapping templates (VTL)
+    RequestMappingTemplate?: string
+    ResponseMappingTemplate?: string
+
+    // Or use S3 location
+    RequestMappingTemplateS3Location?: string
+    ResponseMappingTemplateS3Location?: string
+
+    // Pipeline resolvers
+    Kind?: 'UNIT' | 'PIPELINE'
+    PipelineConfig?: {
+      Functions?: Array<string | { Ref: string }>
+    }
+
+    // Caching
+    CachingConfig?: {
+      CachingKeys?: string[]
+      Ttl?: number
+    }
+
+    // Sync config (for subscriptions)
+    SyncConfig?: {
+      ConflictDetection: 'VERSION' | 'NONE'
+      ConflictHandler?: 'OPTIMISTIC_CONCURRENCY' | 'LAMBDA' | 'AUTOMERGE'
+      LambdaConflictHandlerConfig?: {
+        LambdaConflictHandlerArn: string | { Ref: string }
+      }
+    }
+
+    // Code (for JavaScript resolvers)
+    Code?: string
+    CodeS3Location?: string
+    Runtime?: {
+      Name: 'APPSYNC_JS'
+      RuntimeVersion: string
+    }
+  }
+  DependsOn?: string | string[]
+}
+export declare interface FunctionConfiguration {
+  Type: 'AWS::AppSync::FunctionConfiguration'
+  Properties: {
+    ApiId: string | { Ref: string }
+    Name: string
+    DataSourceName: string | { Ref: string }
+    FunctionVersion?: string
+
+    // Request/Response mapping templates
+    RequestMappingTemplate?: string
+    ResponseMappingTemplate?: string
+    RequestMappingTemplateS3Location?: string
+    ResponseMappingTemplateS3Location?: string
+
+    // Code (for JavaScript functions)
+    Code?: string
+    CodeS3Location?: string
+    Runtime?: {
+      Name: 'APPSYNC_JS'
+      RuntimeVersion: string
+    }
+
+    Description?: string
+  }
+  DependsOn?: string | string[]
+}
+export declare interface ApiKey {
+  Type: 'AWS::AppSync::ApiKey'
+  Properties: {
+    ApiId: string | { Ref: string }
+    Description?: string
+    Expires?: number // Unix timestamp
+  }
+  DependsOn?: string | string[]
+}
+export declare interface DomainName {
+  Type: 'AWS::AppSync::DomainName'
+  Properties: {
+    DomainName: string
+    CertificateArn: string | { Ref: string }
+    Description?: string
+  }
+}
+export declare interface DomainNameApiAssociation {
+  Type: 'AWS::AppSync::DomainNameApiAssociation'
+  Properties: {
+    DomainName: string | { Ref: string }
+    ApiId: string | { Ref: string }
+  }
+  DependsOn?: string | string[]
+}

package/dist/athena.d.ts

@@ -0,0 +1,92 @@
+import type { Tag } from './common';
+export declare interface WorkGroup {
+  Type: 'AWS::Athena::WorkGroup'
+  Properties: {
+    Name: string
+    Description?: string
+    State?: 'ENABLED' | 'DISABLED'
+
+    WorkGroupConfiguration?: {
+      // Query result location
+      ResultConfiguration?: {
+        OutputLocation?: string
+        EncryptionConfiguration?: {
+          EncryptionOption: 'SSE_S3' | 'SSE_KMS' | 'CSE_KMS'
+          KmsKey?: string | { Ref: string }
+        }
+        ExpectedBucketOwner?: string
+        AclConfiguration?: {
+          S3AclOption: 'BUCKET_OWNER_FULL_CONTROL'
+        }
+      }
+
+      // Performance settings
+      EnforceWorkGroupConfiguration?: boolean
+      PublishCloudWatchMetricsEnabled?: boolean
+      BytesScannedCutoffPerQuery?: number
+      RequesterPaysEnabled?: boolean
+
+      // Engine version
+      EngineVersion?: {
+        SelectedEngineVersion?: string
+        EffectiveEngineVersion?: string
+      }
+
+      // Execution role (for federated queries)
+      ExecutionRole?: string | { Ref: string }
+
+      // Additional configurations
+      AdditionalConfiguration?: string
+      CustomerContentEncryptionConfiguration?: {
+        KmsKey: string | { Ref: string }
+      }
+    }
+
+    Tags?: Tag[]
+  }
+  DeletionPolicy?: 'Delete' | 'Retain'
+  UpdateReplacePolicy?: 'Delete' | 'Retain'
+}
+export declare interface DataCatalog {
+  Type: 'AWS::Athena::DataCatalog'
+  Properties: {
+    Name: string
+    Type: 'LAMBDA' | 'GLUE' | 'HIVE'
+    Description?: string
+    Parameters?: Record<string, string>
+    Tags?: Tag[]
+  }
+}
+export declare interface NamedQuery {
+  Type: 'AWS::Athena::NamedQuery'
+  Properties: {
+    Name?: string
+    Database: string
+    QueryString: string
+    Description?: string
+    WorkGroup?: string
+  }
+}
+export declare interface PreparedStatement {
+  Type: 'AWS::Athena::PreparedStatement'
+  Properties: {
+    StatementName: string
+    WorkGroup: string
+    QueryStatement: string
+    Description?: string
+  }
+  DependsOn?: string | string[]
+}
+export declare interface CapacityReservation {
+  Type: 'AWS::Athena::CapacityReservation'
+  Properties: {
+    Name: string
+    TargetDpus: number
+    CapacityAssignmentConfiguration?: {
+      CapacityAssignments?: Array<{
+        WorkGroupNames?: string[]
+      }>
+    }
+    Tags?: Tag[]
+  }
+}

package/dist/autoscaling.d.ts

@@ -0,0 +1,188 @@
+import type { Tag } from './common';
+/**
+ * AWS::AutoScaling::AutoScalingGroup
+ */
+export declare interface AutoScalingGroup {
+  Type: 'AWS::AutoScaling::AutoScalingGroup'
+  Properties: {
+    AutoScalingGroupName?: string
+    MinSize: string | number
+    MaxSize: string | number
+    DesiredCapacity?: string | number
+    DefaultInstanceWarmup?: number
+    HealthCheckType?: 'EC2' | 'ELB'
+    HealthCheckGracePeriod?: number
+    LaunchTemplate?: {
+      LaunchTemplateId?: string | { Ref: string }
+      LaunchTemplateName?: string
+      Version: string | { 'Fn::GetAtt': [string, string] }
+    }
+    LaunchConfigurationName?: string | { Ref: string }
+    AvailabilityZones?: string[] | { 'Fn::GetAZs': string }
+    VPCZoneIdentifier?: string[] | { Ref: string }
+    TargetGroupARNs?: Array<string | { Ref: string }>
+    LoadBalancerNames?: Array<string | { Ref: string }>
+    TerminationPolicies?: Array<'OldestInstance' | 'NewestInstance' | 'OldestLaunchConfiguration' | 'ClosestToNextInstanceHour' | 'Default' | 'OldestLaunchTemplate' | 'AllocationStrategy'>
+    NewInstancesProtectedFromScaleIn?: boolean
+    Tags?: Array<Tag & { PropagateAtLaunch: boolean }>
+    MetricsCollection?: Array<{
+      Granularity: string
+      Metrics?: string[]
+    }>
+    Cooldown?: string | number
+    CapacityRebalance?: boolean
+  }
+  DependsOn?: string | string[]
+  CreationPolicy?: {
+    ResourceSignal?: {
+      Count?: number
+      Timeout?: string
+    }
+    AutoScalingCreationPolicy?: {
+      MinSuccessfulInstancesPercent?: number
+    }
+  }
+  UpdatePolicy?: {
+    AutoScalingReplacingUpdate?: {
+      WillReplace?: boolean
+    }
+    AutoScalingRollingUpdate?: {
+      MaxBatchSize?: number
+      MinInstancesInService?: number
+      MinSuccessfulInstancesPercent?: number
+      PauseTime?: string
+      SuspendProcesses?: string[]
+      WaitOnResourceSignals?: boolean
+    }
+    AutoScalingScheduledAction?: {
+      IgnoreUnmodifiedGroupSizeProperties?: boolean
+    }
+  }
+}
+/**
+ * AWS::AutoScaling::LaunchConfiguration
+ */
+export declare interface AutoScalingLaunchConfiguration {
+  Type: 'AWS::AutoScaling::LaunchConfiguration'
+  Properties: {
+    LaunchConfigurationName?: string
+    ImageId: string
+    InstanceType: string
+    KeyName?: string
+    SecurityGroups?: Array<string | { Ref: string }>
+    UserData?: string | { 'Fn::Base64': any }
+    IamInstanceProfile?: string | { Ref: string } | { 'Fn::GetAtt': [string, string] }
+    BlockDeviceMappings?: Array<{
+      DeviceName: string
+      Ebs?: {
+        DeleteOnTermination?: boolean
+        Encrypted?: boolean
+        Iops?: number
+        SnapshotId?: string
+        Throughput?: number
+        VolumeSize?: number
+        VolumeType?: 'gp2' | 'gp3' | 'io1' | 'io2' | 'sc1' | 'st1' | 'standard'
+      }
+      NoDevice?: boolean
+      VirtualName?: string
+    }>
+    AssociatePublicIpAddress?: boolean
+    EbsOptimized?: boolean
+    InstanceMonitoring?: boolean
+    PlacementTenancy?: 'default' | 'dedicated'
+    SpotPrice?: string
+  }
+}
+/**
+ * AWS::AutoScaling::ScalingPolicy
+ */
+export declare interface AutoScalingScalingPolicy {
+  Type: 'AWS::AutoScaling::ScalingPolicy'
+  Properties: {
+    PolicyName?: string
+    PolicyType?: 'TargetTrackingScaling' | 'StepScaling' | 'SimpleScaling'
+    AutoScalingGroupName: string | { Ref: string }
+    AdjustmentType?: 'ChangeInCapacity' | 'ExactCapacity' | 'PercentChangeInCapacity'
+    ScalingAdjustment?: number
+    Cooldown?: string | number
+    MinAdjustmentMagnitude?: number
+    MetricAggregationType?: 'Minimum' | 'Maximum' | 'Average'
+    EstimatedInstanceWarmup?: number
+    TargetTrackingConfiguration?: {
+      PredefinedMetricSpecification?: {
+        PredefinedMetricType: 'ASGAverageCPUUtilization' | 'ASGAverageNetworkIn' | 'ASGAverageNetworkOut' | 'ALBRequestCountPerTarget'
+        ResourceLabel?: string
+      }
+      CustomizedMetricSpecification?: {
+        MetricName: string
+        Namespace: string
+        Statistic: 'Average' | 'Minimum' | 'Maximum' | 'SampleCount' | 'Sum'
+        Unit?: string
+        Dimensions?: Array<{
+          Name: string
+          Value: string
+        }>
+      }
+      TargetValue: number
+      DisableScaleIn?: boolean
+    }
+    StepAdjustments?: Array<{
+      MetricIntervalLowerBound?: number
+      MetricIntervalUpperBound?: number
+      ScalingAdjustment: number
+    }>
+  }
+}
+/**
+ * AWS::AutoScaling::ScheduledAction
+ */
+export declare interface AutoScalingScheduledAction {
+  Type: 'AWS::AutoScaling::ScheduledAction'
+  Properties: {
+    AutoScalingGroupName: string | { Ref: string }
+    DesiredCapacity?: number
+    MinSize?: number
+    MaxSize?: number
+    Recurrence?: string
+    StartTime?: string
+    EndTime?: string
+    TimeZone?: string
+  }
+}
+/**
+ * AWS::AutoScaling::LifecycleHook
+ */
+export declare interface AutoScalingLifecycleHook {
+  Type: 'AWS::AutoScaling::LifecycleHook'
+  Properties: {
+    LifecycleHookName?: string
+    AutoScalingGroupName: string | { Ref: string }
+    LifecycleTransition: 'autoscaling:EC2_INSTANCE_LAUNCHING' | 'autoscaling:EC2_INSTANCE_TERMINATING'
+    DefaultResult?: 'CONTINUE' | 'ABANDON'
+    HeartbeatTimeout?: number
+    NotificationTargetARN?: string | { Ref: string } | { 'Fn::GetAtt': [string, string] }
+    RoleARN?: string | { 'Fn::GetAtt': [string, string] }
+    NotificationMetadata?: string
+  }
+}
+/**
+ * AWS::AutoScaling::WarmPool
+ */
+export declare interface AutoScalingWarmPool {
+  Type: 'AWS::AutoScaling::WarmPool'
+  Properties: {
+    AutoScalingGroupName: string | { Ref: string }
+    MaxGroupPreparedCapacity?: number
+    MinSize?: number
+    PoolState?: 'Hibernated' | 'Running' | 'Stopped'
+    InstanceReusePolicy?: {
+      ReuseOnScaleIn?: boolean
+    }
+  }
+}
+export type AutoScalingResource = | AutoScalingGroup
+  | AutoScalingLaunchConfiguration
+  | AutoScalingScalingPolicy
+  | AutoScalingScheduledAction
+  | AutoScalingLifecycleHook
+  | AutoScalingWarmPool