@pulumi/aws-native 1.36.0-alpha.1759383572 → 1.36.0-alpha.1759406604

package/types/output.d.ts

@@ -10840,6 +10840,9 @@ export declare namespace bedrock {
          * Whether generating categorical data from audio is enabled.
          */
         state: enums.bedrock.DataAutomationProjectState;
+        /**
+         * This element contains information about extractions from different types. Used to enable speaker and channel labeling for transcripts.
+         */
         typeConfiguration?: outputs.bedrock.DataAutomationProjectAudioExtractionCategoryTypeConfiguration;
         /**
          * The types of data to generate.
@@ -10847,6 +10850,9 @@ export declare namespace bedrock {
         types?: enums.bedrock.DataAutomationProjectAudioExtractionCategoryType[];
     }
     interface DataAutomationProjectAudioExtractionCategoryTypeConfiguration {
+        /**
+         * This element allows you to configure different extractions for your transcript data, such as speaker and channel labeling.
+         */
         transcript?: outputs.bedrock.DataAutomationProjectTranscriptConfiguration;
     }
     interface DataAutomationProjectAudioOverrideConfiguration {
@@ -10896,6 +10902,9 @@ export declare namespace bedrock {
         blueprintVersion?: string;
     }
     interface DataAutomationProjectChannelLabelingConfiguration {
+        /**
+         * State of channel labeling, either enabled or disabled.
+         */
         state: enums.bedrock.DataAutomationProjectState;
     }
     /**
@@ -11086,6 +11095,9 @@ export declare namespace bedrock {
         video?: outputs.bedrock.DataAutomationProjectVideoOverrideConfiguration;
     }
     interface DataAutomationProjectSpeakerLabelingConfiguration {
+        /**
+         * State of speaker labeling, either enabled or disabled.
+         */
         state: enums.bedrock.DataAutomationProjectState;
     }
     interface DataAutomationProjectSplitterConfiguration {
@@ -11116,7 +11128,13 @@ export declare namespace bedrock {
         video?: outputs.bedrock.DataAutomationProjectVideoStandardOutputConfiguration;
     }
     interface DataAutomationProjectTranscriptConfiguration {
+        /**
+         * Enables channel labeling. Each audio channel will be labeled with a number, and the transcript will indicate which channel is being used.
+         */
         channelLabeling?: outputs.bedrock.DataAutomationProjectChannelLabelingConfiguration;
+        /**
+         * Enables speaker labeling. Each speaker within a transcript will recieve a number, and the transcript will note which speaker is talking.
+         */
         speakerLabeling?: outputs.bedrock.DataAutomationProjectSpeakerLabelingConfiguration;
     }
     interface DataAutomationProjectVideoBoundingBox {
@@ -14517,6 +14535,95 @@ export declare namespace bedrockagentcore {
          */
         networkMode: enums.bedrockagentcore.CodeInterpreterCustomCodeInterpreterNetworkMode;
     }
+    interface GatewayAuthorizerConfigurationProperties {
+        customJwtAuthorizer: outputs.bedrockagentcore.GatewayCustomJwtAuthorizerConfiguration;
+    }
+    interface GatewayCustomJwtAuthorizerConfiguration {
+        allowedAudience?: string[];
+        allowedClients?: string[];
+        discoveryUrl: string;
+    }
+    interface GatewayMcpGatewayConfiguration {
+        instructions?: string;
+        searchType?: enums.bedrockagentcore.GatewaySearchType;
+        supportedVersions?: string[];
+    }
+    interface GatewayProtocolConfigurationProperties {
+        mcp: outputs.bedrockagentcore.GatewayMcpGatewayConfiguration;
+    }
+    interface GatewayTargetApiKeyCredentialProvider {
+        credentialLocation?: enums.bedrockagentcore.GatewayTargetApiKeyCredentialLocation;
+        credentialParameterName?: string;
+        credentialPrefix?: string;
+        providerArn: string;
+    }
+    interface GatewayTargetApiSchemaConfiguration0Properties {
+        s3: outputs.bedrockagentcore.GatewayTargetS3Configuration;
+    }
+    interface GatewayTargetApiSchemaConfiguration1Properties {
+        inlinePayload: string;
+    }
+    interface GatewayTargetCredentialProvider0Properties {
+        oauthCredentialProvider: outputs.bedrockagentcore.GatewayTargetOAuthCredentialProvider;
+    }
+    interface GatewayTargetCredentialProvider1Properties {
+        apiKeyCredentialProvider: outputs.bedrockagentcore.GatewayTargetApiKeyCredentialProvider;
+    }
+    interface GatewayTargetCredentialProviderConfiguration {
+        credentialProvider?: outputs.bedrockagentcore.GatewayTargetCredentialProvider0Properties | outputs.bedrockagentcore.GatewayTargetCredentialProvider1Properties;
+        credentialProviderType: enums.bedrockagentcore.GatewayTargetCredentialProviderType;
+    }
+    interface GatewayTargetMcpLambdaTargetConfiguration {
+        lambdaArn: string;
+        toolSchema: outputs.bedrockagentcore.GatewayTargetToolSchema0Properties | outputs.bedrockagentcore.GatewayTargetToolSchema1Properties;
+    }
+    interface GatewayTargetMcpTargetConfiguration0Properties {
+        openApiSchema: outputs.bedrockagentcore.GatewayTargetApiSchemaConfiguration0Properties | outputs.bedrockagentcore.GatewayTargetApiSchemaConfiguration1Properties;
+    }
+    interface GatewayTargetMcpTargetConfiguration1Properties {
+        smithyModel: outputs.bedrockagentcore.GatewayTargetApiSchemaConfiguration0Properties | outputs.bedrockagentcore.GatewayTargetApiSchemaConfiguration1Properties;
+    }
+    interface GatewayTargetMcpTargetConfiguration2Properties {
+        lambda: outputs.bedrockagentcore.GatewayTargetMcpLambdaTargetConfiguration;
+    }
+    interface GatewayTargetOAuthCredentialProvider {
+        customParameters?: {
+            [key: string]: string;
+        };
+        providerArn: string;
+        scopes: string[];
+    }
+    interface GatewayTargetS3Configuration {
+        bucketOwnerAccountId?: string;
+        uri?: string;
+    }
+    interface GatewayTargetSchemaDefinition {
+        description?: string;
+        items?: outputs.bedrockagentcore.GatewayTargetSchemaDefinition;
+        properties?: {
+            [key: string]: outputs.bedrockagentcore.GatewayTargetSchemaDefinition;
+        };
+        required?: string[];
+        type: enums.bedrockagentcore.GatewayTargetSchemaType;
+    }
+    interface GatewayTargetTargetConfigurationProperties {
+        mcp: outputs.bedrockagentcore.GatewayTargetMcpTargetConfiguration0Properties | outputs.bedrockagentcore.GatewayTargetMcpTargetConfiguration1Properties | outputs.bedrockagentcore.GatewayTargetMcpTargetConfiguration2Properties;
+    }
+    interface GatewayTargetToolDefinition {
+        description: string;
+        inputSchema: outputs.bedrockagentcore.GatewayTargetSchemaDefinition;
+        name: string;
+        outputSchema?: outputs.bedrockagentcore.GatewayTargetSchemaDefinition;
+    }
+    interface GatewayTargetToolSchema0Properties {
+        s3: outputs.bedrockagentcore.GatewayTargetS3Configuration;
+    }
+    interface GatewayTargetToolSchema1Properties {
+        inlinePayload: outputs.bedrockagentcore.GatewayTargetToolDefinition[];
+    }
+    interface GatewayWorkloadIdentityDetails {
+        workloadIdentityArn: string;
+    }
     interface RuntimeAgentRuntimeArtifact {
         /**
          * Representation of a container configuration.
@@ -16402,7 +16509,7 @@ export declare namespace cloudfront {
          */
         httpsPort?: number;
         /**
-         * Specifies which IP protocol CloudFront uses when connecting to your origin. If your origin uses both IPv4 and IPv6 protocols, you can choose `dualstack` to help optimize reliability.
+         * Specifies which IP protocol CloudFront uses when connecting to your origin. If your origin uses both IPv4 and IPv6 protocols, you can choose ``dualstack`` to help optimize reliability.
          */
         ipAddressType?: enums.cloudfront.DistributionCustomOriginConfigIpAddressType;
         /**
@@ -17331,6 +17438,7 @@ export declare namespace cloudfront {
     }
     /**
      * Configuration information about a public key that you can use with [signed URLs and signed cookies](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/PrivateContent.html), or with [field-level encryption](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/field-level-encryption.html).
+     *  CloudFront supports signed URLs and signed cookies with RSA 2048 or ECDSA 256 key signatures. Field-level encryption is only compatible with RSA 2048 key signatures.
      */
     interface PublicKeyConfig {
         /**
@@ -20562,6 +20670,9 @@ export declare namespace connect {
      * Contains information about the manual assignment queue and channel
      */
     interface RoutingProfileManualAssignmentQueueConfig {
+        /**
+         * Contains information about a queue resource.
+         */
         queueReference: outputs.connect.RoutingProfileQueueReference;
     }
     /**
@@ -30680,11 +30791,23 @@ export declare namespace ecr {
 }
 export declare namespace ecs {
     interface CapacityProviderAcceleratorCountRequest {
+        /**
+         * The maximum number of accelerators. Instance types with more accelerators are excluded from selection.
+         */
         max?: number;
+        /**
+         * The minimum number of accelerators. Instance types with fewer accelerators are excluded from selection.
+         */
         min?: number;
     }
     interface CapacityProviderAcceleratorTotalMemoryMiBRequest {
+        /**
+         * The maximum total accelerator memory in MiB. Instance types with more accelerator memory are excluded from selection.
+         */
         max?: number;
+        /**
+         * The minimum total accelerator memory in MiB. Instance types with less accelerator memory are excluded from selection.
+         */
         min?: number;
     }
     interface CapacityProviderAutoScalingGroupProvider {
@@ -30712,52 +30835,174 @@ export declare namespace ecs {
         managedTerminationProtection?: enums.ecs.CapacityProviderAutoScalingGroupProviderManagedTerminationProtection;
     }
     interface CapacityProviderBaselineEbsBandwidthMbpsRequest {
+        /**
+         * The maximum baseline Amazon EBS bandwidth in Mbps. Instance types with higher Amazon EBS bandwidth are excluded from selection.
+         */
         max?: number;
+        /**
+         * The minimum baseline Amazon EBS bandwidth in Mbps. Instance types with lower Amazon EBS bandwidth are excluded from selection.
+         */
         min?: number;
     }
     interface CapacityProviderInstanceLaunchTemplate {
+        /**
+         * The Amazon Resource Name (ARN) of the instance profile that Amazon ECS applies to Amazon ECS Managed Instances. This instance profile must include the necessary permissions for your tasks to access AWS services and resources.
+         *
+         * For more information, see [Amazon ECS instance profile for Managed Instances](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/managed-instances-instance-profile.html) in the *Amazon ECS Developer Guide* .
+         */
         ec2InstanceProfileArn: string;
+        /**
+         * The instance requirements. You can specify:
+         *
+         * - The instance types
+         * - Instance requirements such as vCPU count, memory, network performance, and accelerator specifications
+         *
+         * Amazon ECS automatically selects the instances that match the specified criteria.
+         */
         instanceRequirements?: outputs.ecs.CapacityProviderInstanceRequirementsRequest;
+        /**
+         * CloudWatch provides two categories of monitoring: basic monitoring and detailed monitoring. By default, your managed instance is configured for basic monitoring. You can optionally enable detailed monitoring to help you more quickly identify and act on operational issues. You can enable or turn off detailed monitoring at launch or when the managed instance is running or stopped. For more information, see [Detailed monitoring for Amazon ECS Managed Instances](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/detailed-monitoring-managed-instances.html) in the Amazon ECS Developer Guide.
+         */
         monitoring?: enums.ecs.CapacityProviderManagedInstancesMonitoringOptions;
+        /**
+         * The network configuration for Amazon ECS Managed Instances. This specifies the subnets and security groups that instances use for network connectivity.
+         */
         networkConfiguration: outputs.ecs.CapacityProviderManagedInstancesNetworkConfiguration;
+        /**
+         * The storage configuration for Amazon ECS Managed Instances. This defines the root volume size and type for the instances.
+         */
         storageConfiguration?: outputs.ecs.CapacityProviderManagedInstancesStorageConfiguration;
     }
     interface CapacityProviderInstanceRequirementsRequest {
+        /**
+         * The minimum and maximum number of accelerators for the instance types. This is used when you need instances with specific numbers of GPUs or other accelerators.
+         */
         acceleratorCount?: outputs.ecs.CapacityProviderAcceleratorCountRequest;
+        /**
+         * The accelerator manufacturers to include. You can specify `nvidia` , `amd` , `amazon-web-services` , or `xilinx` depending on your accelerator requirements.
+         */
         acceleratorManufacturers?: enums.ecs.CapacityProviderInstanceRequirementsRequestAcceleratorManufacturersItem[];
+        /**
+         * The specific accelerator names to include. For example, you can specify `a100` , `v100` , `k80` , or other specific accelerator models.
+         */
         acceleratorNames?: enums.ecs.CapacityProviderInstanceRequirementsRequestAcceleratorNamesItem[];
+        /**
+         * The minimum and maximum total accelerator memory in mebibytes (MiB). This is important for GPU workloads that require specific amounts of video memory.
+         */
         acceleratorTotalMemoryMiB?: outputs.ecs.CapacityProviderAcceleratorTotalMemoryMiBRequest;
+        /**
+         * The accelerator types to include. You can specify `gpu` for graphics processing units, `fpga` for field programmable gate arrays, or `inference` for machine learning inference accelerators.
+         */
         acceleratorTypes?: enums.ecs.CapacityProviderInstanceRequirementsRequestAcceleratorTypesItem[];
+        /**
+         * The instance types to include in the selection. When specified, Amazon ECS only considers these instance types, subject to the other requirements specified.
+         */
         allowedInstanceTypes?: string[];
+        /**
+         * Indicates whether to include bare metal instance types. Set to `included` to allow bare metal instances, `excluded` to exclude them, or `required` to use only bare metal instances.
+         */
         bareMetal?: enums.ecs.CapacityProviderInstanceRequirementsRequestBareMetal;
+        /**
+         * The minimum and maximum baseline Amazon EBS bandwidth in megabits per second (Mbps). This is important for workloads with high storage I/O requirements.
+         */
         baselineEbsBandwidthMbps?: outputs.ecs.CapacityProviderBaselineEbsBandwidthMbpsRequest;
+        /**
+         * Indicates whether to include burstable performance instance types (T2, T3, T3a, T4g). Set to `included` to allow burstable instances, `excluded` to exclude them, or `required` to use only burstable instances.
+         */
         burstablePerformance?: enums.ecs.CapacityProviderInstanceRequirementsRequestBurstablePerformance;
+        /**
+         * The CPU manufacturers to include or exclude. You can specify `intel` , `amd` , or `amazon-web-services` to control which CPU types are used for your workloads.
+         */
         cpuManufacturers?: enums.ecs.CapacityProviderInstanceRequirementsRequestCpuManufacturersItem[];
+        /**
+         * The instance types to exclude from selection. Use this to prevent Amazon ECS from selecting specific instance types that may not be suitable for your workloads.
+         */
         excludedInstanceTypes?: string[];
+        /**
+         * The instance generations to include. You can specify `current` to use the latest generation instances, or `previous` to include previous generation instances for cost optimization.
+         */
         instanceGenerations?: enums.ecs.CapacityProviderInstanceRequirementsRequestInstanceGenerationsItem[];
+        /**
+         * Indicates whether to include instance types with local storage. Set to `included` to allow local storage, `excluded` to exclude it, or `required` to use only instances with local storage.
+         */
         localStorage?: enums.ecs.CapacityProviderInstanceRequirementsRequestLocalStorage;
+        /**
+         * The local storage types to include. You can specify `hdd` for hard disk drives, `ssd` for solid state drives, or both.
+         */
         localStorageTypes?: enums.ecs.CapacityProviderInstanceRequirementsRequestLocalStorageTypesItem[];
+        /**
+         * The maximum price for Spot instances as a percentage of the optimal On-Demand price. This provides more precise cost control for Spot instance selection.
+         */
         maxSpotPriceAsPercentageOfOptimalOnDemandPrice?: number;
+        /**
+         * The minimum and maximum amount of memory per vCPU in gibibytes (GiB). This helps ensure that instance types have the appropriate memory-to-CPU ratio for your workloads.
+         */
         memoryGiBPerVCpu?: outputs.ecs.CapacityProviderMemoryGiBPerVCpuRequest;
+        /**
+         * The minimum and maximum amount of memory in mebibytes (MiB) for the instance types. Amazon ECS selects instance types that have memory within this range.
+         */
         memoryMiB: outputs.ecs.CapacityProviderMemoryMiBRequest;
+        /**
+         * The minimum and maximum network bandwidth in gigabits per second (Gbps). This is crucial for network-intensive workloads that require high throughput.
+         */
         networkBandwidthGbps?: outputs.ecs.CapacityProviderNetworkBandwidthGbpsRequest;
+        /**
+         * The minimum and maximum number of network interfaces for the instance types. This is useful for workloads that require multiple network interfaces.
+         */
         networkInterfaceCount?: outputs.ecs.CapacityProviderNetworkInterfaceCountRequest;
+        /**
+         * The price protection threshold for On-Demand Instances, as a percentage higher than an identified On-Demand price. The identified On-Demand price is the price of the lowest priced current generation C, M, or R instance type with your specified attributes. If no current generation C, M, or R instance type matches your attributes, then the identified price is from either the lowest priced current generation instance types or, failing that, the lowest priced previous generation instance types that match your attributes. When Amazon ECS selects instance types with your attributes, we will exclude instance types whose price exceeds your specified threshold.
+         */
         onDemandMaxPricePercentageOverLowestPrice?: number;
+        /**
+         * Indicates whether the instance types must support hibernation. When set to `true` , only instance types that support hibernation are selected.
+         */
         requireHibernateSupport?: boolean;
+        /**
+         * The maximum price for Spot instances as a percentage over the lowest priced On-Demand instance. This helps control Spot instance costs while maintaining access to capacity.
+         */
         spotMaxPricePercentageOverLowestPrice?: number;
+        /**
+         * The minimum and maximum total local storage in gigabytes (GB) for instance types with local storage.
+         */
         totalLocalStorageGb?: outputs.ecs.CapacityProviderTotalLocalStorageGbRequest;
+        /**
+         * The minimum and maximum number of vCPUs for the instance types. Amazon ECS selects instance types that have vCPU counts within this range.
+         */
         vCpuCount: outputs.ecs.CapacityProviderVCpuCountRangeRequest;
     }
     interface CapacityProviderManagedInstancesNetworkConfiguration {
+        /**
+         * The list of security group IDs to apply to Amazon ECS Managed Instances. These security groups control the network traffic allowed to and from the instances.
+         */
         securityGroups?: string[];
+        /**
+         * The list of subnet IDs where Amazon ECS can launch Amazon ECS Managed Instances. Instances are distributed across the specified subnets for high availability. All subnets must be in the same VPC.
+         */
         subnets: string[];
     }
     interface CapacityProviderManagedInstancesProvider {
+        /**
+         * The Amazon Resource Name (ARN) of the infrastructure role that Amazon ECS assumes to manage instances. This role must include permissions for Amazon EC2 instance lifecycle management, networking, and any additional AWS services required for your workloads.
+         *
+         * For more information, see [Amazon ECS infrastructure IAM role](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/infrastructure_IAM_role.html) in the *Amazon ECS Developer Guide* .
+         */
         infrastructureRoleArn: string;
+        /**
+         * The launch template that defines how Amazon ECS launches Amazon ECS Managed Instances. This includes the instance profile for your tasks, network and storage configuration, and instance requirements that determine which Amazon EC2 instance types can be used.
+         *
+         * For more information, see [Store instance launch parameters in Amazon EC2 launch templates](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html) in the *Amazon EC2 User Guide* .
+         */
         instanceLaunchTemplate: outputs.ecs.CapacityProviderInstanceLaunchTemplate;
+        /**
+         * Determines whether tags from the capacity provider are automatically applied to Amazon ECS Managed Instances. This helps with cost allocation and resource management by ensuring consistent tagging across your infrastructure.
+         */
         propagateTags?: enums.ecs.CapacityProviderManagedInstancesProviderPropagateTags;
     }
     interface CapacityProviderManagedInstancesStorageConfiguration {
+        /**
+         * The size of the tasks volume.
+         */
         storageSizeGiB: number;
     }
     /**
@@ -30788,27 +31033,63 @@ export declare namespace ecs {
         targetCapacity?: number;
     }
     interface CapacityProviderMemoryGiBPerVCpuRequest {
+        /**
+         * The maximum amount of memory per vCPU in GiB. Instance types with a higher memory-to-vCPU ratio are excluded from selection.
+         */
         max?: number;
+        /**
+         * The minimum amount of memory per vCPU in GiB. Instance types with a lower memory-to-vCPU ratio are excluded from selection.
+         */
         min?: number;
     }
     interface CapacityProviderMemoryMiBRequest {
+        /**
+         * The maximum amount of memory in MiB. Instance types with more memory than this value are excluded from selection.
+         */
         max?: number;
+        /**
+         * The minimum amount of memory in MiB. Instance types with less memory than this value are excluded from selection.
+         */
         min: number;
     }
     interface CapacityProviderNetworkBandwidthGbpsRequest {
+        /**
+         * The maximum network bandwidth in Gbps. Instance types with higher network bandwidth are excluded from selection.
+         */
         max?: number;
+        /**
+         * The minimum network bandwidth in Gbps. Instance types with lower network bandwidth are excluded from selection.
+         */
         min?: number;
     }
     interface CapacityProviderNetworkInterfaceCountRequest {
+        /**
+         * The maximum number of network interfaces. Instance types that support more network interfaces are excluded from selection.
+         */
         max?: number;
+        /**
+         * The minimum number of network interfaces. Instance types that support fewer network interfaces are excluded from selection.
+         */
         min?: number;
     }
     interface CapacityProviderTotalLocalStorageGbRequest {
+        /**
+         * The maximum total local storage in GB. Instance types with more local storage are excluded from selection.
+         */
         max?: number;
+        /**
+         * The minimum total local storage in GB. Instance types with less local storage are excluded from selection.
+         */
         min?: number;
     }
     interface CapacityProviderVCpuCountRangeRequest {
+        /**
+         * The maximum number of vCPUs. Instance types with more vCPUs than this value are excluded from selection.
+         */
         max?: number;
+        /**
+         * The minimum number of vCPUs. Instance types with fewer vCPUs than this value are excluded from selection.
+         */
         min: number;
     }
     interface ClusterCapacityProviderAssociationsCapacityProviderStrategy {

package/types/output.js.map

@@ -1 +1 @@
-{"version":3,"file":"output.js","sourceRoot":"","sources":["../../types/output.ts"],"names":[],"mappings":";AAAA,sEAAsE;AACtE,iFAAiF;;;AA8hpBjF,IAAiB,MAAM,CAgHtB;AAhHD,WAAiB,MAAM;IAoDnB;;OAEG;IACH,SAAgB,yBAAyB,CAAC,GAAe;;QACrD,uCACO,GAAG,KACN,qBAAqB,EAAE,MAAA,CAAC,GAAG,CAAC,qBAAqB,CAAC,mCAAI,CAAC,IACzD;IACN,CAAC;IALe,gCAAyB,4BAKxC,CAAA;AAoDL,CAAC,EAhHgB,MAAM,GAAN,cAAM,KAAN,cAAM,QAgHtB"}
+{"version":3,"file":"output.js","sourceRoot":"","sources":["../../types/output.ts"],"names":[],"mappings":";AAAA,sEAAsE;AACtE,iFAAiF;;;AA4ppBjF,IAAiB,MAAM,CAgHtB;AAhHD,WAAiB,MAAM;IAoDnB;;OAEG;IACH,SAAgB,yBAAyB,CAAC,GAAe;;QACrD,uCACO,GAAG,KACN,qBAAqB,EAAE,MAAA,CAAC,GAAG,CAAC,qBAAqB,CAAC,mCAAI,CAAC,IACzD;IACN,CAAC;IALe,gCAAyB,4BAKxC,CAAA;AAoDL,CAAC,EAhHgB,MAAM,GAAN,cAAM,KAAN,cAAM,QAgHtB"}