diff --git a/.docs.version b/.docs.version index eca0c16b9a..6aebbe5031 100644 --- a/.docs.version +++ b/.docs.version @@ -1 +1 @@ -7f50f4a842f41ac282ea01697add833b174d4838 +209eb2812860ebcaae26946768d8bb066d64a1a8 diff --git a/aws-cloudformation-schema/aws-dms-dataprovider.json b/aws-cloudformation-schema/aws-dms-dataprovider.json index 65a38452ea..8998cbb08c 100644 --- a/aws-cloudformation-schema/aws-dms-dataprovider.json +++ b/aws-cloudformation-schema/aws-dms-dataprovider.json @@ -34,6 +34,18 @@ "DmsSslModeValue" : { "type" : "string", "enum" : [ "none", "require", "verify-ca", "verify-full" ] + }, + "MongoDbSslModeValue" : { + "type" : "string", + "enum" : [ "none", "require", "verify-full" ] + }, + "MongoDbAuthType" : { + "type" : "string", + "enum" : [ "no", "password" ] + }, + "MongoDbAuthMechanism" : { + "type" : "string", + "enum" : [ "default", "mongodb_cr", "scram_sha_1" ] } }, "properties" : { @@ -70,7 +82,7 @@ "Engine" : { "description" : "The property describes a data engine for the data provider.", "type" : "string", - "enum" : [ "postgres", "mysql", "oracle", "sqlserver", "aurora", "aurora_postgresql" ] + "enum" : [ "aurora", "aurora_postgresql", "mysql", "oracle", "postgres", "sqlserver", "redshift", "mariadb", "mongodb", "docdb" ] }, "ExactSettings" : { "description" : "The property describes the exact settings which can be modified", @@ -188,6 +200,103 @@ }, "required" : [ "ServerName", "Port", "SslMode", "DatabaseName" ], "additionalProperties" : false + }, + "RedshiftSettings" : { + "description" : "RedshiftSettings property identifier.", + "type" : "object", + "properties" : { + "ServerName" : { + "type" : "string" + }, + "Port" : { + "type" : "integer" + }, + "DatabaseName" : { + "type" : "string" + } + }, + "required" : [ "ServerName", "Port", "DatabaseName" ], + "additionalProperties" : false + }, + "MariaDbSettings" : { + "description" : "MariaDbSettings property identifier.", + "type" : "object", + "properties" : { + "ServerName" : { + "type" : "string" + }, + "Port" : { + "type" : "integer" + }, + "SslMode" : { + "type" : "object", + "$ref" : "#/definitions/DmsSslModeValue" + }, + "CertificateArn" : { + "type" : "string" + } + }, + "required" : [ "ServerName", "Port", "SslMode" ], + "additionalProperties" : false + }, + "DocDbSettings" : { + "description" : "DocDbSettings property identifier.", + "type" : "object", + "properties" : { + "ServerName" : { + "type" : "string" + }, + "Port" : { + "type" : "integer" + }, + "DatabaseName" : { + "type" : "string" + }, + "SslMode" : { + "type" : "object", + "$ref" : "#/definitions/MongoDbSslModeValue" + }, + "CertificateArn" : { + "type" : "string" + } + }, + "required" : [ "ServerName", "Port", "DatabaseName" ], + "additionalProperties" : false + }, + "MongoDbSettings" : { + "description" : "MongoDbSettings property identifier.", + "type" : "object", + "properties" : { + "ServerName" : { + "type" : "string" + }, + "Port" : { + "type" : "integer" + }, + "DatabaseName" : { + "type" : "string" + }, + "SslMode" : { + "type" : "object", + "$ref" : "#/definitions/MongoDbSslModeValue" + }, + "CertificateArn" : { + "type" : "string" + }, + "AuthType" : { + "type" : "object", + "$ref" : "#/definitions/MongoDbAuthType" + }, + "AuthSource" : { + "type" : "string" + }, + "AuthMechanism" : { + "type" : "object", + "$ref" : "#/definitions/MongoDbAuthMechanism" + } + }, + "required" : [ "ServerName", "Port" ], + "additionalProperties" : false } }, "anyOf" : [ { @@ -198,6 +307,14 @@ "required" : [ "OracleSettings" ] }, { "required" : [ "MicrosoftSqlServerSettings" ] + }, { + "required" : [ "RedshiftSettings" ] + }, { + "required" : [ "DocDbSettings" ] + }, { + "required" : [ "MariaDbSettings" ] + }, { + "required" : [ "MongoDbSettings" ] } ], "additionalProperties" : false }, diff --git a/aws-cloudformation-schema/aws-ssmquicksetup-configurationmanager.json b/aws-cloudformation-schema/aws-ssmquicksetup-configurationmanager.json index 5a21136a30..80d0b586cd 100644 --- a/aws-cloudformation-schema/aws-ssmquicksetup-configurationmanager.json +++ b/aws-cloudformation-schema/aws-ssmquicksetup-configurationmanager.json @@ -92,11 +92,11 @@ "TagsMap" : { "type" : "object", "patternProperties" : { - "^[A-Za-z0-9+=@_\\/:.-]+$" : { + "^[A-Za-z0-9 +=@_\\/:.-]+$" : { "type" : "string", "maxLength" : 256, "minLength" : 1, - "pattern" : "^[A-Za-z0-9+=@_\\/:.-]+$" + "pattern" : "^[A-Za-z0-9 +=@_\\/:.-]+$" } }, "additionalProperties" : false diff --git a/aws-cloudformation-schema/aws-synthetics-canary.json b/aws-cloudformation-schema/aws-synthetics-canary.json index 3b7a99ef78..3a8a10d3c8 100644 --- a/aws-cloudformation-schema/aws-synthetics-canary.json +++ b/aws-cloudformation-schema/aws-synthetics-canary.json @@ -172,6 +172,10 @@ "items" : { "type" : "string" } + }, + "Ipv6AllowedForDualStack" : { + "description" : "Allow outbound IPv6 traffic on VPC canaries that are connected to dual-stack subnets if set to true", + "type" : "boolean" } }, "required" : [ "SubnetIds", "SecurityGroupIds" ] @@ -279,7 +283,7 @@ "permissions" : [ "synthetics:CreateCanary", "synthetics:StartCanary", "synthetics:GetCanary", "synthetics:TagResource", "s3:CreateBucket", "s3:GetObject", "s3:GetObjectVersion", "s3:PutBucketEncryption", "s3:PutEncryptionConfiguration", "s3:GetBucketLocation", "lambda:CreateFunction", "lambda:AddPermission", "lambda:PublishVersion", "lambda:UpdateFunctionCode", "lambda:UpdateFunctionConfiguration", "lambda:GetFunctionConfiguration", "lambda:GetLayerVersionByArn", "lambda:GetLayerVersion", "lambda:PublishLayerVersion", "lambda:TagResource", "ec2:DescribeVpcs", "ec2:DescribeSubnets", "ec2:DescribeSecurityGroups", "iam:PassRole" ] }, "update" : { - "permissions" : [ "synthetics:UpdateCanary", "synthetics:StartCanary", "synthetics:StopCanary", "synthetics:GetCanary", "synthetics:TagResource", "synthetics:UntagResource", "s3:GetObject", "s3:GetObjectVersion", "s3:PutBucketEncryption", "s3:PutEncryptionConfiguration", "s3:GetBucketLocation", "lambda:AddPermission", "lambda:PublishVersion", "lambda:UpdateFunctionCode", "lambda:UpdateFunctionConfiguration", "lambda:GetFunctionConfiguration", "lambda:GetLayerVersionByArn", "lambda:GetLayerVersion", "lambda:PublishLayerVersion", "lambda:ListTags", "lambda:TagResource", "lambda:UntagResource", "iam:PassRole" ] + "permissions" : [ "synthetics:UpdateCanary", "synthetics:StartCanary", "synthetics:StopCanary", "synthetics:GetCanary", "synthetics:TagResource", "synthetics:UntagResource", "s3:GetObject", "s3:GetObjectVersion", "s3:PutBucketEncryption", "s3:PutEncryptionConfiguration", "s3:GetBucketLocation", "lambda:AddPermission", "lambda:PublishVersion", "lambda:UpdateFunctionCode", "lambda:UpdateFunctionConfiguration", "lambda:GetFunctionConfiguration", "lambda:GetLayerVersionByArn", "lambda:GetLayerVersion", "lambda:PublishLayerVersion", "lambda:ListTags", "lambda:TagResource", "lambda:UntagResource", "iam:PassRole", "ec2:DescribeVpcs", "ec2:DescribeSubnets", "ec2:DescribeSecurityGroups" ] }, "read" : { "permissions" : [ "synthetics:GetCanary", "synthetics:DescribeCanaries", "synthetics:ListTagsForResource", "iam:ListRoles", "s3:ListAllMyBuckets", "s3:GetBucketLocation" ] diff --git a/provider/cmd/pulumi-gen-aws-native/supported-types.txt b/provider/cmd/pulumi-gen-aws-native/supported-types.txt index 5538a806f6..727f1ee4c3 100644 --- a/provider/cmd/pulumi-gen-aws-native/supported-types.txt +++ b/provider/cmd/pulumi-gen-aws-native/supported-types.txt @@ -1243,6 +1243,16 @@ MongoDB::Atlas::ThirdPartyIntegration MongoDB::Atlas::Trigger MongoDB::Atlas::X509AuthenticationDatabaseUser MongoDb::Atlas::AwsIamDatabaseUser +NetApp::FSxN::CifsShare +NetApp::FSxN::ClusterPeer +NetApp::FSxN::ExportPolicy +NetApp::FSxN::IGroup +NetApp::FSxN::Lun +NetApp::FSxN::SnapMirror +NetApp::FSxN::Snapshot +NetApp::FSxN::SnapshotPolicy +NetApp::FSxN::SvmPeer +NetApp::FSxN::Volume NewRelic::Agent::Configuration NewRelic::Alert::AlertsPolicy NewRelic::Alert::NrqlConditionStatic diff --git a/provider/cmd/pulumi-resource-aws-native/metadata.json b/provider/cmd/pulumi-resource-aws-native/metadata.json index 52bac0b364..f7fdb7375c 100644 --- a/provider/cmd/pulumi-resource-aws-native/metadata.json +++ b/provider/cmd/pulumi-resource-aws-native/metadata.json @@ -32769,7 +32769,8 @@ "description": "Local secondary indexes to be created on the table. You can create up to five local secondary indexes. Each index is scoped to a given hash key value. The size of each hash key can be up to 10 gigabytes. Each replica in your global table will have the same local secondary index settings." }, "pointInTimeRecoverySpecification": { - "$ref": "#/types/aws-native:dynamodb:GlobalTablePointInTimeRecoverySpecification" + "$ref": "#/types/aws-native:dynamodb:GlobalTablePointInTimeRecoverySpecification", + "description": "Represents the settings used to enable point in time recovery." }, "replicas": { "type": "array", @@ -32847,7 +32848,8 @@ "replaceOnChanges": true }, "pointInTimeRecoverySpecification": { - "$ref": "#/types/aws-native:dynamodb:GlobalTablePointInTimeRecoverySpecification" + "$ref": "#/types/aws-native:dynamodb:GlobalTablePointInTimeRecoverySpecification", + "description": "Represents the settings used to enable point in time recovery." }, "replicas": { "type": "array", @@ -140411,6 +140413,15 @@ "aws-native:dms:DataProviderEngine": { "type": "string" }, + "aws-native:dms:DataProviderMongoDbAuthMechanism": { + "type": "string" + }, + "aws-native:dms:DataProviderMongoDbAuthType": { + "type": "string" + }, + "aws-native:dms:DataProviderMongoDbSslModeValue": { + "type": "string" + }, "aws-native:dms:DataProviderTag": { "type": "object", "properties": { @@ -140558,10 +140569,22 @@ "aws-native:dms:SettingsProperties": { "type": "object", "properties": { + "docDbSettings": { + "$ref": "#/types/aws-native:dms:SettingsPropertiesDocDbSettingsProperties", + "description": "DocDbSettings property identifier." + }, + "mariaDbSettings": { + "$ref": "#/types/aws-native:dms:SettingsPropertiesMariaDbSettingsProperties", + "description": "MariaDbSettings property identifier." + }, "microsoftSqlServerSettings": { "$ref": "#/types/aws-native:dms:SettingsPropertiesMicrosoftSqlServerSettingsProperties", "description": "MicrosoftSqlServerSettings property identifier." }, + "mongoDbSettings": { + "$ref": "#/types/aws-native:dms:SettingsPropertiesMongoDbSettingsProperties", + "description": "MongoDbSettings property identifier." + }, "mySqlSettings": { "$ref": "#/types/aws-native:dms:SettingsPropertiesMySqlSettingsProperties", "description": "MySqlSettings property identifier." @@ -140573,6 +140596,47 @@ "postgreSqlSettings": { "$ref": "#/types/aws-native:dms:SettingsPropertiesPostgreSqlSettingsProperties", "description": "PostgreSqlSettings property identifier." + }, + "redshiftSettings": { + "$ref": "#/types/aws-native:dms:SettingsPropertiesRedshiftSettingsProperties", + "description": "RedshiftSettings property identifier." + } + } + }, + "aws-native:dms:SettingsPropertiesDocDbSettingsProperties": { + "type": "object", + "properties": { + "certificateArn": { + "type": "string" + }, + "databaseName": { + "type": "string" + }, + "port": { + "type": "integer" + }, + "serverName": { + "type": "string" + }, + "sslMode": { + "$ref": "#/types/aws-native:dms:DataProviderMongoDbSslModeValue" + } + } + }, + "aws-native:dms:SettingsPropertiesMariaDbSettingsProperties": { + "type": "object", + "properties": { + "certificateArn": { + "type": "string" + }, + "port": { + "type": "integer" + }, + "serverName": { + "type": "string" + }, + "sslMode": { + "$ref": "#/types/aws-native:dms:DataProviderDmsSslModeValue" } } }, @@ -140596,6 +140660,35 @@ } } }, + "aws-native:dms:SettingsPropertiesMongoDbSettingsProperties": { + "type": "object", + "properties": { + "authMechanism": { + "$ref": "#/types/aws-native:dms:DataProviderMongoDbAuthMechanism" + }, + "authSource": { + "type": "string" + }, + "authType": { + "$ref": "#/types/aws-native:dms:DataProviderMongoDbAuthType" + }, + "certificateArn": { + "type": "string" + }, + "databaseName": { + "type": "string" + }, + "port": { + "type": "integer" + }, + "serverName": { + "type": "string" + }, + "sslMode": { + "$ref": "#/types/aws-native:dms:DataProviderMongoDbSslModeValue" + } + } + }, "aws-native:dms:SettingsPropertiesMySqlSettingsProperties": { "type": "object", "properties": { @@ -140668,6 +140761,20 @@ } } }, + "aws-native:dms:SettingsPropertiesRedshiftSettingsProperties": { + "type": "object", + "properties": { + "databaseName": { + "type": "string" + }, + "port": { + "type": "integer" + }, + "serverName": { + "type": "string" + } + } + }, "aws-native:docdbelastic:ClusterTag": { "type": "object", "properties": { @@ -158399,10 +158506,12 @@ "description": "A Boolean value that indicates whether Online Certificate Status Protocol (OCSP) server certificate check is enabled or not. For more information, see [Configurable endpoints](https://docs.aws.amazon.com//iot/latest/developerguide/iot-custom-endpoints-configurable.html) from the AWS IoT Core Developer Guide." }, "ocspAuthorizedResponderArn": { - "type": "string" + "type": "string", + "description": "The Amazon Resource Name (ARN) for an X.509 certificate stored in ACM. If provided, AWS IoT Core will use this certificate to validate the signature of the received OCSP response. The OCSP responder must sign responses using either this authorized responder certificate or the issuing certificate, depending on whether the ARN is provided or not. The certificate must be in the same account and region as the domain configuration." }, "ocspLambdaArn": { - "type": "string" + "type": "string", + "description": "The Amazon Resource Name (ARN) for a Lambda function that acts as a Request for Comments (RFC) 6960-compliant Online Certificate Status Protocol (OCSP) responder, supporting basic OCSP responses. The Lambda function accepts a base64-encoding of the OCSP request in the Distinguished Encoding Rules (DER) format. The Lambda function's response is also a base64-encoded OCSP response in the DER format. The response size must not exceed 4 kilobytes (KiB). The Lambda function must be in the same account and region as the domain configuration." } }, "irreversibleNames": { @@ -233200,6 +233309,10 @@ "aws-native:synthetics:CanaryVpcConfig": { "type": "object", "properties": { + "ipv6AllowedForDualStack": { + "type": "boolean", + "description": "Allow outbound IPv6 traffic on VPC canaries that are connected to dual-stack subnets if set to true" + }, "securityGroupIds": { "type": "array", "items": { diff --git a/provider/cmd/pulumi-resource-aws-native/schema.json b/provider/cmd/pulumi-resource-aws-native/schema.json index 4bb43f0113..e95dcf2cb1 100644 --- a/provider/cmd/pulumi-resource-aws-native/schema.json +++ b/provider/cmd/pulumi-resource-aws-native/schema.json @@ -43217,8 +43217,12 @@ "type": "string", "enum": [ { - "name": "Postgres", - "value": "postgres" + "name": "Aurora", + "value": "aurora" + }, + { + "name": "AuroraPostgresql", + "value": "aurora_postgresql" }, { "name": "Mysql", @@ -43228,17 +43232,76 @@ "name": "Oracle", "value": "oracle" }, + { + "name": "Postgres", + "value": "postgres" + }, { "name": "Sqlserver", "value": "sqlserver" }, { - "name": "Aurora", - "value": "aurora" + "name": "Redshift", + "value": "redshift" }, { - "name": "AuroraPostgresql", - "value": "aurora_postgresql" + "name": "Mariadb", + "value": "mariadb" + }, + { + "name": "Mongodb", + "value": "mongodb" + }, + { + "name": "Docdb", + "value": "docdb" + } + ] + }, + "aws-native:dms:DataProviderMongoDbAuthMechanism": { + "type": "string", + "enum": [ + { + "name": "Default", + "value": "default" + }, + { + "name": "MongodbCr", + "value": "mongodb_cr" + }, + { + "name": "ScramSha1", + "value": "scram_sha_1" + } + ] + }, + "aws-native:dms:DataProviderMongoDbAuthType": { + "type": "string", + "enum": [ + { + "name": "No", + "value": "no" + }, + { + "name": "Password", + "value": "password" + } + ] + }, + "aws-native:dms:DataProviderMongoDbSslModeValue": { + "type": "string", + "enum": [ + { + "name": "None", + "value": "none" + }, + { + "name": "Require", + "value": "require" + }, + { + "name": "VerifyFull", + "value": "verify-full" } ] }, @@ -43434,10 +43497,22 @@ "aws-native:dms:SettingsProperties": { "description": "The property identifies the exact type of settings for the data provider.", "properties": { + "docDbSettings": { + "$ref": "#/types/aws-native:dms:SettingsPropertiesDocDbSettingsProperties", + "description": "DocDbSettings property identifier." + }, + "mariaDbSettings": { + "$ref": "#/types/aws-native:dms:SettingsPropertiesMariaDbSettingsProperties", + "description": "MariaDbSettings property identifier." + }, "microsoftSqlServerSettings": { "$ref": "#/types/aws-native:dms:SettingsPropertiesMicrosoftSqlServerSettingsProperties", "description": "MicrosoftSqlServerSettings property identifier." }, + "mongoDbSettings": { + "$ref": "#/types/aws-native:dms:SettingsPropertiesMongoDbSettingsProperties", + "description": "MongoDbSettings property identifier." + }, "mySqlSettings": { "$ref": "#/types/aws-native:dms:SettingsPropertiesMySqlSettingsProperties", "description": "MySqlSettings property identifier." @@ -43449,10 +43524,63 @@ "postgreSqlSettings": { "$ref": "#/types/aws-native:dms:SettingsPropertiesPostgreSqlSettingsProperties", "description": "PostgreSqlSettings property identifier." + }, + "redshiftSettings": { + "$ref": "#/types/aws-native:dms:SettingsPropertiesRedshiftSettingsProperties", + "description": "RedshiftSettings property identifier." } }, "type": "object" }, + "aws-native:dms:SettingsPropertiesDocDbSettingsProperties": { + "description": "DocDbSettings property identifier.", + "properties": { + "certificateArn": { + "type": "string" + }, + "databaseName": { + "type": "string" + }, + "port": { + "type": "integer" + }, + "serverName": { + "type": "string" + }, + "sslMode": { + "$ref": "#/types/aws-native:dms:DataProviderMongoDbSslModeValue" + } + }, + "type": "object", + "required": [ + "databaseName", + "port", + "serverName" + ] + }, + "aws-native:dms:SettingsPropertiesMariaDbSettingsProperties": { + "description": "MariaDbSettings property identifier.", + "properties": { + "certificateArn": { + "type": "string" + }, + "port": { + "type": "integer" + }, + "serverName": { + "type": "string" + }, + "sslMode": { + "$ref": "#/types/aws-native:dms:DataProviderDmsSslModeValue" + } + }, + "type": "object", + "required": [ + "port", + "serverName", + "sslMode" + ] + }, "aws-native:dms:SettingsPropertiesMicrosoftSqlServerSettingsProperties": { "description": "MicrosoftSqlServerSettings property identifier.", "properties": { @@ -43480,6 +43608,40 @@ "sslMode" ] }, + "aws-native:dms:SettingsPropertiesMongoDbSettingsProperties": { + "description": "MongoDbSettings property identifier.", + "properties": { + "authMechanism": { + "$ref": "#/types/aws-native:dms:DataProviderMongoDbAuthMechanism" + }, + "authSource": { + "type": "string" + }, + "authType": { + "$ref": "#/types/aws-native:dms:DataProviderMongoDbAuthType" + }, + "certificateArn": { + "type": "string" + }, + "databaseName": { + "type": "string" + }, + "port": { + "type": "integer" + }, + "serverName": { + "type": "string" + }, + "sslMode": { + "$ref": "#/types/aws-native:dms:DataProviderMongoDbSslModeValue" + } + }, + "type": "object", + "required": [ + "port", + "serverName" + ] + }, "aws-native:dms:SettingsPropertiesMySqlSettingsProperties": { "description": "MySqlSettings property identifier.", "properties": { @@ -43572,6 +43734,26 @@ "sslMode" ] }, + "aws-native:dms:SettingsPropertiesRedshiftSettingsProperties": { + "description": "RedshiftSettings property identifier.", + "properties": { + "databaseName": { + "type": "string" + }, + "port": { + "type": "integer" + }, + "serverName": { + "type": "string" + } + }, + "type": "object", + "required": [ + "databaseName", + "port", + "serverName" + ] + }, "aws-native:docdbelastic:ClusterTag": { "properties": { "key": { @@ -68561,10 +68743,12 @@ "description": "A Boolean value that indicates whether Online Certificate Status Protocol (OCSP) server certificate check is enabled or not. For more information, see [Configurable endpoints](https://docs.aws.amazon.com//iot/latest/developerguide/iot-custom-endpoints-configurable.html) from the AWS IoT Core Developer Guide." }, "ocspAuthorizedResponderArn": { - "type": "string" + "type": "string", + "description": "The Amazon Resource Name (ARN) for an X.509 certificate stored in ACM. If provided, AWS IoT Core will use this certificate to validate the signature of the received OCSP response. The OCSP responder must sign responses using either this authorized responder certificate or the issuing certificate, depending on whether the ARN is provided or not. The certificate must be in the same account and region as the domain configuration." }, "ocspLambdaArn": { - "type": "string" + "type": "string", + "description": "The Amazon Resource Name (ARN) for a Lambda function that acts as a Request for Comments (RFC) 6960-compliant Online Certificate Status Protocol (OCSP) responder, supporting basic OCSP responses. The Lambda function accepts a base64-encoding of the OCSP request in the Distinguished Encoding Rules (DER) format. The Lambda function's response is also a base64-encoded OCSP response in the DER format. The response size must not exceed 4 kilobytes (KiB). The Lambda function must be in the same account and region as the domain configuration." } }, "type": "object" @@ -171618,6 +171802,10 @@ }, "aws-native:synthetics:CanaryVpcConfig": { "properties": { + "ipv6AllowedForDualStack": { + "type": "boolean", + "description": "Allow outbound IPv6 traffic on VPC canaries that are connected to dual-stack subnets if set to true" + }, "securityGroupIds": { "type": "array", "items": { @@ -210606,7 +210794,8 @@ "replaceOnChanges": true }, "pointInTimeRecoverySpecification": { - "$ref": "#/types/aws-native:dynamodb:GlobalTablePointInTimeRecoverySpecification" + "$ref": "#/types/aws-native:dynamodb:GlobalTablePointInTimeRecoverySpecification", + "description": "Represents the settings used to enable point in time recovery." }, "replicas": { "type": "array", @@ -210696,7 +210885,8 @@ "description": "Local secondary indexes to be created on the table. You can create up to five local secondary indexes. Each index is scoped to a given hash key value. The size of each hash key can be up to 10 gigabytes. Each replica in your global table will have the same local secondary index settings." }, "pointInTimeRecoverySpecification": { - "$ref": "#/types/aws-native:dynamodb:GlobalTablePointInTimeRecoverySpecification" + "$ref": "#/types/aws-native:dynamodb:GlobalTablePointInTimeRecoverySpecification", + "description": "Represents the settings used to enable point in time recovery." }, "replicas": { "type": "array", @@ -297328,7 +297518,8 @@ "description": "Global secondary indexes to be created on the global table. You can create up to 20 global secondary indexes. Each replica in your global table will have the same global secondary index settings. You can only create or delete one global secondary index in a single stack operation.\n\nSince the backfilling of an index could take a long time, CloudFormation does not wait for the index to become active. If a stack operation rolls back, CloudFormation might not delete an index that has been added. In that case, you will need to delete the index manually." }, "pointInTimeRecoverySpecification": { - "$ref": "#/types/aws-native:dynamodb:GlobalTablePointInTimeRecoverySpecification" + "$ref": "#/types/aws-native:dynamodb:GlobalTablePointInTimeRecoverySpecification", + "description": "Represents the settings used to enable point in time recovery." }, "replicas": { "type": "array", diff --git a/sdk/dotnet/Dms/Enums.cs b/sdk/dotnet/Dms/Enums.cs index a6087e5ecd..6658da84cd 100644 --- a/sdk/dotnet/Dms/Enums.cs +++ b/sdk/dotnet/Dms/Enums.cs @@ -82,12 +82,16 @@ private DataProviderEngine(string value) _value = value ?? throw new ArgumentNullException(nameof(value)); } - public static DataProviderEngine Postgres { get; } = new DataProviderEngine("postgres"); + public static DataProviderEngine Aurora { get; } = new DataProviderEngine("aurora"); + public static DataProviderEngine AuroraPostgresql { get; } = new DataProviderEngine("aurora_postgresql"); public static DataProviderEngine Mysql { get; } = new DataProviderEngine("mysql"); public static DataProviderEngine Oracle { get; } = new DataProviderEngine("oracle"); + public static DataProviderEngine Postgres { get; } = new DataProviderEngine("postgres"); public static DataProviderEngine Sqlserver { get; } = new DataProviderEngine("sqlserver"); - public static DataProviderEngine Aurora { get; } = new DataProviderEngine("aurora"); - public static DataProviderEngine AuroraPostgresql { get; } = new DataProviderEngine("aurora_postgresql"); + public static DataProviderEngine Redshift { get; } = new DataProviderEngine("redshift"); + public static DataProviderEngine Mariadb { get; } = new DataProviderEngine("mariadb"); + public static DataProviderEngine Mongodb { get; } = new DataProviderEngine("mongodb"); + public static DataProviderEngine Docdb { get; } = new DataProviderEngine("docdb"); public static bool operator ==(DataProviderEngine left, DataProviderEngine right) => left.Equals(right); public static bool operator !=(DataProviderEngine left, DataProviderEngine right) => !left.Equals(right); @@ -104,6 +108,92 @@ private DataProviderEngine(string value) public override string ToString() => _value; } + [EnumType] + public readonly struct DataProviderMongoDbAuthMechanism : IEquatable + { + private readonly string _value; + + private DataProviderMongoDbAuthMechanism(string value) + { + _value = value ?? throw new ArgumentNullException(nameof(value)); + } + + public static DataProviderMongoDbAuthMechanism Default { get; } = new DataProviderMongoDbAuthMechanism("default"); + public static DataProviderMongoDbAuthMechanism MongodbCr { get; } = new DataProviderMongoDbAuthMechanism("mongodb_cr"); + public static DataProviderMongoDbAuthMechanism ScramSha1 { get; } = new DataProviderMongoDbAuthMechanism("scram_sha_1"); + + public static bool operator ==(DataProviderMongoDbAuthMechanism left, DataProviderMongoDbAuthMechanism right) => left.Equals(right); + public static bool operator !=(DataProviderMongoDbAuthMechanism left, DataProviderMongoDbAuthMechanism right) => !left.Equals(right); + + public static explicit operator string(DataProviderMongoDbAuthMechanism value) => value._value; + + [EditorBrowsable(EditorBrowsableState.Never)] + public override bool Equals(object? obj) => obj is DataProviderMongoDbAuthMechanism other && Equals(other); + public bool Equals(DataProviderMongoDbAuthMechanism other) => string.Equals(_value, other._value, StringComparison.Ordinal); + + [EditorBrowsable(EditorBrowsableState.Never)] + public override int GetHashCode() => _value?.GetHashCode() ?? 0; + + public override string ToString() => _value; + } + + [EnumType] + public readonly struct DataProviderMongoDbAuthType : IEquatable + { + private readonly string _value; + + private DataProviderMongoDbAuthType(string value) + { + _value = value ?? throw new ArgumentNullException(nameof(value)); + } + + public static DataProviderMongoDbAuthType No { get; } = new DataProviderMongoDbAuthType("no"); + public static DataProviderMongoDbAuthType Password { get; } = new DataProviderMongoDbAuthType("password"); + + public static bool operator ==(DataProviderMongoDbAuthType left, DataProviderMongoDbAuthType right) => left.Equals(right); + public static bool operator !=(DataProviderMongoDbAuthType left, DataProviderMongoDbAuthType right) => !left.Equals(right); + + public static explicit operator string(DataProviderMongoDbAuthType value) => value._value; + + [EditorBrowsable(EditorBrowsableState.Never)] + public override bool Equals(object? obj) => obj is DataProviderMongoDbAuthType other && Equals(other); + public bool Equals(DataProviderMongoDbAuthType other) => string.Equals(_value, other._value, StringComparison.Ordinal); + + [EditorBrowsable(EditorBrowsableState.Never)] + public override int GetHashCode() => _value?.GetHashCode() ?? 0; + + public override string ToString() => _value; + } + + [EnumType] + public readonly struct DataProviderMongoDbSslModeValue : IEquatable + { + private readonly string _value; + + private DataProviderMongoDbSslModeValue(string value) + { + _value = value ?? throw new ArgumentNullException(nameof(value)); + } + + public static DataProviderMongoDbSslModeValue None { get; } = new DataProviderMongoDbSslModeValue("none"); + public static DataProviderMongoDbSslModeValue Require { get; } = new DataProviderMongoDbSslModeValue("require"); + public static DataProviderMongoDbSslModeValue VerifyFull { get; } = new DataProviderMongoDbSslModeValue("verify-full"); + + public static bool operator ==(DataProviderMongoDbSslModeValue left, DataProviderMongoDbSslModeValue right) => left.Equals(right); + public static bool operator !=(DataProviderMongoDbSslModeValue left, DataProviderMongoDbSslModeValue right) => !left.Equals(right); + + public static explicit operator string(DataProviderMongoDbSslModeValue value) => value._value; + + [EditorBrowsable(EditorBrowsableState.Never)] + public override bool Equals(object? obj) => obj is DataProviderMongoDbSslModeValue other && Equals(other); + public bool Equals(DataProviderMongoDbSslModeValue other) => string.Equals(_value, other._value, StringComparison.Ordinal); + + [EditorBrowsable(EditorBrowsableState.Never)] + public override int GetHashCode() => _value?.GetHashCode() ?? 0; + + public override string ToString() => _value; + } + /// /// The property describes a network type for the instance profile. /// diff --git a/sdk/dotnet/Dms/Inputs/SettingsPropertiesArgs.cs b/sdk/dotnet/Dms/Inputs/SettingsPropertiesArgs.cs index 07b2c161ca..93f0927875 100644 --- a/sdk/dotnet/Dms/Inputs/SettingsPropertiesArgs.cs +++ b/sdk/dotnet/Dms/Inputs/SettingsPropertiesArgs.cs @@ -15,12 +15,30 @@ namespace Pulumi.AwsNative.Dms.Inputs /// public sealed class SettingsPropertiesArgs : global::Pulumi.ResourceArgs { + /// + /// DocDbSettings property identifier. + /// + [Input("docDbSettings")] + public Input? DocDbSettings { get; set; } + + /// + /// MariaDbSettings property identifier. + /// + [Input("mariaDbSettings")] + public Input? MariaDbSettings { get; set; } + /// /// MicrosoftSqlServerSettings property identifier. /// [Input("microsoftSqlServerSettings")] public Input? MicrosoftSqlServerSettings { get; set; } + /// + /// MongoDbSettings property identifier. + /// + [Input("mongoDbSettings")] + public Input? MongoDbSettings { get; set; } + /// /// MySqlSettings property identifier. /// @@ -39,6 +57,12 @@ public sealed class SettingsPropertiesArgs : global::Pulumi.ResourceArgs [Input("postgreSqlSettings")] public Input? PostgreSqlSettings { get; set; } + /// + /// RedshiftSettings property identifier. + /// + [Input("redshiftSettings")] + public Input? RedshiftSettings { get; set; } + public SettingsPropertiesArgs() { } diff --git a/sdk/dotnet/Dms/Inputs/SettingsPropertiesDocDbSettingsPropertiesArgs.cs b/sdk/dotnet/Dms/Inputs/SettingsPropertiesDocDbSettingsPropertiesArgs.cs new file mode 100644 index 0000000000..dccdfbd4be --- /dev/null +++ b/sdk/dotnet/Dms/Inputs/SettingsPropertiesDocDbSettingsPropertiesArgs.cs @@ -0,0 +1,38 @@ +// *** WARNING: this file was generated by pulumi. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.AwsNative.Dms.Inputs +{ + + /// + /// DocDbSettings property identifier. + /// + public sealed class SettingsPropertiesDocDbSettingsPropertiesArgs : global::Pulumi.ResourceArgs + { + [Input("certificateArn")] + public Input? CertificateArn { get; set; } + + [Input("databaseName", required: true)] + public Input DatabaseName { get; set; } = null!; + + [Input("port", required: true)] + public Input Port { get; set; } = null!; + + [Input("serverName", required: true)] + public Input ServerName { get; set; } = null!; + + [Input("sslMode")] + public Input? SslMode { get; set; } + + public SettingsPropertiesDocDbSettingsPropertiesArgs() + { + } + public static new SettingsPropertiesDocDbSettingsPropertiesArgs Empty => new SettingsPropertiesDocDbSettingsPropertiesArgs(); + } +} diff --git a/sdk/dotnet/Dms/Inputs/SettingsPropertiesMariaDbSettingsPropertiesArgs.cs b/sdk/dotnet/Dms/Inputs/SettingsPropertiesMariaDbSettingsPropertiesArgs.cs new file mode 100644 index 0000000000..71ec0b674a --- /dev/null +++ b/sdk/dotnet/Dms/Inputs/SettingsPropertiesMariaDbSettingsPropertiesArgs.cs @@ -0,0 +1,35 @@ +// *** WARNING: this file was generated by pulumi. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.AwsNative.Dms.Inputs +{ + + /// + /// MariaDbSettings property identifier. + /// + public sealed class SettingsPropertiesMariaDbSettingsPropertiesArgs : global::Pulumi.ResourceArgs + { + [Input("certificateArn")] + public Input? CertificateArn { get; set; } + + [Input("port", required: true)] + public Input Port { get; set; } = null!; + + [Input("serverName", required: true)] + public Input ServerName { get; set; } = null!; + + [Input("sslMode", required: true)] + public Input SslMode { get; set; } = null!; + + public SettingsPropertiesMariaDbSettingsPropertiesArgs() + { + } + public static new SettingsPropertiesMariaDbSettingsPropertiesArgs Empty => new SettingsPropertiesMariaDbSettingsPropertiesArgs(); + } +} diff --git a/sdk/dotnet/Dms/Inputs/SettingsPropertiesMongoDbSettingsPropertiesArgs.cs b/sdk/dotnet/Dms/Inputs/SettingsPropertiesMongoDbSettingsPropertiesArgs.cs new file mode 100644 index 0000000000..1352899f95 --- /dev/null +++ b/sdk/dotnet/Dms/Inputs/SettingsPropertiesMongoDbSettingsPropertiesArgs.cs @@ -0,0 +1,47 @@ +// *** WARNING: this file was generated by pulumi. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.AwsNative.Dms.Inputs +{ + + /// + /// MongoDbSettings property identifier. + /// + public sealed class SettingsPropertiesMongoDbSettingsPropertiesArgs : global::Pulumi.ResourceArgs + { + [Input("authMechanism")] + public Input? AuthMechanism { get; set; } + + [Input("authSource")] + public Input? AuthSource { get; set; } + + [Input("authType")] + public Input? AuthType { get; set; } + + [Input("certificateArn")] + public Input? CertificateArn { get; set; } + + [Input("databaseName")] + public Input? DatabaseName { get; set; } + + [Input("port", required: true)] + public Input Port { get; set; } = null!; + + [Input("serverName", required: true)] + public Input ServerName { get; set; } = null!; + + [Input("sslMode")] + public Input? SslMode { get; set; } + + public SettingsPropertiesMongoDbSettingsPropertiesArgs() + { + } + public static new SettingsPropertiesMongoDbSettingsPropertiesArgs Empty => new SettingsPropertiesMongoDbSettingsPropertiesArgs(); + } +} diff --git a/sdk/dotnet/Dms/Inputs/SettingsPropertiesRedshiftSettingsPropertiesArgs.cs b/sdk/dotnet/Dms/Inputs/SettingsPropertiesRedshiftSettingsPropertiesArgs.cs new file mode 100644 index 0000000000..6c51d9217e --- /dev/null +++ b/sdk/dotnet/Dms/Inputs/SettingsPropertiesRedshiftSettingsPropertiesArgs.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.AwsNative.Dms.Inputs +{ + + /// + /// RedshiftSettings property identifier. + /// + public sealed class SettingsPropertiesRedshiftSettingsPropertiesArgs : global::Pulumi.ResourceArgs + { + [Input("databaseName", required: true)] + public Input DatabaseName { get; set; } = null!; + + [Input("port", required: true)] + public Input Port { get; set; } = null!; + + [Input("serverName", required: true)] + public Input ServerName { get; set; } = null!; + + public SettingsPropertiesRedshiftSettingsPropertiesArgs() + { + } + public static new SettingsPropertiesRedshiftSettingsPropertiesArgs Empty => new SettingsPropertiesRedshiftSettingsPropertiesArgs(); + } +} diff --git a/sdk/dotnet/Dms/Outputs/SettingsProperties.cs b/sdk/dotnet/Dms/Outputs/SettingsProperties.cs index 43659530c0..103b973205 100644 --- a/sdk/dotnet/Dms/Outputs/SettingsProperties.cs +++ b/sdk/dotnet/Dms/Outputs/SettingsProperties.cs @@ -16,11 +16,23 @@ namespace Pulumi.AwsNative.Dms.Outputs [OutputType] public sealed class SettingsProperties { + /// + /// DocDbSettings property identifier. + /// + public readonly Outputs.SettingsPropertiesDocDbSettingsProperties? DocDbSettings; + /// + /// MariaDbSettings property identifier. + /// + public readonly Outputs.SettingsPropertiesMariaDbSettingsProperties? MariaDbSettings; /// /// MicrosoftSqlServerSettings property identifier. /// public readonly Outputs.SettingsPropertiesMicrosoftSqlServerSettingsProperties? MicrosoftSqlServerSettings; /// + /// MongoDbSettings property identifier. + /// + public readonly Outputs.SettingsPropertiesMongoDbSettingsProperties? MongoDbSettings; + /// /// MySqlSettings property identifier. /// public readonly Outputs.SettingsPropertiesMySqlSettingsProperties? MySqlSettings; @@ -32,21 +44,37 @@ public sealed class SettingsProperties /// PostgreSqlSettings property identifier. /// public readonly Outputs.SettingsPropertiesPostgreSqlSettingsProperties? PostgreSqlSettings; + /// + /// RedshiftSettings property identifier. + /// + public readonly Outputs.SettingsPropertiesRedshiftSettingsProperties? RedshiftSettings; [OutputConstructor] private SettingsProperties( + Outputs.SettingsPropertiesDocDbSettingsProperties? docDbSettings, + + Outputs.SettingsPropertiesMariaDbSettingsProperties? mariaDbSettings, + Outputs.SettingsPropertiesMicrosoftSqlServerSettingsProperties? microsoftSqlServerSettings, + Outputs.SettingsPropertiesMongoDbSettingsProperties? mongoDbSettings, + Outputs.SettingsPropertiesMySqlSettingsProperties? mySqlSettings, Outputs.SettingsPropertiesOracleSettingsProperties? oracleSettings, - Outputs.SettingsPropertiesPostgreSqlSettingsProperties? postgreSqlSettings) + Outputs.SettingsPropertiesPostgreSqlSettingsProperties? postgreSqlSettings, + + Outputs.SettingsPropertiesRedshiftSettingsProperties? redshiftSettings) { + DocDbSettings = docDbSettings; + MariaDbSettings = mariaDbSettings; MicrosoftSqlServerSettings = microsoftSqlServerSettings; + MongoDbSettings = mongoDbSettings; MySqlSettings = mySqlSettings; OracleSettings = oracleSettings; PostgreSqlSettings = postgreSqlSettings; + RedshiftSettings = redshiftSettings; } } } diff --git a/sdk/dotnet/Dms/Outputs/SettingsPropertiesDocDbSettingsProperties.cs b/sdk/dotnet/Dms/Outputs/SettingsPropertiesDocDbSettingsProperties.cs new file mode 100644 index 0000000000..c771d5882a --- /dev/null +++ b/sdk/dotnet/Dms/Outputs/SettingsPropertiesDocDbSettingsProperties.cs @@ -0,0 +1,44 @@ +// *** WARNING: this file was generated by pulumi. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.AwsNative.Dms.Outputs +{ + + /// + /// DocDbSettings property identifier. + /// + [OutputType] + public sealed class SettingsPropertiesDocDbSettingsProperties + { + public readonly string? CertificateArn; + public readonly string DatabaseName; + public readonly int Port; + public readonly string ServerName; + public readonly Pulumi.AwsNative.Dms.DataProviderMongoDbSslModeValue? SslMode; + + [OutputConstructor] + private SettingsPropertiesDocDbSettingsProperties( + string? certificateArn, + + string databaseName, + + int port, + + string serverName, + + Pulumi.AwsNative.Dms.DataProviderMongoDbSslModeValue? sslMode) + { + CertificateArn = certificateArn; + DatabaseName = databaseName; + Port = port; + ServerName = serverName; + SslMode = sslMode; + } + } +} diff --git a/sdk/dotnet/Dms/Outputs/SettingsPropertiesMariaDbSettingsProperties.cs b/sdk/dotnet/Dms/Outputs/SettingsPropertiesMariaDbSettingsProperties.cs new file mode 100644 index 0000000000..6adcd6a0ad --- /dev/null +++ b/sdk/dotnet/Dms/Outputs/SettingsPropertiesMariaDbSettingsProperties.cs @@ -0,0 +1,40 @@ +// *** WARNING: this file was generated by pulumi. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.AwsNative.Dms.Outputs +{ + + /// + /// MariaDbSettings property identifier. + /// + [OutputType] + public sealed class SettingsPropertiesMariaDbSettingsProperties + { + public readonly string? CertificateArn; + public readonly int Port; + public readonly string ServerName; + public readonly Pulumi.AwsNative.Dms.DataProviderDmsSslModeValue SslMode; + + [OutputConstructor] + private SettingsPropertiesMariaDbSettingsProperties( + string? certificateArn, + + int port, + + string serverName, + + Pulumi.AwsNative.Dms.DataProviderDmsSslModeValue sslMode) + { + CertificateArn = certificateArn; + Port = port; + ServerName = serverName; + SslMode = sslMode; + } + } +} diff --git a/sdk/dotnet/Dms/Outputs/SettingsPropertiesMongoDbSettingsProperties.cs b/sdk/dotnet/Dms/Outputs/SettingsPropertiesMongoDbSettingsProperties.cs new file mode 100644 index 0000000000..12d48e5b4e --- /dev/null +++ b/sdk/dotnet/Dms/Outputs/SettingsPropertiesMongoDbSettingsProperties.cs @@ -0,0 +1,56 @@ +// *** WARNING: this file was generated by pulumi. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.AwsNative.Dms.Outputs +{ + + /// + /// MongoDbSettings property identifier. + /// + [OutputType] + public sealed class SettingsPropertiesMongoDbSettingsProperties + { + public readonly Pulumi.AwsNative.Dms.DataProviderMongoDbAuthMechanism? AuthMechanism; + public readonly string? AuthSource; + public readonly Pulumi.AwsNative.Dms.DataProviderMongoDbAuthType? AuthType; + public readonly string? CertificateArn; + public readonly string? DatabaseName; + public readonly int Port; + public readonly string ServerName; + public readonly Pulumi.AwsNative.Dms.DataProviderMongoDbSslModeValue? SslMode; + + [OutputConstructor] + private SettingsPropertiesMongoDbSettingsProperties( + Pulumi.AwsNative.Dms.DataProviderMongoDbAuthMechanism? authMechanism, + + string? authSource, + + Pulumi.AwsNative.Dms.DataProviderMongoDbAuthType? authType, + + string? certificateArn, + + string? databaseName, + + int port, + + string serverName, + + Pulumi.AwsNative.Dms.DataProviderMongoDbSslModeValue? sslMode) + { + AuthMechanism = authMechanism; + AuthSource = authSource; + AuthType = authType; + CertificateArn = certificateArn; + DatabaseName = databaseName; + Port = port; + ServerName = serverName; + SslMode = sslMode; + } + } +} diff --git a/sdk/dotnet/Dms/Outputs/SettingsPropertiesRedshiftSettingsProperties.cs b/sdk/dotnet/Dms/Outputs/SettingsPropertiesRedshiftSettingsProperties.cs new file mode 100644 index 0000000000..81e88ebe79 --- /dev/null +++ b/sdk/dotnet/Dms/Outputs/SettingsPropertiesRedshiftSettingsProperties.cs @@ -0,0 +1,36 @@ +// *** WARNING: this file was generated by pulumi. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.AwsNative.Dms.Outputs +{ + + /// + /// RedshiftSettings property identifier. + /// + [OutputType] + public sealed class SettingsPropertiesRedshiftSettingsProperties + { + public readonly string DatabaseName; + public readonly int Port; + public readonly string ServerName; + + [OutputConstructor] + private SettingsPropertiesRedshiftSettingsProperties( + string databaseName, + + int port, + + string serverName) + { + DatabaseName = databaseName; + Port = port; + ServerName = serverName; + } + } +} diff --git a/sdk/dotnet/DynamoDb/GetGlobalTable.cs b/sdk/dotnet/DynamoDb/GetGlobalTable.cs index 10953b65c3..9290dc6c8e 100644 --- a/sdk/dotnet/DynamoDb/GetGlobalTable.cs +++ b/sdk/dotnet/DynamoDb/GetGlobalTable.cs @@ -90,6 +90,9 @@ public sealed class GetGlobalTableResult /// Since the backfilling of an index could take a long time, CloudFormation does not wait for the index to become active. If a stack operation rolls back, CloudFormation might not delete an index that has been added. In that case, you will need to delete the index manually. /// public readonly ImmutableArray GlobalSecondaryIndexes; + /// + /// Represents the settings used to enable point in time recovery. + /// public readonly Outputs.GlobalTablePointInTimeRecoverySpecification? PointInTimeRecoverySpecification; /// /// Specifies the list of replicas for your global table. The list must contain at least one element, the region where the stack defining the global table is deployed. For example, if you define your table in a stack deployed to us-east-1, you must have an entry in `Replicas` with the region us-east-1. You cannot remove the replica in the stack region. diff --git a/sdk/dotnet/DynamoDb/GlobalTable.cs b/sdk/dotnet/DynamoDb/GlobalTable.cs index e00e0ad09c..6d3b8f9409 100644 --- a/sdk/dotnet/DynamoDb/GlobalTable.cs +++ b/sdk/dotnet/DynamoDb/GlobalTable.cs @@ -58,6 +58,9 @@ public partial class GlobalTable : global::Pulumi.CustomResource [Output("localSecondaryIndexes")] public Output> LocalSecondaryIndexes { get; private set; } = null!; + /// + /// Represents the settings used to enable point in time recovery. + /// [Output("pointInTimeRecoverySpecification")] public Output PointInTimeRecoverySpecification { get; private set; } = null!; @@ -243,6 +246,9 @@ public InputList LocalSecondaryIndexe set => _localSecondaryIndexes = value; } + /// + /// Represents the settings used to enable point in time recovery. + /// [Input("pointInTimeRecoverySpecification")] public Input? PointInTimeRecoverySpecification { get; set; } diff --git a/sdk/dotnet/IoT/Inputs/DomainConfigurationServerCertificateConfigArgs.cs b/sdk/dotnet/IoT/Inputs/DomainConfigurationServerCertificateConfigArgs.cs index 46bbbdd443..488fc685d5 100644 --- a/sdk/dotnet/IoT/Inputs/DomainConfigurationServerCertificateConfigArgs.cs +++ b/sdk/dotnet/IoT/Inputs/DomainConfigurationServerCertificateConfigArgs.cs @@ -18,9 +18,15 @@ public sealed class DomainConfigurationServerCertificateConfigArgs : global::Pul [Input("enableOcspCheck")] public Input? EnableOcspCheck { get; set; } + /// + /// The Amazon Resource Name (ARN) for an X.509 certificate stored in ACM. If provided, AWS IoT Core will use this certificate to validate the signature of the received OCSP response. The OCSP responder must sign responses using either this authorized responder certificate or the issuing certificate, depending on whether the ARN is provided or not. The certificate must be in the same account and region as the domain configuration. + /// [Input("ocspAuthorizedResponderArn")] public Input? OcspAuthorizedResponderArn { get; set; } + /// + /// The Amazon Resource Name (ARN) for a Lambda function that acts as a Request for Comments (RFC) 6960-compliant Online Certificate Status Protocol (OCSP) responder, supporting basic OCSP responses. The Lambda function accepts a base64-encoding of the OCSP request in the Distinguished Encoding Rules (DER) format. The Lambda function's response is also a base64-encoded OCSP response in the DER format. The response size must not exceed 4 kilobytes (KiB). The Lambda function must be in the same account and region as the domain configuration. + /// [Input("ocspLambdaArn")] public Input? OcspLambdaArn { get; set; } diff --git a/sdk/dotnet/IoT/Outputs/DomainConfigurationServerCertificateConfig.cs b/sdk/dotnet/IoT/Outputs/DomainConfigurationServerCertificateConfig.cs index 5fe3f1d341..e856311cae 100644 --- a/sdk/dotnet/IoT/Outputs/DomainConfigurationServerCertificateConfig.cs +++ b/sdk/dotnet/IoT/Outputs/DomainConfigurationServerCertificateConfig.cs @@ -17,7 +17,13 @@ public sealed class DomainConfigurationServerCertificateConfig /// A Boolean value that indicates whether Online Certificate Status Protocol (OCSP) server certificate check is enabled or not. For more information, see [Configurable endpoints](https://docs.aws.amazon.com//iot/latest/developerguide/iot-custom-endpoints-configurable.html) from the AWS IoT Core Developer Guide. /// public readonly bool? EnableOcspCheck; + /// + /// The Amazon Resource Name (ARN) for an X.509 certificate stored in ACM. If provided, AWS IoT Core will use this certificate to validate the signature of the received OCSP response. The OCSP responder must sign responses using either this authorized responder certificate or the issuing certificate, depending on whether the ARN is provided or not. The certificate must be in the same account and region as the domain configuration. + /// public readonly string? OcspAuthorizedResponderArn; + /// + /// The Amazon Resource Name (ARN) for a Lambda function that acts as a Request for Comments (RFC) 6960-compliant Online Certificate Status Protocol (OCSP) responder, supporting basic OCSP responses. The Lambda function accepts a base64-encoding of the OCSP request in the Distinguished Encoding Rules (DER) format. The Lambda function's response is also a base64-encoded OCSP response in the DER format. The response size must not exceed 4 kilobytes (KiB). The Lambda function must be in the same account and region as the domain configuration. + /// public readonly string? OcspLambdaArn; [OutputConstructor] diff --git a/sdk/dotnet/Synthetics/Inputs/CanaryVpcConfigArgs.cs b/sdk/dotnet/Synthetics/Inputs/CanaryVpcConfigArgs.cs index f2e6824e33..cf0933fd41 100644 --- a/sdk/dotnet/Synthetics/Inputs/CanaryVpcConfigArgs.cs +++ b/sdk/dotnet/Synthetics/Inputs/CanaryVpcConfigArgs.cs @@ -12,6 +12,12 @@ namespace Pulumi.AwsNative.Synthetics.Inputs public sealed class CanaryVpcConfigArgs : global::Pulumi.ResourceArgs { + /// + /// Allow outbound IPv6 traffic on VPC canaries that are connected to dual-stack subnets if set to true + /// + [Input("ipv6AllowedForDualStack")] + public Input? Ipv6AllowedForDualStack { get; set; } + [Input("securityGroupIds", required: true)] private InputList? _securityGroupIds; diff --git a/sdk/dotnet/Synthetics/Outputs/CanaryVpcConfig.cs b/sdk/dotnet/Synthetics/Outputs/CanaryVpcConfig.cs index cf9bd12a93..642b131fbd 100644 --- a/sdk/dotnet/Synthetics/Outputs/CanaryVpcConfig.cs +++ b/sdk/dotnet/Synthetics/Outputs/CanaryVpcConfig.cs @@ -13,6 +13,10 @@ namespace Pulumi.AwsNative.Synthetics.Outputs [OutputType] public sealed class CanaryVpcConfig { + /// + /// Allow outbound IPv6 traffic on VPC canaries that are connected to dual-stack subnets if set to true + /// + public readonly bool? Ipv6AllowedForDualStack; /// /// The IDs of the security groups for this canary. /// @@ -28,12 +32,15 @@ public sealed class CanaryVpcConfig [OutputConstructor] private CanaryVpcConfig( + bool? ipv6AllowedForDualStack, + ImmutableArray securityGroupIds, ImmutableArray subnetIds, string? vpcId) { + Ipv6AllowedForDualStack = ipv6AllowedForDualStack; SecurityGroupIds = securityGroupIds; SubnetIds = subnetIds; VpcId = vpcId; diff --git a/sdk/go/aws/dms/pulumiEnums.go b/sdk/go/aws/dms/pulumiEnums.go index d6df972658..7b9be343ba 100644 --- a/sdk/go/aws/dms/pulumiEnums.go +++ b/sdk/go/aws/dms/pulumiEnums.go @@ -351,12 +351,16 @@ func (in *dataProviderDmsSslModeValuePtr) ToDataProviderDmsSslModeValuePtrOutput type DataProviderEngine string const ( - DataProviderEnginePostgres = DataProviderEngine("postgres") + DataProviderEngineAurora = DataProviderEngine("aurora") + DataProviderEngineAuroraPostgresql = DataProviderEngine("aurora_postgresql") DataProviderEngineMysql = DataProviderEngine("mysql") DataProviderEngineOracle = DataProviderEngine("oracle") + DataProviderEnginePostgres = DataProviderEngine("postgres") DataProviderEngineSqlserver = DataProviderEngine("sqlserver") - DataProviderEngineAurora = DataProviderEngine("aurora") - DataProviderEngineAuroraPostgresql = DataProviderEngine("aurora_postgresql") + DataProviderEngineRedshift = DataProviderEngine("redshift") + DataProviderEngineMariadb = DataProviderEngine("mariadb") + DataProviderEngineMongodb = DataProviderEngine("mongodb") + DataProviderEngineDocdb = DataProviderEngine("docdb") ) func (DataProviderEngine) ElementType() reflect.Type { @@ -481,12 +485,16 @@ func (o DataProviderEnginePtrOutput) ToStringPtrOutputWithContext(ctx context.Co // DataProviderEngineInput is an input type that accepts values of the DataProviderEngine enum // A concrete instance of `DataProviderEngineInput` can be one of the following: // -// DataProviderEnginePostgres +// DataProviderEngineAurora +// DataProviderEngineAuroraPostgresql // DataProviderEngineMysql // DataProviderEngineOracle +// DataProviderEnginePostgres // DataProviderEngineSqlserver -// DataProviderEngineAurora -// DataProviderEngineAuroraPostgresql +// DataProviderEngineRedshift +// DataProviderEngineMariadb +// DataProviderEngineMongodb +// DataProviderEngineDocdb type DataProviderEngineInput interface { pulumi.Input @@ -521,6 +529,505 @@ func (in *dataProviderEnginePtr) ToDataProviderEnginePtrOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, in).(DataProviderEnginePtrOutput) } +type DataProviderMongoDbAuthMechanism string + +const ( + DataProviderMongoDbAuthMechanismDefault = DataProviderMongoDbAuthMechanism("default") + DataProviderMongoDbAuthMechanismMongodbCr = DataProviderMongoDbAuthMechanism("mongodb_cr") + DataProviderMongoDbAuthMechanismScramSha1 = DataProviderMongoDbAuthMechanism("scram_sha_1") +) + +func (DataProviderMongoDbAuthMechanism) ElementType() reflect.Type { + return reflect.TypeOf((*DataProviderMongoDbAuthMechanism)(nil)).Elem() +} + +func (e DataProviderMongoDbAuthMechanism) ToDataProviderMongoDbAuthMechanismOutput() DataProviderMongoDbAuthMechanismOutput { + return pulumi.ToOutput(e).(DataProviderMongoDbAuthMechanismOutput) +} + +func (e DataProviderMongoDbAuthMechanism) ToDataProviderMongoDbAuthMechanismOutputWithContext(ctx context.Context) DataProviderMongoDbAuthMechanismOutput { + return pulumi.ToOutputWithContext(ctx, e).(DataProviderMongoDbAuthMechanismOutput) +} + +func (e DataProviderMongoDbAuthMechanism) ToDataProviderMongoDbAuthMechanismPtrOutput() DataProviderMongoDbAuthMechanismPtrOutput { + return e.ToDataProviderMongoDbAuthMechanismPtrOutputWithContext(context.Background()) +} + +func (e DataProviderMongoDbAuthMechanism) ToDataProviderMongoDbAuthMechanismPtrOutputWithContext(ctx context.Context) DataProviderMongoDbAuthMechanismPtrOutput { + return DataProviderMongoDbAuthMechanism(e).ToDataProviderMongoDbAuthMechanismOutputWithContext(ctx).ToDataProviderMongoDbAuthMechanismPtrOutputWithContext(ctx) +} + +func (e DataProviderMongoDbAuthMechanism) ToStringOutput() pulumi.StringOutput { + return pulumi.ToOutput(pulumi.String(e)).(pulumi.StringOutput) +} + +func (e DataProviderMongoDbAuthMechanism) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput { + return pulumi.ToOutputWithContext(ctx, pulumi.String(e)).(pulumi.StringOutput) +} + +func (e DataProviderMongoDbAuthMechanism) ToStringPtrOutput() pulumi.StringPtrOutput { + return pulumi.String(e).ToStringPtrOutputWithContext(context.Background()) +} + +func (e DataProviderMongoDbAuthMechanism) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput { + return pulumi.String(e).ToStringOutputWithContext(ctx).ToStringPtrOutputWithContext(ctx) +} + +type DataProviderMongoDbAuthMechanismOutput struct{ *pulumi.OutputState } + +func (DataProviderMongoDbAuthMechanismOutput) ElementType() reflect.Type { + return reflect.TypeOf((*DataProviderMongoDbAuthMechanism)(nil)).Elem() +} + +func (o DataProviderMongoDbAuthMechanismOutput) ToDataProviderMongoDbAuthMechanismOutput() DataProviderMongoDbAuthMechanismOutput { + return o +} + +func (o DataProviderMongoDbAuthMechanismOutput) ToDataProviderMongoDbAuthMechanismOutputWithContext(ctx context.Context) DataProviderMongoDbAuthMechanismOutput { + return o +} + +func (o DataProviderMongoDbAuthMechanismOutput) ToDataProviderMongoDbAuthMechanismPtrOutput() DataProviderMongoDbAuthMechanismPtrOutput { + return o.ToDataProviderMongoDbAuthMechanismPtrOutputWithContext(context.Background()) +} + +func (o DataProviderMongoDbAuthMechanismOutput) ToDataProviderMongoDbAuthMechanismPtrOutputWithContext(ctx context.Context) DataProviderMongoDbAuthMechanismPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v DataProviderMongoDbAuthMechanism) *DataProviderMongoDbAuthMechanism { + return &v + }).(DataProviderMongoDbAuthMechanismPtrOutput) +} + +func (o DataProviderMongoDbAuthMechanismOutput) ToStringOutput() pulumi.StringOutput { + return o.ToStringOutputWithContext(context.Background()) +} + +func (o DataProviderMongoDbAuthMechanismOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, e DataProviderMongoDbAuthMechanism) string { + return string(e) + }).(pulumi.StringOutput) +} + +func (o DataProviderMongoDbAuthMechanismOutput) ToStringPtrOutput() pulumi.StringPtrOutput { + return o.ToStringPtrOutputWithContext(context.Background()) +} + +func (o DataProviderMongoDbAuthMechanismOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, e DataProviderMongoDbAuthMechanism) *string { + v := string(e) + return &v + }).(pulumi.StringPtrOutput) +} + +type DataProviderMongoDbAuthMechanismPtrOutput struct{ *pulumi.OutputState } + +func (DataProviderMongoDbAuthMechanismPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**DataProviderMongoDbAuthMechanism)(nil)).Elem() +} + +func (o DataProviderMongoDbAuthMechanismPtrOutput) ToDataProviderMongoDbAuthMechanismPtrOutput() DataProviderMongoDbAuthMechanismPtrOutput { + return o +} + +func (o DataProviderMongoDbAuthMechanismPtrOutput) ToDataProviderMongoDbAuthMechanismPtrOutputWithContext(ctx context.Context) DataProviderMongoDbAuthMechanismPtrOutput { + return o +} + +func (o DataProviderMongoDbAuthMechanismPtrOutput) Elem() DataProviderMongoDbAuthMechanismOutput { + return o.ApplyT(func(v *DataProviderMongoDbAuthMechanism) DataProviderMongoDbAuthMechanism { + if v != nil { + return *v + } + var ret DataProviderMongoDbAuthMechanism + return ret + }).(DataProviderMongoDbAuthMechanismOutput) +} + +func (o DataProviderMongoDbAuthMechanismPtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput { + return o.ToStringPtrOutputWithContext(context.Background()) +} + +func (o DataProviderMongoDbAuthMechanismPtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, e *DataProviderMongoDbAuthMechanism) *string { + if e == nil { + return nil + } + v := string(*e) + return &v + }).(pulumi.StringPtrOutput) +} + +// DataProviderMongoDbAuthMechanismInput is an input type that accepts values of the DataProviderMongoDbAuthMechanism enum +// A concrete instance of `DataProviderMongoDbAuthMechanismInput` can be one of the following: +// +// DataProviderMongoDbAuthMechanismDefault +// DataProviderMongoDbAuthMechanismMongodbCr +// DataProviderMongoDbAuthMechanismScramSha1 +type DataProviderMongoDbAuthMechanismInput interface { + pulumi.Input + + ToDataProviderMongoDbAuthMechanismOutput() DataProviderMongoDbAuthMechanismOutput + ToDataProviderMongoDbAuthMechanismOutputWithContext(context.Context) DataProviderMongoDbAuthMechanismOutput +} + +var dataProviderMongoDbAuthMechanismPtrType = reflect.TypeOf((**DataProviderMongoDbAuthMechanism)(nil)).Elem() + +type DataProviderMongoDbAuthMechanismPtrInput interface { + pulumi.Input + + ToDataProviderMongoDbAuthMechanismPtrOutput() DataProviderMongoDbAuthMechanismPtrOutput + ToDataProviderMongoDbAuthMechanismPtrOutputWithContext(context.Context) DataProviderMongoDbAuthMechanismPtrOutput +} + +type dataProviderMongoDbAuthMechanismPtr string + +func DataProviderMongoDbAuthMechanismPtr(v string) DataProviderMongoDbAuthMechanismPtrInput { + return (*dataProviderMongoDbAuthMechanismPtr)(&v) +} + +func (*dataProviderMongoDbAuthMechanismPtr) ElementType() reflect.Type { + return dataProviderMongoDbAuthMechanismPtrType +} + +func (in *dataProviderMongoDbAuthMechanismPtr) ToDataProviderMongoDbAuthMechanismPtrOutput() DataProviderMongoDbAuthMechanismPtrOutput { + return pulumi.ToOutput(in).(DataProviderMongoDbAuthMechanismPtrOutput) +} + +func (in *dataProviderMongoDbAuthMechanismPtr) ToDataProviderMongoDbAuthMechanismPtrOutputWithContext(ctx context.Context) DataProviderMongoDbAuthMechanismPtrOutput { + return pulumi.ToOutputWithContext(ctx, in).(DataProviderMongoDbAuthMechanismPtrOutput) +} + +type DataProviderMongoDbAuthType string + +const ( + DataProviderMongoDbAuthTypeNo = DataProviderMongoDbAuthType("no") + DataProviderMongoDbAuthTypePassword = DataProviderMongoDbAuthType("password") +) + +func (DataProviderMongoDbAuthType) ElementType() reflect.Type { + return reflect.TypeOf((*DataProviderMongoDbAuthType)(nil)).Elem() +} + +func (e DataProviderMongoDbAuthType) ToDataProviderMongoDbAuthTypeOutput() DataProviderMongoDbAuthTypeOutput { + return pulumi.ToOutput(e).(DataProviderMongoDbAuthTypeOutput) +} + +func (e DataProviderMongoDbAuthType) ToDataProviderMongoDbAuthTypeOutputWithContext(ctx context.Context) DataProviderMongoDbAuthTypeOutput { + return pulumi.ToOutputWithContext(ctx, e).(DataProviderMongoDbAuthTypeOutput) +} + +func (e DataProviderMongoDbAuthType) ToDataProviderMongoDbAuthTypePtrOutput() DataProviderMongoDbAuthTypePtrOutput { + return e.ToDataProviderMongoDbAuthTypePtrOutputWithContext(context.Background()) +} + +func (e DataProviderMongoDbAuthType) ToDataProviderMongoDbAuthTypePtrOutputWithContext(ctx context.Context) DataProviderMongoDbAuthTypePtrOutput { + return DataProviderMongoDbAuthType(e).ToDataProviderMongoDbAuthTypeOutputWithContext(ctx).ToDataProviderMongoDbAuthTypePtrOutputWithContext(ctx) +} + +func (e DataProviderMongoDbAuthType) ToStringOutput() pulumi.StringOutput { + return pulumi.ToOutput(pulumi.String(e)).(pulumi.StringOutput) +} + +func (e DataProviderMongoDbAuthType) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput { + return pulumi.ToOutputWithContext(ctx, pulumi.String(e)).(pulumi.StringOutput) +} + +func (e DataProviderMongoDbAuthType) ToStringPtrOutput() pulumi.StringPtrOutput { + return pulumi.String(e).ToStringPtrOutputWithContext(context.Background()) +} + +func (e DataProviderMongoDbAuthType) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput { + return pulumi.String(e).ToStringOutputWithContext(ctx).ToStringPtrOutputWithContext(ctx) +} + +type DataProviderMongoDbAuthTypeOutput struct{ *pulumi.OutputState } + +func (DataProviderMongoDbAuthTypeOutput) ElementType() reflect.Type { + return reflect.TypeOf((*DataProviderMongoDbAuthType)(nil)).Elem() +} + +func (o DataProviderMongoDbAuthTypeOutput) ToDataProviderMongoDbAuthTypeOutput() DataProviderMongoDbAuthTypeOutput { + return o +} + +func (o DataProviderMongoDbAuthTypeOutput) ToDataProviderMongoDbAuthTypeOutputWithContext(ctx context.Context) DataProviderMongoDbAuthTypeOutput { + return o +} + +func (o DataProviderMongoDbAuthTypeOutput) ToDataProviderMongoDbAuthTypePtrOutput() DataProviderMongoDbAuthTypePtrOutput { + return o.ToDataProviderMongoDbAuthTypePtrOutputWithContext(context.Background()) +} + +func (o DataProviderMongoDbAuthTypeOutput) ToDataProviderMongoDbAuthTypePtrOutputWithContext(ctx context.Context) DataProviderMongoDbAuthTypePtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v DataProviderMongoDbAuthType) *DataProviderMongoDbAuthType { + return &v + }).(DataProviderMongoDbAuthTypePtrOutput) +} + +func (o DataProviderMongoDbAuthTypeOutput) ToStringOutput() pulumi.StringOutput { + return o.ToStringOutputWithContext(context.Background()) +} + +func (o DataProviderMongoDbAuthTypeOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, e DataProviderMongoDbAuthType) string { + return string(e) + }).(pulumi.StringOutput) +} + +func (o DataProviderMongoDbAuthTypeOutput) ToStringPtrOutput() pulumi.StringPtrOutput { + return o.ToStringPtrOutputWithContext(context.Background()) +} + +func (o DataProviderMongoDbAuthTypeOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, e DataProviderMongoDbAuthType) *string { + v := string(e) + return &v + }).(pulumi.StringPtrOutput) +} + +type DataProviderMongoDbAuthTypePtrOutput struct{ *pulumi.OutputState } + +func (DataProviderMongoDbAuthTypePtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**DataProviderMongoDbAuthType)(nil)).Elem() +} + +func (o DataProviderMongoDbAuthTypePtrOutput) ToDataProviderMongoDbAuthTypePtrOutput() DataProviderMongoDbAuthTypePtrOutput { + return o +} + +func (o DataProviderMongoDbAuthTypePtrOutput) ToDataProviderMongoDbAuthTypePtrOutputWithContext(ctx context.Context) DataProviderMongoDbAuthTypePtrOutput { + return o +} + +func (o DataProviderMongoDbAuthTypePtrOutput) Elem() DataProviderMongoDbAuthTypeOutput { + return o.ApplyT(func(v *DataProviderMongoDbAuthType) DataProviderMongoDbAuthType { + if v != nil { + return *v + } + var ret DataProviderMongoDbAuthType + return ret + }).(DataProviderMongoDbAuthTypeOutput) +} + +func (o DataProviderMongoDbAuthTypePtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput { + return o.ToStringPtrOutputWithContext(context.Background()) +} + +func (o DataProviderMongoDbAuthTypePtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, e *DataProviderMongoDbAuthType) *string { + if e == nil { + return nil + } + v := string(*e) + return &v + }).(pulumi.StringPtrOutput) +} + +// DataProviderMongoDbAuthTypeInput is an input type that accepts values of the DataProviderMongoDbAuthType enum +// A concrete instance of `DataProviderMongoDbAuthTypeInput` can be one of the following: +// +// DataProviderMongoDbAuthTypeNo +// DataProviderMongoDbAuthTypePassword +type DataProviderMongoDbAuthTypeInput interface { + pulumi.Input + + ToDataProviderMongoDbAuthTypeOutput() DataProviderMongoDbAuthTypeOutput + ToDataProviderMongoDbAuthTypeOutputWithContext(context.Context) DataProviderMongoDbAuthTypeOutput +} + +var dataProviderMongoDbAuthTypePtrType = reflect.TypeOf((**DataProviderMongoDbAuthType)(nil)).Elem() + +type DataProviderMongoDbAuthTypePtrInput interface { + pulumi.Input + + ToDataProviderMongoDbAuthTypePtrOutput() DataProviderMongoDbAuthTypePtrOutput + ToDataProviderMongoDbAuthTypePtrOutputWithContext(context.Context) DataProviderMongoDbAuthTypePtrOutput +} + +type dataProviderMongoDbAuthTypePtr string + +func DataProviderMongoDbAuthTypePtr(v string) DataProviderMongoDbAuthTypePtrInput { + return (*dataProviderMongoDbAuthTypePtr)(&v) +} + +func (*dataProviderMongoDbAuthTypePtr) ElementType() reflect.Type { + return dataProviderMongoDbAuthTypePtrType +} + +func (in *dataProviderMongoDbAuthTypePtr) ToDataProviderMongoDbAuthTypePtrOutput() DataProviderMongoDbAuthTypePtrOutput { + return pulumi.ToOutput(in).(DataProviderMongoDbAuthTypePtrOutput) +} + +func (in *dataProviderMongoDbAuthTypePtr) ToDataProviderMongoDbAuthTypePtrOutputWithContext(ctx context.Context) DataProviderMongoDbAuthTypePtrOutput { + return pulumi.ToOutputWithContext(ctx, in).(DataProviderMongoDbAuthTypePtrOutput) +} + +type DataProviderMongoDbSslModeValue string + +const ( + DataProviderMongoDbSslModeValueNone = DataProviderMongoDbSslModeValue("none") + DataProviderMongoDbSslModeValueRequire = DataProviderMongoDbSslModeValue("require") + DataProviderMongoDbSslModeValueVerifyFull = DataProviderMongoDbSslModeValue("verify-full") +) + +func (DataProviderMongoDbSslModeValue) ElementType() reflect.Type { + return reflect.TypeOf((*DataProviderMongoDbSslModeValue)(nil)).Elem() +} + +func (e DataProviderMongoDbSslModeValue) ToDataProviderMongoDbSslModeValueOutput() DataProviderMongoDbSslModeValueOutput { + return pulumi.ToOutput(e).(DataProviderMongoDbSslModeValueOutput) +} + +func (e DataProviderMongoDbSslModeValue) ToDataProviderMongoDbSslModeValueOutputWithContext(ctx context.Context) DataProviderMongoDbSslModeValueOutput { + return pulumi.ToOutputWithContext(ctx, e).(DataProviderMongoDbSslModeValueOutput) +} + +func (e DataProviderMongoDbSslModeValue) ToDataProviderMongoDbSslModeValuePtrOutput() DataProviderMongoDbSslModeValuePtrOutput { + return e.ToDataProviderMongoDbSslModeValuePtrOutputWithContext(context.Background()) +} + +func (e DataProviderMongoDbSslModeValue) ToDataProviderMongoDbSslModeValuePtrOutputWithContext(ctx context.Context) DataProviderMongoDbSslModeValuePtrOutput { + return DataProviderMongoDbSslModeValue(e).ToDataProviderMongoDbSslModeValueOutputWithContext(ctx).ToDataProviderMongoDbSslModeValuePtrOutputWithContext(ctx) +} + +func (e DataProviderMongoDbSslModeValue) ToStringOutput() pulumi.StringOutput { + return pulumi.ToOutput(pulumi.String(e)).(pulumi.StringOutput) +} + +func (e DataProviderMongoDbSslModeValue) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput { + return pulumi.ToOutputWithContext(ctx, pulumi.String(e)).(pulumi.StringOutput) +} + +func (e DataProviderMongoDbSslModeValue) ToStringPtrOutput() pulumi.StringPtrOutput { + return pulumi.String(e).ToStringPtrOutputWithContext(context.Background()) +} + +func (e DataProviderMongoDbSslModeValue) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput { + return pulumi.String(e).ToStringOutputWithContext(ctx).ToStringPtrOutputWithContext(ctx) +} + +type DataProviderMongoDbSslModeValueOutput struct{ *pulumi.OutputState } + +func (DataProviderMongoDbSslModeValueOutput) ElementType() reflect.Type { + return reflect.TypeOf((*DataProviderMongoDbSslModeValue)(nil)).Elem() +} + +func (o DataProviderMongoDbSslModeValueOutput) ToDataProviderMongoDbSslModeValueOutput() DataProviderMongoDbSslModeValueOutput { + return o +} + +func (o DataProviderMongoDbSslModeValueOutput) ToDataProviderMongoDbSslModeValueOutputWithContext(ctx context.Context) DataProviderMongoDbSslModeValueOutput { + return o +} + +func (o DataProviderMongoDbSslModeValueOutput) ToDataProviderMongoDbSslModeValuePtrOutput() DataProviderMongoDbSslModeValuePtrOutput { + return o.ToDataProviderMongoDbSslModeValuePtrOutputWithContext(context.Background()) +} + +func (o DataProviderMongoDbSslModeValueOutput) ToDataProviderMongoDbSslModeValuePtrOutputWithContext(ctx context.Context) DataProviderMongoDbSslModeValuePtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v DataProviderMongoDbSslModeValue) *DataProviderMongoDbSslModeValue { + return &v + }).(DataProviderMongoDbSslModeValuePtrOutput) +} + +func (o DataProviderMongoDbSslModeValueOutput) ToStringOutput() pulumi.StringOutput { + return o.ToStringOutputWithContext(context.Background()) +} + +func (o DataProviderMongoDbSslModeValueOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, e DataProviderMongoDbSslModeValue) string { + return string(e) + }).(pulumi.StringOutput) +} + +func (o DataProviderMongoDbSslModeValueOutput) ToStringPtrOutput() pulumi.StringPtrOutput { + return o.ToStringPtrOutputWithContext(context.Background()) +} + +func (o DataProviderMongoDbSslModeValueOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, e DataProviderMongoDbSslModeValue) *string { + v := string(e) + return &v + }).(pulumi.StringPtrOutput) +} + +type DataProviderMongoDbSslModeValuePtrOutput struct{ *pulumi.OutputState } + +func (DataProviderMongoDbSslModeValuePtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**DataProviderMongoDbSslModeValue)(nil)).Elem() +} + +func (o DataProviderMongoDbSslModeValuePtrOutput) ToDataProviderMongoDbSslModeValuePtrOutput() DataProviderMongoDbSslModeValuePtrOutput { + return o +} + +func (o DataProviderMongoDbSslModeValuePtrOutput) ToDataProviderMongoDbSslModeValuePtrOutputWithContext(ctx context.Context) DataProviderMongoDbSslModeValuePtrOutput { + return o +} + +func (o DataProviderMongoDbSslModeValuePtrOutput) Elem() DataProviderMongoDbSslModeValueOutput { + return o.ApplyT(func(v *DataProviderMongoDbSslModeValue) DataProviderMongoDbSslModeValue { + if v != nil { + return *v + } + var ret DataProviderMongoDbSslModeValue + return ret + }).(DataProviderMongoDbSslModeValueOutput) +} + +func (o DataProviderMongoDbSslModeValuePtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput { + return o.ToStringPtrOutputWithContext(context.Background()) +} + +func (o DataProviderMongoDbSslModeValuePtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, e *DataProviderMongoDbSslModeValue) *string { + if e == nil { + return nil + } + v := string(*e) + return &v + }).(pulumi.StringPtrOutput) +} + +// DataProviderMongoDbSslModeValueInput is an input type that accepts values of the DataProviderMongoDbSslModeValue enum +// A concrete instance of `DataProviderMongoDbSslModeValueInput` can be one of the following: +// +// DataProviderMongoDbSslModeValueNone +// DataProviderMongoDbSslModeValueRequire +// DataProviderMongoDbSslModeValueVerifyFull +type DataProviderMongoDbSslModeValueInput interface { + pulumi.Input + + ToDataProviderMongoDbSslModeValueOutput() DataProviderMongoDbSslModeValueOutput + ToDataProviderMongoDbSslModeValueOutputWithContext(context.Context) DataProviderMongoDbSslModeValueOutput +} + +var dataProviderMongoDbSslModeValuePtrType = reflect.TypeOf((**DataProviderMongoDbSslModeValue)(nil)).Elem() + +type DataProviderMongoDbSslModeValuePtrInput interface { + pulumi.Input + + ToDataProviderMongoDbSslModeValuePtrOutput() DataProviderMongoDbSslModeValuePtrOutput + ToDataProviderMongoDbSslModeValuePtrOutputWithContext(context.Context) DataProviderMongoDbSslModeValuePtrOutput +} + +type dataProviderMongoDbSslModeValuePtr string + +func DataProviderMongoDbSslModeValuePtr(v string) DataProviderMongoDbSslModeValuePtrInput { + return (*dataProviderMongoDbSslModeValuePtr)(&v) +} + +func (*dataProviderMongoDbSslModeValuePtr) ElementType() reflect.Type { + return dataProviderMongoDbSslModeValuePtrType +} + +func (in *dataProviderMongoDbSslModeValuePtr) ToDataProviderMongoDbSslModeValuePtrOutput() DataProviderMongoDbSslModeValuePtrOutput { + return pulumi.ToOutput(in).(DataProviderMongoDbSslModeValuePtrOutput) +} + +func (in *dataProviderMongoDbSslModeValuePtr) ToDataProviderMongoDbSslModeValuePtrOutputWithContext(ctx context.Context) DataProviderMongoDbSslModeValuePtrOutput { + return pulumi.ToOutputWithContext(ctx, in).(DataProviderMongoDbSslModeValuePtrOutput) +} + // The property describes a network type for the instance profile. type InstanceProfileNetworkType string @@ -860,8 +1367,14 @@ func init() { pulumi.RegisterInputType(reflect.TypeOf((*DataMigrationTypePtrInput)(nil)).Elem(), DataMigrationType("full-load")) pulumi.RegisterInputType(reflect.TypeOf((*DataProviderDmsSslModeValueInput)(nil)).Elem(), DataProviderDmsSslModeValue("none")) pulumi.RegisterInputType(reflect.TypeOf((*DataProviderDmsSslModeValuePtrInput)(nil)).Elem(), DataProviderDmsSslModeValue("none")) - pulumi.RegisterInputType(reflect.TypeOf((*DataProviderEngineInput)(nil)).Elem(), DataProviderEngine("postgres")) - pulumi.RegisterInputType(reflect.TypeOf((*DataProviderEnginePtrInput)(nil)).Elem(), DataProviderEngine("postgres")) + pulumi.RegisterInputType(reflect.TypeOf((*DataProviderEngineInput)(nil)).Elem(), DataProviderEngine("aurora")) + pulumi.RegisterInputType(reflect.TypeOf((*DataProviderEnginePtrInput)(nil)).Elem(), DataProviderEngine("aurora")) + pulumi.RegisterInputType(reflect.TypeOf((*DataProviderMongoDbAuthMechanismInput)(nil)).Elem(), DataProviderMongoDbAuthMechanism("default")) + pulumi.RegisterInputType(reflect.TypeOf((*DataProviderMongoDbAuthMechanismPtrInput)(nil)).Elem(), DataProviderMongoDbAuthMechanism("default")) + pulumi.RegisterInputType(reflect.TypeOf((*DataProviderMongoDbAuthTypeInput)(nil)).Elem(), DataProviderMongoDbAuthType("no")) + pulumi.RegisterInputType(reflect.TypeOf((*DataProviderMongoDbAuthTypePtrInput)(nil)).Elem(), DataProviderMongoDbAuthType("no")) + pulumi.RegisterInputType(reflect.TypeOf((*DataProviderMongoDbSslModeValueInput)(nil)).Elem(), DataProviderMongoDbSslModeValue("none")) + pulumi.RegisterInputType(reflect.TypeOf((*DataProviderMongoDbSslModeValuePtrInput)(nil)).Elem(), DataProviderMongoDbSslModeValue("none")) pulumi.RegisterInputType(reflect.TypeOf((*InstanceProfileNetworkTypeInput)(nil)).Elem(), InstanceProfileNetworkType("IPV4")) pulumi.RegisterInputType(reflect.TypeOf((*InstanceProfileNetworkTypePtrInput)(nil)).Elem(), InstanceProfileNetworkType("IPV4")) pulumi.RegisterInputType(reflect.TypeOf((*ReplicationConfigReplicationTypeInput)(nil)).Elem(), ReplicationConfigReplicationType("full-load")) @@ -872,6 +1385,12 @@ func init() { pulumi.RegisterOutputType(DataProviderDmsSslModeValuePtrOutput{}) pulumi.RegisterOutputType(DataProviderEngineOutput{}) pulumi.RegisterOutputType(DataProviderEnginePtrOutput{}) + pulumi.RegisterOutputType(DataProviderMongoDbAuthMechanismOutput{}) + pulumi.RegisterOutputType(DataProviderMongoDbAuthMechanismPtrOutput{}) + pulumi.RegisterOutputType(DataProviderMongoDbAuthTypeOutput{}) + pulumi.RegisterOutputType(DataProviderMongoDbAuthTypePtrOutput{}) + pulumi.RegisterOutputType(DataProviderMongoDbSslModeValueOutput{}) + pulumi.RegisterOutputType(DataProviderMongoDbSslModeValuePtrOutput{}) pulumi.RegisterOutputType(InstanceProfileNetworkTypeOutput{}) pulumi.RegisterOutputType(InstanceProfileNetworkTypePtrOutput{}) pulumi.RegisterOutputType(ReplicationConfigReplicationTypeOutput{}) diff --git a/sdk/go/aws/dms/pulumiTypes.go b/sdk/go/aws/dms/pulumiTypes.go index 1b56e9a0a2..73a1a4f290 100644 --- a/sdk/go/aws/dms/pulumiTypes.go +++ b/sdk/go/aws/dms/pulumiTypes.go @@ -913,14 +913,22 @@ func (o SchemaConversionApplicationAttributesPropertiesPtrOutput) S3BucketRoleAr // The property identifies the exact type of settings for the data provider. type SettingsProperties struct { + // DocDbSettings property identifier. + DocDbSettings *SettingsPropertiesDocDbSettingsProperties `pulumi:"docDbSettings"` + // MariaDbSettings property identifier. + MariaDbSettings *SettingsPropertiesMariaDbSettingsProperties `pulumi:"mariaDbSettings"` // MicrosoftSqlServerSettings property identifier. MicrosoftSqlServerSettings *SettingsPropertiesMicrosoftSqlServerSettingsProperties `pulumi:"microsoftSqlServerSettings"` + // MongoDbSettings property identifier. + MongoDbSettings *SettingsPropertiesMongoDbSettingsProperties `pulumi:"mongoDbSettings"` // MySqlSettings property identifier. MySqlSettings *SettingsPropertiesMySqlSettingsProperties `pulumi:"mySqlSettings"` // OracleSettings property identifier. OracleSettings *SettingsPropertiesOracleSettingsProperties `pulumi:"oracleSettings"` // PostgreSqlSettings property identifier. PostgreSqlSettings *SettingsPropertiesPostgreSqlSettingsProperties `pulumi:"postgreSqlSettings"` + // RedshiftSettings property identifier. + RedshiftSettings *SettingsPropertiesRedshiftSettingsProperties `pulumi:"redshiftSettings"` } // SettingsPropertiesInput is an input type that accepts SettingsPropertiesArgs and SettingsPropertiesOutput values. @@ -936,14 +944,22 @@ type SettingsPropertiesInput interface { // The property identifies the exact type of settings for the data provider. type SettingsPropertiesArgs struct { + // DocDbSettings property identifier. + DocDbSettings SettingsPropertiesDocDbSettingsPropertiesPtrInput `pulumi:"docDbSettings"` + // MariaDbSettings property identifier. + MariaDbSettings SettingsPropertiesMariaDbSettingsPropertiesPtrInput `pulumi:"mariaDbSettings"` // MicrosoftSqlServerSettings property identifier. MicrosoftSqlServerSettings SettingsPropertiesMicrosoftSqlServerSettingsPropertiesPtrInput `pulumi:"microsoftSqlServerSettings"` + // MongoDbSettings property identifier. + MongoDbSettings SettingsPropertiesMongoDbSettingsPropertiesPtrInput `pulumi:"mongoDbSettings"` // MySqlSettings property identifier. MySqlSettings SettingsPropertiesMySqlSettingsPropertiesPtrInput `pulumi:"mySqlSettings"` // OracleSettings property identifier. OracleSettings SettingsPropertiesOracleSettingsPropertiesPtrInput `pulumi:"oracleSettings"` // PostgreSqlSettings property identifier. PostgreSqlSettings SettingsPropertiesPostgreSqlSettingsPropertiesPtrInput `pulumi:"postgreSqlSettings"` + // RedshiftSettings property identifier. + RedshiftSettings SettingsPropertiesRedshiftSettingsPropertiesPtrInput `pulumi:"redshiftSettings"` } func (SettingsPropertiesArgs) ElementType() reflect.Type { @@ -1024,6 +1040,16 @@ func (o SettingsPropertiesOutput) ToSettingsPropertiesPtrOutputWithContext(ctx c }).(SettingsPropertiesPtrOutput) } +// DocDbSettings property identifier. +func (o SettingsPropertiesOutput) DocDbSettings() SettingsPropertiesDocDbSettingsPropertiesPtrOutput { + return o.ApplyT(func(v SettingsProperties) *SettingsPropertiesDocDbSettingsProperties { return v.DocDbSettings }).(SettingsPropertiesDocDbSettingsPropertiesPtrOutput) +} + +// MariaDbSettings property identifier. +func (o SettingsPropertiesOutput) MariaDbSettings() SettingsPropertiesMariaDbSettingsPropertiesPtrOutput { + return o.ApplyT(func(v SettingsProperties) *SettingsPropertiesMariaDbSettingsProperties { return v.MariaDbSettings }).(SettingsPropertiesMariaDbSettingsPropertiesPtrOutput) +} + // MicrosoftSqlServerSettings property identifier. func (o SettingsPropertiesOutput) MicrosoftSqlServerSettings() SettingsPropertiesMicrosoftSqlServerSettingsPropertiesPtrOutput { return o.ApplyT(func(v SettingsProperties) *SettingsPropertiesMicrosoftSqlServerSettingsProperties { @@ -1031,6 +1057,11 @@ func (o SettingsPropertiesOutput) MicrosoftSqlServerSettings() SettingsPropertie }).(SettingsPropertiesMicrosoftSqlServerSettingsPropertiesPtrOutput) } +// MongoDbSettings property identifier. +func (o SettingsPropertiesOutput) MongoDbSettings() SettingsPropertiesMongoDbSettingsPropertiesPtrOutput { + return o.ApplyT(func(v SettingsProperties) *SettingsPropertiesMongoDbSettingsProperties { return v.MongoDbSettings }).(SettingsPropertiesMongoDbSettingsPropertiesPtrOutput) +} + // MySqlSettings property identifier. func (o SettingsPropertiesOutput) MySqlSettings() SettingsPropertiesMySqlSettingsPropertiesPtrOutput { return o.ApplyT(func(v SettingsProperties) *SettingsPropertiesMySqlSettingsProperties { return v.MySqlSettings }).(SettingsPropertiesMySqlSettingsPropertiesPtrOutput) @@ -1048,6 +1079,11 @@ func (o SettingsPropertiesOutput) PostgreSqlSettings() SettingsPropertiesPostgre }).(SettingsPropertiesPostgreSqlSettingsPropertiesPtrOutput) } +// RedshiftSettings property identifier. +func (o SettingsPropertiesOutput) RedshiftSettings() SettingsPropertiesRedshiftSettingsPropertiesPtrOutput { + return o.ApplyT(func(v SettingsProperties) *SettingsPropertiesRedshiftSettingsProperties { return v.RedshiftSettings }).(SettingsPropertiesRedshiftSettingsPropertiesPtrOutput) +} + type SettingsPropertiesPtrOutput struct{ *pulumi.OutputState } func (SettingsPropertiesPtrOutput) ElementType() reflect.Type { @@ -1072,6 +1108,26 @@ func (o SettingsPropertiesPtrOutput) Elem() SettingsPropertiesOutput { }).(SettingsPropertiesOutput) } +// DocDbSettings property identifier. +func (o SettingsPropertiesPtrOutput) DocDbSettings() SettingsPropertiesDocDbSettingsPropertiesPtrOutput { + return o.ApplyT(func(v *SettingsProperties) *SettingsPropertiesDocDbSettingsProperties { + if v == nil { + return nil + } + return v.DocDbSettings + }).(SettingsPropertiesDocDbSettingsPropertiesPtrOutput) +} + +// MariaDbSettings property identifier. +func (o SettingsPropertiesPtrOutput) MariaDbSettings() SettingsPropertiesMariaDbSettingsPropertiesPtrOutput { + return o.ApplyT(func(v *SettingsProperties) *SettingsPropertiesMariaDbSettingsProperties { + if v == nil { + return nil + } + return v.MariaDbSettings + }).(SettingsPropertiesMariaDbSettingsPropertiesPtrOutput) +} + // MicrosoftSqlServerSettings property identifier. func (o SettingsPropertiesPtrOutput) MicrosoftSqlServerSettings() SettingsPropertiesMicrosoftSqlServerSettingsPropertiesPtrOutput { return o.ApplyT(func(v *SettingsProperties) *SettingsPropertiesMicrosoftSqlServerSettingsProperties { @@ -1082,6 +1138,16 @@ func (o SettingsPropertiesPtrOutput) MicrosoftSqlServerSettings() SettingsProper }).(SettingsPropertiesMicrosoftSqlServerSettingsPropertiesPtrOutput) } +// MongoDbSettings property identifier. +func (o SettingsPropertiesPtrOutput) MongoDbSettings() SettingsPropertiesMongoDbSettingsPropertiesPtrOutput { + return o.ApplyT(func(v *SettingsProperties) *SettingsPropertiesMongoDbSettingsProperties { + if v == nil { + return nil + } + return v.MongoDbSettings + }).(SettingsPropertiesMongoDbSettingsPropertiesPtrOutput) +} + // MySqlSettings property identifier. func (o SettingsPropertiesPtrOutput) MySqlSettings() SettingsPropertiesMySqlSettingsPropertiesPtrOutput { return o.ApplyT(func(v *SettingsProperties) *SettingsPropertiesMySqlSettingsProperties { @@ -1112,6 +1178,393 @@ func (o SettingsPropertiesPtrOutput) PostgreSqlSettings() SettingsPropertiesPost }).(SettingsPropertiesPostgreSqlSettingsPropertiesPtrOutput) } +// RedshiftSettings property identifier. +func (o SettingsPropertiesPtrOutput) RedshiftSettings() SettingsPropertiesRedshiftSettingsPropertiesPtrOutput { + return o.ApplyT(func(v *SettingsProperties) *SettingsPropertiesRedshiftSettingsProperties { + if v == nil { + return nil + } + return v.RedshiftSettings + }).(SettingsPropertiesRedshiftSettingsPropertiesPtrOutput) +} + +// DocDbSettings property identifier. +type SettingsPropertiesDocDbSettingsProperties struct { + CertificateArn *string `pulumi:"certificateArn"` + DatabaseName string `pulumi:"databaseName"` + Port int `pulumi:"port"` + ServerName string `pulumi:"serverName"` + SslMode *DataProviderMongoDbSslModeValue `pulumi:"sslMode"` +} + +// SettingsPropertiesDocDbSettingsPropertiesInput is an input type that accepts SettingsPropertiesDocDbSettingsPropertiesArgs and SettingsPropertiesDocDbSettingsPropertiesOutput values. +// You can construct a concrete instance of `SettingsPropertiesDocDbSettingsPropertiesInput` via: +// +// SettingsPropertiesDocDbSettingsPropertiesArgs{...} +type SettingsPropertiesDocDbSettingsPropertiesInput interface { + pulumi.Input + + ToSettingsPropertiesDocDbSettingsPropertiesOutput() SettingsPropertiesDocDbSettingsPropertiesOutput + ToSettingsPropertiesDocDbSettingsPropertiesOutputWithContext(context.Context) SettingsPropertiesDocDbSettingsPropertiesOutput +} + +// DocDbSettings property identifier. +type SettingsPropertiesDocDbSettingsPropertiesArgs struct { + CertificateArn pulumi.StringPtrInput `pulumi:"certificateArn"` + DatabaseName pulumi.StringInput `pulumi:"databaseName"` + Port pulumi.IntInput `pulumi:"port"` + ServerName pulumi.StringInput `pulumi:"serverName"` + SslMode DataProviderMongoDbSslModeValuePtrInput `pulumi:"sslMode"` +} + +func (SettingsPropertiesDocDbSettingsPropertiesArgs) ElementType() reflect.Type { + return reflect.TypeOf((*SettingsPropertiesDocDbSettingsProperties)(nil)).Elem() +} + +func (i SettingsPropertiesDocDbSettingsPropertiesArgs) ToSettingsPropertiesDocDbSettingsPropertiesOutput() SettingsPropertiesDocDbSettingsPropertiesOutput { + return i.ToSettingsPropertiesDocDbSettingsPropertiesOutputWithContext(context.Background()) +} + +func (i SettingsPropertiesDocDbSettingsPropertiesArgs) ToSettingsPropertiesDocDbSettingsPropertiesOutputWithContext(ctx context.Context) SettingsPropertiesDocDbSettingsPropertiesOutput { + return pulumi.ToOutputWithContext(ctx, i).(SettingsPropertiesDocDbSettingsPropertiesOutput) +} + +func (i SettingsPropertiesDocDbSettingsPropertiesArgs) ToSettingsPropertiesDocDbSettingsPropertiesPtrOutput() SettingsPropertiesDocDbSettingsPropertiesPtrOutput { + return i.ToSettingsPropertiesDocDbSettingsPropertiesPtrOutputWithContext(context.Background()) +} + +func (i SettingsPropertiesDocDbSettingsPropertiesArgs) ToSettingsPropertiesDocDbSettingsPropertiesPtrOutputWithContext(ctx context.Context) SettingsPropertiesDocDbSettingsPropertiesPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(SettingsPropertiesDocDbSettingsPropertiesOutput).ToSettingsPropertiesDocDbSettingsPropertiesPtrOutputWithContext(ctx) +} + +// SettingsPropertiesDocDbSettingsPropertiesPtrInput is an input type that accepts SettingsPropertiesDocDbSettingsPropertiesArgs, SettingsPropertiesDocDbSettingsPropertiesPtr and SettingsPropertiesDocDbSettingsPropertiesPtrOutput values. +// You can construct a concrete instance of `SettingsPropertiesDocDbSettingsPropertiesPtrInput` via: +// +// SettingsPropertiesDocDbSettingsPropertiesArgs{...} +// +// or: +// +// nil +type SettingsPropertiesDocDbSettingsPropertiesPtrInput interface { + pulumi.Input + + ToSettingsPropertiesDocDbSettingsPropertiesPtrOutput() SettingsPropertiesDocDbSettingsPropertiesPtrOutput + ToSettingsPropertiesDocDbSettingsPropertiesPtrOutputWithContext(context.Context) SettingsPropertiesDocDbSettingsPropertiesPtrOutput +} + +type settingsPropertiesDocDbSettingsPropertiesPtrType SettingsPropertiesDocDbSettingsPropertiesArgs + +func SettingsPropertiesDocDbSettingsPropertiesPtr(v *SettingsPropertiesDocDbSettingsPropertiesArgs) SettingsPropertiesDocDbSettingsPropertiesPtrInput { + return (*settingsPropertiesDocDbSettingsPropertiesPtrType)(v) +} + +func (*settingsPropertiesDocDbSettingsPropertiesPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**SettingsPropertiesDocDbSettingsProperties)(nil)).Elem() +} + +func (i *settingsPropertiesDocDbSettingsPropertiesPtrType) ToSettingsPropertiesDocDbSettingsPropertiesPtrOutput() SettingsPropertiesDocDbSettingsPropertiesPtrOutput { + return i.ToSettingsPropertiesDocDbSettingsPropertiesPtrOutputWithContext(context.Background()) +} + +func (i *settingsPropertiesDocDbSettingsPropertiesPtrType) ToSettingsPropertiesDocDbSettingsPropertiesPtrOutputWithContext(ctx context.Context) SettingsPropertiesDocDbSettingsPropertiesPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(SettingsPropertiesDocDbSettingsPropertiesPtrOutput) +} + +// DocDbSettings property identifier. +type SettingsPropertiesDocDbSettingsPropertiesOutput struct{ *pulumi.OutputState } + +func (SettingsPropertiesDocDbSettingsPropertiesOutput) ElementType() reflect.Type { + return reflect.TypeOf((*SettingsPropertiesDocDbSettingsProperties)(nil)).Elem() +} + +func (o SettingsPropertiesDocDbSettingsPropertiesOutput) ToSettingsPropertiesDocDbSettingsPropertiesOutput() SettingsPropertiesDocDbSettingsPropertiesOutput { + return o +} + +func (o SettingsPropertiesDocDbSettingsPropertiesOutput) ToSettingsPropertiesDocDbSettingsPropertiesOutputWithContext(ctx context.Context) SettingsPropertiesDocDbSettingsPropertiesOutput { + return o +} + +func (o SettingsPropertiesDocDbSettingsPropertiesOutput) ToSettingsPropertiesDocDbSettingsPropertiesPtrOutput() SettingsPropertiesDocDbSettingsPropertiesPtrOutput { + return o.ToSettingsPropertiesDocDbSettingsPropertiesPtrOutputWithContext(context.Background()) +} + +func (o SettingsPropertiesDocDbSettingsPropertiesOutput) ToSettingsPropertiesDocDbSettingsPropertiesPtrOutputWithContext(ctx context.Context) SettingsPropertiesDocDbSettingsPropertiesPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v SettingsPropertiesDocDbSettingsProperties) *SettingsPropertiesDocDbSettingsProperties { + return &v + }).(SettingsPropertiesDocDbSettingsPropertiesPtrOutput) +} + +func (o SettingsPropertiesDocDbSettingsPropertiesOutput) CertificateArn() pulumi.StringPtrOutput { + return o.ApplyT(func(v SettingsPropertiesDocDbSettingsProperties) *string { return v.CertificateArn }).(pulumi.StringPtrOutput) +} + +func (o SettingsPropertiesDocDbSettingsPropertiesOutput) DatabaseName() pulumi.StringOutput { + return o.ApplyT(func(v SettingsPropertiesDocDbSettingsProperties) string { return v.DatabaseName }).(pulumi.StringOutput) +} + +func (o SettingsPropertiesDocDbSettingsPropertiesOutput) Port() pulumi.IntOutput { + return o.ApplyT(func(v SettingsPropertiesDocDbSettingsProperties) int { return v.Port }).(pulumi.IntOutput) +} + +func (o SettingsPropertiesDocDbSettingsPropertiesOutput) ServerName() pulumi.StringOutput { + return o.ApplyT(func(v SettingsPropertiesDocDbSettingsProperties) string { return v.ServerName }).(pulumi.StringOutput) +} + +func (o SettingsPropertiesDocDbSettingsPropertiesOutput) SslMode() DataProviderMongoDbSslModeValuePtrOutput { + return o.ApplyT(func(v SettingsPropertiesDocDbSettingsProperties) *DataProviderMongoDbSslModeValue { return v.SslMode }).(DataProviderMongoDbSslModeValuePtrOutput) +} + +type SettingsPropertiesDocDbSettingsPropertiesPtrOutput struct{ *pulumi.OutputState } + +func (SettingsPropertiesDocDbSettingsPropertiesPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**SettingsPropertiesDocDbSettingsProperties)(nil)).Elem() +} + +func (o SettingsPropertiesDocDbSettingsPropertiesPtrOutput) ToSettingsPropertiesDocDbSettingsPropertiesPtrOutput() SettingsPropertiesDocDbSettingsPropertiesPtrOutput { + return o +} + +func (o SettingsPropertiesDocDbSettingsPropertiesPtrOutput) ToSettingsPropertiesDocDbSettingsPropertiesPtrOutputWithContext(ctx context.Context) SettingsPropertiesDocDbSettingsPropertiesPtrOutput { + return o +} + +func (o SettingsPropertiesDocDbSettingsPropertiesPtrOutput) Elem() SettingsPropertiesDocDbSettingsPropertiesOutput { + return o.ApplyT(func(v *SettingsPropertiesDocDbSettingsProperties) SettingsPropertiesDocDbSettingsProperties { + if v != nil { + return *v + } + var ret SettingsPropertiesDocDbSettingsProperties + return ret + }).(SettingsPropertiesDocDbSettingsPropertiesOutput) +} + +func (o SettingsPropertiesDocDbSettingsPropertiesPtrOutput) CertificateArn() pulumi.StringPtrOutput { + return o.ApplyT(func(v *SettingsPropertiesDocDbSettingsProperties) *string { + if v == nil { + return nil + } + return v.CertificateArn + }).(pulumi.StringPtrOutput) +} + +func (o SettingsPropertiesDocDbSettingsPropertiesPtrOutput) DatabaseName() pulumi.StringPtrOutput { + return o.ApplyT(func(v *SettingsPropertiesDocDbSettingsProperties) *string { + if v == nil { + return nil + } + return &v.DatabaseName + }).(pulumi.StringPtrOutput) +} + +func (o SettingsPropertiesDocDbSettingsPropertiesPtrOutput) Port() pulumi.IntPtrOutput { + return o.ApplyT(func(v *SettingsPropertiesDocDbSettingsProperties) *int { + if v == nil { + return nil + } + return &v.Port + }).(pulumi.IntPtrOutput) +} + +func (o SettingsPropertiesDocDbSettingsPropertiesPtrOutput) ServerName() pulumi.StringPtrOutput { + return o.ApplyT(func(v *SettingsPropertiesDocDbSettingsProperties) *string { + if v == nil { + return nil + } + return &v.ServerName + }).(pulumi.StringPtrOutput) +} + +func (o SettingsPropertiesDocDbSettingsPropertiesPtrOutput) SslMode() DataProviderMongoDbSslModeValuePtrOutput { + return o.ApplyT(func(v *SettingsPropertiesDocDbSettingsProperties) *DataProviderMongoDbSslModeValue { + if v == nil { + return nil + } + return v.SslMode + }).(DataProviderMongoDbSslModeValuePtrOutput) +} + +// MariaDbSettings property identifier. +type SettingsPropertiesMariaDbSettingsProperties struct { + CertificateArn *string `pulumi:"certificateArn"` + Port int `pulumi:"port"` + ServerName string `pulumi:"serverName"` + SslMode DataProviderDmsSslModeValue `pulumi:"sslMode"` +} + +// SettingsPropertiesMariaDbSettingsPropertiesInput is an input type that accepts SettingsPropertiesMariaDbSettingsPropertiesArgs and SettingsPropertiesMariaDbSettingsPropertiesOutput values. +// You can construct a concrete instance of `SettingsPropertiesMariaDbSettingsPropertiesInput` via: +// +// SettingsPropertiesMariaDbSettingsPropertiesArgs{...} +type SettingsPropertiesMariaDbSettingsPropertiesInput interface { + pulumi.Input + + ToSettingsPropertiesMariaDbSettingsPropertiesOutput() SettingsPropertiesMariaDbSettingsPropertiesOutput + ToSettingsPropertiesMariaDbSettingsPropertiesOutputWithContext(context.Context) SettingsPropertiesMariaDbSettingsPropertiesOutput +} + +// MariaDbSettings property identifier. +type SettingsPropertiesMariaDbSettingsPropertiesArgs struct { + CertificateArn pulumi.StringPtrInput `pulumi:"certificateArn"` + Port pulumi.IntInput `pulumi:"port"` + ServerName pulumi.StringInput `pulumi:"serverName"` + SslMode DataProviderDmsSslModeValueInput `pulumi:"sslMode"` +} + +func (SettingsPropertiesMariaDbSettingsPropertiesArgs) ElementType() reflect.Type { + return reflect.TypeOf((*SettingsPropertiesMariaDbSettingsProperties)(nil)).Elem() +} + +func (i SettingsPropertiesMariaDbSettingsPropertiesArgs) ToSettingsPropertiesMariaDbSettingsPropertiesOutput() SettingsPropertiesMariaDbSettingsPropertiesOutput { + return i.ToSettingsPropertiesMariaDbSettingsPropertiesOutputWithContext(context.Background()) +} + +func (i SettingsPropertiesMariaDbSettingsPropertiesArgs) ToSettingsPropertiesMariaDbSettingsPropertiesOutputWithContext(ctx context.Context) SettingsPropertiesMariaDbSettingsPropertiesOutput { + return pulumi.ToOutputWithContext(ctx, i).(SettingsPropertiesMariaDbSettingsPropertiesOutput) +} + +func (i SettingsPropertiesMariaDbSettingsPropertiesArgs) ToSettingsPropertiesMariaDbSettingsPropertiesPtrOutput() SettingsPropertiesMariaDbSettingsPropertiesPtrOutput { + return i.ToSettingsPropertiesMariaDbSettingsPropertiesPtrOutputWithContext(context.Background()) +} + +func (i SettingsPropertiesMariaDbSettingsPropertiesArgs) ToSettingsPropertiesMariaDbSettingsPropertiesPtrOutputWithContext(ctx context.Context) SettingsPropertiesMariaDbSettingsPropertiesPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(SettingsPropertiesMariaDbSettingsPropertiesOutput).ToSettingsPropertiesMariaDbSettingsPropertiesPtrOutputWithContext(ctx) +} + +// SettingsPropertiesMariaDbSettingsPropertiesPtrInput is an input type that accepts SettingsPropertiesMariaDbSettingsPropertiesArgs, SettingsPropertiesMariaDbSettingsPropertiesPtr and SettingsPropertiesMariaDbSettingsPropertiesPtrOutput values. +// You can construct a concrete instance of `SettingsPropertiesMariaDbSettingsPropertiesPtrInput` via: +// +// SettingsPropertiesMariaDbSettingsPropertiesArgs{...} +// +// or: +// +// nil +type SettingsPropertiesMariaDbSettingsPropertiesPtrInput interface { + pulumi.Input + + ToSettingsPropertiesMariaDbSettingsPropertiesPtrOutput() SettingsPropertiesMariaDbSettingsPropertiesPtrOutput + ToSettingsPropertiesMariaDbSettingsPropertiesPtrOutputWithContext(context.Context) SettingsPropertiesMariaDbSettingsPropertiesPtrOutput +} + +type settingsPropertiesMariaDbSettingsPropertiesPtrType SettingsPropertiesMariaDbSettingsPropertiesArgs + +func SettingsPropertiesMariaDbSettingsPropertiesPtr(v *SettingsPropertiesMariaDbSettingsPropertiesArgs) SettingsPropertiesMariaDbSettingsPropertiesPtrInput { + return (*settingsPropertiesMariaDbSettingsPropertiesPtrType)(v) +} + +func (*settingsPropertiesMariaDbSettingsPropertiesPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**SettingsPropertiesMariaDbSettingsProperties)(nil)).Elem() +} + +func (i *settingsPropertiesMariaDbSettingsPropertiesPtrType) ToSettingsPropertiesMariaDbSettingsPropertiesPtrOutput() SettingsPropertiesMariaDbSettingsPropertiesPtrOutput { + return i.ToSettingsPropertiesMariaDbSettingsPropertiesPtrOutputWithContext(context.Background()) +} + +func (i *settingsPropertiesMariaDbSettingsPropertiesPtrType) ToSettingsPropertiesMariaDbSettingsPropertiesPtrOutputWithContext(ctx context.Context) SettingsPropertiesMariaDbSettingsPropertiesPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(SettingsPropertiesMariaDbSettingsPropertiesPtrOutput) +} + +// MariaDbSettings property identifier. +type SettingsPropertiesMariaDbSettingsPropertiesOutput struct{ *pulumi.OutputState } + +func (SettingsPropertiesMariaDbSettingsPropertiesOutput) ElementType() reflect.Type { + return reflect.TypeOf((*SettingsPropertiesMariaDbSettingsProperties)(nil)).Elem() +} + +func (o SettingsPropertiesMariaDbSettingsPropertiesOutput) ToSettingsPropertiesMariaDbSettingsPropertiesOutput() SettingsPropertiesMariaDbSettingsPropertiesOutput { + return o +} + +func (o SettingsPropertiesMariaDbSettingsPropertiesOutput) ToSettingsPropertiesMariaDbSettingsPropertiesOutputWithContext(ctx context.Context) SettingsPropertiesMariaDbSettingsPropertiesOutput { + return o +} + +func (o SettingsPropertiesMariaDbSettingsPropertiesOutput) ToSettingsPropertiesMariaDbSettingsPropertiesPtrOutput() SettingsPropertiesMariaDbSettingsPropertiesPtrOutput { + return o.ToSettingsPropertiesMariaDbSettingsPropertiesPtrOutputWithContext(context.Background()) +} + +func (o SettingsPropertiesMariaDbSettingsPropertiesOutput) ToSettingsPropertiesMariaDbSettingsPropertiesPtrOutputWithContext(ctx context.Context) SettingsPropertiesMariaDbSettingsPropertiesPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v SettingsPropertiesMariaDbSettingsProperties) *SettingsPropertiesMariaDbSettingsProperties { + return &v + }).(SettingsPropertiesMariaDbSettingsPropertiesPtrOutput) +} + +func (o SettingsPropertiesMariaDbSettingsPropertiesOutput) CertificateArn() pulumi.StringPtrOutput { + return o.ApplyT(func(v SettingsPropertiesMariaDbSettingsProperties) *string { return v.CertificateArn }).(pulumi.StringPtrOutput) +} + +func (o SettingsPropertiesMariaDbSettingsPropertiesOutput) Port() pulumi.IntOutput { + return o.ApplyT(func(v SettingsPropertiesMariaDbSettingsProperties) int { return v.Port }).(pulumi.IntOutput) +} + +func (o SettingsPropertiesMariaDbSettingsPropertiesOutput) ServerName() pulumi.StringOutput { + return o.ApplyT(func(v SettingsPropertiesMariaDbSettingsProperties) string { return v.ServerName }).(pulumi.StringOutput) +} + +func (o SettingsPropertiesMariaDbSettingsPropertiesOutput) SslMode() DataProviderDmsSslModeValueOutput { + return o.ApplyT(func(v SettingsPropertiesMariaDbSettingsProperties) DataProviderDmsSslModeValue { return v.SslMode }).(DataProviderDmsSslModeValueOutput) +} + +type SettingsPropertiesMariaDbSettingsPropertiesPtrOutput struct{ *pulumi.OutputState } + +func (SettingsPropertiesMariaDbSettingsPropertiesPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**SettingsPropertiesMariaDbSettingsProperties)(nil)).Elem() +} + +func (o SettingsPropertiesMariaDbSettingsPropertiesPtrOutput) ToSettingsPropertiesMariaDbSettingsPropertiesPtrOutput() SettingsPropertiesMariaDbSettingsPropertiesPtrOutput { + return o +} + +func (o SettingsPropertiesMariaDbSettingsPropertiesPtrOutput) ToSettingsPropertiesMariaDbSettingsPropertiesPtrOutputWithContext(ctx context.Context) SettingsPropertiesMariaDbSettingsPropertiesPtrOutput { + return o +} + +func (o SettingsPropertiesMariaDbSettingsPropertiesPtrOutput) Elem() SettingsPropertiesMariaDbSettingsPropertiesOutput { + return o.ApplyT(func(v *SettingsPropertiesMariaDbSettingsProperties) SettingsPropertiesMariaDbSettingsProperties { + if v != nil { + return *v + } + var ret SettingsPropertiesMariaDbSettingsProperties + return ret + }).(SettingsPropertiesMariaDbSettingsPropertiesOutput) +} + +func (o SettingsPropertiesMariaDbSettingsPropertiesPtrOutput) CertificateArn() pulumi.StringPtrOutput { + return o.ApplyT(func(v *SettingsPropertiesMariaDbSettingsProperties) *string { + if v == nil { + return nil + } + return v.CertificateArn + }).(pulumi.StringPtrOutput) +} + +func (o SettingsPropertiesMariaDbSettingsPropertiesPtrOutput) Port() pulumi.IntPtrOutput { + return o.ApplyT(func(v *SettingsPropertiesMariaDbSettingsProperties) *int { + if v == nil { + return nil + } + return &v.Port + }).(pulumi.IntPtrOutput) +} + +func (o SettingsPropertiesMariaDbSettingsPropertiesPtrOutput) ServerName() pulumi.StringPtrOutput { + return o.ApplyT(func(v *SettingsPropertiesMariaDbSettingsProperties) *string { + if v == nil { + return nil + } + return &v.ServerName + }).(pulumi.StringPtrOutput) +} + +func (o SettingsPropertiesMariaDbSettingsPropertiesPtrOutput) SslMode() DataProviderDmsSslModeValuePtrOutput { + return o.ApplyT(func(v *SettingsPropertiesMariaDbSettingsProperties) *DataProviderDmsSslModeValue { + if v == nil { + return nil + } + return &v.SslMode + }).(DataProviderDmsSslModeValuePtrOutput) +} + // MicrosoftSqlServerSettings property identifier. type SettingsPropertiesMicrosoftSqlServerSettingsProperties struct { CertificateArn *string `pulumi:"certificateArn"` @@ -1310,6 +1763,249 @@ func (o SettingsPropertiesMicrosoftSqlServerSettingsPropertiesPtrOutput) SslMode }).(DataProviderDmsSslModeValuePtrOutput) } +// MongoDbSettings property identifier. +type SettingsPropertiesMongoDbSettingsProperties struct { + AuthMechanism *DataProviderMongoDbAuthMechanism `pulumi:"authMechanism"` + AuthSource *string `pulumi:"authSource"` + AuthType *DataProviderMongoDbAuthType `pulumi:"authType"` + CertificateArn *string `pulumi:"certificateArn"` + DatabaseName *string `pulumi:"databaseName"` + Port int `pulumi:"port"` + ServerName string `pulumi:"serverName"` + SslMode *DataProviderMongoDbSslModeValue `pulumi:"sslMode"` +} + +// SettingsPropertiesMongoDbSettingsPropertiesInput is an input type that accepts SettingsPropertiesMongoDbSettingsPropertiesArgs and SettingsPropertiesMongoDbSettingsPropertiesOutput values. +// You can construct a concrete instance of `SettingsPropertiesMongoDbSettingsPropertiesInput` via: +// +// SettingsPropertiesMongoDbSettingsPropertiesArgs{...} +type SettingsPropertiesMongoDbSettingsPropertiesInput interface { + pulumi.Input + + ToSettingsPropertiesMongoDbSettingsPropertiesOutput() SettingsPropertiesMongoDbSettingsPropertiesOutput + ToSettingsPropertiesMongoDbSettingsPropertiesOutputWithContext(context.Context) SettingsPropertiesMongoDbSettingsPropertiesOutput +} + +// MongoDbSettings property identifier. +type SettingsPropertiesMongoDbSettingsPropertiesArgs struct { + AuthMechanism DataProviderMongoDbAuthMechanismPtrInput `pulumi:"authMechanism"` + AuthSource pulumi.StringPtrInput `pulumi:"authSource"` + AuthType DataProviderMongoDbAuthTypePtrInput `pulumi:"authType"` + CertificateArn pulumi.StringPtrInput `pulumi:"certificateArn"` + DatabaseName pulumi.StringPtrInput `pulumi:"databaseName"` + Port pulumi.IntInput `pulumi:"port"` + ServerName pulumi.StringInput `pulumi:"serverName"` + SslMode DataProviderMongoDbSslModeValuePtrInput `pulumi:"sslMode"` +} + +func (SettingsPropertiesMongoDbSettingsPropertiesArgs) ElementType() reflect.Type { + return reflect.TypeOf((*SettingsPropertiesMongoDbSettingsProperties)(nil)).Elem() +} + +func (i SettingsPropertiesMongoDbSettingsPropertiesArgs) ToSettingsPropertiesMongoDbSettingsPropertiesOutput() SettingsPropertiesMongoDbSettingsPropertiesOutput { + return i.ToSettingsPropertiesMongoDbSettingsPropertiesOutputWithContext(context.Background()) +} + +func (i SettingsPropertiesMongoDbSettingsPropertiesArgs) ToSettingsPropertiesMongoDbSettingsPropertiesOutputWithContext(ctx context.Context) SettingsPropertiesMongoDbSettingsPropertiesOutput { + return pulumi.ToOutputWithContext(ctx, i).(SettingsPropertiesMongoDbSettingsPropertiesOutput) +} + +func (i SettingsPropertiesMongoDbSettingsPropertiesArgs) ToSettingsPropertiesMongoDbSettingsPropertiesPtrOutput() SettingsPropertiesMongoDbSettingsPropertiesPtrOutput { + return i.ToSettingsPropertiesMongoDbSettingsPropertiesPtrOutputWithContext(context.Background()) +} + +func (i SettingsPropertiesMongoDbSettingsPropertiesArgs) ToSettingsPropertiesMongoDbSettingsPropertiesPtrOutputWithContext(ctx context.Context) SettingsPropertiesMongoDbSettingsPropertiesPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(SettingsPropertiesMongoDbSettingsPropertiesOutput).ToSettingsPropertiesMongoDbSettingsPropertiesPtrOutputWithContext(ctx) +} + +// SettingsPropertiesMongoDbSettingsPropertiesPtrInput is an input type that accepts SettingsPropertiesMongoDbSettingsPropertiesArgs, SettingsPropertiesMongoDbSettingsPropertiesPtr and SettingsPropertiesMongoDbSettingsPropertiesPtrOutput values. +// You can construct a concrete instance of `SettingsPropertiesMongoDbSettingsPropertiesPtrInput` via: +// +// SettingsPropertiesMongoDbSettingsPropertiesArgs{...} +// +// or: +// +// nil +type SettingsPropertiesMongoDbSettingsPropertiesPtrInput interface { + pulumi.Input + + ToSettingsPropertiesMongoDbSettingsPropertiesPtrOutput() SettingsPropertiesMongoDbSettingsPropertiesPtrOutput + ToSettingsPropertiesMongoDbSettingsPropertiesPtrOutputWithContext(context.Context) SettingsPropertiesMongoDbSettingsPropertiesPtrOutput +} + +type settingsPropertiesMongoDbSettingsPropertiesPtrType SettingsPropertiesMongoDbSettingsPropertiesArgs + +func SettingsPropertiesMongoDbSettingsPropertiesPtr(v *SettingsPropertiesMongoDbSettingsPropertiesArgs) SettingsPropertiesMongoDbSettingsPropertiesPtrInput { + return (*settingsPropertiesMongoDbSettingsPropertiesPtrType)(v) +} + +func (*settingsPropertiesMongoDbSettingsPropertiesPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**SettingsPropertiesMongoDbSettingsProperties)(nil)).Elem() +} + +func (i *settingsPropertiesMongoDbSettingsPropertiesPtrType) ToSettingsPropertiesMongoDbSettingsPropertiesPtrOutput() SettingsPropertiesMongoDbSettingsPropertiesPtrOutput { + return i.ToSettingsPropertiesMongoDbSettingsPropertiesPtrOutputWithContext(context.Background()) +} + +func (i *settingsPropertiesMongoDbSettingsPropertiesPtrType) ToSettingsPropertiesMongoDbSettingsPropertiesPtrOutputWithContext(ctx context.Context) SettingsPropertiesMongoDbSettingsPropertiesPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(SettingsPropertiesMongoDbSettingsPropertiesPtrOutput) +} + +// MongoDbSettings property identifier. +type SettingsPropertiesMongoDbSettingsPropertiesOutput struct{ *pulumi.OutputState } + +func (SettingsPropertiesMongoDbSettingsPropertiesOutput) ElementType() reflect.Type { + return reflect.TypeOf((*SettingsPropertiesMongoDbSettingsProperties)(nil)).Elem() +} + +func (o SettingsPropertiesMongoDbSettingsPropertiesOutput) ToSettingsPropertiesMongoDbSettingsPropertiesOutput() SettingsPropertiesMongoDbSettingsPropertiesOutput { + return o +} + +func (o SettingsPropertiesMongoDbSettingsPropertiesOutput) ToSettingsPropertiesMongoDbSettingsPropertiesOutputWithContext(ctx context.Context) SettingsPropertiesMongoDbSettingsPropertiesOutput { + return o +} + +func (o SettingsPropertiesMongoDbSettingsPropertiesOutput) ToSettingsPropertiesMongoDbSettingsPropertiesPtrOutput() SettingsPropertiesMongoDbSettingsPropertiesPtrOutput { + return o.ToSettingsPropertiesMongoDbSettingsPropertiesPtrOutputWithContext(context.Background()) +} + +func (o SettingsPropertiesMongoDbSettingsPropertiesOutput) ToSettingsPropertiesMongoDbSettingsPropertiesPtrOutputWithContext(ctx context.Context) SettingsPropertiesMongoDbSettingsPropertiesPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v SettingsPropertiesMongoDbSettingsProperties) *SettingsPropertiesMongoDbSettingsProperties { + return &v + }).(SettingsPropertiesMongoDbSettingsPropertiesPtrOutput) +} + +func (o SettingsPropertiesMongoDbSettingsPropertiesOutput) AuthMechanism() DataProviderMongoDbAuthMechanismPtrOutput { + return o.ApplyT(func(v SettingsPropertiesMongoDbSettingsProperties) *DataProviderMongoDbAuthMechanism { + return v.AuthMechanism + }).(DataProviderMongoDbAuthMechanismPtrOutput) +} + +func (o SettingsPropertiesMongoDbSettingsPropertiesOutput) AuthSource() pulumi.StringPtrOutput { + return o.ApplyT(func(v SettingsPropertiesMongoDbSettingsProperties) *string { return v.AuthSource }).(pulumi.StringPtrOutput) +} + +func (o SettingsPropertiesMongoDbSettingsPropertiesOutput) AuthType() DataProviderMongoDbAuthTypePtrOutput { + return o.ApplyT(func(v SettingsPropertiesMongoDbSettingsProperties) *DataProviderMongoDbAuthType { return v.AuthType }).(DataProviderMongoDbAuthTypePtrOutput) +} + +func (o SettingsPropertiesMongoDbSettingsPropertiesOutput) CertificateArn() pulumi.StringPtrOutput { + return o.ApplyT(func(v SettingsPropertiesMongoDbSettingsProperties) *string { return v.CertificateArn }).(pulumi.StringPtrOutput) +} + +func (o SettingsPropertiesMongoDbSettingsPropertiesOutput) DatabaseName() pulumi.StringPtrOutput { + return o.ApplyT(func(v SettingsPropertiesMongoDbSettingsProperties) *string { return v.DatabaseName }).(pulumi.StringPtrOutput) +} + +func (o SettingsPropertiesMongoDbSettingsPropertiesOutput) Port() pulumi.IntOutput { + return o.ApplyT(func(v SettingsPropertiesMongoDbSettingsProperties) int { return v.Port }).(pulumi.IntOutput) +} + +func (o SettingsPropertiesMongoDbSettingsPropertiesOutput) ServerName() pulumi.StringOutput { + return o.ApplyT(func(v SettingsPropertiesMongoDbSettingsProperties) string { return v.ServerName }).(pulumi.StringOutput) +} + +func (o SettingsPropertiesMongoDbSettingsPropertiesOutput) SslMode() DataProviderMongoDbSslModeValuePtrOutput { + return o.ApplyT(func(v SettingsPropertiesMongoDbSettingsProperties) *DataProviderMongoDbSslModeValue { return v.SslMode }).(DataProviderMongoDbSslModeValuePtrOutput) +} + +type SettingsPropertiesMongoDbSettingsPropertiesPtrOutput struct{ *pulumi.OutputState } + +func (SettingsPropertiesMongoDbSettingsPropertiesPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**SettingsPropertiesMongoDbSettingsProperties)(nil)).Elem() +} + +func (o SettingsPropertiesMongoDbSettingsPropertiesPtrOutput) ToSettingsPropertiesMongoDbSettingsPropertiesPtrOutput() SettingsPropertiesMongoDbSettingsPropertiesPtrOutput { + return o +} + +func (o SettingsPropertiesMongoDbSettingsPropertiesPtrOutput) ToSettingsPropertiesMongoDbSettingsPropertiesPtrOutputWithContext(ctx context.Context) SettingsPropertiesMongoDbSettingsPropertiesPtrOutput { + return o +} + +func (o SettingsPropertiesMongoDbSettingsPropertiesPtrOutput) Elem() SettingsPropertiesMongoDbSettingsPropertiesOutput { + return o.ApplyT(func(v *SettingsPropertiesMongoDbSettingsProperties) SettingsPropertiesMongoDbSettingsProperties { + if v != nil { + return *v + } + var ret SettingsPropertiesMongoDbSettingsProperties + return ret + }).(SettingsPropertiesMongoDbSettingsPropertiesOutput) +} + +func (o SettingsPropertiesMongoDbSettingsPropertiesPtrOutput) AuthMechanism() DataProviderMongoDbAuthMechanismPtrOutput { + return o.ApplyT(func(v *SettingsPropertiesMongoDbSettingsProperties) *DataProviderMongoDbAuthMechanism { + if v == nil { + return nil + } + return v.AuthMechanism + }).(DataProviderMongoDbAuthMechanismPtrOutput) +} + +func (o SettingsPropertiesMongoDbSettingsPropertiesPtrOutput) AuthSource() pulumi.StringPtrOutput { + return o.ApplyT(func(v *SettingsPropertiesMongoDbSettingsProperties) *string { + if v == nil { + return nil + } + return v.AuthSource + }).(pulumi.StringPtrOutput) +} + +func (o SettingsPropertiesMongoDbSettingsPropertiesPtrOutput) AuthType() DataProviderMongoDbAuthTypePtrOutput { + return o.ApplyT(func(v *SettingsPropertiesMongoDbSettingsProperties) *DataProviderMongoDbAuthType { + if v == nil { + return nil + } + return v.AuthType + }).(DataProviderMongoDbAuthTypePtrOutput) +} + +func (o SettingsPropertiesMongoDbSettingsPropertiesPtrOutput) CertificateArn() pulumi.StringPtrOutput { + return o.ApplyT(func(v *SettingsPropertiesMongoDbSettingsProperties) *string { + if v == nil { + return nil + } + return v.CertificateArn + }).(pulumi.StringPtrOutput) +} + +func (o SettingsPropertiesMongoDbSettingsPropertiesPtrOutput) DatabaseName() pulumi.StringPtrOutput { + return o.ApplyT(func(v *SettingsPropertiesMongoDbSettingsProperties) *string { + if v == nil { + return nil + } + return v.DatabaseName + }).(pulumi.StringPtrOutput) +} + +func (o SettingsPropertiesMongoDbSettingsPropertiesPtrOutput) Port() pulumi.IntPtrOutput { + return o.ApplyT(func(v *SettingsPropertiesMongoDbSettingsProperties) *int { + if v == nil { + return nil + } + return &v.Port + }).(pulumi.IntPtrOutput) +} + +func (o SettingsPropertiesMongoDbSettingsPropertiesPtrOutput) ServerName() pulumi.StringPtrOutput { + return o.ApplyT(func(v *SettingsPropertiesMongoDbSettingsProperties) *string { + if v == nil { + return nil + } + return &v.ServerName + }).(pulumi.StringPtrOutput) +} + +func (o SettingsPropertiesMongoDbSettingsPropertiesPtrOutput) SslMode() DataProviderMongoDbSslModeValuePtrOutput { + return o.ApplyT(func(v *SettingsPropertiesMongoDbSettingsProperties) *DataProviderMongoDbSslModeValue { + if v == nil { + return nil + } + return v.SslMode + }).(DataProviderMongoDbSslModeValuePtrOutput) +} + // MySqlSettings property identifier. type SettingsPropertiesMySqlSettingsProperties struct { CertificateArn *string `pulumi:"certificateArn"` @@ -1964,6 +2660,172 @@ func (o SettingsPropertiesPostgreSqlSettingsPropertiesPtrOutput) SslMode() DataP }).(DataProviderDmsSslModeValuePtrOutput) } +// RedshiftSettings property identifier. +type SettingsPropertiesRedshiftSettingsProperties struct { + DatabaseName string `pulumi:"databaseName"` + Port int `pulumi:"port"` + ServerName string `pulumi:"serverName"` +} + +// SettingsPropertiesRedshiftSettingsPropertiesInput is an input type that accepts SettingsPropertiesRedshiftSettingsPropertiesArgs and SettingsPropertiesRedshiftSettingsPropertiesOutput values. +// You can construct a concrete instance of `SettingsPropertiesRedshiftSettingsPropertiesInput` via: +// +// SettingsPropertiesRedshiftSettingsPropertiesArgs{...} +type SettingsPropertiesRedshiftSettingsPropertiesInput interface { + pulumi.Input + + ToSettingsPropertiesRedshiftSettingsPropertiesOutput() SettingsPropertiesRedshiftSettingsPropertiesOutput + ToSettingsPropertiesRedshiftSettingsPropertiesOutputWithContext(context.Context) SettingsPropertiesRedshiftSettingsPropertiesOutput +} + +// RedshiftSettings property identifier. +type SettingsPropertiesRedshiftSettingsPropertiesArgs struct { + DatabaseName pulumi.StringInput `pulumi:"databaseName"` + Port pulumi.IntInput `pulumi:"port"` + ServerName pulumi.StringInput `pulumi:"serverName"` +} + +func (SettingsPropertiesRedshiftSettingsPropertiesArgs) ElementType() reflect.Type { + return reflect.TypeOf((*SettingsPropertiesRedshiftSettingsProperties)(nil)).Elem() +} + +func (i SettingsPropertiesRedshiftSettingsPropertiesArgs) ToSettingsPropertiesRedshiftSettingsPropertiesOutput() SettingsPropertiesRedshiftSettingsPropertiesOutput { + return i.ToSettingsPropertiesRedshiftSettingsPropertiesOutputWithContext(context.Background()) +} + +func (i SettingsPropertiesRedshiftSettingsPropertiesArgs) ToSettingsPropertiesRedshiftSettingsPropertiesOutputWithContext(ctx context.Context) SettingsPropertiesRedshiftSettingsPropertiesOutput { + return pulumi.ToOutputWithContext(ctx, i).(SettingsPropertiesRedshiftSettingsPropertiesOutput) +} + +func (i SettingsPropertiesRedshiftSettingsPropertiesArgs) ToSettingsPropertiesRedshiftSettingsPropertiesPtrOutput() SettingsPropertiesRedshiftSettingsPropertiesPtrOutput { + return i.ToSettingsPropertiesRedshiftSettingsPropertiesPtrOutputWithContext(context.Background()) +} + +func (i SettingsPropertiesRedshiftSettingsPropertiesArgs) ToSettingsPropertiesRedshiftSettingsPropertiesPtrOutputWithContext(ctx context.Context) SettingsPropertiesRedshiftSettingsPropertiesPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(SettingsPropertiesRedshiftSettingsPropertiesOutput).ToSettingsPropertiesRedshiftSettingsPropertiesPtrOutputWithContext(ctx) +} + +// SettingsPropertiesRedshiftSettingsPropertiesPtrInput is an input type that accepts SettingsPropertiesRedshiftSettingsPropertiesArgs, SettingsPropertiesRedshiftSettingsPropertiesPtr and SettingsPropertiesRedshiftSettingsPropertiesPtrOutput values. +// You can construct a concrete instance of `SettingsPropertiesRedshiftSettingsPropertiesPtrInput` via: +// +// SettingsPropertiesRedshiftSettingsPropertiesArgs{...} +// +// or: +// +// nil +type SettingsPropertiesRedshiftSettingsPropertiesPtrInput interface { + pulumi.Input + + ToSettingsPropertiesRedshiftSettingsPropertiesPtrOutput() SettingsPropertiesRedshiftSettingsPropertiesPtrOutput + ToSettingsPropertiesRedshiftSettingsPropertiesPtrOutputWithContext(context.Context) SettingsPropertiesRedshiftSettingsPropertiesPtrOutput +} + +type settingsPropertiesRedshiftSettingsPropertiesPtrType SettingsPropertiesRedshiftSettingsPropertiesArgs + +func SettingsPropertiesRedshiftSettingsPropertiesPtr(v *SettingsPropertiesRedshiftSettingsPropertiesArgs) SettingsPropertiesRedshiftSettingsPropertiesPtrInput { + return (*settingsPropertiesRedshiftSettingsPropertiesPtrType)(v) +} + +func (*settingsPropertiesRedshiftSettingsPropertiesPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**SettingsPropertiesRedshiftSettingsProperties)(nil)).Elem() +} + +func (i *settingsPropertiesRedshiftSettingsPropertiesPtrType) ToSettingsPropertiesRedshiftSettingsPropertiesPtrOutput() SettingsPropertiesRedshiftSettingsPropertiesPtrOutput { + return i.ToSettingsPropertiesRedshiftSettingsPropertiesPtrOutputWithContext(context.Background()) +} + +func (i *settingsPropertiesRedshiftSettingsPropertiesPtrType) ToSettingsPropertiesRedshiftSettingsPropertiesPtrOutputWithContext(ctx context.Context) SettingsPropertiesRedshiftSettingsPropertiesPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(SettingsPropertiesRedshiftSettingsPropertiesPtrOutput) +} + +// RedshiftSettings property identifier. +type SettingsPropertiesRedshiftSettingsPropertiesOutput struct{ *pulumi.OutputState } + +func (SettingsPropertiesRedshiftSettingsPropertiesOutput) ElementType() reflect.Type { + return reflect.TypeOf((*SettingsPropertiesRedshiftSettingsProperties)(nil)).Elem() +} + +func (o SettingsPropertiesRedshiftSettingsPropertiesOutput) ToSettingsPropertiesRedshiftSettingsPropertiesOutput() SettingsPropertiesRedshiftSettingsPropertiesOutput { + return o +} + +func (o SettingsPropertiesRedshiftSettingsPropertiesOutput) ToSettingsPropertiesRedshiftSettingsPropertiesOutputWithContext(ctx context.Context) SettingsPropertiesRedshiftSettingsPropertiesOutput { + return o +} + +func (o SettingsPropertiesRedshiftSettingsPropertiesOutput) ToSettingsPropertiesRedshiftSettingsPropertiesPtrOutput() SettingsPropertiesRedshiftSettingsPropertiesPtrOutput { + return o.ToSettingsPropertiesRedshiftSettingsPropertiesPtrOutputWithContext(context.Background()) +} + +func (o SettingsPropertiesRedshiftSettingsPropertiesOutput) ToSettingsPropertiesRedshiftSettingsPropertiesPtrOutputWithContext(ctx context.Context) SettingsPropertiesRedshiftSettingsPropertiesPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v SettingsPropertiesRedshiftSettingsProperties) *SettingsPropertiesRedshiftSettingsProperties { + return &v + }).(SettingsPropertiesRedshiftSettingsPropertiesPtrOutput) +} + +func (o SettingsPropertiesRedshiftSettingsPropertiesOutput) DatabaseName() pulumi.StringOutput { + return o.ApplyT(func(v SettingsPropertiesRedshiftSettingsProperties) string { return v.DatabaseName }).(pulumi.StringOutput) +} + +func (o SettingsPropertiesRedshiftSettingsPropertiesOutput) Port() pulumi.IntOutput { + return o.ApplyT(func(v SettingsPropertiesRedshiftSettingsProperties) int { return v.Port }).(pulumi.IntOutput) +} + +func (o SettingsPropertiesRedshiftSettingsPropertiesOutput) ServerName() pulumi.StringOutput { + return o.ApplyT(func(v SettingsPropertiesRedshiftSettingsProperties) string { return v.ServerName }).(pulumi.StringOutput) +} + +type SettingsPropertiesRedshiftSettingsPropertiesPtrOutput struct{ *pulumi.OutputState } + +func (SettingsPropertiesRedshiftSettingsPropertiesPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**SettingsPropertiesRedshiftSettingsProperties)(nil)).Elem() +} + +func (o SettingsPropertiesRedshiftSettingsPropertiesPtrOutput) ToSettingsPropertiesRedshiftSettingsPropertiesPtrOutput() SettingsPropertiesRedshiftSettingsPropertiesPtrOutput { + return o +} + +func (o SettingsPropertiesRedshiftSettingsPropertiesPtrOutput) ToSettingsPropertiesRedshiftSettingsPropertiesPtrOutputWithContext(ctx context.Context) SettingsPropertiesRedshiftSettingsPropertiesPtrOutput { + return o +} + +func (o SettingsPropertiesRedshiftSettingsPropertiesPtrOutput) Elem() SettingsPropertiesRedshiftSettingsPropertiesOutput { + return o.ApplyT(func(v *SettingsPropertiesRedshiftSettingsProperties) SettingsPropertiesRedshiftSettingsProperties { + if v != nil { + return *v + } + var ret SettingsPropertiesRedshiftSettingsProperties + return ret + }).(SettingsPropertiesRedshiftSettingsPropertiesOutput) +} + +func (o SettingsPropertiesRedshiftSettingsPropertiesPtrOutput) DatabaseName() pulumi.StringPtrOutput { + return o.ApplyT(func(v *SettingsPropertiesRedshiftSettingsProperties) *string { + if v == nil { + return nil + } + return &v.DatabaseName + }).(pulumi.StringPtrOutput) +} + +func (o SettingsPropertiesRedshiftSettingsPropertiesPtrOutput) Port() pulumi.IntPtrOutput { + return o.ApplyT(func(v *SettingsPropertiesRedshiftSettingsProperties) *int { + if v == nil { + return nil + } + return &v.Port + }).(pulumi.IntPtrOutput) +} + +func (o SettingsPropertiesRedshiftSettingsPropertiesPtrOutput) ServerName() pulumi.StringPtrOutput { + return o.ApplyT(func(v *SettingsPropertiesRedshiftSettingsProperties) *string { + if v == nil { + return nil + } + return &v.ServerName + }).(pulumi.StringPtrOutput) +} + func init() { pulumi.RegisterInputType(reflect.TypeOf((*DataMigrationSettingsInput)(nil)).Elem(), DataMigrationSettingsArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*DataMigrationSettingsPtrInput)(nil)).Elem(), DataMigrationSettingsArgs{}) @@ -1976,14 +2838,22 @@ func init() { pulumi.RegisterInputType(reflect.TypeOf((*SchemaConversionApplicationAttributesPropertiesPtrInput)(nil)).Elem(), SchemaConversionApplicationAttributesPropertiesArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*SettingsPropertiesInput)(nil)).Elem(), SettingsPropertiesArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*SettingsPropertiesPtrInput)(nil)).Elem(), SettingsPropertiesArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*SettingsPropertiesDocDbSettingsPropertiesInput)(nil)).Elem(), SettingsPropertiesDocDbSettingsPropertiesArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*SettingsPropertiesDocDbSettingsPropertiesPtrInput)(nil)).Elem(), SettingsPropertiesDocDbSettingsPropertiesArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*SettingsPropertiesMariaDbSettingsPropertiesInput)(nil)).Elem(), SettingsPropertiesMariaDbSettingsPropertiesArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*SettingsPropertiesMariaDbSettingsPropertiesPtrInput)(nil)).Elem(), SettingsPropertiesMariaDbSettingsPropertiesArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*SettingsPropertiesMicrosoftSqlServerSettingsPropertiesInput)(nil)).Elem(), SettingsPropertiesMicrosoftSqlServerSettingsPropertiesArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*SettingsPropertiesMicrosoftSqlServerSettingsPropertiesPtrInput)(nil)).Elem(), SettingsPropertiesMicrosoftSqlServerSettingsPropertiesArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*SettingsPropertiesMongoDbSettingsPropertiesInput)(nil)).Elem(), SettingsPropertiesMongoDbSettingsPropertiesArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*SettingsPropertiesMongoDbSettingsPropertiesPtrInput)(nil)).Elem(), SettingsPropertiesMongoDbSettingsPropertiesArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*SettingsPropertiesMySqlSettingsPropertiesInput)(nil)).Elem(), SettingsPropertiesMySqlSettingsPropertiesArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*SettingsPropertiesMySqlSettingsPropertiesPtrInput)(nil)).Elem(), SettingsPropertiesMySqlSettingsPropertiesArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*SettingsPropertiesOracleSettingsPropertiesInput)(nil)).Elem(), SettingsPropertiesOracleSettingsPropertiesArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*SettingsPropertiesOracleSettingsPropertiesPtrInput)(nil)).Elem(), SettingsPropertiesOracleSettingsPropertiesArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*SettingsPropertiesPostgreSqlSettingsPropertiesInput)(nil)).Elem(), SettingsPropertiesPostgreSqlSettingsPropertiesArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*SettingsPropertiesPostgreSqlSettingsPropertiesPtrInput)(nil)).Elem(), SettingsPropertiesPostgreSqlSettingsPropertiesArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*SettingsPropertiesRedshiftSettingsPropertiesInput)(nil)).Elem(), SettingsPropertiesRedshiftSettingsPropertiesArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*SettingsPropertiesRedshiftSettingsPropertiesPtrInput)(nil)).Elem(), SettingsPropertiesRedshiftSettingsPropertiesArgs{}) pulumi.RegisterOutputType(DataMigrationSettingsOutput{}) pulumi.RegisterOutputType(DataMigrationSettingsPtrOutput{}) pulumi.RegisterOutputType(DataMigrationSourceDataSettingsOutput{}) @@ -1996,12 +2866,20 @@ func init() { pulumi.RegisterOutputType(SchemaConversionApplicationAttributesPropertiesPtrOutput{}) pulumi.RegisterOutputType(SettingsPropertiesOutput{}) pulumi.RegisterOutputType(SettingsPropertiesPtrOutput{}) + pulumi.RegisterOutputType(SettingsPropertiesDocDbSettingsPropertiesOutput{}) + pulumi.RegisterOutputType(SettingsPropertiesDocDbSettingsPropertiesPtrOutput{}) + pulumi.RegisterOutputType(SettingsPropertiesMariaDbSettingsPropertiesOutput{}) + pulumi.RegisterOutputType(SettingsPropertiesMariaDbSettingsPropertiesPtrOutput{}) pulumi.RegisterOutputType(SettingsPropertiesMicrosoftSqlServerSettingsPropertiesOutput{}) pulumi.RegisterOutputType(SettingsPropertiesMicrosoftSqlServerSettingsPropertiesPtrOutput{}) + pulumi.RegisterOutputType(SettingsPropertiesMongoDbSettingsPropertiesOutput{}) + pulumi.RegisterOutputType(SettingsPropertiesMongoDbSettingsPropertiesPtrOutput{}) pulumi.RegisterOutputType(SettingsPropertiesMySqlSettingsPropertiesOutput{}) pulumi.RegisterOutputType(SettingsPropertiesMySqlSettingsPropertiesPtrOutput{}) pulumi.RegisterOutputType(SettingsPropertiesOracleSettingsPropertiesOutput{}) pulumi.RegisterOutputType(SettingsPropertiesOracleSettingsPropertiesPtrOutput{}) pulumi.RegisterOutputType(SettingsPropertiesPostgreSqlSettingsPropertiesOutput{}) pulumi.RegisterOutputType(SettingsPropertiesPostgreSqlSettingsPropertiesPtrOutput{}) + pulumi.RegisterOutputType(SettingsPropertiesRedshiftSettingsPropertiesOutput{}) + pulumi.RegisterOutputType(SettingsPropertiesRedshiftSettingsPropertiesPtrOutput{}) } diff --git a/sdk/go/aws/dynamodb/getGlobalTable.go b/sdk/go/aws/dynamodb/getGlobalTable.go index c97171164c..38d9e9913c 100644 --- a/sdk/go/aws/dynamodb/getGlobalTable.go +++ b/sdk/go/aws/dynamodb/getGlobalTable.go @@ -44,7 +44,8 @@ type LookupGlobalTableResult struct { // Global secondary indexes to be created on the global table. You can create up to 20 global secondary indexes. Each replica in your global table will have the same global secondary index settings. You can only create or delete one global secondary index in a single stack operation. // // Since the backfilling of an index could take a long time, CloudFormation does not wait for the index to become active. If a stack operation rolls back, CloudFormation might not delete an index that has been added. In that case, you will need to delete the index manually. - GlobalSecondaryIndexes []GlobalTableGlobalSecondaryIndex `pulumi:"globalSecondaryIndexes"` + GlobalSecondaryIndexes []GlobalTableGlobalSecondaryIndex `pulumi:"globalSecondaryIndexes"` + // Represents the settings used to enable point in time recovery. PointInTimeRecoverySpecification *GlobalTablePointInTimeRecoverySpecification `pulumi:"pointInTimeRecoverySpecification"` // Specifies the list of replicas for your global table. The list must contain at least one element, the region where the stack defining the global table is deployed. For example, if you define your table in a stack deployed to us-east-1, you must have an entry in `Replicas` with the region us-east-1. You cannot remove the replica in the stack region. // @@ -135,6 +136,7 @@ func (o LookupGlobalTableResultOutput) GlobalSecondaryIndexes() GlobalTableGloba return o.ApplyT(func(v LookupGlobalTableResult) []GlobalTableGlobalSecondaryIndex { return v.GlobalSecondaryIndexes }).(GlobalTableGlobalSecondaryIndexArrayOutput) } +// Represents the settings used to enable point in time recovery. func (o LookupGlobalTableResultOutput) PointInTimeRecoverySpecification() GlobalTablePointInTimeRecoverySpecificationPtrOutput { return o.ApplyT(func(v LookupGlobalTableResult) *GlobalTablePointInTimeRecoverySpecification { return v.PointInTimeRecoverySpecification diff --git a/sdk/go/aws/dynamodb/globalTable.go b/sdk/go/aws/dynamodb/globalTable.go index 51721368c9..518083b19b 100644 --- a/sdk/go/aws/dynamodb/globalTable.go +++ b/sdk/go/aws/dynamodb/globalTable.go @@ -34,7 +34,8 @@ type GlobalTable struct { // Specifies the attributes that make up the primary key for the table. The attributes in the `KeySchema` property must also be defined in the `AttributeDefinitions` property. KeySchema GlobalTableKeySchemaArrayOutput `pulumi:"keySchema"` // Local secondary indexes to be created on the table. You can create up to five local secondary indexes. Each index is scoped to a given hash key value. The size of each hash key can be up to 10 gigabytes. Each replica in your global table will have the same local secondary index settings. - LocalSecondaryIndexes GlobalTableLocalSecondaryIndexArrayOutput `pulumi:"localSecondaryIndexes"` + LocalSecondaryIndexes GlobalTableLocalSecondaryIndexArrayOutput `pulumi:"localSecondaryIndexes"` + // Represents the settings used to enable point in time recovery. PointInTimeRecoverySpecification GlobalTablePointInTimeRecoverySpecificationPtrOutput `pulumi:"pointInTimeRecoverySpecification"` // Specifies the list of replicas for your global table. The list must contain at least one element, the region where the stack defining the global table is deployed. For example, if you define your table in a stack deployed to us-east-1, you must have an entry in `Replicas` with the region us-east-1. You cannot remove the replica in the stack region. // @@ -139,7 +140,8 @@ type globalTableArgs struct { // Specifies the attributes that make up the primary key for the table. The attributes in the `KeySchema` property must also be defined in the `AttributeDefinitions` property. KeySchema []GlobalTableKeySchema `pulumi:"keySchema"` // Local secondary indexes to be created on the table. You can create up to five local secondary indexes. Each index is scoped to a given hash key value. The size of each hash key can be up to 10 gigabytes. Each replica in your global table will have the same local secondary index settings. - LocalSecondaryIndexes []GlobalTableLocalSecondaryIndex `pulumi:"localSecondaryIndexes"` + LocalSecondaryIndexes []GlobalTableLocalSecondaryIndex `pulumi:"localSecondaryIndexes"` + // Represents the settings used to enable point in time recovery. PointInTimeRecoverySpecification *GlobalTablePointInTimeRecoverySpecification `pulumi:"pointInTimeRecoverySpecification"` // Specifies the list of replicas for your global table. The list must contain at least one element, the region where the stack defining the global table is deployed. For example, if you define your table in a stack deployed to us-east-1, you must have an entry in `Replicas` with the region us-east-1. You cannot remove the replica in the stack region. // @@ -185,7 +187,8 @@ type GlobalTableArgs struct { // Specifies the attributes that make up the primary key for the table. The attributes in the `KeySchema` property must also be defined in the `AttributeDefinitions` property. KeySchema GlobalTableKeySchemaArrayInput // Local secondary indexes to be created on the table. You can create up to five local secondary indexes. Each index is scoped to a given hash key value. The size of each hash key can be up to 10 gigabytes. Each replica in your global table will have the same local secondary index settings. - LocalSecondaryIndexes GlobalTableLocalSecondaryIndexArrayInput + LocalSecondaryIndexes GlobalTableLocalSecondaryIndexArrayInput + // Represents the settings used to enable point in time recovery. PointInTimeRecoverySpecification GlobalTablePointInTimeRecoverySpecificationPtrInput // Specifies the list of replicas for your global table. The list must contain at least one element, the region where the stack defining the global table is deployed. For example, if you define your table in a stack deployed to us-east-1, you must have an entry in `Replicas` with the region us-east-1. You cannot remove the replica in the stack region. // @@ -287,6 +290,7 @@ func (o GlobalTableOutput) LocalSecondaryIndexes() GlobalTableLocalSecondaryInde return o.ApplyT(func(v *GlobalTable) GlobalTableLocalSecondaryIndexArrayOutput { return v.LocalSecondaryIndexes }).(GlobalTableLocalSecondaryIndexArrayOutput) } +// Represents the settings used to enable point in time recovery. func (o GlobalTableOutput) PointInTimeRecoverySpecification() GlobalTablePointInTimeRecoverySpecificationPtrOutput { return o.ApplyT(func(v *GlobalTable) GlobalTablePointInTimeRecoverySpecificationPtrOutput { return v.PointInTimeRecoverySpecification diff --git a/sdk/go/aws/iot/pulumiTypes.go b/sdk/go/aws/iot/pulumiTypes.go index 5ea49653ac..e5dc57ca34 100644 --- a/sdk/go/aws/iot/pulumiTypes.go +++ b/sdk/go/aws/iot/pulumiTypes.go @@ -2164,9 +2164,11 @@ func (o DomainConfigurationClientCertificateConfigPtrOutput) ClientCertificateCa type DomainConfigurationServerCertificateConfig struct { // A Boolean value that indicates whether Online Certificate Status Protocol (OCSP) server certificate check is enabled or not. For more information, see [Configurable endpoints](https://docs.aws.amazon.com//iot/latest/developerguide/iot-custom-endpoints-configurable.html) from the AWS IoT Core Developer Guide. - EnableOcspCheck *bool `pulumi:"enableOcspCheck"` + EnableOcspCheck *bool `pulumi:"enableOcspCheck"` + // The Amazon Resource Name (ARN) for an X.509 certificate stored in ACM. If provided, AWS IoT Core will use this certificate to validate the signature of the received OCSP response. The OCSP responder must sign responses using either this authorized responder certificate or the issuing certificate, depending on whether the ARN is provided or not. The certificate must be in the same account and region as the domain configuration. OcspAuthorizedResponderArn *string `pulumi:"ocspAuthorizedResponderArn"` - OcspLambdaArn *string `pulumi:"ocspLambdaArn"` + // The Amazon Resource Name (ARN) for a Lambda function that acts as a Request for Comments (RFC) 6960-compliant Online Certificate Status Protocol (OCSP) responder, supporting basic OCSP responses. The Lambda function accepts a base64-encoding of the OCSP request in the Distinguished Encoding Rules (DER) format. The Lambda function's response is also a base64-encoded OCSP response in the DER format. The response size must not exceed 4 kilobytes (KiB). The Lambda function must be in the same account and region as the domain configuration. + OcspLambdaArn *string `pulumi:"ocspLambdaArn"` } // DomainConfigurationServerCertificateConfigInput is an input type that accepts DomainConfigurationServerCertificateConfigArgs and DomainConfigurationServerCertificateConfigOutput values. @@ -2182,9 +2184,11 @@ type DomainConfigurationServerCertificateConfigInput interface { type DomainConfigurationServerCertificateConfigArgs struct { // A Boolean value that indicates whether Online Certificate Status Protocol (OCSP) server certificate check is enabled or not. For more information, see [Configurable endpoints](https://docs.aws.amazon.com//iot/latest/developerguide/iot-custom-endpoints-configurable.html) from the AWS IoT Core Developer Guide. - EnableOcspCheck pulumi.BoolPtrInput `pulumi:"enableOcspCheck"` + EnableOcspCheck pulumi.BoolPtrInput `pulumi:"enableOcspCheck"` + // The Amazon Resource Name (ARN) for an X.509 certificate stored in ACM. If provided, AWS IoT Core will use this certificate to validate the signature of the received OCSP response. The OCSP responder must sign responses using either this authorized responder certificate or the issuing certificate, depending on whether the ARN is provided or not. The certificate must be in the same account and region as the domain configuration. OcspAuthorizedResponderArn pulumi.StringPtrInput `pulumi:"ocspAuthorizedResponderArn"` - OcspLambdaArn pulumi.StringPtrInput `pulumi:"ocspLambdaArn"` + // The Amazon Resource Name (ARN) for a Lambda function that acts as a Request for Comments (RFC) 6960-compliant Online Certificate Status Protocol (OCSP) responder, supporting basic OCSP responses. The Lambda function accepts a base64-encoding of the OCSP request in the Distinguished Encoding Rules (DER) format. The Lambda function's response is also a base64-encoded OCSP response in the DER format. The response size must not exceed 4 kilobytes (KiB). The Lambda function must be in the same account and region as the domain configuration. + OcspLambdaArn pulumi.StringPtrInput `pulumi:"ocspLambdaArn"` } func (DomainConfigurationServerCertificateConfigArgs) ElementType() reflect.Type { @@ -2269,10 +2273,12 @@ func (o DomainConfigurationServerCertificateConfigOutput) EnableOcspCheck() pulu return o.ApplyT(func(v DomainConfigurationServerCertificateConfig) *bool { return v.EnableOcspCheck }).(pulumi.BoolPtrOutput) } +// The Amazon Resource Name (ARN) for an X.509 certificate stored in ACM. If provided, AWS IoT Core will use this certificate to validate the signature of the received OCSP response. The OCSP responder must sign responses using either this authorized responder certificate or the issuing certificate, depending on whether the ARN is provided or not. The certificate must be in the same account and region as the domain configuration. func (o DomainConfigurationServerCertificateConfigOutput) OcspAuthorizedResponderArn() pulumi.StringPtrOutput { return o.ApplyT(func(v DomainConfigurationServerCertificateConfig) *string { return v.OcspAuthorizedResponderArn }).(pulumi.StringPtrOutput) } +// The Amazon Resource Name (ARN) for a Lambda function that acts as a Request for Comments (RFC) 6960-compliant Online Certificate Status Protocol (OCSP) responder, supporting basic OCSP responses. The Lambda function accepts a base64-encoding of the OCSP request in the Distinguished Encoding Rules (DER) format. The Lambda function's response is also a base64-encoded OCSP response in the DER format. The response size must not exceed 4 kilobytes (KiB). The Lambda function must be in the same account and region as the domain configuration. func (o DomainConfigurationServerCertificateConfigOutput) OcspLambdaArn() pulumi.StringPtrOutput { return o.ApplyT(func(v DomainConfigurationServerCertificateConfig) *string { return v.OcspLambdaArn }).(pulumi.StringPtrOutput) } @@ -2311,6 +2317,7 @@ func (o DomainConfigurationServerCertificateConfigPtrOutput) EnableOcspCheck() p }).(pulumi.BoolPtrOutput) } +// The Amazon Resource Name (ARN) for an X.509 certificate stored in ACM. If provided, AWS IoT Core will use this certificate to validate the signature of the received OCSP response. The OCSP responder must sign responses using either this authorized responder certificate or the issuing certificate, depending on whether the ARN is provided or not. The certificate must be in the same account and region as the domain configuration. func (o DomainConfigurationServerCertificateConfigPtrOutput) OcspAuthorizedResponderArn() pulumi.StringPtrOutput { return o.ApplyT(func(v *DomainConfigurationServerCertificateConfig) *string { if v == nil { @@ -2320,6 +2327,7 @@ func (o DomainConfigurationServerCertificateConfigPtrOutput) OcspAuthorizedRespo }).(pulumi.StringPtrOutput) } +// The Amazon Resource Name (ARN) for a Lambda function that acts as a Request for Comments (RFC) 6960-compliant Online Certificate Status Protocol (OCSP) responder, supporting basic OCSP responses. The Lambda function accepts a base64-encoding of the OCSP request in the Distinguished Encoding Rules (DER) format. The Lambda function's response is also a base64-encoded OCSP response in the DER format. The response size must not exceed 4 kilobytes (KiB). The Lambda function must be in the same account and region as the domain configuration. func (o DomainConfigurationServerCertificateConfigPtrOutput) OcspLambdaArn() pulumi.StringPtrOutput { return o.ApplyT(func(v *DomainConfigurationServerCertificateConfig) *string { if v == nil { diff --git a/sdk/go/aws/synthetics/pulumiTypes.go b/sdk/go/aws/synthetics/pulumiTypes.go index cc73fb4edd..300f0406cf 100644 --- a/sdk/go/aws/synthetics/pulumiTypes.go +++ b/sdk/go/aws/synthetics/pulumiTypes.go @@ -1089,6 +1089,8 @@ func (o CanaryVisualReferencePtrOutput) BaseScreenshots() CanaryBaseScreenshotAr } type CanaryVpcConfig struct { + // Allow outbound IPv6 traffic on VPC canaries that are connected to dual-stack subnets if set to true + Ipv6AllowedForDualStack *bool `pulumi:"ipv6AllowedForDualStack"` // The IDs of the security groups for this canary. SecurityGroupIds []string `pulumi:"securityGroupIds"` // The IDs of the subnets where this canary is to run. @@ -1109,6 +1111,8 @@ type CanaryVpcConfigInput interface { } type CanaryVpcConfigArgs struct { + // Allow outbound IPv6 traffic on VPC canaries that are connected to dual-stack subnets if set to true + Ipv6AllowedForDualStack pulumi.BoolPtrInput `pulumi:"ipv6AllowedForDualStack"` // The IDs of the security groups for this canary. SecurityGroupIds pulumi.StringArrayInput `pulumi:"securityGroupIds"` // The IDs of the subnets where this canary is to run. @@ -1194,6 +1198,11 @@ func (o CanaryVpcConfigOutput) ToCanaryVpcConfigPtrOutputWithContext(ctx context }).(CanaryVpcConfigPtrOutput) } +// Allow outbound IPv6 traffic on VPC canaries that are connected to dual-stack subnets if set to true +func (o CanaryVpcConfigOutput) Ipv6AllowedForDualStack() pulumi.BoolPtrOutput { + return o.ApplyT(func(v CanaryVpcConfig) *bool { return v.Ipv6AllowedForDualStack }).(pulumi.BoolPtrOutput) +} + // The IDs of the security groups for this canary. func (o CanaryVpcConfigOutput) SecurityGroupIds() pulumi.StringArrayOutput { return o.ApplyT(func(v CanaryVpcConfig) []string { return v.SecurityGroupIds }).(pulumi.StringArrayOutput) @@ -1233,6 +1242,16 @@ func (o CanaryVpcConfigPtrOutput) Elem() CanaryVpcConfigOutput { }).(CanaryVpcConfigOutput) } +// Allow outbound IPv6 traffic on VPC canaries that are connected to dual-stack subnets if set to true +func (o CanaryVpcConfigPtrOutput) Ipv6AllowedForDualStack() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *CanaryVpcConfig) *bool { + if v == nil { + return nil + } + return v.Ipv6AllowedForDualStack + }).(pulumi.BoolPtrOutput) +} + // The IDs of the security groups for this canary. func (o CanaryVpcConfigPtrOutput) SecurityGroupIds() pulumi.StringArrayOutput { return o.ApplyT(func(v *CanaryVpcConfig) []string { diff --git a/sdk/nodejs/dynamodb/getGlobalTable.ts b/sdk/nodejs/dynamodb/getGlobalTable.ts index 2eda768694..016468a2a8 100644 --- a/sdk/nodejs/dynamodb/getGlobalTable.ts +++ b/sdk/nodejs/dynamodb/getGlobalTable.ts @@ -50,6 +50,9 @@ export interface GetGlobalTableResult { * Since the backfilling of an index could take a long time, CloudFormation does not wait for the index to become active. If a stack operation rolls back, CloudFormation might not delete an index that has been added. In that case, you will need to delete the index manually. */ readonly globalSecondaryIndexes?: outputs.dynamodb.GlobalTableGlobalSecondaryIndex[]; + /** + * Represents the settings used to enable point in time recovery. + */ readonly pointInTimeRecoverySpecification?: outputs.dynamodb.GlobalTablePointInTimeRecoverySpecification; /** * Specifies the list of replicas for your global table. The list must contain at least one element, the region where the stack defining the global table is deployed. For example, if you define your table in a stack deployed to us-east-1, you must have an entry in `Replicas` with the region us-east-1. You cannot remove the replica in the stack region. diff --git a/sdk/nodejs/dynamodb/globalTable.ts b/sdk/nodejs/dynamodb/globalTable.ts index b38a8fdd37..731eaab0ea 100644 --- a/sdk/nodejs/dynamodb/globalTable.ts +++ b/sdk/nodejs/dynamodb/globalTable.ts @@ -68,6 +68,9 @@ export class GlobalTable extends pulumi.CustomResource { * Local secondary indexes to be created on the table. You can create up to five local secondary indexes. Each index is scoped to a given hash key value. The size of each hash key can be up to 10 gigabytes. Each replica in your global table will have the same local secondary index settings. */ public readonly localSecondaryIndexes!: pulumi.Output; + /** + * Represents the settings used to enable point in time recovery. + */ public readonly pointInTimeRecoverySpecification!: pulumi.Output; /** * Specifies the list of replicas for your global table. The list must contain at least one element, the region where the stack defining the global table is deployed. For example, if you define your table in a stack deployed to us-east-1, you must have an entry in `Replicas` with the region us-east-1. You cannot remove the replica in the stack region. @@ -214,6 +217,9 @@ export interface GlobalTableArgs { * Local secondary indexes to be created on the table. You can create up to five local secondary indexes. Each index is scoped to a given hash key value. The size of each hash key can be up to 10 gigabytes. Each replica in your global table will have the same local secondary index settings. */ localSecondaryIndexes?: pulumi.Input[]>; + /** + * Represents the settings used to enable point in time recovery. + */ pointInTimeRecoverySpecification?: pulumi.Input; /** * Specifies the list of replicas for your global table. The list must contain at least one element, the region where the stack defining the global table is deployed. For example, if you define your table in a stack deployed to us-east-1, you must have an entry in `Replicas` with the region us-east-1. You cannot remove the replica in the stack region. diff --git a/sdk/nodejs/types/enums/dms/index.ts b/sdk/nodejs/types/enums/dms/index.ts index 93ed89b968..9b115c35a3 100644 --- a/sdk/nodejs/types/enums/dms/index.ts +++ b/sdk/nodejs/types/enums/dms/index.ts @@ -23,12 +23,16 @@ export const DataProviderDmsSslModeValue = { export type DataProviderDmsSslModeValue = (typeof DataProviderDmsSslModeValue)[keyof typeof DataProviderDmsSslModeValue]; export const DataProviderEngine = { - Postgres: "postgres", + Aurora: "aurora", + AuroraPostgresql: "aurora_postgresql", Mysql: "mysql", Oracle: "oracle", + Postgres: "postgres", Sqlserver: "sqlserver", - Aurora: "aurora", - AuroraPostgresql: "aurora_postgresql", + Redshift: "redshift", + Mariadb: "mariadb", + Mongodb: "mongodb", + Docdb: "docdb", } as const; /** @@ -36,6 +40,29 @@ export const DataProviderEngine = { */ export type DataProviderEngine = (typeof DataProviderEngine)[keyof typeof DataProviderEngine]; +export const DataProviderMongoDbAuthMechanism = { + Default: "default", + MongodbCr: "mongodb_cr", + ScramSha1: "scram_sha_1", +} as const; + +export type DataProviderMongoDbAuthMechanism = (typeof DataProviderMongoDbAuthMechanism)[keyof typeof DataProviderMongoDbAuthMechanism]; + +export const DataProviderMongoDbAuthType = { + No: "no", + Password: "password", +} as const; + +export type DataProviderMongoDbAuthType = (typeof DataProviderMongoDbAuthType)[keyof typeof DataProviderMongoDbAuthType]; + +export const DataProviderMongoDbSslModeValue = { + None: "none", + Require: "require", + VerifyFull: "verify-full", +} as const; + +export type DataProviderMongoDbSslModeValue = (typeof DataProviderMongoDbSslModeValue)[keyof typeof DataProviderMongoDbSslModeValue]; + export const InstanceProfileNetworkType = { Ipv4: "IPV4", Dual: "DUAL", diff --git a/sdk/nodejs/types/input.ts b/sdk/nodejs/types/input.ts index 09b373f8e9..c126a4edb9 100644 --- a/sdk/nodejs/types/input.ts +++ b/sdk/nodejs/types/input.ts @@ -21268,10 +21268,22 @@ export namespace dms { * The property identifies the exact type of settings for the data provider. */ export interface SettingsPropertiesArgs { + /** + * DocDbSettings property identifier. + */ + docDbSettings?: pulumi.Input; + /** + * MariaDbSettings property identifier. + */ + mariaDbSettings?: pulumi.Input; /** * MicrosoftSqlServerSettings property identifier. */ microsoftSqlServerSettings?: pulumi.Input; + /** + * MongoDbSettings property identifier. + */ + mongoDbSettings?: pulumi.Input; /** * MySqlSettings property identifier. */ @@ -21284,6 +21296,31 @@ export namespace dms { * PostgreSqlSettings property identifier. */ postgreSqlSettings?: pulumi.Input; + /** + * RedshiftSettings property identifier. + */ + redshiftSettings?: pulumi.Input; + } + + /** + * DocDbSettings property identifier. + */ + export interface SettingsPropertiesDocDbSettingsPropertiesArgs { + certificateArn?: pulumi.Input; + databaseName: pulumi.Input; + port: pulumi.Input; + serverName: pulumi.Input; + sslMode?: pulumi.Input; + } + + /** + * MariaDbSettings property identifier. + */ + export interface SettingsPropertiesMariaDbSettingsPropertiesArgs { + certificateArn?: pulumi.Input; + port: pulumi.Input; + serverName: pulumi.Input; + sslMode: pulumi.Input; } /** @@ -21297,6 +21334,20 @@ export namespace dms { sslMode: pulumi.Input; } + /** + * MongoDbSettings property identifier. + */ + export interface SettingsPropertiesMongoDbSettingsPropertiesArgs { + authMechanism?: pulumi.Input; + authSource?: pulumi.Input; + authType?: pulumi.Input; + certificateArn?: pulumi.Input; + databaseName?: pulumi.Input; + port: pulumi.Input; + serverName: pulumi.Input; + sslMode?: pulumi.Input; + } + /** * MySqlSettings property identifier. */ @@ -21333,6 +21384,15 @@ export namespace dms { serverName: pulumi.Input; sslMode: pulumi.Input; } + + /** + * RedshiftSettings property identifier. + */ + export interface SettingsPropertiesRedshiftSettingsPropertiesArgs { + databaseName: pulumi.Input; + port: pulumi.Input; + serverName: pulumi.Input; + } } export namespace docdbelastic { @@ -35938,7 +35998,13 @@ export namespace iot { * A Boolean value that indicates whether Online Certificate Status Protocol (OCSP) server certificate check is enabled or not. For more information, see [Configurable endpoints](https://docs.aws.amazon.com//iot/latest/developerguide/iot-custom-endpoints-configurable.html) from the AWS IoT Core Developer Guide. */ enableOcspCheck?: pulumi.Input; + /** + * The Amazon Resource Name (ARN) for an X.509 certificate stored in ACM. If provided, AWS IoT Core will use this certificate to validate the signature of the received OCSP response. The OCSP responder must sign responses using either this authorized responder certificate or the issuing certificate, depending on whether the ARN is provided or not. The certificate must be in the same account and region as the domain configuration. + */ ocspAuthorizedResponderArn?: pulumi.Input; + /** + * The Amazon Resource Name (ARN) for a Lambda function that acts as a Request for Comments (RFC) 6960-compliant Online Certificate Status Protocol (OCSP) responder, supporting basic OCSP responses. The Lambda function accepts a base64-encoding of the OCSP request in the Distinguished Encoding Rules (DER) format. The Lambda function's response is also a base64-encoded OCSP response in the DER format. The response size must not exceed 4 kilobytes (KiB). The Lambda function must be in the same account and region as the domain configuration. + */ ocspLambdaArn?: pulumi.Input; } @@ -94511,6 +94577,10 @@ export namespace synthetics { } export interface CanaryVpcConfigArgs { + /** + * Allow outbound IPv6 traffic on VPC canaries that are connected to dual-stack subnets if set to true + */ + ipv6AllowedForDualStack?: pulumi.Input; /** * The IDs of the security groups for this canary. */ diff --git a/sdk/nodejs/types/output.ts b/sdk/nodejs/types/output.ts index 61761899f7..ac977a20ad 100644 --- a/sdk/nodejs/types/output.ts +++ b/sdk/nodejs/types/output.ts @@ -22067,10 +22067,22 @@ export namespace dms { * The property identifies the exact type of settings for the data provider. */ export interface SettingsProperties { + /** + * DocDbSettings property identifier. + */ + docDbSettings?: outputs.dms.SettingsPropertiesDocDbSettingsProperties; + /** + * MariaDbSettings property identifier. + */ + mariaDbSettings?: outputs.dms.SettingsPropertiesMariaDbSettingsProperties; /** * MicrosoftSqlServerSettings property identifier. */ microsoftSqlServerSettings?: outputs.dms.SettingsPropertiesMicrosoftSqlServerSettingsProperties; + /** + * MongoDbSettings property identifier. + */ + mongoDbSettings?: outputs.dms.SettingsPropertiesMongoDbSettingsProperties; /** * MySqlSettings property identifier. */ @@ -22083,6 +22095,31 @@ export namespace dms { * PostgreSqlSettings property identifier. */ postgreSqlSettings?: outputs.dms.SettingsPropertiesPostgreSqlSettingsProperties; + /** + * RedshiftSettings property identifier. + */ + redshiftSettings?: outputs.dms.SettingsPropertiesRedshiftSettingsProperties; + } + + /** + * DocDbSettings property identifier. + */ + export interface SettingsPropertiesDocDbSettingsProperties { + certificateArn?: string; + databaseName: string; + port: number; + serverName: string; + sslMode?: enums.dms.DataProviderMongoDbSslModeValue; + } + + /** + * MariaDbSettings property identifier. + */ + export interface SettingsPropertiesMariaDbSettingsProperties { + certificateArn?: string; + port: number; + serverName: string; + sslMode: enums.dms.DataProviderDmsSslModeValue; } /** @@ -22096,6 +22133,20 @@ export namespace dms { sslMode: enums.dms.DataProviderDmsSslModeValue; } + /** + * MongoDbSettings property identifier. + */ + export interface SettingsPropertiesMongoDbSettingsProperties { + authMechanism?: enums.dms.DataProviderMongoDbAuthMechanism; + authSource?: string; + authType?: enums.dms.DataProviderMongoDbAuthType; + certificateArn?: string; + databaseName?: string; + port: number; + serverName: string; + sslMode?: enums.dms.DataProviderMongoDbSslModeValue; + } + /** * MySqlSettings property identifier. */ @@ -22133,6 +22184,15 @@ export namespace dms { sslMode: enums.dms.DataProviderDmsSslModeValue; } + /** + * RedshiftSettings property identifier. + */ + export interface SettingsPropertiesRedshiftSettingsProperties { + databaseName: string; + port: number; + serverName: string; + } + } export namespace docdbelastic { @@ -37362,7 +37422,13 @@ export namespace iot { * A Boolean value that indicates whether Online Certificate Status Protocol (OCSP) server certificate check is enabled or not. For more information, see [Configurable endpoints](https://docs.aws.amazon.com//iot/latest/developerguide/iot-custom-endpoints-configurable.html) from the AWS IoT Core Developer Guide. */ enableOcspCheck?: boolean; + /** + * The Amazon Resource Name (ARN) for an X.509 certificate stored in ACM. If provided, AWS IoT Core will use this certificate to validate the signature of the received OCSP response. The OCSP responder must sign responses using either this authorized responder certificate or the issuing certificate, depending on whether the ARN is provided or not. The certificate must be in the same account and region as the domain configuration. + */ ocspAuthorizedResponderArn?: string; + /** + * The Amazon Resource Name (ARN) for a Lambda function that acts as a Request for Comments (RFC) 6960-compliant Online Certificate Status Protocol (OCSP) responder, supporting basic OCSP responses. The Lambda function accepts a base64-encoding of the OCSP request in the Distinguished Encoding Rules (DER) format. The Lambda function's response is also a base64-encoded OCSP response in the DER format. The response size must not exceed 4 kilobytes (KiB). The Lambda function must be in the same account and region as the domain configuration. + */ ocspLambdaArn?: string; } @@ -97029,6 +97095,10 @@ export namespace synthetics { } export interface CanaryVpcConfig { + /** + * Allow outbound IPv6 traffic on VPC canaries that are connected to dual-stack subnets if set to true + */ + ipv6AllowedForDualStack?: boolean; /** * The IDs of the security groups for this canary. */ diff --git a/sdk/python/pulumi_aws_native/dms/_enums.py b/sdk/python/pulumi_aws_native/dms/_enums.py index b4ff8f5d95..7024d57f53 100644 --- a/sdk/python/pulumi_aws_native/dms/_enums.py +++ b/sdk/python/pulumi_aws_native/dms/_enums.py @@ -8,6 +8,9 @@ 'DataMigrationType', 'DataProviderDmsSslModeValue', 'DataProviderEngine', + 'DataProviderMongoDbAuthMechanism', + 'DataProviderMongoDbAuthType', + 'DataProviderMongoDbSslModeValue', 'InstanceProfileNetworkType', 'ReplicationConfigReplicationType', ] @@ -33,12 +36,33 @@ class DataProviderEngine(str, Enum): """ The property describes a data engine for the data provider. """ - POSTGRES = "postgres" + AURORA = "aurora" + AURORA_POSTGRESQL = "aurora_postgresql" MYSQL = "mysql" ORACLE = "oracle" + POSTGRES = "postgres" SQLSERVER = "sqlserver" - AURORA = "aurora" - AURORA_POSTGRESQL = "aurora_postgresql" + REDSHIFT = "redshift" + MARIADB = "mariadb" + MONGODB = "mongodb" + DOCDB = "docdb" + + +class DataProviderMongoDbAuthMechanism(str, Enum): + DEFAULT = "default" + MONGODB_CR = "mongodb_cr" + SCRAM_SHA1 = "scram_sha_1" + + +class DataProviderMongoDbAuthType(str, Enum): + NO = "no" + PASSWORD = "password" + + +class DataProviderMongoDbSslModeValue(str, Enum): + NONE = "none" + REQUIRE = "require" + VERIFY_FULL = "verify-full" class InstanceProfileNetworkType(str, Enum): diff --git a/sdk/python/pulumi_aws_native/dms/_inputs.py b/sdk/python/pulumi_aws_native/dms/_inputs.py index fb5a23fd28..a41045e125 100644 --- a/sdk/python/pulumi_aws_native/dms/_inputs.py +++ b/sdk/python/pulumi_aws_native/dms/_inputs.py @@ -26,14 +26,22 @@ 'ReplicationConfigComputeConfigArgsDict', 'SchemaConversionApplicationAttributesPropertiesArgs', 'SchemaConversionApplicationAttributesPropertiesArgsDict', + 'SettingsPropertiesDocDbSettingsPropertiesArgs', + 'SettingsPropertiesDocDbSettingsPropertiesArgsDict', + 'SettingsPropertiesMariaDbSettingsPropertiesArgs', + 'SettingsPropertiesMariaDbSettingsPropertiesArgsDict', 'SettingsPropertiesMicrosoftSqlServerSettingsPropertiesArgs', 'SettingsPropertiesMicrosoftSqlServerSettingsPropertiesArgsDict', + 'SettingsPropertiesMongoDbSettingsPropertiesArgs', + 'SettingsPropertiesMongoDbSettingsPropertiesArgsDict', 'SettingsPropertiesMySqlSettingsPropertiesArgs', 'SettingsPropertiesMySqlSettingsPropertiesArgsDict', 'SettingsPropertiesOracleSettingsPropertiesArgs', 'SettingsPropertiesOracleSettingsPropertiesArgsDict', 'SettingsPropertiesPostgreSqlSettingsPropertiesArgs', 'SettingsPropertiesPostgreSqlSettingsPropertiesArgsDict', + 'SettingsPropertiesRedshiftSettingsPropertiesArgs', + 'SettingsPropertiesRedshiftSettingsPropertiesArgsDict', 'SettingsPropertiesArgs', 'SettingsPropertiesArgsDict', ] @@ -574,6 +582,149 @@ def s3_bucket_role_arn(self, value: Optional[pulumi.Input[str]]): pulumi.set(self, "s3_bucket_role_arn", value) +if not MYPY: + class SettingsPropertiesDocDbSettingsPropertiesArgsDict(TypedDict): + """ + DocDbSettings property identifier. + """ + database_name: pulumi.Input[str] + port: pulumi.Input[int] + server_name: pulumi.Input[str] + certificate_arn: NotRequired[pulumi.Input[str]] + ssl_mode: NotRequired[pulumi.Input['DataProviderMongoDbSslModeValue']] +elif False: + SettingsPropertiesDocDbSettingsPropertiesArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class SettingsPropertiesDocDbSettingsPropertiesArgs: + def __init__(__self__, *, + database_name: pulumi.Input[str], + port: pulumi.Input[int], + server_name: pulumi.Input[str], + certificate_arn: Optional[pulumi.Input[str]] = None, + ssl_mode: Optional[pulumi.Input['DataProviderMongoDbSslModeValue']] = None): + """ + DocDbSettings property identifier. + """ + pulumi.set(__self__, "database_name", database_name) + pulumi.set(__self__, "port", port) + pulumi.set(__self__, "server_name", server_name) + if certificate_arn is not None: + pulumi.set(__self__, "certificate_arn", certificate_arn) + if ssl_mode is not None: + pulumi.set(__self__, "ssl_mode", ssl_mode) + + @property + @pulumi.getter(name="databaseName") + def database_name(self) -> pulumi.Input[str]: + return pulumi.get(self, "database_name") + + @database_name.setter + def database_name(self, value: pulumi.Input[str]): + pulumi.set(self, "database_name", value) + + @property + @pulumi.getter + def port(self) -> pulumi.Input[int]: + return pulumi.get(self, "port") + + @port.setter + def port(self, value: pulumi.Input[int]): + pulumi.set(self, "port", value) + + @property + @pulumi.getter(name="serverName") + def server_name(self) -> pulumi.Input[str]: + return pulumi.get(self, "server_name") + + @server_name.setter + def server_name(self, value: pulumi.Input[str]): + pulumi.set(self, "server_name", value) + + @property + @pulumi.getter(name="certificateArn") + def certificate_arn(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "certificate_arn") + + @certificate_arn.setter + def certificate_arn(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "certificate_arn", value) + + @property + @pulumi.getter(name="sslMode") + def ssl_mode(self) -> Optional[pulumi.Input['DataProviderMongoDbSslModeValue']]: + return pulumi.get(self, "ssl_mode") + + @ssl_mode.setter + def ssl_mode(self, value: Optional[pulumi.Input['DataProviderMongoDbSslModeValue']]): + pulumi.set(self, "ssl_mode", value) + + +if not MYPY: + class SettingsPropertiesMariaDbSettingsPropertiesArgsDict(TypedDict): + """ + MariaDbSettings property identifier. + """ + port: pulumi.Input[int] + server_name: pulumi.Input[str] + ssl_mode: pulumi.Input['DataProviderDmsSslModeValue'] + certificate_arn: NotRequired[pulumi.Input[str]] +elif False: + SettingsPropertiesMariaDbSettingsPropertiesArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class SettingsPropertiesMariaDbSettingsPropertiesArgs: + def __init__(__self__, *, + port: pulumi.Input[int], + server_name: pulumi.Input[str], + ssl_mode: pulumi.Input['DataProviderDmsSslModeValue'], + certificate_arn: Optional[pulumi.Input[str]] = None): + """ + MariaDbSettings property identifier. + """ + pulumi.set(__self__, "port", port) + pulumi.set(__self__, "server_name", server_name) + pulumi.set(__self__, "ssl_mode", ssl_mode) + if certificate_arn is not None: + pulumi.set(__self__, "certificate_arn", certificate_arn) + + @property + @pulumi.getter + def port(self) -> pulumi.Input[int]: + return pulumi.get(self, "port") + + @port.setter + def port(self, value: pulumi.Input[int]): + pulumi.set(self, "port", value) + + @property + @pulumi.getter(name="serverName") + def server_name(self) -> pulumi.Input[str]: + return pulumi.get(self, "server_name") + + @server_name.setter + def server_name(self, value: pulumi.Input[str]): + pulumi.set(self, "server_name", value) + + @property + @pulumi.getter(name="sslMode") + def ssl_mode(self) -> pulumi.Input['DataProviderDmsSslModeValue']: + return pulumi.get(self, "ssl_mode") + + @ssl_mode.setter + def ssl_mode(self, value: pulumi.Input['DataProviderDmsSslModeValue']): + pulumi.set(self, "ssl_mode", value) + + @property + @pulumi.getter(name="certificateArn") + def certificate_arn(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "certificate_arn") + + @certificate_arn.setter + def certificate_arn(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "certificate_arn", value) + + if not MYPY: class SettingsPropertiesMicrosoftSqlServerSettingsPropertiesArgsDict(TypedDict): """ @@ -651,6 +802,124 @@ def certificate_arn(self, value: Optional[pulumi.Input[str]]): pulumi.set(self, "certificate_arn", value) +if not MYPY: + class SettingsPropertiesMongoDbSettingsPropertiesArgsDict(TypedDict): + """ + MongoDbSettings property identifier. + """ + port: pulumi.Input[int] + server_name: pulumi.Input[str] + auth_mechanism: NotRequired[pulumi.Input['DataProviderMongoDbAuthMechanism']] + auth_source: NotRequired[pulumi.Input[str]] + auth_type: NotRequired[pulumi.Input['DataProviderMongoDbAuthType']] + certificate_arn: NotRequired[pulumi.Input[str]] + database_name: NotRequired[pulumi.Input[str]] + ssl_mode: NotRequired[pulumi.Input['DataProviderMongoDbSslModeValue']] +elif False: + SettingsPropertiesMongoDbSettingsPropertiesArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class SettingsPropertiesMongoDbSettingsPropertiesArgs: + def __init__(__self__, *, + port: pulumi.Input[int], + server_name: pulumi.Input[str], + auth_mechanism: Optional[pulumi.Input['DataProviderMongoDbAuthMechanism']] = None, + auth_source: Optional[pulumi.Input[str]] = None, + auth_type: Optional[pulumi.Input['DataProviderMongoDbAuthType']] = None, + certificate_arn: Optional[pulumi.Input[str]] = None, + database_name: Optional[pulumi.Input[str]] = None, + ssl_mode: Optional[pulumi.Input['DataProviderMongoDbSslModeValue']] = None): + """ + MongoDbSettings property identifier. + """ + pulumi.set(__self__, "port", port) + pulumi.set(__self__, "server_name", server_name) + if auth_mechanism is not None: + pulumi.set(__self__, "auth_mechanism", auth_mechanism) + if auth_source is not None: + pulumi.set(__self__, "auth_source", auth_source) + if auth_type is not None: + pulumi.set(__self__, "auth_type", auth_type) + if certificate_arn is not None: + pulumi.set(__self__, "certificate_arn", certificate_arn) + if database_name is not None: + pulumi.set(__self__, "database_name", database_name) + if ssl_mode is not None: + pulumi.set(__self__, "ssl_mode", ssl_mode) + + @property + @pulumi.getter + def port(self) -> pulumi.Input[int]: + return pulumi.get(self, "port") + + @port.setter + def port(self, value: pulumi.Input[int]): + pulumi.set(self, "port", value) + + @property + @pulumi.getter(name="serverName") + def server_name(self) -> pulumi.Input[str]: + return pulumi.get(self, "server_name") + + @server_name.setter + def server_name(self, value: pulumi.Input[str]): + pulumi.set(self, "server_name", value) + + @property + @pulumi.getter(name="authMechanism") + def auth_mechanism(self) -> Optional[pulumi.Input['DataProviderMongoDbAuthMechanism']]: + return pulumi.get(self, "auth_mechanism") + + @auth_mechanism.setter + def auth_mechanism(self, value: Optional[pulumi.Input['DataProviderMongoDbAuthMechanism']]): + pulumi.set(self, "auth_mechanism", value) + + @property + @pulumi.getter(name="authSource") + def auth_source(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "auth_source") + + @auth_source.setter + def auth_source(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "auth_source", value) + + @property + @pulumi.getter(name="authType") + def auth_type(self) -> Optional[pulumi.Input['DataProviderMongoDbAuthType']]: + return pulumi.get(self, "auth_type") + + @auth_type.setter + def auth_type(self, value: Optional[pulumi.Input['DataProviderMongoDbAuthType']]): + pulumi.set(self, "auth_type", value) + + @property + @pulumi.getter(name="certificateArn") + def certificate_arn(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "certificate_arn") + + @certificate_arn.setter + def certificate_arn(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "certificate_arn", value) + + @property + @pulumi.getter(name="databaseName") + def database_name(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "database_name") + + @database_name.setter + def database_name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "database_name", value) + + @property + @pulumi.getter(name="sslMode") + def ssl_mode(self) -> Optional[pulumi.Input['DataProviderMongoDbSslModeValue']]: + return pulumi.get(self, "ssl_mode") + + @ssl_mode.setter + def ssl_mode(self, value: Optional[pulumi.Input['DataProviderMongoDbSslModeValue']]): + pulumi.set(self, "ssl_mode", value) + + if not MYPY: class SettingsPropertiesMySqlSettingsPropertiesArgsDict(TypedDict): """ @@ -935,15 +1204,79 @@ def certificate_arn(self, value: Optional[pulumi.Input[str]]): pulumi.set(self, "certificate_arn", value) +if not MYPY: + class SettingsPropertiesRedshiftSettingsPropertiesArgsDict(TypedDict): + """ + RedshiftSettings property identifier. + """ + database_name: pulumi.Input[str] + port: pulumi.Input[int] + server_name: pulumi.Input[str] +elif False: + SettingsPropertiesRedshiftSettingsPropertiesArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class SettingsPropertiesRedshiftSettingsPropertiesArgs: + def __init__(__self__, *, + database_name: pulumi.Input[str], + port: pulumi.Input[int], + server_name: pulumi.Input[str]): + """ + RedshiftSettings property identifier. + """ + pulumi.set(__self__, "database_name", database_name) + pulumi.set(__self__, "port", port) + pulumi.set(__self__, "server_name", server_name) + + @property + @pulumi.getter(name="databaseName") + def database_name(self) -> pulumi.Input[str]: + return pulumi.get(self, "database_name") + + @database_name.setter + def database_name(self, value: pulumi.Input[str]): + pulumi.set(self, "database_name", value) + + @property + @pulumi.getter + def port(self) -> pulumi.Input[int]: + return pulumi.get(self, "port") + + @port.setter + def port(self, value: pulumi.Input[int]): + pulumi.set(self, "port", value) + + @property + @pulumi.getter(name="serverName") + def server_name(self) -> pulumi.Input[str]: + return pulumi.get(self, "server_name") + + @server_name.setter + def server_name(self, value: pulumi.Input[str]): + pulumi.set(self, "server_name", value) + + if not MYPY: class SettingsPropertiesArgsDict(TypedDict): """ The property identifies the exact type of settings for the data provider. """ + doc_db_settings: NotRequired[pulumi.Input['SettingsPropertiesDocDbSettingsPropertiesArgsDict']] + """ + DocDbSettings property identifier. + """ + maria_db_settings: NotRequired[pulumi.Input['SettingsPropertiesMariaDbSettingsPropertiesArgsDict']] + """ + MariaDbSettings property identifier. + """ microsoft_sql_server_settings: NotRequired[pulumi.Input['SettingsPropertiesMicrosoftSqlServerSettingsPropertiesArgsDict']] """ MicrosoftSqlServerSettings property identifier. """ + mongo_db_settings: NotRequired[pulumi.Input['SettingsPropertiesMongoDbSettingsPropertiesArgsDict']] + """ + MongoDbSettings property identifier. + """ my_sql_settings: NotRequired[pulumi.Input['SettingsPropertiesMySqlSettingsPropertiesArgsDict']] """ MySqlSettings property identifier. @@ -956,31 +1289,75 @@ class SettingsPropertiesArgsDict(TypedDict): """ PostgreSqlSettings property identifier. """ + redshift_settings: NotRequired[pulumi.Input['SettingsPropertiesRedshiftSettingsPropertiesArgsDict']] + """ + RedshiftSettings property identifier. + """ elif False: SettingsPropertiesArgsDict: TypeAlias = Mapping[str, Any] @pulumi.input_type class SettingsPropertiesArgs: def __init__(__self__, *, + doc_db_settings: Optional[pulumi.Input['SettingsPropertiesDocDbSettingsPropertiesArgs']] = None, + maria_db_settings: Optional[pulumi.Input['SettingsPropertiesMariaDbSettingsPropertiesArgs']] = None, microsoft_sql_server_settings: Optional[pulumi.Input['SettingsPropertiesMicrosoftSqlServerSettingsPropertiesArgs']] = None, + mongo_db_settings: Optional[pulumi.Input['SettingsPropertiesMongoDbSettingsPropertiesArgs']] = None, my_sql_settings: Optional[pulumi.Input['SettingsPropertiesMySqlSettingsPropertiesArgs']] = None, oracle_settings: Optional[pulumi.Input['SettingsPropertiesOracleSettingsPropertiesArgs']] = None, - postgre_sql_settings: Optional[pulumi.Input['SettingsPropertiesPostgreSqlSettingsPropertiesArgs']] = None): + postgre_sql_settings: Optional[pulumi.Input['SettingsPropertiesPostgreSqlSettingsPropertiesArgs']] = None, + redshift_settings: Optional[pulumi.Input['SettingsPropertiesRedshiftSettingsPropertiesArgs']] = None): """ The property identifies the exact type of settings for the data provider. + :param pulumi.Input['SettingsPropertiesDocDbSettingsPropertiesArgs'] doc_db_settings: DocDbSettings property identifier. + :param pulumi.Input['SettingsPropertiesMariaDbSettingsPropertiesArgs'] maria_db_settings: MariaDbSettings property identifier. :param pulumi.Input['SettingsPropertiesMicrosoftSqlServerSettingsPropertiesArgs'] microsoft_sql_server_settings: MicrosoftSqlServerSettings property identifier. + :param pulumi.Input['SettingsPropertiesMongoDbSettingsPropertiesArgs'] mongo_db_settings: MongoDbSettings property identifier. :param pulumi.Input['SettingsPropertiesMySqlSettingsPropertiesArgs'] my_sql_settings: MySqlSettings property identifier. :param pulumi.Input['SettingsPropertiesOracleSettingsPropertiesArgs'] oracle_settings: OracleSettings property identifier. :param pulumi.Input['SettingsPropertiesPostgreSqlSettingsPropertiesArgs'] postgre_sql_settings: PostgreSqlSettings property identifier. + :param pulumi.Input['SettingsPropertiesRedshiftSettingsPropertiesArgs'] redshift_settings: RedshiftSettings property identifier. """ + if doc_db_settings is not None: + pulumi.set(__self__, "doc_db_settings", doc_db_settings) + if maria_db_settings is not None: + pulumi.set(__self__, "maria_db_settings", maria_db_settings) if microsoft_sql_server_settings is not None: pulumi.set(__self__, "microsoft_sql_server_settings", microsoft_sql_server_settings) + if mongo_db_settings is not None: + pulumi.set(__self__, "mongo_db_settings", mongo_db_settings) if my_sql_settings is not None: pulumi.set(__self__, "my_sql_settings", my_sql_settings) if oracle_settings is not None: pulumi.set(__self__, "oracle_settings", oracle_settings) if postgre_sql_settings is not None: pulumi.set(__self__, "postgre_sql_settings", postgre_sql_settings) + if redshift_settings is not None: + pulumi.set(__self__, "redshift_settings", redshift_settings) + + @property + @pulumi.getter(name="docDbSettings") + def doc_db_settings(self) -> Optional[pulumi.Input['SettingsPropertiesDocDbSettingsPropertiesArgs']]: + """ + DocDbSettings property identifier. + """ + return pulumi.get(self, "doc_db_settings") + + @doc_db_settings.setter + def doc_db_settings(self, value: Optional[pulumi.Input['SettingsPropertiesDocDbSettingsPropertiesArgs']]): + pulumi.set(self, "doc_db_settings", value) + + @property + @pulumi.getter(name="mariaDbSettings") + def maria_db_settings(self) -> Optional[pulumi.Input['SettingsPropertiesMariaDbSettingsPropertiesArgs']]: + """ + MariaDbSettings property identifier. + """ + return pulumi.get(self, "maria_db_settings") + + @maria_db_settings.setter + def maria_db_settings(self, value: Optional[pulumi.Input['SettingsPropertiesMariaDbSettingsPropertiesArgs']]): + pulumi.set(self, "maria_db_settings", value) @property @pulumi.getter(name="microsoftSqlServerSettings") @@ -994,6 +1371,18 @@ def microsoft_sql_server_settings(self) -> Optional[pulumi.Input['SettingsProper def microsoft_sql_server_settings(self, value: Optional[pulumi.Input['SettingsPropertiesMicrosoftSqlServerSettingsPropertiesArgs']]): pulumi.set(self, "microsoft_sql_server_settings", value) + @property + @pulumi.getter(name="mongoDbSettings") + def mongo_db_settings(self) -> Optional[pulumi.Input['SettingsPropertiesMongoDbSettingsPropertiesArgs']]: + """ + MongoDbSettings property identifier. + """ + return pulumi.get(self, "mongo_db_settings") + + @mongo_db_settings.setter + def mongo_db_settings(self, value: Optional[pulumi.Input['SettingsPropertiesMongoDbSettingsPropertiesArgs']]): + pulumi.set(self, "mongo_db_settings", value) + @property @pulumi.getter(name="mySqlSettings") def my_sql_settings(self) -> Optional[pulumi.Input['SettingsPropertiesMySqlSettingsPropertiesArgs']]: @@ -1030,4 +1419,16 @@ def postgre_sql_settings(self) -> Optional[pulumi.Input['SettingsPropertiesPostg def postgre_sql_settings(self, value: Optional[pulumi.Input['SettingsPropertiesPostgreSqlSettingsPropertiesArgs']]): pulumi.set(self, "postgre_sql_settings", value) + @property + @pulumi.getter(name="redshiftSettings") + def redshift_settings(self) -> Optional[pulumi.Input['SettingsPropertiesRedshiftSettingsPropertiesArgs']]: + """ + RedshiftSettings property identifier. + """ + return pulumi.get(self, "redshift_settings") + + @redshift_settings.setter + def redshift_settings(self, value: Optional[pulumi.Input['SettingsPropertiesRedshiftSettingsPropertiesArgs']]): + pulumi.set(self, "redshift_settings", value) + diff --git a/sdk/python/pulumi_aws_native/dms/outputs.py b/sdk/python/pulumi_aws_native/dms/outputs.py index bfc488f199..7ecdfa3a5a 100644 --- a/sdk/python/pulumi_aws_native/dms/outputs.py +++ b/sdk/python/pulumi_aws_native/dms/outputs.py @@ -23,10 +23,14 @@ 'ReplicationConfigComputeConfig', 'SchemaConversionApplicationAttributesProperties', 'SettingsProperties', + 'SettingsPropertiesDocDbSettingsProperties', + 'SettingsPropertiesMariaDbSettingsProperties', 'SettingsPropertiesMicrosoftSqlServerSettingsProperties', + 'SettingsPropertiesMongoDbSettingsProperties', 'SettingsPropertiesMySqlSettingsProperties', 'SettingsPropertiesOracleSettingsProperties', 'SettingsPropertiesPostgreSqlSettingsProperties', + 'SettingsPropertiesRedshiftSettingsProperties', ] @pulumi.output_type @@ -484,14 +488,22 @@ class SettingsProperties(dict): @staticmethod def __key_warning(key: str): suggest = None - if key == "microsoftSqlServerSettings": + if key == "docDbSettings": + suggest = "doc_db_settings" + elif key == "mariaDbSettings": + suggest = "maria_db_settings" + elif key == "microsoftSqlServerSettings": suggest = "microsoft_sql_server_settings" + elif key == "mongoDbSettings": + suggest = "mongo_db_settings" elif key == "mySqlSettings": suggest = "my_sql_settings" elif key == "oracleSettings": suggest = "oracle_settings" elif key == "postgreSqlSettings": suggest = "postgre_sql_settings" + elif key == "redshiftSettings": + suggest = "redshift_settings" if suggest: pulumi.log.warn(f"Key '{key}' not found in SettingsProperties. Access the value via the '{suggest}' property getter instead.") @@ -505,25 +517,57 @@ def get(self, key: str, default = None) -> Any: return super().get(key, default) def __init__(__self__, *, + doc_db_settings: Optional['outputs.SettingsPropertiesDocDbSettingsProperties'] = None, + maria_db_settings: Optional['outputs.SettingsPropertiesMariaDbSettingsProperties'] = None, microsoft_sql_server_settings: Optional['outputs.SettingsPropertiesMicrosoftSqlServerSettingsProperties'] = None, + mongo_db_settings: Optional['outputs.SettingsPropertiesMongoDbSettingsProperties'] = None, my_sql_settings: Optional['outputs.SettingsPropertiesMySqlSettingsProperties'] = None, oracle_settings: Optional['outputs.SettingsPropertiesOracleSettingsProperties'] = None, - postgre_sql_settings: Optional['outputs.SettingsPropertiesPostgreSqlSettingsProperties'] = None): + postgre_sql_settings: Optional['outputs.SettingsPropertiesPostgreSqlSettingsProperties'] = None, + redshift_settings: Optional['outputs.SettingsPropertiesRedshiftSettingsProperties'] = None): """ The property identifies the exact type of settings for the data provider. + :param 'SettingsPropertiesDocDbSettingsProperties' doc_db_settings: DocDbSettings property identifier. + :param 'SettingsPropertiesMariaDbSettingsProperties' maria_db_settings: MariaDbSettings property identifier. :param 'SettingsPropertiesMicrosoftSqlServerSettingsProperties' microsoft_sql_server_settings: MicrosoftSqlServerSettings property identifier. + :param 'SettingsPropertiesMongoDbSettingsProperties' mongo_db_settings: MongoDbSettings property identifier. :param 'SettingsPropertiesMySqlSettingsProperties' my_sql_settings: MySqlSettings property identifier. :param 'SettingsPropertiesOracleSettingsProperties' oracle_settings: OracleSettings property identifier. :param 'SettingsPropertiesPostgreSqlSettingsProperties' postgre_sql_settings: PostgreSqlSettings property identifier. + :param 'SettingsPropertiesRedshiftSettingsProperties' redshift_settings: RedshiftSettings property identifier. """ + if doc_db_settings is not None: + pulumi.set(__self__, "doc_db_settings", doc_db_settings) + if maria_db_settings is not None: + pulumi.set(__self__, "maria_db_settings", maria_db_settings) if microsoft_sql_server_settings is not None: pulumi.set(__self__, "microsoft_sql_server_settings", microsoft_sql_server_settings) + if mongo_db_settings is not None: + pulumi.set(__self__, "mongo_db_settings", mongo_db_settings) if my_sql_settings is not None: pulumi.set(__self__, "my_sql_settings", my_sql_settings) if oracle_settings is not None: pulumi.set(__self__, "oracle_settings", oracle_settings) if postgre_sql_settings is not None: pulumi.set(__self__, "postgre_sql_settings", postgre_sql_settings) + if redshift_settings is not None: + pulumi.set(__self__, "redshift_settings", redshift_settings) + + @property + @pulumi.getter(name="docDbSettings") + def doc_db_settings(self) -> Optional['outputs.SettingsPropertiesDocDbSettingsProperties']: + """ + DocDbSettings property identifier. + """ + return pulumi.get(self, "doc_db_settings") + + @property + @pulumi.getter(name="mariaDbSettings") + def maria_db_settings(self) -> Optional['outputs.SettingsPropertiesMariaDbSettingsProperties']: + """ + MariaDbSettings property identifier. + """ + return pulumi.get(self, "maria_db_settings") @property @pulumi.getter(name="microsoftSqlServerSettings") @@ -533,6 +577,14 @@ def microsoft_sql_server_settings(self) -> Optional['outputs.SettingsPropertiesM """ return pulumi.get(self, "microsoft_sql_server_settings") + @property + @pulumi.getter(name="mongoDbSettings") + def mongo_db_settings(self) -> Optional['outputs.SettingsPropertiesMongoDbSettingsProperties']: + """ + MongoDbSettings property identifier. + """ + return pulumi.get(self, "mongo_db_settings") + @property @pulumi.getter(name="mySqlSettings") def my_sql_settings(self) -> Optional['outputs.SettingsPropertiesMySqlSettingsProperties']: @@ -557,6 +609,146 @@ def postgre_sql_settings(self) -> Optional['outputs.SettingsPropertiesPostgreSql """ return pulumi.get(self, "postgre_sql_settings") + @property + @pulumi.getter(name="redshiftSettings") + def redshift_settings(self) -> Optional['outputs.SettingsPropertiesRedshiftSettingsProperties']: + """ + RedshiftSettings property identifier. + """ + return pulumi.get(self, "redshift_settings") + + +@pulumi.output_type +class SettingsPropertiesDocDbSettingsProperties(dict): + """ + DocDbSettings property identifier. + """ + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "databaseName": + suggest = "database_name" + elif key == "serverName": + suggest = "server_name" + elif key == "certificateArn": + suggest = "certificate_arn" + elif key == "sslMode": + suggest = "ssl_mode" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in SettingsPropertiesDocDbSettingsProperties. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + SettingsPropertiesDocDbSettingsProperties.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + SettingsPropertiesDocDbSettingsProperties.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + database_name: str, + port: int, + server_name: str, + certificate_arn: Optional[str] = None, + ssl_mode: Optional['DataProviderMongoDbSslModeValue'] = None): + """ + DocDbSettings property identifier. + """ + pulumi.set(__self__, "database_name", database_name) + pulumi.set(__self__, "port", port) + pulumi.set(__self__, "server_name", server_name) + if certificate_arn is not None: + pulumi.set(__self__, "certificate_arn", certificate_arn) + if ssl_mode is not None: + pulumi.set(__self__, "ssl_mode", ssl_mode) + + @property + @pulumi.getter(name="databaseName") + def database_name(self) -> str: + return pulumi.get(self, "database_name") + + @property + @pulumi.getter + def port(self) -> int: + return pulumi.get(self, "port") + + @property + @pulumi.getter(name="serverName") + def server_name(self) -> str: + return pulumi.get(self, "server_name") + + @property + @pulumi.getter(name="certificateArn") + def certificate_arn(self) -> Optional[str]: + return pulumi.get(self, "certificate_arn") + + @property + @pulumi.getter(name="sslMode") + def ssl_mode(self) -> Optional['DataProviderMongoDbSslModeValue']: + return pulumi.get(self, "ssl_mode") + + +@pulumi.output_type +class SettingsPropertiesMariaDbSettingsProperties(dict): + """ + MariaDbSettings property identifier. + """ + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "serverName": + suggest = "server_name" + elif key == "sslMode": + suggest = "ssl_mode" + elif key == "certificateArn": + suggest = "certificate_arn" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in SettingsPropertiesMariaDbSettingsProperties. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + SettingsPropertiesMariaDbSettingsProperties.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + SettingsPropertiesMariaDbSettingsProperties.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + port: int, + server_name: str, + ssl_mode: 'DataProviderDmsSslModeValue', + certificate_arn: Optional[str] = None): + """ + MariaDbSettings property identifier. + """ + pulumi.set(__self__, "port", port) + pulumi.set(__self__, "server_name", server_name) + pulumi.set(__self__, "ssl_mode", ssl_mode) + if certificate_arn is not None: + pulumi.set(__self__, "certificate_arn", certificate_arn) + + @property + @pulumi.getter + def port(self) -> int: + return pulumi.get(self, "port") + + @property + @pulumi.getter(name="serverName") + def server_name(self) -> str: + return pulumi.get(self, "server_name") + + @property + @pulumi.getter(name="sslMode") + def ssl_mode(self) -> 'DataProviderDmsSslModeValue': + return pulumi.get(self, "ssl_mode") + + @property + @pulumi.getter(name="certificateArn") + def certificate_arn(self) -> Optional[str]: + return pulumi.get(self, "certificate_arn") + @pulumi.output_type class SettingsPropertiesMicrosoftSqlServerSettingsProperties(dict): @@ -628,6 +820,108 @@ def certificate_arn(self) -> Optional[str]: return pulumi.get(self, "certificate_arn") +@pulumi.output_type +class SettingsPropertiesMongoDbSettingsProperties(dict): + """ + MongoDbSettings property identifier. + """ + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "serverName": + suggest = "server_name" + elif key == "authMechanism": + suggest = "auth_mechanism" + elif key == "authSource": + suggest = "auth_source" + elif key == "authType": + suggest = "auth_type" + elif key == "certificateArn": + suggest = "certificate_arn" + elif key == "databaseName": + suggest = "database_name" + elif key == "sslMode": + suggest = "ssl_mode" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in SettingsPropertiesMongoDbSettingsProperties. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + SettingsPropertiesMongoDbSettingsProperties.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + SettingsPropertiesMongoDbSettingsProperties.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + port: int, + server_name: str, + auth_mechanism: Optional['DataProviderMongoDbAuthMechanism'] = None, + auth_source: Optional[str] = None, + auth_type: Optional['DataProviderMongoDbAuthType'] = None, + certificate_arn: Optional[str] = None, + database_name: Optional[str] = None, + ssl_mode: Optional['DataProviderMongoDbSslModeValue'] = None): + """ + MongoDbSettings property identifier. + """ + pulumi.set(__self__, "port", port) + pulumi.set(__self__, "server_name", server_name) + if auth_mechanism is not None: + pulumi.set(__self__, "auth_mechanism", auth_mechanism) + if auth_source is not None: + pulumi.set(__self__, "auth_source", auth_source) + if auth_type is not None: + pulumi.set(__self__, "auth_type", auth_type) + if certificate_arn is not None: + pulumi.set(__self__, "certificate_arn", certificate_arn) + if database_name is not None: + pulumi.set(__self__, "database_name", database_name) + if ssl_mode is not None: + pulumi.set(__self__, "ssl_mode", ssl_mode) + + @property + @pulumi.getter + def port(self) -> int: + return pulumi.get(self, "port") + + @property + @pulumi.getter(name="serverName") + def server_name(self) -> str: + return pulumi.get(self, "server_name") + + @property + @pulumi.getter(name="authMechanism") + def auth_mechanism(self) -> Optional['DataProviderMongoDbAuthMechanism']: + return pulumi.get(self, "auth_mechanism") + + @property + @pulumi.getter(name="authSource") + def auth_source(self) -> Optional[str]: + return pulumi.get(self, "auth_source") + + @property + @pulumi.getter(name="authType") + def auth_type(self) -> Optional['DataProviderMongoDbAuthType']: + return pulumi.get(self, "auth_type") + + @property + @pulumi.getter(name="certificateArn") + def certificate_arn(self) -> Optional[str]: + return pulumi.get(self, "certificate_arn") + + @property + @pulumi.getter(name="databaseName") + def database_name(self) -> Optional[str]: + return pulumi.get(self, "database_name") + + @property + @pulumi.getter(name="sslMode") + def ssl_mode(self) -> Optional['DataProviderMongoDbSslModeValue']: + return pulumi.get(self, "ssl_mode") + + @pulumi.output_type class SettingsPropertiesMySqlSettingsProperties(dict): """ @@ -879,3 +1173,54 @@ def certificate_arn(self) -> Optional[str]: return pulumi.get(self, "certificate_arn") +@pulumi.output_type +class SettingsPropertiesRedshiftSettingsProperties(dict): + """ + RedshiftSettings property identifier. + """ + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "databaseName": + suggest = "database_name" + elif key == "serverName": + suggest = "server_name" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in SettingsPropertiesRedshiftSettingsProperties. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + SettingsPropertiesRedshiftSettingsProperties.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + SettingsPropertiesRedshiftSettingsProperties.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + database_name: str, + port: int, + server_name: str): + """ + RedshiftSettings property identifier. + """ + pulumi.set(__self__, "database_name", database_name) + pulumi.set(__self__, "port", port) + pulumi.set(__self__, "server_name", server_name) + + @property + @pulumi.getter(name="databaseName") + def database_name(self) -> str: + return pulumi.get(self, "database_name") + + @property + @pulumi.getter + def port(self) -> int: + return pulumi.get(self, "port") + + @property + @pulumi.getter(name="serverName") + def server_name(self) -> str: + return pulumi.get(self, "server_name") + + diff --git a/sdk/python/pulumi_aws_native/dynamodb/get_global_table.py b/sdk/python/pulumi_aws_native/dynamodb/get_global_table.py index a7a3ee6328..2654bca938 100644 --- a/sdk/python/pulumi_aws_native/dynamodb/get_global_table.py +++ b/sdk/python/pulumi_aws_native/dynamodb/get_global_table.py @@ -111,6 +111,9 @@ def global_secondary_indexes(self) -> Optional[Sequence['outputs.GlobalTableGlob @property @pulumi.getter(name="pointInTimeRecoverySpecification") def point_in_time_recovery_specification(self) -> Optional['outputs.GlobalTablePointInTimeRecoverySpecification']: + """ + Represents the settings used to enable point in time recovery. + """ return pulumi.get(self, "point_in_time_recovery_specification") @property diff --git a/sdk/python/pulumi_aws_native/dynamodb/global_table.py b/sdk/python/pulumi_aws_native/dynamodb/global_table.py index 08445d92e7..d4ec655ff4 100644 --- a/sdk/python/pulumi_aws_native/dynamodb/global_table.py +++ b/sdk/python/pulumi_aws_native/dynamodb/global_table.py @@ -57,6 +57,7 @@ def __init__(__self__, *, Since the backfilling of an index could take a long time, CloudFormation does not wait for the index to become active. If a stack operation rolls back, CloudFormation might not delete an index that has been added. In that case, you will need to delete the index manually. :param pulumi.Input[Sequence[pulumi.Input['GlobalTableLocalSecondaryIndexArgs']]] local_secondary_indexes: Local secondary indexes to be created on the table. You can create up to five local secondary indexes. Each index is scoped to a given hash key value. The size of each hash key can be up to 10 gigabytes. Each replica in your global table will have the same local secondary index settings. + :param pulumi.Input['GlobalTablePointInTimeRecoverySpecificationArgs'] point_in_time_recovery_specification: Represents the settings used to enable point in time recovery. :param pulumi.Input['GlobalTableSseSpecificationArgs'] sse_specification: Specifies the settings to enable server-side encryption. These settings will be applied to all replicas. If you plan to use customer-managed KMS keys, you must provide a key for each replica using the `ReplicaSpecification.ReplicaSSESpecification` property. :param pulumi.Input['GlobalTableStreamSpecificationArgs'] stream_specification: Specifies the streams settings on your global table. You must provide a value for this property if your global table contains more than one replica. You can only change the streams settings if your global table has only one replica. :param pulumi.Input[str] table_name: A name for the global table. If you don't specify a name, AWS CloudFormation generates a unique ID and uses that ID as the table name. For more information, see [Name type](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-name.html) . @@ -181,6 +182,9 @@ def local_secondary_indexes(self, value: Optional[pulumi.Input[Sequence[pulumi.I @property @pulumi.getter(name="pointInTimeRecoverySpecification") def point_in_time_recovery_specification(self) -> Optional[pulumi.Input['GlobalTablePointInTimeRecoverySpecificationArgs']]: + """ + Represents the settings used to enable point in time recovery. + """ return pulumi.get(self, "point_in_time_recovery_specification") @point_in_time_recovery_specification.setter @@ -311,6 +315,7 @@ def __init__(__self__, Since the backfilling of an index could take a long time, CloudFormation does not wait for the index to become active. If a stack operation rolls back, CloudFormation might not delete an index that has been added. In that case, you will need to delete the index manually. :param pulumi.Input[Sequence[pulumi.Input[Union['GlobalTableKeySchemaArgs', 'GlobalTableKeySchemaArgsDict']]]] key_schema: Specifies the attributes that make up the primary key for the table. The attributes in the `KeySchema` property must also be defined in the `AttributeDefinitions` property. :param pulumi.Input[Sequence[pulumi.Input[Union['GlobalTableLocalSecondaryIndexArgs', 'GlobalTableLocalSecondaryIndexArgsDict']]]] local_secondary_indexes: Local secondary indexes to be created on the table. You can create up to five local secondary indexes. Each index is scoped to a given hash key value. The size of each hash key can be up to 10 gigabytes. Each replica in your global table will have the same local secondary index settings. + :param pulumi.Input[Union['GlobalTablePointInTimeRecoverySpecificationArgs', 'GlobalTablePointInTimeRecoverySpecificationArgsDict']] point_in_time_recovery_specification: Represents the settings used to enable point in time recovery. :param pulumi.Input[Sequence[pulumi.Input[Union['GlobalTableReplicaSpecificationArgs', 'GlobalTableReplicaSpecificationArgsDict']]]] replicas: Specifies the list of replicas for your global table. The list must contain at least one element, the region where the stack defining the global table is deployed. For example, if you define your table in a stack deployed to us-east-1, you must have an entry in `Replicas` with the region us-east-1. You cannot remove the replica in the stack region. > Adding a replica might take a few minutes for an empty table, or up to several hours for large tables. If you want to add or remove a replica, we recommend submitting an `UpdateStack` operation containing only that change. @@ -499,6 +504,9 @@ def local_secondary_indexes(self) -> pulumi.Output[Optional[Sequence['outputs.Gl @property @pulumi.getter(name="pointInTimeRecoverySpecification") def point_in_time_recovery_specification(self) -> pulumi.Output[Optional['outputs.GlobalTablePointInTimeRecoverySpecification']]: + """ + Represents the settings used to enable point in time recovery. + """ return pulumi.get(self, "point_in_time_recovery_specification") @property diff --git a/sdk/python/pulumi_aws_native/iot/_inputs.py b/sdk/python/pulumi_aws_native/iot/_inputs.py index e01d9535ab..3aebe76538 100644 --- a/sdk/python/pulumi_aws_native/iot/_inputs.py +++ b/sdk/python/pulumi_aws_native/iot/_inputs.py @@ -1106,7 +1106,13 @@ class DomainConfigurationServerCertificateConfigArgsDict(TypedDict): A Boolean value that indicates whether Online Certificate Status Protocol (OCSP) server certificate check is enabled or not. For more information, see [Configurable endpoints](https://docs.aws.amazon.com//iot/latest/developerguide/iot-custom-endpoints-configurable.html) from the AWS IoT Core Developer Guide. """ ocsp_authorized_responder_arn: NotRequired[pulumi.Input[str]] + """ + The Amazon Resource Name (ARN) for an X.509 certificate stored in ACM. If provided, AWS IoT Core will use this certificate to validate the signature of the received OCSP response. The OCSP responder must sign responses using either this authorized responder certificate or the issuing certificate, depending on whether the ARN is provided or not. The certificate must be in the same account and region as the domain configuration. + """ ocsp_lambda_arn: NotRequired[pulumi.Input[str]] + """ + The Amazon Resource Name (ARN) for a Lambda function that acts as a Request for Comments (RFC) 6960-compliant Online Certificate Status Protocol (OCSP) responder, supporting basic OCSP responses. The Lambda function accepts a base64-encoding of the OCSP request in the Distinguished Encoding Rules (DER) format. The Lambda function's response is also a base64-encoded OCSP response in the DER format. The response size must not exceed 4 kilobytes (KiB). The Lambda function must be in the same account and region as the domain configuration. + """ elif False: DomainConfigurationServerCertificateConfigArgsDict: TypeAlias = Mapping[str, Any] @@ -1118,6 +1124,8 @@ def __init__(__self__, *, ocsp_lambda_arn: Optional[pulumi.Input[str]] = None): """ :param pulumi.Input[bool] enable_ocsp_check: A Boolean value that indicates whether Online Certificate Status Protocol (OCSP) server certificate check is enabled or not. For more information, see [Configurable endpoints](https://docs.aws.amazon.com//iot/latest/developerguide/iot-custom-endpoints-configurable.html) from the AWS IoT Core Developer Guide. + :param pulumi.Input[str] ocsp_authorized_responder_arn: The Amazon Resource Name (ARN) for an X.509 certificate stored in ACM. If provided, AWS IoT Core will use this certificate to validate the signature of the received OCSP response. The OCSP responder must sign responses using either this authorized responder certificate or the issuing certificate, depending on whether the ARN is provided or not. The certificate must be in the same account and region as the domain configuration. + :param pulumi.Input[str] ocsp_lambda_arn: The Amazon Resource Name (ARN) for a Lambda function that acts as a Request for Comments (RFC) 6960-compliant Online Certificate Status Protocol (OCSP) responder, supporting basic OCSP responses. The Lambda function accepts a base64-encoding of the OCSP request in the Distinguished Encoding Rules (DER) format. The Lambda function's response is also a base64-encoded OCSP response in the DER format. The response size must not exceed 4 kilobytes (KiB). The Lambda function must be in the same account and region as the domain configuration. """ if enable_ocsp_check is not None: pulumi.set(__self__, "enable_ocsp_check", enable_ocsp_check) @@ -1141,6 +1149,9 @@ def enable_ocsp_check(self, value: Optional[pulumi.Input[bool]]): @property @pulumi.getter(name="ocspAuthorizedResponderArn") def ocsp_authorized_responder_arn(self) -> Optional[pulumi.Input[str]]: + """ + The Amazon Resource Name (ARN) for an X.509 certificate stored in ACM. If provided, AWS IoT Core will use this certificate to validate the signature of the received OCSP response. The OCSP responder must sign responses using either this authorized responder certificate or the issuing certificate, depending on whether the ARN is provided or not. The certificate must be in the same account and region as the domain configuration. + """ return pulumi.get(self, "ocsp_authorized_responder_arn") @ocsp_authorized_responder_arn.setter @@ -1150,6 +1161,9 @@ def ocsp_authorized_responder_arn(self, value: Optional[pulumi.Input[str]]): @property @pulumi.getter(name="ocspLambdaArn") def ocsp_lambda_arn(self) -> Optional[pulumi.Input[str]]: + """ + The Amazon Resource Name (ARN) for a Lambda function that acts as a Request for Comments (RFC) 6960-compliant Online Certificate Status Protocol (OCSP) responder, supporting basic OCSP responses. The Lambda function accepts a base64-encoding of the OCSP request in the Distinguished Encoding Rules (DER) format. The Lambda function's response is also a base64-encoded OCSP response in the DER format. The response size must not exceed 4 kilobytes (KiB). The Lambda function must be in the same account and region as the domain configuration. + """ return pulumi.get(self, "ocsp_lambda_arn") @ocsp_lambda_arn.setter diff --git a/sdk/python/pulumi_aws_native/iot/outputs.py b/sdk/python/pulumi_aws_native/iot/outputs.py index a198bad3fb..5d3b3d44ac 100644 --- a/sdk/python/pulumi_aws_native/iot/outputs.py +++ b/sdk/python/pulumi_aws_native/iot/outputs.py @@ -875,6 +875,8 @@ def __init__(__self__, *, ocsp_lambda_arn: Optional[str] = None): """ :param bool enable_ocsp_check: A Boolean value that indicates whether Online Certificate Status Protocol (OCSP) server certificate check is enabled or not. For more information, see [Configurable endpoints](https://docs.aws.amazon.com//iot/latest/developerguide/iot-custom-endpoints-configurable.html) from the AWS IoT Core Developer Guide. + :param str ocsp_authorized_responder_arn: The Amazon Resource Name (ARN) for an X.509 certificate stored in ACM. If provided, AWS IoT Core will use this certificate to validate the signature of the received OCSP response. The OCSP responder must sign responses using either this authorized responder certificate or the issuing certificate, depending on whether the ARN is provided or not. The certificate must be in the same account and region as the domain configuration. + :param str ocsp_lambda_arn: The Amazon Resource Name (ARN) for a Lambda function that acts as a Request for Comments (RFC) 6960-compliant Online Certificate Status Protocol (OCSP) responder, supporting basic OCSP responses. The Lambda function accepts a base64-encoding of the OCSP request in the Distinguished Encoding Rules (DER) format. The Lambda function's response is also a base64-encoded OCSP response in the DER format. The response size must not exceed 4 kilobytes (KiB). The Lambda function must be in the same account and region as the domain configuration. """ if enable_ocsp_check is not None: pulumi.set(__self__, "enable_ocsp_check", enable_ocsp_check) @@ -894,11 +896,17 @@ def enable_ocsp_check(self) -> Optional[bool]: @property @pulumi.getter(name="ocspAuthorizedResponderArn") def ocsp_authorized_responder_arn(self) -> Optional[str]: + """ + The Amazon Resource Name (ARN) for an X.509 certificate stored in ACM. If provided, AWS IoT Core will use this certificate to validate the signature of the received OCSP response. The OCSP responder must sign responses using either this authorized responder certificate or the issuing certificate, depending on whether the ARN is provided or not. The certificate must be in the same account and region as the domain configuration. + """ return pulumi.get(self, "ocsp_authorized_responder_arn") @property @pulumi.getter(name="ocspLambdaArn") def ocsp_lambda_arn(self) -> Optional[str]: + """ + The Amazon Resource Name (ARN) for a Lambda function that acts as a Request for Comments (RFC) 6960-compliant Online Certificate Status Protocol (OCSP) responder, supporting basic OCSP responses. The Lambda function accepts a base64-encoding of the OCSP request in the Distinguished Encoding Rules (DER) format. The Lambda function's response is also a base64-encoded OCSP response in the DER format. The response size must not exceed 4 kilobytes (KiB). The Lambda function must be in the same account and region as the domain configuration. + """ return pulumi.get(self, "ocsp_lambda_arn") diff --git a/sdk/python/pulumi_aws_native/synthetics/_inputs.py b/sdk/python/pulumi_aws_native/synthetics/_inputs.py index 86378bd5b7..e173a80b31 100644 --- a/sdk/python/pulumi_aws_native/synthetics/_inputs.py +++ b/sdk/python/pulumi_aws_native/synthetics/_inputs.py @@ -530,6 +530,10 @@ class CanaryVpcConfigArgsDict(TypedDict): """ The IDs of the subnets where this canary is to run. """ + ipv6_allowed_for_dual_stack: NotRequired[pulumi.Input[bool]] + """ + Allow outbound IPv6 traffic on VPC canaries that are connected to dual-stack subnets if set to true + """ vpc_id: NotRequired[pulumi.Input[str]] """ The ID of the VPC where this canary is to run. @@ -542,14 +546,18 @@ class CanaryVpcConfigArgs: def __init__(__self__, *, security_group_ids: pulumi.Input[Sequence[pulumi.Input[str]]], subnet_ids: pulumi.Input[Sequence[pulumi.Input[str]]], + ipv6_allowed_for_dual_stack: Optional[pulumi.Input[bool]] = None, vpc_id: Optional[pulumi.Input[str]] = None): """ :param pulumi.Input[Sequence[pulumi.Input[str]]] security_group_ids: The IDs of the security groups for this canary. :param pulumi.Input[Sequence[pulumi.Input[str]]] subnet_ids: The IDs of the subnets where this canary is to run. + :param pulumi.Input[bool] ipv6_allowed_for_dual_stack: Allow outbound IPv6 traffic on VPC canaries that are connected to dual-stack subnets if set to true :param pulumi.Input[str] vpc_id: The ID of the VPC where this canary is to run. """ pulumi.set(__self__, "security_group_ids", security_group_ids) pulumi.set(__self__, "subnet_ids", subnet_ids) + if ipv6_allowed_for_dual_stack is not None: + pulumi.set(__self__, "ipv6_allowed_for_dual_stack", ipv6_allowed_for_dual_stack) if vpc_id is not None: pulumi.set(__self__, "vpc_id", vpc_id) @@ -577,6 +585,18 @@ def subnet_ids(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]: def subnet_ids(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]): pulumi.set(self, "subnet_ids", value) + @property + @pulumi.getter(name="ipv6AllowedForDualStack") + def ipv6_allowed_for_dual_stack(self) -> Optional[pulumi.Input[bool]]: + """ + Allow outbound IPv6 traffic on VPC canaries that are connected to dual-stack subnets if set to true + """ + return pulumi.get(self, "ipv6_allowed_for_dual_stack") + + @ipv6_allowed_for_dual_stack.setter + def ipv6_allowed_for_dual_stack(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "ipv6_allowed_for_dual_stack", value) + @property @pulumi.getter(name="vpcId") def vpc_id(self) -> Optional[pulumi.Input[str]]: diff --git a/sdk/python/pulumi_aws_native/synthetics/outputs.py b/sdk/python/pulumi_aws_native/synthetics/outputs.py index a6ec0ee16f..e8658f22ba 100644 --- a/sdk/python/pulumi_aws_native/synthetics/outputs.py +++ b/sdk/python/pulumi_aws_native/synthetics/outputs.py @@ -462,6 +462,8 @@ def __key_warning(key: str): suggest = "security_group_ids" elif key == "subnetIds": suggest = "subnet_ids" + elif key == "ipv6AllowedForDualStack": + suggest = "ipv6_allowed_for_dual_stack" elif key == "vpcId": suggest = "vpc_id" @@ -479,14 +481,18 @@ def get(self, key: str, default = None) -> Any: def __init__(__self__, *, security_group_ids: Sequence[str], subnet_ids: Sequence[str], + ipv6_allowed_for_dual_stack: Optional[bool] = None, vpc_id: Optional[str] = None): """ :param Sequence[str] security_group_ids: The IDs of the security groups for this canary. :param Sequence[str] subnet_ids: The IDs of the subnets where this canary is to run. + :param bool ipv6_allowed_for_dual_stack: Allow outbound IPv6 traffic on VPC canaries that are connected to dual-stack subnets if set to true :param str vpc_id: The ID of the VPC where this canary is to run. """ pulumi.set(__self__, "security_group_ids", security_group_ids) pulumi.set(__self__, "subnet_ids", subnet_ids) + if ipv6_allowed_for_dual_stack is not None: + pulumi.set(__self__, "ipv6_allowed_for_dual_stack", ipv6_allowed_for_dual_stack) if vpc_id is not None: pulumi.set(__self__, "vpc_id", vpc_id) @@ -506,6 +512,14 @@ def subnet_ids(self) -> Sequence[str]: """ return pulumi.get(self, "subnet_ids") + @property + @pulumi.getter(name="ipv6AllowedForDualStack") + def ipv6_allowed_for_dual_stack(self) -> Optional[bool]: + """ + Allow outbound IPv6 traffic on VPC canaries that are connected to dual-stack subnets if set to true + """ + return pulumi.get(self, "ipv6_allowed_for_dual_stack") + @property @pulumi.getter(name="vpcId") def vpc_id(self) -> Optional[str]: