connect to an aws service

connect to an aws service

Usage

aws_connect(service)

Arguments

service

character, the name of a service, e.g., "lambda" or "iam". Should be a function exported by `paws` (see `getNamespaceExports("paws")`)

Value

A `paws` client for the service: a list of functions, one per service operation.

Examples

aws_connect("lambda")
#> $add_layer_version_permission
#> function (LayerName, VersionNumber, StatementId, Action, Principal, 
#>     OrganizationId = NULL, RevisionId = NULL) 
#> {
#>     op <- new_operation(name = "AddLayerVersionPermission", http_method = "POST", 
#>         http_path = "/2018-10-31/layers/{LayerName}/versions/{VersionNumber}/policy", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$add_layer_version_permission_input(LayerName = LayerName, 
#>         VersionNumber = VersionNumber, StatementId = StatementId, 
#>         Action = Action, Principal = Principal, OrganizationId = OrganizationId, 
#>         RevisionId = RevisionId)
#>     output <- .lambda$add_layer_version_permission_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fedfec80>
#> <environment: namespace:paws.compute>
#> 
#> $add_permission
#> function (FunctionName, StatementId, Action, Principal, SourceArn = NULL, 
#>     FunctionUrlAuthType = NULL, InvokedViaFunctionUrl = NULL, 
#>     SourceAccount = NULL, EventSourceToken = NULL, Qualifier = NULL, 
#>     RevisionId = NULL, PrincipalOrgID = NULL) 
#> {
#>     op <- new_operation(name = "AddPermission", http_method = "POST", 
#>         http_path = "/2015-03-31/functions/{FunctionName}/policy", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$add_permission_input(FunctionName = FunctionName, 
#>         StatementId = StatementId, Action = Action, Principal = Principal, 
#>         SourceArn = SourceArn, FunctionUrlAuthType = FunctionUrlAuthType, 
#>         InvokedViaFunctionUrl = InvokedViaFunctionUrl, SourceAccount = SourceAccount, 
#>         EventSourceToken = EventSourceToken, Qualifier = Qualifier, 
#>         RevisionId = RevisionId, PrincipalOrgID = PrincipalOrgID)
#>     output <- .lambda$add_permission_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee00a88>
#> <environment: namespace:paws.compute>
#> 
#> $checkpoint_durable_execution
#> function (DurableExecutionArn, CheckpointToken, Updates = NULL, 
#>     ClientToken = NULL) 
#> {
#>     op <- new_operation(name = "CheckpointDurableExecution", 
#>         http_method = "POST", http_path = "/2025-12-01/durable-executions/{DurableExecutionArn}/checkpoint", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$checkpoint_durable_execution_input(DurableExecutionArn = DurableExecutionArn, 
#>         CheckpointToken = CheckpointToken, Updates = Updates, 
#>         ClientToken = ClientToken)
#>     output <- .lambda$checkpoint_durable_execution_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee04a88>
#> <environment: namespace:paws.compute>
#> 
#> $create_alias
#> function (FunctionName, Name, FunctionVersion, Description = NULL, 
#>     RoutingConfig = NULL) 
#> {
#>     op <- new_operation(name = "CreateAlias", http_method = "POST", 
#>         http_path = "/2015-03-31/functions/{FunctionName}/aliases", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$create_alias_input(FunctionName = FunctionName, 
#>         Name = Name, FunctionVersion = FunctionVersion, Description = Description, 
#>         RoutingConfig = RoutingConfig)
#>     output <- .lambda$create_alias_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee07070>
#> <environment: namespace:paws.compute>
#> 
#> $create_capacity_provider
#> function (CapacityProviderName, VpcConfig, PermissionsConfig, 
#>     InstanceRequirements = NULL, CapacityProviderScalingConfig = NULL, 
#>     KmsKeyArn = NULL, Tags = NULL, PropagateTags = NULL, TelemetryConfig = NULL) 
#> {
#>     op <- new_operation(name = "CreateCapacityProvider", http_method = "POST", 
#>         http_path = "/2025-11-30/capacity-providers", host_prefix = "", 
#>         paginator = list(), stream_api = FALSE, http_checksum = NULL)
#>     input <- .lambda$create_capacity_provider_input(CapacityProviderName = CapacityProviderName, 
#>         VpcConfig = VpcConfig, PermissionsConfig = PermissionsConfig, 
#>         InstanceRequirements = InstanceRequirements, CapacityProviderScalingConfig = CapacityProviderScalingConfig, 
#>         KmsKeyArn = KmsKeyArn, Tags = Tags, PropagateTags = PropagateTags, 
#>         TelemetryConfig = TelemetryConfig)
#>     output <- .lambda$create_capacity_provider_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee092a0>
#> <environment: namespace:paws.compute>
#> 
#> $create_code_signing_config
#> function (Description = NULL, AllowedPublishers, CodeSigningPolicies = NULL, 
#>     Tags = NULL) 
#> {
#>     op <- new_operation(name = "CreateCodeSigningConfig", http_method = "POST", 
#>         http_path = "/2020-04-22/code-signing-configs", host_prefix = "", 
#>         paginator = list(), stream_api = FALSE, http_checksum = NULL)
#>     input <- .lambda$create_code_signing_config_input(Description = Description, 
#>         AllowedPublishers = AllowedPublishers, CodeSigningPolicies = CodeSigningPolicies, 
#>         Tags = Tags)
#>     output <- .lambda$create_code_signing_config_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee0b658>
#> <environment: namespace:paws.compute>
#> 
#> $create_event_source_mapping
#> function (EventSourceArn = NULL, FunctionName, Enabled = NULL, 
#>     BatchSize = NULL, FilterCriteria = NULL, KMSKeyArn = NULL, 
#>     MetricsConfig = NULL, LoggingConfig = NULL, ScalingConfig = NULL, 
#>     MaximumBatchingWindowInSeconds = NULL, ParallelizationFactor = NULL, 
#>     StartingPosition = NULL, StartingPositionTimestamp = NULL, 
#>     DestinationConfig = NULL, MaximumRecordAgeInSeconds = NULL, 
#>     BisectBatchOnFunctionError = NULL, MaximumRetryAttempts = NULL, 
#>     Tags = NULL, TumblingWindowInSeconds = NULL, Topics = NULL, 
#>     Queues = NULL, SourceAccessConfigurations = NULL, SelfManagedEventSource = NULL, 
#>     FunctionResponseTypes = NULL, AmazonManagedKafkaEventSourceConfig = NULL, 
#>     SelfManagedKafkaEventSourceConfig = NULL, DocumentDBEventSourceConfig = NULL, 
#>     ProvisionedPollerConfig = NULL) 
#> {
#>     op <- new_operation(name = "CreateEventSourceMapping", http_method = "POST", 
#>         http_path = "/2015-03-31/event-source-mappings", host_prefix = "", 
#>         paginator = list(), stream_api = FALSE, http_checksum = NULL)
#>     input <- .lambda$create_event_source_mapping_input(EventSourceArn = EventSourceArn, 
#>         FunctionName = FunctionName, Enabled = Enabled, BatchSize = BatchSize, 
#>         FilterCriteria = FilterCriteria, KMSKeyArn = KMSKeyArn, 
#>         MetricsConfig = MetricsConfig, LoggingConfig = LoggingConfig, 
#>         ScalingConfig = ScalingConfig, MaximumBatchingWindowInSeconds = MaximumBatchingWindowInSeconds, 
#>         ParallelizationFactor = ParallelizationFactor, StartingPosition = StartingPosition, 
#>         StartingPositionTimestamp = StartingPositionTimestamp, 
#>         DestinationConfig = DestinationConfig, MaximumRecordAgeInSeconds = MaximumRecordAgeInSeconds, 
#>         BisectBatchOnFunctionError = BisectBatchOnFunctionError, 
#>         MaximumRetryAttempts = MaximumRetryAttempts, Tags = Tags, 
#>         TumblingWindowInSeconds = TumblingWindowInSeconds, Topics = Topics, 
#>         Queues = Queues, SourceAccessConfigurations = SourceAccessConfigurations, 
#>         SelfManagedEventSource = SelfManagedEventSource, FunctionResponseTypes = FunctionResponseTypes, 
#>         AmazonManagedKafkaEventSourceConfig = AmazonManagedKafkaEventSourceConfig, 
#>         SelfManagedKafkaEventSourceConfig = SelfManagedKafkaEventSourceConfig, 
#>         DocumentDBEventSourceConfig = DocumentDBEventSourceConfig, 
#>         ProvisionedPollerConfig = ProvisionedPollerConfig)
#>     output <- .lambda$create_event_source_mapping_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee0cd98>
#> <environment: namespace:paws.compute>
#> 
#> $create_function
#> function (FunctionName, Runtime = NULL, Role, Handler = NULL, 
#>     Code, Description = NULL, Timeout = NULL, MemorySize = NULL, 
#>     Publish = NULL, PublishTo = NULL, VpcConfig = NULL, PackageType = NULL, 
#>     DeadLetterConfig = NULL, Environment = NULL, KMSKeyArn = NULL, 
#>     TracingConfig = NULL, Tags = NULL, Layers = NULL, FileSystemConfigs = NULL, 
#>     CodeSigningConfigArn = NULL, ImageConfig = NULL, Architectures = NULL, 
#>     EphemeralStorage = NULL, SnapStart = NULL, LoggingConfig = NULL, 
#>     TenancyConfig = NULL, CapacityProviderConfig = NULL, DurableConfig = NULL) 
#> {
#>     op <- new_operation(name = "CreateFunction", http_method = "POST", 
#>         http_path = "/2015-03-31/functions", host_prefix = "", 
#>         paginator = list(), stream_api = FALSE, http_checksum = NULL)
#>     input <- .lambda$create_function_input(FunctionName = FunctionName, 
#>         Runtime = Runtime, Role = Role, Handler = Handler, Code = Code, 
#>         Description = Description, Timeout = Timeout, MemorySize = MemorySize, 
#>         Publish = Publish, PublishTo = PublishTo, VpcConfig = VpcConfig, 
#>         PackageType = PackageType, DeadLetterConfig = DeadLetterConfig, 
#>         Environment = Environment, KMSKeyArn = KMSKeyArn, TracingConfig = TracingConfig, 
#>         Tags = Tags, Layers = Layers, FileSystemConfigs = FileSystemConfigs, 
#>         CodeSigningConfigArn = CodeSigningConfigArn, ImageConfig = ImageConfig, 
#>         Architectures = Architectures, EphemeralStorage = EphemeralStorage, 
#>         SnapStart = SnapStart, LoggingConfig = LoggingConfig, 
#>         TenancyConfig = TenancyConfig, CapacityProviderConfig = CapacityProviderConfig, 
#>         DurableConfig = DurableConfig)
#>     output <- .lambda$create_function_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee115e8>
#> <environment: namespace:paws.compute>
#> 
#> $create_function_url_config
#> function (FunctionName, Qualifier = NULL, AuthType, Cors = NULL, 
#>     InvokeMode = NULL) 
#> {
#>     op <- new_operation(name = "CreateFunctionUrlConfig", http_method = "POST", 
#>         http_path = "/2021-10-31/functions/{FunctionName}/url", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$create_function_url_config_input(FunctionName = FunctionName, 
#>         Qualifier = Qualifier, AuthType = AuthType, Cors = Cors, 
#>         InvokeMode = InvokeMode)
#>     output <- .lambda$create_function_url_config_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee14ba0>
#> <environment: namespace:paws.compute>
#> 
#> $delete_alias
#> function (FunctionName, Name) 
#> {
#>     op <- new_operation(name = "DeleteAlias", http_method = "DELETE", 
#>         http_path = "/2015-03-31/functions/{FunctionName}/aliases/{Name}", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$delete_alias_input(FunctionName = FunctionName, 
#>         Name = Name)
#>     output <- .lambda$delete_alias_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee17348>
#> <environment: namespace:paws.compute>
#> 
#> $delete_capacity_provider
#> function (CapacityProviderName) 
#> {
#>     op <- new_operation(name = "DeleteCapacityProvider", http_method = "DELETE", 
#>         http_path = "/2025-11-30/capacity-providers/{CapacityProviderName}", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$delete_capacity_provider_input(CapacityProviderName = CapacityProviderName)
#>     output <- .lambda$delete_capacity_provider_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee15ef0>
#> <environment: namespace:paws.compute>
#> 
#> $delete_code_signing_config
#> function (CodeSigningConfigArn) 
#> {
#>     op <- new_operation(name = "DeleteCodeSigningConfig", http_method = "DELETE", 
#>         http_path = "/2020-04-22/code-signing-configs/{CodeSigningConfigArn}", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$delete_code_signing_config_input(CodeSigningConfigArn = CodeSigningConfigArn)
#>     output <- .lambda$delete_code_signing_config_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee18970>
#> <environment: namespace:paws.compute>
#> 
#> $delete_event_source_mapping
#> function (UUID) 
#> {
#>     op <- new_operation(name = "DeleteEventSourceMapping", http_method = "DELETE", 
#>         http_path = "/2015-03-31/event-source-mappings/{UUID}", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$delete_event_source_mapping_input(UUID = UUID)
#>     output <- .lambda$delete_event_source_mapping_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee1b380>
#> <environment: namespace:paws.compute>
#> 
#> $delete_function
#> function (FunctionName, Qualifier = NULL) 
#> {
#>     op <- new_operation(name = "DeleteFunction", http_method = "DELETE", 
#>         http_path = "/2015-03-31/functions/{FunctionName}", host_prefix = "", 
#>         paginator = list(), stream_api = FALSE, http_checksum = NULL)
#>     input <- .lambda$delete_function_input(FunctionName = FunctionName, 
#>         Qualifier = Qualifier)
#>     output <- .lambda$delete_function_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee19f98>
#> <environment: namespace:paws.compute>
#> 
#> $delete_function_code_signing_config
#> function (FunctionName) 
#> {
#>     op <- new_operation(name = "DeleteFunctionCodeSigningConfig", 
#>         http_method = "DELETE", http_path = "/2020-06-30/functions/{FunctionName}/code-signing-config", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$delete_function_code_signing_config_input(FunctionName = FunctionName)
#>     output <- .lambda$delete_function_code_signing_config_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee1c970>
#> <environment: namespace:paws.compute>
#> 
#> $delete_function_concurrency
#> function (FunctionName) 
#> {
#>     op <- new_operation(name = "DeleteFunctionConcurrency", http_method = "DELETE", 
#>         http_path = "/2017-10-31/functions/{FunctionName}/concurrency", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$delete_function_concurrency_input(FunctionName = FunctionName)
#>     output <- .lambda$delete_function_concurrency_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee1f3f0>
#> <environment: namespace:paws.compute>
#> 
#> $delete_function_event_invoke_config
#> function (FunctionName, Qualifier = NULL) 
#> {
#>     op <- new_operation(name = "DeleteFunctionEventInvokeConfig", 
#>         http_method = "DELETE", http_path = "/2019-09-25/functions/{FunctionName}/event-invoke-config", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$delete_function_event_invoke_config_input(FunctionName = FunctionName, 
#>         Qualifier = Qualifier)
#>     output <- .lambda$delete_function_event_invoke_config_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee1e008>
#> <environment: namespace:paws.compute>
#> 
#> $delete_function_url_config
#> function (FunctionName, Qualifier = NULL) 
#> {
#>     op <- new_operation(name = "DeleteFunctionUrlConfig", http_method = "DELETE", 
#>         http_path = "/2021-10-31/functions/{FunctionName}/url", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$delete_function_url_config_input(FunctionName = FunctionName, 
#>         Qualifier = Qualifier)
#>     output <- .lambda$delete_function_url_config_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee228c8>
#> <environment: namespace:paws.compute>
#> 
#> $delete_layer_version
#> function (LayerName, VersionNumber) 
#> {
#>     op <- new_operation(name = "DeleteLayerVersion", http_method = "DELETE", 
#>         http_path = "/2018-10-31/layers/{LayerName}/versions/{VersionNumber}", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$delete_layer_version_input(LayerName = LayerName, 
#>         VersionNumber = VersionNumber)
#>     output <- .lambda$delete_layer_version_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee21438>
#> <environment: namespace:paws.compute>
#> 
#> $delete_provisioned_concurrency_config
#> function (FunctionName, Qualifier) 
#> {
#>     op <- new_operation(name = "DeleteProvisionedConcurrencyConfig", 
#>         http_method = "DELETE", http_path = "/2019-09-30/functions/{FunctionName}/provisioned-concurrency", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$delete_provisioned_concurrency_config_input(FunctionName = FunctionName, 
#>         Qualifier = Qualifier)
#>     output <- .lambda$delete_provisioned_concurrency_config_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee23dd8>
#> <environment: namespace:paws.compute>
#> 
#> $delete_resource_policy
#> function (ResourceArn, RevisionId = NULL) 
#> {
#>     op <- new_operation(name = "DeleteResourcePolicy", http_method = "DELETE", 
#>         http_path = "/2026-07-09/resource-policy/{ResourceArn}", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$delete_resource_policy_input(ResourceArn = ResourceArn, 
#>         RevisionId = RevisionId)
#>     output <- .lambda$delete_resource_policy_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee26708>
#> <environment: namespace:paws.compute>
#> 
#> $get_account_settings
#> function () 
#> {
#>     op <- new_operation(name = "GetAccountSettings", http_method = "GET", 
#>         http_path = "/2016-08-19/account-settings", host_prefix = "", 
#>         paginator = list(), stream_api = FALSE, http_checksum = NULL)
#>     input <- .lambda$get_account_settings_input()
#>     output <- .lambda$get_account_settings_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee252e8>
#> <environment: namespace:paws.compute>
#> 
#> $get_alias
#> function (FunctionName, Name) 
#> {
#>     op <- new_operation(name = "GetAlias", http_method = "GET", 
#>         http_path = "/2015-03-31/functions/{FunctionName}/aliases/{Name}", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$get_alias_input(FunctionName = FunctionName, 
#>         Name = Name)
#>     output <- .lambda$get_alias_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee27dd8>
#> <environment: namespace:paws.compute>
#> 
#> $get_capacity_provider
#> function (CapacityProviderName) 
#> {
#>     op <- new_operation(name = "GetCapacityProvider", http_method = "GET", 
#>         http_path = "/2025-11-30/capacity-providers/{CapacityProviderName}", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$get_capacity_provider_input(CapacityProviderName = CapacityProviderName)
#>     output <- .lambda$get_capacity_provider_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee2a7b0>
#> <environment: namespace:paws.compute>
#> 
#> $get_code_signing_config
#> function (CodeSigningConfigArn) 
#> {
#>     op <- new_operation(name = "GetCodeSigningConfig", http_method = "GET", 
#>         http_path = "/2020-04-22/code-signing-configs/{CodeSigningConfigArn}", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$get_code_signing_config_input(CodeSigningConfigArn = CodeSigningConfigArn)
#>     output <- .lambda$get_code_signing_config_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee29400>
#> <environment: namespace:paws.compute>
#> 
#> $get_durable_execution
#> function (DurableExecutionArn, IncludeExecutionData = NULL) 
#> {
#>     op <- new_operation(name = "GetDurableExecution", http_method = "GET", 
#>         http_path = "/2025-12-01/durable-executions/{DurableExecutionArn}", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$get_durable_execution_input(DurableExecutionArn = DurableExecutionArn, 
#>         IncludeExecutionData = IncludeExecutionData)
#>     output <- .lambda$get_durable_execution_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee2bdd8>
#> <environment: namespace:paws.compute>
#> 
#> $get_durable_execution_history
#> function (DurableExecutionArn, IncludeExecutionData = NULL, MaxItems = NULL, 
#>     Marker = NULL, ReverseOrder = NULL) 
#> {
#>     op <- new_operation(name = "GetDurableExecutionHistory", 
#>         http_method = "GET", http_path = "/2025-12-01/durable-executions/{DurableExecutionArn}/history", 
#>         host_prefix = "", paginator = list(input_token = "Marker", 
#>             output_token = "NextMarker", limit_key = "MaxItems", 
#>             result_key = "Events"), stream_api = FALSE, http_checksum = NULL)
#>     input <- .lambda$get_durable_execution_history_input(DurableExecutionArn = DurableExecutionArn, 
#>         IncludeExecutionData = IncludeExecutionData, MaxItems = MaxItems, 
#>         Marker = Marker, ReverseOrder = ReverseOrder)
#>     output <- .lambda$get_durable_execution_history_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee2e580>
#> <environment: namespace:paws.compute>
#> 
#> $get_durable_execution_state
#> function (DurableExecutionArn, CheckpointToken, Marker = NULL, 
#>     MaxItems = NULL) 
#> {
#>     op <- new_operation(name = "GetDurableExecutionState", http_method = "GET", 
#>         http_path = "/2025-12-01/durable-executions/{DurableExecutionArn}/state", 
#>         host_prefix = "", paginator = list(input_token = "Marker", 
#>             output_token = "NextMarker", limit_key = "MaxItems", 
#>             result_key = "Operations"), stream_api = FALSE, http_checksum = NULL)
#>     input <- .lambda$get_durable_execution_state_input(DurableExecutionArn = DurableExecutionArn, 
#>         CheckpointToken = CheckpointToken, Marker = Marker, MaxItems = MaxItems)
#>     output <- .lambda$get_durable_execution_state_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee30a18>
#> <environment: namespace:paws.compute>
#> 
#> $get_event_source_mapping
#> function (UUID) 
#> {
#>     op <- new_operation(name = "GetEventSourceMapping", http_method = "GET", 
#>         http_path = "/2015-03-31/event-source-mappings/{UUID}", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$get_event_source_mapping_input(UUID = UUID)
#>     output <- .lambda$get_event_source_mapping_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee2f390>
#> <environment: namespace:paws.compute>
#> 
#> $get_function
#> function (FunctionName, Qualifier = NULL) 
#> {
#>     op <- new_operation(name = "GetFunction", http_method = "GET", 
#>         http_path = "/2015-03-31/functions/{FunctionName}", host_prefix = "", 
#>         paginator = list(), stream_api = FALSE, http_checksum = NULL)
#>     input <- .lambda$get_function_input(FunctionName = FunctionName, 
#>         Qualifier = Qualifier)
#>     output <- .lambda$get_function_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee33cf8>
#> <environment: namespace:paws.compute>
#> 
#> $get_function_code_signing_config
#> function (FunctionName) 
#> {
#>     op <- new_operation(name = "GetFunctionCodeSigningConfig", 
#>         http_method = "GET", http_path = "/2020-06-30/functions/{FunctionName}/code-signing-config", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$get_function_code_signing_config_input(FunctionName = FunctionName)
#>     output <- .lambda$get_function_code_signing_config_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee366d0>
#> <environment: namespace:paws.compute>
#> 
#> $get_function_concurrency
#> function (FunctionName) 
#> {
#>     op <- new_operation(name = "GetFunctionConcurrency", http_method = "GET", 
#>         http_path = "/2019-09-30/functions/{FunctionName}/concurrency", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$get_function_concurrency_input(FunctionName = FunctionName)
#>     output <- .lambda$get_function_concurrency_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee35320>
#> <environment: namespace:paws.compute>
#> 
#> $get_function_configuration
#> function (FunctionName, Qualifier = NULL) 
#> {
#>     op <- new_operation(name = "GetFunctionConfiguration", http_method = "GET", 
#>         http_path = "/2015-03-31/functions/{FunctionName}/configuration", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$get_function_configuration_input(FunctionName = FunctionName, 
#>         Qualifier = Qualifier)
#>     output <- .lambda$get_function_configuration_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee37d68>
#> <environment: namespace:paws.compute>
#> 
#> $get_function_event_invoke_config
#> function (FunctionName, Qualifier = NULL) 
#> {
#>     op <- new_operation(name = "GetFunctionEventInvokeConfig", 
#>         http_method = "GET", http_path = "/2019-09-25/functions/{FunctionName}/event-invoke-config", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$get_function_event_invoke_config_input(FunctionName = FunctionName, 
#>         Qualifier = Qualifier)
#>     output <- .lambda$get_function_event_invoke_config_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee3a708>
#> <environment: namespace:paws.compute>
#> 
#> $get_function_recursion_config
#> function (FunctionName) 
#> {
#>     op <- new_operation(name = "GetFunctionRecursionConfig", 
#>         http_method = "GET", http_path = "/2024-08-31/functions/{FunctionName}/recursion-config", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$get_function_recursion_config_input(FunctionName = FunctionName)
#>     output <- .lambda$get_function_recursion_config_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee392b0>
#> <environment: namespace:paws.compute>
#> 
#> $get_function_scaling_config
#> function (FunctionName, Qualifier) 
#> {
#>     op <- new_operation(name = "GetFunctionScalingConfig", http_method = "GET", 
#>         http_path = "/2025-11-30/functions/{FunctionName}/function-scaling-config", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$get_function_scaling_config_input(FunctionName = FunctionName, 
#>         Qualifier = Qualifier)
#>     output <- .lambda$get_function_scaling_config_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee3bcf8>
#> <environment: namespace:paws.compute>
#> 
#> $get_function_url_config
#> function (FunctionName, Qualifier = NULL) 
#> {
#>     op <- new_operation(name = "GetFunctionUrlConfig", http_method = "GET", 
#>         http_path = "/2021-10-31/functions/{FunctionName}/url", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$get_function_url_config_input(FunctionName = FunctionName, 
#>         Qualifier = Qualifier)
#>     output <- .lambda$get_function_url_config_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee3e698>
#> <environment: namespace:paws.compute>
#> 
#> $get_layer_version
#> function (LayerName, VersionNumber) 
#> {
#>     op <- new_operation(name = "GetLayerVersion", http_method = "GET", 
#>         http_path = "/2018-10-31/layers/{LayerName}/versions/{VersionNumber}", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$get_layer_version_input(LayerName = LayerName, 
#>         VersionNumber = VersionNumber)
#>     output <- .lambda$get_layer_version_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee3d208>
#> <environment: namespace:paws.compute>
#> 
#> $get_layer_version_by_arn
#> function (Arn) 
#> {
#>     op <- new_operation(name = "GetLayerVersionByArn", http_method = "GET", 
#>         http_path = "/2018-10-31/layers?find=LayerVersion", host_prefix = "", 
#>         paginator = list(), stream_api = FALSE, http_checksum = NULL)
#>     input <- .lambda$get_layer_version_by_arn_input(Arn = Arn)
#>     output <- .lambda$get_layer_version_by_arn_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee3fb70>
#> <environment: namespace:paws.compute>
#> 
#> $get_layer_version_policy
#> function (LayerName, VersionNumber) 
#> {
#>     op <- new_operation(name = "GetLayerVersionPolicy", http_method = "GET", 
#>         http_path = "/2018-10-31/layers/{LayerName}/versions/{VersionNumber}/policy", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$get_layer_version_policy_input(LayerName = LayerName, 
#>         VersionNumber = VersionNumber)
#>     output <- .lambda$get_layer_version_policy_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee3e788>
#> <environment: namespace:paws.compute>
#> 
#> $get_policy
#> function (FunctionName, Qualifier = NULL) 
#> {
#>     op <- new_operation(name = "GetPolicy", http_method = "GET", 
#>         http_path = "/2015-03-31/functions/{FunctionName}/policy", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$get_policy_input(FunctionName = FunctionName, 
#>         Qualifier = Qualifier)
#>     output <- .lambda$get_policy_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee41128>
#> <environment: namespace:paws.compute>
#> 
#> $get_provisioned_concurrency_config
#> function (FunctionName, Qualifier) 
#> {
#>     op <- new_operation(name = "GetProvisionedConcurrencyConfig", 
#>         http_method = "GET", http_path = "/2019-09-30/functions/{FunctionName}/provisioned-concurrency", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$get_provisioned_concurrency_config_input(FunctionName = FunctionName, 
#>         Qualifier = Qualifier)
#>     output <- .lambda$get_provisioned_concurrency_config_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee459e8>
#> <environment: namespace:paws.compute>
#> 
#> $get_resource_policy
#> function (ResourceArn) 
#> {
#>     op <- new_operation(name = "GetResourcePolicy", http_method = "GET", 
#>         http_path = "/2026-07-09/resource-policy/{ResourceArn}", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$get_resource_policy_input(ResourceArn = ResourceArn)
#>     output <- .lambda$get_resource_policy_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee44590>
#> <environment: namespace:paws.compute>
#> 
#> $get_runtime_management_config
#> function (FunctionName, Qualifier = NULL) 
#> {
#>     op <- new_operation(name = "GetRuntimeManagementConfig", 
#>         http_method = "GET", http_path = "/2021-07-20/functions/{FunctionName}/runtime-management-config", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$get_runtime_management_config_input(FunctionName = FunctionName, 
#>         Qualifier = Qualifier)
#>     output <- .lambda$get_runtime_management_config_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee46fd8>
#> <environment: namespace:paws.compute>
#> 
#> $invoke
#> function (FunctionName, InvocationType = NULL, LogType = NULL, 
#>     ClientContext = NULL, DurableExecutionName = NULL, Payload = NULL, 
#>     Qualifier = NULL, TenantId = NULL) 
#> {
#>     op <- new_operation(name = "Invoke", http_method = "POST", 
#>         http_path = "/2015-03-31/functions/{FunctionName}/invocations", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$invoke_input(FunctionName = FunctionName, 
#>         InvocationType = InvocationType, LogType = LogType, ClientContext = ClientContext, 
#>         DurableExecutionName = DurableExecutionName, Payload = Payload, 
#>         Qualifier = Qualifier, TenantId = TenantId)
#>     output <- .lambda$invoke_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee49588>
#> <environment: namespace:paws.compute>
#> 
#> $invoke_async
#> function (FunctionName, InvokeArgs) 
#> {
#>     op <- new_operation(name = "InvokeAsync", http_method = "POST", 
#>         http_path = "/2014-11-13/functions/{FunctionName}/invoke-async", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$invoke_async_input(FunctionName = FunctionName, 
#>         InvokeArgs = InvokeArgs)
#>     output <- .lambda$invoke_async_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee4bac8>
#> <environment: namespace:paws.compute>
#> 
#> $invoke_with_response_stream
#> function (FunctionName, LogType = NULL, ClientContext = NULL, 
#>     Qualifier = NULL, Payload = NULL, TenantId = NULL, InvocationType = NULL) 
#> {
#>     op <- new_operation(name = "InvokeWithResponseStream", http_method = "POST", 
#>         http_path = "/2021-11-15/functions/{FunctionName}/response-streaming-invocations", 
#>         host_prefix = "", paginator = list(), stream_api = TRUE, 
#>         http_checksum = NULL)
#>     input <- .lambda$invoke_with_response_stream_input(FunctionName = FunctionName, 
#>         LogType = LogType, ClientContext = ClientContext, Qualifier = Qualifier, 
#>         Payload = Payload, TenantId = TenantId, InvocationType = InvocationType)
#>     output <- .lambda$invoke_with_response_stream_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee4a520>
#> <environment: namespace:paws.compute>
#> 
#> $list_aliases
#> function (FunctionName, FunctionVersion = NULL, Marker = NULL, 
#>     MaxItems = NULL) 
#> {
#>     op <- new_operation(name = "ListAliases", http_method = "GET", 
#>         http_path = "/2015-03-31/functions/{FunctionName}/aliases", 
#>         host_prefix = "", paginator = list(input_token = "Marker", 
#>             output_token = "NextMarker", limit_key = "MaxItems", 
#>             result_key = "Aliases"), stream_api = FALSE, http_checksum = NULL)
#>     input <- .lambda$list_aliases_input(FunctionName = FunctionName, 
#>         FunctionVersion = FunctionVersion, Marker = Marker, MaxItems = MaxItems)
#>     output <- .lambda$list_aliases_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee4cb08>
#> <environment: namespace:paws.compute>
#> 
#> $list_capacity_providers
#> function (State = NULL, Marker = NULL, MaxItems = NULL) 
#> {
#>     op <- new_operation(name = "ListCapacityProviders", http_method = "GET", 
#>         http_path = "/2025-11-30/capacity-providers", host_prefix = "", 
#>         paginator = list(input_token = "Marker", output_token = "NextMarker", 
#>             limit_key = "MaxItems", result_key = "CapacityProviders"), 
#>         stream_api = FALSE, http_checksum = NULL)
#>     input <- .lambda$list_capacity_providers_input(State = State, 
#>         Marker = Marker, MaxItems = MaxItems)
#>     output <- .lambda$list_capacity_providers_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee4f1d0>
#> <environment: namespace:paws.compute>
#> 
#> $list_code_signing_configs
#> function (Marker = NULL, MaxItems = NULL) 
#> {
#>     op <- new_operation(name = "ListCodeSigningConfigs", http_method = "GET", 
#>         http_path = "/2020-04-22/code-signing-configs", host_prefix = "", 
#>         paginator = list(input_token = "Marker", limit_key = "MaxItems", 
#>             output_token = "NextMarker", result_key = "CodeSigningConfigs"), 
#>         stream_api = FALSE, http_checksum = NULL)
#>     input <- .lambda$list_code_signing_configs_input(Marker = Marker, 
#>         MaxItems = MaxItems)
#>     output <- .lambda$list_code_signing_configs_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee519e8>
#> <environment: namespace:paws.compute>
#> 
#> $list_durable_executions_by_function
#> function (FunctionName, Qualifier = NULL, DurableExecutionName = NULL, 
#>     Statuses = NULL, StartedAfter = NULL, StartedBefore = NULL, 
#>     ReverseOrder = NULL, Marker = NULL, MaxItems = NULL) 
#> {
#>     op <- new_operation(name = "ListDurableExecutionsByFunction", 
#>         http_method = "GET", http_path = "/2025-12-01/functions/{FunctionName}/durable-executions", 
#>         host_prefix = "", paginator = list(input_token = "Marker", 
#>             output_token = "NextMarker", limit_key = "MaxItems", 
#>             result_key = "DurableExecutions"), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$list_durable_executions_by_function_input(FunctionName = FunctionName, 
#>         Qualifier = Qualifier, DurableExecutionName = DurableExecutionName, 
#>         Statuses = Statuses, StartedAfter = StartedAfter, StartedBefore = StartedBefore, 
#>         ReverseOrder = ReverseOrder, Marker = Marker, MaxItems = MaxItems)
#>     output <- .lambda$list_durable_executions_by_function_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee501a0>
#> <environment: namespace:paws.compute>
#> 
#> $list_event_source_mappings
#> function (EventSourceArn = NULL, FunctionName = NULL, Marker = NULL, 
#>     MaxItems = NULL) 
#> {
#>     op <- new_operation(name = "ListEventSourceMappings", http_method = "GET", 
#>         http_path = "/2015-03-31/event-source-mappings", host_prefix = "", 
#>         paginator = list(input_token = "Marker", output_token = "NextMarker", 
#>             limit_key = "MaxItems", result_key = "EventSourceMappings"), 
#>         stream_api = FALSE, http_checksum = NULL)
#>     input <- .lambda$list_event_source_mappings_input(EventSourceArn = EventSourceArn, 
#>         FunctionName = FunctionName, Marker = Marker, MaxItems = MaxItems)
#>     output <- .lambda$list_event_source_mappings_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee52558>
#> <environment: namespace:paws.compute>
#> 
#> $list_function_event_invoke_configs
#> function (FunctionName, Marker = NULL, MaxItems = NULL) 
#> {
#>     op <- new_operation(name = "ListFunctionEventInvokeConfigs", 
#>         http_method = "GET", http_path = "/2019-09-25/functions/{FunctionName}/event-invoke-config/list", 
#>         host_prefix = "", paginator = list(input_token = "Marker", 
#>             limit_key = "MaxItems", output_token = "NextMarker", 
#>             result_key = "FunctionEventInvokeConfigs"), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$list_function_event_invoke_configs_input(FunctionName = FunctionName, 
#>         Marker = Marker, MaxItems = MaxItems)
#>     output <- .lambda$list_function_event_invoke_configs_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee54c90>
#> <environment: namespace:paws.compute>
#> 
#> $list_function_url_configs
#> function (FunctionName, Marker = NULL, MaxItems = NULL) 
#> {
#>     op <- new_operation(name = "ListFunctionUrlConfigs", http_method = "GET", 
#>         http_path = "/2021-10-31/functions/{FunctionName}/urls", 
#>         host_prefix = "", paginator = list(input_token = "Marker", 
#>             limit_key = "MaxItems", output_token = "NextMarker", 
#>             result_key = "FunctionUrlConfigs"), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$list_function_url_configs_input(FunctionName = FunctionName, 
#>         Marker = Marker, MaxItems = MaxItems)
#>     output <- .lambda$list_function_url_configs_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee59390>
#> <environment: namespace:paws.compute>
#> 
#> $list_function_versions_by_capacity_provider
#> function (CapacityProviderName, Marker = NULL, MaxItems = NULL) 
#> {
#>     op <- new_operation(name = "ListFunctionVersionsByCapacityProvider", 
#>         http_method = "GET", http_path = "/2025-11-30/capacity-providers/{CapacityProviderName}/function-versions", 
#>         host_prefix = "", paginator = list(input_token = "Marker", 
#>             output_token = "NextMarker", limit_key = "MaxItems", 
#>             result_key = "FunctionVersions"), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$list_function_versions_by_capacity_provider_input(CapacityProviderName = CapacityProviderName, 
#>         Marker = Marker, MaxItems = MaxItems)
#>     output <- .lambda$list_function_versions_by_capacity_provider_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee57d40>
#> <environment: namespace:paws.compute>
#> 
#> $list_functions
#> function (MasterRegion = NULL, FunctionVersion = NULL, Marker = NULL, 
#>     MaxItems = NULL) 
#> {
#>     op <- new_operation(name = "ListFunctions", http_method = "GET", 
#>         http_path = "/2015-03-31/functions", host_prefix = "", 
#>         paginator = list(input_token = "Marker", output_token = "NextMarker", 
#>             limit_key = "MaxItems", result_key = "Functions"), 
#>         stream_api = FALSE, http_checksum = NULL)
#>     input <- .lambda$list_functions_input(MasterRegion = MasterRegion, 
#>         FunctionVersion = FunctionVersion, Marker = Marker, MaxItems = MaxItems)
#>     output <- .lambda$list_functions_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee5a478>
#> <environment: namespace:paws.compute>
#> 
#> $list_functions_by_code_signing_config
#> function (CodeSigningConfigArn, Marker = NULL, MaxItems = NULL) 
#> {
#>     op <- new_operation(name = "ListFunctionsByCodeSigningConfig", 
#>         http_method = "GET", http_path = "/2020-04-22/code-signing-configs/{CodeSigningConfigArn}/functions", 
#>         host_prefix = "", paginator = list(input_token = "Marker", 
#>             limit_key = "MaxItems", output_token = "NextMarker", 
#>             result_key = "FunctionArns"), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$list_functions_by_code_signing_config_input(CodeSigningConfigArn = CodeSigningConfigArn, 
#>         Marker = Marker, MaxItems = MaxItems)
#>     output <- .lambda$list_functions_by_code_signing_config_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee5cbb0>
#> <environment: namespace:paws.compute>
#> 
#> $list_layer_versions
#> function (CompatibleArchitecture = NULL, CompatibleRuntime = NULL, 
#>     LayerName, Marker = NULL, MaxItems = NULL) 
#> {
#>     op <- new_operation(name = "ListLayerVersions", http_method = "GET", 
#>         http_path = "/2018-10-31/layers/{LayerName}/versions", 
#>         host_prefix = "", paginator = list(input_token = "Marker", 
#>             limit_key = "MaxItems", output_token = "NextMarker", 
#>             result_key = "LayerVersions"), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$list_layer_versions_input(CompatibleArchitecture = CompatibleArchitecture, 
#>         CompatibleRuntime = CompatibleRuntime, LayerName = LayerName, 
#>         Marker = Marker, MaxItems = MaxItems)
#>     output <- .lambda$list_layer_versions_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee5f240>
#> <environment: namespace:paws.compute>
#> 
#> $list_layers
#> function (CompatibleArchitecture = NULL, CompatibleRuntime = NULL, 
#>     Marker = NULL, MaxItems = NULL) 
#> {
#>     op <- new_operation(name = "ListLayers", http_method = "GET", 
#>         http_path = "/2018-10-31/layers", host_prefix = "", paginator = list(input_token = "Marker", 
#>             limit_key = "MaxItems", output_token = "NextMarker", 
#>             result_key = "Layers"), stream_api = FALSE, http_checksum = NULL)
#>     input <- .lambda$list_layers_input(CompatibleArchitecture = CompatibleArchitecture, 
#>         CompatibleRuntime = CompatibleRuntime, Marker = Marker, 
#>         MaxItems = MaxItems)
#>     output <- .lambda$list_layers_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee5da68>
#> <environment: namespace:paws.compute>
#> 
#> $list_provisioned_concurrency_configs
#> function (FunctionName, Marker = NULL, MaxItems = NULL) 
#> {
#>     op <- new_operation(name = "ListProvisionedConcurrencyConfigs", 
#>         http_method = "GET", http_path = "/2019-09-30/functions/{FunctionName}/provisioned-concurrency?List=ALL", 
#>         host_prefix = "", paginator = list(input_token = "Marker", 
#>             limit_key = "MaxItems", output_token = "NextMarker", 
#>             result_key = "ProvisionedConcurrencyConfigs"), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$list_provisioned_concurrency_configs_input(FunctionName = FunctionName, 
#>         Marker = Marker, MaxItems = MaxItems)
#>     output <- .lambda$list_provisioned_concurrency_configs_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee601a0>
#> <environment: namespace:paws.compute>
#> 
#> $list_tags
#> function (Resource) 
#> {
#>     op <- new_operation(name = "ListTags", http_method = "GET", 
#>         http_path = "/2017-03-31/tags/{Resource}", host_prefix = "", 
#>         paginator = list(), stream_api = FALSE, http_checksum = NULL)
#>     input <- .lambda$list_tags_input(Resource = Resource)
#>     output <- .lambda$list_tags_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee62980>
#> <environment: namespace:paws.compute>
#> 
#> $list_versions_by_function
#> function (FunctionName, Marker = NULL, MaxItems = NULL) 
#> {
#>     op <- new_operation(name = "ListVersionsByFunction", http_method = "GET", 
#>         http_path = "/2015-03-31/functions/{FunctionName}/versions", 
#>         host_prefix = "", paginator = list(input_token = "Marker", 
#>             limit_key = "MaxItems", output_token = "NextMarker", 
#>             result_key = "Versions"), stream_api = FALSE, http_checksum = NULL)
#>     input <- .lambda$list_versions_by_function_input(FunctionName = FunctionName, 
#>         Marker = Marker, MaxItems = MaxItems)
#>     output <- .lambda$list_versions_by_function_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee672b0>
#> <environment: namespace:paws.compute>
#> 
#> $publish_layer_version
#> function (LayerName, Description = NULL, Content, CompatibleArchitectures = NULL, 
#>     CompatibleRuntimes = NULL, LicenseInfo = NULL) 
#> {
#>     op <- new_operation(name = "PublishLayerVersion", http_method = "POST", 
#>         http_path = "/2018-10-31/layers/{LayerName}/versions", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$publish_layer_version_input(LayerName = LayerName, 
#>         Description = Description, Content = Content, CompatibleArchitectures = CompatibleArchitectures, 
#>         CompatibleRuntimes = CompatibleRuntimes, LicenseInfo = LicenseInfo)
#>     output <- .lambda$publish_layer_version_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee659f8>
#> <environment: namespace:paws.compute>
#> 
#> $publish_version
#> function (FunctionName, CodeSha256 = NULL, Description = NULL, 
#>     RevisionId = NULL, PublishTo = NULL) 
#> {
#>     op <- new_operation(name = "PublishVersion", http_method = "POST", 
#>         http_path = "/2015-03-31/functions/{FunctionName}/versions", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$publish_version_input(FunctionName = FunctionName, 
#>         CodeSha256 = CodeSha256, Description = Description, RevisionId = RevisionId, 
#>         PublishTo = PublishTo)
#>     output <- .lambda$publish_version_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee67fe0>
#> <environment: namespace:paws.compute>
#> 
#> $put_function_code_signing_config
#> function (CodeSigningConfigArn, FunctionName) 
#> {
#>     op <- new_operation(name = "PutFunctionCodeSigningConfig", 
#>         http_method = "PUT", http_path = "/2020-06-30/functions/{FunctionName}/code-signing-config", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$put_function_code_signing_config_input(CodeSigningConfigArn = CodeSigningConfigArn, 
#>         FunctionName = FunctionName)
#>     output <- .lambda$put_function_code_signing_config_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee6a788>
#> <environment: namespace:paws.compute>
#> 
#> $put_function_concurrency
#> function (FunctionName, ReservedConcurrentExecutions) 
#> {
#>     op <- new_operation(name = "PutFunctionConcurrency", http_method = "PUT", 
#>         http_path = "/2017-10-31/functions/{FunctionName}/concurrency", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$put_function_concurrency_input(FunctionName = FunctionName, 
#>         ReservedConcurrentExecutions = ReservedConcurrentExecutions)
#>     output <- .lambda$put_function_concurrency_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee6d0b8>
#> <environment: namespace:paws.compute>
#> 
#> $put_function_event_invoke_config
#> function (FunctionName, Qualifier = NULL, MaximumRetryAttempts = NULL, 
#>     MaximumEventAgeInSeconds = NULL, DestinationConfig = NULL) 
#> {
#>     op <- new_operation(name = "PutFunctionEventInvokeConfig", 
#>         http_method = "PUT", http_path = "/2019-09-25/functions/{FunctionName}/event-invoke-config", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$put_function_event_invoke_config_input(FunctionName = FunctionName, 
#>         Qualifier = Qualifier, MaximumRetryAttempts = MaximumRetryAttempts, 
#>         MaximumEventAgeInSeconds = MaximumEventAgeInSeconds, 
#>         DestinationConfig = DestinationConfig)
#>     output <- .lambda$put_function_event_invoke_config_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee6bb10>
#> <environment: namespace:paws.compute>
#> 
#> $put_function_recursion_config
#> function (FunctionName, RecursiveLoop) 
#> {
#>     op <- new_operation(name = "PutFunctionRecursionConfig", 
#>         http_method = "PUT", http_path = "/2024-08-31/functions/{FunctionName}/recursion-config", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$put_function_recursion_config_input(FunctionName = FunctionName, 
#>         RecursiveLoop = RecursiveLoop)
#>     output <- .lambda$put_function_recursion_config_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee6e248>
#> <environment: namespace:paws.compute>
#> 
#> $put_function_scaling_config
#> function (FunctionName, Qualifier, FunctionScalingConfig = NULL) 
#> {
#>     op <- new_operation(name = "PutFunctionScalingConfig", http_method = "PUT", 
#>         http_path = "/2025-11-30/functions/{FunctionName}/function-scaling-config", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$put_function_scaling_config_input(FunctionName = FunctionName, 
#>         Qualifier = Qualifier, FunctionScalingConfig = FunctionScalingConfig)
#>     output <- .lambda$put_function_scaling_config_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee70b40>
#> <environment: namespace:paws.compute>
#> 
#> $put_provisioned_concurrency_config
#> function (FunctionName, Qualifier, ProvisionedConcurrentExecutions) 
#> {
#>     op <- new_operation(name = "PutProvisionedConcurrencyConfig", 
#>         http_method = "PUT", http_path = "/2019-09-30/functions/{FunctionName}/provisioned-concurrency", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$put_provisioned_concurrency_config_input(FunctionName = FunctionName, 
#>         Qualifier = Qualifier, ProvisionedConcurrentExecutions = ProvisionedConcurrentExecutions)
#>     output <- .lambda$put_provisioned_concurrency_config_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee6f560>
#> <environment: namespace:paws.compute>
#> 
#> $put_resource_policy
#> function (ResourceArn, Policy, RevisionId = NULL) 
#> {
#>     op <- new_operation(name = "PutResourcePolicy", http_method = "PUT", 
#>         http_path = "/2026-07-09/resource-policy/{ResourceArn}", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$put_resource_policy_input(ResourceArn = ResourceArn, 
#>         Policy = Policy, RevisionId = RevisionId)
#>     output <- .lambda$put_resource_policy_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee71db0>
#> <environment: namespace:paws.compute>
#> 
#> $put_runtime_management_config
#> function (FunctionName, Qualifier = NULL, UpdateRuntimeOn, RuntimeVersionArn = NULL) 
#> {
#>     op <- new_operation(name = "PutRuntimeManagementConfig", 
#>         http_method = "PUT", http_path = "/2021-07-20/functions/{FunctionName}/runtime-management-config", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$put_runtime_management_config_input(FunctionName = FunctionName, 
#>         Qualifier = Qualifier, UpdateRuntimeOn = UpdateRuntimeOn, 
#>         RuntimeVersionArn = RuntimeVersionArn)
#>     output <- .lambda$put_runtime_management_config_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee74558>
#> <environment: namespace:paws.compute>
#> 
#> $remove_layer_version_permission
#> function (LayerName, VersionNumber, StatementId, RevisionId = NULL) 
#> {
#>     op <- new_operation(name = "RemoveLayerVersionPermission", 
#>         http_method = "DELETE", http_path = "/2018-10-31/layers/{LayerName}/versions/{VersionNumber}/policy/{StatementId}", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$remove_layer_version_permission_input(LayerName = LayerName, 
#>         VersionNumber = VersionNumber, StatementId = StatementId, 
#>         RevisionId = RevisionId)
#>     output <- .lambda$remove_layer_version_permission_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee78c58>
#> <environment: namespace:paws.compute>
#> 
#> $remove_permission
#> function (FunctionName, StatementId, Qualifier = NULL, RevisionId = NULL) 
#> {
#>     op <- new_operation(name = "RemovePermission", http_method = "DELETE", 
#>         http_path = "/2015-03-31/functions/{FunctionName}/policy/{StatementId}", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$remove_permission_input(FunctionName = FunctionName, 
#>         StatementId = StatementId, Qualifier = Qualifier, RevisionId = RevisionId)
#>     output <- .lambda$remove_permission_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee77608>
#> <environment: namespace:paws.compute>
#> 
#> $send_durable_execution_callback_failure
#> function (CallbackId, Error = NULL) 
#> {
#>     op <- new_operation(name = "SendDurableExecutionCallbackFailure", 
#>         http_method = "POST", http_path = "/2025-12-01/durable-execution-callbacks/{CallbackId}/fail", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$send_durable_execution_callback_failure_input(CallbackId = CallbackId, 
#>         Error = Error)
#>     output <- .lambda$send_durable_execution_callback_failure_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee79de8>
#> <environment: namespace:paws.compute>
#> 
#> $send_durable_execution_callback_heartbeat
#> function (CallbackId) 
#> {
#>     op <- new_operation(name = "SendDurableExecutionCallbackHeartbeat", 
#>         http_method = "POST", http_path = "/2025-12-01/durable-execution-callbacks/{CallbackId}/heartbeat", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$send_durable_execution_callback_heartbeat_input(CallbackId = CallbackId)
#>     output <- .lambda$send_durable_execution_callback_heartbeat_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee7c7c0>
#> <environment: namespace:paws.compute>
#> 
#> $send_durable_execution_callback_success
#> function (CallbackId, Result = NULL) 
#> {
#>     op <- new_operation(name = "SendDurableExecutionCallbackSuccess", 
#>         http_method = "POST", http_path = "/2025-12-01/durable-execution-callbacks/{CallbackId}/succeed", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$send_durable_execution_callback_success_input(CallbackId = CallbackId, 
#>         Result = Result)
#>     output <- .lambda$send_durable_execution_callback_success_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee7b368>
#> <environment: namespace:paws.compute>
#> 
#> $stop_durable_execution
#> function (DurableExecutionArn, Error = NULL) 
#> {
#>     op <- new_operation(name = "StopDurableExecution", http_method = "POST", 
#>         http_path = "/2025-12-01/durable-executions/{DurableExecutionArn}/stop", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$stop_durable_execution_input(DurableExecutionArn = DurableExecutionArn, 
#>         Error = Error)
#>     output <- .lambda$stop_durable_execution_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee7dd08>
#> <environment: namespace:paws.compute>
#> 
#> $tag_resource
#> function (Resource, Tags) 
#> {
#>     op <- new_operation(name = "TagResource", http_method = "POST", 
#>         http_path = "/2017-03-31/tags/{Resource}", host_prefix = "", 
#>         paginator = list(), stream_api = FALSE, http_checksum = NULL)
#>     input <- .lambda$tag_resource_input(Resource = Resource, 
#>         Tags = Tags)
#>     output <- .lambda$tag_resource_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee806a8>
#> <environment: namespace:paws.compute>
#> 
#> $untag_resource
#> function (Resource, TagKeys) 
#> {
#>     op <- new_operation(name = "UntagResource", http_method = "DELETE", 
#>         http_path = "/2017-03-31/tags/{Resource}", host_prefix = "", 
#>         paginator = list(), stream_api = FALSE, http_checksum = NULL)
#>     input <- .lambda$untag_resource_input(Resource = Resource, 
#>         TagKeys = TagKeys)
#>     output <- .lambda$untag_resource_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee7f1a8>
#> <environment: namespace:paws.compute>
#> 
#> $update_alias
#> function (FunctionName, Name, FunctionVersion = NULL, Description = NULL, 
#>     RoutingConfig = NULL, RevisionId = NULL) 
#> {
#>     op <- new_operation(name = "UpdateAlias", http_method = "PUT", 
#>         http_path = "/2015-03-31/functions/{FunctionName}/aliases/{Name}", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$update_alias_input(FunctionName = FunctionName, 
#>         Name = Name, FunctionVersion = FunctionVersion, Description = Description, 
#>         RoutingConfig = RoutingConfig, RevisionId = RevisionId)
#>     output <- .lambda$update_alias_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee81a68>
#> <environment: namespace:paws.compute>
#> 
#> $update_capacity_provider
#> function (CapacityProviderName, CapacityProviderScalingConfig = NULL, 
#>     PropagateTags = NULL, TelemetryConfig = NULL) 
#> {
#>     op <- new_operation(name = "UpdateCapacityProvider", http_method = "PUT", 
#>         http_path = "/2025-11-30/capacity-providers/{CapacityProviderName}", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$update_capacity_provider_input(CapacityProviderName = CapacityProviderName, 
#>         CapacityProviderScalingConfig = CapacityProviderScalingConfig, 
#>         PropagateTags = PropagateTags, TelemetryConfig = TelemetryConfig)
#>     output <- .lambda$update_capacity_provider_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee840f8>
#> <environment: namespace:paws.compute>
#> 
#> $update_code_signing_config
#> function (CodeSigningConfigArn, Description = NULL, AllowedPublishers = NULL, 
#>     CodeSigningPolicies = NULL) 
#> {
#>     op <- new_operation(name = "UpdateCodeSigningConfig", http_method = "PUT", 
#>         http_path = "/2020-04-22/code-signing-configs/{CodeSigningConfigArn}", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$update_code_signing_config_input(CodeSigningConfigArn = CodeSigningConfigArn, 
#>         Description = Description, AllowedPublishers = AllowedPublishers, 
#>         CodeSigningPolicies = CodeSigningPolicies)
#>     output <- .lambda$update_code_signing_config_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee82aa8>
#> <environment: namespace:paws.compute>
#> 
#> $update_event_source_mapping
#> function (UUID, FunctionName = NULL, Enabled = NULL, BatchSize = NULL, 
#>     FilterCriteria = NULL, KMSKeyArn = NULL, MetricsConfig = NULL, 
#>     LoggingConfig = NULL, ScalingConfig = NULL, MaximumBatchingWindowInSeconds = NULL, 
#>     ParallelizationFactor = NULL, DestinationConfig = NULL, MaximumRecordAgeInSeconds = NULL, 
#>     BisectBatchOnFunctionError = NULL, MaximumRetryAttempts = NULL, 
#>     TumblingWindowInSeconds = NULL, SourceAccessConfigurations = NULL, 
#>     FunctionResponseTypes = NULL, AmazonManagedKafkaEventSourceConfig = NULL, 
#>     SelfManagedKafkaEventSourceConfig = NULL, DocumentDBEventSourceConfig = NULL, 
#>     ProvisionedPollerConfig = NULL) 
#> {
#>     op <- new_operation(name = "UpdateEventSourceMapping", http_method = "PUT", 
#>         http_path = "/2015-03-31/event-source-mappings/{UUID}", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$update_event_source_mapping_input(UUID = UUID, 
#>         FunctionName = FunctionName, Enabled = Enabled, BatchSize = BatchSize, 
#>         FilterCriteria = FilterCriteria, KMSKeyArn = KMSKeyArn, 
#>         MetricsConfig = MetricsConfig, LoggingConfig = LoggingConfig, 
#>         ScalingConfig = ScalingConfig, MaximumBatchingWindowInSeconds = MaximumBatchingWindowInSeconds, 
#>         ParallelizationFactor = ParallelizationFactor, DestinationConfig = DestinationConfig, 
#>         MaximumRecordAgeInSeconds = MaximumRecordAgeInSeconds, 
#>         BisectBatchOnFunctionError = BisectBatchOnFunctionError, 
#>         MaximumRetryAttempts = MaximumRetryAttempts, TumblingWindowInSeconds = TumblingWindowInSeconds, 
#>         SourceAccessConfigurations = SourceAccessConfigurations, 
#>         FunctionResponseTypes = FunctionResponseTypes, AmazonManagedKafkaEventSourceConfig = AmazonManagedKafkaEventSourceConfig, 
#>         SelfManagedKafkaEventSourceConfig = SelfManagedKafkaEventSourceConfig, 
#>         DocumentDBEventSourceConfig = DocumentDBEventSourceConfig, 
#>         ProvisionedPollerConfig = ProvisionedPollerConfig)
#>     output <- .lambda$update_event_source_mapping_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee86db8>
#> <environment: namespace:paws.compute>
#> 
#> $update_function_code
#> function (FunctionName, ZipFile = NULL, S3Bucket = NULL, S3Key = NULL, 
#>     S3ObjectVersion = NULL, S3ObjectStorageMode = NULL, ImageUri = NULL, 
#>     Architectures = NULL, Publish = NULL, PublishTo = NULL, DryRun = NULL, 
#>     RevisionId = NULL, SourceKMSKeyArn = NULL) 
#> {
#>     op <- new_operation(name = "UpdateFunctionCode", http_method = "PUT", 
#>         http_path = "/2015-03-31/functions/{FunctionName}/code", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$update_function_code_input(FunctionName = FunctionName, 
#>         ZipFile = ZipFile, S3Bucket = S3Bucket, S3Key = S3Key, 
#>         S3ObjectVersion = S3ObjectVersion, S3ObjectStorageMode = S3ObjectStorageMode, 
#>         ImageUri = ImageUri, Architectures = Architectures, Publish = Publish, 
#>         PublishTo = PublishTo, DryRun = DryRun, RevisionId = RevisionId, 
#>         SourceKMSKeyArn = SourceKMSKeyArn)
#>     output <- .lambda$update_function_code_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee8c280>
#> <environment: namespace:paws.compute>
#> 
#> $update_function_configuration
#> function (FunctionName, Role = NULL, Handler = NULL, Description = NULL, 
#>     Timeout = NULL, MemorySize = NULL, VpcConfig = NULL, Environment = NULL, 
#>     Runtime = NULL, DeadLetterConfig = NULL, KMSKeyArn = NULL, 
#>     TracingConfig = NULL, RevisionId = NULL, Layers = NULL, FileSystemConfigs = NULL, 
#>     ImageConfig = NULL, EphemeralStorage = NULL, SnapStart = NULL, 
#>     LoggingConfig = NULL, CapacityProviderConfig = NULL, DurableConfig = NULL) 
#> {
#>     op <- new_operation(name = "UpdateFunctionConfiguration", 
#>         http_method = "PUT", http_path = "/2015-03-31/functions/{FunctionName}/configuration", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$update_function_configuration_input(FunctionName = FunctionName, 
#>         Role = Role, Handler = Handler, Description = Description, 
#>         Timeout = Timeout, MemorySize = MemorySize, VpcConfig = VpcConfig, 
#>         Environment = Environment, Runtime = Runtime, DeadLetterConfig = DeadLetterConfig, 
#>         KMSKeyArn = KMSKeyArn, TracingConfig = TracingConfig, 
#>         RevisionId = RevisionId, Layers = Layers, FileSystemConfigs = FileSystemConfigs, 
#>         ImageConfig = ImageConfig, EphemeralStorage = EphemeralStorage, 
#>         SnapStart = SnapStart, LoggingConfig = LoggingConfig, 
#>         CapacityProviderConfig = CapacityProviderConfig, DurableConfig = DurableConfig)
#>     output <- .lambda$update_function_configuration_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee8e0c0>
#> <environment: namespace:paws.compute>
#> 
#> $update_function_event_invoke_config
#> function (FunctionName, Qualifier = NULL, MaximumRetryAttempts = NULL, 
#>     MaximumEventAgeInSeconds = NULL, DestinationConfig = NULL) 
#> {
#>     op <- new_operation(name = "UpdateFunctionEventInvokeConfig", 
#>         http_method = "POST", http_path = "/2019-09-25/functions/{FunctionName}/event-invoke-config", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$update_function_event_invoke_config_input(FunctionName = FunctionName, 
#>         Qualifier = Qualifier, MaximumRetryAttempts = MaximumRetryAttempts, 
#>         MaximumEventAgeInSeconds = MaximumEventAgeInSeconds, 
#>         DestinationConfig = DestinationConfig)
#>     output <- .lambda$update_function_event_invoke_config_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee8fd40>
#> <environment: namespace:paws.compute>
#> 
#> $update_function_url_config
#> function (FunctionName, Qualifier = NULL, AuthType = NULL, Cors = NULL, 
#>     InvokeMode = NULL) 
#> {
#>     op <- new_operation(name = "UpdateFunctionUrlConfig", http_method = "PUT", 
#>         http_path = "/2021-10-31/functions/{FunctionName}/url", 
#>         host_prefix = "", paginator = list(), stream_api = FALSE, 
#>         http_checksum = NULL)
#>     input <- .lambda$update_function_url_config_input(FunctionName = FunctionName, 
#>         Qualifier = Qualifier, AuthType = AuthType, Cors = Cors, 
#>         InvokeMode = InvokeMode)
#>     output <- .lambda$update_function_url_config_output()
#>     config <- get_config()
#>     svc <- .lambda$service(config, op)
#>     request <- new_request(svc, op, input, output)
#>     response <- send_request(request)
#>     return(response)
#> }
#> <bytecode: 0x5625fee8e610>
#> <environment: namespace:paws.compute>
#> 
#> $.internal
#> $.internal$config
#> $credentials
#> <environment: 0x5625fefb1e98>
#> 
#> $endpoint
#> [1] ""
#> attr(,"tags")
#> attr(,"tags")$type
#> [1] "scalar"
#> 
#> 
#> $endpoint_resolver
#> [1] ""
#> attr(,"tags")
#> attr(,"tags")$type
#> [1] "scalar"
#> 
#> 
#> $enforce_should_retry_check
#> [1] FALSE
#> attr(,"tags")
#> attr(,"tags")$type
#> [1] "scalar"
#> 
#> 
#> $region
#> [1] ""
#> 
#> $disable_ssl
#> [1] FALSE
#> attr(,"tags")
#> attr(,"tags")$type
#> [1] "scalar"
#> 
#> 
#> $close_connection
#> [1] FALSE
#> attr(,"tags")
#> attr(,"tags")$type
#> [1] "scalar"
#> 
#> 
#> $max_retries
#> [1] 3
#> attr(,"tags")
#> attr(,"tags")$type
#> [1] "scalar"
#> 
#> 
#> $connect_timeout
#> [1] 60
#> attr(,"tags")
#> attr(,"tags")$type
#> [1] "scalar"
#> 
#> 
#> $retryer
#> logical(0)
#> attr(,"tags")
#> attr(,"tags")$type
#> [1] "scalar"
#> 
#> 
#> $disable_param_validation
#> [1] FALSE
#> attr(,"tags")
#> attr(,"tags")$type
#> [1] "scalar"
#> 
#> 
#> $disable_compute_checksums
#> [1] FALSE
#> attr(,"tags")
#> attr(,"tags")$type
#> [1] "scalar"
#> 
#> 
#> $request_checksum_calculation
#> [1] "when_supported"
#> attr(,"tags")
#> attr(,"tags")$type
#> [1] "scalar"
#> 
#> 
#> $s3_force_path_style
#> [1] FALSE
#> attr(,"tags")
#> attr(,"tags")$type
#> [1] "scalar"
#> 
#> 
#> $s3_virtual_address
#> [1] FALSE
#> attr(,"tags")
#> attr(,"tags")$type
#> [1] "scalar"
#> 
#> 
#> $s3_disable_100_continue
#> [1] FALSE
#> attr(,"tags")
#> attr(,"tags")$type
#> [1] "scalar"
#> 
#> 
#> $s3_use_accelerate
#> [1] FALSE
#> attr(,"tags")
#> attr(,"tags")$type
#> [1] "scalar"
#> 
#> 
#> $s3_disable_content_md5_validation
#> [1] FALSE
#> attr(,"tags")
#> attr(,"tags")$type
#> [1] "scalar"
#> 
#> 
#> $ec2_metadata_disable_timeout_override
#> [1] FALSE
#> attr(,"tags")
#> attr(,"tags")$type
#> [1] "scalar"
#> 
#> 
#> $use_dual_stack
#> [1] FALSE
#> attr(,"tags")
#> attr(,"tags")$type
#> [1] "scalar"
#> 
#> 
#> $sleep_delay
#> logical(0)
#> attr(,"tags")
#> attr(,"tags")$type
#> [1] "scalar"
#> 
#> 
#> $disable_rest_protocol_uri_cleaning
#> [1] FALSE
#> attr(,"tags")
#> attr(,"tags")$type
#> [1] "scalar"
#> 
#> 
#> $sts_regional_endpoint
#> [1] ""
#> attr(,"tags")
#> attr(,"tags")$type
#> [1] "scalar"
#> 
#> 
#> $signature_version
#> [1] ""
#> attr(,"tags")
#> attr(,"tags")$type
#> [1] "scalar"
#> 
#> 
#> $partition_name
#> [1] ""
#> 
#> attr(,"tags")
#> attr(,"tags")$type
#> [1] "structure"
#> 
#> attr(,"class")
#> [1] "struct"
#> 
#>