sailfork / t3code-github / .repos/ alchemy-effect/ packages/ aws/ src/ Providers.ts

import { DockerLive } from "@alchemy.run/docker/Docker";
/** @effect-diagnostics layerMergeAllWithDependencies:off */
import { isRetryable, isThrottlingError, isTransientError } from "@distilled.cloud/aws/Category";
import { capped, jittered, Retry, type Factory as RetryFactory } from "@distilled.cloud/aws/Retry";
import { CredentialsStoreLive } from "alchemy/Auth/Credentials";
import * as Command from "alchemy/Command";
import { KeyPair, KeyPairProvider } from "alchemy/KeyPair";
import * as ProviderLayer from "alchemy/Local/ProviderLayer";
import * as Provider from "alchemy/Provider";
import { defaultProviderMode } from "alchemy/ProviderMode";
import { Random, RandomProvider } from "alchemy/Random";
import {
  Server as WebsiteServer,
  ServerProvider as WebsiteServerProvider,
} from "alchemy/Website/Server";
import * as Duration from "effect/Duration";
import * as Effect from "effect/Effect";
import { pipe } from "effect/Function";
import * as HttpClientError from "effect/http/HttpClientError";
import * as Layer from "effect/Layer";
import * as Ref from "effect/Ref";
import * as Schedule from "effect/Schedule";
import * as AccessAnalyzer from "./AccessAnalyzer/index.ts";
import * as Account from "./Account/index.ts";
import * as ACM from "./ACM/index.ts";
import * as ACMPCA from "./ACMPCA/index.ts";
import * as AIOps from "./AIOps/index.ts";
import * as AMP from "./AMP/index.ts";
import * as Amplify from "./Amplify/index.ts";
import * as ApiGateway from "./ApiGateway/index.ts";
import * as ApiGatewayV2 from "./ApiGatewayV2/index.ts";
import * as AppConfig from "./AppConfig/index.ts";
import * as AppFlow from "./AppFlow/index.ts";
import * as AppIntegrations from "./AppIntegrations/index.ts";
import * as ApplicationAutoScaling from "./ApplicationAutoScaling/index.ts";
import * as ApplicationSignals from "./ApplicationSignals/index.ts";
import * as AppRegistry from "./AppRegistry/index.ts";
import * as AppRunner from "./AppRunner/index.ts";
import * as AppSync from "./AppSync/index.ts";
import * as Assets from "./Assets.ts";
import * as Athena from "./Athena/index.ts";
import * as AuditManager from "./AuditManager/index.ts";
import { AwsAuth } from "./AuthProvider.ts";
import * as AutoScaling from "./AutoScaling/index.ts";
import * as B2BI from "./B2BI/index.ts";
import * as Backup from "./Backup/index.ts";
import * as BackupSearch from "./BackupSearch/index.ts";
import * as Batch from "./Batch/index.ts";
import * as BCMDataExports from "./BCMDataExports/index.ts";
import * as Bedrock from "./Bedrock/index.ts";
import * as BedrockAgentCore from "./BedrockAgentCore/index.ts";
import * as BedrockDataAutomation from "./BedrockDataAutomation/index.ts";
import * as Budgets from "./Budgets/index.ts";
import * as Chatbot from "./Chatbot/index.ts";
import * as CloudControl from "./CloudControl/index.ts";
import * as CloudFormation from "./CloudFormation/index.ts";
import * as CloudFront from "./CloudFront/index.ts";
import * as CloudHSMV2 from "./CloudHSMV2/index.ts";
import * as CloudMap from "./CloudMap/index.ts";
import * as CloudTrail from "./CloudTrail/index.ts";
import * as CloudWatch from "./CloudWatch/index.ts";
import * as CodeArtifact from "./CodeArtifact/index.ts";
import * as CodeBuild from "./CodeBuild/index.ts";
import * as CodeConnections from "./CodeConnections/index.ts";
import * as CodeDeploy from "./CodeDeploy/index.ts";
import * as CodePipeline from "./CodePipeline/index.ts";
import * as Cognito from "./Cognito/index.ts";
import * as Config from "./Config/index.ts";
import * as ControlTower from "./ControlTower/index.ts";
import * as CostAndUsageReport from "./CostAndUsageReport/index.ts";
import * as CostExplorer from "./CostExplorer/index.ts";
import * as Credentials from "./Credentials.ts";
import * as DataBrew from "./DataBrew/index.ts";
import * as DataExchange from "./DataExchange/index.ts";
import * as DataSync from "./DataSync/index.ts";
import * as DataZone from "./DataZone/index.ts";
import * as DAX from "./DAX/index.ts";
import * as Deadline from "./Deadline/index.ts";
import * as Detective from "./Detective/index.ts";
import * as DevOpsGuru from "./DevOpsGuru/index.ts";
import * as DirectoryService from "./DirectoryService/index.ts";
import * as DLM from "./DLM/index.ts";
import * as DMS from "./DMS/index.ts";
import * as DocDB from "./DocDB/index.ts";
import * as DocDBElastic from "./DocDBElastic/index.ts";
import * as DSQL from "./DSQL/index.ts";
import * as DynamoDB from "./DynamoDB/index.ts";
import * as EC2 from "./EC2/index.ts";
import * as ECR from "./ECR/index.ts";
import * as ECRPublic from "./ECRPublic/index.ts";
import * as ECS from "./ECS/index.ts";
import * as EFS from "./EFS/index.ts";
import * as EKS from "./EKS/index.ts";
import * as ElastiCache from "./ElastiCache/index.ts";
import * as ELBv2 from "./ELBv2/index.ts";
import * as EMR from "./EMR/index.ts";
import * as EMRContainers from "./EMRContainers/index.ts";
import * as EMRServerless from "./EMRServerless/index.ts";
import * as Endpoint from "./Endpoint.ts";
import * as EntityResolution from "./EntityResolution/index.ts";
import { providedOrDefault } from "./Environment.ts";
import * as EventBridge from "./EventBridge/index.ts";
import * as FinSpace from "./FinSpace/index.ts";
import * as Firehose from "./Firehose/index.ts";
import * as FIS from "./FIS/index.ts";
import * as FMS from "./FMS/index.ts";
import * as Forecast from "./Forecast/index.ts";
import * as FraudDetector from "./FraudDetector/index.ts";
import * as FSx from "./FSx/index.ts";
import * as Glacier from "./Glacier/index.ts";
import * as GlobalAccelerator from "./GlobalAccelerator/index.ts";
import * as Glue from "./Glue/index.ts";
import * as Grafana from "./Grafana/index.ts";
import * as GreengrassV2 from "./GreengrassV2/index.ts";
import * as GuardDuty from "./GuardDuty/index.ts";
import * as HealthLake from "./HealthLake/index.ts";
import * as IAM from "./IAM/index.ts";
import * as IdentityCenter from "./IdentityCenter/index.ts";
import * as ImageBuilder from "./ImageBuilder/index.ts";
import * as Inspector2 from "./Inspector2/index.ts";
import * as InternetMonitor from "./InternetMonitor/index.ts";
import * as IoT from "./IoT/index.ts";
import * as IoTFleetWise from "./IoTFleetWise/index.ts";
import * as IoTManagedIntegrations from "./IoTManagedIntegrations/index.ts";
import * as IoTSiteWise from "./IoTSiteWise/index.ts";
import * as IoTWireless from "./IoTWireless/index.ts";
import * as IVS from "./IVS/index.ts";
import * as IVSChat from "./IVSChat/index.ts";
import * as IVSRealtime from "./IVSRealtime/index.ts";
import * as Kafka from "./Kafka/index.ts";
import * as Kendra from "./Kendra/index.ts";
import * as Keyspaces from "./Keyspaces/index.ts";
import * as Kinesis from "./Kinesis/index.ts";
import * as KinesisAnalyticsV2 from "./KinesisAnalyticsV2/index.ts";
import * as KinesisVideo from "./KinesisVideo/index.ts";
import * as KMS from "./KMS/index.ts";
import * as LakeFormation from "./LakeFormation/index.ts";
import * as Lambda from "./Lambda/index.ts";
import * as LexV2 from "./LexV2/index.ts";
import * as LicenseManager from "./LicenseManager/index.ts";
import { flociDual, flociServices } from "./Local/FlociServices.ts";
import { captureAwsEnvironment, pinCollectionEnvironment } from "./Local/ProviderContext.ts";
import * as Location from "./Location/index.ts";
import * as Logs from "./Logs/index.ts";
import * as Macie2 from "./Macie2/index.ts";
import * as MailManager from "./MailManager/index.ts";
import * as MediaConnect from "./MediaConnect/index.ts";
import * as MediaConvert from "./MediaConvert/index.ts";
import * as MediaLive from "./MediaLive/index.ts";
import * as MediaPackageV2 from "./MediaPackageV2/index.ts";
import * as MediaTailor from "./MediaTailor/index.ts";
import * as MedicalImaging from "./MedicalImaging/index.ts";
import * as MemoryDB from "./MemoryDB/index.ts";
import * as MQ from "./MQ/index.ts";
import * as MWAA from "./MWAA/index.ts";
import * as MWAAServerless from "./MWAAServerless/index.ts";
import * as Neptune from "./Neptune/index.ts";
import * as NeptuneGraph from "./NeptuneGraph/index.ts";
import * as NetworkFirewall from "./NetworkFirewall/index.ts";
import * as Notifications from "./Notifications/index.ts";
import * as NotificationsContacts from "./NotificationsContacts/index.ts";
import * as OAM from "./OAM/index.ts";
import * as ObservabilityAdmin from "./ObservabilityAdmin/index.ts";
import * as Omics from "./Omics/index.ts";
import * as OpenSearch from "./OpenSearch/index.ts";
import * as OpenSearchServerless from "./OpenSearchServerless/index.ts";
import * as Organizations from "./Organizations/index.ts";
import * as OSIS from "./OSIS/index.ts";
import * as PaymentCryptography from "./PaymentCryptography/index.ts";
import * as Personalize from "./Personalize/index.ts";
import * as PinpointSMSVoiceV2 from "./PinpointSMSVoiceV2/index.ts";
import * as Pipes from "./Pipes/index.ts";
import * as Polly from "./Polly/index.ts";
import * as QApps from "./QApps/index.ts";
import * as QBusiness from "./QBusiness/index.ts";
import * as QuickSight from "./QuickSight/index.ts";
import * as RAM from "./RAM/index.ts";
import * as Rbin from "./Rbin/index.ts";
import * as RDS from "./RDS/index.ts";
import * as Redshift from "./Redshift/index.ts";
import * as RedshiftServerless from "./RedshiftServerless/index.ts";
import * as Region from "./Region.ts";
import * as RePostSpace from "./RePostSpace/index.ts";
import * as ResourceExplorer from "./ResourceExplorer/index.ts";
import * as ResourceGroups from "./ResourceGroups/index.ts";
import * as RolesAnywhere from "./RolesAnywhere/index.ts";
import * as Route53 from "./Route53/index.ts";
import * as Route53Profiles from "./Route53Profiles/index.ts";
import * as Route53Resolver from "./Route53Resolver/index.ts";
import * as RUM from "./RUM/index.ts";
import * as S3 from "./S3/index.ts";
import * as S3Control from "./S3Control/index.ts";
import * as S3Files from "./S3Files/index.ts";
import * as S3Tables from "./S3Tables/index.ts";
import * as S3Vectors from "./S3Vectors/index.ts";
import * as SageMaker from "./SageMaker/index.ts";
import * as Scheduler from "./Scheduler/index.ts";
import * as Schemas from "./Schemas/index.ts";
import * as SecretsManager from "./SecretsManager/index.ts";
import * as SecurityHub from "./SecurityHub/index.ts";
import * as SecurityLake from "./SecurityLake/index.ts";
import * as ServiceCatalog from "./ServiceCatalog/index.ts";
import * as ServiceQuotas from "./ServiceQuotas/index.ts";
import * as SES from "./SES/index.ts";
import * as Shield from "./Shield/index.ts";
import * as Signer from "./Signer/index.ts";
import * as SimpleDB from "./SimpleDB/index.ts";
import * as SNS from "./SNS/index.ts";
import * as SocialMessaging from "./SocialMessaging/index.ts";
import * as SQS from "./SQS/index.ts";
import * as SSM from "./SSM/index.ts";
import * as SSMContacts from "./SSMContacts/index.ts";
import * as SSMIncidents from "./SSMIncidents/index.ts";
import * as StepFunctions from "./StepFunctions/index.ts";
import * as Synthetics from "./Synthetics/index.ts";
import * as Textract from "./Textract/index.ts";
import * as Timestream from "./Timestream/index.ts";
import * as Transfer from "./Transfer/index.ts";
import * as Translate from "./Translate/index.ts";
import * as VerifiedPermissions from "./VerifiedPermissions/index.ts";
import * as VpcLattice from "./VpcLattice/index.ts";
import * as WAFv2 from "./WAFv2/index.ts";
import * as Website from "./Website/index.ts";
import * as XRay from "./XRay/index.ts";

