@aws-sdk/client-accessanalyzer 3.194.0 → 3.197.0

package/dist-es/endpoint/ruleset.js

@@ -0,0 +1,315 @@
+export const ruleSet = {
+    version: "1.0",
+    parameters: {
+        Region: {
+            builtIn: "AWS::Region",
+            required: false,
+            documentation: "The AWS region used to dispatch the request.",
+            type: "String",
+        },
+        UseDualStack: {
+            builtIn: "AWS::UseDualStack",
+            required: true,
+            default: false,
+            documentation: "When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.",
+            type: "Boolean",
+        },
+        UseFIPS: {
+            builtIn: "AWS::UseFIPS",
+            required: true,
+            default: false,
+            documentation: "When true, send this request to the FIPS-compliant regional endpoint. If the configured endpoint does not have a FIPS compliant endpoint, dispatching the request will return an error.",
+            type: "Boolean",
+        },
+        Endpoint: {
+            builtIn: "SDK::Endpoint",
+            required: false,
+            documentation: "Override the endpoint used to send this request",
+            type: "String",
+        },
+    },
+    rules: [
+        {
+            conditions: [
+                {
+                    fn: "aws.partition",
+                    argv: [
+                        {
+                            ref: "Region",
+                        },
+                    ],
+                    assign: "PartitionResult",
+                },
+            ],
+            type: "tree",
+            rules: [
+                {
+                    conditions: [
+                        {
+                            fn: "isSet",
+                            argv: [
+                                {
+                                    ref: "Endpoint",
+                                },
+                            ],
+                        },
+                        {
+                            fn: "parseURL",
+                            argv: [
+                                {
+                                    ref: "Endpoint",
+                                },
+                            ],
+                            assign: "url",
+                        },
+                    ],
+                    type: "tree",
+                    rules: [
+                        {
+                            conditions: [
+                                {
+                                    fn: "booleanEquals",
+                                    argv: [
+                                        {
+                                            ref: "UseFIPS",
+                                        },
+                                        true,
+                                    ],
+                                },
+                            ],
+                            error: "Invalid Configuration: FIPS and custom endpoint are not supported",
+                            type: "error",
+                        },
+                        {
+                            conditions: [],
+                            type: "tree",
+                            rules: [
+                                {
+                                    conditions: [
+                                        {
+                                            fn: "booleanEquals",
+                                            argv: [
+                                                {
+                                                    ref: "UseDualStack",
+                                                },
+                                                true,
+                                            ],
+                                        },
+                                    ],
+                                    error: "Invalid Configuration: Dualstack and custom endpoint are not supported",
+                                    type: "error",
+                                },
+                                {
+                                    conditions: [],
+                                    endpoint: {
+                                        url: {
+                                            ref: "Endpoint",
+                                        },
+                                        properties: {},
+                                        headers: {},
+                                    },
+                                    type: "endpoint",
+                                },
+                            ],
+                        },
+                    ],
+                },
+                {
+                    conditions: [
+                        {
+                            fn: "booleanEquals",
+                            argv: [
+                                {
+                                    ref: "UseFIPS",
+                                },
+                                true,
+                            ],
+                        },
+                        {
+                            fn: "booleanEquals",
+                            argv: [
+                                {
+                                    ref: "UseDualStack",
+                                },
+                                true,
+                            ],
+                        },
+                    ],
+                    type: "tree",
+                    rules: [
+                        {
+                            conditions: [
+                                {
+                                    fn: "booleanEquals",
+                                    argv: [
+                                        true,
+                                        {
+                                            fn: "getAttr",
+                                            argv: [
+                                                {
+                                                    ref: "PartitionResult",
+                                                },
+                                                "supportsFIPS",
+                                            ],
+                                        },
+                                    ],
+                                },
+                                {
+                                    fn: "booleanEquals",
+                                    argv: [
+                                        true,
+                                        {
+                                            fn: "getAttr",
+                                            argv: [
+                                                {
+                                                    ref: "PartitionResult",
+                                                },
+                                                "supportsDualStack",
+                                            ],
+                                        },
+                                    ],
+                                },
+                            ],
+                            type: "tree",
+                            rules: [
+                                {
+                                    conditions: [],
+                                    endpoint: {
+                                        url: "https://access-analyzer-fips.{Region}.{PartitionResult#dualStackDnsSuffix}",
+                                        properties: {},
+                                        headers: {},
+                                    },
+                                    type: "endpoint",
+                                },
+                            ],
+                        },
+                        {
+                            conditions: [],
+                            error: "FIPS and DualStack are enabled, but this partition does not support one or both",
+                            type: "error",
+                        },
+                    ],
+                },
+                {
+                    conditions: [
+                        {
+                            fn: "booleanEquals",
+                            argv: [
+                                {
+                                    ref: "UseFIPS",
+                                },
+                                true,
+                            ],
+                        },
+                    ],
+                    type: "tree",
+                    rules: [
+                        {
+                            conditions: [
+                                {
+                                    fn: "booleanEquals",
+                                    argv: [
+                                        true,
+                                        {
+                                            fn: "getAttr",
+                                            argv: [
+                                                {
+                                                    ref: "PartitionResult",
+                                                },
+                                                "supportsFIPS",
+                                            ],
+                                        },
+                                    ],
+                                },
+                            ],
+                            type: "tree",
+                            rules: [
+                                {
+                                    conditions: [],
+                                    type: "tree",
+                                    rules: [
+                                        {
+                                            conditions: [],
+                                            endpoint: {
+                                                url: "https://access-analyzer-fips.{Region}.{PartitionResult#dnsSuffix}",
+                                                properties: {},
+                                                headers: {},
+                                            },
+                                            type: "endpoint",
+                                        },
+                                    ],
+                                },
+                            ],
+                        },
+                        {
+                            conditions: [],
+                            error: "FIPS is enabled but this partition does not support FIPS",
+                            type: "error",
+                        },
+                    ],
+                },
+                {
+                    conditions: [
+                        {
+                            fn: "booleanEquals",
+                            argv: [
+                                {
+                                    ref: "UseDualStack",
+                                },
+                                true,
+                            ],
+                        },
+                    ],
+                    type: "tree",
+                    rules: [
+                        {
+                            conditions: [
+                                {
+                                    fn: "booleanEquals",
+                                    argv: [
+                                        true,
+                                        {
+                                            fn: "getAttr",
+                                            argv: [
+                                                {
+                                                    ref: "PartitionResult",
+                                                },
+                                                "supportsDualStack",
+                                            ],
+                                        },
+                                    ],
+                                },
+                            ],
+                            type: "tree",
+                            rules: [
+                                {
+                                    conditions: [],
+                                    endpoint: {
+                                        url: "https://access-analyzer.{Region}.{PartitionResult#dualStackDnsSuffix}",
+                                        properties: {},
+                                        headers: {},
+                                    },
+                                    type: "endpoint",
+                                },
+                            ],
+                        },
+                        {
+                            conditions: [],
+                            error: "DualStack is enabled but this partition does not support DualStack",
+                            type: "error",
+                        },
+                    ],
+                },
+                {
+                    conditions: [],
+                    endpoint: {
+                        url: "https://access-analyzer.{Region}.{PartitionResult#dnsSuffix}",
+                        properties: {},
+                        headers: {},
+                    },
+                    type: "endpoint",
+                },
+            ],
+        },
+    ],
+};

