diff --git a/.docs.version b/.docs.version index 6bc3539f8c..f2b3dd06ad 100644 --- a/.docs.version +++ b/.docs.version @@ -1 +1 @@ -3f0bd75e36846801897080920bf4c479aca57c01 +9460d1e13ded3a066026fe4ad23a2987b621a4a8 diff --git a/aws-cloudformation-schema/aws-ec2-placementgroup.json b/aws-cloudformation-schema/aws-ec2-placementgroup.json index c9694fa293..c20d05ddaa 100644 --- a/aws-cloudformation-schema/aws-ec2-placementgroup.json +++ b/aws-cloudformation-schema/aws-ec2-placementgroup.json @@ -58,7 +58,9 @@ "tagging" : { "taggable" : true, "tagUpdatable" : false, - "cloudFormationSystemTags" : false + "cloudFormationSystemTags" : false, + "tagProperty" : "/properties/Tags", + "permissions" : [ "ec2:CreateTags" ] }, "handlers" : { "create" : { diff --git a/aws-cloudformation-schema/aws-ec2-securitygroup.json b/aws-cloudformation-schema/aws-ec2-securitygroup.json index 5d2a5d477a..d3a4de122f 100644 --- a/aws-cloudformation-schema/aws-ec2-securitygroup.json +++ b/aws-cloudformation-schema/aws-ec2-securitygroup.json @@ -1,5 +1,6 @@ { "tagging" : { + "permissions" : [ "ec2:CreateTags", "ec2:DeleteTags" ], "taggable" : true, "tagOnCreate" : true, "tagUpdatable" : true, @@ -36,7 +37,7 @@ "permissions" : [ "ec2:DescribeSecurityGroups" ] }, "delete" : { - "permissions" : [ "ec2:DeleteSecurityGroup", "ec2:DescribeInstances" ] + "permissions" : [ "ec2:DescribeSecurityGroups", "ec2:DeleteSecurityGroup", "ec2:DescribeInstances" ] } }, "writeOnlyProperties" : [ "/properties/SecurityGroupIngress/*/SourceSecurityGroupName" ], diff --git a/aws-cloudformation-schema/aws-ec2-subnet.json b/aws-cloudformation-schema/aws-ec2-subnet.json index a7bef321bd..86361e90b9 100644 --- a/aws-cloudformation-schema/aws-ec2-subnet.json +++ b/aws-cloudformation-schema/aws-ec2-subnet.json @@ -61,7 +61,7 @@ }, "EnableDns64" : { "type" : "boolean", - "description" : "Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. For more information, see [DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-nat64-dns64) in the *User Guide*." + "description" : "Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations.\n You must first configure a NAT gateway in a public subnet (separate from the subnet containing the IPv6-only workloads). For example, the subnet containing the NAT gateway should have a ``0.0.0.0/0`` route pointing to the internet gateway. For more information, see [Configure DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/nat-gateway-nat64-dns64.html#nat-gateway-nat64-dns64-walkthrough) in the *User Guide*." }, "PrivateDnsNameOptionsOnLaunch" : { "type" : "object", diff --git a/aws-cloudformation-schema/aws-ec2-transitgatewayconnect.json b/aws-cloudformation-schema/aws-ec2-transitgatewayconnect.json index 29e60a9118..a3b8fe9a33 100644 --- a/aws-cloudformation-schema/aws-ec2-transitgatewayconnect.json +++ b/aws-cloudformation-schema/aws-ec2-transitgatewayconnect.json @@ -62,6 +62,13 @@ "additionalProperties" : false } }, + "tagging" : { + "taggable" : true, + "tagOnCreate" : true, + "tagUpdatable" : true, + "cloudFormationSystemTags" : false, + "tagProperty" : "/properties/Tags" + }, "additionalProperties" : false, "readOnlyProperties" : [ "/properties/TransitGatewayAttachmentId", "/properties/State", "/properties/CreationTime", "/properties/TransitGatewayId" ], "createOnlyProperties" : [ "/properties/TransportTransitGatewayAttachmentId", "/properties/Options" ], diff --git a/aws-cloudformation-schema/aws-redshift-cluster.json b/aws-cloudformation-schema/aws-redshift-cluster.json index facdedb022..422936b062 100644 --- a/aws-cloudformation-schema/aws-redshift-cluster.json +++ b/aws-cloudformation-schema/aws-redshift-cluster.json @@ -57,6 +57,17 @@ }, "S3KeyPrefix" : { "type" : "string" + }, + "LogDestinationType" : { + "type" : "string" + }, + "LogExports" : { + "maxItems" : 3, + "insertionOrder" : false, + "type" : "array", + "items" : { + "type" : "string" + } } } }, diff --git a/aws-cloudformation-schema/aws-route53resolver-resolverrule.json b/aws-cloudformation-schema/aws-route53resolver-resolverrule.json index 3535d73298..35b304c82d 100644 --- a/aws-cloudformation-schema/aws-route53resolver-resolverrule.json +++ b/aws-cloudformation-schema/aws-route53resolver-resolverrule.json @@ -25,7 +25,13 @@ "RuleType" : { "type" : "string", "description" : "When you want to forward DNS queries for specified domain name to resolvers on your network, specify FORWARD. When you have a forwarding rule to forward DNS queries for a domain to your network and you want Resolver to process queries for a subdomain of that domain, specify SYSTEM.", - "enum" : [ "FORWARD", "SYSTEM", "RECURSIVE" ] + "enum" : [ "FORWARD", "SYSTEM", "RECURSIVE", "DELEGATE" ] + }, + "DelegationRecord" : { + "type" : "string", + "description" : "The name server domain for queries to be delegated to if a query matches the delegation record.", + "minLength" : 1, + "maxLength" : 256 }, "Tags" : { "type" : "array", @@ -107,7 +113,7 @@ "cloudFormationSystemTags" : false, "tagProperty" : "/properties/Tags" }, - "required" : [ "DomainName", "RuleType" ], + "required" : [ "RuleType" ], "primaryIdentifier" : [ "/properties/ResolverRuleId" ], "readOnlyProperties" : [ "/properties/Arn", "/properties/ResolverRuleId" ], "createOnlyProperties" : [ "/properties/RuleType" ], diff --git a/provider/cmd/pulumi-gen-aws-native/supported-types.txt b/provider/cmd/pulumi-gen-aws-native/supported-types.txt index 0e444f3c88..5a8a9b3247 100644 --- a/provider/cmd/pulumi-gen-aws-native/supported-types.txt +++ b/provider/cmd/pulumi-gen-aws-native/supported-types.txt @@ -130,6 +130,8 @@ AWS::CleanRooms::AnalysisTemplate AWS::CleanRooms::Collaboration AWS::CleanRooms::ConfiguredTable AWS::CleanRooms::ConfiguredTableAssociation +AWS::CleanRooms::IdMappingTable +AWS::CleanRooms::IdNamespaceAssociation AWS::CleanRooms::Membership AWS::CleanRooms::PrivacyBudgetTemplate AWS::CleanRoomsML::TrainingDataset diff --git a/provider/cmd/pulumi-resource-aws-native/metadata.json b/provider/cmd/pulumi-resource-aws-native/metadata.json index f038a6c34b..e28bcf3317 100644 --- a/provider/cmd/pulumi-resource-aws-native/metadata.json +++ b/provider/cmd/pulumi-resource-aws-native/metadata.json @@ -12729,6 +12729,203 @@ "tagsProperty": "tags", "tagsStyle": "keyValueArray" }, + "aws-native:cleanrooms:IdMappingTable": { + "cf": "AWS::CleanRooms::IdMappingTable", + "inputs": { + "description": { + "type": "string", + "description": "The description of the ID mapping table." + }, + "inputReferenceConfig": { + "$ref": "#/types/aws-native:cleanrooms:IdMappingTableInputReferenceConfig", + "description": "The input reference configuration for the ID mapping table." + }, + "kmsKeyArn": { + "type": "string", + "description": "The Amazon Resource Name (ARN) of the AWS KMS key." + }, + "membershipIdentifier": { + "type": "string", + "description": "The unique identifier of the membership resource for the ID mapping table." + }, + "name": { + "type": "string", + "description": "The name of the ID mapping table." + }, + "tags": { + "type": "array", + "items": { + "$ref": "#/types/aws-native:index:Tag" + }, + "description": "An optional label that you can assign to a resource when you create it. Each tag consists of a key and an optional value, both of which you define. When you use tagging, you can also use tag-based access control in IAM policies to control access to this resource." + } + }, + "outputs": { + "arn": { + "type": "string", + "description": "The Amazon Resource Name (ARN) of the ID mapping table." + }, + "collaborationArn": { + "type": "string", + "description": "The Amazon Resource Name (ARN) of the collaboration that contains this ID mapping table." + }, + "collaborationIdentifier": { + "type": "string" + }, + "description": { + "type": "string", + "description": "The description of the ID mapping table." + }, + "idMappingTableIdentifier": { + "type": "string" + }, + "inputReferenceConfig": { + "$ref": "#/types/aws-native:cleanrooms:IdMappingTableInputReferenceConfig", + "description": "The input reference configuration for the ID mapping table.", + "replaceOnChanges": true + }, + "inputReferenceProperties": { + "$ref": "#/types/aws-native:cleanrooms:IdMappingTableInputReferenceProperties" + }, + "kmsKeyArn": { + "type": "string", + "description": "The Amazon Resource Name (ARN) of the AWS KMS key." + }, + "membershipArn": { + "type": "string", + "description": "The Amazon Resource Name (ARN) of the membership resource for the ID mapping table." + }, + "membershipIdentifier": { + "type": "string", + "description": "The unique identifier of the membership resource for the ID mapping table.", + "replaceOnChanges": true + }, + "name": { + "type": "string", + "description": "The name of the ID mapping table.", + "replaceOnChanges": true + }, + "tags": { + "type": "array", + "items": { + "$ref": "#/types/aws-native:index:Tag" + }, + "description": "An optional label that you can assign to a resource when you create it. Each tag consists of a key and an optional value, both of which you define. When you use tagging, you can also use tag-based access control in IAM policies to control access to this resource." + } + }, + "autoNamingSpec": { + "sdkName": "name", + "maxLength": 128 + }, + "required": [ + "inputReferenceConfig", + "membershipIdentifier" + ], + "createOnly": [ + "inputReferenceConfig", + "membershipIdentifier", + "name" + ], + "tagsProperty": "tags", + "tagsStyle": "keyValueArray" + }, + "aws-native:cleanrooms:IdNamespaceAssociation": { + "cf": "AWS::CleanRooms::IdNamespaceAssociation", + "inputs": { + "description": { + "type": "string", + "description": "The description of the ID namespace association." + }, + "idMappingConfig": { + "$ref": "#/types/aws-native:cleanrooms:IdNamespaceAssociationIdMappingConfig", + "description": "The configuration settings for the ID mapping table." + }, + "inputReferenceConfig": { + "$ref": "#/types/aws-native:cleanrooms:IdNamespaceAssociationInputReferenceConfig", + "description": "The input reference configuration for the ID namespace association." + }, + "membershipIdentifier": { + "type": "string", + "description": "The unique identifier of the membership that contains the ID namespace association." + }, + "name": { + "type": "string", + "description": "The name of this ID namespace association." + }, + "tags": { + "type": "array", + "items": { + "$ref": "#/types/aws-native:index:Tag" + } + } + }, + "outputs": { + "arn": { + "type": "string", + "description": "The Amazon Resource Name (ARN) of the ID namespace association." + }, + "collaborationArn": { + "type": "string", + "description": "The Amazon Resource Name (ARN) of the collaboration that contains this ID namespace association." + }, + "collaborationIdentifier": { + "type": "string" + }, + "description": { + "type": "string", + "description": "The description of the ID namespace association." + }, + "idMappingConfig": { + "$ref": "#/types/aws-native:cleanrooms:IdNamespaceAssociationIdMappingConfig", + "description": "The configuration settings for the ID mapping table." + }, + "idNamespaceAssociationIdentifier": { + "type": "string" + }, + "inputReferenceConfig": { + "$ref": "#/types/aws-native:cleanrooms:IdNamespaceAssociationInputReferenceConfig", + "description": "The input reference configuration for the ID namespace association.", + "replaceOnChanges": true + }, + "inputReferenceProperties": { + "$ref": "#/types/aws-native:cleanrooms:IdNamespaceAssociationInputReferenceProperties" + }, + "membershipArn": { + "type": "string", + "description": "The Amazon Resource Name (ARN) of the membership resource for this ID namespace association." + }, + "membershipIdentifier": { + "type": "string", + "description": "The unique identifier of the membership that contains the ID namespace association.", + "replaceOnChanges": true + }, + "name": { + "type": "string", + "description": "The name of this ID namespace association." + }, + "tags": { + "type": "array", + "items": { + "$ref": "#/types/aws-native:index:Tag" + } + } + }, + "autoNamingSpec": { + "sdkName": "name", + "minLength": 1, + "maxLength": 100 + }, + "required": [ + "inputReferenceConfig", + "membershipIdentifier" + ], + "createOnly": [ + "inputReferenceConfig", + "membershipIdentifier" + ], + "tagsProperty": "tags", + "tagsStyle": "keyValueArray" + }, "aws-native:cleanrooms:Membership": { "cf": "AWS::CleanRooms::Membership", "inputs": { @@ -31782,7 +31979,7 @@ }, "enableDns64": { "type": "boolean", - "description": "Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. For more information, see [DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-nat64-dns64) in the *User Guide*." + "description": "Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations.\n You must first configure a NAT gateway in a public subnet (separate from the subnet containing the IPv6-only workloads). For example, the subnet containing the NAT gateway should have a ``0.0.0.0/0`` route pointing to the internet gateway. For more information, see [Configure DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/nat-gateway-nat64-dns64.html#nat-gateway-nat64-dns64-walkthrough) in the *User Guide*." }, "enableLniAtDeviceIndex": { "type": "integer", @@ -31865,7 +32062,7 @@ }, "enableDns64": { "type": "boolean", - "description": "Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. For more information, see [DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-nat64-dns64) in the *User Guide*." + "description": "Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations.\n You must first configure a NAT gateway in a public subnet (separate from the subnet containing the IPv6-only workloads). For example, the subnet containing the NAT gateway should have a ``0.0.0.0/0`` route pointing to the internet gateway. For more information, see [Configure DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/nat-gateway-nat64-dns64.html#nat-gateway-nat64-dns64-walkthrough) in the *User Guide*." }, "enableLniAtDeviceIndex": { "type": "integer", @@ -79310,6 +79507,10 @@ "aws-native:route53resolver:ResolverRule": { "cf": "AWS::Route53Resolver::ResolverRule", "inputs": { + "delegationRecord": { + "type": "string", + "description": "The name server domain for queries to be delegated to if a query matches the delegation record." + }, "domainName": { "type": "string", "description": "DNS queries for this domain name are forwarded to the IP addresses that are specified in TargetIps" @@ -79346,6 +79547,10 @@ "type": "string", "description": "The Amazon Resource Name (ARN) of the resolver rule." }, + "delegationRecord": { + "type": "string", + "description": "The name server domain for queries to be delegated to if a query matches the delegation record." + }, "domainName": { "type": "string", "description": "DNS queries for this domain name are forwarded to the IP addresses that are specified in TargetIps" @@ -79387,7 +79592,6 @@ "maxLength": 64 }, "required": [ - "domainName", "ruleType" ], "createOnly": [ @@ -106111,6 +106315,117 @@ } } }, + "aws-native:cleanrooms:IdMappingTableInputReferenceConfig": { + "type": "object", + "properties": { + "inputReferenceArn": { + "type": "string", + "description": "The Amazon Resource Name (ARN) of the referenced resource in AWS Entity Resolution . Valid values are ID mapping workflow ARNs." + }, + "manageResourcePolicies": { + "type": "boolean", + "description": "When `TRUE` , AWS Clean Rooms manages permissions for the ID mapping table resource.\n\nWhen `FALSE` , the resource owner manages permissions for the ID mapping table resource." + } + } + }, + "aws-native:cleanrooms:IdMappingTableInputReferenceProperties": { + "type": "object", + "properties": { + "idMappingTableInputSource": { + "type": "array", + "items": { + "$ref": "#/types/aws-native:cleanrooms:IdMappingTableInputSource" + }, + "description": "The input source of the ID mapping table." + } + } + }, + "aws-native:cleanrooms:IdMappingTableInputSource": { + "type": "object", + "properties": { + "idNamespaceAssociationId": { + "type": "string", + "description": "The unique identifier of the ID namespace association." + }, + "type": { + "$ref": "#/types/aws-native:cleanrooms:IdMappingTableInputSourceType", + "description": "The type of the input source of the ID mapping table." + } + } + }, + "aws-native:cleanrooms:IdMappingTableInputSourceType": { + "type": "string" + }, + "aws-native:cleanrooms:IdMappingTableTag": { + "type": "object", + "properties": { + "key": { + "type": "string", + "description": "The key of the tag." + }, + "value": { + "type": "string", + "description": "The value of the tag." + } + } + }, + "aws-native:cleanrooms:IdNamespaceAssociationDocument": { + "type": "object" + }, + "aws-native:cleanrooms:IdNamespaceAssociationIdMappingConfig": { + "type": "object", + "properties": { + "allowUseAsDimensionColumn": { + "type": "boolean", + "description": "An indicator as to whether you can use your column as a dimension column in the ID mapping table ( `TRUE` ) or not ( `FALSE` ).\n\nDefault is `FALSE` ." + } + } + }, + "aws-native:cleanrooms:IdNamespaceAssociationInputReferenceConfig": { + "type": "object", + "properties": { + "inputReferenceArn": { + "type": "string", + "description": "The Amazon Resource Name (ARN) of the AWS Entity Resolution resource that is being associated to the collaboration. Valid resource ARNs are from the ID namespaces that you own." + }, + "manageResourcePolicies": { + "type": "boolean", + "description": "When `TRUE` , AWS Clean Rooms manages permissions for the ID namespace association resource.\n\nWhen `FALSE` , the resource owner manages permissions for the ID namespace association resource." + } + } + }, + "aws-native:cleanrooms:IdNamespaceAssociationInputReferenceProperties": { + "type": "object", + "properties": { + "idMappingWorkflowsSupported": { + "type": "array", + "items": { + "$ref": "#/types/aws-native:cleanrooms:IdNamespaceAssociationDocument" + }, + "description": "Defines how ID mapping workflows are supported for this ID namespace association." + }, + "idNamespaceType": { + "$ref": "#/types/aws-native:cleanrooms:IdNamespaceAssociationInputReferencePropertiesIdNamespaceType", + "description": "The ID namespace type for this ID namespace association." + } + } + }, + "aws-native:cleanrooms:IdNamespaceAssociationInputReferencePropertiesIdNamespaceType": { + "type": "string" + }, + "aws-native:cleanrooms:IdNamespaceAssociationTag": { + "type": "object", + "properties": { + "key": { + "type": "string", + "description": "The key of the tag." + }, + "value": { + "type": "string", + "description": "The value of the tag." + } + } + }, "aws-native:cleanrooms:MembershipPaymentConfiguration": { "type": "object", "properties": { @@ -187674,6 +187989,15 @@ "type": "string", "description": "The name of an existing S3 bucket where the log files are to be stored.\n\nConstraints:\n\n- Must be in the same region as the cluster\n- The cluster must have read bucket and put object permissions" }, + "logDestinationType": { + "type": "string" + }, + "logExports": { + "type": "array", + "items": { + "type": "string" + } + }, "s3KeyPrefix": { "type": "string", "description": "The prefix applied to the log file names.\n\nConstraints:\n\n- Cannot exceed 512 characters\n- Cannot contain spaces( ), double quotes (\"), single quotes ('), a backslash (\\), or control characters. The hexadecimal codes for invalid characters are:\n\n- x00 to x20\n- x22\n- x27\n- x5c\n- x7f or larger" @@ -207101,6 +207425,20 @@ "membershipIdentifier" ] }, + "aws-native:cleanrooms:getIdMappingTable": { + "cf": "AWS::CleanRooms::IdMappingTable", + "ids": [ + "idMappingTableIdentifier", + "membershipIdentifier" + ] + }, + "aws-native:cleanrooms:getIdNamespaceAssociation": { + "cf": "AWS::CleanRooms::IdNamespaceAssociation", + "ids": [ + "idNamespaceAssociationIdentifier", + "membershipIdentifier" + ] + }, "aws-native:cleanrooms:getMembership": { "cf": "AWS::CleanRooms::Membership", "ids": [ diff --git a/provider/cmd/pulumi-resource-aws-native/schema.json b/provider/cmd/pulumi-resource-aws-native/schema.json index 5fdd740f9a..99fcf6d3b1 100644 --- a/provider/cmd/pulumi-resource-aws-native/schema.json +++ b/provider/cmd/pulumi-resource-aws-native/schema.json @@ -19167,6 +19167,165 @@ "value" ] }, + "aws-native:cleanrooms:IdMappingTableInputReferenceConfig": { + "properties": { + "inputReferenceArn": { + "type": "string", + "description": "The Amazon Resource Name (ARN) of the referenced resource in AWS Entity Resolution . Valid values are ID mapping workflow ARNs." + }, + "manageResourcePolicies": { + "type": "boolean", + "description": "When `TRUE` , AWS Clean Rooms manages permissions for the ID mapping table resource.\n\nWhen `FALSE` , the resource owner manages permissions for the ID mapping table resource." + } + }, + "type": "object", + "required": [ + "inputReferenceArn", + "manageResourcePolicies" + ] + }, + "aws-native:cleanrooms:IdMappingTableInputReferenceProperties": { + "properties": { + "idMappingTableInputSource": { + "type": "array", + "items": { + "$ref": "#/types/aws-native:cleanrooms:IdMappingTableInputSource" + }, + "description": "The input source of the ID mapping table." + } + }, + "type": "object", + "required": [ + "idMappingTableInputSource" + ] + }, + "aws-native:cleanrooms:IdMappingTableInputSource": { + "properties": { + "idNamespaceAssociationId": { + "type": "string", + "description": "The unique identifier of the ID namespace association." + }, + "type": { + "$ref": "#/types/aws-native:cleanrooms:IdMappingTableInputSourceType", + "description": "The type of the input source of the ID mapping table." + } + }, + "type": "object", + "required": [ + "idNamespaceAssociationId", + "type" + ] + }, + "aws-native:cleanrooms:IdMappingTableInputSourceType": { + "description": "The type of the input source of the ID mapping table.", + "type": "string", + "enum": [ + { + "name": "Source", + "value": "SOURCE" + }, + { + "name": "Target", + "value": "TARGET" + } + ] + }, + "aws-native:cleanrooms:IdMappingTableTag": { + "properties": { + "key": { + "type": "string", + "description": "The key of the tag." + }, + "value": { + "type": "string", + "description": "The value of the tag." + } + }, + "type": "object", + "required": [ + "key", + "value" + ] + }, + "aws-native:cleanrooms:IdNamespaceAssociationDocument": { + "type": "object" + }, + "aws-native:cleanrooms:IdNamespaceAssociationIdMappingConfig": { + "properties": { + "allowUseAsDimensionColumn": { + "type": "boolean", + "description": "An indicator as to whether you can use your column as a dimension column in the ID mapping table ( `TRUE` ) or not ( `FALSE` ).\n\nDefault is `FALSE` ." + } + }, + "type": "object", + "required": [ + "allowUseAsDimensionColumn" + ] + }, + "aws-native:cleanrooms:IdNamespaceAssociationInputReferenceConfig": { + "properties": { + "inputReferenceArn": { + "type": "string", + "description": "The Amazon Resource Name (ARN) of the AWS Entity Resolution resource that is being associated to the collaboration. Valid resource ARNs are from the ID namespaces that you own." + }, + "manageResourcePolicies": { + "type": "boolean", + "description": "When `TRUE` , AWS Clean Rooms manages permissions for the ID namespace association resource.\n\nWhen `FALSE` , the resource owner manages permissions for the ID namespace association resource." + } + }, + "type": "object", + "required": [ + "inputReferenceArn", + "manageResourcePolicies" + ] + }, + "aws-native:cleanrooms:IdNamespaceAssociationInputReferenceProperties": { + "properties": { + "idMappingWorkflowsSupported": { + "type": "array", + "items": { + "$ref": "#/types/aws-native:cleanrooms:IdNamespaceAssociationDocument" + }, + "description": "Defines how ID mapping workflows are supported for this ID namespace association." + }, + "idNamespaceType": { + "$ref": "#/types/aws-native:cleanrooms:IdNamespaceAssociationInputReferencePropertiesIdNamespaceType", + "description": "The ID namespace type for this ID namespace association." + } + }, + "type": "object" + }, + "aws-native:cleanrooms:IdNamespaceAssociationInputReferencePropertiesIdNamespaceType": { + "description": "The ID namespace type for this ID namespace association.", + "type": "string", + "enum": [ + { + "name": "Source", + "value": "SOURCE" + }, + { + "name": "Target", + "value": "TARGET" + } + ] + }, + "aws-native:cleanrooms:IdNamespaceAssociationTag": { + "properties": { + "key": { + "type": "string", + "description": "The key of the tag." + }, + "value": { + "type": "string", + "description": "The value of the tag." + } + }, + "type": "object", + "required": [ + "key", + "value" + ] + }, "aws-native:cleanrooms:MembershipPaymentConfiguration": { "properties": { "queryCompute": { @@ -131159,6 +131318,15 @@ "type": "string", "description": "The name of an existing S3 bucket where the log files are to be stored.\n\nConstraints:\n\n- Must be in the same region as the cluster\n- The cluster must have read bucket and put object permissions" }, + "logDestinationType": { + "type": "string" + }, + "logExports": { + "type": "array", + "items": { + "type": "string" + } + }, "s3KeyPrefix": { "type": "string", "description": "The prefix applied to the log file names.\n\nConstraints:\n\n- Cannot exceed 512 characters\n- Cannot contain spaces( ), double quotes (\"), single quotes ('), a backslash (\\), or control characters. The hexadecimal codes for invalid characters are:\n\n- x00 to x20\n- x22\n- x27\n- x5c\n- x7f or larger" @@ -134269,6 +134437,10 @@ { "name": "Recursive", "value": "RECURSIVE" + }, + { + "name": "Delegate", + "value": "DELEGATE" } ] }, @@ -172313,6 +172485,205 @@ "roleArn" ] }, + "aws-native:cleanrooms:IdMappingTable": { + "description": "Represents an association between an ID mapping workflow and a collaboration", + "properties": { + "arn": { + "type": "string", + "description": "The Amazon Resource Name (ARN) of the ID mapping table." + }, + "collaborationArn": { + "type": "string", + "description": "The Amazon Resource Name (ARN) of the collaboration that contains this ID mapping table." + }, + "collaborationIdentifier": { + "type": "string" + }, + "description": { + "type": "string", + "description": "The description of the ID mapping table." + }, + "idMappingTableIdentifier": { + "type": "string" + }, + "inputReferenceConfig": { + "$ref": "#/types/aws-native:cleanrooms:IdMappingTableInputReferenceConfig", + "description": "The input reference configuration for the ID mapping table.", + "replaceOnChanges": true + }, + "inputReferenceProperties": { + "$ref": "#/types/aws-native:cleanrooms:IdMappingTableInputReferenceProperties" + }, + "kmsKeyArn": { + "type": "string", + "description": "The Amazon Resource Name (ARN) of the AWS KMS key." + }, + "membershipArn": { + "type": "string", + "description": "The Amazon Resource Name (ARN) of the membership resource for the ID mapping table." + }, + "membershipIdentifier": { + "type": "string", + "description": "The unique identifier of the membership resource for the ID mapping table.", + "replaceOnChanges": true + }, + "name": { + "type": "string", + "description": "The name of the ID mapping table.", + "replaceOnChanges": true + }, + "tags": { + "type": "array", + "items": { + "$ref": "#/types/aws-native:index:Tag" + }, + "description": "An optional label that you can assign to a resource when you create it. Each tag consists of a key and an optional value, both of which you define. When you use tagging, you can also use tag-based access control in IAM policies to control access to this resource." + } + }, + "type": "object", + "required": [ + "arn", + "collaborationArn", + "collaborationIdentifier", + "idMappingTableIdentifier", + "inputReferenceConfig", + "inputReferenceProperties", + "membershipArn", + "membershipIdentifier", + "name" + ], + "inputProperties": { + "description": { + "type": "string", + "description": "The description of the ID mapping table." + }, + "inputReferenceConfig": { + "$ref": "#/types/aws-native:cleanrooms:IdMappingTableInputReferenceConfig", + "description": "The input reference configuration for the ID mapping table." + }, + "kmsKeyArn": { + "type": "string", + "description": "The Amazon Resource Name (ARN) of the AWS KMS key." + }, + "membershipIdentifier": { + "type": "string", + "description": "The unique identifier of the membership resource for the ID mapping table." + }, + "name": { + "type": "string", + "description": "The name of the ID mapping table." + }, + "tags": { + "type": "array", + "items": { + "$ref": "#/types/aws-native:index:Tag" + }, + "description": "An optional label that you can assign to a resource when you create it. Each tag consists of a key and an optional value, both of which you define. When you use tagging, you can also use tag-based access control in IAM policies to control access to this resource." + } + }, + "requiredInputs": [ + "inputReferenceConfig", + "membershipIdentifier" + ] + }, + "aws-native:cleanrooms:IdNamespaceAssociation": { + "description": "Represents an association between an ID namespace and a collaboration", + "properties": { + "arn": { + "type": "string", + "description": "The Amazon Resource Name (ARN) of the ID namespace association." + }, + "collaborationArn": { + "type": "string", + "description": "The Amazon Resource Name (ARN) of the collaboration that contains this ID namespace association." + }, + "collaborationIdentifier": { + "type": "string" + }, + "description": { + "type": "string", + "description": "The description of the ID namespace association." + }, + "idMappingConfig": { + "$ref": "#/types/aws-native:cleanrooms:IdNamespaceAssociationIdMappingConfig", + "description": "The configuration settings for the ID mapping table." + }, + "idNamespaceAssociationIdentifier": { + "type": "string" + }, + "inputReferenceConfig": { + "$ref": "#/types/aws-native:cleanrooms:IdNamespaceAssociationInputReferenceConfig", + "description": "The input reference configuration for the ID namespace association.", + "replaceOnChanges": true + }, + "inputReferenceProperties": { + "$ref": "#/types/aws-native:cleanrooms:IdNamespaceAssociationInputReferenceProperties" + }, + "membershipArn": { + "type": "string", + "description": "The Amazon Resource Name (ARN) of the membership resource for this ID namespace association." + }, + "membershipIdentifier": { + "type": "string", + "description": "The unique identifier of the membership that contains the ID namespace association.", + "replaceOnChanges": true + }, + "name": { + "type": "string", + "description": "The name of this ID namespace association." + }, + "tags": { + "type": "array", + "items": { + "$ref": "#/types/aws-native:index:Tag" + } + } + }, + "type": "object", + "required": [ + "arn", + "collaborationArn", + "collaborationIdentifier", + "idNamespaceAssociationIdentifier", + "inputReferenceConfig", + "inputReferenceProperties", + "membershipArn", + "membershipIdentifier", + "name" + ], + "inputProperties": { + "description": { + "type": "string", + "description": "The description of the ID namespace association." + }, + "idMappingConfig": { + "$ref": "#/types/aws-native:cleanrooms:IdNamespaceAssociationIdMappingConfig", + "description": "The configuration settings for the ID mapping table." + }, + "inputReferenceConfig": { + "$ref": "#/types/aws-native:cleanrooms:IdNamespaceAssociationInputReferenceConfig", + "description": "The input reference configuration for the ID namespace association." + }, + "membershipIdentifier": { + "type": "string", + "description": "The unique identifier of the membership that contains the ID namespace association." + }, + "name": { + "type": "string", + "description": "The name of this ID namespace association." + }, + "tags": { + "type": "array", + "items": { + "$ref": "#/types/aws-native:index:Tag" + } + } + }, + "requiredInputs": [ + "inputReferenceConfig", + "membershipIdentifier" + ] + }, "aws-native:cleanrooms:Membership": { "description": "Represents an AWS account that is a part of a collaboration", "properties": { @@ -190936,7 +191307,7 @@ }, "enableDns64": { "type": "boolean", - "description": "Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. For more information, see [DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-nat64-dns64) in the *User Guide*." + "description": "Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations.\n You must first configure a NAT gateway in a public subnet (separate from the subnet containing the IPv6-only workloads). For example, the subnet containing the NAT gateway should have a ``0.0.0.0/0`` route pointing to the internet gateway. For more information, see [Configure DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/nat-gateway-nat64-dns64.html#nat-gateway-nat64-dns64-walkthrough) in the *User Guide*." }, "enableLniAtDeviceIndex": { "type": "integer", @@ -191037,7 +191408,7 @@ }, "enableDns64": { "type": "boolean", - "description": "Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. For more information, see [DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-nat64-dns64) in the *User Guide*." + "description": "Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations.\n You must first configure a NAT gateway in a public subnet (separate from the subnet containing the IPv6-only workloads). For example, the subnet containing the NAT gateway should have a ``0.0.0.0/0`` route pointing to the internet gateway. For more information, see [Configure DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/nat-gateway-nat64-dns64.html#nat-gateway-nat64-dns64-walkthrough) in the *User Guide*." }, "enableLniAtDeviceIndex": { "type": "integer", @@ -236847,6 +237218,10 @@ "type": "string", "description": "The Amazon Resource Name (ARN) of the resolver rule." }, + "delegationRecord": { + "type": "string", + "description": "The name server domain for queries to be delegated to if a query matches the delegation record." + }, "domainName": { "type": "string", "description": "DNS queries for this domain name are forwarded to the IP addresses that are specified in TargetIps" @@ -236886,11 +237261,14 @@ "type": "object", "required": [ "arn", - "domainName", "resolverRuleId", "ruleType" ], "inputProperties": { + "delegationRecord": { + "type": "string", + "description": "The name server domain for queries to be delegated to if a query matches the delegation record." + }, "domainName": { "type": "string", "description": "DNS queries for this domain name are forwarded to the IP addresses that are specified in TargetIps" @@ -236923,7 +237301,6 @@ } }, "requiredInputs": [ - "domainName", "ruleType" ] }, @@ -256889,6 +257266,125 @@ } } }, + "aws-native:cleanrooms:getIdMappingTable": { + "description": "Represents an association between an ID mapping workflow and a collaboration", + "inputs": { + "properties": { + "idMappingTableIdentifier": { + "type": "string" + }, + "membershipIdentifier": { + "type": "string", + "description": "The unique identifier of the membership resource for the ID mapping table." + } + }, + "required": [ + "idMappingTableIdentifier", + "membershipIdentifier" + ] + }, + "outputs": { + "properties": { + "arn": { + "type": "string", + "description": "The Amazon Resource Name (ARN) of the ID mapping table." + }, + "collaborationArn": { + "type": "string", + "description": "The Amazon Resource Name (ARN) of the collaboration that contains this ID mapping table." + }, + "collaborationIdentifier": { + "type": "string" + }, + "description": { + "type": "string", + "description": "The description of the ID mapping table." + }, + "idMappingTableIdentifier": { + "type": "string" + }, + "inputReferenceProperties": { + "$ref": "#/types/aws-native:cleanrooms:IdMappingTableInputReferenceProperties" + }, + "kmsKeyArn": { + "type": "string", + "description": "The Amazon Resource Name (ARN) of the AWS KMS key." + }, + "membershipArn": { + "type": "string", + "description": "The Amazon Resource Name (ARN) of the membership resource for the ID mapping table." + }, + "tags": { + "type": "array", + "items": { + "$ref": "#/types/aws-native:index:Tag" + }, + "description": "An optional label that you can assign to a resource when you create it. Each tag consists of a key and an optional value, both of which you define. When you use tagging, you can also use tag-based access control in IAM policies to control access to this resource." + } + } + } + }, + "aws-native:cleanrooms:getIdNamespaceAssociation": { + "description": "Represents an association between an ID namespace and a collaboration", + "inputs": { + "properties": { + "idNamespaceAssociationIdentifier": { + "type": "string" + }, + "membershipIdentifier": { + "type": "string", + "description": "The unique identifier of the membership that contains the ID namespace association." + } + }, + "required": [ + "idNamespaceAssociationIdentifier", + "membershipIdentifier" + ] + }, + "outputs": { + "properties": { + "arn": { + "type": "string", + "description": "The Amazon Resource Name (ARN) of the ID namespace association." + }, + "collaborationArn": { + "type": "string", + "description": "The Amazon Resource Name (ARN) of the collaboration that contains this ID namespace association." + }, + "collaborationIdentifier": { + "type": "string" + }, + "description": { + "type": "string", + "description": "The description of the ID namespace association." + }, + "idMappingConfig": { + "$ref": "#/types/aws-native:cleanrooms:IdNamespaceAssociationIdMappingConfig", + "description": "The configuration settings for the ID mapping table." + }, + "idNamespaceAssociationIdentifier": { + "type": "string" + }, + "inputReferenceProperties": { + "$ref": "#/types/aws-native:cleanrooms:IdNamespaceAssociationInputReferenceProperties" + }, + "membershipArn": { + "type": "string", + "description": "The Amazon Resource Name (ARN) of the membership resource for this ID namespace association." + }, + "name": { + "type": "string", + "description": "The name of this ID namespace association." + }, + "tags": { + "type": "array", + "items": { + "$ref": "#/types/aws-native:index:Tag" + } + } + } + } + }, "aws-native:cleanrooms:getMembership": { "description": "Represents an AWS account that is a part of a collaboration", "inputs": { @@ -266685,7 +267181,7 @@ }, "enableDns64": { "type": "boolean", - "description": "Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. For more information, see [DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-nat64-dns64) in the *User Guide*." + "description": "Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations.\n You must first configure a NAT gateway in a public subnet (separate from the subnet containing the IPv6-only workloads). For example, the subnet containing the NAT gateway should have a ``0.0.0.0/0`` route pointing to the internet gateway. For more information, see [Configure DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/nat-gateway-nat64-dns64.html#nat-gateway-nat64-dns64-walkthrough) in the *User Guide*." }, "ipv6CidrBlock": { "type": "string", @@ -290415,6 +290911,10 @@ "type": "string", "description": "The Amazon Resource Name (ARN) of the resolver rule." }, + "delegationRecord": { + "type": "string", + "description": "The name server domain for queries to be delegated to if a query matches the delegation record." + }, "domainName": { "type": "string", "description": "DNS queries for this domain name are forwarded to the IP addresses that are specified in TargetIps" diff --git a/reports/missedAutonaming.json b/reports/missedAutonaming.json index b0618c6c9a..056cab21c4 100644 --- a/reports/missedAutonaming.json +++ b/reports/missedAutonaming.json @@ -4883,7 +4883,7 @@ }, "enableDns64": { "type": "boolean", - "description": "Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. For more information, see [DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-nat64-dns64) in the *User Guide*." + "description": "Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations.\n You must first configure a NAT gateway in a public subnet (separate from the subnet containing the IPv6-only workloads). For example, the subnet containing the NAT gateway should have a ``0.0.0.0/0`` route pointing to the internet gateway. For more information, see [Configure DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/nat-gateway-nat64-dns64.html#nat-gateway-nat64-dns64-walkthrough) in the *User Guide*." }, "enableLniAtDeviceIndex": { "type": "integer", diff --git a/sdk/dotnet/CleanRooms/Enums.cs b/sdk/dotnet/CleanRooms/Enums.cs index 12b87d3049..c15e0fbf6c 100644 --- a/sdk/dotnet/CleanRooms/Enums.cs +++ b/sdk/dotnet/CleanRooms/Enums.cs @@ -414,6 +414,68 @@ private ConfiguredTableScalarFunctions(string value) public override string ToString() => _value; } + /// + /// The type of the input source of the ID mapping table. + /// + [EnumType] + public readonly struct IdMappingTableInputSourceType : IEquatable + { + private readonly string _value; + + private IdMappingTableInputSourceType(string value) + { + _value = value ?? throw new ArgumentNullException(nameof(value)); + } + + public static IdMappingTableInputSourceType Source { get; } = new IdMappingTableInputSourceType("SOURCE"); + public static IdMappingTableInputSourceType Target { get; } = new IdMappingTableInputSourceType("TARGET"); + + public static bool operator ==(IdMappingTableInputSourceType left, IdMappingTableInputSourceType right) => left.Equals(right); + public static bool operator !=(IdMappingTableInputSourceType left, IdMappingTableInputSourceType right) => !left.Equals(right); + + public static explicit operator string(IdMappingTableInputSourceType value) => value._value; + + [EditorBrowsable(EditorBrowsableState.Never)] + public override bool Equals(object? obj) => obj is IdMappingTableInputSourceType other && Equals(other); + public bool Equals(IdMappingTableInputSourceType other) => string.Equals(_value, other._value, StringComparison.Ordinal); + + [EditorBrowsable(EditorBrowsableState.Never)] + public override int GetHashCode() => _value?.GetHashCode() ?? 0; + + public override string ToString() => _value; + } + + /// + /// The ID namespace type for this ID namespace association. + /// + [EnumType] + public readonly struct IdNamespaceAssociationInputReferencePropertiesIdNamespaceType : IEquatable + { + private readonly string _value; + + private IdNamespaceAssociationInputReferencePropertiesIdNamespaceType(string value) + { + _value = value ?? throw new ArgumentNullException(nameof(value)); + } + + public static IdNamespaceAssociationInputReferencePropertiesIdNamespaceType Source { get; } = new IdNamespaceAssociationInputReferencePropertiesIdNamespaceType("SOURCE"); + public static IdNamespaceAssociationInputReferencePropertiesIdNamespaceType Target { get; } = new IdNamespaceAssociationInputReferencePropertiesIdNamespaceType("TARGET"); + + public static bool operator ==(IdNamespaceAssociationInputReferencePropertiesIdNamespaceType left, IdNamespaceAssociationInputReferencePropertiesIdNamespaceType right) => left.Equals(right); + public static bool operator !=(IdNamespaceAssociationInputReferencePropertiesIdNamespaceType left, IdNamespaceAssociationInputReferencePropertiesIdNamespaceType right) => !left.Equals(right); + + public static explicit operator string(IdNamespaceAssociationInputReferencePropertiesIdNamespaceType value) => value._value; + + [EditorBrowsable(EditorBrowsableState.Never)] + public override bool Equals(object? obj) => obj is IdNamespaceAssociationInputReferencePropertiesIdNamespaceType other && Equals(other); + public bool Equals(IdNamespaceAssociationInputReferencePropertiesIdNamespaceType 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 MembershipQueryLogStatus : IEquatable { diff --git a/sdk/dotnet/CleanRooms/GetIdMappingTable.cs b/sdk/dotnet/CleanRooms/GetIdMappingTable.cs new file mode 100644 index 0000000000..6b429c40fe --- /dev/null +++ b/sdk/dotnet/CleanRooms/GetIdMappingTable.cs @@ -0,0 +1,125 @@ +// *** 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.CleanRooms +{ + public static class GetIdMappingTable + { + /// + /// Represents an association between an ID mapping workflow and a collaboration + /// + public static Task InvokeAsync(GetIdMappingTableArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("aws-native:cleanrooms:getIdMappingTable", args ?? new GetIdMappingTableArgs(), options.WithDefaults()); + + /// + /// Represents an association between an ID mapping workflow and a collaboration + /// + public static Output Invoke(GetIdMappingTableInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("aws-native:cleanrooms:getIdMappingTable", args ?? new GetIdMappingTableInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetIdMappingTableArgs : global::Pulumi.InvokeArgs + { + [Input("idMappingTableIdentifier", required: true)] + public string IdMappingTableIdentifier { get; set; } = null!; + + /// + /// The unique identifier of the membership resource for the ID mapping table. + /// + [Input("membershipIdentifier", required: true)] + public string MembershipIdentifier { get; set; } = null!; + + public GetIdMappingTableArgs() + { + } + public static new GetIdMappingTableArgs Empty => new GetIdMappingTableArgs(); + } + + public sealed class GetIdMappingTableInvokeArgs : global::Pulumi.InvokeArgs + { + [Input("idMappingTableIdentifier", required: true)] + public Input IdMappingTableIdentifier { get; set; } = null!; + + /// + /// The unique identifier of the membership resource for the ID mapping table. + /// + [Input("membershipIdentifier", required: true)] + public Input MembershipIdentifier { get; set; } = null!; + + public GetIdMappingTableInvokeArgs() + { + } + public static new GetIdMappingTableInvokeArgs Empty => new GetIdMappingTableInvokeArgs(); + } + + + [OutputType] + public sealed class GetIdMappingTableResult + { + /// + /// The Amazon Resource Name (ARN) of the ID mapping table. + /// + public readonly string? Arn; + /// + /// The Amazon Resource Name (ARN) of the collaboration that contains this ID mapping table. + /// + public readonly string? CollaborationArn; + public readonly string? CollaborationIdentifier; + /// + /// The description of the ID mapping table. + /// + public readonly string? Description; + public readonly string? IdMappingTableIdentifier; + public readonly Outputs.IdMappingTableInputReferenceProperties? InputReferenceProperties; + /// + /// The Amazon Resource Name (ARN) of the AWS KMS key. + /// + public readonly string? KmsKeyArn; + /// + /// The Amazon Resource Name (ARN) of the membership resource for the ID mapping table. + /// + public readonly string? MembershipArn; + /// + /// An optional label that you can assign to a resource when you create it. Each tag consists of a key and an optional value, both of which you define. When you use tagging, you can also use tag-based access control in IAM policies to control access to this resource. + /// + public readonly ImmutableArray Tags; + + [OutputConstructor] + private GetIdMappingTableResult( + string? arn, + + string? collaborationArn, + + string? collaborationIdentifier, + + string? description, + + string? idMappingTableIdentifier, + + Outputs.IdMappingTableInputReferenceProperties? inputReferenceProperties, + + string? kmsKeyArn, + + string? membershipArn, + + ImmutableArray tags) + { + Arn = arn; + CollaborationArn = collaborationArn; + CollaborationIdentifier = collaborationIdentifier; + Description = description; + IdMappingTableIdentifier = idMappingTableIdentifier; + InputReferenceProperties = inputReferenceProperties; + KmsKeyArn = kmsKeyArn; + MembershipArn = membershipArn; + Tags = tags; + } + } +} diff --git a/sdk/dotnet/CleanRooms/GetIdNamespaceAssociation.cs b/sdk/dotnet/CleanRooms/GetIdNamespaceAssociation.cs new file mode 100644 index 0000000000..37ba964358 --- /dev/null +++ b/sdk/dotnet/CleanRooms/GetIdNamespaceAssociation.cs @@ -0,0 +1,129 @@ +// *** 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.CleanRooms +{ + public static class GetIdNamespaceAssociation + { + /// + /// Represents an association between an ID namespace and a collaboration + /// + public static Task InvokeAsync(GetIdNamespaceAssociationArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("aws-native:cleanrooms:getIdNamespaceAssociation", args ?? new GetIdNamespaceAssociationArgs(), options.WithDefaults()); + + /// + /// Represents an association between an ID namespace and a collaboration + /// + public static Output Invoke(GetIdNamespaceAssociationInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("aws-native:cleanrooms:getIdNamespaceAssociation", args ?? new GetIdNamespaceAssociationInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetIdNamespaceAssociationArgs : global::Pulumi.InvokeArgs + { + [Input("idNamespaceAssociationIdentifier", required: true)] + public string IdNamespaceAssociationIdentifier { get; set; } = null!; + + /// + /// The unique identifier of the membership that contains the ID namespace association. + /// + [Input("membershipIdentifier", required: true)] + public string MembershipIdentifier { get; set; } = null!; + + public GetIdNamespaceAssociationArgs() + { + } + public static new GetIdNamespaceAssociationArgs Empty => new GetIdNamespaceAssociationArgs(); + } + + public sealed class GetIdNamespaceAssociationInvokeArgs : global::Pulumi.InvokeArgs + { + [Input("idNamespaceAssociationIdentifier", required: true)] + public Input IdNamespaceAssociationIdentifier { get; set; } = null!; + + /// + /// The unique identifier of the membership that contains the ID namespace association. + /// + [Input("membershipIdentifier", required: true)] + public Input MembershipIdentifier { get; set; } = null!; + + public GetIdNamespaceAssociationInvokeArgs() + { + } + public static new GetIdNamespaceAssociationInvokeArgs Empty => new GetIdNamespaceAssociationInvokeArgs(); + } + + + [OutputType] + public sealed class GetIdNamespaceAssociationResult + { + /// + /// The Amazon Resource Name (ARN) of the ID namespace association. + /// + public readonly string? Arn; + /// + /// The Amazon Resource Name (ARN) of the collaboration that contains this ID namespace association. + /// + public readonly string? CollaborationArn; + public readonly string? CollaborationIdentifier; + /// + /// The description of the ID namespace association. + /// + public readonly string? Description; + /// + /// The configuration settings for the ID mapping table. + /// + public readonly Outputs.IdNamespaceAssociationIdMappingConfig? IdMappingConfig; + public readonly string? IdNamespaceAssociationIdentifier; + public readonly Outputs.IdNamespaceAssociationInputReferenceProperties? InputReferenceProperties; + /// + /// The Amazon Resource Name (ARN) of the membership resource for this ID namespace association. + /// + public readonly string? MembershipArn; + /// + /// The name of this ID namespace association. + /// + public readonly string? Name; + public readonly ImmutableArray Tags; + + [OutputConstructor] + private GetIdNamespaceAssociationResult( + string? arn, + + string? collaborationArn, + + string? collaborationIdentifier, + + string? description, + + Outputs.IdNamespaceAssociationIdMappingConfig? idMappingConfig, + + string? idNamespaceAssociationIdentifier, + + Outputs.IdNamespaceAssociationInputReferenceProperties? inputReferenceProperties, + + string? membershipArn, + + string? name, + + ImmutableArray tags) + { + Arn = arn; + CollaborationArn = collaborationArn; + CollaborationIdentifier = collaborationIdentifier; + Description = description; + IdMappingConfig = idMappingConfig; + IdNamespaceAssociationIdentifier = idNamespaceAssociationIdentifier; + InputReferenceProperties = inputReferenceProperties; + MembershipArn = membershipArn; + Name = name; + Tags = tags; + } + } +} diff --git a/sdk/dotnet/CleanRooms/IdMappingTable.cs b/sdk/dotnet/CleanRooms/IdMappingTable.cs new file mode 100644 index 0000000000..9deb012f88 --- /dev/null +++ b/sdk/dotnet/CleanRooms/IdMappingTable.cs @@ -0,0 +1,179 @@ +// *** 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.CleanRooms +{ + /// + /// Represents an association between an ID mapping workflow and a collaboration + /// + [AwsNativeResourceType("aws-native:cleanrooms:IdMappingTable")] + public partial class IdMappingTable : global::Pulumi.CustomResource + { + /// + /// The Amazon Resource Name (ARN) of the ID mapping table. + /// + [Output("arn")] + public Output Arn { get; private set; } = null!; + + /// + /// The Amazon Resource Name (ARN) of the collaboration that contains this ID mapping table. + /// + [Output("collaborationArn")] + public Output CollaborationArn { get; private set; } = null!; + + [Output("collaborationIdentifier")] + public Output CollaborationIdentifier { get; private set; } = null!; + + /// + /// The description of the ID mapping table. + /// + [Output("description")] + public Output Description { get; private set; } = null!; + + [Output("idMappingTableIdentifier")] + public Output IdMappingTableIdentifier { get; private set; } = null!; + + /// + /// The input reference configuration for the ID mapping table. + /// + [Output("inputReferenceConfig")] + public Output InputReferenceConfig { get; private set; } = null!; + + [Output("inputReferenceProperties")] + public Output InputReferenceProperties { get; private set; } = null!; + + /// + /// The Amazon Resource Name (ARN) of the AWS KMS key. + /// + [Output("kmsKeyArn")] + public Output KmsKeyArn { get; private set; } = null!; + + /// + /// The Amazon Resource Name (ARN) of the membership resource for the ID mapping table. + /// + [Output("membershipArn")] + public Output MembershipArn { get; private set; } = null!; + + /// + /// The unique identifier of the membership resource for the ID mapping table. + /// + [Output("membershipIdentifier")] + public Output MembershipIdentifier { get; private set; } = null!; + + /// + /// The name of the ID mapping table. + /// + [Output("name")] + public Output Name { get; private set; } = null!; + + /// + /// An optional label that you can assign to a resource when you create it. Each tag consists of a key and an optional value, both of which you define. When you use tagging, you can also use tag-based access control in IAM policies to control access to this resource. + /// + [Output("tags")] + public Output> Tags { get; private set; } = null!; + + + /// + /// Create a IdMappingTable resource with the given unique name, arguments, and options. + /// + /// + /// The unique name of the resource + /// The arguments used to populate this resource's properties + /// A bag of options that control this resource's behavior + public IdMappingTable(string name, IdMappingTableArgs args, CustomResourceOptions? options = null) + : base("aws-native:cleanrooms:IdMappingTable", name, args ?? new IdMappingTableArgs(), MakeResourceOptions(options, "")) + { + } + + private IdMappingTable(string name, Input id, CustomResourceOptions? options = null) + : base("aws-native:cleanrooms:IdMappingTable", name, null, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + ReplaceOnChanges = + { + "inputReferenceConfig", + "membershipIdentifier", + "name", + }, + }; + var merged = CustomResourceOptions.Merge(defaultOptions, options); + // Override the ID if one was specified for consistency with other language SDKs. + merged.Id = id ?? merged.Id; + return merged; + } + /// + /// Get an existing IdMappingTable resource's state with the given name, ID, and optional extra + /// properties used to qualify the lookup. + /// + /// + /// The unique name of the resulting resource. + /// The unique provider ID of the resource to lookup. + /// A bag of options that control this resource's behavior + public static IdMappingTable Get(string name, Input id, CustomResourceOptions? options = null) + { + return new IdMappingTable(name, id, options); + } + } + + public sealed class IdMappingTableArgs : global::Pulumi.ResourceArgs + { + /// + /// The description of the ID mapping table. + /// + [Input("description")] + public Input? Description { get; set; } + + /// + /// The input reference configuration for the ID mapping table. + /// + [Input("inputReferenceConfig", required: true)] + public Input InputReferenceConfig { get; set; } = null!; + + /// + /// The Amazon Resource Name (ARN) of the AWS KMS key. + /// + [Input("kmsKeyArn")] + public Input? KmsKeyArn { get; set; } + + /// + /// The unique identifier of the membership resource for the ID mapping table. + /// + [Input("membershipIdentifier", required: true)] + public Input MembershipIdentifier { get; set; } = null!; + + /// + /// The name of the ID mapping table. + /// + [Input("name")] + public Input? Name { get; set; } + + [Input("tags")] + private InputList? _tags; + + /// + /// An optional label that you can assign to a resource when you create it. Each tag consists of a key and an optional value, both of which you define. When you use tagging, you can also use tag-based access control in IAM policies to control access to this resource. + /// + public InputList Tags + { + get => _tags ?? (_tags = new InputList()); + set => _tags = value; + } + + public IdMappingTableArgs() + { + } + public static new IdMappingTableArgs Empty => new IdMappingTableArgs(); + } +} diff --git a/sdk/dotnet/CleanRooms/IdNamespaceAssociation.cs b/sdk/dotnet/CleanRooms/IdNamespaceAssociation.cs new file mode 100644 index 0000000000..963ef15be7 --- /dev/null +++ b/sdk/dotnet/CleanRooms/IdNamespaceAssociation.cs @@ -0,0 +1,171 @@ +// *** 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.CleanRooms +{ + /// + /// Represents an association between an ID namespace and a collaboration + /// + [AwsNativeResourceType("aws-native:cleanrooms:IdNamespaceAssociation")] + public partial class IdNamespaceAssociation : global::Pulumi.CustomResource + { + /// + /// The Amazon Resource Name (ARN) of the ID namespace association. + /// + [Output("arn")] + public Output Arn { get; private set; } = null!; + + /// + /// The Amazon Resource Name (ARN) of the collaboration that contains this ID namespace association. + /// + [Output("collaborationArn")] + public Output CollaborationArn { get; private set; } = null!; + + [Output("collaborationIdentifier")] + public Output CollaborationIdentifier { get; private set; } = null!; + + /// + /// The description of the ID namespace association. + /// + [Output("description")] + public Output Description { get; private set; } = null!; + + /// + /// The configuration settings for the ID mapping table. + /// + [Output("idMappingConfig")] + public Output IdMappingConfig { get; private set; } = null!; + + [Output("idNamespaceAssociationIdentifier")] + public Output IdNamespaceAssociationIdentifier { get; private set; } = null!; + + /// + /// The input reference configuration for the ID namespace association. + /// + [Output("inputReferenceConfig")] + public Output InputReferenceConfig { get; private set; } = null!; + + [Output("inputReferenceProperties")] + public Output InputReferenceProperties { get; private set; } = null!; + + /// + /// The Amazon Resource Name (ARN) of the membership resource for this ID namespace association. + /// + [Output("membershipArn")] + public Output MembershipArn { get; private set; } = null!; + + /// + /// The unique identifier of the membership that contains the ID namespace association. + /// + [Output("membershipIdentifier")] + public Output MembershipIdentifier { get; private set; } = null!; + + /// + /// The name of this ID namespace association. + /// + [Output("name")] + public Output Name { get; private set; } = null!; + + [Output("tags")] + public Output> Tags { get; private set; } = null!; + + + /// + /// Create a IdNamespaceAssociation resource with the given unique name, arguments, and options. + /// + /// + /// The unique name of the resource + /// The arguments used to populate this resource's properties + /// A bag of options that control this resource's behavior + public IdNamespaceAssociation(string name, IdNamespaceAssociationArgs args, CustomResourceOptions? options = null) + : base("aws-native:cleanrooms:IdNamespaceAssociation", name, args ?? new IdNamespaceAssociationArgs(), MakeResourceOptions(options, "")) + { + } + + private IdNamespaceAssociation(string name, Input id, CustomResourceOptions? options = null) + : base("aws-native:cleanrooms:IdNamespaceAssociation", name, null, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + ReplaceOnChanges = + { + "inputReferenceConfig", + "membershipIdentifier", + }, + }; + var merged = CustomResourceOptions.Merge(defaultOptions, options); + // Override the ID if one was specified for consistency with other language SDKs. + merged.Id = id ?? merged.Id; + return merged; + } + /// + /// Get an existing IdNamespaceAssociation resource's state with the given name, ID, and optional extra + /// properties used to qualify the lookup. + /// + /// + /// The unique name of the resulting resource. + /// The unique provider ID of the resource to lookup. + /// A bag of options that control this resource's behavior + public static IdNamespaceAssociation Get(string name, Input id, CustomResourceOptions? options = null) + { + return new IdNamespaceAssociation(name, id, options); + } + } + + public sealed class IdNamespaceAssociationArgs : global::Pulumi.ResourceArgs + { + /// + /// The description of the ID namespace association. + /// + [Input("description")] + public Input? Description { get; set; } + + /// + /// The configuration settings for the ID mapping table. + /// + [Input("idMappingConfig")] + public Input? IdMappingConfig { get; set; } + + /// + /// The input reference configuration for the ID namespace association. + /// + [Input("inputReferenceConfig", required: true)] + public Input InputReferenceConfig { get; set; } = null!; + + /// + /// The unique identifier of the membership that contains the ID namespace association. + /// + [Input("membershipIdentifier", required: true)] + public Input MembershipIdentifier { get; set; } = null!; + + /// + /// The name of this ID namespace association. + /// + [Input("name")] + public Input? Name { get; set; } + + [Input("tags")] + private InputList? _tags; + public InputList Tags + { + get => _tags ?? (_tags = new InputList()); + set => _tags = value; + } + + public IdNamespaceAssociationArgs() + { + } + public static new IdNamespaceAssociationArgs Empty => new IdNamespaceAssociationArgs(); + } +} diff --git a/sdk/dotnet/CleanRooms/Inputs/IdMappingTableInputReferenceConfigArgs.cs b/sdk/dotnet/CleanRooms/Inputs/IdMappingTableInputReferenceConfigArgs.cs new file mode 100644 index 0000000000..a519fe7478 --- /dev/null +++ b/sdk/dotnet/CleanRooms/Inputs/IdMappingTableInputReferenceConfigArgs.cs @@ -0,0 +1,34 @@ +// *** 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.CleanRooms.Inputs +{ + + public sealed class IdMappingTableInputReferenceConfigArgs : global::Pulumi.ResourceArgs + { + /// + /// The Amazon Resource Name (ARN) of the referenced resource in AWS Entity Resolution . Valid values are ID mapping workflow ARNs. + /// + [Input("inputReferenceArn", required: true)] + public Input InputReferenceArn { get; set; } = null!; + + /// + /// When `TRUE` , AWS Clean Rooms manages permissions for the ID mapping table resource. + /// + /// When `FALSE` , the resource owner manages permissions for the ID mapping table resource. + /// + [Input("manageResourcePolicies", required: true)] + public Input ManageResourcePolicies { get; set; } = null!; + + public IdMappingTableInputReferenceConfigArgs() + { + } + public static new IdMappingTableInputReferenceConfigArgs Empty => new IdMappingTableInputReferenceConfigArgs(); + } +} diff --git a/sdk/dotnet/CleanRooms/Inputs/IdNamespaceAssociationIdMappingConfigArgs.cs b/sdk/dotnet/CleanRooms/Inputs/IdNamespaceAssociationIdMappingConfigArgs.cs new file mode 100644 index 0000000000..c7125f0456 --- /dev/null +++ b/sdk/dotnet/CleanRooms/Inputs/IdNamespaceAssociationIdMappingConfigArgs.cs @@ -0,0 +1,28 @@ +// *** 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.CleanRooms.Inputs +{ + + public sealed class IdNamespaceAssociationIdMappingConfigArgs : global::Pulumi.ResourceArgs + { + /// + /// An indicator as to whether you can use your column as a dimension column in the ID mapping table ( `TRUE` ) or not ( `FALSE` ). + /// + /// Default is `FALSE` . + /// + [Input("allowUseAsDimensionColumn", required: true)] + public Input AllowUseAsDimensionColumn { get; set; } = null!; + + public IdNamespaceAssociationIdMappingConfigArgs() + { + } + public static new IdNamespaceAssociationIdMappingConfigArgs Empty => new IdNamespaceAssociationIdMappingConfigArgs(); + } +} diff --git a/sdk/dotnet/CleanRooms/Inputs/IdNamespaceAssociationInputReferenceConfigArgs.cs b/sdk/dotnet/CleanRooms/Inputs/IdNamespaceAssociationInputReferenceConfigArgs.cs new file mode 100644 index 0000000000..9fc75848ab --- /dev/null +++ b/sdk/dotnet/CleanRooms/Inputs/IdNamespaceAssociationInputReferenceConfigArgs.cs @@ -0,0 +1,34 @@ +// *** 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.CleanRooms.Inputs +{ + + public sealed class IdNamespaceAssociationInputReferenceConfigArgs : global::Pulumi.ResourceArgs + { + /// + /// The Amazon Resource Name (ARN) of the AWS Entity Resolution resource that is being associated to the collaboration. Valid resource ARNs are from the ID namespaces that you own. + /// + [Input("inputReferenceArn", required: true)] + public Input InputReferenceArn { get; set; } = null!; + + /// + /// When `TRUE` , AWS Clean Rooms manages permissions for the ID namespace association resource. + /// + /// When `FALSE` , the resource owner manages permissions for the ID namespace association resource. + /// + [Input("manageResourcePolicies", required: true)] + public Input ManageResourcePolicies { get; set; } = null!; + + public IdNamespaceAssociationInputReferenceConfigArgs() + { + } + public static new IdNamespaceAssociationInputReferenceConfigArgs Empty => new IdNamespaceAssociationInputReferenceConfigArgs(); + } +} diff --git a/sdk/dotnet/CleanRooms/Outputs/IdMappingTableInputReferenceConfig.cs b/sdk/dotnet/CleanRooms/Outputs/IdMappingTableInputReferenceConfig.cs new file mode 100644 index 0000000000..9f25e8ed40 --- /dev/null +++ b/sdk/dotnet/CleanRooms/Outputs/IdMappingTableInputReferenceConfig.cs @@ -0,0 +1,37 @@ +// *** 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.CleanRooms.Outputs +{ + + [OutputType] + public sealed class IdMappingTableInputReferenceConfig + { + /// + /// The Amazon Resource Name (ARN) of the referenced resource in AWS Entity Resolution . Valid values are ID mapping workflow ARNs. + /// + public readonly string InputReferenceArn; + /// + /// When `TRUE` , AWS Clean Rooms manages permissions for the ID mapping table resource. + /// + /// When `FALSE` , the resource owner manages permissions for the ID mapping table resource. + /// + public readonly bool ManageResourcePolicies; + + [OutputConstructor] + private IdMappingTableInputReferenceConfig( + string inputReferenceArn, + + bool manageResourcePolicies) + { + InputReferenceArn = inputReferenceArn; + ManageResourcePolicies = manageResourcePolicies; + } + } +} diff --git a/sdk/dotnet/CleanRooms/Outputs/IdMappingTableInputReferenceProperties.cs b/sdk/dotnet/CleanRooms/Outputs/IdMappingTableInputReferenceProperties.cs new file mode 100644 index 0000000000..e30b464f76 --- /dev/null +++ b/sdk/dotnet/CleanRooms/Outputs/IdMappingTableInputReferenceProperties.cs @@ -0,0 +1,27 @@ +// *** 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.CleanRooms.Outputs +{ + + [OutputType] + public sealed class IdMappingTableInputReferenceProperties + { + /// + /// The input source of the ID mapping table. + /// + public readonly ImmutableArray IdMappingTableInputSource; + + [OutputConstructor] + private IdMappingTableInputReferenceProperties(ImmutableArray idMappingTableInputSource) + { + IdMappingTableInputSource = idMappingTableInputSource; + } + } +} diff --git a/sdk/dotnet/CleanRooms/Outputs/IdMappingTableInputSource.cs b/sdk/dotnet/CleanRooms/Outputs/IdMappingTableInputSource.cs new file mode 100644 index 0000000000..2d38116d01 --- /dev/null +++ b/sdk/dotnet/CleanRooms/Outputs/IdMappingTableInputSource.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.CleanRooms.Outputs +{ + + [OutputType] + public sealed class IdMappingTableInputSource + { + /// + /// The unique identifier of the ID namespace association. + /// + public readonly string IdNamespaceAssociationId; + /// + /// The type of the input source of the ID mapping table. + /// + public readonly Pulumi.AwsNative.CleanRooms.IdMappingTableInputSourceType Type; + + [OutputConstructor] + private IdMappingTableInputSource( + string idNamespaceAssociationId, + + Pulumi.AwsNative.CleanRooms.IdMappingTableInputSourceType type) + { + IdNamespaceAssociationId = idNamespaceAssociationId; + Type = type; + } + } +} diff --git a/sdk/dotnet/CleanRooms/Outputs/IdNamespaceAssociationDocument.cs b/sdk/dotnet/CleanRooms/Outputs/IdNamespaceAssociationDocument.cs new file mode 100644 index 0000000000..20ee4c655d --- /dev/null +++ b/sdk/dotnet/CleanRooms/Outputs/IdNamespaceAssociationDocument.cs @@ -0,0 +1,21 @@ +// *** 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.CleanRooms.Outputs +{ + + [OutputType] + public sealed class IdNamespaceAssociationDocument + { + [OutputConstructor] + private IdNamespaceAssociationDocument() + { + } + } +} diff --git a/sdk/dotnet/CleanRooms/Outputs/IdNamespaceAssociationIdMappingConfig.cs b/sdk/dotnet/CleanRooms/Outputs/IdNamespaceAssociationIdMappingConfig.cs new file mode 100644 index 0000000000..64ab9beae4 --- /dev/null +++ b/sdk/dotnet/CleanRooms/Outputs/IdNamespaceAssociationIdMappingConfig.cs @@ -0,0 +1,29 @@ +// *** 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.CleanRooms.Outputs +{ + + [OutputType] + public sealed class IdNamespaceAssociationIdMappingConfig + { + /// + /// An indicator as to whether you can use your column as a dimension column in the ID mapping table ( `TRUE` ) or not ( `FALSE` ). + /// + /// Default is `FALSE` . + /// + public readonly bool AllowUseAsDimensionColumn; + + [OutputConstructor] + private IdNamespaceAssociationIdMappingConfig(bool allowUseAsDimensionColumn) + { + AllowUseAsDimensionColumn = allowUseAsDimensionColumn; + } + } +} diff --git a/sdk/dotnet/CleanRooms/Outputs/IdNamespaceAssociationInputReferenceConfig.cs b/sdk/dotnet/CleanRooms/Outputs/IdNamespaceAssociationInputReferenceConfig.cs new file mode 100644 index 0000000000..1a433bad45 --- /dev/null +++ b/sdk/dotnet/CleanRooms/Outputs/IdNamespaceAssociationInputReferenceConfig.cs @@ -0,0 +1,37 @@ +// *** 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.CleanRooms.Outputs +{ + + [OutputType] + public sealed class IdNamespaceAssociationInputReferenceConfig + { + /// + /// The Amazon Resource Name (ARN) of the AWS Entity Resolution resource that is being associated to the collaboration. Valid resource ARNs are from the ID namespaces that you own. + /// + public readonly string InputReferenceArn; + /// + /// When `TRUE` , AWS Clean Rooms manages permissions for the ID namespace association resource. + /// + /// When `FALSE` , the resource owner manages permissions for the ID namespace association resource. + /// + public readonly bool ManageResourcePolicies; + + [OutputConstructor] + private IdNamespaceAssociationInputReferenceConfig( + string inputReferenceArn, + + bool manageResourcePolicies) + { + InputReferenceArn = inputReferenceArn; + ManageResourcePolicies = manageResourcePolicies; + } + } +} diff --git a/sdk/dotnet/CleanRooms/Outputs/IdNamespaceAssociationInputReferenceProperties.cs b/sdk/dotnet/CleanRooms/Outputs/IdNamespaceAssociationInputReferenceProperties.cs new file mode 100644 index 0000000000..f5c7bfb990 --- /dev/null +++ b/sdk/dotnet/CleanRooms/Outputs/IdNamespaceAssociationInputReferenceProperties.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.CleanRooms.Outputs +{ + + [OutputType] + public sealed class IdNamespaceAssociationInputReferenceProperties + { + /// + /// Defines how ID mapping workflows are supported for this ID namespace association. + /// + public readonly ImmutableArray IdMappingWorkflowsSupported; + /// + /// The ID namespace type for this ID namespace association. + /// + public readonly Pulumi.AwsNative.CleanRooms.IdNamespaceAssociationInputReferencePropertiesIdNamespaceType? IdNamespaceType; + + [OutputConstructor] + private IdNamespaceAssociationInputReferenceProperties( + ImmutableArray idMappingWorkflowsSupported, + + Pulumi.AwsNative.CleanRooms.IdNamespaceAssociationInputReferencePropertiesIdNamespaceType? idNamespaceType) + { + IdMappingWorkflowsSupported = idMappingWorkflowsSupported; + IdNamespaceType = idNamespaceType; + } + } +} diff --git a/sdk/dotnet/Ec2/GetSubnet.cs b/sdk/dotnet/Ec2/GetSubnet.cs index 543f075fd8..8ac459220f 100644 --- a/sdk/dotnet/Ec2/GetSubnet.cs +++ b/sdk/dotnet/Ec2/GetSubnet.cs @@ -67,7 +67,8 @@ public sealed class GetSubnetResult /// public readonly bool? AssignIpv6AddressOnCreation; /// - /// Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. For more information, see [DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-nat64-dns64) in the *User Guide*. + /// Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. + /// You must first configure a NAT gateway in a public subnet (separate from the subnet containing the IPv6-only workloads). For example, the subnet containing the NAT gateway should have a ``0.0.0.0/0`` route pointing to the internet gateway. For more information, see [Configure DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/nat-gateway-nat64-dns64.html#nat-gateway-nat64-dns64-walkthrough) in the *User Guide*. /// public readonly bool? EnableDns64; /// diff --git a/sdk/dotnet/Ec2/Subnet.cs b/sdk/dotnet/Ec2/Subnet.cs index 3e46a206cc..17ee98bc96 100644 --- a/sdk/dotnet/Ec2/Subnet.cs +++ b/sdk/dotnet/Ec2/Subnet.cs @@ -45,7 +45,8 @@ public partial class Subnet : global::Pulumi.CustomResource public Output CidrBlock { get; private set; } = null!; /// - /// Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. For more information, see [DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-nat64-dns64) in the *User Guide*. + /// Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. + /// You must first configure a NAT gateway in a public subnet (separate from the subnet containing the IPv6-only workloads). For example, the subnet containing the NAT gateway should have a ``0.0.0.0/0`` route pointing to the internet gateway. For more information, see [Configure DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/nat-gateway-nat64-dns64.html#nat-gateway-nat64-dns64-walkthrough) in the *User Guide*. /// [Output("enableDns64")] public Output EnableDns64 { get; private set; } = null!; @@ -233,7 +234,8 @@ public sealed class SubnetArgs : global::Pulumi.ResourceArgs public Input? CidrBlock { get; set; } /// - /// Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. For more information, see [DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-nat64-dns64) in the *User Guide*. + /// Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. + /// You must first configure a NAT gateway in a public subnet (separate from the subnet containing the IPv6-only workloads). For example, the subnet containing the NAT gateway should have a ``0.0.0.0/0`` route pointing to the internet gateway. For more information, see [Configure DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/nat-gateway-nat64-dns64.html#nat-gateway-nat64-dns64-walkthrough) in the *User Guide*. /// [Input("enableDns64")] public Input? EnableDns64 { get; set; } diff --git a/sdk/dotnet/Redshift/Inputs/ClusterLoggingPropertiesArgs.cs b/sdk/dotnet/Redshift/Inputs/ClusterLoggingPropertiesArgs.cs index 18e754d5ee..d8b60dd773 100644 --- a/sdk/dotnet/Redshift/Inputs/ClusterLoggingPropertiesArgs.cs +++ b/sdk/dotnet/Redshift/Inputs/ClusterLoggingPropertiesArgs.cs @@ -23,6 +23,17 @@ public sealed class ClusterLoggingPropertiesArgs : global::Pulumi.ResourceArgs [Input("bucketName")] public Input? BucketName { get; set; } + [Input("logDestinationType")] + public Input? LogDestinationType { get; set; } + + [Input("logExports")] + private InputList? _logExports; + public InputList LogExports + { + get => _logExports ?? (_logExports = new InputList()); + set => _logExports = value; + } + /// /// The prefix applied to the log file names. /// diff --git a/sdk/dotnet/Redshift/Outputs/ClusterLoggingProperties.cs b/sdk/dotnet/Redshift/Outputs/ClusterLoggingProperties.cs index d7236a9096..e3097efa31 100644 --- a/sdk/dotnet/Redshift/Outputs/ClusterLoggingProperties.cs +++ b/sdk/dotnet/Redshift/Outputs/ClusterLoggingProperties.cs @@ -22,6 +22,8 @@ public sealed class ClusterLoggingProperties /// - The cluster must have read bucket and put object permissions /// public readonly string? BucketName; + public readonly string? LogDestinationType; + public readonly ImmutableArray LogExports; /// /// The prefix applied to the log file names. /// @@ -42,9 +44,15 @@ public sealed class ClusterLoggingProperties private ClusterLoggingProperties( string? bucketName, + string? logDestinationType, + + ImmutableArray logExports, + string? s3KeyPrefix) { BucketName = bucketName; + LogDestinationType = logDestinationType; + LogExports = logExports; S3KeyPrefix = s3KeyPrefix; } } diff --git a/sdk/dotnet/Route53Resolver/Enums.cs b/sdk/dotnet/Route53Resolver/Enums.cs index 6aff6460b3..157c41acee 100644 --- a/sdk/dotnet/Route53Resolver/Enums.cs +++ b/sdk/dotnet/Route53Resolver/Enums.cs @@ -576,6 +576,7 @@ private ResolverRuleRuleType(string value) public static ResolverRuleRuleType Forward { get; } = new ResolverRuleRuleType("FORWARD"); public static ResolverRuleRuleType System { get; } = new ResolverRuleRuleType("SYSTEM"); public static ResolverRuleRuleType Recursive { get; } = new ResolverRuleRuleType("RECURSIVE"); + public static ResolverRuleRuleType Delegate { get; } = new ResolverRuleRuleType("DELEGATE"); public static bool operator ==(ResolverRuleRuleType left, ResolverRuleRuleType right) => left.Equals(right); public static bool operator !=(ResolverRuleRuleType left, ResolverRuleRuleType right) => !left.Equals(right); diff --git a/sdk/dotnet/Route53Resolver/GetResolverRule.cs b/sdk/dotnet/Route53Resolver/GetResolverRule.cs index 4a624883c7..efcdf3506f 100644 --- a/sdk/dotnet/Route53Resolver/GetResolverRule.cs +++ b/sdk/dotnet/Route53Resolver/GetResolverRule.cs @@ -62,6 +62,10 @@ public sealed class GetResolverRuleResult /// public readonly string? Arn; /// + /// The name server domain for queries to be delegated to if a query matches the delegation record. + /// + public readonly string? DelegationRecord; + /// /// DNS queries for this domain name are forwarded to the IP addresses that are specified in TargetIps /// public readonly string? DomainName; @@ -90,6 +94,8 @@ public sealed class GetResolverRuleResult private GetResolverRuleResult( string? arn, + string? delegationRecord, + string? domainName, string? name, @@ -103,6 +109,7 @@ private GetResolverRuleResult( ImmutableArray targetIps) { Arn = arn; + DelegationRecord = delegationRecord; DomainName = domainName; Name = name; ResolverEndpointId = resolverEndpointId; diff --git a/sdk/dotnet/Route53Resolver/ResolverRule.cs b/sdk/dotnet/Route53Resolver/ResolverRule.cs index ea2b002c10..f02761780b 100644 --- a/sdk/dotnet/Route53Resolver/ResolverRule.cs +++ b/sdk/dotnet/Route53Resolver/ResolverRule.cs @@ -21,11 +21,17 @@ public partial class ResolverRule : global::Pulumi.CustomResource [Output("arn")] public Output Arn { get; private set; } = null!; + /// + /// The name server domain for queries to be delegated to if a query matches the delegation record. + /// + [Output("delegationRecord")] + public Output DelegationRecord { get; private set; } = null!; + /// /// DNS queries for this domain name are forwarded to the IP addresses that are specified in TargetIps /// [Output("domainName")] - public Output DomainName { get; private set; } = null!; + public Output DomainName { get; private set; } = null!; /// /// The name for the Resolver rule @@ -112,11 +118,17 @@ public static ResolverRule Get(string name, Input id, CustomResourceOpti public sealed class ResolverRuleArgs : global::Pulumi.ResourceArgs { + /// + /// The name server domain for queries to be delegated to if a query matches the delegation record. + /// + [Input("delegationRecord")] + public Input? DelegationRecord { get; set; } + /// /// DNS queries for this domain name are forwarded to the IP addresses that are specified in TargetIps /// - [Input("domainName", required: true)] - public Input DomainName { get; set; } = null!; + [Input("domainName")] + public Input? DomainName { get; set; } /// /// The name for the Resolver rule diff --git a/sdk/go/aws/cleanrooms/getIdMappingTable.go b/sdk/go/aws/cleanrooms/getIdMappingTable.go new file mode 100644 index 0000000000..bbc4b6928d --- /dev/null +++ b/sdk/go/aws/cleanrooms/getIdMappingTable.go @@ -0,0 +1,133 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package cleanrooms + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi-aws-native/sdk/go/aws" + "github.com/pulumi/pulumi-aws-native/sdk/go/aws/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Represents an association between an ID mapping workflow and a collaboration +func LookupIdMappingTable(ctx *pulumi.Context, args *LookupIdMappingTableArgs, opts ...pulumi.InvokeOption) (*LookupIdMappingTableResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupIdMappingTableResult + err := ctx.Invoke("aws-native:cleanrooms:getIdMappingTable", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +type LookupIdMappingTableArgs struct { + IdMappingTableIdentifier string `pulumi:"idMappingTableIdentifier"` + // The unique identifier of the membership resource for the ID mapping table. + MembershipIdentifier string `pulumi:"membershipIdentifier"` +} + +type LookupIdMappingTableResult struct { + // The Amazon Resource Name (ARN) of the ID mapping table. + Arn *string `pulumi:"arn"` + // The Amazon Resource Name (ARN) of the collaboration that contains this ID mapping table. + CollaborationArn *string `pulumi:"collaborationArn"` + CollaborationIdentifier *string `pulumi:"collaborationIdentifier"` + // The description of the ID mapping table. + Description *string `pulumi:"description"` + IdMappingTableIdentifier *string `pulumi:"idMappingTableIdentifier"` + InputReferenceProperties *IdMappingTableInputReferenceProperties `pulumi:"inputReferenceProperties"` + // The Amazon Resource Name (ARN) of the AWS KMS key. + KmsKeyArn *string `pulumi:"kmsKeyArn"` + // The Amazon Resource Name (ARN) of the membership resource for the ID mapping table. + MembershipArn *string `pulumi:"membershipArn"` + // An optional label that you can assign to a resource when you create it. Each tag consists of a key and an optional value, both of which you define. When you use tagging, you can also use tag-based access control in IAM policies to control access to this resource. + Tags []aws.Tag `pulumi:"tags"` +} + +func LookupIdMappingTableOutput(ctx *pulumi.Context, args LookupIdMappingTableOutputArgs, opts ...pulumi.InvokeOption) LookupIdMappingTableResultOutput { + return pulumi.ToOutputWithContext(context.Background(), args). + ApplyT(func(v interface{}) (LookupIdMappingTableResult, error) { + args := v.(LookupIdMappingTableArgs) + r, err := LookupIdMappingTable(ctx, &args, opts...) + var s LookupIdMappingTableResult + if r != nil { + s = *r + } + return s, err + }).(LookupIdMappingTableResultOutput) +} + +type LookupIdMappingTableOutputArgs struct { + IdMappingTableIdentifier pulumi.StringInput `pulumi:"idMappingTableIdentifier"` + // The unique identifier of the membership resource for the ID mapping table. + MembershipIdentifier pulumi.StringInput `pulumi:"membershipIdentifier"` +} + +func (LookupIdMappingTableOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupIdMappingTableArgs)(nil)).Elem() +} + +type LookupIdMappingTableResultOutput struct{ *pulumi.OutputState } + +func (LookupIdMappingTableResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupIdMappingTableResult)(nil)).Elem() +} + +func (o LookupIdMappingTableResultOutput) ToLookupIdMappingTableResultOutput() LookupIdMappingTableResultOutput { + return o +} + +func (o LookupIdMappingTableResultOutput) ToLookupIdMappingTableResultOutputWithContext(ctx context.Context) LookupIdMappingTableResultOutput { + return o +} + +// The Amazon Resource Name (ARN) of the ID mapping table. +func (o LookupIdMappingTableResultOutput) Arn() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupIdMappingTableResult) *string { return v.Arn }).(pulumi.StringPtrOutput) +} + +// The Amazon Resource Name (ARN) of the collaboration that contains this ID mapping table. +func (o LookupIdMappingTableResultOutput) CollaborationArn() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupIdMappingTableResult) *string { return v.CollaborationArn }).(pulumi.StringPtrOutput) +} + +func (o LookupIdMappingTableResultOutput) CollaborationIdentifier() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupIdMappingTableResult) *string { return v.CollaborationIdentifier }).(pulumi.StringPtrOutput) +} + +// The description of the ID mapping table. +func (o LookupIdMappingTableResultOutput) Description() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupIdMappingTableResult) *string { return v.Description }).(pulumi.StringPtrOutput) +} + +func (o LookupIdMappingTableResultOutput) IdMappingTableIdentifier() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupIdMappingTableResult) *string { return v.IdMappingTableIdentifier }).(pulumi.StringPtrOutput) +} + +func (o LookupIdMappingTableResultOutput) InputReferenceProperties() IdMappingTableInputReferencePropertiesPtrOutput { + return o.ApplyT(func(v LookupIdMappingTableResult) *IdMappingTableInputReferenceProperties { + return v.InputReferenceProperties + }).(IdMappingTableInputReferencePropertiesPtrOutput) +} + +// The Amazon Resource Name (ARN) of the AWS KMS key. +func (o LookupIdMappingTableResultOutput) KmsKeyArn() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupIdMappingTableResult) *string { return v.KmsKeyArn }).(pulumi.StringPtrOutput) +} + +// The Amazon Resource Name (ARN) of the membership resource for the ID mapping table. +func (o LookupIdMappingTableResultOutput) MembershipArn() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupIdMappingTableResult) *string { return v.MembershipArn }).(pulumi.StringPtrOutput) +} + +// An optional label that you can assign to a resource when you create it. Each tag consists of a key and an optional value, both of which you define. When you use tagging, you can also use tag-based access control in IAM policies to control access to this resource. +func (o LookupIdMappingTableResultOutput) Tags() aws.TagArrayOutput { + return o.ApplyT(func(v LookupIdMappingTableResult) []aws.Tag { return v.Tags }).(aws.TagArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupIdMappingTableResultOutput{}) +} diff --git a/sdk/go/aws/cleanrooms/getIdNamespaceAssociation.go b/sdk/go/aws/cleanrooms/getIdNamespaceAssociation.go new file mode 100644 index 0000000000..3c0dfa87c2 --- /dev/null +++ b/sdk/go/aws/cleanrooms/getIdNamespaceAssociation.go @@ -0,0 +1,140 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package cleanrooms + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi-aws-native/sdk/go/aws" + "github.com/pulumi/pulumi-aws-native/sdk/go/aws/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Represents an association between an ID namespace and a collaboration +func LookupIdNamespaceAssociation(ctx *pulumi.Context, args *LookupIdNamespaceAssociationArgs, opts ...pulumi.InvokeOption) (*LookupIdNamespaceAssociationResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupIdNamespaceAssociationResult + err := ctx.Invoke("aws-native:cleanrooms:getIdNamespaceAssociation", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +type LookupIdNamespaceAssociationArgs struct { + IdNamespaceAssociationIdentifier string `pulumi:"idNamespaceAssociationIdentifier"` + // The unique identifier of the membership that contains the ID namespace association. + MembershipIdentifier string `pulumi:"membershipIdentifier"` +} + +type LookupIdNamespaceAssociationResult struct { + // The Amazon Resource Name (ARN) of the ID namespace association. + Arn *string `pulumi:"arn"` + // The Amazon Resource Name (ARN) of the collaboration that contains this ID namespace association. + CollaborationArn *string `pulumi:"collaborationArn"` + CollaborationIdentifier *string `pulumi:"collaborationIdentifier"` + // The description of the ID namespace association. + Description *string `pulumi:"description"` + // The configuration settings for the ID mapping table. + IdMappingConfig *IdNamespaceAssociationIdMappingConfig `pulumi:"idMappingConfig"` + IdNamespaceAssociationIdentifier *string `pulumi:"idNamespaceAssociationIdentifier"` + InputReferenceProperties *IdNamespaceAssociationInputReferenceProperties `pulumi:"inputReferenceProperties"` + // The Amazon Resource Name (ARN) of the membership resource for this ID namespace association. + MembershipArn *string `pulumi:"membershipArn"` + // The name of this ID namespace association. + Name *string `pulumi:"name"` + Tags []aws.Tag `pulumi:"tags"` +} + +func LookupIdNamespaceAssociationOutput(ctx *pulumi.Context, args LookupIdNamespaceAssociationOutputArgs, opts ...pulumi.InvokeOption) LookupIdNamespaceAssociationResultOutput { + return pulumi.ToOutputWithContext(context.Background(), args). + ApplyT(func(v interface{}) (LookupIdNamespaceAssociationResult, error) { + args := v.(LookupIdNamespaceAssociationArgs) + r, err := LookupIdNamespaceAssociation(ctx, &args, opts...) + var s LookupIdNamespaceAssociationResult + if r != nil { + s = *r + } + return s, err + }).(LookupIdNamespaceAssociationResultOutput) +} + +type LookupIdNamespaceAssociationOutputArgs struct { + IdNamespaceAssociationIdentifier pulumi.StringInput `pulumi:"idNamespaceAssociationIdentifier"` + // The unique identifier of the membership that contains the ID namespace association. + MembershipIdentifier pulumi.StringInput `pulumi:"membershipIdentifier"` +} + +func (LookupIdNamespaceAssociationOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupIdNamespaceAssociationArgs)(nil)).Elem() +} + +type LookupIdNamespaceAssociationResultOutput struct{ *pulumi.OutputState } + +func (LookupIdNamespaceAssociationResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupIdNamespaceAssociationResult)(nil)).Elem() +} + +func (o LookupIdNamespaceAssociationResultOutput) ToLookupIdNamespaceAssociationResultOutput() LookupIdNamespaceAssociationResultOutput { + return o +} + +func (o LookupIdNamespaceAssociationResultOutput) ToLookupIdNamespaceAssociationResultOutputWithContext(ctx context.Context) LookupIdNamespaceAssociationResultOutput { + return o +} + +// The Amazon Resource Name (ARN) of the ID namespace association. +func (o LookupIdNamespaceAssociationResultOutput) Arn() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupIdNamespaceAssociationResult) *string { return v.Arn }).(pulumi.StringPtrOutput) +} + +// The Amazon Resource Name (ARN) of the collaboration that contains this ID namespace association. +func (o LookupIdNamespaceAssociationResultOutput) CollaborationArn() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupIdNamespaceAssociationResult) *string { return v.CollaborationArn }).(pulumi.StringPtrOutput) +} + +func (o LookupIdNamespaceAssociationResultOutput) CollaborationIdentifier() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupIdNamespaceAssociationResult) *string { return v.CollaborationIdentifier }).(pulumi.StringPtrOutput) +} + +// The description of the ID namespace association. +func (o LookupIdNamespaceAssociationResultOutput) Description() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupIdNamespaceAssociationResult) *string { return v.Description }).(pulumi.StringPtrOutput) +} + +// The configuration settings for the ID mapping table. +func (o LookupIdNamespaceAssociationResultOutput) IdMappingConfig() IdNamespaceAssociationIdMappingConfigPtrOutput { + return o.ApplyT(func(v LookupIdNamespaceAssociationResult) *IdNamespaceAssociationIdMappingConfig { + return v.IdMappingConfig + }).(IdNamespaceAssociationIdMappingConfigPtrOutput) +} + +func (o LookupIdNamespaceAssociationResultOutput) IdNamespaceAssociationIdentifier() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupIdNamespaceAssociationResult) *string { return v.IdNamespaceAssociationIdentifier }).(pulumi.StringPtrOutput) +} + +func (o LookupIdNamespaceAssociationResultOutput) InputReferenceProperties() IdNamespaceAssociationInputReferencePropertiesPtrOutput { + return o.ApplyT(func(v LookupIdNamespaceAssociationResult) *IdNamespaceAssociationInputReferenceProperties { + return v.InputReferenceProperties + }).(IdNamespaceAssociationInputReferencePropertiesPtrOutput) +} + +// The Amazon Resource Name (ARN) of the membership resource for this ID namespace association. +func (o LookupIdNamespaceAssociationResultOutput) MembershipArn() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupIdNamespaceAssociationResult) *string { return v.MembershipArn }).(pulumi.StringPtrOutput) +} + +// The name of this ID namespace association. +func (o LookupIdNamespaceAssociationResultOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupIdNamespaceAssociationResult) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +func (o LookupIdNamespaceAssociationResultOutput) Tags() aws.TagArrayOutput { + return o.ApplyT(func(v LookupIdNamespaceAssociationResult) []aws.Tag { return v.Tags }).(aws.TagArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupIdNamespaceAssociationResultOutput{}) +} diff --git a/sdk/go/aws/cleanrooms/idMappingTable.go b/sdk/go/aws/cleanrooms/idMappingTable.go new file mode 100644 index 0000000000..b5a91cd104 --- /dev/null +++ b/sdk/go/aws/cleanrooms/idMappingTable.go @@ -0,0 +1,224 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package cleanrooms + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-aws-native/sdk/go/aws" + "github.com/pulumi/pulumi-aws-native/sdk/go/aws/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Represents an association between an ID mapping workflow and a collaboration +type IdMappingTable struct { + pulumi.CustomResourceState + + // The Amazon Resource Name (ARN) of the ID mapping table. + Arn pulumi.StringOutput `pulumi:"arn"` + // The Amazon Resource Name (ARN) of the collaboration that contains this ID mapping table. + CollaborationArn pulumi.StringOutput `pulumi:"collaborationArn"` + CollaborationIdentifier pulumi.StringOutput `pulumi:"collaborationIdentifier"` + // The description of the ID mapping table. + Description pulumi.StringPtrOutput `pulumi:"description"` + IdMappingTableIdentifier pulumi.StringOutput `pulumi:"idMappingTableIdentifier"` + // The input reference configuration for the ID mapping table. + InputReferenceConfig IdMappingTableInputReferenceConfigOutput `pulumi:"inputReferenceConfig"` + InputReferenceProperties IdMappingTableInputReferencePropertiesOutput `pulumi:"inputReferenceProperties"` + // The Amazon Resource Name (ARN) of the AWS KMS key. + KmsKeyArn pulumi.StringPtrOutput `pulumi:"kmsKeyArn"` + // The Amazon Resource Name (ARN) of the membership resource for the ID mapping table. + MembershipArn pulumi.StringOutput `pulumi:"membershipArn"` + // The unique identifier of the membership resource for the ID mapping table. + MembershipIdentifier pulumi.StringOutput `pulumi:"membershipIdentifier"` + // The name of the ID mapping table. + Name pulumi.StringOutput `pulumi:"name"` + // An optional label that you can assign to a resource when you create it. Each tag consists of a key and an optional value, both of which you define. When you use tagging, you can also use tag-based access control in IAM policies to control access to this resource. + Tags aws.TagArrayOutput `pulumi:"tags"` +} + +// NewIdMappingTable registers a new resource with the given unique name, arguments, and options. +func NewIdMappingTable(ctx *pulumi.Context, + name string, args *IdMappingTableArgs, opts ...pulumi.ResourceOption) (*IdMappingTable, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.InputReferenceConfig == nil { + return nil, errors.New("invalid value for required argument 'InputReferenceConfig'") + } + if args.MembershipIdentifier == nil { + return nil, errors.New("invalid value for required argument 'MembershipIdentifier'") + } + replaceOnChanges := pulumi.ReplaceOnChanges([]string{ + "inputReferenceConfig", + "membershipIdentifier", + "name", + }) + opts = append(opts, replaceOnChanges) + opts = internal.PkgResourceDefaultOpts(opts) + var resource IdMappingTable + err := ctx.RegisterResource("aws-native:cleanrooms:IdMappingTable", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetIdMappingTable gets an existing IdMappingTable resource's state with the given name, ID, and optional +// state properties that are used to uniquely qualify the lookup (nil if not required). +func GetIdMappingTable(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *IdMappingTableState, opts ...pulumi.ResourceOption) (*IdMappingTable, error) { + var resource IdMappingTable + err := ctx.ReadResource("aws-native:cleanrooms:IdMappingTable", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering IdMappingTable resources. +type idMappingTableState struct { +} + +type IdMappingTableState struct { +} + +func (IdMappingTableState) ElementType() reflect.Type { + return reflect.TypeOf((*idMappingTableState)(nil)).Elem() +} + +type idMappingTableArgs struct { + // The description of the ID mapping table. + Description *string `pulumi:"description"` + // The input reference configuration for the ID mapping table. + InputReferenceConfig IdMappingTableInputReferenceConfig `pulumi:"inputReferenceConfig"` + // The Amazon Resource Name (ARN) of the AWS KMS key. + KmsKeyArn *string `pulumi:"kmsKeyArn"` + // The unique identifier of the membership resource for the ID mapping table. + MembershipIdentifier string `pulumi:"membershipIdentifier"` + // The name of the ID mapping table. + Name *string `pulumi:"name"` + // An optional label that you can assign to a resource when you create it. Each tag consists of a key and an optional value, both of which you define. When you use tagging, you can also use tag-based access control in IAM policies to control access to this resource. + Tags []aws.Tag `pulumi:"tags"` +} + +// The set of arguments for constructing a IdMappingTable resource. +type IdMappingTableArgs struct { + // The description of the ID mapping table. + Description pulumi.StringPtrInput + // The input reference configuration for the ID mapping table. + InputReferenceConfig IdMappingTableInputReferenceConfigInput + // The Amazon Resource Name (ARN) of the AWS KMS key. + KmsKeyArn pulumi.StringPtrInput + // The unique identifier of the membership resource for the ID mapping table. + MembershipIdentifier pulumi.StringInput + // The name of the ID mapping table. + Name pulumi.StringPtrInput + // An optional label that you can assign to a resource when you create it. Each tag consists of a key and an optional value, both of which you define. When you use tagging, you can also use tag-based access control in IAM policies to control access to this resource. + Tags aws.TagArrayInput +} + +func (IdMappingTableArgs) ElementType() reflect.Type { + return reflect.TypeOf((*idMappingTableArgs)(nil)).Elem() +} + +type IdMappingTableInput interface { + pulumi.Input + + ToIdMappingTableOutput() IdMappingTableOutput + ToIdMappingTableOutputWithContext(ctx context.Context) IdMappingTableOutput +} + +func (*IdMappingTable) ElementType() reflect.Type { + return reflect.TypeOf((**IdMappingTable)(nil)).Elem() +} + +func (i *IdMappingTable) ToIdMappingTableOutput() IdMappingTableOutput { + return i.ToIdMappingTableOutputWithContext(context.Background()) +} + +func (i *IdMappingTable) ToIdMappingTableOutputWithContext(ctx context.Context) IdMappingTableOutput { + return pulumi.ToOutputWithContext(ctx, i).(IdMappingTableOutput) +} + +type IdMappingTableOutput struct{ *pulumi.OutputState } + +func (IdMappingTableOutput) ElementType() reflect.Type { + return reflect.TypeOf((**IdMappingTable)(nil)).Elem() +} + +func (o IdMappingTableOutput) ToIdMappingTableOutput() IdMappingTableOutput { + return o +} + +func (o IdMappingTableOutput) ToIdMappingTableOutputWithContext(ctx context.Context) IdMappingTableOutput { + return o +} + +// The Amazon Resource Name (ARN) of the ID mapping table. +func (o IdMappingTableOutput) Arn() pulumi.StringOutput { + return o.ApplyT(func(v *IdMappingTable) pulumi.StringOutput { return v.Arn }).(pulumi.StringOutput) +} + +// The Amazon Resource Name (ARN) of the collaboration that contains this ID mapping table. +func (o IdMappingTableOutput) CollaborationArn() pulumi.StringOutput { + return o.ApplyT(func(v *IdMappingTable) pulumi.StringOutput { return v.CollaborationArn }).(pulumi.StringOutput) +} + +func (o IdMappingTableOutput) CollaborationIdentifier() pulumi.StringOutput { + return o.ApplyT(func(v *IdMappingTable) pulumi.StringOutput { return v.CollaborationIdentifier }).(pulumi.StringOutput) +} + +// The description of the ID mapping table. +func (o IdMappingTableOutput) Description() pulumi.StringPtrOutput { + return o.ApplyT(func(v *IdMappingTable) pulumi.StringPtrOutput { return v.Description }).(pulumi.StringPtrOutput) +} + +func (o IdMappingTableOutput) IdMappingTableIdentifier() pulumi.StringOutput { + return o.ApplyT(func(v *IdMappingTable) pulumi.StringOutput { return v.IdMappingTableIdentifier }).(pulumi.StringOutput) +} + +// The input reference configuration for the ID mapping table. +func (o IdMappingTableOutput) InputReferenceConfig() IdMappingTableInputReferenceConfigOutput { + return o.ApplyT(func(v *IdMappingTable) IdMappingTableInputReferenceConfigOutput { return v.InputReferenceConfig }).(IdMappingTableInputReferenceConfigOutput) +} + +func (o IdMappingTableOutput) InputReferenceProperties() IdMappingTableInputReferencePropertiesOutput { + return o.ApplyT(func(v *IdMappingTable) IdMappingTableInputReferencePropertiesOutput { + return v.InputReferenceProperties + }).(IdMappingTableInputReferencePropertiesOutput) +} + +// The Amazon Resource Name (ARN) of the AWS KMS key. +func (o IdMappingTableOutput) KmsKeyArn() pulumi.StringPtrOutput { + return o.ApplyT(func(v *IdMappingTable) pulumi.StringPtrOutput { return v.KmsKeyArn }).(pulumi.StringPtrOutput) +} + +// The Amazon Resource Name (ARN) of the membership resource for the ID mapping table. +func (o IdMappingTableOutput) MembershipArn() pulumi.StringOutput { + return o.ApplyT(func(v *IdMappingTable) pulumi.StringOutput { return v.MembershipArn }).(pulumi.StringOutput) +} + +// The unique identifier of the membership resource for the ID mapping table. +func (o IdMappingTableOutput) MembershipIdentifier() pulumi.StringOutput { + return o.ApplyT(func(v *IdMappingTable) pulumi.StringOutput { return v.MembershipIdentifier }).(pulumi.StringOutput) +} + +// The name of the ID mapping table. +func (o IdMappingTableOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *IdMappingTable) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// An optional label that you can assign to a resource when you create it. Each tag consists of a key and an optional value, both of which you define. When you use tagging, you can also use tag-based access control in IAM policies to control access to this resource. +func (o IdMappingTableOutput) Tags() aws.TagArrayOutput { + return o.ApplyT(func(v *IdMappingTable) aws.TagArrayOutput { return v.Tags }).(aws.TagArrayOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*IdMappingTableInput)(nil)).Elem(), &IdMappingTable{}) + pulumi.RegisterOutputType(IdMappingTableOutput{}) +} diff --git a/sdk/go/aws/cleanrooms/idNamespaceAssociation.go b/sdk/go/aws/cleanrooms/idNamespaceAssociation.go new file mode 100644 index 0000000000..45675e51a3 --- /dev/null +++ b/sdk/go/aws/cleanrooms/idNamespaceAssociation.go @@ -0,0 +1,223 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package cleanrooms + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-aws-native/sdk/go/aws" + "github.com/pulumi/pulumi-aws-native/sdk/go/aws/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Represents an association between an ID namespace and a collaboration +type IdNamespaceAssociation struct { + pulumi.CustomResourceState + + // The Amazon Resource Name (ARN) of the ID namespace association. + Arn pulumi.StringOutput `pulumi:"arn"` + // The Amazon Resource Name (ARN) of the collaboration that contains this ID namespace association. + CollaborationArn pulumi.StringOutput `pulumi:"collaborationArn"` + CollaborationIdentifier pulumi.StringOutput `pulumi:"collaborationIdentifier"` + // The description of the ID namespace association. + Description pulumi.StringPtrOutput `pulumi:"description"` + // The configuration settings for the ID mapping table. + IdMappingConfig IdNamespaceAssociationIdMappingConfigPtrOutput `pulumi:"idMappingConfig"` + IdNamespaceAssociationIdentifier pulumi.StringOutput `pulumi:"idNamespaceAssociationIdentifier"` + // The input reference configuration for the ID namespace association. + InputReferenceConfig IdNamespaceAssociationInputReferenceConfigOutput `pulumi:"inputReferenceConfig"` + InputReferenceProperties IdNamespaceAssociationInputReferencePropertiesOutput `pulumi:"inputReferenceProperties"` + // The Amazon Resource Name (ARN) of the membership resource for this ID namespace association. + MembershipArn pulumi.StringOutput `pulumi:"membershipArn"` + // The unique identifier of the membership that contains the ID namespace association. + MembershipIdentifier pulumi.StringOutput `pulumi:"membershipIdentifier"` + // The name of this ID namespace association. + Name pulumi.StringOutput `pulumi:"name"` + Tags aws.TagArrayOutput `pulumi:"tags"` +} + +// NewIdNamespaceAssociation registers a new resource with the given unique name, arguments, and options. +func NewIdNamespaceAssociation(ctx *pulumi.Context, + name string, args *IdNamespaceAssociationArgs, opts ...pulumi.ResourceOption) (*IdNamespaceAssociation, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.InputReferenceConfig == nil { + return nil, errors.New("invalid value for required argument 'InputReferenceConfig'") + } + if args.MembershipIdentifier == nil { + return nil, errors.New("invalid value for required argument 'MembershipIdentifier'") + } + replaceOnChanges := pulumi.ReplaceOnChanges([]string{ + "inputReferenceConfig", + "membershipIdentifier", + }) + opts = append(opts, replaceOnChanges) + opts = internal.PkgResourceDefaultOpts(opts) + var resource IdNamespaceAssociation + err := ctx.RegisterResource("aws-native:cleanrooms:IdNamespaceAssociation", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetIdNamespaceAssociation gets an existing IdNamespaceAssociation resource's state with the given name, ID, and optional +// state properties that are used to uniquely qualify the lookup (nil if not required). +func GetIdNamespaceAssociation(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *IdNamespaceAssociationState, opts ...pulumi.ResourceOption) (*IdNamespaceAssociation, error) { + var resource IdNamespaceAssociation + err := ctx.ReadResource("aws-native:cleanrooms:IdNamespaceAssociation", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering IdNamespaceAssociation resources. +type idNamespaceAssociationState struct { +} + +type IdNamespaceAssociationState struct { +} + +func (IdNamespaceAssociationState) ElementType() reflect.Type { + return reflect.TypeOf((*idNamespaceAssociationState)(nil)).Elem() +} + +type idNamespaceAssociationArgs struct { + // The description of the ID namespace association. + Description *string `pulumi:"description"` + // The configuration settings for the ID mapping table. + IdMappingConfig *IdNamespaceAssociationIdMappingConfig `pulumi:"idMappingConfig"` + // The input reference configuration for the ID namespace association. + InputReferenceConfig IdNamespaceAssociationInputReferenceConfig `pulumi:"inputReferenceConfig"` + // The unique identifier of the membership that contains the ID namespace association. + MembershipIdentifier string `pulumi:"membershipIdentifier"` + // The name of this ID namespace association. + Name *string `pulumi:"name"` + Tags []aws.Tag `pulumi:"tags"` +} + +// The set of arguments for constructing a IdNamespaceAssociation resource. +type IdNamespaceAssociationArgs struct { + // The description of the ID namespace association. + Description pulumi.StringPtrInput + // The configuration settings for the ID mapping table. + IdMappingConfig IdNamespaceAssociationIdMappingConfigPtrInput + // The input reference configuration for the ID namespace association. + InputReferenceConfig IdNamespaceAssociationInputReferenceConfigInput + // The unique identifier of the membership that contains the ID namespace association. + MembershipIdentifier pulumi.StringInput + // The name of this ID namespace association. + Name pulumi.StringPtrInput + Tags aws.TagArrayInput +} + +func (IdNamespaceAssociationArgs) ElementType() reflect.Type { + return reflect.TypeOf((*idNamespaceAssociationArgs)(nil)).Elem() +} + +type IdNamespaceAssociationInput interface { + pulumi.Input + + ToIdNamespaceAssociationOutput() IdNamespaceAssociationOutput + ToIdNamespaceAssociationOutputWithContext(ctx context.Context) IdNamespaceAssociationOutput +} + +func (*IdNamespaceAssociation) ElementType() reflect.Type { + return reflect.TypeOf((**IdNamespaceAssociation)(nil)).Elem() +} + +func (i *IdNamespaceAssociation) ToIdNamespaceAssociationOutput() IdNamespaceAssociationOutput { + return i.ToIdNamespaceAssociationOutputWithContext(context.Background()) +} + +func (i *IdNamespaceAssociation) ToIdNamespaceAssociationOutputWithContext(ctx context.Context) IdNamespaceAssociationOutput { + return pulumi.ToOutputWithContext(ctx, i).(IdNamespaceAssociationOutput) +} + +type IdNamespaceAssociationOutput struct{ *pulumi.OutputState } + +func (IdNamespaceAssociationOutput) ElementType() reflect.Type { + return reflect.TypeOf((**IdNamespaceAssociation)(nil)).Elem() +} + +func (o IdNamespaceAssociationOutput) ToIdNamespaceAssociationOutput() IdNamespaceAssociationOutput { + return o +} + +func (o IdNamespaceAssociationOutput) ToIdNamespaceAssociationOutputWithContext(ctx context.Context) IdNamespaceAssociationOutput { + return o +} + +// The Amazon Resource Name (ARN) of the ID namespace association. +func (o IdNamespaceAssociationOutput) Arn() pulumi.StringOutput { + return o.ApplyT(func(v *IdNamespaceAssociation) pulumi.StringOutput { return v.Arn }).(pulumi.StringOutput) +} + +// The Amazon Resource Name (ARN) of the collaboration that contains this ID namespace association. +func (o IdNamespaceAssociationOutput) CollaborationArn() pulumi.StringOutput { + return o.ApplyT(func(v *IdNamespaceAssociation) pulumi.StringOutput { return v.CollaborationArn }).(pulumi.StringOutput) +} + +func (o IdNamespaceAssociationOutput) CollaborationIdentifier() pulumi.StringOutput { + return o.ApplyT(func(v *IdNamespaceAssociation) pulumi.StringOutput { return v.CollaborationIdentifier }).(pulumi.StringOutput) +} + +// The description of the ID namespace association. +func (o IdNamespaceAssociationOutput) Description() pulumi.StringPtrOutput { + return o.ApplyT(func(v *IdNamespaceAssociation) pulumi.StringPtrOutput { return v.Description }).(pulumi.StringPtrOutput) +} + +// The configuration settings for the ID mapping table. +func (o IdNamespaceAssociationOutput) IdMappingConfig() IdNamespaceAssociationIdMappingConfigPtrOutput { + return o.ApplyT(func(v *IdNamespaceAssociation) IdNamespaceAssociationIdMappingConfigPtrOutput { + return v.IdMappingConfig + }).(IdNamespaceAssociationIdMappingConfigPtrOutput) +} + +func (o IdNamespaceAssociationOutput) IdNamespaceAssociationIdentifier() pulumi.StringOutput { + return o.ApplyT(func(v *IdNamespaceAssociation) pulumi.StringOutput { return v.IdNamespaceAssociationIdentifier }).(pulumi.StringOutput) +} + +// The input reference configuration for the ID namespace association. +func (o IdNamespaceAssociationOutput) InputReferenceConfig() IdNamespaceAssociationInputReferenceConfigOutput { + return o.ApplyT(func(v *IdNamespaceAssociation) IdNamespaceAssociationInputReferenceConfigOutput { + return v.InputReferenceConfig + }).(IdNamespaceAssociationInputReferenceConfigOutput) +} + +func (o IdNamespaceAssociationOutput) InputReferenceProperties() IdNamespaceAssociationInputReferencePropertiesOutput { + return o.ApplyT(func(v *IdNamespaceAssociation) IdNamespaceAssociationInputReferencePropertiesOutput { + return v.InputReferenceProperties + }).(IdNamespaceAssociationInputReferencePropertiesOutput) +} + +// The Amazon Resource Name (ARN) of the membership resource for this ID namespace association. +func (o IdNamespaceAssociationOutput) MembershipArn() pulumi.StringOutput { + return o.ApplyT(func(v *IdNamespaceAssociation) pulumi.StringOutput { return v.MembershipArn }).(pulumi.StringOutput) +} + +// The unique identifier of the membership that contains the ID namespace association. +func (o IdNamespaceAssociationOutput) MembershipIdentifier() pulumi.StringOutput { + return o.ApplyT(func(v *IdNamespaceAssociation) pulumi.StringOutput { return v.MembershipIdentifier }).(pulumi.StringOutput) +} + +// The name of this ID namespace association. +func (o IdNamespaceAssociationOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *IdNamespaceAssociation) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +func (o IdNamespaceAssociationOutput) Tags() aws.TagArrayOutput { + return o.ApplyT(func(v *IdNamespaceAssociation) aws.TagArrayOutput { return v.Tags }).(aws.TagArrayOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*IdNamespaceAssociationInput)(nil)).Elem(), &IdNamespaceAssociation{}) + pulumi.RegisterOutputType(IdNamespaceAssociationOutput{}) +} diff --git a/sdk/go/aws/cleanrooms/init.go b/sdk/go/aws/cleanrooms/init.go index b6171ca25b..18453665a9 100644 --- a/sdk/go/aws/cleanrooms/init.go +++ b/sdk/go/aws/cleanrooms/init.go @@ -29,6 +29,10 @@ func (m *module) Construct(ctx *pulumi.Context, name, typ, urn string) (r pulumi r = &ConfiguredTable{} case "aws-native:cleanrooms:ConfiguredTableAssociation": r = &ConfiguredTableAssociation{} + case "aws-native:cleanrooms:IdMappingTable": + r = &IdMappingTable{} + case "aws-native:cleanrooms:IdNamespaceAssociation": + r = &IdNamespaceAssociation{} case "aws-native:cleanrooms:Membership": r = &Membership{} case "aws-native:cleanrooms:PrivacyBudgetTemplate": diff --git a/sdk/go/aws/cleanrooms/pulumiEnums.go b/sdk/go/aws/cleanrooms/pulumiEnums.go index 771e2e6a17..9b6e7d4e91 100644 --- a/sdk/go/aws/cleanrooms/pulumiEnums.go +++ b/sdk/go/aws/cleanrooms/pulumiEnums.go @@ -2366,6 +2366,188 @@ func (o ConfiguredTableScalarFunctionsArrayOutput) Index(i pulumi.IntInput) Conf }).(ConfiguredTableScalarFunctionsOutput) } +// The type of the input source of the ID mapping table. +type IdMappingTableInputSourceType string + +const ( + IdMappingTableInputSourceTypeSource = IdMappingTableInputSourceType("SOURCE") + IdMappingTableInputSourceTypeTarget = IdMappingTableInputSourceType("TARGET") +) + +type IdMappingTableInputSourceTypeOutput struct{ *pulumi.OutputState } + +func (IdMappingTableInputSourceTypeOutput) ElementType() reflect.Type { + return reflect.TypeOf((*IdMappingTableInputSourceType)(nil)).Elem() +} + +func (o IdMappingTableInputSourceTypeOutput) ToIdMappingTableInputSourceTypeOutput() IdMappingTableInputSourceTypeOutput { + return o +} + +func (o IdMappingTableInputSourceTypeOutput) ToIdMappingTableInputSourceTypeOutputWithContext(ctx context.Context) IdMappingTableInputSourceTypeOutput { + return o +} + +func (o IdMappingTableInputSourceTypeOutput) ToIdMappingTableInputSourceTypePtrOutput() IdMappingTableInputSourceTypePtrOutput { + return o.ToIdMappingTableInputSourceTypePtrOutputWithContext(context.Background()) +} + +func (o IdMappingTableInputSourceTypeOutput) ToIdMappingTableInputSourceTypePtrOutputWithContext(ctx context.Context) IdMappingTableInputSourceTypePtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v IdMappingTableInputSourceType) *IdMappingTableInputSourceType { + return &v + }).(IdMappingTableInputSourceTypePtrOutput) +} + +func (o IdMappingTableInputSourceTypeOutput) ToStringOutput() pulumi.StringOutput { + return o.ToStringOutputWithContext(context.Background()) +} + +func (o IdMappingTableInputSourceTypeOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, e IdMappingTableInputSourceType) string { + return string(e) + }).(pulumi.StringOutput) +} + +func (o IdMappingTableInputSourceTypeOutput) ToStringPtrOutput() pulumi.StringPtrOutput { + return o.ToStringPtrOutputWithContext(context.Background()) +} + +func (o IdMappingTableInputSourceTypeOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, e IdMappingTableInputSourceType) *string { + v := string(e) + return &v + }).(pulumi.StringPtrOutput) +} + +type IdMappingTableInputSourceTypePtrOutput struct{ *pulumi.OutputState } + +func (IdMappingTableInputSourceTypePtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**IdMappingTableInputSourceType)(nil)).Elem() +} + +func (o IdMappingTableInputSourceTypePtrOutput) ToIdMappingTableInputSourceTypePtrOutput() IdMappingTableInputSourceTypePtrOutput { + return o +} + +func (o IdMappingTableInputSourceTypePtrOutput) ToIdMappingTableInputSourceTypePtrOutputWithContext(ctx context.Context) IdMappingTableInputSourceTypePtrOutput { + return o +} + +func (o IdMappingTableInputSourceTypePtrOutput) Elem() IdMappingTableInputSourceTypeOutput { + return o.ApplyT(func(v *IdMappingTableInputSourceType) IdMappingTableInputSourceType { + if v != nil { + return *v + } + var ret IdMappingTableInputSourceType + return ret + }).(IdMappingTableInputSourceTypeOutput) +} + +func (o IdMappingTableInputSourceTypePtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput { + return o.ToStringPtrOutputWithContext(context.Background()) +} + +func (o IdMappingTableInputSourceTypePtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, e *IdMappingTableInputSourceType) *string { + if e == nil { + return nil + } + v := string(*e) + return &v + }).(pulumi.StringPtrOutput) +} + +// The ID namespace type for this ID namespace association. +type IdNamespaceAssociationInputReferencePropertiesIdNamespaceType string + +const ( + IdNamespaceAssociationInputReferencePropertiesIdNamespaceTypeSource = IdNamespaceAssociationInputReferencePropertiesIdNamespaceType("SOURCE") + IdNamespaceAssociationInputReferencePropertiesIdNamespaceTypeTarget = IdNamespaceAssociationInputReferencePropertiesIdNamespaceType("TARGET") +) + +type IdNamespaceAssociationInputReferencePropertiesIdNamespaceTypeOutput struct{ *pulumi.OutputState } + +func (IdNamespaceAssociationInputReferencePropertiesIdNamespaceTypeOutput) ElementType() reflect.Type { + return reflect.TypeOf((*IdNamespaceAssociationInputReferencePropertiesIdNamespaceType)(nil)).Elem() +} + +func (o IdNamespaceAssociationInputReferencePropertiesIdNamespaceTypeOutput) ToIdNamespaceAssociationInputReferencePropertiesIdNamespaceTypeOutput() IdNamespaceAssociationInputReferencePropertiesIdNamespaceTypeOutput { + return o +} + +func (o IdNamespaceAssociationInputReferencePropertiesIdNamespaceTypeOutput) ToIdNamespaceAssociationInputReferencePropertiesIdNamespaceTypeOutputWithContext(ctx context.Context) IdNamespaceAssociationInputReferencePropertiesIdNamespaceTypeOutput { + return o +} + +func (o IdNamespaceAssociationInputReferencePropertiesIdNamespaceTypeOutput) ToIdNamespaceAssociationInputReferencePropertiesIdNamespaceTypePtrOutput() IdNamespaceAssociationInputReferencePropertiesIdNamespaceTypePtrOutput { + return o.ToIdNamespaceAssociationInputReferencePropertiesIdNamespaceTypePtrOutputWithContext(context.Background()) +} + +func (o IdNamespaceAssociationInputReferencePropertiesIdNamespaceTypeOutput) ToIdNamespaceAssociationInputReferencePropertiesIdNamespaceTypePtrOutputWithContext(ctx context.Context) IdNamespaceAssociationInputReferencePropertiesIdNamespaceTypePtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v IdNamespaceAssociationInputReferencePropertiesIdNamespaceType) *IdNamespaceAssociationInputReferencePropertiesIdNamespaceType { + return &v + }).(IdNamespaceAssociationInputReferencePropertiesIdNamespaceTypePtrOutput) +} + +func (o IdNamespaceAssociationInputReferencePropertiesIdNamespaceTypeOutput) ToStringOutput() pulumi.StringOutput { + return o.ToStringOutputWithContext(context.Background()) +} + +func (o IdNamespaceAssociationInputReferencePropertiesIdNamespaceTypeOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, e IdNamespaceAssociationInputReferencePropertiesIdNamespaceType) string { + return string(e) + }).(pulumi.StringOutput) +} + +func (o IdNamespaceAssociationInputReferencePropertiesIdNamespaceTypeOutput) ToStringPtrOutput() pulumi.StringPtrOutput { + return o.ToStringPtrOutputWithContext(context.Background()) +} + +func (o IdNamespaceAssociationInputReferencePropertiesIdNamespaceTypeOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, e IdNamespaceAssociationInputReferencePropertiesIdNamespaceType) *string { + v := string(e) + return &v + }).(pulumi.StringPtrOutput) +} + +type IdNamespaceAssociationInputReferencePropertiesIdNamespaceTypePtrOutput struct{ *pulumi.OutputState } + +func (IdNamespaceAssociationInputReferencePropertiesIdNamespaceTypePtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**IdNamespaceAssociationInputReferencePropertiesIdNamespaceType)(nil)).Elem() +} + +func (o IdNamespaceAssociationInputReferencePropertiesIdNamespaceTypePtrOutput) ToIdNamespaceAssociationInputReferencePropertiesIdNamespaceTypePtrOutput() IdNamespaceAssociationInputReferencePropertiesIdNamespaceTypePtrOutput { + return o +} + +func (o IdNamespaceAssociationInputReferencePropertiesIdNamespaceTypePtrOutput) ToIdNamespaceAssociationInputReferencePropertiesIdNamespaceTypePtrOutputWithContext(ctx context.Context) IdNamespaceAssociationInputReferencePropertiesIdNamespaceTypePtrOutput { + return o +} + +func (o IdNamespaceAssociationInputReferencePropertiesIdNamespaceTypePtrOutput) Elem() IdNamespaceAssociationInputReferencePropertiesIdNamespaceTypeOutput { + return o.ApplyT(func(v *IdNamespaceAssociationInputReferencePropertiesIdNamespaceType) IdNamespaceAssociationInputReferencePropertiesIdNamespaceType { + if v != nil { + return *v + } + var ret IdNamespaceAssociationInputReferencePropertiesIdNamespaceType + return ret + }).(IdNamespaceAssociationInputReferencePropertiesIdNamespaceTypeOutput) +} + +func (o IdNamespaceAssociationInputReferencePropertiesIdNamespaceTypePtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput { + return o.ToStringPtrOutputWithContext(context.Background()) +} + +func (o IdNamespaceAssociationInputReferencePropertiesIdNamespaceTypePtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, e *IdNamespaceAssociationInputReferencePropertiesIdNamespaceType) *string { + if e == nil { + return nil + } + v := string(*e) + return &v + }).(pulumi.StringPtrOutput) +} + type MembershipQueryLogStatus string const ( @@ -3095,6 +3277,10 @@ func init() { pulumi.RegisterOutputType(ConfiguredTableScalarFunctionsOutput{}) pulumi.RegisterOutputType(ConfiguredTableScalarFunctionsPtrOutput{}) pulumi.RegisterOutputType(ConfiguredTableScalarFunctionsArrayOutput{}) + pulumi.RegisterOutputType(IdMappingTableInputSourceTypeOutput{}) + pulumi.RegisterOutputType(IdMappingTableInputSourceTypePtrOutput{}) + pulumi.RegisterOutputType(IdNamespaceAssociationInputReferencePropertiesIdNamespaceTypeOutput{}) + pulumi.RegisterOutputType(IdNamespaceAssociationInputReferencePropertiesIdNamespaceTypePtrOutput{}) pulumi.RegisterOutputType(MembershipQueryLogStatusOutput{}) pulumi.RegisterOutputType(MembershipQueryLogStatusPtrOutput{}) pulumi.RegisterOutputType(MembershipResultFormatOutput{}) diff --git a/sdk/go/aws/cleanrooms/pulumiTypes.go b/sdk/go/aws/cleanrooms/pulumiTypes.go index 3552fd192a..828eb08928 100644 --- a/sdk/go/aws/cleanrooms/pulumiTypes.go +++ b/sdk/go/aws/cleanrooms/pulumiTypes.go @@ -2476,6 +2476,526 @@ type ConfiguredTableTag struct { Value string `pulumi:"value"` } +type IdMappingTableInputReferenceConfig struct { + // The Amazon Resource Name (ARN) of the referenced resource in AWS Entity Resolution . Valid values are ID mapping workflow ARNs. + InputReferenceArn string `pulumi:"inputReferenceArn"` + // When `TRUE` , AWS Clean Rooms manages permissions for the ID mapping table resource. + // + // When `FALSE` , the resource owner manages permissions for the ID mapping table resource. + ManageResourcePolicies bool `pulumi:"manageResourcePolicies"` +} + +// IdMappingTableInputReferenceConfigInput is an input type that accepts IdMappingTableInputReferenceConfigArgs and IdMappingTableInputReferenceConfigOutput values. +// You can construct a concrete instance of `IdMappingTableInputReferenceConfigInput` via: +// +// IdMappingTableInputReferenceConfigArgs{...} +type IdMappingTableInputReferenceConfigInput interface { + pulumi.Input + + ToIdMappingTableInputReferenceConfigOutput() IdMappingTableInputReferenceConfigOutput + ToIdMappingTableInputReferenceConfigOutputWithContext(context.Context) IdMappingTableInputReferenceConfigOutput +} + +type IdMappingTableInputReferenceConfigArgs struct { + // The Amazon Resource Name (ARN) of the referenced resource in AWS Entity Resolution . Valid values are ID mapping workflow ARNs. + InputReferenceArn pulumi.StringInput `pulumi:"inputReferenceArn"` + // When `TRUE` , AWS Clean Rooms manages permissions for the ID mapping table resource. + // + // When `FALSE` , the resource owner manages permissions for the ID mapping table resource. + ManageResourcePolicies pulumi.BoolInput `pulumi:"manageResourcePolicies"` +} + +func (IdMappingTableInputReferenceConfigArgs) ElementType() reflect.Type { + return reflect.TypeOf((*IdMappingTableInputReferenceConfig)(nil)).Elem() +} + +func (i IdMappingTableInputReferenceConfigArgs) ToIdMappingTableInputReferenceConfigOutput() IdMappingTableInputReferenceConfigOutput { + return i.ToIdMappingTableInputReferenceConfigOutputWithContext(context.Background()) +} + +func (i IdMappingTableInputReferenceConfigArgs) ToIdMappingTableInputReferenceConfigOutputWithContext(ctx context.Context) IdMappingTableInputReferenceConfigOutput { + return pulumi.ToOutputWithContext(ctx, i).(IdMappingTableInputReferenceConfigOutput) +} + +type IdMappingTableInputReferenceConfigOutput struct{ *pulumi.OutputState } + +func (IdMappingTableInputReferenceConfigOutput) ElementType() reflect.Type { + return reflect.TypeOf((*IdMappingTableInputReferenceConfig)(nil)).Elem() +} + +func (o IdMappingTableInputReferenceConfigOutput) ToIdMappingTableInputReferenceConfigOutput() IdMappingTableInputReferenceConfigOutput { + return o +} + +func (o IdMappingTableInputReferenceConfigOutput) ToIdMappingTableInputReferenceConfigOutputWithContext(ctx context.Context) IdMappingTableInputReferenceConfigOutput { + return o +} + +// The Amazon Resource Name (ARN) of the referenced resource in AWS Entity Resolution . Valid values are ID mapping workflow ARNs. +func (o IdMappingTableInputReferenceConfigOutput) InputReferenceArn() pulumi.StringOutput { + return o.ApplyT(func(v IdMappingTableInputReferenceConfig) string { return v.InputReferenceArn }).(pulumi.StringOutput) +} + +// When `TRUE` , AWS Clean Rooms manages permissions for the ID mapping table resource. +// +// When `FALSE` , the resource owner manages permissions for the ID mapping table resource. +func (o IdMappingTableInputReferenceConfigOutput) ManageResourcePolicies() pulumi.BoolOutput { + return o.ApplyT(func(v IdMappingTableInputReferenceConfig) bool { return v.ManageResourcePolicies }).(pulumi.BoolOutput) +} + +type IdMappingTableInputReferenceProperties struct { + // The input source of the ID mapping table. + IdMappingTableInputSource []IdMappingTableInputSource `pulumi:"idMappingTableInputSource"` +} + +type IdMappingTableInputReferencePropertiesOutput struct{ *pulumi.OutputState } + +func (IdMappingTableInputReferencePropertiesOutput) ElementType() reflect.Type { + return reflect.TypeOf((*IdMappingTableInputReferenceProperties)(nil)).Elem() +} + +func (o IdMappingTableInputReferencePropertiesOutput) ToIdMappingTableInputReferencePropertiesOutput() IdMappingTableInputReferencePropertiesOutput { + return o +} + +func (o IdMappingTableInputReferencePropertiesOutput) ToIdMappingTableInputReferencePropertiesOutputWithContext(ctx context.Context) IdMappingTableInputReferencePropertiesOutput { + return o +} + +// The input source of the ID mapping table. +func (o IdMappingTableInputReferencePropertiesOutput) IdMappingTableInputSource() IdMappingTableInputSourceArrayOutput { + return o.ApplyT(func(v IdMappingTableInputReferenceProperties) []IdMappingTableInputSource { + return v.IdMappingTableInputSource + }).(IdMappingTableInputSourceArrayOutput) +} + +type IdMappingTableInputReferencePropertiesPtrOutput struct{ *pulumi.OutputState } + +func (IdMappingTableInputReferencePropertiesPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**IdMappingTableInputReferenceProperties)(nil)).Elem() +} + +func (o IdMappingTableInputReferencePropertiesPtrOutput) ToIdMappingTableInputReferencePropertiesPtrOutput() IdMappingTableInputReferencePropertiesPtrOutput { + return o +} + +func (o IdMappingTableInputReferencePropertiesPtrOutput) ToIdMappingTableInputReferencePropertiesPtrOutputWithContext(ctx context.Context) IdMappingTableInputReferencePropertiesPtrOutput { + return o +} + +func (o IdMappingTableInputReferencePropertiesPtrOutput) Elem() IdMappingTableInputReferencePropertiesOutput { + return o.ApplyT(func(v *IdMappingTableInputReferenceProperties) IdMappingTableInputReferenceProperties { + if v != nil { + return *v + } + var ret IdMappingTableInputReferenceProperties + return ret + }).(IdMappingTableInputReferencePropertiesOutput) +} + +// The input source of the ID mapping table. +func (o IdMappingTableInputReferencePropertiesPtrOutput) IdMappingTableInputSource() IdMappingTableInputSourceArrayOutput { + return o.ApplyT(func(v *IdMappingTableInputReferenceProperties) []IdMappingTableInputSource { + if v == nil { + return nil + } + return v.IdMappingTableInputSource + }).(IdMappingTableInputSourceArrayOutput) +} + +type IdMappingTableInputSource struct { + // The unique identifier of the ID namespace association. + IdNamespaceAssociationId string `pulumi:"idNamespaceAssociationId"` + // The type of the input source of the ID mapping table. + Type IdMappingTableInputSourceType `pulumi:"type"` +} + +type IdMappingTableInputSourceOutput struct{ *pulumi.OutputState } + +func (IdMappingTableInputSourceOutput) ElementType() reflect.Type { + return reflect.TypeOf((*IdMappingTableInputSource)(nil)).Elem() +} + +func (o IdMappingTableInputSourceOutput) ToIdMappingTableInputSourceOutput() IdMappingTableInputSourceOutput { + return o +} + +func (o IdMappingTableInputSourceOutput) ToIdMappingTableInputSourceOutputWithContext(ctx context.Context) IdMappingTableInputSourceOutput { + return o +} + +// The unique identifier of the ID namespace association. +func (o IdMappingTableInputSourceOutput) IdNamespaceAssociationId() pulumi.StringOutput { + return o.ApplyT(func(v IdMappingTableInputSource) string { return v.IdNamespaceAssociationId }).(pulumi.StringOutput) +} + +// The type of the input source of the ID mapping table. +func (o IdMappingTableInputSourceOutput) Type() IdMappingTableInputSourceTypeOutput { + return o.ApplyT(func(v IdMappingTableInputSource) IdMappingTableInputSourceType { return v.Type }).(IdMappingTableInputSourceTypeOutput) +} + +type IdMappingTableInputSourceArrayOutput struct{ *pulumi.OutputState } + +func (IdMappingTableInputSourceArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]IdMappingTableInputSource)(nil)).Elem() +} + +func (o IdMappingTableInputSourceArrayOutput) ToIdMappingTableInputSourceArrayOutput() IdMappingTableInputSourceArrayOutput { + return o +} + +func (o IdMappingTableInputSourceArrayOutput) ToIdMappingTableInputSourceArrayOutputWithContext(ctx context.Context) IdMappingTableInputSourceArrayOutput { + return o +} + +func (o IdMappingTableInputSourceArrayOutput) Index(i pulumi.IntInput) IdMappingTableInputSourceOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) IdMappingTableInputSource { + return vs[0].([]IdMappingTableInputSource)[vs[1].(int)] + }).(IdMappingTableInputSourceOutput) +} + +type IdMappingTableTag struct { + // The key of the tag. + Key string `pulumi:"key"` + // The value of the tag. + Value string `pulumi:"value"` +} + +type IdNamespaceAssociationDocument struct { +} + +type IdNamespaceAssociationDocumentOutput struct{ *pulumi.OutputState } + +func (IdNamespaceAssociationDocumentOutput) ElementType() reflect.Type { + return reflect.TypeOf((*IdNamespaceAssociationDocument)(nil)).Elem() +} + +func (o IdNamespaceAssociationDocumentOutput) ToIdNamespaceAssociationDocumentOutput() IdNamespaceAssociationDocumentOutput { + return o +} + +func (o IdNamespaceAssociationDocumentOutput) ToIdNamespaceAssociationDocumentOutputWithContext(ctx context.Context) IdNamespaceAssociationDocumentOutput { + return o +} + +type IdNamespaceAssociationDocumentArrayOutput struct{ *pulumi.OutputState } + +func (IdNamespaceAssociationDocumentArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]IdNamespaceAssociationDocument)(nil)).Elem() +} + +func (o IdNamespaceAssociationDocumentArrayOutput) ToIdNamespaceAssociationDocumentArrayOutput() IdNamespaceAssociationDocumentArrayOutput { + return o +} + +func (o IdNamespaceAssociationDocumentArrayOutput) ToIdNamespaceAssociationDocumentArrayOutputWithContext(ctx context.Context) IdNamespaceAssociationDocumentArrayOutput { + return o +} + +func (o IdNamespaceAssociationDocumentArrayOutput) Index(i pulumi.IntInput) IdNamespaceAssociationDocumentOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) IdNamespaceAssociationDocument { + return vs[0].([]IdNamespaceAssociationDocument)[vs[1].(int)] + }).(IdNamespaceAssociationDocumentOutput) +} + +type IdNamespaceAssociationIdMappingConfig struct { + // An indicator as to whether you can use your column as a dimension column in the ID mapping table ( `TRUE` ) or not ( `FALSE` ). + // + // Default is `FALSE` . + AllowUseAsDimensionColumn bool `pulumi:"allowUseAsDimensionColumn"` +} + +// IdNamespaceAssociationIdMappingConfigInput is an input type that accepts IdNamespaceAssociationIdMappingConfigArgs and IdNamespaceAssociationIdMappingConfigOutput values. +// You can construct a concrete instance of `IdNamespaceAssociationIdMappingConfigInput` via: +// +// IdNamespaceAssociationIdMappingConfigArgs{...} +type IdNamespaceAssociationIdMappingConfigInput interface { + pulumi.Input + + ToIdNamespaceAssociationIdMappingConfigOutput() IdNamespaceAssociationIdMappingConfigOutput + ToIdNamespaceAssociationIdMappingConfigOutputWithContext(context.Context) IdNamespaceAssociationIdMappingConfigOutput +} + +type IdNamespaceAssociationIdMappingConfigArgs struct { + // An indicator as to whether you can use your column as a dimension column in the ID mapping table ( `TRUE` ) or not ( `FALSE` ). + // + // Default is `FALSE` . + AllowUseAsDimensionColumn pulumi.BoolInput `pulumi:"allowUseAsDimensionColumn"` +} + +func (IdNamespaceAssociationIdMappingConfigArgs) ElementType() reflect.Type { + return reflect.TypeOf((*IdNamespaceAssociationIdMappingConfig)(nil)).Elem() +} + +func (i IdNamespaceAssociationIdMappingConfigArgs) ToIdNamespaceAssociationIdMappingConfigOutput() IdNamespaceAssociationIdMappingConfigOutput { + return i.ToIdNamespaceAssociationIdMappingConfigOutputWithContext(context.Background()) +} + +func (i IdNamespaceAssociationIdMappingConfigArgs) ToIdNamespaceAssociationIdMappingConfigOutputWithContext(ctx context.Context) IdNamespaceAssociationIdMappingConfigOutput { + return pulumi.ToOutputWithContext(ctx, i).(IdNamespaceAssociationIdMappingConfigOutput) +} + +func (i IdNamespaceAssociationIdMappingConfigArgs) ToIdNamespaceAssociationIdMappingConfigPtrOutput() IdNamespaceAssociationIdMappingConfigPtrOutput { + return i.ToIdNamespaceAssociationIdMappingConfigPtrOutputWithContext(context.Background()) +} + +func (i IdNamespaceAssociationIdMappingConfigArgs) ToIdNamespaceAssociationIdMappingConfigPtrOutputWithContext(ctx context.Context) IdNamespaceAssociationIdMappingConfigPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(IdNamespaceAssociationIdMappingConfigOutput).ToIdNamespaceAssociationIdMappingConfigPtrOutputWithContext(ctx) +} + +// IdNamespaceAssociationIdMappingConfigPtrInput is an input type that accepts IdNamespaceAssociationIdMappingConfigArgs, IdNamespaceAssociationIdMappingConfigPtr and IdNamespaceAssociationIdMappingConfigPtrOutput values. +// You can construct a concrete instance of `IdNamespaceAssociationIdMappingConfigPtrInput` via: +// +// IdNamespaceAssociationIdMappingConfigArgs{...} +// +// or: +// +// nil +type IdNamespaceAssociationIdMappingConfigPtrInput interface { + pulumi.Input + + ToIdNamespaceAssociationIdMappingConfigPtrOutput() IdNamespaceAssociationIdMappingConfigPtrOutput + ToIdNamespaceAssociationIdMappingConfigPtrOutputWithContext(context.Context) IdNamespaceAssociationIdMappingConfigPtrOutput +} + +type idNamespaceAssociationIdMappingConfigPtrType IdNamespaceAssociationIdMappingConfigArgs + +func IdNamespaceAssociationIdMappingConfigPtr(v *IdNamespaceAssociationIdMappingConfigArgs) IdNamespaceAssociationIdMappingConfigPtrInput { + return (*idNamespaceAssociationIdMappingConfigPtrType)(v) +} + +func (*idNamespaceAssociationIdMappingConfigPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**IdNamespaceAssociationIdMappingConfig)(nil)).Elem() +} + +func (i *idNamespaceAssociationIdMappingConfigPtrType) ToIdNamespaceAssociationIdMappingConfigPtrOutput() IdNamespaceAssociationIdMappingConfigPtrOutput { + return i.ToIdNamespaceAssociationIdMappingConfigPtrOutputWithContext(context.Background()) +} + +func (i *idNamespaceAssociationIdMappingConfigPtrType) ToIdNamespaceAssociationIdMappingConfigPtrOutputWithContext(ctx context.Context) IdNamespaceAssociationIdMappingConfigPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(IdNamespaceAssociationIdMappingConfigPtrOutput) +} + +type IdNamespaceAssociationIdMappingConfigOutput struct{ *pulumi.OutputState } + +func (IdNamespaceAssociationIdMappingConfigOutput) ElementType() reflect.Type { + return reflect.TypeOf((*IdNamespaceAssociationIdMappingConfig)(nil)).Elem() +} + +func (o IdNamespaceAssociationIdMappingConfigOutput) ToIdNamespaceAssociationIdMappingConfigOutput() IdNamespaceAssociationIdMappingConfigOutput { + return o +} + +func (o IdNamespaceAssociationIdMappingConfigOutput) ToIdNamespaceAssociationIdMappingConfigOutputWithContext(ctx context.Context) IdNamespaceAssociationIdMappingConfigOutput { + return o +} + +func (o IdNamespaceAssociationIdMappingConfigOutput) ToIdNamespaceAssociationIdMappingConfigPtrOutput() IdNamespaceAssociationIdMappingConfigPtrOutput { + return o.ToIdNamespaceAssociationIdMappingConfigPtrOutputWithContext(context.Background()) +} + +func (o IdNamespaceAssociationIdMappingConfigOutput) ToIdNamespaceAssociationIdMappingConfigPtrOutputWithContext(ctx context.Context) IdNamespaceAssociationIdMappingConfigPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v IdNamespaceAssociationIdMappingConfig) *IdNamespaceAssociationIdMappingConfig { + return &v + }).(IdNamespaceAssociationIdMappingConfigPtrOutput) +} + +// An indicator as to whether you can use your column as a dimension column in the ID mapping table ( `TRUE` ) or not ( `FALSE` ). +// +// Default is `FALSE` . +func (o IdNamespaceAssociationIdMappingConfigOutput) AllowUseAsDimensionColumn() pulumi.BoolOutput { + return o.ApplyT(func(v IdNamespaceAssociationIdMappingConfig) bool { return v.AllowUseAsDimensionColumn }).(pulumi.BoolOutput) +} + +type IdNamespaceAssociationIdMappingConfigPtrOutput struct{ *pulumi.OutputState } + +func (IdNamespaceAssociationIdMappingConfigPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**IdNamespaceAssociationIdMappingConfig)(nil)).Elem() +} + +func (o IdNamespaceAssociationIdMappingConfigPtrOutput) ToIdNamespaceAssociationIdMappingConfigPtrOutput() IdNamespaceAssociationIdMappingConfigPtrOutput { + return o +} + +func (o IdNamespaceAssociationIdMappingConfigPtrOutput) ToIdNamespaceAssociationIdMappingConfigPtrOutputWithContext(ctx context.Context) IdNamespaceAssociationIdMappingConfigPtrOutput { + return o +} + +func (o IdNamespaceAssociationIdMappingConfigPtrOutput) Elem() IdNamespaceAssociationIdMappingConfigOutput { + return o.ApplyT(func(v *IdNamespaceAssociationIdMappingConfig) IdNamespaceAssociationIdMappingConfig { + if v != nil { + return *v + } + var ret IdNamespaceAssociationIdMappingConfig + return ret + }).(IdNamespaceAssociationIdMappingConfigOutput) +} + +// An indicator as to whether you can use your column as a dimension column in the ID mapping table ( `TRUE` ) or not ( `FALSE` ). +// +// Default is `FALSE` . +func (o IdNamespaceAssociationIdMappingConfigPtrOutput) AllowUseAsDimensionColumn() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *IdNamespaceAssociationIdMappingConfig) *bool { + if v == nil { + return nil + } + return &v.AllowUseAsDimensionColumn + }).(pulumi.BoolPtrOutput) +} + +type IdNamespaceAssociationInputReferenceConfig struct { + // The Amazon Resource Name (ARN) of the AWS Entity Resolution resource that is being associated to the collaboration. Valid resource ARNs are from the ID namespaces that you own. + InputReferenceArn string `pulumi:"inputReferenceArn"` + // When `TRUE` , AWS Clean Rooms manages permissions for the ID namespace association resource. + // + // When `FALSE` , the resource owner manages permissions for the ID namespace association resource. + ManageResourcePolicies bool `pulumi:"manageResourcePolicies"` +} + +// IdNamespaceAssociationInputReferenceConfigInput is an input type that accepts IdNamespaceAssociationInputReferenceConfigArgs and IdNamespaceAssociationInputReferenceConfigOutput values. +// You can construct a concrete instance of `IdNamespaceAssociationInputReferenceConfigInput` via: +// +// IdNamespaceAssociationInputReferenceConfigArgs{...} +type IdNamespaceAssociationInputReferenceConfigInput interface { + pulumi.Input + + ToIdNamespaceAssociationInputReferenceConfigOutput() IdNamespaceAssociationInputReferenceConfigOutput + ToIdNamespaceAssociationInputReferenceConfigOutputWithContext(context.Context) IdNamespaceAssociationInputReferenceConfigOutput +} + +type IdNamespaceAssociationInputReferenceConfigArgs struct { + // The Amazon Resource Name (ARN) of the AWS Entity Resolution resource that is being associated to the collaboration. Valid resource ARNs are from the ID namespaces that you own. + InputReferenceArn pulumi.StringInput `pulumi:"inputReferenceArn"` + // When `TRUE` , AWS Clean Rooms manages permissions for the ID namespace association resource. + // + // When `FALSE` , the resource owner manages permissions for the ID namespace association resource. + ManageResourcePolicies pulumi.BoolInput `pulumi:"manageResourcePolicies"` +} + +func (IdNamespaceAssociationInputReferenceConfigArgs) ElementType() reflect.Type { + return reflect.TypeOf((*IdNamespaceAssociationInputReferenceConfig)(nil)).Elem() +} + +func (i IdNamespaceAssociationInputReferenceConfigArgs) ToIdNamespaceAssociationInputReferenceConfigOutput() IdNamespaceAssociationInputReferenceConfigOutput { + return i.ToIdNamespaceAssociationInputReferenceConfigOutputWithContext(context.Background()) +} + +func (i IdNamespaceAssociationInputReferenceConfigArgs) ToIdNamespaceAssociationInputReferenceConfigOutputWithContext(ctx context.Context) IdNamespaceAssociationInputReferenceConfigOutput { + return pulumi.ToOutputWithContext(ctx, i).(IdNamespaceAssociationInputReferenceConfigOutput) +} + +type IdNamespaceAssociationInputReferenceConfigOutput struct{ *pulumi.OutputState } + +func (IdNamespaceAssociationInputReferenceConfigOutput) ElementType() reflect.Type { + return reflect.TypeOf((*IdNamespaceAssociationInputReferenceConfig)(nil)).Elem() +} + +func (o IdNamespaceAssociationInputReferenceConfigOutput) ToIdNamespaceAssociationInputReferenceConfigOutput() IdNamespaceAssociationInputReferenceConfigOutput { + return o +} + +func (o IdNamespaceAssociationInputReferenceConfigOutput) ToIdNamespaceAssociationInputReferenceConfigOutputWithContext(ctx context.Context) IdNamespaceAssociationInputReferenceConfigOutput { + return o +} + +// The Amazon Resource Name (ARN) of the AWS Entity Resolution resource that is being associated to the collaboration. Valid resource ARNs are from the ID namespaces that you own. +func (o IdNamespaceAssociationInputReferenceConfigOutput) InputReferenceArn() pulumi.StringOutput { + return o.ApplyT(func(v IdNamespaceAssociationInputReferenceConfig) string { return v.InputReferenceArn }).(pulumi.StringOutput) +} + +// When `TRUE` , AWS Clean Rooms manages permissions for the ID namespace association resource. +// +// When `FALSE` , the resource owner manages permissions for the ID namespace association resource. +func (o IdNamespaceAssociationInputReferenceConfigOutput) ManageResourcePolicies() pulumi.BoolOutput { + return o.ApplyT(func(v IdNamespaceAssociationInputReferenceConfig) bool { return v.ManageResourcePolicies }).(pulumi.BoolOutput) +} + +type IdNamespaceAssociationInputReferenceProperties struct { + // Defines how ID mapping workflows are supported for this ID namespace association. + IdMappingWorkflowsSupported []IdNamespaceAssociationDocument `pulumi:"idMappingWorkflowsSupported"` + // The ID namespace type for this ID namespace association. + IdNamespaceType *IdNamespaceAssociationInputReferencePropertiesIdNamespaceType `pulumi:"idNamespaceType"` +} + +type IdNamespaceAssociationInputReferencePropertiesOutput struct{ *pulumi.OutputState } + +func (IdNamespaceAssociationInputReferencePropertiesOutput) ElementType() reflect.Type { + return reflect.TypeOf((*IdNamespaceAssociationInputReferenceProperties)(nil)).Elem() +} + +func (o IdNamespaceAssociationInputReferencePropertiesOutput) ToIdNamespaceAssociationInputReferencePropertiesOutput() IdNamespaceAssociationInputReferencePropertiesOutput { + return o +} + +func (o IdNamespaceAssociationInputReferencePropertiesOutput) ToIdNamespaceAssociationInputReferencePropertiesOutputWithContext(ctx context.Context) IdNamespaceAssociationInputReferencePropertiesOutput { + return o +} + +// Defines how ID mapping workflows are supported for this ID namespace association. +func (o IdNamespaceAssociationInputReferencePropertiesOutput) IdMappingWorkflowsSupported() IdNamespaceAssociationDocumentArrayOutput { + return o.ApplyT(func(v IdNamespaceAssociationInputReferenceProperties) []IdNamespaceAssociationDocument { + return v.IdMappingWorkflowsSupported + }).(IdNamespaceAssociationDocumentArrayOutput) +} + +// The ID namespace type for this ID namespace association. +func (o IdNamespaceAssociationInputReferencePropertiesOutput) IdNamespaceType() IdNamespaceAssociationInputReferencePropertiesIdNamespaceTypePtrOutput { + return o.ApplyT(func(v IdNamespaceAssociationInputReferenceProperties) *IdNamespaceAssociationInputReferencePropertiesIdNamespaceType { + return v.IdNamespaceType + }).(IdNamespaceAssociationInputReferencePropertiesIdNamespaceTypePtrOutput) +} + +type IdNamespaceAssociationInputReferencePropertiesPtrOutput struct{ *pulumi.OutputState } + +func (IdNamespaceAssociationInputReferencePropertiesPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**IdNamespaceAssociationInputReferenceProperties)(nil)).Elem() +} + +func (o IdNamespaceAssociationInputReferencePropertiesPtrOutput) ToIdNamespaceAssociationInputReferencePropertiesPtrOutput() IdNamespaceAssociationInputReferencePropertiesPtrOutput { + return o +} + +func (o IdNamespaceAssociationInputReferencePropertiesPtrOutput) ToIdNamespaceAssociationInputReferencePropertiesPtrOutputWithContext(ctx context.Context) IdNamespaceAssociationInputReferencePropertiesPtrOutput { + return o +} + +func (o IdNamespaceAssociationInputReferencePropertiesPtrOutput) Elem() IdNamespaceAssociationInputReferencePropertiesOutput { + return o.ApplyT(func(v *IdNamespaceAssociationInputReferenceProperties) IdNamespaceAssociationInputReferenceProperties { + if v != nil { + return *v + } + var ret IdNamespaceAssociationInputReferenceProperties + return ret + }).(IdNamespaceAssociationInputReferencePropertiesOutput) +} + +// Defines how ID mapping workflows are supported for this ID namespace association. +func (o IdNamespaceAssociationInputReferencePropertiesPtrOutput) IdMappingWorkflowsSupported() IdNamespaceAssociationDocumentArrayOutput { + return o.ApplyT(func(v *IdNamespaceAssociationInputReferenceProperties) []IdNamespaceAssociationDocument { + if v == nil { + return nil + } + return v.IdMappingWorkflowsSupported + }).(IdNamespaceAssociationDocumentArrayOutput) +} + +// The ID namespace type for this ID namespace association. +func (o IdNamespaceAssociationInputReferencePropertiesPtrOutput) IdNamespaceType() IdNamespaceAssociationInputReferencePropertiesIdNamespaceTypePtrOutput { + return o.ApplyT(func(v *IdNamespaceAssociationInputReferenceProperties) *IdNamespaceAssociationInputReferencePropertiesIdNamespaceType { + if v == nil { + return nil + } + return v.IdNamespaceType + }).(IdNamespaceAssociationInputReferencePropertiesIdNamespaceTypePtrOutput) +} + +type IdNamespaceAssociationTag struct { + // The key of the tag. + Key string `pulumi:"key"` + // The value of the tag. + Value string `pulumi:"value"` +} + type MembershipPaymentConfiguration struct { // The payment responsibilities accepted by the collaboration member for query compute costs. QueryCompute MembershipQueryComputePaymentConfig `pulumi:"queryCompute"` @@ -3416,6 +3936,10 @@ func init() { pulumi.RegisterInputType(reflect.TypeOf((*ConfiguredTableDifferentialPrivacyColumnArrayInput)(nil)).Elem(), ConfiguredTableDifferentialPrivacyColumnArray{}) pulumi.RegisterInputType(reflect.TypeOf((*ConfiguredTableGlueTableReferenceInput)(nil)).Elem(), ConfiguredTableGlueTableReferenceArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*ConfiguredTableTableReferenceInput)(nil)).Elem(), ConfiguredTableTableReferenceArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*IdMappingTableInputReferenceConfigInput)(nil)).Elem(), IdMappingTableInputReferenceConfigArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*IdNamespaceAssociationIdMappingConfigInput)(nil)).Elem(), IdNamespaceAssociationIdMappingConfigArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*IdNamespaceAssociationIdMappingConfigPtrInput)(nil)).Elem(), IdNamespaceAssociationIdMappingConfigArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*IdNamespaceAssociationInputReferenceConfigInput)(nil)).Elem(), IdNamespaceAssociationInputReferenceConfigArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*MembershipPaymentConfigurationInput)(nil)).Elem(), MembershipPaymentConfigurationArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*MembershipPaymentConfigurationPtrInput)(nil)).Elem(), MembershipPaymentConfigurationArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*MembershipProtectedQueryOutputConfigurationInput)(nil)).Elem(), MembershipProtectedQueryOutputConfigurationArgs{}) @@ -3468,6 +3992,18 @@ func init() { pulumi.RegisterOutputType(ConfiguredTableDifferentialPrivacyColumnArrayOutput{}) pulumi.RegisterOutputType(ConfiguredTableGlueTableReferenceOutput{}) pulumi.RegisterOutputType(ConfiguredTableTableReferenceOutput{}) + pulumi.RegisterOutputType(IdMappingTableInputReferenceConfigOutput{}) + pulumi.RegisterOutputType(IdMappingTableInputReferencePropertiesOutput{}) + pulumi.RegisterOutputType(IdMappingTableInputReferencePropertiesPtrOutput{}) + pulumi.RegisterOutputType(IdMappingTableInputSourceOutput{}) + pulumi.RegisterOutputType(IdMappingTableInputSourceArrayOutput{}) + pulumi.RegisterOutputType(IdNamespaceAssociationDocumentOutput{}) + pulumi.RegisterOutputType(IdNamespaceAssociationDocumentArrayOutput{}) + pulumi.RegisterOutputType(IdNamespaceAssociationIdMappingConfigOutput{}) + pulumi.RegisterOutputType(IdNamespaceAssociationIdMappingConfigPtrOutput{}) + pulumi.RegisterOutputType(IdNamespaceAssociationInputReferenceConfigOutput{}) + pulumi.RegisterOutputType(IdNamespaceAssociationInputReferencePropertiesOutput{}) + pulumi.RegisterOutputType(IdNamespaceAssociationInputReferencePropertiesPtrOutput{}) pulumi.RegisterOutputType(MembershipPaymentConfigurationOutput{}) pulumi.RegisterOutputType(MembershipPaymentConfigurationPtrOutput{}) pulumi.RegisterOutputType(MembershipProtectedQueryOutputConfigurationOutput{}) diff --git a/sdk/go/aws/ec2/getSubnet.go b/sdk/go/aws/ec2/getSubnet.go index 988a506090..622bd11a2f 100644 --- a/sdk/go/aws/ec2/getSubnet.go +++ b/sdk/go/aws/ec2/getSubnet.go @@ -35,7 +35,8 @@ type LookupSubnetResult struct { // Indicates whether a network interface created in this subnet receives an IPv6 address. The default value is ``false``. // If you specify ``AssignIpv6AddressOnCreation``, you must also specify an IPv6 CIDR block. AssignIpv6AddressOnCreation *bool `pulumi:"assignIpv6AddressOnCreation"` - // Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. For more information, see [DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-nat64-dns64) in the *User Guide*. + // Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. + // You must first configure a NAT gateway in a public subnet (separate from the subnet containing the IPv6-only workloads). For example, the subnet containing the NAT gateway should have a ``0.0.0.0/0`` route pointing to the internet gateway. For more information, see [Configure DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/nat-gateway-nat64-dns64.html#nat-gateway-nat64-dns64-walkthrough) in the *User Guide*. EnableDns64 *bool `pulumi:"enableDns64"` // The IPv6 CIDR block. // If you specify ``AssignIpv6AddressOnCreation``, you must also specify an IPv6 CIDR block. @@ -102,7 +103,9 @@ func (o LookupSubnetResultOutput) AssignIpv6AddressOnCreation() pulumi.BoolPtrOu return o.ApplyT(func(v LookupSubnetResult) *bool { return v.AssignIpv6AddressOnCreation }).(pulumi.BoolPtrOutput) } -// Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. For more information, see [DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-nat64-dns64) in the *User Guide*. +// Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. +// +// You must first configure a NAT gateway in a public subnet (separate from the subnet containing the IPv6-only workloads). For example, the subnet containing the NAT gateway should have a ``0.0.0.0/0`` route pointing to the internet gateway. For more information, see [Configure DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/nat-gateway-nat64-dns64.html#nat-gateway-nat64-dns64-walkthrough) in the *User Guide*. func (o LookupSubnetResultOutput) EnableDns64() pulumi.BoolPtrOutput { return o.ApplyT(func(v LookupSubnetResult) *bool { return v.EnableDns64 }).(pulumi.BoolPtrOutput) } diff --git a/sdk/go/aws/ec2/subnet.go b/sdk/go/aws/ec2/subnet.go index f1d6e7d925..1183642097 100644 --- a/sdk/go/aws/ec2/subnet.go +++ b/sdk/go/aws/ec2/subnet.go @@ -31,7 +31,8 @@ type Subnet struct { // The IPv4 CIDR block assigned to the subnet. // If you update this property, we create a new subnet, and then delete the existing one. CidrBlock pulumi.StringPtrOutput `pulumi:"cidrBlock"` - // Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. For more information, see [DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-nat64-dns64) in the *User Guide*. + // Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. + // You must first configure a NAT gateway in a public subnet (separate from the subnet containing the IPv6-only workloads). For example, the subnet containing the NAT gateway should have a ``0.0.0.0/0`` route pointing to the internet gateway. For more information, see [Configure DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/nat-gateway-nat64-dns64.html#nat-gateway-nat64-dns64-walkthrough) in the *User Guide*. EnableDns64 pulumi.BoolPtrOutput `pulumi:"enableDns64"` // Indicates the device position for local network interfaces in this subnet. For example, ``1`` indicates local network interfaces in this subnet are the secondary network interface (eth1). EnableLniAtDeviceIndex pulumi.IntPtrOutput `pulumi:"enableLniAtDeviceIndex"` @@ -139,7 +140,8 @@ type subnetArgs struct { // The IPv4 CIDR block assigned to the subnet. // If you update this property, we create a new subnet, and then delete the existing one. CidrBlock *string `pulumi:"cidrBlock"` - // Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. For more information, see [DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-nat64-dns64) in the *User Guide*. + // Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. + // You must first configure a NAT gateway in a public subnet (separate from the subnet containing the IPv6-only workloads). For example, the subnet containing the NAT gateway should have a ``0.0.0.0/0`` route pointing to the internet gateway. For more information, see [Configure DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/nat-gateway-nat64-dns64.html#nat-gateway-nat64-dns64-walkthrough) in the *User Guide*. EnableDns64 *bool `pulumi:"enableDns64"` // Indicates the device position for local network interfaces in this subnet. For example, ``1`` indicates local network interfaces in this subnet are the secondary network interface (eth1). EnableLniAtDeviceIndex *int `pulumi:"enableLniAtDeviceIndex"` @@ -189,7 +191,8 @@ type SubnetArgs struct { // The IPv4 CIDR block assigned to the subnet. // If you update this property, we create a new subnet, and then delete the existing one. CidrBlock pulumi.StringPtrInput - // Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. For more information, see [DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-nat64-dns64) in the *User Guide*. + // Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. + // You must first configure a NAT gateway in a public subnet (separate from the subnet containing the IPv6-only workloads). For example, the subnet containing the NAT gateway should have a ``0.0.0.0/0`` route pointing to the internet gateway. For more information, see [Configure DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/nat-gateway-nat64-dns64.html#nat-gateway-nat64-dns64-walkthrough) in the *User Guide*. EnableDns64 pulumi.BoolPtrInput // Indicates the device position for local network interfaces in this subnet. For example, ``1`` indicates local network interfaces in this subnet are the secondary network interface (eth1). EnableLniAtDeviceIndex pulumi.IntPtrInput @@ -289,7 +292,9 @@ func (o SubnetOutput) CidrBlock() pulumi.StringPtrOutput { return o.ApplyT(func(v *Subnet) pulumi.StringPtrOutput { return v.CidrBlock }).(pulumi.StringPtrOutput) } -// Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. For more information, see [DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-nat64-dns64) in the *User Guide*. +// Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. +// +// You must first configure a NAT gateway in a public subnet (separate from the subnet containing the IPv6-only workloads). For example, the subnet containing the NAT gateway should have a ``0.0.0.0/0`` route pointing to the internet gateway. For more information, see [Configure DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/nat-gateway-nat64-dns64.html#nat-gateway-nat64-dns64-walkthrough) in the *User Guide*. func (o SubnetOutput) EnableDns64() pulumi.BoolPtrOutput { return o.ApplyT(func(v *Subnet) pulumi.BoolPtrOutput { return v.EnableDns64 }).(pulumi.BoolPtrOutput) } diff --git a/sdk/go/aws/redshift/pulumiTypes.go b/sdk/go/aws/redshift/pulumiTypes.go index dee384e26e..9f0681b402 100644 --- a/sdk/go/aws/redshift/pulumiTypes.go +++ b/sdk/go/aws/redshift/pulumiTypes.go @@ -176,7 +176,9 @@ type ClusterLoggingProperties struct { // // - Must be in the same region as the cluster // - The cluster must have read bucket and put object permissions - BucketName *string `pulumi:"bucketName"` + BucketName *string `pulumi:"bucketName"` + LogDestinationType *string `pulumi:"logDestinationType"` + LogExports []string `pulumi:"logExports"` // The prefix applied to the log file names. // // Constraints: @@ -210,7 +212,9 @@ type ClusterLoggingPropertiesArgs struct { // // - Must be in the same region as the cluster // - The cluster must have read bucket and put object permissions - BucketName pulumi.StringPtrInput `pulumi:"bucketName"` + BucketName pulumi.StringPtrInput `pulumi:"bucketName"` + LogDestinationType pulumi.StringPtrInput `pulumi:"logDestinationType"` + LogExports pulumi.StringArrayInput `pulumi:"logExports"` // The prefix applied to the log file names. // // Constraints: @@ -313,6 +317,14 @@ func (o ClusterLoggingPropertiesOutput) BucketName() pulumi.StringPtrOutput { return o.ApplyT(func(v ClusterLoggingProperties) *string { return v.BucketName }).(pulumi.StringPtrOutput) } +func (o ClusterLoggingPropertiesOutput) LogDestinationType() pulumi.StringPtrOutput { + return o.ApplyT(func(v ClusterLoggingProperties) *string { return v.LogDestinationType }).(pulumi.StringPtrOutput) +} + +func (o ClusterLoggingPropertiesOutput) LogExports() pulumi.StringArrayOutput { + return o.ApplyT(func(v ClusterLoggingProperties) []string { return v.LogExports }).(pulumi.StringArrayOutput) +} + // The prefix applied to the log file names. // // Constraints: @@ -368,6 +380,24 @@ func (o ClusterLoggingPropertiesPtrOutput) BucketName() pulumi.StringPtrOutput { }).(pulumi.StringPtrOutput) } +func (o ClusterLoggingPropertiesPtrOutput) LogDestinationType() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ClusterLoggingProperties) *string { + if v == nil { + return nil + } + return v.LogDestinationType + }).(pulumi.StringPtrOutput) +} + +func (o ClusterLoggingPropertiesPtrOutput) LogExports() pulumi.StringArrayOutput { + return o.ApplyT(func(v *ClusterLoggingProperties) []string { + if v == nil { + return nil + } + return v.LogExports + }).(pulumi.StringArrayOutput) +} + // The prefix applied to the log file names. // // Constraints: diff --git a/sdk/go/aws/route53resolver/getResolverRule.go b/sdk/go/aws/route53resolver/getResolverRule.go index ff9e5a0e8c..11f57ce175 100644 --- a/sdk/go/aws/route53resolver/getResolverRule.go +++ b/sdk/go/aws/route53resolver/getResolverRule.go @@ -31,6 +31,8 @@ type LookupResolverRuleArgs struct { type LookupResolverRuleResult struct { // The Amazon Resource Name (ARN) of the resolver rule. Arn *string `pulumi:"arn"` + // The name server domain for queries to be delegated to if a query matches the delegation record. + DelegationRecord *string `pulumi:"delegationRecord"` // DNS queries for this domain name are forwarded to the IP addresses that are specified in TargetIps DomainName *string `pulumi:"domainName"` // The name for the Resolver rule @@ -86,6 +88,11 @@ func (o LookupResolverRuleResultOutput) Arn() pulumi.StringPtrOutput { return o.ApplyT(func(v LookupResolverRuleResult) *string { return v.Arn }).(pulumi.StringPtrOutput) } +// The name server domain for queries to be delegated to if a query matches the delegation record. +func (o LookupResolverRuleResultOutput) DelegationRecord() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupResolverRuleResult) *string { return v.DelegationRecord }).(pulumi.StringPtrOutput) +} + // DNS queries for this domain name are forwarded to the IP addresses that are specified in TargetIps func (o LookupResolverRuleResultOutput) DomainName() pulumi.StringPtrOutput { return o.ApplyT(func(v LookupResolverRuleResult) *string { return v.DomainName }).(pulumi.StringPtrOutput) diff --git a/sdk/go/aws/route53resolver/pulumiEnums.go b/sdk/go/aws/route53resolver/pulumiEnums.go index 88c8170d5c..f2925cbbb7 100644 --- a/sdk/go/aws/route53resolver/pulumiEnums.go +++ b/sdk/go/aws/route53resolver/pulumiEnums.go @@ -2040,6 +2040,7 @@ const ( ResolverRuleRuleTypeForward = ResolverRuleRuleType("FORWARD") ResolverRuleRuleTypeSystem = ResolverRuleRuleType("SYSTEM") ResolverRuleRuleTypeRecursive = ResolverRuleRuleType("RECURSIVE") + ResolverRuleRuleTypeDelegate = ResolverRuleRuleType("DELEGATE") ) func (ResolverRuleRuleType) ElementType() reflect.Type { @@ -2167,6 +2168,7 @@ func (o ResolverRuleRuleTypePtrOutput) ToStringPtrOutputWithContext(ctx context. // ResolverRuleRuleTypeForward // ResolverRuleRuleTypeSystem // ResolverRuleRuleTypeRecursive +// ResolverRuleRuleTypeDelegate type ResolverRuleRuleTypeInput interface { pulumi.Input diff --git a/sdk/go/aws/route53resolver/resolverRule.go b/sdk/go/aws/route53resolver/resolverRule.go index 899f456c27..8520c14cdc 100644 --- a/sdk/go/aws/route53resolver/resolverRule.go +++ b/sdk/go/aws/route53resolver/resolverRule.go @@ -19,8 +19,10 @@ type ResolverRule struct { // The Amazon Resource Name (ARN) of the resolver rule. Arn pulumi.StringOutput `pulumi:"arn"` + // The name server domain for queries to be delegated to if a query matches the delegation record. + DelegationRecord pulumi.StringPtrOutput `pulumi:"delegationRecord"` // DNS queries for this domain name are forwarded to the IP addresses that are specified in TargetIps - DomainName pulumi.StringOutput `pulumi:"domainName"` + DomainName pulumi.StringPtrOutput `pulumi:"domainName"` // The name for the Resolver rule Name pulumi.StringPtrOutput `pulumi:"name"` // The ID of the endpoint that the rule is associated with. @@ -42,9 +44,6 @@ func NewResolverRule(ctx *pulumi.Context, return nil, errors.New("missing one or more required arguments") } - if args.DomainName == nil { - return nil, errors.New("invalid value for required argument 'DomainName'") - } if args.RuleType == nil { return nil, errors.New("invalid value for required argument 'RuleType'") } @@ -85,8 +84,10 @@ func (ResolverRuleState) ElementType() reflect.Type { } type resolverRuleArgs struct { + // The name server domain for queries to be delegated to if a query matches the delegation record. + DelegationRecord *string `pulumi:"delegationRecord"` // DNS queries for this domain name are forwarded to the IP addresses that are specified in TargetIps - DomainName string `pulumi:"domainName"` + DomainName *string `pulumi:"domainName"` // The name for the Resolver rule Name *string `pulumi:"name"` // The ID of the endpoint that the rule is associated with. @@ -101,8 +102,10 @@ type resolverRuleArgs struct { // The set of arguments for constructing a ResolverRule resource. type ResolverRuleArgs struct { + // The name server domain for queries to be delegated to if a query matches the delegation record. + DelegationRecord pulumi.StringPtrInput // DNS queries for this domain name are forwarded to the IP addresses that are specified in TargetIps - DomainName pulumi.StringInput + DomainName pulumi.StringPtrInput // The name for the Resolver rule Name pulumi.StringPtrInput // The ID of the endpoint that the rule is associated with. @@ -157,9 +160,14 @@ func (o ResolverRuleOutput) Arn() pulumi.StringOutput { return o.ApplyT(func(v *ResolverRule) pulumi.StringOutput { return v.Arn }).(pulumi.StringOutput) } +// The name server domain for queries to be delegated to if a query matches the delegation record. +func (o ResolverRuleOutput) DelegationRecord() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ResolverRule) pulumi.StringPtrOutput { return v.DelegationRecord }).(pulumi.StringPtrOutput) +} + // DNS queries for this domain name are forwarded to the IP addresses that are specified in TargetIps -func (o ResolverRuleOutput) DomainName() pulumi.StringOutput { - return o.ApplyT(func(v *ResolverRule) pulumi.StringOutput { return v.DomainName }).(pulumi.StringOutput) +func (o ResolverRuleOutput) DomainName() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ResolverRule) pulumi.StringPtrOutput { return v.DomainName }).(pulumi.StringPtrOutput) } // The name for the Resolver rule diff --git a/sdk/nodejs/cleanrooms/getIdMappingTable.ts b/sdk/nodejs/cleanrooms/getIdMappingTable.ts new file mode 100644 index 0000000000..7edc5e2b3b --- /dev/null +++ b/sdk/nodejs/cleanrooms/getIdMappingTable.ts @@ -0,0 +1,72 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +import * as pulumi from "@pulumi/pulumi"; +import * as inputs from "../types/input"; +import * as outputs from "../types/output"; +import * as enums from "../types/enums"; +import * as utilities from "../utilities"; + +/** + * Represents an association between an ID mapping workflow and a collaboration + */ +export function getIdMappingTable(args: GetIdMappingTableArgs, opts?: pulumi.InvokeOptions): Promise { + + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("aws-native:cleanrooms:getIdMappingTable", { + "idMappingTableIdentifier": args.idMappingTableIdentifier, + "membershipIdentifier": args.membershipIdentifier, + }, opts); +} + +export interface GetIdMappingTableArgs { + idMappingTableIdentifier: string; + /** + * The unique identifier of the membership resource for the ID mapping table. + */ + membershipIdentifier: string; +} + +export interface GetIdMappingTableResult { + /** + * The Amazon Resource Name (ARN) of the ID mapping table. + */ + readonly arn?: string; + /** + * The Amazon Resource Name (ARN) of the collaboration that contains this ID mapping table. + */ + readonly collaborationArn?: string; + readonly collaborationIdentifier?: string; + /** + * The description of the ID mapping table. + */ + readonly description?: string; + readonly idMappingTableIdentifier?: string; + readonly inputReferenceProperties?: outputs.cleanrooms.IdMappingTableInputReferenceProperties; + /** + * The Amazon Resource Name (ARN) of the AWS KMS key. + */ + readonly kmsKeyArn?: string; + /** + * The Amazon Resource Name (ARN) of the membership resource for the ID mapping table. + */ + readonly membershipArn?: string; + /** + * An optional label that you can assign to a resource when you create it. Each tag consists of a key and an optional value, both of which you define. When you use tagging, you can also use tag-based access control in IAM policies to control access to this resource. + */ + readonly tags?: outputs.Tag[]; +} +/** + * Represents an association between an ID mapping workflow and a collaboration + */ +export function getIdMappingTableOutput(args: GetIdMappingTableOutputArgs, opts?: pulumi.InvokeOptions): pulumi.Output { + return pulumi.output(args).apply((a: any) => getIdMappingTable(a, opts)) +} + +export interface GetIdMappingTableOutputArgs { + idMappingTableIdentifier: pulumi.Input; + /** + * The unique identifier of the membership resource for the ID mapping table. + */ + membershipIdentifier: pulumi.Input; +} diff --git a/sdk/nodejs/cleanrooms/getIdNamespaceAssociation.ts b/sdk/nodejs/cleanrooms/getIdNamespaceAssociation.ts new file mode 100644 index 0000000000..8a76c21d2a --- /dev/null +++ b/sdk/nodejs/cleanrooms/getIdNamespaceAssociation.ts @@ -0,0 +1,73 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +import * as pulumi from "@pulumi/pulumi"; +import * as inputs from "../types/input"; +import * as outputs from "../types/output"; +import * as enums from "../types/enums"; +import * as utilities from "../utilities"; + +/** + * Represents an association between an ID namespace and a collaboration + */ +export function getIdNamespaceAssociation(args: GetIdNamespaceAssociationArgs, opts?: pulumi.InvokeOptions): Promise { + + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("aws-native:cleanrooms:getIdNamespaceAssociation", { + "idNamespaceAssociationIdentifier": args.idNamespaceAssociationIdentifier, + "membershipIdentifier": args.membershipIdentifier, + }, opts); +} + +export interface GetIdNamespaceAssociationArgs { + idNamespaceAssociationIdentifier: string; + /** + * The unique identifier of the membership that contains the ID namespace association. + */ + membershipIdentifier: string; +} + +export interface GetIdNamespaceAssociationResult { + /** + * The Amazon Resource Name (ARN) of the ID namespace association. + */ + readonly arn?: string; + /** + * The Amazon Resource Name (ARN) of the collaboration that contains this ID namespace association. + */ + readonly collaborationArn?: string; + readonly collaborationIdentifier?: string; + /** + * The description of the ID namespace association. + */ + readonly description?: string; + /** + * The configuration settings for the ID mapping table. + */ + readonly idMappingConfig?: outputs.cleanrooms.IdNamespaceAssociationIdMappingConfig; + readonly idNamespaceAssociationIdentifier?: string; + readonly inputReferenceProperties?: outputs.cleanrooms.IdNamespaceAssociationInputReferenceProperties; + /** + * The Amazon Resource Name (ARN) of the membership resource for this ID namespace association. + */ + readonly membershipArn?: string; + /** + * The name of this ID namespace association. + */ + readonly name?: string; + readonly tags?: outputs.Tag[]; +} +/** + * Represents an association between an ID namespace and a collaboration + */ +export function getIdNamespaceAssociationOutput(args: GetIdNamespaceAssociationOutputArgs, opts?: pulumi.InvokeOptions): pulumi.Output { + return pulumi.output(args).apply((a: any) => getIdNamespaceAssociation(a, opts)) +} + +export interface GetIdNamespaceAssociationOutputArgs { + idNamespaceAssociationIdentifier: pulumi.Input; + /** + * The unique identifier of the membership that contains the ID namespace association. + */ + membershipIdentifier: pulumi.Input; +} diff --git a/sdk/nodejs/cleanrooms/idMappingTable.ts b/sdk/nodejs/cleanrooms/idMappingTable.ts new file mode 100644 index 0000000000..fe18777031 --- /dev/null +++ b/sdk/nodejs/cleanrooms/idMappingTable.ts @@ -0,0 +1,158 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +import * as pulumi from "@pulumi/pulumi"; +import * as inputs from "../types/input"; +import * as outputs from "../types/output"; +import * as enums from "../types/enums"; +import * as utilities from "../utilities"; + +/** + * Represents an association between an ID mapping workflow and a collaboration + */ +export class IdMappingTable extends pulumi.CustomResource { + /** + * Get an existing IdMappingTable resource's state with the given name, ID, and optional extra + * properties used to qualify the lookup. + * + * @param name The _unique_ name of the resulting resource. + * @param id The _unique_ provider ID of the resource to lookup. + * @param opts Optional settings to control the behavior of the CustomResource. + */ + public static get(name: string, id: pulumi.Input, opts?: pulumi.CustomResourceOptions): IdMappingTable { + return new IdMappingTable(name, undefined as any, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'aws-native:cleanrooms:IdMappingTable'; + + /** + * Returns true if the given object is an instance of IdMappingTable. This is designed to work even + * when multiple copies of the Pulumi SDK have been loaded into the same process. + */ + public static isInstance(obj: any): obj is IdMappingTable { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === IdMappingTable.__pulumiType; + } + + /** + * The Amazon Resource Name (ARN) of the ID mapping table. + */ + public /*out*/ readonly arn!: pulumi.Output; + /** + * The Amazon Resource Name (ARN) of the collaboration that contains this ID mapping table. + */ + public /*out*/ readonly collaborationArn!: pulumi.Output; + public /*out*/ readonly collaborationIdentifier!: pulumi.Output; + /** + * The description of the ID mapping table. + */ + public readonly description!: pulumi.Output; + public /*out*/ readonly idMappingTableIdentifier!: pulumi.Output; + /** + * The input reference configuration for the ID mapping table. + */ + public readonly inputReferenceConfig!: pulumi.Output; + public /*out*/ readonly inputReferenceProperties!: pulumi.Output; + /** + * The Amazon Resource Name (ARN) of the AWS KMS key. + */ + public readonly kmsKeyArn!: pulumi.Output; + /** + * The Amazon Resource Name (ARN) of the membership resource for the ID mapping table. + */ + public /*out*/ readonly membershipArn!: pulumi.Output; + /** + * The unique identifier of the membership resource for the ID mapping table. + */ + public readonly membershipIdentifier!: pulumi.Output; + /** + * The name of the ID mapping table. + */ + public readonly name!: pulumi.Output; + /** + * An optional label that you can assign to a resource when you create it. Each tag consists of a key and an optional value, both of which you define. When you use tagging, you can also use tag-based access control in IAM policies to control access to this resource. + */ + public readonly tags!: pulumi.Output; + + /** + * Create a IdMappingTable resource with the given unique name, arguments, and options. + * + * @param name The _unique_ name of the resource. + * @param args The arguments to use to populate this resource's properties. + * @param opts A bag of options that control this resource's behavior. + */ + constructor(name: string, args: IdMappingTableArgs, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (!opts.id) { + if ((!args || args.inputReferenceConfig === undefined) && !opts.urn) { + throw new Error("Missing required property 'inputReferenceConfig'"); + } + if ((!args || args.membershipIdentifier === undefined) && !opts.urn) { + throw new Error("Missing required property 'membershipIdentifier'"); + } + resourceInputs["description"] = args ? args.description : undefined; + resourceInputs["inputReferenceConfig"] = args ? args.inputReferenceConfig : undefined; + resourceInputs["kmsKeyArn"] = args ? args.kmsKeyArn : undefined; + resourceInputs["membershipIdentifier"] = args ? args.membershipIdentifier : undefined; + resourceInputs["name"] = args ? args.name : undefined; + resourceInputs["tags"] = args ? args.tags : undefined; + resourceInputs["arn"] = undefined /*out*/; + resourceInputs["collaborationArn"] = undefined /*out*/; + resourceInputs["collaborationIdentifier"] = undefined /*out*/; + resourceInputs["idMappingTableIdentifier"] = undefined /*out*/; + resourceInputs["inputReferenceProperties"] = undefined /*out*/; + resourceInputs["membershipArn"] = undefined /*out*/; + } else { + resourceInputs["arn"] = undefined /*out*/; + resourceInputs["collaborationArn"] = undefined /*out*/; + resourceInputs["collaborationIdentifier"] = undefined /*out*/; + resourceInputs["description"] = undefined /*out*/; + resourceInputs["idMappingTableIdentifier"] = undefined /*out*/; + resourceInputs["inputReferenceConfig"] = undefined /*out*/; + resourceInputs["inputReferenceProperties"] = undefined /*out*/; + resourceInputs["kmsKeyArn"] = undefined /*out*/; + resourceInputs["membershipArn"] = undefined /*out*/; + resourceInputs["membershipIdentifier"] = undefined /*out*/; + resourceInputs["name"] = undefined /*out*/; + resourceInputs["tags"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + const replaceOnChanges = { replaceOnChanges: ["inputReferenceConfig", "membershipIdentifier", "name"] }; + opts = pulumi.mergeOptions(opts, replaceOnChanges); + super(IdMappingTable.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * The set of arguments for constructing a IdMappingTable resource. + */ +export interface IdMappingTableArgs { + /** + * The description of the ID mapping table. + */ + description?: pulumi.Input; + /** + * The input reference configuration for the ID mapping table. + */ + inputReferenceConfig: pulumi.Input; + /** + * The Amazon Resource Name (ARN) of the AWS KMS key. + */ + kmsKeyArn?: pulumi.Input; + /** + * The unique identifier of the membership resource for the ID mapping table. + */ + membershipIdentifier: pulumi.Input; + /** + * The name of the ID mapping table. + */ + name?: pulumi.Input; + /** + * An optional label that you can assign to a resource when you create it. Each tag consists of a key and an optional value, both of which you define. When you use tagging, you can also use tag-based access control in IAM policies to control access to this resource. + */ + tags?: pulumi.Input[]>; +} diff --git a/sdk/nodejs/cleanrooms/idNamespaceAssociation.ts b/sdk/nodejs/cleanrooms/idNamespaceAssociation.ts new file mode 100644 index 0000000000..85fe028829 --- /dev/null +++ b/sdk/nodejs/cleanrooms/idNamespaceAssociation.ts @@ -0,0 +1,152 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +import * as pulumi from "@pulumi/pulumi"; +import * as inputs from "../types/input"; +import * as outputs from "../types/output"; +import * as enums from "../types/enums"; +import * as utilities from "../utilities"; + +/** + * Represents an association between an ID namespace and a collaboration + */ +export class IdNamespaceAssociation extends pulumi.CustomResource { + /** + * Get an existing IdNamespaceAssociation resource's state with the given name, ID, and optional extra + * properties used to qualify the lookup. + * + * @param name The _unique_ name of the resulting resource. + * @param id The _unique_ provider ID of the resource to lookup. + * @param opts Optional settings to control the behavior of the CustomResource. + */ + public static get(name: string, id: pulumi.Input, opts?: pulumi.CustomResourceOptions): IdNamespaceAssociation { + return new IdNamespaceAssociation(name, undefined as any, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'aws-native:cleanrooms:IdNamespaceAssociation'; + + /** + * Returns true if the given object is an instance of IdNamespaceAssociation. This is designed to work even + * when multiple copies of the Pulumi SDK have been loaded into the same process. + */ + public static isInstance(obj: any): obj is IdNamespaceAssociation { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === IdNamespaceAssociation.__pulumiType; + } + + /** + * The Amazon Resource Name (ARN) of the ID namespace association. + */ + public /*out*/ readonly arn!: pulumi.Output; + /** + * The Amazon Resource Name (ARN) of the collaboration that contains this ID namespace association. + */ + public /*out*/ readonly collaborationArn!: pulumi.Output; + public /*out*/ readonly collaborationIdentifier!: pulumi.Output; + /** + * The description of the ID namespace association. + */ + public readonly description!: pulumi.Output; + /** + * The configuration settings for the ID mapping table. + */ + public readonly idMappingConfig!: pulumi.Output; + public /*out*/ readonly idNamespaceAssociationIdentifier!: pulumi.Output; + /** + * The input reference configuration for the ID namespace association. + */ + public readonly inputReferenceConfig!: pulumi.Output; + public /*out*/ readonly inputReferenceProperties!: pulumi.Output; + /** + * The Amazon Resource Name (ARN) of the membership resource for this ID namespace association. + */ + public /*out*/ readonly membershipArn!: pulumi.Output; + /** + * The unique identifier of the membership that contains the ID namespace association. + */ + public readonly membershipIdentifier!: pulumi.Output; + /** + * The name of this ID namespace association. + */ + public readonly name!: pulumi.Output; + public readonly tags!: pulumi.Output; + + /** + * Create a IdNamespaceAssociation resource with the given unique name, arguments, and options. + * + * @param name The _unique_ name of the resource. + * @param args The arguments to use to populate this resource's properties. + * @param opts A bag of options that control this resource's behavior. + */ + constructor(name: string, args: IdNamespaceAssociationArgs, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (!opts.id) { + if ((!args || args.inputReferenceConfig === undefined) && !opts.urn) { + throw new Error("Missing required property 'inputReferenceConfig'"); + } + if ((!args || args.membershipIdentifier === undefined) && !opts.urn) { + throw new Error("Missing required property 'membershipIdentifier'"); + } + resourceInputs["description"] = args ? args.description : undefined; + resourceInputs["idMappingConfig"] = args ? args.idMappingConfig : undefined; + resourceInputs["inputReferenceConfig"] = args ? args.inputReferenceConfig : undefined; + resourceInputs["membershipIdentifier"] = args ? args.membershipIdentifier : undefined; + resourceInputs["name"] = args ? args.name : undefined; + resourceInputs["tags"] = args ? args.tags : undefined; + resourceInputs["arn"] = undefined /*out*/; + resourceInputs["collaborationArn"] = undefined /*out*/; + resourceInputs["collaborationIdentifier"] = undefined /*out*/; + resourceInputs["idNamespaceAssociationIdentifier"] = undefined /*out*/; + resourceInputs["inputReferenceProperties"] = undefined /*out*/; + resourceInputs["membershipArn"] = undefined /*out*/; + } else { + resourceInputs["arn"] = undefined /*out*/; + resourceInputs["collaborationArn"] = undefined /*out*/; + resourceInputs["collaborationIdentifier"] = undefined /*out*/; + resourceInputs["description"] = undefined /*out*/; + resourceInputs["idMappingConfig"] = undefined /*out*/; + resourceInputs["idNamespaceAssociationIdentifier"] = undefined /*out*/; + resourceInputs["inputReferenceConfig"] = undefined /*out*/; + resourceInputs["inputReferenceProperties"] = undefined /*out*/; + resourceInputs["membershipArn"] = undefined /*out*/; + resourceInputs["membershipIdentifier"] = undefined /*out*/; + resourceInputs["name"] = undefined /*out*/; + resourceInputs["tags"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + const replaceOnChanges = { replaceOnChanges: ["inputReferenceConfig", "membershipIdentifier"] }; + opts = pulumi.mergeOptions(opts, replaceOnChanges); + super(IdNamespaceAssociation.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * The set of arguments for constructing a IdNamespaceAssociation resource. + */ +export interface IdNamespaceAssociationArgs { + /** + * The description of the ID namespace association. + */ + description?: pulumi.Input; + /** + * The configuration settings for the ID mapping table. + */ + idMappingConfig?: pulumi.Input; + /** + * The input reference configuration for the ID namespace association. + */ + inputReferenceConfig: pulumi.Input; + /** + * The unique identifier of the membership that contains the ID namespace association. + */ + membershipIdentifier: pulumi.Input; + /** + * The name of this ID namespace association. + */ + name?: pulumi.Input; + tags?: pulumi.Input[]>; +} diff --git a/sdk/nodejs/cleanrooms/index.ts b/sdk/nodejs/cleanrooms/index.ts index 28fdcd3755..b641347ab4 100644 --- a/sdk/nodejs/cleanrooms/index.ts +++ b/sdk/nodejs/cleanrooms/index.ts @@ -45,6 +45,16 @@ export const getConfiguredTableAssociation: typeof import("./getConfiguredTableA export const getConfiguredTableAssociationOutput: typeof import("./getConfiguredTableAssociation").getConfiguredTableAssociationOutput = null as any; utilities.lazyLoad(exports, ["getConfiguredTableAssociation","getConfiguredTableAssociationOutput"], () => require("./getConfiguredTableAssociation")); +export { GetIdMappingTableArgs, GetIdMappingTableResult, GetIdMappingTableOutputArgs } from "./getIdMappingTable"; +export const getIdMappingTable: typeof import("./getIdMappingTable").getIdMappingTable = null as any; +export const getIdMappingTableOutput: typeof import("./getIdMappingTable").getIdMappingTableOutput = null as any; +utilities.lazyLoad(exports, ["getIdMappingTable","getIdMappingTableOutput"], () => require("./getIdMappingTable")); + +export { GetIdNamespaceAssociationArgs, GetIdNamespaceAssociationResult, GetIdNamespaceAssociationOutputArgs } from "./getIdNamespaceAssociation"; +export const getIdNamespaceAssociation: typeof import("./getIdNamespaceAssociation").getIdNamespaceAssociation = null as any; +export const getIdNamespaceAssociationOutput: typeof import("./getIdNamespaceAssociation").getIdNamespaceAssociationOutput = null as any; +utilities.lazyLoad(exports, ["getIdNamespaceAssociation","getIdNamespaceAssociationOutput"], () => require("./getIdNamespaceAssociation")); + export { GetMembershipArgs, GetMembershipResult, GetMembershipOutputArgs } from "./getMembership"; export const getMembership: typeof import("./getMembership").getMembership = null as any; export const getMembershipOutput: typeof import("./getMembership").getMembershipOutput = null as any; @@ -55,6 +65,16 @@ export const getPrivacyBudgetTemplate: typeof import("./getPrivacyBudgetTemplate export const getPrivacyBudgetTemplateOutput: typeof import("./getPrivacyBudgetTemplate").getPrivacyBudgetTemplateOutput = null as any; utilities.lazyLoad(exports, ["getPrivacyBudgetTemplate","getPrivacyBudgetTemplateOutput"], () => require("./getPrivacyBudgetTemplate")); +export { IdMappingTableArgs } from "./idMappingTable"; +export type IdMappingTable = import("./idMappingTable").IdMappingTable; +export const IdMappingTable: typeof import("./idMappingTable").IdMappingTable = null as any; +utilities.lazyLoad(exports, ["IdMappingTable"], () => require("./idMappingTable")); + +export { IdNamespaceAssociationArgs } from "./idNamespaceAssociation"; +export type IdNamespaceAssociation = import("./idNamespaceAssociation").IdNamespaceAssociation; +export const IdNamespaceAssociation: typeof import("./idNamespaceAssociation").IdNamespaceAssociation = null as any; +utilities.lazyLoad(exports, ["IdNamespaceAssociation"], () => require("./idNamespaceAssociation")); + export { MembershipArgs } from "./membership"; export type Membership = import("./membership").Membership; export const Membership: typeof import("./membership").Membership = null as any; @@ -81,6 +101,10 @@ const _module = { return new ConfiguredTable(name, undefined, { urn }) case "aws-native:cleanrooms:ConfiguredTableAssociation": return new ConfiguredTableAssociation(name, undefined, { urn }) + case "aws-native:cleanrooms:IdMappingTable": + return new IdMappingTable(name, undefined, { urn }) + case "aws-native:cleanrooms:IdNamespaceAssociation": + return new IdNamespaceAssociation(name, undefined, { urn }) case "aws-native:cleanrooms:Membership": return new Membership(name, undefined, { urn }) case "aws-native:cleanrooms:PrivacyBudgetTemplate": diff --git a/sdk/nodejs/ec2/getSubnet.ts b/sdk/nodejs/ec2/getSubnet.ts index 8f4828dd62..00148295cf 100644 --- a/sdk/nodejs/ec2/getSubnet.ts +++ b/sdk/nodejs/ec2/getSubnet.ts @@ -34,7 +34,8 @@ export interface GetSubnetResult { */ readonly assignIpv6AddressOnCreation?: boolean; /** - * Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. For more information, see [DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-nat64-dns64) in the *User Guide*. + * Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. + * You must first configure a NAT gateway in a public subnet (separate from the subnet containing the IPv6-only workloads). For example, the subnet containing the NAT gateway should have a ``0.0.0.0/0`` route pointing to the internet gateway. For more information, see [Configure DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/nat-gateway-nat64-dns64.html#nat-gateway-nat64-dns64-walkthrough) in the *User Guide*. */ readonly enableDns64?: boolean; /** diff --git a/sdk/nodejs/ec2/subnet.ts b/sdk/nodejs/ec2/subnet.ts index 8c2def8208..c7248ef4ec 100644 --- a/sdk/nodejs/ec2/subnet.ts +++ b/sdk/nodejs/ec2/subnet.ts @@ -59,7 +59,8 @@ export class Subnet extends pulumi.CustomResource { */ public readonly cidrBlock!: pulumi.Output; /** - * Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. For more information, see [DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-nat64-dns64) in the *User Guide*. + * Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. + * You must first configure a NAT gateway in a public subnet (separate from the subnet containing the IPv6-only workloads). For example, the subnet containing the NAT gateway should have a ``0.0.0.0/0`` route pointing to the internet gateway. For more information, see [Configure DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/nat-gateway-nat64-dns64.html#nat-gateway-nat64-dns64-walkthrough) in the *User Guide*. */ public readonly enableDns64!: pulumi.Output; /** @@ -217,7 +218,8 @@ export interface SubnetArgs { */ cidrBlock?: pulumi.Input; /** - * Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. For more information, see [DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-nat64-dns64) in the *User Guide*. + * Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. + * You must first configure a NAT gateway in a public subnet (separate from the subnet containing the IPv6-only workloads). For example, the subnet containing the NAT gateway should have a ``0.0.0.0/0`` route pointing to the internet gateway. For more information, see [Configure DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/nat-gateway-nat64-dns64.html#nat-gateway-nat64-dns64-walkthrough) in the *User Guide*. */ enableDns64?: pulumi.Input; /** diff --git a/sdk/nodejs/route53resolver/getResolverRule.ts b/sdk/nodejs/route53resolver/getResolverRule.ts index ce09ae32d3..a4336c50a3 100644 --- a/sdk/nodejs/route53resolver/getResolverRule.ts +++ b/sdk/nodejs/route53resolver/getResolverRule.ts @@ -30,6 +30,10 @@ export interface GetResolverRuleResult { * The Amazon Resource Name (ARN) of the resolver rule. */ readonly arn?: string; + /** + * The name server domain for queries to be delegated to if a query matches the delegation record. + */ + readonly delegationRecord?: string; /** * DNS queries for this domain name are forwarded to the IP addresses that are specified in TargetIps */ diff --git a/sdk/nodejs/route53resolver/resolverRule.ts b/sdk/nodejs/route53resolver/resolverRule.ts index 4212ed5a3e..f83e8b0d2b 100644 --- a/sdk/nodejs/route53resolver/resolverRule.ts +++ b/sdk/nodejs/route53resolver/resolverRule.ts @@ -41,10 +41,14 @@ export class ResolverRule extends pulumi.CustomResource { * The Amazon Resource Name (ARN) of the resolver rule. */ public /*out*/ readonly arn!: pulumi.Output; + /** + * The name server domain for queries to be delegated to if a query matches the delegation record. + */ + public readonly delegationRecord!: pulumi.Output; /** * DNS queries for this domain name are forwarded to the IP addresses that are specified in TargetIps */ - public readonly domainName!: pulumi.Output; + public readonly domainName!: pulumi.Output; /** * The name for the Resolver rule */ @@ -81,12 +85,10 @@ export class ResolverRule extends pulumi.CustomResource { let resourceInputs: pulumi.Inputs = {}; opts = opts || {}; if (!opts.id) { - if ((!args || args.domainName === undefined) && !opts.urn) { - throw new Error("Missing required property 'domainName'"); - } if ((!args || args.ruleType === undefined) && !opts.urn) { throw new Error("Missing required property 'ruleType'"); } + resourceInputs["delegationRecord"] = args ? args.delegationRecord : undefined; resourceInputs["domainName"] = args ? args.domainName : undefined; resourceInputs["name"] = args ? args.name : undefined; resourceInputs["resolverEndpointId"] = args ? args.resolverEndpointId : undefined; @@ -97,6 +99,7 @@ export class ResolverRule extends pulumi.CustomResource { resourceInputs["resolverRuleId"] = undefined /*out*/; } else { resourceInputs["arn"] = undefined /*out*/; + resourceInputs["delegationRecord"] = undefined /*out*/; resourceInputs["domainName"] = undefined /*out*/; resourceInputs["name"] = undefined /*out*/; resourceInputs["resolverEndpointId"] = undefined /*out*/; @@ -116,10 +119,14 @@ export class ResolverRule extends pulumi.CustomResource { * The set of arguments for constructing a ResolverRule resource. */ export interface ResolverRuleArgs { + /** + * The name server domain for queries to be delegated to if a query matches the delegation record. + */ + delegationRecord?: pulumi.Input; /** * DNS queries for this domain name are forwarded to the IP addresses that are specified in TargetIps */ - domainName: pulumi.Input; + domainName?: pulumi.Input; /** * The name for the Resolver rule */ diff --git a/sdk/nodejs/tsconfig.json b/sdk/nodejs/tsconfig.json index fa6855f5f2..4db465e182 100644 --- a/sdk/nodejs/tsconfig.json +++ b/sdk/nodejs/tsconfig.json @@ -304,8 +304,12 @@ "cleanrooms/getCollaboration.ts", "cleanrooms/getConfiguredTable.ts", "cleanrooms/getConfiguredTableAssociation.ts", + "cleanrooms/getIdMappingTable.ts", + "cleanrooms/getIdNamespaceAssociation.ts", "cleanrooms/getMembership.ts", "cleanrooms/getPrivacyBudgetTemplate.ts", + "cleanrooms/idMappingTable.ts", + "cleanrooms/idNamespaceAssociation.ts", "cleanrooms/index.ts", "cleanrooms/membership.ts", "cleanrooms/privacyBudgetTemplate.ts", diff --git a/sdk/nodejs/types/enums/cleanrooms/index.ts b/sdk/nodejs/types/enums/cleanrooms/index.ts index c01faacb47..47b7a63f5c 100644 --- a/sdk/nodejs/types/enums/cleanrooms/index.ts +++ b/sdk/nodejs/types/enums/cleanrooms/index.ts @@ -136,6 +136,26 @@ export const ConfiguredTableScalarFunctions = { export type ConfiguredTableScalarFunctions = (typeof ConfiguredTableScalarFunctions)[keyof typeof ConfiguredTableScalarFunctions]; +export const IdMappingTableInputSourceType = { + Source: "SOURCE", + Target: "TARGET", +} as const; + +/** + * The type of the input source of the ID mapping table. + */ +export type IdMappingTableInputSourceType = (typeof IdMappingTableInputSourceType)[keyof typeof IdMappingTableInputSourceType]; + +export const IdNamespaceAssociationInputReferencePropertiesIdNamespaceType = { + Source: "SOURCE", + Target: "TARGET", +} as const; + +/** + * The ID namespace type for this ID namespace association. + */ +export type IdNamespaceAssociationInputReferencePropertiesIdNamespaceType = (typeof IdNamespaceAssociationInputReferencePropertiesIdNamespaceType)[keyof typeof IdNamespaceAssociationInputReferencePropertiesIdNamespaceType]; + export const MembershipQueryLogStatus = { Enabled: "ENABLED", Disabled: "DISABLED", diff --git a/sdk/nodejs/types/enums/route53resolver/index.ts b/sdk/nodejs/types/enums/route53resolver/index.ts index eb89ab6314..39be6cbb43 100644 --- a/sdk/nodejs/types/enums/route53resolver/index.ts +++ b/sdk/nodejs/types/enums/route53resolver/index.ts @@ -202,6 +202,7 @@ export const ResolverRuleRuleType = { Forward: "FORWARD", System: "SYSTEM", Recursive: "RECURSIVE", + Delegate: "DELEGATE", } as const; /** diff --git a/sdk/nodejs/types/input.ts b/sdk/nodejs/types/input.ts index 80b4c2e93c..f78ed6dce1 100644 --- a/sdk/nodejs/types/input.ts +++ b/sdk/nodejs/types/input.ts @@ -10538,6 +10538,41 @@ export namespace cleanrooms { glue: pulumi.Input; } + export interface IdMappingTableInputReferenceConfigArgs { + /** + * The Amazon Resource Name (ARN) of the referenced resource in AWS Entity Resolution . Valid values are ID mapping workflow ARNs. + */ + inputReferenceArn: pulumi.Input; + /** + * When `TRUE` , AWS Clean Rooms manages permissions for the ID mapping table resource. + * + * When `FALSE` , the resource owner manages permissions for the ID mapping table resource. + */ + manageResourcePolicies: pulumi.Input; + } + + export interface IdNamespaceAssociationIdMappingConfigArgs { + /** + * An indicator as to whether you can use your column as a dimension column in the ID mapping table ( `TRUE` ) or not ( `FALSE` ). + * + * Default is `FALSE` . + */ + allowUseAsDimensionColumn: pulumi.Input; + } + + export interface IdNamespaceAssociationInputReferenceConfigArgs { + /** + * The Amazon Resource Name (ARN) of the AWS Entity Resolution resource that is being associated to the collaboration. Valid resource ARNs are from the ID namespaces that you own. + */ + inputReferenceArn: pulumi.Input; + /** + * When `TRUE` , AWS Clean Rooms manages permissions for the ID namespace association resource. + * + * When `FALSE` , the resource owner manages permissions for the ID namespace association resource. + */ + manageResourcePolicies: pulumi.Input; + } + export interface MembershipPaymentConfigurationArgs { /** * The payment responsibilities accepted by the collaboration member for query compute costs. @@ -76093,6 +76128,8 @@ export namespace redshift { * - The cluster must have read bucket and put object permissions */ bucketName?: pulumi.Input; + logDestinationType?: pulumi.Input; + logExports?: pulumi.Input[]>; /** * The prefix applied to the log file names. * diff --git a/sdk/nodejs/types/output.ts b/sdk/nodejs/types/output.ts index 894bb8810a..a9f2be3331 100644 --- a/sdk/nodejs/types/output.ts +++ b/sdk/nodejs/types/output.ts @@ -10955,6 +10955,73 @@ export namespace cleanrooms { glue: outputs.cleanrooms.ConfiguredTableGlueTableReference; } + export interface IdMappingTableInputReferenceConfig { + /** + * The Amazon Resource Name (ARN) of the referenced resource in AWS Entity Resolution . Valid values are ID mapping workflow ARNs. + */ + inputReferenceArn: string; + /** + * When `TRUE` , AWS Clean Rooms manages permissions for the ID mapping table resource. + * + * When `FALSE` , the resource owner manages permissions for the ID mapping table resource. + */ + manageResourcePolicies: boolean; + } + + export interface IdMappingTableInputReferenceProperties { + /** + * The input source of the ID mapping table. + */ + idMappingTableInputSource: outputs.cleanrooms.IdMappingTableInputSource[]; + } + + export interface IdMappingTableInputSource { + /** + * The unique identifier of the ID namespace association. + */ + idNamespaceAssociationId: string; + /** + * The type of the input source of the ID mapping table. + */ + type: enums.cleanrooms.IdMappingTableInputSourceType; + } + + export interface IdNamespaceAssociationDocument { + } + + export interface IdNamespaceAssociationIdMappingConfig { + /** + * An indicator as to whether you can use your column as a dimension column in the ID mapping table ( `TRUE` ) or not ( `FALSE` ). + * + * Default is `FALSE` . + */ + allowUseAsDimensionColumn: boolean; + } + + export interface IdNamespaceAssociationInputReferenceConfig { + /** + * The Amazon Resource Name (ARN) of the AWS Entity Resolution resource that is being associated to the collaboration. Valid resource ARNs are from the ID namespaces that you own. + */ + inputReferenceArn: string; + /** + * When `TRUE` , AWS Clean Rooms manages permissions for the ID namespace association resource. + * + * When `FALSE` , the resource owner manages permissions for the ID namespace association resource. + */ + manageResourcePolicies: boolean; + } + + export interface IdNamespaceAssociationInputReferenceProperties { + /** + * Defines how ID mapping workflows are supported for this ID namespace association. + */ + idMappingWorkflowsSupported?: outputs.cleanrooms.IdNamespaceAssociationDocument[]; + /** + * The ID namespace type for this ID namespace association. + */ + idNamespaceType?: enums.cleanrooms.IdNamespaceAssociationInputReferencePropertiesIdNamespaceType; + } + export interface MembershipPaymentConfiguration { /** * The payment responsibilities accepted by the collaboration member for query compute costs. @@ -77896,6 +77963,8 @@ export namespace redshift { * - The cluster must have read bucket and put object permissions */ bucketName?: string; + logDestinationType?: string; + logExports?: string[]; /** * The prefix applied to the log file names. * diff --git a/sdk/python/pulumi_aws_native/__init__.py b/sdk/python/pulumi_aws_native/__init__.py index 2183dcfcb5..2aaa6068e8 100644 --- a/sdk/python/pulumi_aws_native/__init__.py +++ b/sdk/python/pulumi_aws_native/__init__.py @@ -1016,6 +1016,8 @@ "aws-native:cleanrooms:Collaboration": "Collaboration", "aws-native:cleanrooms:ConfiguredTable": "ConfiguredTable", "aws-native:cleanrooms:ConfiguredTableAssociation": "ConfiguredTableAssociation", + "aws-native:cleanrooms:IdMappingTable": "IdMappingTable", + "aws-native:cleanrooms:IdNamespaceAssociation": "IdNamespaceAssociation", "aws-native:cleanrooms:Membership": "Membership", "aws-native:cleanrooms:PrivacyBudgetTemplate": "PrivacyBudgetTemplate" } diff --git a/sdk/python/pulumi_aws_native/cleanrooms/__init__.py b/sdk/python/pulumi_aws_native/cleanrooms/__init__.py index 35ab1e3089..cdca58b207 100644 --- a/sdk/python/pulumi_aws_native/cleanrooms/__init__.py +++ b/sdk/python/pulumi_aws_native/cleanrooms/__init__.py @@ -14,8 +14,12 @@ from .get_collaboration import * from .get_configured_table import * from .get_configured_table_association import * +from .get_id_mapping_table import * +from .get_id_namespace_association import * from .get_membership import * from .get_privacy_budget_template import * +from .id_mapping_table import * +from .id_namespace_association import * from .membership import * from .privacy_budget_template import * from ._inputs import * diff --git a/sdk/python/pulumi_aws_native/cleanrooms/_enums.py b/sdk/python/pulumi_aws_native/cleanrooms/_enums.py index 4dc98a4315..9542f445c8 100644 --- a/sdk/python/pulumi_aws_native/cleanrooms/_enums.py +++ b/sdk/python/pulumi_aws_native/cleanrooms/_enums.py @@ -18,6 +18,8 @@ 'ConfiguredTableJoinOperator', 'ConfiguredTableJoinRequiredOption', 'ConfiguredTableScalarFunctions', + 'IdMappingTableInputSourceType', + 'IdNamespaceAssociationInputReferencePropertiesIdNamespaceType', 'MembershipQueryLogStatus', 'MembershipResultFormat', 'PrivacyBudgetTemplateAutoRefresh', @@ -133,6 +135,22 @@ class ConfiguredTableScalarFunctions(str, Enum): TRIM = "TRIM" +class IdMappingTableInputSourceType(str, Enum): + """ + The type of the input source of the ID mapping table. + """ + SOURCE = "SOURCE" + TARGET = "TARGET" + + +class IdNamespaceAssociationInputReferencePropertiesIdNamespaceType(str, Enum): + """ + The ID namespace type for this ID namespace association. + """ + SOURCE = "SOURCE" + TARGET = "TARGET" + + class MembershipQueryLogStatus(str, Enum): ENABLED = "ENABLED" DISABLED = "DISABLED" diff --git a/sdk/python/pulumi_aws_native/cleanrooms/_inputs.py b/sdk/python/pulumi_aws_native/cleanrooms/_inputs.py index d6cbdefdb1..3ac299cd35 100644 --- a/sdk/python/pulumi_aws_native/cleanrooms/_inputs.py +++ b/sdk/python/pulumi_aws_native/cleanrooms/_inputs.py @@ -39,6 +39,9 @@ 'ConfiguredTableDifferentialPrivacyArgs', 'ConfiguredTableGlueTableReferenceArgs', 'ConfiguredTableTableReferenceArgs', + 'IdMappingTableInputReferenceConfigArgs', + 'IdNamespaceAssociationIdMappingConfigArgs', + 'IdNamespaceAssociationInputReferenceConfigArgs', 'MembershipPaymentConfigurationArgs', 'MembershipProtectedQueryOutputConfigurationArgs', 'MembershipProtectedQueryResultConfigurationArgs', @@ -985,6 +988,114 @@ def glue(self, value: pulumi.Input['ConfiguredTableGlueTableReferenceArgs']): pulumi.set(self, "glue", value) +@pulumi.input_type +class IdMappingTableInputReferenceConfigArgs: + def __init__(__self__, *, + input_reference_arn: pulumi.Input[str], + manage_resource_policies: pulumi.Input[bool]): + """ + :param pulumi.Input[str] input_reference_arn: The Amazon Resource Name (ARN) of the referenced resource in AWS Entity Resolution . Valid values are ID mapping workflow ARNs. + :param pulumi.Input[bool] manage_resource_policies: When `TRUE` , AWS Clean Rooms manages permissions for the ID mapping table resource. + + When `FALSE` , the resource owner manages permissions for the ID mapping table resource. + """ + pulumi.set(__self__, "input_reference_arn", input_reference_arn) + pulumi.set(__self__, "manage_resource_policies", manage_resource_policies) + + @property + @pulumi.getter(name="inputReferenceArn") + def input_reference_arn(self) -> pulumi.Input[str]: + """ + The Amazon Resource Name (ARN) of the referenced resource in AWS Entity Resolution . Valid values are ID mapping workflow ARNs. + """ + return pulumi.get(self, "input_reference_arn") + + @input_reference_arn.setter + def input_reference_arn(self, value: pulumi.Input[str]): + pulumi.set(self, "input_reference_arn", value) + + @property + @pulumi.getter(name="manageResourcePolicies") + def manage_resource_policies(self) -> pulumi.Input[bool]: + """ + When `TRUE` , AWS Clean Rooms manages permissions for the ID mapping table resource. + + When `FALSE` , the resource owner manages permissions for the ID mapping table resource. + """ + return pulumi.get(self, "manage_resource_policies") + + @manage_resource_policies.setter + def manage_resource_policies(self, value: pulumi.Input[bool]): + pulumi.set(self, "manage_resource_policies", value) + + +@pulumi.input_type +class IdNamespaceAssociationIdMappingConfigArgs: + def __init__(__self__, *, + allow_use_as_dimension_column: pulumi.Input[bool]): + """ + :param pulumi.Input[bool] allow_use_as_dimension_column: An indicator as to whether you can use your column as a dimension column in the ID mapping table ( `TRUE` ) or not ( `FALSE` ). + + Default is `FALSE` . + """ + pulumi.set(__self__, "allow_use_as_dimension_column", allow_use_as_dimension_column) + + @property + @pulumi.getter(name="allowUseAsDimensionColumn") + def allow_use_as_dimension_column(self) -> pulumi.Input[bool]: + """ + An indicator as to whether you can use your column as a dimension column in the ID mapping table ( `TRUE` ) or not ( `FALSE` ). + + Default is `FALSE` . + """ + return pulumi.get(self, "allow_use_as_dimension_column") + + @allow_use_as_dimension_column.setter + def allow_use_as_dimension_column(self, value: pulumi.Input[bool]): + pulumi.set(self, "allow_use_as_dimension_column", value) + + +@pulumi.input_type +class IdNamespaceAssociationInputReferenceConfigArgs: + def __init__(__self__, *, + input_reference_arn: pulumi.Input[str], + manage_resource_policies: pulumi.Input[bool]): + """ + :param pulumi.Input[str] input_reference_arn: The Amazon Resource Name (ARN) of the AWS Entity Resolution resource that is being associated to the collaboration. Valid resource ARNs are from the ID namespaces that you own. + :param pulumi.Input[bool] manage_resource_policies: When `TRUE` , AWS Clean Rooms manages permissions for the ID namespace association resource. + + When `FALSE` , the resource owner manages permissions for the ID namespace association resource. + """ + pulumi.set(__self__, "input_reference_arn", input_reference_arn) + pulumi.set(__self__, "manage_resource_policies", manage_resource_policies) + + @property + @pulumi.getter(name="inputReferenceArn") + def input_reference_arn(self) -> pulumi.Input[str]: + """ + The Amazon Resource Name (ARN) of the AWS Entity Resolution resource that is being associated to the collaboration. Valid resource ARNs are from the ID namespaces that you own. + """ + return pulumi.get(self, "input_reference_arn") + + @input_reference_arn.setter + def input_reference_arn(self, value: pulumi.Input[str]): + pulumi.set(self, "input_reference_arn", value) + + @property + @pulumi.getter(name="manageResourcePolicies") + def manage_resource_policies(self) -> pulumi.Input[bool]: + """ + When `TRUE` , AWS Clean Rooms manages permissions for the ID namespace association resource. + + When `FALSE` , the resource owner manages permissions for the ID namespace association resource. + """ + return pulumi.get(self, "manage_resource_policies") + + @manage_resource_policies.setter + def manage_resource_policies(self, value: pulumi.Input[bool]): + pulumi.set(self, "manage_resource_policies", value) + + @pulumi.input_type class MembershipPaymentConfigurationArgs: def __init__(__self__, *, diff --git a/sdk/python/pulumi_aws_native/cleanrooms/get_id_mapping_table.py b/sdk/python/pulumi_aws_native/cleanrooms/get_id_mapping_table.py new file mode 100644 index 0000000000..944c51887c --- /dev/null +++ b/sdk/python/pulumi_aws_native/cleanrooms/get_id_mapping_table.py @@ -0,0 +1,171 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +from .. import _utilities +from . import outputs +from .. import outputs as _root_outputs +from ._enums import * + +__all__ = [ + 'GetIdMappingTableResult', + 'AwaitableGetIdMappingTableResult', + 'get_id_mapping_table', + 'get_id_mapping_table_output', +] + +@pulumi.output_type +class GetIdMappingTableResult: + def __init__(__self__, arn=None, collaboration_arn=None, collaboration_identifier=None, description=None, id_mapping_table_identifier=None, input_reference_properties=None, kms_key_arn=None, membership_arn=None, tags=None): + if arn and not isinstance(arn, str): + raise TypeError("Expected argument 'arn' to be a str") + pulumi.set(__self__, "arn", arn) + if collaboration_arn and not isinstance(collaboration_arn, str): + raise TypeError("Expected argument 'collaboration_arn' to be a str") + pulumi.set(__self__, "collaboration_arn", collaboration_arn) + if collaboration_identifier and not isinstance(collaboration_identifier, str): + raise TypeError("Expected argument 'collaboration_identifier' to be a str") + pulumi.set(__self__, "collaboration_identifier", collaboration_identifier) + if description and not isinstance(description, str): + raise TypeError("Expected argument 'description' to be a str") + pulumi.set(__self__, "description", description) + if id_mapping_table_identifier and not isinstance(id_mapping_table_identifier, str): + raise TypeError("Expected argument 'id_mapping_table_identifier' to be a str") + pulumi.set(__self__, "id_mapping_table_identifier", id_mapping_table_identifier) + if input_reference_properties and not isinstance(input_reference_properties, dict): + raise TypeError("Expected argument 'input_reference_properties' to be a dict") + pulumi.set(__self__, "input_reference_properties", input_reference_properties) + if kms_key_arn and not isinstance(kms_key_arn, str): + raise TypeError("Expected argument 'kms_key_arn' to be a str") + pulumi.set(__self__, "kms_key_arn", kms_key_arn) + if membership_arn and not isinstance(membership_arn, str): + raise TypeError("Expected argument 'membership_arn' to be a str") + pulumi.set(__self__, "membership_arn", membership_arn) + if tags and not isinstance(tags, list): + raise TypeError("Expected argument 'tags' to be a list") + pulumi.set(__self__, "tags", tags) + + @property + @pulumi.getter + def arn(self) -> Optional[str]: + """ + The Amazon Resource Name (ARN) of the ID mapping table. + """ + return pulumi.get(self, "arn") + + @property + @pulumi.getter(name="collaborationArn") + def collaboration_arn(self) -> Optional[str]: + """ + The Amazon Resource Name (ARN) of the collaboration that contains this ID mapping table. + """ + return pulumi.get(self, "collaboration_arn") + + @property + @pulumi.getter(name="collaborationIdentifier") + def collaboration_identifier(self) -> Optional[str]: + return pulumi.get(self, "collaboration_identifier") + + @property + @pulumi.getter + def description(self) -> Optional[str]: + """ + The description of the ID mapping table. + """ + return pulumi.get(self, "description") + + @property + @pulumi.getter(name="idMappingTableIdentifier") + def id_mapping_table_identifier(self) -> Optional[str]: + return pulumi.get(self, "id_mapping_table_identifier") + + @property + @pulumi.getter(name="inputReferenceProperties") + def input_reference_properties(self) -> Optional['outputs.IdMappingTableInputReferenceProperties']: + return pulumi.get(self, "input_reference_properties") + + @property + @pulumi.getter(name="kmsKeyArn") + def kms_key_arn(self) -> Optional[str]: + """ + The Amazon Resource Name (ARN) of the AWS KMS key. + """ + return pulumi.get(self, "kms_key_arn") + + @property + @pulumi.getter(name="membershipArn") + def membership_arn(self) -> Optional[str]: + """ + The Amazon Resource Name (ARN) of the membership resource for the ID mapping table. + """ + return pulumi.get(self, "membership_arn") + + @property + @pulumi.getter + def tags(self) -> Optional[Sequence['_root_outputs.Tag']]: + """ + An optional label that you can assign to a resource when you create it. Each tag consists of a key and an optional value, both of which you define. When you use tagging, you can also use tag-based access control in IAM policies to control access to this resource. + """ + return pulumi.get(self, "tags") + + +class AwaitableGetIdMappingTableResult(GetIdMappingTableResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetIdMappingTableResult( + arn=self.arn, + collaboration_arn=self.collaboration_arn, + collaboration_identifier=self.collaboration_identifier, + description=self.description, + id_mapping_table_identifier=self.id_mapping_table_identifier, + input_reference_properties=self.input_reference_properties, + kms_key_arn=self.kms_key_arn, + membership_arn=self.membership_arn, + tags=self.tags) + + +def get_id_mapping_table(id_mapping_table_identifier: Optional[str] = None, + membership_identifier: Optional[str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetIdMappingTableResult: + """ + Represents an association between an ID mapping workflow and a collaboration + + + :param str membership_identifier: The unique identifier of the membership resource for the ID mapping table. + """ + __args__ = dict() + __args__['idMappingTableIdentifier'] = id_mapping_table_identifier + __args__['membershipIdentifier'] = membership_identifier + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('aws-native:cleanrooms:getIdMappingTable', __args__, opts=opts, typ=GetIdMappingTableResult).value + + return AwaitableGetIdMappingTableResult( + arn=pulumi.get(__ret__, 'arn'), + collaboration_arn=pulumi.get(__ret__, 'collaboration_arn'), + collaboration_identifier=pulumi.get(__ret__, 'collaboration_identifier'), + description=pulumi.get(__ret__, 'description'), + id_mapping_table_identifier=pulumi.get(__ret__, 'id_mapping_table_identifier'), + input_reference_properties=pulumi.get(__ret__, 'input_reference_properties'), + kms_key_arn=pulumi.get(__ret__, 'kms_key_arn'), + membership_arn=pulumi.get(__ret__, 'membership_arn'), + tags=pulumi.get(__ret__, 'tags')) + + +@_utilities.lift_output_func(get_id_mapping_table) +def get_id_mapping_table_output(id_mapping_table_identifier: Optional[pulumi.Input[str]] = None, + membership_identifier: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetIdMappingTableResult]: + """ + Represents an association between an ID mapping workflow and a collaboration + + + :param str membership_identifier: The unique identifier of the membership resource for the ID mapping table. + """ + ... diff --git a/sdk/python/pulumi_aws_native/cleanrooms/get_id_namespace_association.py b/sdk/python/pulumi_aws_native/cleanrooms/get_id_namespace_association.py new file mode 100644 index 0000000000..693fa0b792 --- /dev/null +++ b/sdk/python/pulumi_aws_native/cleanrooms/get_id_namespace_association.py @@ -0,0 +1,181 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +from .. import _utilities +from . import outputs +from .. import outputs as _root_outputs +from ._enums import * + +__all__ = [ + 'GetIdNamespaceAssociationResult', + 'AwaitableGetIdNamespaceAssociationResult', + 'get_id_namespace_association', + 'get_id_namespace_association_output', +] + +@pulumi.output_type +class GetIdNamespaceAssociationResult: + def __init__(__self__, arn=None, collaboration_arn=None, collaboration_identifier=None, description=None, id_mapping_config=None, id_namespace_association_identifier=None, input_reference_properties=None, membership_arn=None, name=None, tags=None): + if arn and not isinstance(arn, str): + raise TypeError("Expected argument 'arn' to be a str") + pulumi.set(__self__, "arn", arn) + if collaboration_arn and not isinstance(collaboration_arn, str): + raise TypeError("Expected argument 'collaboration_arn' to be a str") + pulumi.set(__self__, "collaboration_arn", collaboration_arn) + if collaboration_identifier and not isinstance(collaboration_identifier, str): + raise TypeError("Expected argument 'collaboration_identifier' to be a str") + pulumi.set(__self__, "collaboration_identifier", collaboration_identifier) + if description and not isinstance(description, str): + raise TypeError("Expected argument 'description' to be a str") + pulumi.set(__self__, "description", description) + if id_mapping_config and not isinstance(id_mapping_config, dict): + raise TypeError("Expected argument 'id_mapping_config' to be a dict") + pulumi.set(__self__, "id_mapping_config", id_mapping_config) + if id_namespace_association_identifier and not isinstance(id_namespace_association_identifier, str): + raise TypeError("Expected argument 'id_namespace_association_identifier' to be a str") + pulumi.set(__self__, "id_namespace_association_identifier", id_namespace_association_identifier) + if input_reference_properties and not isinstance(input_reference_properties, dict): + raise TypeError("Expected argument 'input_reference_properties' to be a dict") + pulumi.set(__self__, "input_reference_properties", input_reference_properties) + if membership_arn and not isinstance(membership_arn, str): + raise TypeError("Expected argument 'membership_arn' to be a str") + pulumi.set(__self__, "membership_arn", membership_arn) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if tags and not isinstance(tags, list): + raise TypeError("Expected argument 'tags' to be a list") + pulumi.set(__self__, "tags", tags) + + @property + @pulumi.getter + def arn(self) -> Optional[str]: + """ + The Amazon Resource Name (ARN) of the ID namespace association. + """ + return pulumi.get(self, "arn") + + @property + @pulumi.getter(name="collaborationArn") + def collaboration_arn(self) -> Optional[str]: + """ + The Amazon Resource Name (ARN) of the collaboration that contains this ID namespace association. + """ + return pulumi.get(self, "collaboration_arn") + + @property + @pulumi.getter(name="collaborationIdentifier") + def collaboration_identifier(self) -> Optional[str]: + return pulumi.get(self, "collaboration_identifier") + + @property + @pulumi.getter + def description(self) -> Optional[str]: + """ + The description of the ID namespace association. + """ + return pulumi.get(self, "description") + + @property + @pulumi.getter(name="idMappingConfig") + def id_mapping_config(self) -> Optional['outputs.IdNamespaceAssociationIdMappingConfig']: + """ + The configuration settings for the ID mapping table. + """ + return pulumi.get(self, "id_mapping_config") + + @property + @pulumi.getter(name="idNamespaceAssociationIdentifier") + def id_namespace_association_identifier(self) -> Optional[str]: + return pulumi.get(self, "id_namespace_association_identifier") + + @property + @pulumi.getter(name="inputReferenceProperties") + def input_reference_properties(self) -> Optional['outputs.IdNamespaceAssociationInputReferenceProperties']: + return pulumi.get(self, "input_reference_properties") + + @property + @pulumi.getter(name="membershipArn") + def membership_arn(self) -> Optional[str]: + """ + The Amazon Resource Name (ARN) of the membership resource for this ID namespace association. + """ + return pulumi.get(self, "membership_arn") + + @property + @pulumi.getter + def name(self) -> Optional[str]: + """ + The name of this ID namespace association. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter + def tags(self) -> Optional[Sequence['_root_outputs.Tag']]: + return pulumi.get(self, "tags") + + +class AwaitableGetIdNamespaceAssociationResult(GetIdNamespaceAssociationResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetIdNamespaceAssociationResult( + arn=self.arn, + collaboration_arn=self.collaboration_arn, + collaboration_identifier=self.collaboration_identifier, + description=self.description, + id_mapping_config=self.id_mapping_config, + id_namespace_association_identifier=self.id_namespace_association_identifier, + input_reference_properties=self.input_reference_properties, + membership_arn=self.membership_arn, + name=self.name, + tags=self.tags) + + +def get_id_namespace_association(id_namespace_association_identifier: Optional[str] = None, + membership_identifier: Optional[str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetIdNamespaceAssociationResult: + """ + Represents an association between an ID namespace and a collaboration + + + :param str membership_identifier: The unique identifier of the membership that contains the ID namespace association. + """ + __args__ = dict() + __args__['idNamespaceAssociationIdentifier'] = id_namespace_association_identifier + __args__['membershipIdentifier'] = membership_identifier + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('aws-native:cleanrooms:getIdNamespaceAssociation', __args__, opts=opts, typ=GetIdNamespaceAssociationResult).value + + return AwaitableGetIdNamespaceAssociationResult( + arn=pulumi.get(__ret__, 'arn'), + collaboration_arn=pulumi.get(__ret__, 'collaboration_arn'), + collaboration_identifier=pulumi.get(__ret__, 'collaboration_identifier'), + description=pulumi.get(__ret__, 'description'), + id_mapping_config=pulumi.get(__ret__, 'id_mapping_config'), + id_namespace_association_identifier=pulumi.get(__ret__, 'id_namespace_association_identifier'), + input_reference_properties=pulumi.get(__ret__, 'input_reference_properties'), + membership_arn=pulumi.get(__ret__, 'membership_arn'), + name=pulumi.get(__ret__, 'name'), + tags=pulumi.get(__ret__, 'tags')) + + +@_utilities.lift_output_func(get_id_namespace_association) +def get_id_namespace_association_output(id_namespace_association_identifier: Optional[pulumi.Input[str]] = None, + membership_identifier: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetIdNamespaceAssociationResult]: + """ + Represents an association between an ID namespace and a collaboration + + + :param str membership_identifier: The unique identifier of the membership that contains the ID namespace association. + """ + ... diff --git a/sdk/python/pulumi_aws_native/cleanrooms/id_mapping_table.py b/sdk/python/pulumi_aws_native/cleanrooms/id_mapping_table.py new file mode 100644 index 0000000000..ebb0422741 --- /dev/null +++ b/sdk/python/pulumi_aws_native/cleanrooms/id_mapping_table.py @@ -0,0 +1,324 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +from .. import _utilities +from . import outputs +from .. import _inputs as _root_inputs +from .. import outputs as _root_outputs +from ._enums import * +from ._inputs import * + +__all__ = ['IdMappingTableArgs', 'IdMappingTable'] + +@pulumi.input_type +class IdMappingTableArgs: + def __init__(__self__, *, + input_reference_config: pulumi.Input['IdMappingTableInputReferenceConfigArgs'], + membership_identifier: pulumi.Input[str], + description: Optional[pulumi.Input[str]] = None, + kms_key_arn: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + tags: Optional[pulumi.Input[Sequence[pulumi.Input['_root_inputs.TagArgs']]]] = None): + """ + The set of arguments for constructing a IdMappingTable resource. + :param pulumi.Input['IdMappingTableInputReferenceConfigArgs'] input_reference_config: The input reference configuration for the ID mapping table. + :param pulumi.Input[str] membership_identifier: The unique identifier of the membership resource for the ID mapping table. + :param pulumi.Input[str] description: The description of the ID mapping table. + :param pulumi.Input[str] kms_key_arn: The Amazon Resource Name (ARN) of the AWS KMS key. + :param pulumi.Input[str] name: The name of the ID mapping table. + :param pulumi.Input[Sequence[pulumi.Input['_root_inputs.TagArgs']]] tags: An optional label that you can assign to a resource when you create it. Each tag consists of a key and an optional value, both of which you define. When you use tagging, you can also use tag-based access control in IAM policies to control access to this resource. + """ + pulumi.set(__self__, "input_reference_config", input_reference_config) + pulumi.set(__self__, "membership_identifier", membership_identifier) + if description is not None: + pulumi.set(__self__, "description", description) + if kms_key_arn is not None: + pulumi.set(__self__, "kms_key_arn", kms_key_arn) + if name is not None: + pulumi.set(__self__, "name", name) + if tags is not None: + pulumi.set(__self__, "tags", tags) + + @property + @pulumi.getter(name="inputReferenceConfig") + def input_reference_config(self) -> pulumi.Input['IdMappingTableInputReferenceConfigArgs']: + """ + The input reference configuration for the ID mapping table. + """ + return pulumi.get(self, "input_reference_config") + + @input_reference_config.setter + def input_reference_config(self, value: pulumi.Input['IdMappingTableInputReferenceConfigArgs']): + pulumi.set(self, "input_reference_config", value) + + @property + @pulumi.getter(name="membershipIdentifier") + def membership_identifier(self) -> pulumi.Input[str]: + """ + The unique identifier of the membership resource for the ID mapping table. + """ + return pulumi.get(self, "membership_identifier") + + @membership_identifier.setter + def membership_identifier(self, value: pulumi.Input[str]): + pulumi.set(self, "membership_identifier", value) + + @property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[str]]: + """ + The description of the ID mapping table. + """ + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "description", value) + + @property + @pulumi.getter(name="kmsKeyArn") + def kms_key_arn(self) -> Optional[pulumi.Input[str]]: + """ + The Amazon Resource Name (ARN) of the AWS KMS key. + """ + return pulumi.get(self, "kms_key_arn") + + @kms_key_arn.setter + def kms_key_arn(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "kms_key_arn", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[str]]: + """ + The name of the ID mapping table. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['_root_inputs.TagArgs']]]]: + """ + An optional label that you can assign to a resource when you create it. Each tag consists of a key and an optional value, both of which you define. When you use tagging, you can also use tag-based access control in IAM policies to control access to this resource. + """ + return pulumi.get(self, "tags") + + @tags.setter + def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['_root_inputs.TagArgs']]]]): + pulumi.set(self, "tags", value) + + +class IdMappingTable(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[str]] = None, + input_reference_config: Optional[pulumi.Input[Union['IdMappingTableInputReferenceConfigArgs', 'IdMappingTableInputReferenceConfigArgsDict']]] = None, + kms_key_arn: Optional[pulumi.Input[str]] = None, + membership_identifier: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['_root_inputs.TagArgs', '_root_inputs.TagArgsDict']]]]] = None, + __props__=None): + """ + Represents an association between an ID mapping workflow and a collaboration + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[str] description: The description of the ID mapping table. + :param pulumi.Input[Union['IdMappingTableInputReferenceConfigArgs', 'IdMappingTableInputReferenceConfigArgsDict']] input_reference_config: The input reference configuration for the ID mapping table. + :param pulumi.Input[str] kms_key_arn: The Amazon Resource Name (ARN) of the AWS KMS key. + :param pulumi.Input[str] membership_identifier: The unique identifier of the membership resource for the ID mapping table. + :param pulumi.Input[str] name: The name of the ID mapping table. + :param pulumi.Input[Sequence[pulumi.Input[Union['_root_inputs.TagArgs', '_root_inputs.TagArgsDict']]]] tags: An optional label that you can assign to a resource when you create it. Each tag consists of a key and an optional value, both of which you define. When you use tagging, you can also use tag-based access control in IAM policies to control access to this resource. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: IdMappingTableArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Represents an association between an ID mapping workflow and a collaboration + + :param str resource_name: The name of the resource. + :param IdMappingTableArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(IdMappingTableArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[str]] = None, + input_reference_config: Optional[pulumi.Input[Union['IdMappingTableInputReferenceConfigArgs', 'IdMappingTableInputReferenceConfigArgsDict']]] = None, + kms_key_arn: Optional[pulumi.Input[str]] = None, + membership_identifier: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['_root_inputs.TagArgs', '_root_inputs.TagArgsDict']]]]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = IdMappingTableArgs.__new__(IdMappingTableArgs) + + __props__.__dict__["description"] = description + if input_reference_config is None and not opts.urn: + raise TypeError("Missing required property 'input_reference_config'") + __props__.__dict__["input_reference_config"] = input_reference_config + __props__.__dict__["kms_key_arn"] = kms_key_arn + if membership_identifier is None and not opts.urn: + raise TypeError("Missing required property 'membership_identifier'") + __props__.__dict__["membership_identifier"] = membership_identifier + __props__.__dict__["name"] = name + __props__.__dict__["tags"] = tags + __props__.__dict__["arn"] = None + __props__.__dict__["collaboration_arn"] = None + __props__.__dict__["collaboration_identifier"] = None + __props__.__dict__["id_mapping_table_identifier"] = None + __props__.__dict__["input_reference_properties"] = None + __props__.__dict__["membership_arn"] = None + replace_on_changes = pulumi.ResourceOptions(replace_on_changes=["inputReferenceConfig", "membershipIdentifier", "name"]) + opts = pulumi.ResourceOptions.merge(opts, replace_on_changes) + super(IdMappingTable, __self__).__init__( + 'aws-native:cleanrooms:IdMappingTable', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None) -> 'IdMappingTable': + """ + Get an existing IdMappingTable resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = IdMappingTableArgs.__new__(IdMappingTableArgs) + + __props__.__dict__["arn"] = None + __props__.__dict__["collaboration_arn"] = None + __props__.__dict__["collaboration_identifier"] = None + __props__.__dict__["description"] = None + __props__.__dict__["id_mapping_table_identifier"] = None + __props__.__dict__["input_reference_config"] = None + __props__.__dict__["input_reference_properties"] = None + __props__.__dict__["kms_key_arn"] = None + __props__.__dict__["membership_arn"] = None + __props__.__dict__["membership_identifier"] = None + __props__.__dict__["name"] = None + __props__.__dict__["tags"] = None + return IdMappingTable(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def arn(self) -> pulumi.Output[str]: + """ + The Amazon Resource Name (ARN) of the ID mapping table. + """ + return pulumi.get(self, "arn") + + @property + @pulumi.getter(name="collaborationArn") + def collaboration_arn(self) -> pulumi.Output[str]: + """ + The Amazon Resource Name (ARN) of the collaboration that contains this ID mapping table. + """ + return pulumi.get(self, "collaboration_arn") + + @property + @pulumi.getter(name="collaborationIdentifier") + def collaboration_identifier(self) -> pulumi.Output[str]: + return pulumi.get(self, "collaboration_identifier") + + @property + @pulumi.getter + def description(self) -> pulumi.Output[Optional[str]]: + """ + The description of the ID mapping table. + """ + return pulumi.get(self, "description") + + @property + @pulumi.getter(name="idMappingTableIdentifier") + def id_mapping_table_identifier(self) -> pulumi.Output[str]: + return pulumi.get(self, "id_mapping_table_identifier") + + @property + @pulumi.getter(name="inputReferenceConfig") + def input_reference_config(self) -> pulumi.Output['outputs.IdMappingTableInputReferenceConfig']: + """ + The input reference configuration for the ID mapping table. + """ + return pulumi.get(self, "input_reference_config") + + @property + @pulumi.getter(name="inputReferenceProperties") + def input_reference_properties(self) -> pulumi.Output['outputs.IdMappingTableInputReferenceProperties']: + return pulumi.get(self, "input_reference_properties") + + @property + @pulumi.getter(name="kmsKeyArn") + def kms_key_arn(self) -> pulumi.Output[Optional[str]]: + """ + The Amazon Resource Name (ARN) of the AWS KMS key. + """ + return pulumi.get(self, "kms_key_arn") + + @property + @pulumi.getter(name="membershipArn") + def membership_arn(self) -> pulumi.Output[str]: + """ + The Amazon Resource Name (ARN) of the membership resource for the ID mapping table. + """ + return pulumi.get(self, "membership_arn") + + @property + @pulumi.getter(name="membershipIdentifier") + def membership_identifier(self) -> pulumi.Output[str]: + """ + The unique identifier of the membership resource for the ID mapping table. + """ + return pulumi.get(self, "membership_identifier") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[str]: + """ + The name of the ID mapping table. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter + def tags(self) -> pulumi.Output[Optional[Sequence['_root_outputs.Tag']]]: + """ + An optional label that you can assign to a resource when you create it. Each tag consists of a key and an optional value, both of which you define. When you use tagging, you can also use tag-based access control in IAM policies to control access to this resource. + """ + return pulumi.get(self, "tags") + diff --git a/sdk/python/pulumi_aws_native/cleanrooms/id_namespace_association.py b/sdk/python/pulumi_aws_native/cleanrooms/id_namespace_association.py new file mode 100644 index 0000000000..a9197751d5 --- /dev/null +++ b/sdk/python/pulumi_aws_native/cleanrooms/id_namespace_association.py @@ -0,0 +1,316 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +from .. import _utilities +from . import outputs +from .. import _inputs as _root_inputs +from .. import outputs as _root_outputs +from ._enums import * +from ._inputs import * + +__all__ = ['IdNamespaceAssociationArgs', 'IdNamespaceAssociation'] + +@pulumi.input_type +class IdNamespaceAssociationArgs: + def __init__(__self__, *, + input_reference_config: pulumi.Input['IdNamespaceAssociationInputReferenceConfigArgs'], + membership_identifier: pulumi.Input[str], + description: Optional[pulumi.Input[str]] = None, + id_mapping_config: Optional[pulumi.Input['IdNamespaceAssociationIdMappingConfigArgs']] = None, + name: Optional[pulumi.Input[str]] = None, + tags: Optional[pulumi.Input[Sequence[pulumi.Input['_root_inputs.TagArgs']]]] = None): + """ + The set of arguments for constructing a IdNamespaceAssociation resource. + :param pulumi.Input['IdNamespaceAssociationInputReferenceConfigArgs'] input_reference_config: The input reference configuration for the ID namespace association. + :param pulumi.Input[str] membership_identifier: The unique identifier of the membership that contains the ID namespace association. + :param pulumi.Input[str] description: The description of the ID namespace association. + :param pulumi.Input['IdNamespaceAssociationIdMappingConfigArgs'] id_mapping_config: The configuration settings for the ID mapping table. + :param pulumi.Input[str] name: The name of this ID namespace association. + """ + pulumi.set(__self__, "input_reference_config", input_reference_config) + pulumi.set(__self__, "membership_identifier", membership_identifier) + if description is not None: + pulumi.set(__self__, "description", description) + if id_mapping_config is not None: + pulumi.set(__self__, "id_mapping_config", id_mapping_config) + if name is not None: + pulumi.set(__self__, "name", name) + if tags is not None: + pulumi.set(__self__, "tags", tags) + + @property + @pulumi.getter(name="inputReferenceConfig") + def input_reference_config(self) -> pulumi.Input['IdNamespaceAssociationInputReferenceConfigArgs']: + """ + The input reference configuration for the ID namespace association. + """ + return pulumi.get(self, "input_reference_config") + + @input_reference_config.setter + def input_reference_config(self, value: pulumi.Input['IdNamespaceAssociationInputReferenceConfigArgs']): + pulumi.set(self, "input_reference_config", value) + + @property + @pulumi.getter(name="membershipIdentifier") + def membership_identifier(self) -> pulumi.Input[str]: + """ + The unique identifier of the membership that contains the ID namespace association. + """ + return pulumi.get(self, "membership_identifier") + + @membership_identifier.setter + def membership_identifier(self, value: pulumi.Input[str]): + pulumi.set(self, "membership_identifier", value) + + @property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[str]]: + """ + The description of the ID namespace association. + """ + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "description", value) + + @property + @pulumi.getter(name="idMappingConfig") + def id_mapping_config(self) -> Optional[pulumi.Input['IdNamespaceAssociationIdMappingConfigArgs']]: + """ + The configuration settings for the ID mapping table. + """ + return pulumi.get(self, "id_mapping_config") + + @id_mapping_config.setter + def id_mapping_config(self, value: Optional[pulumi.Input['IdNamespaceAssociationIdMappingConfigArgs']]): + pulumi.set(self, "id_mapping_config", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[str]]: + """ + The name of this ID namespace association. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['_root_inputs.TagArgs']]]]: + return pulumi.get(self, "tags") + + @tags.setter + def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['_root_inputs.TagArgs']]]]): + pulumi.set(self, "tags", value) + + +class IdNamespaceAssociation(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[str]] = None, + id_mapping_config: Optional[pulumi.Input[Union['IdNamespaceAssociationIdMappingConfigArgs', 'IdNamespaceAssociationIdMappingConfigArgsDict']]] = None, + input_reference_config: Optional[pulumi.Input[Union['IdNamespaceAssociationInputReferenceConfigArgs', 'IdNamespaceAssociationInputReferenceConfigArgsDict']]] = None, + membership_identifier: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['_root_inputs.TagArgs', '_root_inputs.TagArgsDict']]]]] = None, + __props__=None): + """ + Represents an association between an ID namespace and a collaboration + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[str] description: The description of the ID namespace association. + :param pulumi.Input[Union['IdNamespaceAssociationIdMappingConfigArgs', 'IdNamespaceAssociationIdMappingConfigArgsDict']] id_mapping_config: The configuration settings for the ID mapping table. + :param pulumi.Input[Union['IdNamespaceAssociationInputReferenceConfigArgs', 'IdNamespaceAssociationInputReferenceConfigArgsDict']] input_reference_config: The input reference configuration for the ID namespace association. + :param pulumi.Input[str] membership_identifier: The unique identifier of the membership that contains the ID namespace association. + :param pulumi.Input[str] name: The name of this ID namespace association. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: IdNamespaceAssociationArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Represents an association between an ID namespace and a collaboration + + :param str resource_name: The name of the resource. + :param IdNamespaceAssociationArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(IdNamespaceAssociationArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[str]] = None, + id_mapping_config: Optional[pulumi.Input[Union['IdNamespaceAssociationIdMappingConfigArgs', 'IdNamespaceAssociationIdMappingConfigArgsDict']]] = None, + input_reference_config: Optional[pulumi.Input[Union['IdNamespaceAssociationInputReferenceConfigArgs', 'IdNamespaceAssociationInputReferenceConfigArgsDict']]] = None, + membership_identifier: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['_root_inputs.TagArgs', '_root_inputs.TagArgsDict']]]]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = IdNamespaceAssociationArgs.__new__(IdNamespaceAssociationArgs) + + __props__.__dict__["description"] = description + __props__.__dict__["id_mapping_config"] = id_mapping_config + if input_reference_config is None and not opts.urn: + raise TypeError("Missing required property 'input_reference_config'") + __props__.__dict__["input_reference_config"] = input_reference_config + if membership_identifier is None and not opts.urn: + raise TypeError("Missing required property 'membership_identifier'") + __props__.__dict__["membership_identifier"] = membership_identifier + __props__.__dict__["name"] = name + __props__.__dict__["tags"] = tags + __props__.__dict__["arn"] = None + __props__.__dict__["collaboration_arn"] = None + __props__.__dict__["collaboration_identifier"] = None + __props__.__dict__["id_namespace_association_identifier"] = None + __props__.__dict__["input_reference_properties"] = None + __props__.__dict__["membership_arn"] = None + replace_on_changes = pulumi.ResourceOptions(replace_on_changes=["inputReferenceConfig", "membershipIdentifier"]) + opts = pulumi.ResourceOptions.merge(opts, replace_on_changes) + super(IdNamespaceAssociation, __self__).__init__( + 'aws-native:cleanrooms:IdNamespaceAssociation', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None) -> 'IdNamespaceAssociation': + """ + Get an existing IdNamespaceAssociation resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = IdNamespaceAssociationArgs.__new__(IdNamespaceAssociationArgs) + + __props__.__dict__["arn"] = None + __props__.__dict__["collaboration_arn"] = None + __props__.__dict__["collaboration_identifier"] = None + __props__.__dict__["description"] = None + __props__.__dict__["id_mapping_config"] = None + __props__.__dict__["id_namespace_association_identifier"] = None + __props__.__dict__["input_reference_config"] = None + __props__.__dict__["input_reference_properties"] = None + __props__.__dict__["membership_arn"] = None + __props__.__dict__["membership_identifier"] = None + __props__.__dict__["name"] = None + __props__.__dict__["tags"] = None + return IdNamespaceAssociation(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def arn(self) -> pulumi.Output[str]: + """ + The Amazon Resource Name (ARN) of the ID namespace association. + """ + return pulumi.get(self, "arn") + + @property + @pulumi.getter(name="collaborationArn") + def collaboration_arn(self) -> pulumi.Output[str]: + """ + The Amazon Resource Name (ARN) of the collaboration that contains this ID namespace association. + """ + return pulumi.get(self, "collaboration_arn") + + @property + @pulumi.getter(name="collaborationIdentifier") + def collaboration_identifier(self) -> pulumi.Output[str]: + return pulumi.get(self, "collaboration_identifier") + + @property + @pulumi.getter + def description(self) -> pulumi.Output[Optional[str]]: + """ + The description of the ID namespace association. + """ + return pulumi.get(self, "description") + + @property + @pulumi.getter(name="idMappingConfig") + def id_mapping_config(self) -> pulumi.Output[Optional['outputs.IdNamespaceAssociationIdMappingConfig']]: + """ + The configuration settings for the ID mapping table. + """ + return pulumi.get(self, "id_mapping_config") + + @property + @pulumi.getter(name="idNamespaceAssociationIdentifier") + def id_namespace_association_identifier(self) -> pulumi.Output[str]: + return pulumi.get(self, "id_namespace_association_identifier") + + @property + @pulumi.getter(name="inputReferenceConfig") + def input_reference_config(self) -> pulumi.Output['outputs.IdNamespaceAssociationInputReferenceConfig']: + """ + The input reference configuration for the ID namespace association. + """ + return pulumi.get(self, "input_reference_config") + + @property + @pulumi.getter(name="inputReferenceProperties") + def input_reference_properties(self) -> pulumi.Output['outputs.IdNamespaceAssociationInputReferenceProperties']: + return pulumi.get(self, "input_reference_properties") + + @property + @pulumi.getter(name="membershipArn") + def membership_arn(self) -> pulumi.Output[str]: + """ + The Amazon Resource Name (ARN) of the membership resource for this ID namespace association. + """ + return pulumi.get(self, "membership_arn") + + @property + @pulumi.getter(name="membershipIdentifier") + def membership_identifier(self) -> pulumi.Output[str]: + """ + The unique identifier of the membership that contains the ID namespace association. + """ + return pulumi.get(self, "membership_identifier") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[str]: + """ + The name of this ID namespace association. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter + def tags(self) -> pulumi.Output[Optional[Sequence['_root_outputs.Tag']]]: + return pulumi.get(self, "tags") + diff --git a/sdk/python/pulumi_aws_native/cleanrooms/outputs.py b/sdk/python/pulumi_aws_native/cleanrooms/outputs.py index 8dba9557b0..f8650f75ef 100644 --- a/sdk/python/pulumi_aws_native/cleanrooms/outputs.py +++ b/sdk/python/pulumi_aws_native/cleanrooms/outputs.py @@ -41,6 +41,13 @@ 'ConfiguredTableDifferentialPrivacyColumn', 'ConfiguredTableGlueTableReference', 'ConfiguredTableTableReference', + 'IdMappingTableInputReferenceConfig', + 'IdMappingTableInputReferenceProperties', + 'IdMappingTableInputSource', + 'IdNamespaceAssociationDocument', + 'IdNamespaceAssociationIdMappingConfig', + 'IdNamespaceAssociationInputReferenceConfig', + 'IdNamespaceAssociationInputReferenceProperties', 'MembershipPaymentConfiguration', 'MembershipProtectedQueryOutputConfiguration', 'MembershipProtectedQueryResultConfiguration', @@ -1072,6 +1079,286 @@ def glue(self) -> 'outputs.ConfiguredTableGlueTableReference': return pulumi.get(self, "glue") +@pulumi.output_type +class IdMappingTableInputReferenceConfig(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "inputReferenceArn": + suggest = "input_reference_arn" + elif key == "manageResourcePolicies": + suggest = "manage_resource_policies" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in IdMappingTableInputReferenceConfig. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + IdMappingTableInputReferenceConfig.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + IdMappingTableInputReferenceConfig.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + input_reference_arn: str, + manage_resource_policies: bool): + """ + :param str input_reference_arn: The Amazon Resource Name (ARN) of the referenced resource in AWS Entity Resolution . Valid values are ID mapping workflow ARNs. + :param bool manage_resource_policies: When `TRUE` , AWS Clean Rooms manages permissions for the ID mapping table resource. + + When `FALSE` , the resource owner manages permissions for the ID mapping table resource. + """ + pulumi.set(__self__, "input_reference_arn", input_reference_arn) + pulumi.set(__self__, "manage_resource_policies", manage_resource_policies) + + @property + @pulumi.getter(name="inputReferenceArn") + def input_reference_arn(self) -> str: + """ + The Amazon Resource Name (ARN) of the referenced resource in AWS Entity Resolution . Valid values are ID mapping workflow ARNs. + """ + return pulumi.get(self, "input_reference_arn") + + @property + @pulumi.getter(name="manageResourcePolicies") + def manage_resource_policies(self) -> bool: + """ + When `TRUE` , AWS Clean Rooms manages permissions for the ID mapping table resource. + + When `FALSE` , the resource owner manages permissions for the ID mapping table resource. + """ + return pulumi.get(self, "manage_resource_policies") + + +@pulumi.output_type +class IdMappingTableInputReferenceProperties(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "idMappingTableInputSource": + suggest = "id_mapping_table_input_source" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in IdMappingTableInputReferenceProperties. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + IdMappingTableInputReferenceProperties.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + IdMappingTableInputReferenceProperties.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + id_mapping_table_input_source: Sequence['outputs.IdMappingTableInputSource']): + """ + :param Sequence['IdMappingTableInputSource'] id_mapping_table_input_source: The input source of the ID mapping table. + """ + pulumi.set(__self__, "id_mapping_table_input_source", id_mapping_table_input_source) + + @property + @pulumi.getter(name="idMappingTableInputSource") + def id_mapping_table_input_source(self) -> Sequence['outputs.IdMappingTableInputSource']: + """ + The input source of the ID mapping table. + """ + return pulumi.get(self, "id_mapping_table_input_source") + + +@pulumi.output_type +class IdMappingTableInputSource(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "idNamespaceAssociationId": + suggest = "id_namespace_association_id" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in IdMappingTableInputSource. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + IdMappingTableInputSource.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + IdMappingTableInputSource.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + id_namespace_association_id: str, + type: 'IdMappingTableInputSourceType'): + """ + :param str id_namespace_association_id: The unique identifier of the ID namespace association. + :param 'IdMappingTableInputSourceType' type: The type of the input source of the ID mapping table. + """ + pulumi.set(__self__, "id_namespace_association_id", id_namespace_association_id) + pulumi.set(__self__, "type", type) + + @property + @pulumi.getter(name="idNamespaceAssociationId") + def id_namespace_association_id(self) -> str: + """ + The unique identifier of the ID namespace association. + """ + return pulumi.get(self, "id_namespace_association_id") + + @property + @pulumi.getter + def type(self) -> 'IdMappingTableInputSourceType': + """ + The type of the input source of the ID mapping table. + """ + return pulumi.get(self, "type") + + +@pulumi.output_type +class IdNamespaceAssociationDocument(dict): + def __init__(__self__): + pass + + +@pulumi.output_type +class IdNamespaceAssociationIdMappingConfig(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "allowUseAsDimensionColumn": + suggest = "allow_use_as_dimension_column" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in IdNamespaceAssociationIdMappingConfig. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + IdNamespaceAssociationIdMappingConfig.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + IdNamespaceAssociationIdMappingConfig.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + allow_use_as_dimension_column: bool): + """ + :param bool allow_use_as_dimension_column: An indicator as to whether you can use your column as a dimension column in the ID mapping table ( `TRUE` ) or not ( `FALSE` ). + + Default is `FALSE` . + """ + pulumi.set(__self__, "allow_use_as_dimension_column", allow_use_as_dimension_column) + + @property + @pulumi.getter(name="allowUseAsDimensionColumn") + def allow_use_as_dimension_column(self) -> bool: + """ + An indicator as to whether you can use your column as a dimension column in the ID mapping table ( `TRUE` ) or not ( `FALSE` ). + + Default is `FALSE` . + """ + return pulumi.get(self, "allow_use_as_dimension_column") + + +@pulumi.output_type +class IdNamespaceAssociationInputReferenceConfig(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "inputReferenceArn": + suggest = "input_reference_arn" + elif key == "manageResourcePolicies": + suggest = "manage_resource_policies" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in IdNamespaceAssociationInputReferenceConfig. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + IdNamespaceAssociationInputReferenceConfig.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + IdNamespaceAssociationInputReferenceConfig.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + input_reference_arn: str, + manage_resource_policies: bool): + """ + :param str input_reference_arn: The Amazon Resource Name (ARN) of the AWS Entity Resolution resource that is being associated to the collaboration. Valid resource ARNs are from the ID namespaces that you own. + :param bool manage_resource_policies: When `TRUE` , AWS Clean Rooms manages permissions for the ID namespace association resource. + + When `FALSE` , the resource owner manages permissions for the ID namespace association resource. + """ + pulumi.set(__self__, "input_reference_arn", input_reference_arn) + pulumi.set(__self__, "manage_resource_policies", manage_resource_policies) + + @property + @pulumi.getter(name="inputReferenceArn") + def input_reference_arn(self) -> str: + """ + The Amazon Resource Name (ARN) of the AWS Entity Resolution resource that is being associated to the collaboration. Valid resource ARNs are from the ID namespaces that you own. + """ + return pulumi.get(self, "input_reference_arn") + + @property + @pulumi.getter(name="manageResourcePolicies") + def manage_resource_policies(self) -> bool: + """ + When `TRUE` , AWS Clean Rooms manages permissions for the ID namespace association resource. + + When `FALSE` , the resource owner manages permissions for the ID namespace association resource. + """ + return pulumi.get(self, "manage_resource_policies") + + +@pulumi.output_type +class IdNamespaceAssociationInputReferenceProperties(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "idMappingWorkflowsSupported": + suggest = "id_mapping_workflows_supported" + elif key == "idNamespaceType": + suggest = "id_namespace_type" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in IdNamespaceAssociationInputReferenceProperties. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + IdNamespaceAssociationInputReferenceProperties.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + IdNamespaceAssociationInputReferenceProperties.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + id_mapping_workflows_supported: Optional[Sequence['outputs.IdNamespaceAssociationDocument']] = None, + id_namespace_type: Optional['IdNamespaceAssociationInputReferencePropertiesIdNamespaceType'] = None): + """ + :param Sequence['IdNamespaceAssociationDocument'] id_mapping_workflows_supported: Defines how ID mapping workflows are supported for this ID namespace association. + :param 'IdNamespaceAssociationInputReferencePropertiesIdNamespaceType' id_namespace_type: The ID namespace type for this ID namespace association. + """ + if id_mapping_workflows_supported is not None: + pulumi.set(__self__, "id_mapping_workflows_supported", id_mapping_workflows_supported) + if id_namespace_type is not None: + pulumi.set(__self__, "id_namespace_type", id_namespace_type) + + @property + @pulumi.getter(name="idMappingWorkflowsSupported") + def id_mapping_workflows_supported(self) -> Optional[Sequence['outputs.IdNamespaceAssociationDocument']]: + """ + Defines how ID mapping workflows are supported for this ID namespace association. + """ + return pulumi.get(self, "id_mapping_workflows_supported") + + @property + @pulumi.getter(name="idNamespaceType") + def id_namespace_type(self) -> Optional['IdNamespaceAssociationInputReferencePropertiesIdNamespaceType']: + """ + The ID namespace type for this ID namespace association. + """ + return pulumi.get(self, "id_namespace_type") + + @pulumi.output_type class MembershipPaymentConfiguration(dict): @staticmethod diff --git a/sdk/python/pulumi_aws_native/ec2/get_subnet.py b/sdk/python/pulumi_aws_native/ec2/get_subnet.py index 7c83e8891a..6e18080fba 100644 --- a/sdk/python/pulumi_aws_native/ec2/get_subnet.py +++ b/sdk/python/pulumi_aws_native/ec2/get_subnet.py @@ -62,7 +62,8 @@ def assign_ipv6_address_on_creation(self) -> Optional[bool]: @pulumi.getter(name="enableDns64") def enable_dns64(self) -> Optional[bool]: """ - Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. For more information, see [DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-nat64-dns64) in the *User Guide*. + Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. + You must first configure a NAT gateway in a public subnet (separate from the subnet containing the IPv6-only workloads). For example, the subnet containing the NAT gateway should have a ``0.0.0.0/0`` route pointing to the internet gateway. For more information, see [Configure DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/nat-gateway-nat64-dns64.html#nat-gateway-nat64-dns64-walkthrough) in the *User Guide*. """ return pulumi.get(self, "enable_dns64") diff --git a/sdk/python/pulumi_aws_native/ec2/subnet.py b/sdk/python/pulumi_aws_native/ec2/subnet.py index 27bca3954d..1a5c96838b 100644 --- a/sdk/python/pulumi_aws_native/ec2/subnet.py +++ b/sdk/python/pulumi_aws_native/ec2/subnet.py @@ -47,7 +47,8 @@ def __init__(__self__, *, :param pulumi.Input[str] availability_zone_id: The AZ ID of the subnet. :param pulumi.Input[str] cidr_block: The IPv4 CIDR block assigned to the subnet. If you update this property, we create a new subnet, and then delete the existing one. - :param pulumi.Input[bool] enable_dns64: Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. For more information, see [DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-nat64-dns64) in the *User Guide*. + :param pulumi.Input[bool] enable_dns64: Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. + You must first configure a NAT gateway in a public subnet (separate from the subnet containing the IPv6-only workloads). For example, the subnet containing the NAT gateway should have a ``0.0.0.0/0`` route pointing to the internet gateway. For more information, see [Configure DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/nat-gateway-nat64-dns64.html#nat-gateway-nat64-dns64-walkthrough) in the *User Guide*. :param pulumi.Input[int] enable_lni_at_device_index: Indicates the device position for local network interfaces in this subnet. For example, ``1`` indicates local network interfaces in this subnet are the secondary network interface (eth1). :param pulumi.Input[str] ipv4_ipam_pool_id: An IPv4 IPAM pool ID for the subnet. :param pulumi.Input[int] ipv4_netmask_length: An IPv4 netmask length for the subnet. @@ -171,7 +172,8 @@ def cidr_block(self, value: Optional[pulumi.Input[str]]): @pulumi.getter(name="enableDns64") def enable_dns64(self) -> Optional[pulumi.Input[bool]]: """ - Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. For more information, see [DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-nat64-dns64) in the *User Guide*. + Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. + You must first configure a NAT gateway in a public subnet (separate from the subnet containing the IPv6-only workloads). For example, the subnet containing the NAT gateway should have a ``0.0.0.0/0`` route pointing to the internet gateway. For more information, see [Configure DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/nat-gateway-nat64-dns64.html#nat-gateway-nat64-dns64-walkthrough) in the *User Guide*. """ return pulumi.get(self, "enable_dns64") @@ -368,7 +370,8 @@ def __init__(__self__, :param pulumi.Input[str] availability_zone_id: The AZ ID of the subnet. :param pulumi.Input[str] cidr_block: The IPv4 CIDR block assigned to the subnet. If you update this property, we create a new subnet, and then delete the existing one. - :param pulumi.Input[bool] enable_dns64: Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. For more information, see [DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-nat64-dns64) in the *User Guide*. + :param pulumi.Input[bool] enable_dns64: Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. + You must first configure a NAT gateway in a public subnet (separate from the subnet containing the IPv6-only workloads). For example, the subnet containing the NAT gateway should have a ``0.0.0.0/0`` route pointing to the internet gateway. For more information, see [Configure DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/nat-gateway-nat64-dns64.html#nat-gateway-nat64-dns64-walkthrough) in the *User Guide*. :param pulumi.Input[int] enable_lni_at_device_index: Indicates the device position for local network interfaces in this subnet. For example, ``1`` indicates local network interfaces in this subnet are the secondary network interface (eth1). :param pulumi.Input[str] ipv4_ipam_pool_id: An IPv4 IPAM pool ID for the subnet. :param pulumi.Input[int] ipv4_netmask_length: An IPv4 netmask length for the subnet. @@ -550,7 +553,8 @@ def cidr_block(self) -> pulumi.Output[Optional[str]]: @pulumi.getter(name="enableDns64") def enable_dns64(self) -> pulumi.Output[Optional[bool]]: """ - Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. For more information, see [DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-nat64-dns64) in the *User Guide*. + Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. + You must first configure a NAT gateway in a public subnet (separate from the subnet containing the IPv6-only workloads). For example, the subnet containing the NAT gateway should have a ``0.0.0.0/0`` route pointing to the internet gateway. For more information, see [Configure DNS64 and NAT64](https://docs.aws.amazon.com/vpc/latest/userguide/nat-gateway-nat64-dns64.html#nat-gateway-nat64-dns64-walkthrough) in the *User Guide*. """ return pulumi.get(self, "enable_dns64") diff --git a/sdk/python/pulumi_aws_native/redshift/_inputs.py b/sdk/python/pulumi_aws_native/redshift/_inputs.py index 77f9bb3c95..5f71486d38 100644 --- a/sdk/python/pulumi_aws_native/redshift/_inputs.py +++ b/sdk/python/pulumi_aws_native/redshift/_inputs.py @@ -60,6 +60,8 @@ def port(self, value: Optional[pulumi.Input[str]]): class ClusterLoggingPropertiesArgs: def __init__(__self__, *, bucket_name: Optional[pulumi.Input[str]] = None, + log_destination_type: Optional[pulumi.Input[str]] = None, + log_exports: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, s3_key_prefix: Optional[pulumi.Input[str]] = None): """ :param pulumi.Input[str] bucket_name: The name of an existing S3 bucket where the log files are to be stored. @@ -83,6 +85,10 @@ def __init__(__self__, *, """ if bucket_name is not None: pulumi.set(__self__, "bucket_name", bucket_name) + if log_destination_type is not None: + pulumi.set(__self__, "log_destination_type", log_destination_type) + if log_exports is not None: + pulumi.set(__self__, "log_exports", log_exports) if s3_key_prefix is not None: pulumi.set(__self__, "s3_key_prefix", s3_key_prefix) @@ -103,6 +109,24 @@ def bucket_name(self) -> Optional[pulumi.Input[str]]: def bucket_name(self, value: Optional[pulumi.Input[str]]): pulumi.set(self, "bucket_name", value) + @property + @pulumi.getter(name="logDestinationType") + def log_destination_type(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "log_destination_type") + + @log_destination_type.setter + def log_destination_type(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "log_destination_type", value) + + @property + @pulumi.getter(name="logExports") + def log_exports(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]: + return pulumi.get(self, "log_exports") + + @log_exports.setter + def log_exports(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]): + pulumi.set(self, "log_exports", value) + @property @pulumi.getter(name="s3KeyPrefix") def s3_key_prefix(self) -> Optional[pulumi.Input[str]]: diff --git a/sdk/python/pulumi_aws_native/redshift/outputs.py b/sdk/python/pulumi_aws_native/redshift/outputs.py index f9fd77d553..ac261bcb42 100644 --- a/sdk/python/pulumi_aws_native/redshift/outputs.py +++ b/sdk/python/pulumi_aws_native/redshift/outputs.py @@ -59,6 +59,10 @@ def __key_warning(key: str): suggest = None if key == "bucketName": suggest = "bucket_name" + elif key == "logDestinationType": + suggest = "log_destination_type" + elif key == "logExports": + suggest = "log_exports" elif key == "s3KeyPrefix": suggest = "s3_key_prefix" @@ -75,6 +79,8 @@ def get(self, key: str, default = None) -> Any: def __init__(__self__, *, bucket_name: Optional[str] = None, + log_destination_type: Optional[str] = None, + log_exports: Optional[Sequence[str]] = None, s3_key_prefix: Optional[str] = None): """ :param str bucket_name: The name of an existing S3 bucket where the log files are to be stored. @@ -98,6 +104,10 @@ def __init__(__self__, *, """ if bucket_name is not None: pulumi.set(__self__, "bucket_name", bucket_name) + if log_destination_type is not None: + pulumi.set(__self__, "log_destination_type", log_destination_type) + if log_exports is not None: + pulumi.set(__self__, "log_exports", log_exports) if s3_key_prefix is not None: pulumi.set(__self__, "s3_key_prefix", s3_key_prefix) @@ -114,6 +124,16 @@ def bucket_name(self) -> Optional[str]: """ return pulumi.get(self, "bucket_name") + @property + @pulumi.getter(name="logDestinationType") + def log_destination_type(self) -> Optional[str]: + return pulumi.get(self, "log_destination_type") + + @property + @pulumi.getter(name="logExports") + def log_exports(self) -> Optional[Sequence[str]]: + return pulumi.get(self, "log_exports") + @property @pulumi.getter(name="s3KeyPrefix") def s3_key_prefix(self) -> Optional[str]: diff --git a/sdk/python/pulumi_aws_native/route53resolver/_enums.py b/sdk/python/pulumi_aws_native/route53resolver/_enums.py index 1f057773ec..74d8a12c28 100644 --- a/sdk/python/pulumi_aws_native/route53resolver/_enums.py +++ b/sdk/python/pulumi_aws_native/route53resolver/_enums.py @@ -196,6 +196,7 @@ class ResolverRuleRuleType(str, Enum): FORWARD = "FORWARD" SYSTEM = "SYSTEM" RECURSIVE = "RECURSIVE" + DELEGATE = "DELEGATE" class ResolverRuleTargetAddressProtocol(str, Enum): diff --git a/sdk/python/pulumi_aws_native/route53resolver/get_resolver_rule.py b/sdk/python/pulumi_aws_native/route53resolver/get_resolver_rule.py index 02598e8a38..47f46a079c 100644 --- a/sdk/python/pulumi_aws_native/route53resolver/get_resolver_rule.py +++ b/sdk/python/pulumi_aws_native/route53resolver/get_resolver_rule.py @@ -21,10 +21,13 @@ @pulumi.output_type class GetResolverRuleResult: - def __init__(__self__, arn=None, domain_name=None, name=None, resolver_endpoint_id=None, resolver_rule_id=None, tags=None, target_ips=None): + def __init__(__self__, arn=None, delegation_record=None, domain_name=None, name=None, resolver_endpoint_id=None, resolver_rule_id=None, tags=None, target_ips=None): if arn and not isinstance(arn, str): raise TypeError("Expected argument 'arn' to be a str") pulumi.set(__self__, "arn", arn) + if delegation_record and not isinstance(delegation_record, str): + raise TypeError("Expected argument 'delegation_record' to be a str") + pulumi.set(__self__, "delegation_record", delegation_record) if domain_name and not isinstance(domain_name, str): raise TypeError("Expected argument 'domain_name' to be a str") pulumi.set(__self__, "domain_name", domain_name) @@ -52,6 +55,14 @@ def arn(self) -> Optional[str]: """ return pulumi.get(self, "arn") + @property + @pulumi.getter(name="delegationRecord") + def delegation_record(self) -> Optional[str]: + """ + The name server domain for queries to be delegated to if a query matches the delegation record. + """ + return pulumi.get(self, "delegation_record") + @property @pulumi.getter(name="domainName") def domain_name(self) -> Optional[str]: @@ -108,6 +119,7 @@ def __await__(self): yield self return GetResolverRuleResult( arn=self.arn, + delegation_record=self.delegation_record, domain_name=self.domain_name, name=self.name, resolver_endpoint_id=self.resolver_endpoint_id, @@ -131,6 +143,7 @@ def get_resolver_rule(resolver_rule_id: Optional[str] = None, return AwaitableGetResolverRuleResult( arn=pulumi.get(__ret__, 'arn'), + delegation_record=pulumi.get(__ret__, 'delegation_record'), domain_name=pulumi.get(__ret__, 'domain_name'), name=pulumi.get(__ret__, 'name'), resolver_endpoint_id=pulumi.get(__ret__, 'resolver_endpoint_id'), diff --git a/sdk/python/pulumi_aws_native/route53resolver/resolver_rule.py b/sdk/python/pulumi_aws_native/route53resolver/resolver_rule.py index 5a39b5e960..85f83f565c 100644 --- a/sdk/python/pulumi_aws_native/route53resolver/resolver_rule.py +++ b/sdk/python/pulumi_aws_native/route53resolver/resolver_rule.py @@ -19,23 +19,28 @@ @pulumi.input_type class ResolverRuleArgs: def __init__(__self__, *, - domain_name: pulumi.Input[str], rule_type: pulumi.Input['ResolverRuleRuleType'], + delegation_record: Optional[pulumi.Input[str]] = None, + domain_name: Optional[pulumi.Input[str]] = None, name: Optional[pulumi.Input[str]] = None, resolver_endpoint_id: Optional[pulumi.Input[str]] = None, tags: Optional[pulumi.Input[Sequence[pulumi.Input['_root_inputs.TagArgs']]]] = None, target_ips: Optional[pulumi.Input[Sequence[pulumi.Input['ResolverRuleTargetAddressArgs']]]] = None): """ The set of arguments for constructing a ResolverRule resource. - :param pulumi.Input[str] domain_name: DNS queries for this domain name are forwarded to the IP addresses that are specified in TargetIps :param pulumi.Input['ResolverRuleRuleType'] rule_type: When you want to forward DNS queries for specified domain name to resolvers on your network, specify FORWARD. When you have a forwarding rule to forward DNS queries for a domain to your network and you want Resolver to process queries for a subdomain of that domain, specify SYSTEM. + :param pulumi.Input[str] delegation_record: The name server domain for queries to be delegated to if a query matches the delegation record. + :param pulumi.Input[str] domain_name: DNS queries for this domain name are forwarded to the IP addresses that are specified in TargetIps :param pulumi.Input[str] name: The name for the Resolver rule :param pulumi.Input[str] resolver_endpoint_id: The ID of the endpoint that the rule is associated with. :param pulumi.Input[Sequence[pulumi.Input['_root_inputs.TagArgs']]] tags: An array of key-value pairs to apply to this resource. :param pulumi.Input[Sequence[pulumi.Input['ResolverRuleTargetAddressArgs']]] target_ips: An array that contains the IP addresses and ports that an outbound endpoint forwards DNS queries to. Typically, these are the IP addresses of DNS resolvers on your network. Specify IPv4 addresses. IPv6 is not supported. """ - pulumi.set(__self__, "domain_name", domain_name) pulumi.set(__self__, "rule_type", rule_type) + if delegation_record is not None: + pulumi.set(__self__, "delegation_record", delegation_record) + if domain_name is not None: + pulumi.set(__self__, "domain_name", domain_name) if name is not None: pulumi.set(__self__, "name", name) if resolver_endpoint_id is not None: @@ -45,18 +50,6 @@ def __init__(__self__, *, if target_ips is not None: pulumi.set(__self__, "target_ips", target_ips) - @property - @pulumi.getter(name="domainName") - def domain_name(self) -> pulumi.Input[str]: - """ - DNS queries for this domain name are forwarded to the IP addresses that are specified in TargetIps - """ - return pulumi.get(self, "domain_name") - - @domain_name.setter - def domain_name(self, value: pulumi.Input[str]): - pulumi.set(self, "domain_name", value) - @property @pulumi.getter(name="ruleType") def rule_type(self) -> pulumi.Input['ResolverRuleRuleType']: @@ -69,6 +62,30 @@ def rule_type(self) -> pulumi.Input['ResolverRuleRuleType']: def rule_type(self, value: pulumi.Input['ResolverRuleRuleType']): pulumi.set(self, "rule_type", value) + @property + @pulumi.getter(name="delegationRecord") + def delegation_record(self) -> Optional[pulumi.Input[str]]: + """ + The name server domain for queries to be delegated to if a query matches the delegation record. + """ + return pulumi.get(self, "delegation_record") + + @delegation_record.setter + def delegation_record(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "delegation_record", value) + + @property + @pulumi.getter(name="domainName") + def domain_name(self) -> Optional[pulumi.Input[str]]: + """ + DNS queries for this domain name are forwarded to the IP addresses that are specified in TargetIps + """ + return pulumi.get(self, "domain_name") + + @domain_name.setter + def domain_name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "domain_name", value) + @property @pulumi.getter def name(self) -> Optional[pulumi.Input[str]]: @@ -123,6 +140,7 @@ class ResolverRule(pulumi.CustomResource): def __init__(__self__, resource_name: str, opts: Optional[pulumi.ResourceOptions] = None, + delegation_record: Optional[pulumi.Input[str]] = None, domain_name: Optional[pulumi.Input[str]] = None, name: Optional[pulumi.Input[str]] = None, resolver_endpoint_id: Optional[pulumi.Input[str]] = None, @@ -135,6 +153,7 @@ def __init__(__self__, :param str resource_name: The name of the resource. :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[str] delegation_record: The name server domain for queries to be delegated to if a query matches the delegation record. :param pulumi.Input[str] domain_name: DNS queries for this domain name are forwarded to the IP addresses that are specified in TargetIps :param pulumi.Input[str] name: The name for the Resolver rule :param pulumi.Input[str] resolver_endpoint_id: The ID of the endpoint that the rule is associated with. @@ -166,6 +185,7 @@ def __init__(__self__, resource_name: str, *args, **kwargs): def _internal_init(__self__, resource_name: str, opts: Optional[pulumi.ResourceOptions] = None, + delegation_record: Optional[pulumi.Input[str]] = None, domain_name: Optional[pulumi.Input[str]] = None, name: Optional[pulumi.Input[str]] = None, resolver_endpoint_id: Optional[pulumi.Input[str]] = None, @@ -181,8 +201,7 @@ def _internal_init(__self__, raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') __props__ = ResolverRuleArgs.__new__(ResolverRuleArgs) - if domain_name is None and not opts.urn: - raise TypeError("Missing required property 'domain_name'") + __props__.__dict__["delegation_record"] = delegation_record __props__.__dict__["domain_name"] = domain_name __props__.__dict__["name"] = name __props__.__dict__["resolver_endpoint_id"] = resolver_endpoint_id @@ -218,6 +237,7 @@ def get(resource_name: str, __props__ = ResolverRuleArgs.__new__(ResolverRuleArgs) __props__.__dict__["arn"] = None + __props__.__dict__["delegation_record"] = None __props__.__dict__["domain_name"] = None __props__.__dict__["name"] = None __props__.__dict__["resolver_endpoint_id"] = None @@ -235,9 +255,17 @@ def arn(self) -> pulumi.Output[str]: """ return pulumi.get(self, "arn") + @property + @pulumi.getter(name="delegationRecord") + def delegation_record(self) -> pulumi.Output[Optional[str]]: + """ + The name server domain for queries to be delegated to if a query matches the delegation record. + """ + return pulumi.get(self, "delegation_record") + @property @pulumi.getter(name="domainName") - def domain_name(self) -> pulumi.Output[str]: + def domain_name(self) -> pulumi.Output[Optional[str]]: """ DNS queries for this domain name are forwarded to the IP addresses that are specified in TargetIps """