export class Providers extends Provider.ProviderCollection<Providers>()("AWS") {}

/**
 * Every AWS provider, pinned to one AWS environment (account, region and
 * credentials).
 *
 * By default the environment resolves lazily from the configured profile, CI
 * credentials or the ambient AWS environment. Provide your own
 * `AWSEnvironment` to deploy with another credential source, e.g. a role
 * assumed at runtime; provide the same layer to {@link state} so resources and
 * state share it.
 *
 * ```typescript
 * const environment = Layer.effect(
 *   AWS.AWSEnvironment,
 *   Effect.gen(function* () {
 *     const session = yield* assumeDeployRole;
 *     return Effect.succeed({
 *       accountId: session.accountId,
 *       region: session.region,
 *       credentials: session.credentials,
 *     });
 *   }),
 * );
 *
 * const Stack = Alchemy.Stack(
 *   "my-stack",
 *   {
 *     providers: AWS.providers().pipe(Layer.provide(environment)),
 *     state: AWS.state({ bucketName: "my-company-state" }).pipe(Layer.provide(environment)),
 *   },
 *   program,
 * );
 * ```
 */
export const providers = () =>
  Layer.effect(
    Providers,
    // Providers are PINNED to the environment they are registered with (the
    // live chain provided at the bottom of this pipe) — see
    // `pinCollectionEnvironment`. The ambient environment the STACK program
    // sees flips to the emulator in a dev run (bottom of this file), and the
    // pin is what keeps live-mode and mode-agnostic providers on the real
    // cloud regardless.
    Effect.flatMap(
      Provider.collection([
        KeyPair,
        Random,
        AccessAnalyzer.Analyzer,
        AccessAnalyzer.ArchiveRule,
        Account.AccountName,
        Account.AlternateContact,
        Account.ContactInformation,
        Account.Region,
        ACM.AccountConfiguration,
        ACM.Certificate,
        ACM.CertificateValidation,
        ACMPCA.CertificateAuthority,
        ACMPCA.CertificateAuthorityPolicy,
        ACMPCA.Permission,
        AIOps.InvestigationGroup,
        AMP.AlertManagerDefinition,
        AMP.AnomalyDetector,
        AMP.LoggingConfiguration,
        AMP.QueryLoggingConfiguration,
        AMP.ResourcePolicy,
        AMP.RuleGroupsNamespace,
        AMP.Scraper,
        AMP.ScraperLoggingConfiguration,
        AMP.Workspace,
        Amplify.App,
        Amplify.Branch,
        ApiGateway.Account,
        ApiGateway.ApiKey,
        ApiGateway.Authorizer,
        ApiGateway.BasePathMapping,
        ApiGateway.DeploymentResource,
        ApiGateway.DomainName,
        ApiGateway.GatewayResponse,
        ApiGateway.MethodResource,
        ApiGateway.GatewayResource,
        ApiGateway.RestApi,
        ApiGateway.StageResource,
        ApiGateway.UsagePlan,
        ApiGateway.UsagePlanKey,
        ApiGateway.VpcLink,
        ApiGatewayV2.Api,
        ApiGatewayV2.ApiMappingResource,
        ApiGatewayV2.AuthorizerResource,
        ApiGatewayV2.DomainName,
        ApiGatewayV2.IntegrationResource,
        ApiGatewayV2.RouteResource,
        ApiGatewayV2.StageResource,
        ApiGatewayV2.VpcLink,
        AppConfig.Application,
        AppConfig.ConfigurationProfile,
        AppConfig.Deployment,
        AppConfig.DeploymentStrategy,
        AppConfig.Environment,
        AppConfig.Extension,
        AppConfig.ExtensionAssociation,
        AppConfig.HostedConfigurationVersion,
        AppFlow.ConnectorProfile,
        AppFlow.Flow,
        AppIntegrations.Application,
        AppIntegrations.DataIntegration,
        AppIntegrations.EventIntegration,
        ApplicationAutoScaling.ScalableTarget,
        ApplicationAutoScaling.ScalingPolicy,
        ApplicationAutoScaling.ScheduledAction,
        ApplicationSignals.Discovery,
        ApplicationSignals.GroupingConfiguration,
        ApplicationSignals.InstrumentationConfiguration,
        ApplicationSignals.ServiceLevelObjective,
        AppRegistry.Application,
        AppRegistry.AttributeGroup,
        AppRegistry.AttributeGroupAssociation,
        AppRegistry.ResourceAssociation,
        AppRunner.AutoScalingConfiguration,
        AppRunner.ObservabilityConfiguration,
        AppRunner.Service,
        AppRunner.VpcConnector,
        AppSync.ApiAssociationResource,
        AppSync.ApiKeyResource,
        AppSync.DataSourceResource,
        AppSync.DomainName,
        AppSync.FunctionResource,
        AppSync.GraphqlApi,
        AppSync.ResolverResource,
        Athena.DataCatalog,
        Athena.NamedQuery,
        Athena.PreparedStatement,
        Athena.WorkGroup,
        AuditManager.Assessment,
        AuditManager.Control,
        AuditManager.Framework,
        AutoScaling.AutoScalingGroup,
        AutoScaling.LaunchTemplate,
        AutoScaling.LifecycleHook,
        AutoScaling.ScalingPolicy,
        AutoScaling.ScheduledAction,
        B2BI.Capability,
        B2BI.Partnership,
        B2BI.Profile,
        B2BI.Transformer,
        Backup.BackupPlan,
        Backup.BackupSelection,
        Backup.BackupVault,
        BackupSearch.ExportJob,
        BackupSearch.SearchJob,
        Batch.ComputeEnvironment,
        Batch.JobDefinition,
        Batch.JobQueue,
        BCMDataExports.Export,
        Bedrock.Agent,
        Bedrock.AgentAlias,
        Bedrock.DataSource,
        Bedrock.KnowledgeBase,
        BedrockAgentCore.BrowserCustom,
        BedrockAgentCore.CodeInterpreter,
        BedrockAgentCore.Gateway,
        BedrockAgentCore.Memory,
        BedrockAgentCore.Runtime,
        BedrockDataAutomation.Blueprint,
        BedrockDataAutomation.DataAutomationLibrary,
        BedrockDataAutomation.DataAutomationProject,
        Budgets.Budget,
        Budgets.BudgetAction,
        Chatbot.Association,
        Chatbot.CustomAction,
        Chatbot.MicrosoftTeamsChannelConfiguration,
        Chatbot.SlackChannelConfiguration,
        CloudControl.Resource,
        CloudFormation.Stack,
        CloudFront.CachePolicy,
        CloudFront.Distribution,
        CloudFront.Function,
        CloudFront.Invalidation,
        CloudFront.KeyGroup,
        CloudFront.KeyValueStore,
        CloudFront.KvEntries,
        CloudFront.KvRoutesUpdate,
        CloudFront.OriginAccessControl,
        CloudFront.OriginRequestPolicy,
        CloudFront.PublicKey,
        CloudFront.RealtimeLogConfig,
        CloudFront.ResponseHeadersPolicy,
        CloudFront.VpcOrigin,
        CloudHSMV2.Cluster,
        CloudHSMV2.Hsm,
        CloudMap.HttpNamespace,
        CloudMap.InstanceRegistration,
        CloudMap.PrivateDnsNamespace,
        CloudMap.PublicDnsNamespace,
        CloudMap.Service,
        CloudTrail.EventDataStore,
        CloudTrail.Trail,
        CloudWatch.Alarm,
        CloudWatch.AlarmMuteRule,
        CloudWatch.AnomalyDetector,
        CloudWatch.CompositeAlarm,
        CloudWatch.Dashboard,
        CloudWatch.InsightRule,
        CloudWatch.MetricStream,
        CodeArtifact.Domain,
        CodeArtifact.Repository,
        CodeBuild.Project,
        CodeBuild.ReportGroup,
        CodeConnections.Connection,
        CodeConnections.Host,
        CodeConnections.RepositoryLink,
        CodeConnections.SyncConfiguration,
        CodeDeploy.Application,
        CodeDeploy.DeploymentConfig,
        CodeDeploy.DeploymentGroup,
        CodePipeline.Pipeline,
        Cognito.Group,
        Cognito.IdentityPool,
        Cognito.IdentityPoolRoleAttachment,
        Cognito.IdentityProvider,
        Cognito.ManagedLoginBranding,
        Cognito.ResourceServer,
        Cognito.User,
        Cognito.UserPool,
        Cognito.UserPoolClient,
        Cognito.UserPoolDomain,
        Config.AggregationAuthorization,
        Config.ConfigRule,
        Config.ConfigurationRecorder,
        Config.DeliveryChannel,
        Config.RetentionConfiguration,
        ControlTower.EnabledBaseline,
        ControlTower.EnabledControl,
        ControlTower.LandingZone,
        CostAndUsageReport.ReportDefinition,
        CostExplorer.AnomalyMonitor,
        CostExplorer.AnomalySubscription,
        CostExplorer.CostCategory,
        DataBrew.Dataset,
        DataBrew.Job,
        DataBrew.Project,
        DataBrew.Recipe,
        DataBrew.Ruleset,
        DataBrew.Schedule,
        DataExchange.DataSet,
        DataExchange.EventAction,
        DataExchange.Revision,
        DataSync.LocationEfs,
        DataSync.LocationS3,
        DataSync.Task,
        DataZone.Domain,
        DataZone.Environment,
        DataZone.EnvironmentBlueprintConfiguration,
        DataZone.Project,
        DAX.Cluster,
        DAX.ParameterGroup,
        DAX.SubnetGroup,
        Deadline.Budget,
        Deadline.Farm,
        Deadline.Fleet,
        Deadline.Monitor,
        Deadline.Queue,
        Deadline.StorageProfile,
        DirectoryService.ConditionalForwarder,
        DirectoryService.Directory,
        DirectoryService.EventTopic,
        DLM.LifecyclePolicy,
        DocDB.DBCluster,
        DocDB.DBInstance,
        DocDB.DBSubnetGroup,
        DocDBElastic.Cluster,
        DMS.Endpoint,
        DMS.ReplicationInstance,
        DMS.ReplicationSubnetGroup,
        DSQL.Cluster,
        DSQL.ClusterPolicy,
        DSQL.Stream,
        Detective.Graph,
        DevOpsGuru.EventSourcesConfig,
        DevOpsGuru.NotificationChannel,
        DevOpsGuru.ResourceCollection,
        DevOpsGuru.ServiceIntegration,
        DynamoDB.Table,
        EC2.DhcpOptions,
        EC2.EgressOnlyInternetGateway,
        EC2.EIP,
        EC2.FlowLog,
        EC2.Instance,
        EC2.InternetGateway,
        EC2.KeyPair,
        EC2.NatGateway,
        EC2.NetworkAcl,
        EC2.NetworkAclAssociation,
        EC2.NetworkAclEntry,
        EC2.NetworkInterface,
        EC2.NetworkInterfaceAttachment,
        EC2.PrefixList,
        EC2.Route,
        EC2.RouteTable,
        EC2.RouteTableAssociation,
        EC2.SecurityGroup,
        EC2.DefaultSecurityGroup,
        EC2.SecurityGroupRule,
        EC2.Snapshot,
        EC2.Subnet,
        EC2.Volume,
        EC2.VolumeAttachment,
        EC2.ClientVpnEndpoint,
        EC2.ClientVpnTargetNetworkAssociation,
        EC2.ClientVpnAuthorizationRule,
        EC2.ClientVpnRoute,
        EC2.Vpc,
        EC2.VpcEndpoint,
        EC2.VpcPeeringConnection,
        ECR.Image,
        ECR.RegistryPolicy,
        ECR.Repository,
        ECRPublic.PublicRepository,
        ECS.CapacityProvider,
        ECS.Cluster,
        ECS.Service,
        ECS.Task,
        ECS.TaskDefinition,
        EFS.AccessPoint,
        EFS.FileSystem,
        EFS.MountTarget,
        EKS.AccessEntry,
        EKS.Addon,
        EKS.Cluster,
        EKS.FargateProfile,
        EKS.Nodegroup,
        EKS.PodIdentityAssociation,
        ElastiCache.CacheCluster,
        ElastiCache.ReplicationGroup,
        ElastiCache.ServerlessCache,
        ElastiCache.SubnetGroup,
        ELBv2.Listener,
        ELBv2.ListenerCertificate,
        ELBv2.ListenerRule,
        ELBv2.LoadBalancer,
        ELBv2.TargetGroup,
        ELBv2.TargetGroupAttachment,
        ELBv2.TrustStore,
        EMR.Cluster,
        EMR.SecurityConfiguration,
        EMR.Studio,
        EMRContainers.JobTemplate,
        EMRContainers.VirtualCluster,
        EMRServerless.Application,
        EntityResolution.IdMappingWorkflow,
        EntityResolution.IdNamespace,
        EntityResolution.MatchingWorkflow,
        EntityResolution.SchemaMapping,
        EventBridge.ApiDestination,
        EventBridge.Archive,
        EventBridge.Connection,
        EventBridge.Endpoint,
        EventBridge.EventBus,
        EventBridge.Permission,
        EventBridge.Rule,
        FIS.ExperimentTemplate,
        FIS.TargetAccountConfiguration,
        FMS.AdminAccount,
        FinSpace.Environment,
        FinSpace.KxCluster,
        FinSpace.KxDatabase,
        FinSpace.KxEnvironment,
        Firehose.DeliveryStream,
        FSx.FileSystem,
        Forecast.Dataset,
        Forecast.DatasetGroup,
        FraudDetector.Detector,
        FraudDetector.DetectorVersion,
        FraudDetector.EntityType,
        FraudDetector.EventType,
        FraudDetector.Label,
        FraudDetector.List,
        FraudDetector.Outcome,
        FraudDetector.Variable,
        Glacier.Vault,
        GlobalAccelerator.Accelerator,
        GlobalAccelerator.EndpointGroup,
        GlobalAccelerator.Listener,
        Glue.Connection,
        Glue.Crawler,
        Glue.Database,
        Glue.Job,
        Glue.Table,
        Grafana.Workspace,
        GreengrassV2.ComponentVersion,
        GreengrassV2.Deployment,
        GuardDuty.Detector,
        GuardDuty.Filter,
        GuardDuty.IPSet,
        GuardDuty.ThreatIntelSet,
        HealthLake.FHIRDatastore,
        IAM.AccessKey,
        IAM.AccountAlias,
        IAM.AccountPasswordPolicy,
        IAM.Group,
        IAM.GroupMembership,
        IAM.InstanceProfile,
        IAM.LoginProfile,
        IAM.OpenIDConnectProvider,
        IAM.Policy,
        IAM.Role,
        IAM.SAMLProvider,
        IAM.ServerCertificate,
        IAM.ServiceLinkedRole,
        IAM.ServiceSpecificCredential,
        IAM.SigningCertificate,
        IAM.SSHPublicKey,
        IAM.User,
        IAM.VirtualMFADevice,
        IdentityCenter.AccountAssignment,
        IdentityCenter.Group,
        IdentityCenter.Instance,
        ImageBuilder.Component,
        ImageBuilder.DistributionConfiguration,
        ImageBuilder.ImagePipeline,
        ImageBuilder.ImageRecipe,
        ImageBuilder.InfrastructureConfiguration,
        Inspector2.CisScanConfiguration,
        Inspector2.Enabler,
        Inspector2.Filter,
        InternetMonitor.Monitor,
        IdentityCenter.PermissionSet,
        IoT.Policy,
        IoT.Thing,
        IoT.ThingType,
        IoT.TopicRule,
        IoTFleetWise.Campaign,
        IoTFleetWise.DecoderManifest,
        IoTFleetWise.Fleet,
        IoTFleetWise.ModelManifest,
        IoTFleetWise.SignalCatalog,
        IoTFleetWise.StateTemplate,
        IoTFleetWise.Vehicle,
        IoTManagedIntegrations.CredentialLocker,
        IoTManagedIntegrations.Destination,
        IoTManagedIntegrations.ManagedThing,
        IoTManagedIntegrations.NotificationConfiguration,
        IoTSiteWise.Asset,
        IoTSiteWise.AssetModel,
        IoTSiteWise.Gateway,
        IoTWireless.Destination,
        IoTWireless.DeviceProfile,
        IoTWireless.ServiceProfile,
        IoTWireless.WirelessDevice,
        IoTWireless.WirelessGateway,
        IVS.Channel,
        IVS.PlaybackKeyPair,
        IVS.PlaybackRestrictionPolicy,
        IVS.RecordingConfiguration,
        IVS.StreamKey,
        IVSChat.LoggingConfiguration,
        IVSChat.Room,
        IVSRealtime.Stage,
        Kafka.ServerlessCluster,
        Kendra.DataSource,
        Kendra.Index,
        Keyspaces.Keyspace,
        Keyspaces.Table,
        Keyspaces.Type,
        KMS.Alias,
        KMS.Key,
        Kinesis.Stream,
        Kinesis.StreamConsumer,
        KinesisAnalyticsV2.Application,
        KinesisAnalyticsV2.ApplicationCloudWatchLoggingOption,
        KinesisAnalyticsV2.ApplicationSnapshot,
        KinesisVideo.SignalingChannel,
        KinesisVideo.Stream,
        LakeFormation.DataCellsFilter,
        LakeFormation.DataLakeSettings,
        LakeFormation.LFTag,
        LakeFormation.LFTagAssociation,
        LakeFormation.LFTagExpression,
        LakeFormation.OptIn,
        LakeFormation.Permissions,
        LakeFormation.Resource,
        Lambda.Alias,
        Lambda.EventSourceMapping,
        Lambda.Function,
        Lambda.LayerVersion,
        Lambda.Version,
        Lambda.MicrovmImage,
        Lambda.NetworkConnector,
        Lambda.Permission,
        Lambda.WebFunction,
        Lambda.WebFunctionEndpoint,
        Lambda.WebFunctionPermission,
        LexV2.Bot,
        LexV2.BotAlias,
        LexV2.BotLocale,
        LexV2.BotVersion,
        LexV2.Intent,
        LexV2.SlotType,
        LicenseManager.LicenseConfiguration,
        Location.ApiKey,
        Location.GeofenceCollection,
        Location.Map,
        Location.PlaceIndex,
        Location.RouteCalculator,
        Location.Tracker,
        Location.TrackerConsumer,
        Logs.Destination,
        Logs.LogGroup,
        Logs.LogStream,
        Logs.MetricFilter,
        Logs.ResourcePolicy,
        Logs.SubscriptionFilter,
        MediaConnect.Flow,
        MediaConvert.Job,
        MediaConvert.JobTemplate,
        MediaConvert.Preset,
        MediaConvert.Queue,
        MediaLive.Channel,
        MediaLive.Input,
        MediaLive.InputSecurityGroup,
        MediaPackageV2.Channel,
        MediaPackageV2.ChannelGroup,
        MediaPackageV2.OriginEndpoint,
        MediaTailor.PlaybackConfiguration,
        MedicalImaging.Datastore,
        MQ.Broker,
        MQ.Configuration,
        MWAA.Environment,
        MWAAServerless.Workflow,
        Macie2.Session,
        Macie2.ClassificationJob,
        Macie2.AllowList,
        Macie2.CustomDataIdentifier,
        Macie2.FindingsFilter,
        MailManager.AddonInstance,
        MailManager.AddonSubscription,
        MailManager.AddressList,
        MailManager.Archive,
        MailManager.IngressPoint,
        MailManager.Relay,
        MailManager.RuleSet,
        MailManager.TrafficPolicy,
        MemoryDB.ACL,
        MemoryDB.Cluster,
        MemoryDB.ParameterGroup,
        MemoryDB.SubnetGroup,
        MemoryDB.User,
        Neptune.DBCluster,
        Neptune.DBClusterParameterGroup,
        Neptune.DBInstance,
        Neptune.DBParameterGroup,
        Neptune.DBSubnetGroup,
        NeptuneGraph.Graph,
        NetworkFirewall.Firewall,
        NetworkFirewall.FirewallPolicy,
        NetworkFirewall.LoggingConfiguration,
        NetworkFirewall.RuleGroup,
        Notifications.ChannelAssociation,
        Notifications.EventRule,
        Notifications.NotificationConfiguration,
        Notifications.NotificationHub,
        NotificationsContacts.EmailContact,
        OAM.Link,
        OAM.Sink,
        ObservabilityAdmin.TelemetryConfig,
        ObservabilityAdmin.TelemetryRule,
        Omics.AnnotationStore,
        Omics.ReferenceStore,
        Omics.RunGroup,
        Omics.SequenceStore,
        Omics.VariantStore,
        Omics.Workflow,
        OpenSearch.Domain,
        OSIS.Pipeline,
        OSIS.PipelineEndpoint,
        OSIS.ResourcePolicy,
        OpenSearchServerless.AccessPolicy,
        OpenSearchServerless.Collection,
        OpenSearchServerless.CollectionGroup,
        OpenSearchServerless.LifecyclePolicy,
        OpenSearchServerless.SecurityConfig,
        OpenSearchServerless.SecurityPolicy,
        OpenSearchServerless.VpcEndpoint,
        Organizations.Account,
        Organizations.DelegatedAdministrator,
        Organizations.Organization,
        Organizations.OrganizationalUnit,
        Organizations.OrganizationResourcePolicy,
        Organizations.Policy,
        Organizations.PolicyAttachment,
        Organizations.Root,
        Organizations.RootPolicyType,
        Organizations.TrustedServiceAccess,
        PaymentCryptography.Alias,
        PaymentCryptography.Key,
        Personalize.Dataset,
        Personalize.DatasetGroup,
        Personalize.EventTracker,
        Personalize.Schema,
        PinpointSMSVoiceV2.ConfigurationSet,
        PinpointSMSVoiceV2.EventDestination,
        PinpointSMSVoiceV2.OptOutList,
        PinpointSMSVoiceV2.PhoneNumber,
        Pipes.Pipe,
        Polly.Lexicon,
        QApps.QApp,
        QBusiness.Application,
        QBusiness.DataSource,
        QBusiness.Index,
        QBusiness.Retriever,
        QBusiness.WebExperience,
        QuickSight.Analysis,
        QuickSight.Dashboard,
        QuickSight.DataSet,
        QuickSight.DataSource,
        RAM.Permission,
        RAM.ResourceShare,
        RDS.DBCluster,
        RDS.DBClusterEndpoint,
        RDS.DBClusterParameterGroup,
        RDS.DBInstance,
        RDS.DBParameterGroup,
        RDS.DBProxy,
        RDS.DBProxyEndpoint,
        RDS.DBProxyTargetGroup,
        RDS.DBSubnetGroup,
        Rbin.Rule,
        RePostSpace.Space,
        Redshift.Cluster,
        Redshift.ClusterParameterGroup,
        Redshift.ClusterSubnetGroup,
        Redshift.EventSubscription,
        RedshiftServerless.Namespace,
        RedshiftServerless.Workgroup,
        ResourceExplorer.Index,
        ResourceExplorer.View,
        ResourceGroups.Group,
        RolesAnywhere.Crl,
        RolesAnywhere.Profile,
        RolesAnywhere.TrustAnchor,
        Route53.HealthCheck,
        Route53.HostedZone,
        Route53.QueryLoggingConfig,
        Route53.Record,
        Route53.RecordList,
        Route53.Records,
        Route53.VpcAssociationAuthorization,
        Route53.ZoneVpcAssociation,
        Route53Profiles.Profile,
        Route53Profiles.ProfileAssociation,
        Route53Profiles.ProfileResourceAssociation,
        Route53Resolver.ResolverEndpoint,
        Route53Resolver.ResolverRule,
        Route53Resolver.ResolverRuleAssociation,
        RUM.AppMonitor,
        RUM.MetricsDestination,
        RUM.ResourcePolicy,
        S3.Bucket,
        S3Control.AccessPoint,
        S3Control.AccessPointPolicy,
        S3Control.MultiRegionAccessPoint,
        S3Control.ObjectLambdaAccessPoint,
        S3Control.StorageLensConfiguration,
        S3Files.AccessPoint,
        S3Files.FileSystem,
        S3Tables.TableBucket,
        S3Tables.Namespace,
        S3Tables.Table,
        S3Vectors.VectorBucket,
        S3Vectors.Index,
        SageMaker.Model,
        SageMaker.EndpointConfig,
        SageMaker.Endpoint,
        SageMaker.FeatureGroup,
        SageMaker.Cluster,
        SageMaker.ClusterSchedulerConfig,
        SageMaker.ComputeQuota,
        Scheduler.Schedule,
        Scheduler.ScheduleGroup,
        Schemas.Discoverer,
        Schemas.Registry,
        Schemas.Schema,
        SecurityHub.ActionTarget,
        SecurityHub.AutomationRule,
        SecurityHub.FindingAggregator,
        SecurityHub.Hub,
        SecurityHub.Insight,
        SecurityLake.AwsLogSource,
        SecurityLake.CustomLogSource,
        SecurityLake.DataLake,
        SecurityLake.ExceptionSubscription,
        SecurityLake.Subscriber,
        SecurityLake.SubscriberNotification,
        SecretsManager.RotationSchedule,
        SecretsManager.Secret,
        ServiceCatalog.Portfolio,
        ServiceCatalog.PortfolioProductAssociation,
        ServiceCatalog.PrincipalPortfolioAssociation,
        ServiceCatalog.Product,
        ServiceQuotas.ServiceQuotaIncreaseRequest,
        SES.AccountSettings,
        SES.ActiveReceiptRuleSet,
        SES.ConfigurationSet,
        SES.ConfigurationSetEventDestination,
        SES.Contact,
        SES.ContactList,
        SES.CustomVerificationEmailTemplate,
        SES.DedicatedIpPool,
        SES.EmailIdentity,
        SES.EmailIdentityPolicy,
        SES.EmailTemplate,
        SES.MultiRegionEndpoint,
        SES.ReceiptFilter,
        SES.ReceiptRule,
        SES.ReceiptRuleSet,
        SES.Tenant,
        SES.TenantResourceAssociation,
        Shield.Protection,
        Shield.ProtectionGroup,
        Shield.Subscription,
        Signer.ProfilePermission,
        Signer.SigningProfile,
        SimpleDB.Domain,
        SNS.PlatformApplication,
        SNS.Subscription,
        SNS.Topic,
        SocialMessaging.LinkedWhatsAppBusinessAccount,
        SQS.Queue,
        SSM.Parameter,
        SSMContacts.Contact,
        SSMContacts.ContactChannel,
        SSMContacts.Plan,
        SSMContacts.Rotation,
        SSMIncidents.ReplicationSet,
        SSMIncidents.ResponsePlan,
        StepFunctions.Activity,
        StepFunctions.StateMachine,
        Synthetics.Canary,
        Synthetics.Group,
        Textract.Adapter,
        Timestream.Database,
        Timestream.DbInstance,
        Timestream.ScheduledQuery,
        Timestream.Table,
        Transfer.Server,
        Transfer.User,
        Translate.ParallelData,
        Translate.Terminology,
        VerifiedPermissions.IdentitySource,
        VerifiedPermissions.Policy,
        VerifiedPermissions.PolicyStore,
        VerifiedPermissions.PolicyStoreAlias,
        VerifiedPermissions.PolicyTemplate,
        VerifiedPermissions.Schema,
        VpcLattice.AccessLogSubscription,
        VpcLattice.AuthPolicy,
        VpcLattice.Listener,
        VpcLattice.ResourcePolicy,
        VpcLattice.Rule,
        VpcLattice.ServiceNetworkServiceAssociation,
        VpcLattice.TargetGroup,
        VpcLattice.Service,
        VpcLattice.ServiceNetwork,
        VpcLattice.ServiceNetworkVpcAssociation,
        WAFv2.IPSet,
        WAFv2.LoggingConfiguration,
        WAFv2.RegexPatternSet,
        WAFv2.RuleGroup,
        WAFv2.WebACL,
        WAFv2.WebACLAssociation,
        Website.AssetDeployment,
        WebsiteServer,
        XRay.Group,
        XRay.ResourcePolicy,
        XRay.SamplingRule,
      ]),
      (collection) =>
        Effect.map(captureAwsEnvironment, (environment) =>
          pinCollectionEnvironment(collection, environment),
        ),
    ),
  ).pipe(
    Layer.provide(
      Layer.mergeAll(
        Layer.mergeAll(
          ACMPCA.CertificateAuthorityProvider(),
          ACMPCA.CertificateAuthorityPolicyProvider(),
          ACMPCA.PermissionProvider(),
          AppFlow.ConnectorProfileProvider(),
          AppFlow.FlowProvider(),
          flociDual(AppIntegrations.Application, () => AppIntegrations.ApplicationProvider()),
          flociDual(AppIntegrations.DataIntegration, () =>
            AppIntegrations.DataIntegrationProvider(),
          ),
          flociDual(AppIntegrations.EventIntegration, () =>
            AppIntegrations.EventIntegrationProvider(),
          ),
          B2BI.CapabilityProvider(),
          B2BI.PartnershipProvider(),
          B2BI.ProfileProvider(),
          B2BI.TransformerProvider(),
          BedrockDataAutomation.BlueprintProvider(),
          BedrockDataAutomation.DataAutomationLibraryProvider(),
          BedrockDataAutomation.DataAutomationProjectProvider(),
          flociDual(Config.AggregationAuthorization, () =>
            Config.AggregationAuthorizationProvider(),
          ),
          flociDual(Config.ConfigRule, () => Config.ConfigRuleProvider()),
          flociDual(Config.ConfigurationRecorder, () => Config.ConfigurationRecorderProvider()),
          flociDual(Config.DeliveryChannel, () => Config.DeliveryChannelProvider()),
          flociDual(Config.RetentionConfiguration, () => Config.RetentionConfigurationProvider()),
        ),
        Layer.mergeAll(
          flociDual(ACM.AccountConfiguration, () => ACM.AccountConfigurationProvider()),
          flociDual(ACM.Certificate, () => ACM.CertificateProvider()),
          flociDual(ACM.CertificateValidation, () => ACM.CertificateValidationProvider()),
          flociDual(AMP.AlertManagerDefinition, () => AMP.AlertManagerDefinitionProvider()),
          flociDual(AMP.AnomalyDetector, () => AMP.AnomalyDetectorProvider()),
          flociDual(AMP.LoggingConfiguration, () => AMP.LoggingConfigurationProvider()),
          flociDual(AMP.QueryLoggingConfiguration, () => AMP.QueryLoggingConfigurationProvider()),
          flociDual(AMP.ResourcePolicy, () => AMP.ResourcePolicyProvider()),
          flociDual(AMP.RuleGroupsNamespace, () => AMP.RuleGroupsNamespaceProvider()),
          flociDual(AMP.Scraper, () => AMP.ScraperProvider()),
          flociDual(AMP.ScraperLoggingConfiguration, () =>
            AMP.ScraperLoggingConfigurationProvider(),
          ),
          flociDual(AMP.Workspace, () => AMP.WorkspaceProvider()),
          flociDual(ApiGateway.Account, () => ApiGateway.AccountProvider()),
          flociDual(ApiGateway.ApiKey, () => ApiGateway.ApiKeyProvider()),
          flociDual(ApiGateway.Authorizer, () => ApiGateway.AuthorizerProvider()),
          flociDual(ApiGateway.BasePathMapping, () => ApiGateway.BasePathMappingProvider()),
          flociDual(ApiGateway.DeploymentResource, () => ApiGateway.DeploymentProvider()),
          flociDual(ApiGateway.DomainName, () => ApiGateway.DomainNameProvider()),
          flociDual(ApiGateway.GatewayResponse, () => ApiGateway.GatewayResponseProvider()),
          flociDual(ApiGateway.MethodResource, () => ApiGateway.MethodProvider()),
          flociDual(ApiGateway.GatewayResource, () => ApiGateway.ResourceProvider()),
          flociDual(ApiGateway.RestApi, () => ApiGateway.RestApiProvider()),
          flociDual(ApiGateway.StageResource, () => ApiGateway.StageProvider()),
          flociDual(ApiGateway.UsagePlan, () => ApiGateway.UsagePlanProvider()),
          flociDual(ApiGateway.UsagePlanKey, () => ApiGateway.UsagePlanKeyProvider()),
          flociDual(ApiGateway.VpcLink, () => ApiGateway.VpcLinkProvider()),
          flociDual(ApiGatewayV2.Api, () => ApiGatewayV2.ApiProvider()),
          flociDual(ApiGatewayV2.ApiMappingResource, () => ApiGatewayV2.ApiMappingProvider()),
          flociDual(ApiGatewayV2.AuthorizerResource, () => ApiGatewayV2.AuthorizerProvider()),
          flociDual(ApiGatewayV2.DomainName, () => ApiGatewayV2.DomainNameProvider()),
          flociDual(ApiGatewayV2.IntegrationResource, () => ApiGatewayV2.IntegrationProvider()),
          flociDual(ApiGatewayV2.RouteResource, () => ApiGatewayV2.RouteProvider()),
          flociDual(ApiGatewayV2.StageResource, () => ApiGatewayV2.StageProvider()),
          flociDual(ApiGatewayV2.VpcLink, () => ApiGatewayV2.VpcLinkProvider()),
          flociDual(AppConfig.Application, () => AppConfig.ApplicationProvider()),
          flociDual(AppConfig.ConfigurationProfile, () => AppConfig.ConfigurationProfileProvider()),
          flociDual(AppConfig.Deployment, () => AppConfig.DeploymentProvider()),
          flociDual(AppConfig.DeploymentStrategy, () => AppConfig.DeploymentStrategyProvider()),
          flociDual(AppConfig.Environment, () => AppConfig.EnvironmentProvider()),
          flociDual(AppConfig.Extension, () => AppConfig.ExtensionProvider()),
          flociDual(AppConfig.ExtensionAssociation, () => AppConfig.ExtensionAssociationProvider()),
          flociDual(AppConfig.HostedConfigurationVersion, () =>
            AppConfig.HostedConfigurationVersionProvider(),
          ),
          flociDual(ApplicationAutoScaling.ScalableTarget, () =>
            ApplicationAutoScaling.ScalableTargetProvider(),
          ),
          flociDual(ApplicationAutoScaling.ScalingPolicy, () =>
            ApplicationAutoScaling.ScalingPolicyProvider(),
          ),
          flociDual(ApplicationAutoScaling.ScheduledAction, () =>
            ApplicationAutoScaling.ScheduledActionProvider(),
          ),
          AppRunner.AutoScalingConfigurationProvider(),
          AppRunner.ObservabilityConfigurationProvider(),
          AppRunner.ServiceProvider(),
          AppRunner.VpcConnectorProvider(),
          flociDual(AppSync.ApiAssociationResource, () => AppSync.ApiAssociationProvider()),
          flociDual(AppSync.ApiKeyResource, () => AppSync.ApiKeyProvider()),
          flociDual(AppSync.DataSourceResource, () => AppSync.DataSourceProvider()),
          flociDual(AppSync.DomainName, () => AppSync.DomainNameProvider()),
          flociDual(AppSync.FunctionResource, () => AppSync.FunctionProvider()),
          flociDual(AppSync.GraphqlApi, () => AppSync.GraphqlApiProvider()),
          flociDual(AppSync.ResolverResource, () => AppSync.ResolverProvider()),
          flociDual(Athena.DataCatalog, () => Athena.DataCatalogProvider()),
          flociDual(Athena.NamedQuery, () => Athena.NamedQueryProvider()),
          flociDual(Athena.PreparedStatement, () => Athena.PreparedStatementProvider()),
          flociDual(Athena.WorkGroup, () => Athena.WorkGroupProvider()),
          flociDual(AutoScaling.AutoScalingGroup, () => AutoScaling.AutoScalingGroupProvider()),
          flociDual(AutoScaling.LaunchTemplate, () => AutoScaling.LaunchTemplateProvider()),
          flociDual(AutoScaling.LifecycleHook, () => AutoScaling.LifecycleHookProvider()),
          flociDual(AutoScaling.ScalingPolicy, () => AutoScaling.ScalingPolicyProvider()),
          flociDual(AutoScaling.ScheduledAction, () => AutoScaling.ScheduledActionProvider()),
          flociDual(Batch.ComputeEnvironment, () => Batch.ComputeEnvironmentProvider()),
          flociDual(Batch.JobDefinition, () => Batch.JobDefinitionProvider()),
          flociDual(Batch.JobQueue, () => Batch.JobQueueProvider()),
          flociDual(CloudControl.Resource, () => CloudControl.CloudControlResourceProvider()),
          flociDual(CloudFormation.Stack, () => CloudFormation.StackProvider()),
          flociDual(CloudFront.CachePolicy, () => CloudFront.CachePolicyProvider()),
          flociDual(CloudFront.Distribution, () => CloudFront.DistributionProvider()),
          flociDual(CloudFront.Function, () => CloudFront.FunctionProvider()),
          flociDual(CloudFront.Invalidation, () => CloudFront.InvalidationProvider()),
          flociDual(CloudFront.KeyGroup, () => CloudFront.KeyGroupProvider()),
          flociDual(CloudFront.KeyValueStore, () => CloudFront.KeyValueStoreProvider()),
          flociDual(CloudFront.KvEntries, () => CloudFront.KvEntriesProvider()),
          flociDual(CloudFront.KvRoutesUpdate, () => CloudFront.KvRoutesUpdateProvider()),
          flociDual(CloudFront.OriginAccessControl, () => CloudFront.OriginAccessControlProvider()),
          flociDual(CloudFront.OriginRequestPolicy, () => CloudFront.OriginRequestPolicyProvider()),
          flociDual(CloudFront.PublicKey, () => CloudFront.PublicKeyProvider()),
          flociDual(CloudFront.RealtimeLogConfig, () => CloudFront.RealtimeLogConfigProvider()),
          flociDual(CloudFront.ResponseHeadersPolicy, () =>
            CloudFront.ResponseHeadersPolicyProvider(),
          ),
          flociDual(CloudFront.VpcOrigin, () => CloudFront.VpcOriginProvider()),
          flociDual(CloudHSMV2.Cluster, () => CloudHSMV2.ClusterProvider()),
          flociDual(CloudHSMV2.Hsm, () => CloudHSMV2.HsmProvider()),
          flociDual(CloudMap.HttpNamespace, () => CloudMap.HttpNamespaceProvider()),
          flociDual(CloudMap.InstanceRegistration, () => CloudMap.InstanceRegistrationProvider()),
          flociDual(CloudMap.PrivateDnsNamespace, () => CloudMap.PrivateDnsNamespaceProvider()),
          flociDual(CloudMap.PublicDnsNamespace, () => CloudMap.PublicDnsNamespaceProvider()),
          flociDual(CloudMap.Service, () => CloudMap.ServiceProvider()),
          flociDual(CloudWatch.AlarmMuteRule, () => CloudWatch.AlarmMuteRuleProvider()),
          flociDual(CloudWatch.Alarm, () => CloudWatch.AlarmProvider()),
          flociDual(CloudWatch.AnomalyDetector, () => CloudWatch.AnomalyDetectorProvider()),
          flociDual(CloudWatch.CompositeAlarm, () => CloudWatch.CompositeAlarmProvider()),
          flociDual(CloudWatch.Dashboard, () => CloudWatch.DashboardProvider()),
          flociDual(CloudWatch.InsightRule, () => CloudWatch.InsightRuleProvider()),
          flociDual(CloudWatch.MetricStream, () => CloudWatch.MetricStreamProvider()),
          flociDual(CodeArtifact.Domain, () => CodeArtifact.DomainProvider()),
          flociDual(CodeArtifact.Repository, () => CodeArtifact.RepositoryProvider()),
          flociDual(CodeBuild.Project, () => CodeBuild.ProjectProvider()),
          flociDual(CodeBuild.ReportGroup, () => CodeBuild.ReportGroupProvider()),
          CodeConnections.ConnectionProvider(),
          CodeConnections.HostProvider(),
          CodeConnections.RepositoryLinkProvider(),
          CodeConnections.SyncConfigurationProvider(),
          flociDual(CodeDeploy.Application, () => CodeDeploy.ApplicationProvider()),
          flociDual(CodeDeploy.DeploymentConfig, () => CodeDeploy.DeploymentConfigProvider()),
          flociDual(CodeDeploy.DeploymentGroup, () => CodeDeploy.DeploymentGroupProvider()),
          flociDual(CodePipeline.Pipeline, () => CodePipeline.PipelineProvider()),
          flociDual(Cognito.Group, () => Cognito.GroupProvider()),
          flociDual(Cognito.IdentityPool, () => Cognito.IdentityPoolProvider()),
          flociDual(Cognito.IdentityPoolRoleAttachment, () =>
            Cognito.IdentityPoolRoleAttachmentProvider(),
          ),
          flociDual(Cognito.IdentityProvider, () => Cognito.IdentityProviderProvider()),
          flociDual(Cognito.ManagedLoginBranding, () => Cognito.ManagedLoginBrandingProvider()),
          flociDual(Cognito.ResourceServer, () => Cognito.ResourceServerProvider()),
          flociDual(Cognito.UserPoolClient, () => Cognito.UserPoolClientProvider()),
          flociDual(Cognito.User, () => Cognito.UserProvider()),
          flociDual(Cognito.UserPoolDomain, () => Cognito.UserPoolDomainProvider()),
          flociDual(Cognito.UserPool, () => Cognito.UserPoolProvider()),
        ),
        Layer.mergeAll(
          DataBrew.DatasetProvider(),
          DataBrew.JobProvider(),
          DataBrew.ProjectProvider(),
          DataBrew.RecipeProvider(),
          DataBrew.RulesetProvider(),
          DataBrew.ScheduleProvider(),
          DataExchange.DataSetProvider(),
          DataExchange.EventActionProvider(),
          DataExchange.RevisionProvider(),
          flociDual(DataSync.LocationEfs, () => DataSync.LocationEfsProvider()),
          flociDual(DataSync.LocationS3, () => DataSync.LocationS3Provider()),
          flociDual(DataSync.Task, () => DataSync.TaskProvider()),
          DataZone.DomainProvider(),
          DataZone.EnvironmentProvider(),
          DataZone.EnvironmentBlueprintConfigurationProvider(),
          DataZone.ProjectProvider(),
          DAX.ClusterProvider(),
          DAX.ParameterGroupProvider(),
          DAX.SubnetGroupProvider(),
          Deadline.BudgetProvider(),
          Deadline.FarmProvider(),
          Deadline.FleetProvider(),
          Deadline.MonitorProvider(),
          Deadline.QueueProvider(),
          Deadline.StorageProfileProvider(),
          DirectoryService.ConditionalForwarderProvider(),
          DirectoryService.DirectoryProvider(),
          DirectoryService.EventTopicProvider(),
          DLM.LifecyclePolicyProvider(),
          flociDual(DocDB.DBCluster, () => DocDB.DBClusterProvider()),
          flociDual(DocDB.DBInstance, () => DocDB.DBInstanceProvider()),
          flociDual(DocDB.DBSubnetGroup, () => DocDB.DBSubnetGroupProvider()),
          DocDBElastic.ClusterProvider(),
          flociDual(DMS.Endpoint, () => DMS.EndpointProvider()),
          flociDual(DMS.ReplicationInstance, () => DMS.ReplicationInstanceProvider()),
          flociDual(DMS.ReplicationSubnetGroup, () => DMS.ReplicationSubnetGroupProvider()),
          DSQL.ClusterProvider(),
          DSQL.ClusterPolicyProvider(),
          DSQL.StreamProvider(),
          DevOpsGuru.EventSourcesConfigProvider(),
          DevOpsGuru.NotificationChannelProvider(),
          DevOpsGuru.ResourceCollectionProvider(),
          DevOpsGuru.ServiceIntegrationProvider(),
          flociDual(DynamoDB.Table, () => DynamoDB.TableProvider()),
          // Keep this service-sized group nested: a flat mergeAll here exceeds
          // Effect's variadic inference limit and silently drops tail layers.
          Layer.mergeAll(
            flociDual(EC2.ClientVpnEndpoint, () => EC2.ClientVpnEndpointProvider()),
            flociDual(EC2.ClientVpnTargetNetworkAssociation, () =>
              EC2.ClientVpnTargetNetworkAssociationProvider(),
            ),
            flociDual(EC2.ClientVpnAuthorizationRule, () =>
              EC2.ClientVpnAuthorizationRuleProvider(),
            ),
            flociDual(EC2.ClientVpnRoute, () => EC2.ClientVpnRouteProvider()),
            flociDual(EC2.DefaultSecurityGroup, () => EC2.DefaultSecurityGroupProvider()),
            flociDual(EC2.DhcpOptions, () => EC2.DhcpOptionsProvider()),
            flociDual(EC2.EgressOnlyInternetGateway, () => EC2.EgressOnlyInternetGatewayProvider()),
            flociDual(EC2.EIP, () => EC2.EIPProvider()),
            flociDual(EC2.FlowLog, () => EC2.FlowLogProvider()),
            flociDual(EC2.Instance, () => EC2.InstanceProvider()),
            // Dual EC2 networking glue: local (floci) ECS services/tasks run
            // inside an emulated VPC — a live VPC can't host local containers
            // and local target groups can't reference a live vpcId.
            flociDual(EC2.InternetGateway, () => EC2.InternetGatewayProvider()),
            flociDual(EC2.KeyPair, () => EC2.KeyPairProvider()),
            flociDual(EC2.NatGateway, () => EC2.NatGatewayProvider()),
            flociDual(EC2.NetworkAclAssociation, () => EC2.NetworkAclAssociationProvider()),
            flociDual(EC2.NetworkAclEntry, () => EC2.NetworkAclEntryProvider()),
            flociDual(EC2.NetworkAcl, () => EC2.NetworkAclProvider()),
            flociDual(EC2.NetworkInterface, () => EC2.NetworkInterfaceProvider()),
            flociDual(EC2.NetworkInterfaceAttachment, () =>
              EC2.NetworkInterfaceAttachmentProvider(),
            ),
            flociDual(EC2.PrefixList, () => EC2.PrefixListProvider()),
            flociDual(EC2.Route, () => EC2.RouteProvider()),
            flociDual(EC2.RouteTableAssociation, () => EC2.RouteTableAssociationProvider()),
            flociDual(EC2.RouteTable, () => EC2.RouteTableProvider()),
            flociDual(EC2.SecurityGroup, () => EC2.SecurityGroupProvider()),
            flociDual(EC2.SecurityGroupRule, () => EC2.SecurityGroupRuleProvider()),
            flociDual(EC2.Snapshot, () => EC2.SnapshotProvider()),
            flociDual(EC2.Subnet, () => EC2.SubnetProvider()),
            flociDual(EC2.Volume, () => EC2.VolumeProvider()),
            flociDual(EC2.VolumeAttachment, () => EC2.VolumeAttachmentProvider()),
            flociDual(EC2.VpcEndpoint, () => EC2.VpcEndpointProvider()),
            flociDual(EC2.VpcPeeringConnection, () => EC2.VpcPeeringConnectionProvider()),
            flociDual(EC2.Vpc, () => EC2.VpcProvider()),
          ),
          flociDual(ECR.Image, () => ECR.ImageProvider()),
          flociDual(ECR.RegistryPolicy, () => ECR.RegistryPolicyProvider()),
          flociDual(ECR.Repository, () => ECR.RepositoryProvider()),
          flociDual(ECS.CapacityProvider, () => ECS.CapacityProviderProvider()),
          flociDual(ECS.Cluster, () => ECS.ClusterProvider()),
          // Dual: live ECS in deploy, floci-emulated (RPC-sidecar-hosted,
          // hot-reloading real containers) in dev — see FlociServiceProvider
          // / FlociTaskProvider.
          // Hand-written floci local providers still live on the floci data
          // plane: declare it so deploy-time binding clients (Action bodies,
          // plan-time `execute`) route to the emulator — and so a binding
          // spanning a `flociDual` sibling (RunTask(cluster, task)) does not
          // see "mixed data planes". Pinned by test/AWS/LocalDataPlane.test.ts.
          ProviderLayer.dual(ECS.Service, {
            live: () => ECS.ServiceProvider(),
            local: () => ECS.FlociServiceProvider(),
            dataPlane: flociServices,
          }),
          flociDual(ECS.TaskDefinition, () => ECS.TaskDefinitionProvider()),
          ProviderLayer.dual(ECS.Task, {
            live: () => ECS.TaskProvider(),
            local: () => ECS.FlociTaskProvider(),
            dataPlane: flociServices,
          }),
          flociDual(EFS.AccessPoint, () => EFS.AccessPointProvider()),
          flociDual(EFS.FileSystem, () => EFS.FileSystemProvider()),
          flociDual(EFS.MountTarget, () => EFS.MountTargetProvider()),
          flociDual(EKS.AccessEntry, () => EKS.AccessEntryProvider()),
          flociDual(EKS.Addon, () => EKS.AddonProvider()),
          flociDual(EKS.Cluster, () => EKS.ClusterProvider()),
          flociDual(EKS.FargateProfile, () => EKS.FargateProfileProvider()),
          flociDual(EKS.Nodegroup, () => EKS.NodegroupProvider()),
          flociDual(EKS.PodIdentityAssociation, () => EKS.PodIdentityAssociationProvider()),
          flociDual(ElastiCache.CacheCluster, () => ElastiCache.CacheClusterProvider()),
          flociDual(ElastiCache.ReplicationGroup, () => ElastiCache.ReplicationGroupProvider()),
          flociDual(ElastiCache.ServerlessCache, () => ElastiCache.ServerlessCacheProvider()),
          flociDual(ElastiCache.SubnetGroup, () => ElastiCache.SubnetGroupProvider()),
          // Dual ELBv2: floci emulates ALBs with locally-resolvable DNS
          // (`*.elb.localhost.floci.io` → 127.0.0.1, host-routed on the
          // gateway port) so local ECS services are reachable behind a
          // local load balancer in dev.
          flociDual(ELBv2.Listener, () => ELBv2.ListenerProvider()),
          flociDual(ELBv2.ListenerCertificate, () => ELBv2.ListenerCertificateProvider()),
          flociDual(ELBv2.ListenerRule, () => ELBv2.ListenerRuleProvider()),
          flociDual(ELBv2.LoadBalancer, () => ELBv2.LoadBalancerProvider()),
          flociDual(ELBv2.TargetGroup, () => ELBv2.TargetGroupProvider()),
          flociDual(ELBv2.TargetGroupAttachment, () => ELBv2.TargetGroupAttachmentProvider()),
          flociDual(ELBv2.TrustStore, () => ELBv2.TrustStoreProvider()),
          flociDual(EventBridge.ApiDestination, () => EventBridge.ApiDestinationProvider()),
          flociDual(EventBridge.Archive, () => EventBridge.ArchiveProvider()),
          flociDual(EventBridge.Connection, () => EventBridge.ConnectionProvider()),
          EventBridge.EndpointProvider(),
          flociDual(EventBridge.EventBus, () => EventBridge.EventBusProvider()),
          // Dual like EventBus/Rule: a live PutPermission against a
          // floci-emulated bus would fail with ResourceNotFoundException.
          flociDual(EventBridge.Permission, () => EventBridge.PermissionProvider()),
          flociDual(EventBridge.Rule, () => EventBridge.RuleProvider()),
          flociDual(FIS.ExperimentTemplate, () => FIS.ExperimentTemplateProvider()),
          flociDual(FIS.TargetAccountConfiguration, () => FIS.TargetAccountConfigurationProvider()),
          flociDual(Firehose.DeliveryStream, () => Firehose.DeliveryStreamProvider()),
          FSx.FileSystemProvider(),
          Glacier.VaultProvider(),
          flociDual(Glue.Connection, () => Glue.ConnectionProvider()),
          flociDual(Glue.Crawler, () => Glue.CrawlerProvider()),
          flociDual(Glue.Database, () => Glue.DatabaseProvider()),
          flociDual(Glue.Job, () => Glue.JobProvider()),
          flociDual(Glue.Table, () => Glue.TableProvider()),
          Grafana.WorkspaceProvider(),
          GreengrassV2.ComponentVersionProvider(),
          GreengrassV2.DeploymentProvider(),
          HealthLake.FHIRDatastoreProvider(),
          flociDual(IAM.AccessKey, () => IAM.AccessKeyProvider()),
          flociDual(IAM.AccountAlias, () => IAM.AccountAliasProvider()),
          flociDual(IAM.AccountPasswordPolicy, () => IAM.AccountPasswordPolicyProvider()),
          flociDual(IAM.GroupMembership, () => IAM.GroupMembershipProvider()),
          flociDual(IAM.Group, () => IAM.GroupProvider()),
          flociDual(IAM.InstanceProfile, () => IAM.InstanceProfileProvider()),
          flociDual(IAM.LoginProfile, () => IAM.LoginProfileProvider()),
          flociDual(IAM.OpenIDConnectProvider, () => IAM.OpenIDConnectProviderProvider()),
          flociDual(IAM.Policy, () => IAM.PolicyProvider()),
          flociDual(IAM.Role, () => IAM.RoleProvider()),
          flociDual(IAM.SAMLProvider, () => IAM.SAMLProviderProvider()),
          flociDual(IAM.ServerCertificate, () => IAM.ServerCertificateProvider()),
          flociDual(IAM.ServiceLinkedRole, () => IAM.ServiceLinkedRoleProvider()),
          flociDual(IAM.ServiceSpecificCredential, () => IAM.ServiceSpecificCredentialProvider()),
          flociDual(IAM.SigningCertificate, () => IAM.SigningCertificateProvider()),
          flociDual(IAM.SSHPublicKey, () => IAM.SSHPublicKeyProvider()),
          flociDual(IAM.User, () => IAM.UserProvider()),
          flociDual(IAM.VirtualMFADevice, () => IAM.VirtualMFADeviceProvider()),
        ),
        Layer.mergeAll(
          flociDual(IdentityCenter.AccountAssignment, () =>
            IdentityCenter.AccountAssignmentProvider(),
          ),
          flociDual(IdentityCenter.Group, () => IdentityCenter.GroupProvider()),
          flociDual(IdentityCenter.Instance, () => IdentityCenter.InstanceProvider()),
          flociDual(IdentityCenter.PermissionSet, () => IdentityCenter.PermissionSetProvider()),
          flociDual(Kafka.ServerlessCluster, () => Kafka.ServerlessClusterProvider()),
          Kendra.DataSourceProvider(),
          Kendra.IndexProvider(),
          Keyspaces.KeyspaceProvider(),
          Keyspaces.TableProvider(),
          Keyspaces.TypeProvider(),
          flociDual(KMS.Alias, () => KMS.AliasProvider()),
          flociDual(KMS.Key, () => KMS.KeyProvider()),
          flociDual(Kinesis.StreamConsumer, () => Kinesis.StreamConsumerProvider()),
          flociDual(Kinesis.Stream, () => Kinesis.StreamProvider()),
          flociDual(KinesisAnalyticsV2.Application, () => KinesisAnalyticsV2.ApplicationProvider()),
          flociDual(KinesisAnalyticsV2.ApplicationCloudWatchLoggingOption, () =>
            KinesisAnalyticsV2.ApplicationCloudWatchLoggingOptionProvider(),
          ),
          flociDual(KinesisAnalyticsV2.ApplicationSnapshot, () =>
            KinesisAnalyticsV2.ApplicationSnapshotProvider(),
          ),
          KinesisVideo.SignalingChannelProvider(),
          KinesisVideo.StreamProvider(),
          flociDual(LakeFormation.DataCellsFilter, () => LakeFormation.DataCellsFilterProvider()),
          flociDual(LakeFormation.DataLakeSettings, () => LakeFormation.DataLakeSettingsProvider()),
          flociDual(LakeFormation.LFTag, () => LakeFormation.LFTagProvider()),
          flociDual(LakeFormation.LFTagAssociation, () => LakeFormation.LFTagAssociationProvider()),
          flociDual(LakeFormation.LFTagExpression, () => LakeFormation.LFTagExpressionProvider()),
          flociDual(LakeFormation.OptIn, () => LakeFormation.OptInProvider()),
          flociDual(LakeFormation.Permissions, () => LakeFormation.PermissionsProvider()),
          flociDual(LakeFormation.Resource, () => LakeFormation.ResourceProvider()),
          flociDual(Lambda.Alias, () => Lambda.AliasProvider()),
          // Requires the alchemy floci fork ≥ 1.6.0-alchemy.2: the
          // reconciler's ownership scan calls lambda ListTags on
          // `event-source-mapping:` ARNs, which stock floci 1.6.0 rejects.
          flociDual(Lambda.EventSourceMapping, () => Lambda.EventSourceMappingProvider()),
          // Dual: live Lambda in deploy, floci-emulated (RPC-sidecar-hosted,
          // hot-reloading) Lambda in dev — see FlociFunctionProvider.
          ProviderLayer.dual(Lambda.Function, {
            live: () => Lambda.FunctionProvider(),
            local: () => Lambda.FlociFunctionProvider(),
            dataPlane: flociServices,
          }),
          flociDual(Lambda.LayerVersion, () => Lambda.LayerVersionProvider()),
          flociDual(Lambda.Version, () => Lambda.VersionProvider()),
          // Dual: dev builds the MicroVM image with a plain host-side
          // `docker build` (BuildKit layer cache against the user's real
          // sources) and hands floci a pre-built `docker://` reference —
          // see FlociMicrovmImageProvider.
          ProviderLayer.dual(Lambda.MicrovmImage, {
            live: () => Lambda.MicrovmImageProvider(),
            local: () => Lambda.FlociMicrovmImageProvider(),
            dataPlane: flociServices,
          }),
          flociDual(Lambda.NetworkConnector, () => Lambda.NetworkConnectorProvider()),
          // Dual: glue onto the (dual) Lambda Function — a live addPermission
          // against a floci function ARN fails with ResourceNotFoundException.
          flociDual(Lambda.Permission, () => Lambda.PermissionProvider()),
          // Live-only: floci does not emulate Web Functions, so `alchemy dev`
          // deploys them to AWS like any mode-agnostic provider.
          Lambda.WebFunctionProvider(),
          Lambda.WebFunctionEndpointProvider(),
          Lambda.WebFunctionPermissionProvider(),
          flociDual(Logs.Destination, () => Logs.DestinationProvider()),
          flociDual(Logs.LogGroup, () => Logs.LogGroupProvider()),
          flociDual(Logs.LogStream, () => Logs.LogStreamProvider()),
          flociDual(Logs.MetricFilter, () => Logs.MetricFilterProvider()),
          flociDual(Logs.ResourcePolicy, () => Logs.ResourcePolicyProvider()),
          flociDual(Logs.SubscriptionFilter, () => Logs.SubscriptionFilterProvider()),
          MediaConnect.FlowProvider(),
          MediaConvert.JobProvider(),
          MediaConvert.JobTemplateProvider(),
          MediaConvert.PresetProvider(),
          MediaConvert.QueueProvider(),
          MediaLive.ChannelProvider(),
          MediaLive.InputProvider(),
          MediaLive.InputSecurityGroupProvider(),
          MediaPackageV2.ChannelProvider(),
          MediaPackageV2.ChannelGroupProvider(),
          MediaPackageV2.OriginEndpointProvider(),
          MediaTailor.PlaybackConfigurationProvider(),
          MedicalImaging.DatastoreProvider(),
          flociDual(MQ.Broker, () => MQ.BrokerProvider()),
          flociDual(MQ.Configuration, () => MQ.ConfigurationProvider()),
          MailManager.AddonInstanceProvider(),
          MailManager.AddonSubscriptionProvider(),
          MailManager.AddressListProvider(),
          MailManager.ArchiveProvider(),
          MailManager.IngressPointProvider(),
          MailManager.RelayProvider(),
          MailManager.RuleSetProvider(),
          MailManager.TrafficPolicyProvider(),
          flociDual(MemoryDB.ACL, () => MemoryDB.ACLProvider()),
          flociDual(MemoryDB.Cluster, () => MemoryDB.ClusterProvider()),