package/dist-es/models/models_0.js

@@ -121,6 +121,22 @@ export var KmsGrantOperation;
     KmsGrantOperation["SIGN"] = "Sign";
     KmsGrantOperation["VERIFY"] = "Verify";
 })(KmsGrantOperation || (KmsGrantOperation = {}));
+export var RdsDbClusterSnapshotAttributeValue;
+(function (RdsDbClusterSnapshotAttributeValue) {
+    RdsDbClusterSnapshotAttributeValue.visit = (value, visitor) => {
+        if (value.accountIds !== undefined)
+            return visitor.accountIds(value.accountIds);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(RdsDbClusterSnapshotAttributeValue || (RdsDbClusterSnapshotAttributeValue = {}));
+export var RdsDbSnapshotAttributeValue;
+(function (RdsDbSnapshotAttributeValue) {
+    RdsDbSnapshotAttributeValue.visit = (value, visitor) => {
+        if (value.accountIds !== undefined)
+            return visitor.accountIds(value.accountIds);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(RdsDbSnapshotAttributeValue || (RdsDbSnapshotAttributeValue = {}));
 export var NetworkOriginConfiguration;
 (function (NetworkOriginConfiguration) {
     NetworkOriginConfiguration.visit = (value, visitor) => {
@@ -152,14 +168,26 @@ export var AclPermission;
 export var Configuration;
 (function (Configuration) {
     Configuration.visit = (value, visitor) => {
+        if (value.ebsSnapshot !== undefined)
+            return visitor.ebsSnapshot(value.ebsSnapshot);
+        if (value.ecrRepository !== undefined)
+            return visitor.ecrRepository(value.ecrRepository);
         if (value.iamRole !== undefined)
             return visitor.iamRole(value.iamRole);
+        if (value.efsFileSystem !== undefined)
+            return visitor.efsFileSystem(value.efsFileSystem);
         if (value.kmsKey !== undefined)
             return visitor.kmsKey(value.kmsKey);
+        if (value.rdsDbClusterSnapshot !== undefined)
+            return visitor.rdsDbClusterSnapshot(value.rdsDbClusterSnapshot);
+        if (value.rdsDbSnapshot !== undefined)
+            return visitor.rdsDbSnapshot(value.rdsDbSnapshot);
         if (value.secretsManagerSecret !== undefined)
             return visitor.secretsManagerSecret(value.secretsManagerSecret);
         if (value.s3Bucket !== undefined)
             return visitor.s3Bucket(value.s3Bucket);
+        if (value.snsTopic !== undefined)
+            return visitor.snsTopic(value.snsTopic);
         if (value.sqsQueue !== undefined)
             return visitor.sqsQueue(value.sqsQueue);
         return visitor._(value.$unknown[0], value.$unknown[1]);
@@ -313,6 +341,15 @@ export const CancelPolicyGenerationRequestFilterSensitiveLog = (obj) => ({
 export const CancelPolicyGenerationResponseFilterSensitiveLog = (obj) => ({
     ...obj,
 });
+export const EbsSnapshotConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const EcrRepositoryConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const EfsFileSystemConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
 export const IamRoleConfigurationFilterSensitiveLog = (obj) => ({
     ...obj,
 });
@@ -325,6 +362,36 @@ export const KmsGrantConfigurationFilterSensitiveLog = (obj) => ({
 export const KmsKeyConfigurationFilterSensitiveLog = (obj) => ({
     ...obj,
 });
+export const RdsDbClusterSnapshotAttributeValueFilterSensitiveLog = (obj) => {
+    if (obj.accountIds !== undefined)
+        return { accountIds: obj.accountIds };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const RdsDbClusterSnapshotConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.attributes && {
+        attributes: Object.entries(obj.attributes).reduce((acc, [key, value]) => ({
+            ...acc,
+            [key]: RdsDbClusterSnapshotAttributeValueFilterSensitiveLog(value),
+        }), {}),
+    }),
+});
+export const RdsDbSnapshotAttributeValueFilterSensitiveLog = (obj) => {
+    if (obj.accountIds !== undefined)
+        return { accountIds: obj.accountIds };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const RdsDbSnapshotConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.attributes && {
+        attributes: Object.entries(obj.attributes).reduce((acc, [key, value]) => ({
+            ...acc,
+            [key]: RdsDbSnapshotAttributeValueFilterSensitiveLog(value),
+        }), {}),
+    }),
+});
 export const InternetConfigurationFilterSensitiveLog = (obj) => ({
     ...obj,
 });
@@ -373,18 +440,33 @@ export const S3BucketConfigurationFilterSensitiveLog = (obj) => ({
 export const SecretsManagerSecretConfigurationFilterSensitiveLog = (obj) => ({
     ...obj,
 });
+export const SnsTopicConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
 export const SqsQueueConfigurationFilterSensitiveLog = (obj) => ({
     ...obj,
 });
 export const ConfigurationFilterSensitiveLog = (obj) => {
+    if (obj.ebsSnapshot !== undefined)
+        return { ebsSnapshot: EbsSnapshotConfigurationFilterSensitiveLog(obj.ebsSnapshot) };
+    if (obj.ecrRepository !== undefined)
+        return { ecrRepository: EcrRepositoryConfigurationFilterSensitiveLog(obj.ecrRepository) };
     if (obj.iamRole !== undefined)
         return { iamRole: IamRoleConfigurationFilterSensitiveLog(obj.iamRole) };
+    if (obj.efsFileSystem !== undefined)
+        return { efsFileSystem: EfsFileSystemConfigurationFilterSensitiveLog(obj.efsFileSystem) };
     if (obj.kmsKey !== undefined)
         return { kmsKey: KmsKeyConfigurationFilterSensitiveLog(obj.kmsKey) };
+    if (obj.rdsDbClusterSnapshot !== undefined)
+        return { rdsDbClusterSnapshot: RdsDbClusterSnapshotConfigurationFilterSensitiveLog(obj.rdsDbClusterSnapshot) };
+    if (obj.rdsDbSnapshot !== undefined)
+        return { rdsDbSnapshot: RdsDbSnapshotConfigurationFilterSensitiveLog(obj.rdsDbSnapshot) };
     if (obj.secretsManagerSecret !== undefined)
         return { secretsManagerSecret: SecretsManagerSecretConfigurationFilterSensitiveLog(obj.secretsManagerSecret) };
     if (obj.s3Bucket !== undefined)
         return { s3Bucket: S3BucketConfigurationFilterSensitiveLog(obj.s3Bucket) };
+    if (obj.snsTopic !== undefined)
+        return { snsTopic: SnsTopicConfigurationFilterSensitiveLog(obj.snsTopic) };
     if (obj.sqsQueue !== undefined)
         return { sqsQueue: SqsQueueConfigurationFilterSensitiveLog(obj.sqsQueue) };
     if (obj.$unknown !== undefined)