@cdk_utils/iam 1.29.0 → 1.30.0

package/lib/generated/services/network-security-manager.js

@@ -0,0 +1,778 @@
+"use strict";
+var _a, _b, _c, _d;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkSecurityManagerConditions = exports.NetworkSecurityManagerOperations = exports.NetworkSecurityManagerResources = exports.NetworkSecurityManagerActions = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// =============================================================================
+// AUTO-GENERATED FILE — DO NOT EDIT MANUALLY
+// Generated from AWS Service Authorization Reference data
+// Source: data/service-reference/network-security-manager.json
+// Run `npx projen generate-constants` to regenerate
+// =============================================================================
+/**
+ * IAM action constants for the network-security-manager service.
+ */
+class NetworkSecurityManagerActions {
+}
+exports.NetworkSecurityManagerActions = NetworkSecurityManagerActions;
+_a = JSII_RTTI_SYMBOL_1;
+NetworkSecurityManagerActions[_a] = { fqn: "@cdk_utils/iam.network_security_manager.NetworkSecurityManagerActions", version: "1.30.0" };
+/** The IAM service prefix. */
+NetworkSecurityManagerActions.SERVICE_PREFIX = "network-security-manager";
+/** [Write] network-security-manager:CreateDeployment */
+NetworkSecurityManagerActions.CreateDeployment = "network-security-manager:CreateDeployment";
+/** [Write] network-security-manager:CreateDeploymentSnapshot */
+NetworkSecurityManagerActions.CreateDeploymentSnapshot = "network-security-manager:CreateDeploymentSnapshot";
+/** [Write] network-security-manager:CreatePolicy */
+NetworkSecurityManagerActions.CreatePolicy = "network-security-manager:CreatePolicy";
+/** [Write] network-security-manager:CreatePolicySnapshot */
+NetworkSecurityManagerActions.CreatePolicySnapshot = "network-security-manager:CreatePolicySnapshot";
+/** [Write] network-security-manager:CreateRule */
+NetworkSecurityManagerActions.CreateRule = "network-security-manager:CreateRule";
+/** [Write] network-security-manager:CreateRuleSnapshot */
+NetworkSecurityManagerActions.CreateRuleSnapshot = "network-security-manager:CreateRuleSnapshot";
+/** [Write] network-security-manager:CreateScope */
+NetworkSecurityManagerActions.CreateScope = "network-security-manager:CreateScope";
+/** [Write] network-security-manager:CreateScopeSnapshot */
+NetworkSecurityManagerActions.CreateScopeSnapshot = "network-security-manager:CreateScopeSnapshot";
+/** [Write] network-security-manager:CreateTemplate */
+NetworkSecurityManagerActions.CreateTemplate = "network-security-manager:CreateTemplate";
+/** [Write] network-security-manager:CreateTemplateSnapshot */
+NetworkSecurityManagerActions.CreateTemplateSnapshot = "network-security-manager:CreateTemplateSnapshot";
+/** [Write] network-security-manager:DeleteAdminAccount */
+NetworkSecurityManagerActions.DeleteAdminAccount = "network-security-manager:DeleteAdminAccount";
+/** [Write] network-security-manager:DeleteDeployment */
+NetworkSecurityManagerActions.DeleteDeployment = "network-security-manager:DeleteDeployment";
+/** [Write] network-security-manager:DeletePolicy */
+NetworkSecurityManagerActions.DeletePolicy = "network-security-manager:DeletePolicy";
+/** [Write] network-security-manager:DeleteRule */
+NetworkSecurityManagerActions.DeleteRule = "network-security-manager:DeleteRule";
+/** [Write] network-security-manager:DeleteScope */
+NetworkSecurityManagerActions.DeleteScope = "network-security-manager:DeleteScope";
+/** [Write] network-security-manager:DeleteTemplate */
+NetworkSecurityManagerActions.DeleteTemplate = "network-security-manager:DeleteTemplate";
+/** [Write] network-security-manager:GenerateRuleConfiguration */
+NetworkSecurityManagerActions.GenerateRuleConfiguration = "network-security-manager:GenerateRuleConfiguration";
+/** [Read] network-security-manager:GetAdminAccount */
+NetworkSecurityManagerActions.actionGetAdminAccount = "network-security-manager:GetAdminAccount";
+/** [Read] network-security-manager:GetDeployment */
+NetworkSecurityManagerActions.actionGetDeployment = "network-security-manager:GetDeployment";
+/** [Read] network-security-manager:GetPolicy */
+NetworkSecurityManagerActions.actionGetPolicy = "network-security-manager:GetPolicy";
+/** [Read] network-security-manager:GetRule */
+NetworkSecurityManagerActions.actionGetRule = "network-security-manager:GetRule";
+/** [Read] network-security-manager:GetScope */
+NetworkSecurityManagerActions.actionGetScope = "network-security-manager:GetScope";
+/** [Read] network-security-manager:GetTemplate */
+NetworkSecurityManagerActions.actionGetTemplate = "network-security-manager:GetTemplate";
+/** [List] network-security-manager:ListAdminAccounts */
+NetworkSecurityManagerActions.ListAdminAccounts = "network-security-manager:ListAdminAccounts";
+/** [Read] network-security-manager:ListAggregateResourceSynchronizationStatuses */
+NetworkSecurityManagerActions.ListAggregateResourceSynchronizationStatuses = "network-security-manager:ListAggregateResourceSynchronizationStatuses";
+/** [Read] network-security-manager:ListDeploymentSnapshots */
+NetworkSecurityManagerActions.ListDeploymentSnapshots = "network-security-manager:ListDeploymentSnapshots";
+/** [List] network-security-manager:ListDeployments */
+NetworkSecurityManagerActions.ListDeployments = "network-security-manager:ListDeployments";
+/** [List] network-security-manager:ListPolicies */
+NetworkSecurityManagerActions.ListPolicies = "network-security-manager:ListPolicies";
+/** [Read] network-security-manager:ListPolicySnapshots */
+NetworkSecurityManagerActions.ListPolicySnapshots = "network-security-manager:ListPolicySnapshots";
+/** [Read] network-security-manager:ListResourceAssociations */
+NetworkSecurityManagerActions.ListResourceAssociations = "network-security-manager:ListResourceAssociations";
+/** [Read] network-security-manager:ListResourceSynchronizationStatuses */
+NetworkSecurityManagerActions.ListResourceSynchronizationStatuses = "network-security-manager:ListResourceSynchronizationStatuses";
+/** [Read] network-security-manager:ListRuleSnapshots */
+NetworkSecurityManagerActions.ListRuleSnapshots = "network-security-manager:ListRuleSnapshots";
+/** [List] network-security-manager:ListRules */
+NetworkSecurityManagerActions.ListRules = "network-security-manager:ListRules";
+/** [Read] network-security-manager:ListScopeSnapshots */
+NetworkSecurityManagerActions.ListScopeSnapshots = "network-security-manager:ListScopeSnapshots";
+/** [List] network-security-manager:ListScopes */
+NetworkSecurityManagerActions.ListScopes = "network-security-manager:ListScopes";
+/** [Read] network-security-manager:ListTagsForResource */
+NetworkSecurityManagerActions.ListTagsForResource = "network-security-manager:ListTagsForResource";
+/** [Read] network-security-manager:ListTemplateSnapshots */
+NetworkSecurityManagerActions.ListTemplateSnapshots = "network-security-manager:ListTemplateSnapshots";
+/** [List] network-security-manager:ListTemplates */
+NetworkSecurityManagerActions.ListTemplates = "network-security-manager:ListTemplates";
+/** [Write] network-security-manager:PutAdminAccount */
+NetworkSecurityManagerActions.PutAdminAccount = "network-security-manager:PutAdminAccount";
+/** [Tagging] network-security-manager:TagResource */
+NetworkSecurityManagerActions.TagResource = "network-security-manager:TagResource";
+/** [Tagging] network-security-manager:UntagResource */
+NetworkSecurityManagerActions.UntagResource = "network-security-manager:UntagResource";
+/** [Write] network-security-manager:UpdateDeployment */
+NetworkSecurityManagerActions.UpdateDeployment = "network-security-manager:UpdateDeployment";
+/** [Write] network-security-manager:UpdatePolicy */
+NetworkSecurityManagerActions.UpdatePolicy = "network-security-manager:UpdatePolicy";
+/** [Write] network-security-manager:UpdateRule */
+NetworkSecurityManagerActions.UpdateRule = "network-security-manager:UpdateRule";
+/** [Write] network-security-manager:UpdateScope */
+NetworkSecurityManagerActions.UpdateScope = "network-security-manager:UpdateScope";
+/** [Write] network-security-manager:UpdateTemplate */
+NetworkSecurityManagerActions.UpdateTemplate = "network-security-manager:UpdateTemplate";
+/** All read-level actions. */
+NetworkSecurityManagerActions.AllReadActions = [
+    NetworkSecurityManagerActions.actionGetAdminAccount,
+    NetworkSecurityManagerActions.actionGetDeployment,
+    NetworkSecurityManagerActions.actionGetPolicy,
+    NetworkSecurityManagerActions.actionGetRule,
+    NetworkSecurityManagerActions.actionGetScope,
+    NetworkSecurityManagerActions.actionGetTemplate,
+    NetworkSecurityManagerActions.ListAggregateResourceSynchronizationStatuses,
+    NetworkSecurityManagerActions.ListDeploymentSnapshots,
+    NetworkSecurityManagerActions.ListPolicySnapshots,
+    NetworkSecurityManagerActions.ListResourceAssociations,
+    NetworkSecurityManagerActions.ListResourceSynchronizationStatuses,
+    NetworkSecurityManagerActions.ListRuleSnapshots,
+    NetworkSecurityManagerActions.ListScopeSnapshots,
+    NetworkSecurityManagerActions.ListTagsForResource,
+    NetworkSecurityManagerActions.ListTemplateSnapshots,
+];
+/** All write-level actions. */
+NetworkSecurityManagerActions.AllWriteActions = [
+    NetworkSecurityManagerActions.CreateDeployment,
+    NetworkSecurityManagerActions.CreateDeploymentSnapshot,
+    NetworkSecurityManagerActions.CreatePolicy,
+    NetworkSecurityManagerActions.CreatePolicySnapshot,
+    NetworkSecurityManagerActions.CreateRule,
+    NetworkSecurityManagerActions.CreateRuleSnapshot,
+    NetworkSecurityManagerActions.CreateScope,
+    NetworkSecurityManagerActions.CreateScopeSnapshot,
+    NetworkSecurityManagerActions.CreateTemplate,
+    NetworkSecurityManagerActions.CreateTemplateSnapshot,
+    NetworkSecurityManagerActions.DeleteAdminAccount,
+    NetworkSecurityManagerActions.DeleteDeployment,
+    NetworkSecurityManagerActions.DeletePolicy,
+    NetworkSecurityManagerActions.DeleteRule,
+    NetworkSecurityManagerActions.DeleteScope,
+    NetworkSecurityManagerActions.DeleteTemplate,
+    NetworkSecurityManagerActions.GenerateRuleConfiguration,
+    NetworkSecurityManagerActions.PutAdminAccount,
+    NetworkSecurityManagerActions.UpdateDeployment,
+    NetworkSecurityManagerActions.UpdatePolicy,
+    NetworkSecurityManagerActions.UpdateRule,
+    NetworkSecurityManagerActions.UpdateScope,
+    NetworkSecurityManagerActions.UpdateTemplate,
+];
+/** All list-level actions. */
+NetworkSecurityManagerActions.AllListActions = [
+    NetworkSecurityManagerActions.ListAdminAccounts,
+    NetworkSecurityManagerActions.ListDeployments,
+    NetworkSecurityManagerActions.ListPolicies,
+    NetworkSecurityManagerActions.ListRules,
+    NetworkSecurityManagerActions.ListScopes,
+    NetworkSecurityManagerActions.ListTemplates,
+];
+/** All permission-management-level actions. */
+NetworkSecurityManagerActions.AllPermissionManagementActions = [];
+/** All tagging-level actions. */
+NetworkSecurityManagerActions.AllTaggingActions = [
+    NetworkSecurityManagerActions.TagResource,
+    NetworkSecurityManagerActions.UntagResource,
+];
+const DeploymentArnRegex = /^arn:(?<partition>[^:]+):network-security-manager:(?<region>[^:]*):(?<account>[^:]*):deployment:(?<deploymentId>[^:/?]+)$/;
+const DeploymentSnapshotArnRegex = /^arn:(?<partition>[^:]+):network-security-manager:(?<region>[^:]*):(?<account>[^:]*):deployment:(?<deploymentId>[^:/?]+):(?<versionNumber>[^:/?]+)$/;
+const PolicyArnRegex = /^arn:(?<partition>[^:]+):network-security-manager:(?<region>[^:]*):(?<account>[^:]*):policy:(?<policyId>[^:/?]+)$/;
+const PolicySnapshotArnRegex = /^arn:(?<partition>[^:]+):network-security-manager:(?<region>[^:]*):(?<account>[^:]*):policy:(?<policyId>[^:/?]+):(?<versionNumber>[^:/?]+)$/;
+const RuleArnRegex = /^arn:(?<partition>[^:]+):network-security-manager:(?<region>[^:]*):(?<account>[^:]*):rule:(?<ruleId>[^:/?]+)$/;
+const RuleSnapshotArnRegex = /^arn:(?<partition>[^:]+):network-security-manager:(?<region>[^:]*):(?<account>[^:]*):rule:(?<ruleId>[^:/?]+):(?<versionNumber>[^:/?]+)$/;
+const ScopeArnRegex = /^arn:(?<partition>[^:]+):network-security-manager:(?<region>[^:]*):(?<account>[^:]*):scope:(?<scopeId>[^:/?]+)$/;
+const ScopeSnapshotArnRegex = /^arn:(?<partition>[^:]+):network-security-manager:(?<region>[^:]*):(?<account>[^:]*):scope:(?<scopeId>[^:/?]+):(?<versionNumber>[^:/?]+)$/;
+const TemplateArnRegex = /^arn:(?<partition>[^:]+):network-security-manager:(?<region>[^:]*):(?<account>[^:]*):template:(?<templateId>[^:/?]+)$/;
+const TemplateSnapshotArnRegex = /^arn:(?<partition>[^:]+):network-security-manager:(?<region>[^:]*):(?<account>[^:]*):template:(?<templateId>[^:/?]+):(?<versionNumber>[^:/?]+)$/;
+/**
+ * ARN builders, validators, and parsers for network-security-manager resources.
+ */
+class NetworkSecurityManagerResources {
+    /**
+     * Builds an ARN for the deployment resource.
+     */
+    static deployment(props) {
+        return `arn:${props.partition ?? "aws"}:network-security-manager:${props.region ?? "*"}:${props.account ?? "*"}:deployment:${props.deploymentId}`;
+    }
+    /**
+     * Validates whether a string is a valid ARN for the deployment resource.
+     */
+    static isValidDeploymentArn(arn) {
+        return DeploymentArnRegex.test(arn);
+    }
+    /**
+     * Parses a deployment ARN into its components.
+     * @throws Error if the ARN does not match the expected format.
+     */
+    static parseDeploymentArn(arn) {
+        const match = DeploymentArnRegex.exec(arn);
+        if (!match?.groups) {
+            throw new Error(`Invalid deployment ARN: ${arn}`);
+        }
+        return {
+            partition: match.groups.partition,
+            region: match.groups.region,
+            account: match.groups.account,
+            deploymentId: match.groups.deploymentId,
+        };
+    }
+    /**
+     * Builds an ARN for the deployment-snapshot resource.
+     */
+    static deploymentSnapshot(props) {
+        return `arn:${props.partition ?? "aws"}:network-security-manager:${props.region ?? "*"}:${props.account ?? "*"}:deployment:${props.deploymentId}:${props.versionNumber}`;
+    }
+    /**
+     * Validates whether a string is a valid ARN for the deployment-snapshot resource.
+     */
+    static isValidDeploymentSnapshotArn(arn) {
+        return DeploymentSnapshotArnRegex.test(arn);
+    }
+    /**
+     * Parses a deployment-snapshot ARN into its components.
+     * @throws Error if the ARN does not match the expected format.
+     */
+    static parseDeploymentSnapshotArn(arn) {
+        const match = DeploymentSnapshotArnRegex.exec(arn);
+        if (!match?.groups) {
+            throw new Error(`Invalid deployment-snapshot ARN: ${arn}`);
+        }
+        return {
+            partition: match.groups.partition,
+            region: match.groups.region,
+            account: match.groups.account,
+            deploymentId: match.groups.deploymentId,
+            versionNumber: match.groups.versionNumber,
+        };
+    }
+    /**
+     * Builds an ARN for the policy resource.
+     */
+    static policy(props) {
+        return `arn:${props.partition ?? "aws"}:network-security-manager:${props.region ?? "*"}:${props.account ?? "*"}:policy:${props.policyId}`;
+    }
+    /**
+     * Validates whether a string is a valid ARN for the policy resource.
+     */
+    static isValidPolicyArn(arn) {
+        return PolicyArnRegex.test(arn);
+    }
+    /**
+     * Parses a policy ARN into its components.
+     * @throws Error if the ARN does not match the expected format.
+     */
+    static parsePolicyArn(arn) {
+        const match = PolicyArnRegex.exec(arn);
+        if (!match?.groups) {
+            throw new Error(`Invalid policy ARN: ${arn}`);
+        }
+        return {
+            partition: match.groups.partition,
+            region: match.groups.region,
+            account: match.groups.account,
+            policyId: match.groups.policyId,
+        };
+    }
+    /**
+     * Builds an ARN for the policy-snapshot resource.
+     */
+    static policySnapshot(props) {
+        return `arn:${props.partition ?? "aws"}:network-security-manager:${props.region ?? "*"}:${props.account ?? "*"}:policy:${props.policyId}:${props.versionNumber}`;
+    }
+    /**
+     * Validates whether a string is a valid ARN for the policy-snapshot resource.
+     */
+    static isValidPolicySnapshotArn(arn) {
+        return PolicySnapshotArnRegex.test(arn);
+    }
+    /**
+     * Parses a policy-snapshot ARN into its components.
+     * @throws Error if the ARN does not match the expected format.
+     */
+    static parsePolicySnapshotArn(arn) {
+        const match = PolicySnapshotArnRegex.exec(arn);
+        if (!match?.groups) {
+            throw new Error(`Invalid policy-snapshot ARN: ${arn}`);
+        }
+        return {
+            partition: match.groups.partition,
+            region: match.groups.region,
+            account: match.groups.account,
+            policyId: match.groups.policyId,
+            versionNumber: match.groups.versionNumber,
+        };
+    }
+    /**
+     * Builds an ARN for the rule resource.
+     */
+    static rule(props) {
+        return `arn:${props.partition ?? "aws"}:network-security-manager:${props.region ?? "*"}:${props.account ?? "*"}:rule:${props.ruleId}`;
+    }
+    /**
+     * Validates whether a string is a valid ARN for the rule resource.
+     */
+    static isValidRuleArn(arn) {
+        return RuleArnRegex.test(arn);
+    }
+    /**
+     * Parses a rule ARN into its components.
+     * @throws Error if the ARN does not match the expected format.
+     */
+    static parseRuleArn(arn) {
+        const match = RuleArnRegex.exec(arn);
+        if (!match?.groups) {
+            throw new Error(`Invalid rule ARN: ${arn}`);
+        }
+        return {
+            partition: match.groups.partition,
+            region: match.groups.region,
+            account: match.groups.account,
+            ruleId: match.groups.ruleId,
+        };
+    }
+    /**
+     * Builds an ARN for the rule-snapshot resource.
+     */
+    static ruleSnapshot(props) {
+        return `arn:${props.partition ?? "aws"}:network-security-manager:${props.region ?? "*"}:${props.account ?? "*"}:rule:${props.ruleId}:${props.versionNumber}`;
+    }
+    /**
+     * Validates whether a string is a valid ARN for the rule-snapshot resource.
+     */
+    static isValidRuleSnapshotArn(arn) {
+        return RuleSnapshotArnRegex.test(arn);
+    }
+    /**
+     * Parses a rule-snapshot ARN into its components.
+     * @throws Error if the ARN does not match the expected format.
+     */
+    static parseRuleSnapshotArn(arn) {
+        const match = RuleSnapshotArnRegex.exec(arn);
+        if (!match?.groups) {
+            throw new Error(`Invalid rule-snapshot ARN: ${arn}`);
+        }
+        return {
+            partition: match.groups.partition,
+            region: match.groups.region,
+            account: match.groups.account,
+            ruleId: match.groups.ruleId,
+            versionNumber: match.groups.versionNumber,
+        };
+    }
+    /**
+     * Builds an ARN for the scope resource.
+     */
+    static scope(props) {
+        return `arn:${props.partition ?? "aws"}:network-security-manager:${props.region ?? "*"}:${props.account ?? "*"}:scope:${props.scopeId}`;
+    }
+    /**
+     * Validates whether a string is a valid ARN for the scope resource.
+     */
+    static isValidScopeArn(arn) {
+        return ScopeArnRegex.test(arn);
+    }
+    /**
+     * Parses a scope ARN into its components.
+     * @throws Error if the ARN does not match the expected format.
+     */
+    static parseScopeArn(arn) {
+        const match = ScopeArnRegex.exec(arn);
+        if (!match?.groups) {
+            throw new Error(`Invalid scope ARN: ${arn}`);
+        }
+        return {
+            partition: match.groups.partition,
+            region: match.groups.region,
+            account: match.groups.account,
+            scopeId: match.groups.scopeId,
+        };
+    }
+    /**
+     * Builds an ARN for the scope-snapshot resource.
+     */
+    static scopeSnapshot(props) {
+        return `arn:${props.partition ?? "aws"}:network-security-manager:${props.region ?? "*"}:${props.account ?? "*"}:scope:${props.scopeId}:${props.versionNumber}`;
+    }
+    /**
+     * Validates whether a string is a valid ARN for the scope-snapshot resource.
+     */
+    static isValidScopeSnapshotArn(arn) {
+        return ScopeSnapshotArnRegex.test(arn);
+    }
+    /**
+     * Parses a scope-snapshot ARN into its components.
+     * @throws Error if the ARN does not match the expected format.
+     */
+    static parseScopeSnapshotArn(arn) {
+        const match = ScopeSnapshotArnRegex.exec(arn);
+        if (!match?.groups) {
+            throw new Error(`Invalid scope-snapshot ARN: ${arn}`);
+        }
+        return {
+            partition: match.groups.partition,
+            region: match.groups.region,
+            account: match.groups.account,
+            scopeId: match.groups.scopeId,
+            versionNumber: match.groups.versionNumber,
+        };
+    }
+    /**
+     * Builds an ARN for the template resource.
+     */
+    static template(props) {
+        return `arn:${props.partition ?? "aws"}:network-security-manager:${props.region ?? "*"}:${props.account ?? "*"}:template:${props.templateId}`;
+    }
+    /**
+     * Validates whether a string is a valid ARN for the template resource.
+     */
+    static isValidTemplateArn(arn) {
+        return TemplateArnRegex.test(arn);
+    }
+    /**
+     * Parses a template ARN into its components.
+     * @throws Error if the ARN does not match the expected format.
+     */
+    static parseTemplateArn(arn) {
+        const match = TemplateArnRegex.exec(arn);
+        if (!match?.groups) {
+            throw new Error(`Invalid template ARN: ${arn}`);
+        }
+        return {
+            partition: match.groups.partition,
+            region: match.groups.region,
+            account: match.groups.account,
+            templateId: match.groups.templateId,
+        };
+    }
+    /**
+     * Builds an ARN for the template-snapshot resource.
+     */
+    static templateSnapshot(props) {
+        return `arn:${props.partition ?? "aws"}:network-security-manager:${props.region ?? "*"}:${props.account ?? "*"}:template:${props.templateId}:${props.versionNumber}`;
+    }
+    /**
+     * Validates whether a string is a valid ARN for the template-snapshot resource.
+     */
+    static isValidTemplateSnapshotArn(arn) {
+        return TemplateSnapshotArnRegex.test(arn);
+    }
+    /**
+     * Parses a template-snapshot ARN into its components.
+     * @throws Error if the ARN does not match the expected format.
+     */
+    static parseTemplateSnapshotArn(arn) {
+        const match = TemplateSnapshotArnRegex.exec(arn);
+        if (!match?.groups) {
+            throw new Error(`Invalid template-snapshot ARN: ${arn}`);
+        }
+        return {
+            partition: match.groups.partition,
+            region: match.groups.region,
+            account: match.groups.account,
+            templateId: match.groups.templateId,
+            versionNumber: match.groups.versionNumber,
+        };
+    }
+}
+exports.NetworkSecurityManagerResources = NetworkSecurityManagerResources;
+_b = JSII_RTTI_SYMBOL_1;
+NetworkSecurityManagerResources[_b] = { fqn: "@cdk_utils/iam.network_security_manager.NetworkSecurityManagerResources", version: "1.30.0" };
+/**
+ * API operation to required IAM actions mapping for network-security-manager.
+ */
+class NetworkSecurityManagerOperations {
+}
+exports.NetworkSecurityManagerOperations = NetworkSecurityManagerOperations;
+_c = JSII_RTTI_SYMBOL_1;
+NetworkSecurityManagerOperations[_c] = { fqn: "@cdk_utils/iam.network_security_manager.NetworkSecurityManagerOperations", version: "1.30.0" };
+/** IAM actions required for the CreateDeployment API call. */
+NetworkSecurityManagerOperations.CreateDeployment = [
+    "network-security-manager:CreateDeployment",
+    "network-security-manager:TagResource",
+];
+/** IAM actions required for the CreateDeploymentSnapshot API call. */
+NetworkSecurityManagerOperations.CreateDeploymentSnapshot = [
+    "network-security-manager:CreateDeploymentSnapshot",
+    "network-security-manager:TagResource",
+];
+/** IAM actions required for the CreatePolicy API call. */
+NetworkSecurityManagerOperations.CreatePolicy = [
+    "network-security-manager:CreatePolicy",
+    "network-security-manager:TagResource",
+];
+/** IAM actions required for the CreatePolicySnapshot API call. */
+NetworkSecurityManagerOperations.CreatePolicySnapshot = [
+    "network-security-manager:CreatePolicySnapshot",
+    "network-security-manager:TagResource",
+];
+/** IAM actions required for the CreateRule API call. */
+NetworkSecurityManagerOperations.CreateRule = [
+    "network-security-manager:CreateRule",
+    "network-security-manager:TagResource",
+];
+/** IAM actions required for the CreateRuleSnapshot API call. */
+NetworkSecurityManagerOperations.CreateRuleSnapshot = [
+    "network-security-manager:CreateRuleSnapshot",
+    "network-security-manager:TagResource",
+];
+/** IAM actions required for the CreateScope API call. */
+NetworkSecurityManagerOperations.CreateScope = [
+    "network-security-manager:CreateScope",
+    "network-security-manager:TagResource",
+];
+/** IAM actions required for the CreateScopeSnapshot API call. */
+NetworkSecurityManagerOperations.CreateScopeSnapshot = [
+    "network-security-manager:CreateScopeSnapshot",
+    "network-security-manager:TagResource",
+];
+/** IAM actions required for the CreateTemplate API call. */
+NetworkSecurityManagerOperations.CreateTemplate = [
+    "network-security-manager:CreateTemplate",
+    "network-security-manager:TagResource",
+];
+/** IAM actions required for the CreateTemplateSnapshot API call. */
+NetworkSecurityManagerOperations.CreateTemplateSnapshot = [
+    "network-security-manager:CreateTemplateSnapshot",
+    "network-security-manager:TagResource",
+];
+/** IAM actions required for the DeleteAdminAccount API call. */
+NetworkSecurityManagerOperations.DeleteAdminAccount = [
+    "network-security-manager:DeleteAdminAccount",
+];
+/** IAM actions required for the DeleteDeployment API call. */
+NetworkSecurityManagerOperations.DeleteDeployment = [
+    "network-security-manager:DeleteDeployment",
+];
+/** IAM actions required for the DeletePolicy API call. */
+NetworkSecurityManagerOperations.DeletePolicy = [
+    "network-security-manager:DeletePolicy",
+];
+/** IAM actions required for the DeleteRule API call. */
+NetworkSecurityManagerOperations.DeleteRule = [
+    "network-security-manager:DeleteRule",
+];
+/** IAM actions required for the DeleteScope API call. */
+NetworkSecurityManagerOperations.DeleteScope = [
+    "network-security-manager:DeleteScope",
+];
+/** IAM actions required for the DeleteTemplate API call. */
+NetworkSecurityManagerOperations.DeleteTemplate = [
+    "network-security-manager:DeleteTemplate",
+];
+/** IAM actions required for the GenerateRuleConfiguration API call. */
+NetworkSecurityManagerOperations.GenerateRuleConfiguration = [
+    "network-security-manager:GenerateRuleConfiguration",
+];
+/** IAM actions required for the GetAdminAccount API call. */
+NetworkSecurityManagerOperations.opGetAdminAccount = [
+    "network-security-manager:GetAdminAccount",
+];
+/** IAM actions required for the GetDeployment API call. */
+NetworkSecurityManagerOperations.opGetDeployment = [
+    "network-security-manager:GetDeployment",
+];
+/** IAM actions required for the GetPolicy API call. */
+NetworkSecurityManagerOperations.opGetPolicy = [
+    "network-security-manager:GetPolicy",
+];
+/** IAM actions required for the GetRule API call. */
+NetworkSecurityManagerOperations.opGetRule = ["network-security-manager:GetRule"];
+/** IAM actions required for the GetScope API call. */
+NetworkSecurityManagerOperations.opGetScope = ["network-security-manager:GetScope"];
+/** IAM actions required for the GetTemplate API call. */
+NetworkSecurityManagerOperations.opGetTemplate = [
+    "network-security-manager:GetTemplate",
+];
+/** IAM actions required for the ListAdminAccounts API call. */
+NetworkSecurityManagerOperations.ListAdminAccounts = [
+    "network-security-manager:ListAdminAccounts",
+];
+/** IAM actions required for the ListAggregateResourceSynchronizationStatuses API call. */
+NetworkSecurityManagerOperations.ListAggregateResourceSynchronizationStatuses = [
+    "network-security-manager:ListAggregateResourceSynchronizationStatuses",
+];
+/** IAM actions required for the ListDeploymentSnapshots API call. */
+NetworkSecurityManagerOperations.ListDeploymentSnapshots = [
+    "network-security-manager:ListDeploymentSnapshots",
+];
+/** IAM actions required for the ListDeployments API call. */
+NetworkSecurityManagerOperations.ListDeployments = [
+    "network-security-manager:ListDeployments",
+];
+/** IAM actions required for the ListPolicies API call. */
+NetworkSecurityManagerOperations.ListPolicies = [
+    "network-security-manager:ListPolicies",
+];
+/** IAM actions required for the ListPolicySnapshots API call. */
+NetworkSecurityManagerOperations.ListPolicySnapshots = [
+    "network-security-manager:ListPolicySnapshots",
+];
+/** IAM actions required for the ListResourceAssociations API call. */
+NetworkSecurityManagerOperations.ListResourceAssociations = [
+    "network-security-manager:ListResourceAssociations",
+];
+/** IAM actions required for the ListResourceSynchronizationStatuses API call. */
+NetworkSecurityManagerOperations.ListResourceSynchronizationStatuses = [
+    "network-security-manager:ListResourceSynchronizationStatuses",
+];
+/** IAM actions required for the ListRuleSnapshots API call. */
+NetworkSecurityManagerOperations.ListRuleSnapshots = [
+    "network-security-manager:ListRuleSnapshots",
+];
+/** IAM actions required for the ListRules API call. */
+NetworkSecurityManagerOperations.ListRules = ["network-security-manager:ListRules"];
+/** IAM actions required for the ListScopeSnapshots API call. */
+NetworkSecurityManagerOperations.ListScopeSnapshots = [
+    "network-security-manager:ListScopeSnapshots",
+];
+/** IAM actions required for the ListScopes API call. */
+NetworkSecurityManagerOperations.ListScopes = [
+    "network-security-manager:ListScopes",
+];
+/** IAM actions required for the ListTagsForResource API call. */
+NetworkSecurityManagerOperations.ListTagsForResource = [
+    "network-security-manager:ListTagsForResource",
+];
+/** IAM actions required for the ListTemplateSnapshots API call. */
+NetworkSecurityManagerOperations.ListTemplateSnapshots = [
+    "network-security-manager:ListTemplateSnapshots",
+];
+/** IAM actions required for the ListTemplates API call. */
+NetworkSecurityManagerOperations.ListTemplates = [
+    "network-security-manager:ListTemplates",
+];
+/** IAM actions required for the PutAdminAccount API call. */
+NetworkSecurityManagerOperations.PutAdminAccount = [
+    "network-security-manager:PutAdminAccount",
+];
+/** IAM actions required for the TagResource API call. */
+NetworkSecurityManagerOperations.TagResource = [
+    "network-security-manager:TagResource",
+];
+/** IAM actions required for the UntagResource API call. */
+NetworkSecurityManagerOperations.UntagResource = [
+    "network-security-manager:UntagResource",
+];
+/** IAM actions required for the UpdateDeployment API call. */
+NetworkSecurityManagerOperations.UpdateDeployment = [
+    "network-security-manager:UpdateDeployment",
+];
+/** IAM actions required for the UpdatePolicy API call. */
+NetworkSecurityManagerOperations.UpdatePolicy = [
+    "network-security-manager:UpdatePolicy",
+];
+/** IAM actions required for the UpdateRule API call. */
+NetworkSecurityManagerOperations.UpdateRule = [
+    "network-security-manager:UpdateRule",
+];
+/** IAM actions required for the UpdateScope API call. */
+NetworkSecurityManagerOperations.UpdateScope = [
+    "network-security-manager:UpdateScope",
+];
+/** IAM actions required for the UpdateTemplate API call. */
+NetworkSecurityManagerOperations.UpdateTemplate = [
+    "network-security-manager:UpdateTemplate",
+];
+/**
+ * Condition key constants and builders for network-security-manager.
+ */
+class NetworkSecurityManagerConditions {
+    /**
+     * Generates a condition block for `aws:RequestTag/${TagKey}`.
+     */
+    static requestTag(value) {
+        return { StringEquals: { "aws:RequestTag/${TagKey}": value } };
+    }
+    /**
+     * Generates a condition block for `aws:ResourceTag/${TagKey}`.
+     */
+    static resourceTag(value) {
+        return { StringEquals: { "aws:ResourceTag/${TagKey}": value } };
+    }
+    /**
+     * Generates a condition block for `aws:TagKeys`.
+     */
+    static tagKeys(values) {
+        return { "ForAllValues:StringEquals": { "aws:TagKeys": values } };
+    }
+}
+exports.NetworkSecurityManagerConditions = NetworkSecurityManagerConditions;
+_d = JSII_RTTI_SYMBOL_1;
+NetworkSecurityManagerConditions[_d] = { fqn: "@cdk_utils/iam.network_security_manager.NetworkSecurityManagerConditions", version: "1.30.0" };
+/** Condition keys applicable to the CreateDeployment action. */
+NetworkSecurityManagerConditions.CreateDeploymentConditionKeys = [
+    "aws:RequestTag/${TagKey}",
+    "aws:TagKeys",
+];
+/** Condition keys applicable to the CreateDeploymentSnapshot action. */
+NetworkSecurityManagerConditions.CreateDeploymentSnapshotConditionKeys = [
+    "aws:RequestTag/${TagKey}",
+    "aws:TagKeys",
+];
+/** Condition keys applicable to the CreatePolicy action. */
+NetworkSecurityManagerConditions.CreatePolicyConditionKeys = [
+    "aws:RequestTag/${TagKey}",
+    "aws:TagKeys",
+];
+/** Condition keys applicable to the CreatePolicySnapshot action. */
+NetworkSecurityManagerConditions.CreatePolicySnapshotConditionKeys = [
+    "aws:RequestTag/${TagKey}",
+    "aws:TagKeys",
+];
+/** Condition keys applicable to the CreateRule action. */
+NetworkSecurityManagerConditions.CreateRuleConditionKeys = [
+    "aws:RequestTag/${TagKey}",
+    "aws:TagKeys",
+];
+/** Condition keys applicable to the CreateRuleSnapshot action. */
+NetworkSecurityManagerConditions.CreateRuleSnapshotConditionKeys = [
+    "aws:RequestTag/${TagKey}",
+    "aws:TagKeys",
+];
+/** Condition keys applicable to the CreateScope action. */
+NetworkSecurityManagerConditions.CreateScopeConditionKeys = [
+    "aws:RequestTag/${TagKey}",
+    "aws:TagKeys",
+];
+/** Condition keys applicable to the CreateScopeSnapshot action. */
+NetworkSecurityManagerConditions.CreateScopeSnapshotConditionKeys = [
+    "aws:RequestTag/${TagKey}",
+    "aws:TagKeys",
+];
+/** Condition keys applicable to the CreateTemplate action. */
+NetworkSecurityManagerConditions.CreateTemplateConditionKeys = [
+    "aws:RequestTag/${TagKey}",
+    "aws:TagKeys",
+];
+/** Condition keys applicable to the CreateTemplateSnapshot action. */
+NetworkSecurityManagerConditions.CreateTemplateSnapshotConditionKeys = [
+    "aws:RequestTag/${TagKey}",
+    "aws:TagKeys",
+];
+/** Condition keys applicable to the ListResourceAssociations action. */
+NetworkSecurityManagerConditions.ListResourceAssociationsConditionKeys = [
+    "aws:ResourceTag/${TagKey}",
+];
+/** Condition keys applicable to the ListResourceSynchronizationStatuses action. */
+NetworkSecurityManagerConditions.ListResourceSynchronizationStatusesConditionKeys = [
+    "aws:ResourceTag/${TagKey}",
+];
+/** Condition keys applicable to the ListTagsForResource action. */
+NetworkSecurityManagerConditions.ListTagsForResourceConditionKeys = [
+    "aws:ResourceTag/${TagKey}",
+];
+/** Condition keys applicable to the TagResource action. */
+NetworkSecurityManagerConditions.TagResourceConditionKeys = [
+    "aws:RequestTag/${TagKey}",
+    "aws:ResourceTag/${TagKey}",
+    "aws:TagKeys",
+];
+/** Condition keys applicable to the UntagResource action. */
+NetworkSecurityManagerConditions.UntagResourceConditionKeys = [
+    "aws:ResourceTag/${TagKey}",
+    "aws:TagKeys",
+];
+/** Condition key: aws:RequestTag/${TagKey} (String) */
+NetworkSecurityManagerConditions.AWS_REQUEST_TAG = "aws:RequestTag/${TagKey}";
+/** Condition key: aws:ResourceTag/${TagKey} (String) */
+NetworkSecurityManagerConditions.AWS_RESOURCE_TAG = "aws:ResourceTag/${TagKey}";
+/** Condition key: aws:TagKeys (ArrayOfString) */
+NetworkSecurityManagerConditions.AWS_TAG_KEYS = "aws:TagKeys";
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"network-security-manager.js","sourceRoot":"","sources":["../../../src/generated/services/network-security-manager.ts"],"names":[],"mappings":"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","sourcesContent":["// =============================================================================\n// AUTO-GENERATED FILE — DO NOT EDIT MANUALLY\n// Generated from AWS Service Authorization Reference data\n// Source: data/service-reference/network-security-manager.json\n// Run `npx projen generate-constants` to regenerate\n// =============================================================================\n\n/**\n * IAM action constants for the network-security-manager service.\n */\nexport class NetworkSecurityManagerActions {\n\t/** The IAM service prefix. */\n\tstatic readonly SERVICE_PREFIX = \"network-security-manager\";\n\n\t/** [Write] network-security-manager:CreateDeployment */\n\tstatic readonly CreateDeployment =\n\t\t\"network-security-manager:CreateDeployment\";\n\t/** [Write] network-security-manager:CreateDeploymentSnapshot */\n\tstatic readonly CreateDeploymentSnapshot =\n\t\t\"network-security-manager:CreateDeploymentSnapshot\";\n\t/** [Write] network-security-manager:CreatePolicy */\n\tstatic readonly CreatePolicy = \"network-security-manager:CreatePolicy\";\n\t/** [Write] network-security-manager:CreatePolicySnapshot */\n\tstatic readonly CreatePolicySnapshot =\n\t\t\"network-security-manager:CreatePolicySnapshot\";\n\t/** [Write] network-security-manager:CreateRule */\n\tstatic readonly CreateRule = \"network-security-manager:CreateRule\";\n\t/** [Write] network-security-manager:CreateRuleSnapshot */\n\tstatic readonly CreateRuleSnapshot =\n\t\t\"network-security-manager:CreateRuleSnapshot\";\n\t/** [Write] network-security-manager:CreateScope */\n\tstatic readonly CreateScope = \"network-security-manager:CreateScope\";\n\t/** [Write] network-security-manager:CreateScopeSnapshot */\n\tstatic readonly CreateScopeSnapshot =\n\t\t\"network-security-manager:CreateScopeSnapshot\";\n\t/** [Write] network-security-manager:CreateTemplate */\n\tstatic readonly CreateTemplate = \"network-security-manager:CreateTemplate\";\n\t/** [Write] network-security-manager:CreateTemplateSnapshot */\n\tstatic readonly CreateTemplateSnapshot =\n\t\t\"network-security-manager:CreateTemplateSnapshot\";\n\t/** [Write] network-security-manager:DeleteAdminAccount */\n\tstatic readonly DeleteAdminAccount =\n\t\t\"network-security-manager:DeleteAdminAccount\";\n\t/** [Write] network-security-manager:DeleteDeployment */\n\tstatic readonly DeleteDeployment =\n\t\t\"network-security-manager:DeleteDeployment\";\n\t/** [Write] network-security-manager:DeletePolicy */\n\tstatic readonly DeletePolicy = \"network-security-manager:DeletePolicy\";\n\t/** [Write] network-security-manager:DeleteRule */\n\tstatic readonly DeleteRule = \"network-security-manager:DeleteRule\";\n\t/** [Write] network-security-manager:DeleteScope */\n\tstatic readonly DeleteScope = \"network-security-manager:DeleteScope\";\n\t/** [Write] network-security-manager:DeleteTemplate */\n\tstatic readonly DeleteTemplate = \"network-security-manager:DeleteTemplate\";\n\t/** [Write] network-security-manager:GenerateRuleConfiguration */\n\tstatic readonly GenerateRuleConfiguration =\n\t\t\"network-security-manager:GenerateRuleConfiguration\";\n\t/** [Read] network-security-manager:GetAdminAccount */\n\tstatic readonly actionGetAdminAccount =\n\t\t\"network-security-manager:GetAdminAccount\";\n\t/** [Read] network-security-manager:GetDeployment */\n\tstatic readonly actionGetDeployment =\n\t\t\"network-security-manager:GetDeployment\";\n\t/** [Read] network-security-manager:GetPolicy */\n\tstatic readonly actionGetPolicy = \"network-security-manager:GetPolicy\";\n\t/** [Read] network-security-manager:GetRule */\n\tstatic readonly actionGetRule = \"network-security-manager:GetRule\";\n\t/** [Read] network-security-manager:GetScope */\n\tstatic readonly actionGetScope = \"network-security-manager:GetScope\";\n\t/** [Read] network-security-manager:GetTemplate */\n\tstatic readonly actionGetTemplate = \"network-security-manager:GetTemplate\";\n\t/** [List] network-security-manager:ListAdminAccounts */\n\tstatic readonly ListAdminAccounts =\n\t\t\"network-security-manager:ListAdminAccounts\";\n\t/** [Read] network-security-manager:ListAggregateResourceSynchronizationStatuses */\n\tstatic readonly ListAggregateResourceSynchronizationStatuses =\n\t\t\"network-security-manager:ListAggregateResourceSynchronizationStatuses\";\n\t/** [Read] network-security-manager:ListDeploymentSnapshots */\n\tstatic readonly ListDeploymentSnapshots =\n\t\t\"network-security-manager:ListDeploymentSnapshots\";\n\t/** [List] network-security-manager:ListDeployments */\n\tstatic readonly ListDeployments = \"network-security-manager:ListDeployments\";\n\t/** [List] network-security-manager:ListPolicies */\n\tstatic readonly ListPolicies = \"network-security-manager:ListPolicies\";\n\t/** [Read] network-security-manager:ListPolicySnapshots */\n\tstatic readonly ListPolicySnapshots =\n\t\t\"network-security-manager:ListPolicySnapshots\";\n\t/** [Read] network-security-manager:ListResourceAssociations */\n\tstatic readonly ListResourceAssociations =\n\t\t\"network-security-manager:ListResourceAssociations\";\n\t/** [Read] network-security-manager:ListResourceSynchronizationStatuses */\n\tstatic readonly ListResourceSynchronizationStatuses =\n\t\t\"network-security-manager:ListResourceSynchronizationStatuses\";\n\t/** [Read] network-security-manager:ListRuleSnapshots */\n\tstatic readonly ListRuleSnapshots =\n\t\t\"network-security-manager:ListRuleSnapshots\";\n\t/** [List] network-security-manager:ListRules */\n\tstatic readonly ListRules = \"network-security-manager:ListRules\";\n\t/** [Read] network-security-manager:ListScopeSnapshots */\n\tstatic readonly ListScopeSnapshots =\n\t\t\"network-security-manager:ListScopeSnapshots\";\n\t/** [List] network-security-manager:ListScopes */\n\tstatic readonly ListScopes = \"network-security-manager:ListScopes\";\n\t/** [Read] network-security-manager:ListTagsForResource */\n\tstatic readonly ListTagsForResource =\n\t\t\"network-security-manager:ListTagsForResource\";\n\t/** [Read] network-security-manager:ListTemplateSnapshots */\n\tstatic readonly ListTemplateSnapshots =\n\t\t\"network-security-manager:ListTemplateSnapshots\";\n\t/** [List] network-security-manager:ListTemplates */\n\tstatic readonly ListTemplates = \"network-security-manager:ListTemplates\";\n\t/** [Write] network-security-manager:PutAdminAccount */\n\tstatic readonly PutAdminAccount = \"network-security-manager:PutAdminAccount\";\n\t/** [Tagging] network-security-manager:TagResource */\n\tstatic readonly TagResource = \"network-security-manager:TagResource\";\n\t/** [Tagging] network-security-manager:UntagResource */\n\tstatic readonly UntagResource = \"network-security-manager:UntagResource\";\n\t/** [Write] network-security-manager:UpdateDeployment */\n\tstatic readonly UpdateDeployment =\n\t\t\"network-security-manager:UpdateDeployment\";\n\t/** [Write] network-security-manager:UpdatePolicy */\n\tstatic readonly UpdatePolicy = \"network-security-manager:UpdatePolicy\";\n\t/** [Write] network-security-manager:UpdateRule */\n\tstatic readonly UpdateRule = \"network-security-manager:UpdateRule\";\n\t/** [Write] network-security-manager:UpdateScope */\n\tstatic readonly UpdateScope = \"network-security-manager:UpdateScope\";\n\t/** [Write] network-security-manager:UpdateTemplate */\n\tstatic readonly UpdateTemplate = \"network-security-manager:UpdateTemplate\";\n\n\t/** All read-level actions. */\n\tstatic readonly AllReadActions: string[] = [\n\t\tNetworkSecurityManagerActions.actionGetAdminAccount,\n\t\tNetworkSecurityManagerActions.actionGetDeployment,\n\t\tNetworkSecurityManagerActions.actionGetPolicy,\n\t\tNetworkSecurityManagerActions.actionGetRule,\n\t\tNetworkSecurityManagerActions.actionGetScope,\n\t\tNetworkSecurityManagerActions.actionGetTemplate,\n\t\tNetworkSecurityManagerActions.ListAggregateResourceSynchronizationStatuses,\n\t\tNetworkSecurityManagerActions.ListDeploymentSnapshots,\n\t\tNetworkSecurityManagerActions.ListPolicySnapshots,\n\t\tNetworkSecurityManagerActions.ListResourceAssociations,\n\t\tNetworkSecurityManagerActions.ListResourceSynchronizationStatuses,\n\t\tNetworkSecurityManagerActions.ListRuleSnapshots,\n\t\tNetworkSecurityManagerActions.ListScopeSnapshots,\n\t\tNetworkSecurityManagerActions.ListTagsForResource,\n\t\tNetworkSecurityManagerActions.ListTemplateSnapshots,\n\t];\n\t/** All write-level actions. */\n\tstatic readonly AllWriteActions: string[] = [\n\t\tNetworkSecurityManagerActions.CreateDeployment,\n\t\tNetworkSecurityManagerActions.CreateDeploymentSnapshot,\n\t\tNetworkSecurityManagerActions.CreatePolicy,\n\t\tNetworkSecurityManagerActions.CreatePolicySnapshot,\n\t\tNetworkSecurityManagerActions.CreateRule,\n\t\tNetworkSecurityManagerActions.CreateRuleSnapshot,\n\t\tNetworkSecurityManagerActions.CreateScope,\n\t\tNetworkSecurityManagerActions.CreateScopeSnapshot,\n\t\tNetworkSecurityManagerActions.CreateTemplate,\n\t\tNetworkSecurityManagerActions.CreateTemplateSnapshot,\n\t\tNetworkSecurityManagerActions.DeleteAdminAccount,\n\t\tNetworkSecurityManagerActions.DeleteDeployment,\n\t\tNetworkSecurityManagerActions.DeletePolicy,\n\t\tNetworkSecurityManagerActions.DeleteRule,\n\t\tNetworkSecurityManagerActions.DeleteScope,\n\t\tNetworkSecurityManagerActions.DeleteTemplate,\n\t\tNetworkSecurityManagerActions.GenerateRuleConfiguration,\n\t\tNetworkSecurityManagerActions.PutAdminAccount,\n\t\tNetworkSecurityManagerActions.UpdateDeployment,\n\t\tNetworkSecurityManagerActions.UpdatePolicy,\n\t\tNetworkSecurityManagerActions.UpdateRule,\n\t\tNetworkSecurityManagerActions.UpdateScope,\n\t\tNetworkSecurityManagerActions.UpdateTemplate,\n\t];\n\t/** All list-level actions. */\n\tstatic readonly AllListActions: string[] = [\n\t\tNetworkSecurityManagerActions.ListAdminAccounts,\n\t\tNetworkSecurityManagerActions.ListDeployments,\n\t\tNetworkSecurityManagerActions.ListPolicies,\n\t\tNetworkSecurityManagerActions.ListRules,\n\t\tNetworkSecurityManagerActions.ListScopes,\n\t\tNetworkSecurityManagerActions.ListTemplates,\n\t];\n\t/** All permission-management-level actions. */\n\tstatic readonly AllPermissionManagementActions: string[] = [];\n\t/** All tagging-level actions. */\n\tstatic readonly AllTaggingActions: string[] = [\n\t\tNetworkSecurityManagerActions.TagResource,\n\t\tNetworkSecurityManagerActions.UntagResource,\n\t];\n}\n\n/**\n * Properties for building a deployment ARN.\n */\nexport interface NetworkSecurityManagerDeploymentArnProps {\n\t/** The DeploymentId component of the ARN. */\n\treadonly deploymentId: string;\n\t/** AWS region. Defaults to \"*\". */\n\treadonly region?: string;\n\t/** AWS account ID. Defaults to \"*\". */\n\treadonly account?: string;\n\t/** AWS partition. Defaults to \"aws\". */\n\treadonly partition?: string;\n}\n\n/**\n * Parsed components of a deployment ARN.\n */\nexport interface NetworkSecurityManagerDeploymentArnComponents {\n\t/** AWS partition. */\n\treadonly partition: string;\n\t/** AWS region. */\n\treadonly region: string;\n\t/** AWS account ID. */\n\treadonly account: string;\n\t/** The DeploymentId component. */\n\treadonly deploymentId: string;\n}\n\n/**\n * Properties for building a deployment-snapshot ARN.\n */\nexport interface NetworkSecurityManagerDeploymentSnapshotArnProps {\n\t/** The DeploymentId component of the ARN. */\n\treadonly deploymentId: string;\n\t/** The VersionNumber component of the ARN. */\n\treadonly versionNumber: string;\n\t/** AWS region. Defaults to \"*\". */\n\treadonly region?: string;\n\t/** AWS account ID. Defaults to \"*\". */\n\treadonly account?: string;\n\t/** AWS partition. Defaults to \"aws\". */\n\treadonly partition?: string;\n}\n\n/**\n * Parsed components of a deployment-snapshot ARN.\n */\nexport interface NetworkSecurityManagerDeploymentSnapshotArnComponents {\n\t/** AWS partition. */\n\treadonly partition: string;\n\t/** AWS region. */\n\treadonly region: string;\n\t/** AWS account ID. */\n\treadonly account: string;\n\t/** The DeploymentId component. */\n\treadonly deploymentId: string;\n\t/** The VersionNumber component. */\n\treadonly versionNumber: string;\n}\n\n/**\n * Properties for building a policy ARN.\n */\nexport interface NetworkSecurityManagerPolicyArnProps {\n\t/** The PolicyId component of the ARN. */\n\treadonly policyId: string;\n\t/** AWS region. Defaults to \"*\". */\n\treadonly region?: string;\n\t/** AWS account ID. Defaults to \"*\". */\n\treadonly account?: string;\n\t/** AWS partition. Defaults to \"aws\". */\n\treadonly partition?: string;\n}\n\n/**\n * Parsed components of a policy ARN.\n */\nexport interface NetworkSecurityManagerPolicyArnComponents {\n\t/** AWS partition. */\n\treadonly partition: string;\n\t/** AWS region. */\n\treadonly region: string;\n\t/** AWS account ID. */\n\treadonly account: string;\n\t/** The PolicyId component. */\n\treadonly policyId: string;\n}\n\n/**\n * Properties for building a policy-snapshot ARN.\n */\nexport interface NetworkSecurityManagerPolicySnapshotArnProps {\n\t/** The PolicyId component of the ARN. */\n\treadonly policyId: string;\n\t/** The VersionNumber component of the ARN. */\n\treadonly versionNumber: string;\n\t/** AWS region. Defaults to \"*\". */\n\treadonly region?: string;\n\t/** AWS account ID. Defaults to \"*\". */\n\treadonly account?: string;\n\t/** AWS partition. Defaults to \"aws\". */\n\treadonly partition?: string;\n}\n\n/**\n * Parsed components of a policy-snapshot ARN.\n */\nexport interface NetworkSecurityManagerPolicySnapshotArnComponents {\n\t/** AWS partition. */\n\treadonly partition: string;\n\t/** AWS region. */\n\treadonly region: string;\n\t/** AWS account ID. */\n\treadonly account: string;\n\t/** The PolicyId component. */\n\treadonly policyId: string;\n\t/** The VersionNumber component. */\n\treadonly versionNumber: string;\n}\n\n/**\n * Properties for building a rule ARN.\n */\nexport interface NetworkSecurityManagerRuleArnProps {\n\t/** The RuleId component of the ARN. */\n\treadonly ruleId: string;\n\t/** AWS region. Defaults to \"*\". */\n\treadonly region?: string;\n\t/** AWS account ID. Defaults to \"*\". */\n\treadonly account?: string;\n\t/** AWS partition. Defaults to \"aws\". */\n\treadonly partition?: string;\n}\n\n/**\n * Parsed components of a rule ARN.\n */\nexport interface NetworkSecurityManagerRuleArnComponents {\n\t/** AWS partition. */\n\treadonly partition: string;\n\t/** AWS region. */\n\treadonly region: string;\n\t/** AWS account ID. */\n\treadonly account: string;\n\t/** The RuleId component. */\n\treadonly ruleId: string;\n}\n\n/**\n * Properties for building a rule-snapshot ARN.\n */\nexport interface NetworkSecurityManagerRuleSnapshotArnProps {\n\t/** The RuleId component of the ARN. */\n\treadonly ruleId: string;\n\t/** The VersionNumber component of the ARN. */\n\treadonly versionNumber: string;\n\t/** AWS region. Defaults to \"*\". */\n\treadonly region?: string;\n\t/** AWS account ID. Defaults to \"*\". */\n\treadonly account?: string;\n\t/** AWS partition. Defaults to \"aws\". */\n\treadonly partition?: string;\n}\n\n/**\n * Parsed components of a rule-snapshot ARN.\n */\nexport interface NetworkSecurityManagerRuleSnapshotArnComponents {\n\t/** AWS partition. */\n\treadonly partition: string;\n\t/** AWS region. */\n\treadonly region: string;\n\t/** AWS account ID. */\n\treadonly account: string;\n\t/** The RuleId component. */\n\treadonly ruleId: string;\n\t/** The VersionNumber component. */\n\treadonly versionNumber: string;\n}\n\n/**\n * Properties for building a scope ARN.\n */\nexport interface NetworkSecurityManagerScopeArnProps {\n\t/** The ScopeId component of the ARN. */\n\treadonly scopeId: string;\n\t/** AWS region. Defaults to \"*\". */\n\treadonly region?: string;\n\t/** AWS account ID. Defaults to \"*\". */\n\treadonly account?: string;\n\t/** AWS partition. Defaults to \"aws\". */\n\treadonly partition?: string;\n}\n\n/**\n * Parsed components of a scope ARN.\n */\nexport interface NetworkSecurityManagerScopeArnComponents {\n\t/** AWS partition. */\n\treadonly partition: string;\n\t/** AWS region. */\n\treadonly region: string;\n\t/** AWS account ID. */\n\treadonly account: string;\n\t/** The ScopeId component. */\n\treadonly scopeId: string;\n}\n\n/**\n * Properties for building a scope-snapshot ARN.\n */\nexport interface NetworkSecurityManagerScopeSnapshotArnProps {\n\t/** The ScopeId component of the ARN. */\n\treadonly scopeId: string;\n\t/** The VersionNumber component of the ARN. */\n\treadonly versionNumber: string;\n\t/** AWS region. Defaults to \"*\". */\n\treadonly region?: string;\n\t/** AWS account ID. Defaults to \"*\". */\n\treadonly account?: string;\n\t/** AWS partition. Defaults to \"aws\". */\n\treadonly partition?: string;\n}\n\n/**\n * Parsed components of a scope-snapshot ARN.\n */\nexport interface NetworkSecurityManagerScopeSnapshotArnComponents {\n\t/** AWS partition. */\n\treadonly partition: string;\n\t/** AWS region. */\n\treadonly region: string;\n\t/** AWS account ID. */\n\treadonly account: string;\n\t/** The ScopeId component. */\n\treadonly scopeId: string;\n\t/** The VersionNumber component. */\n\treadonly versionNumber: string;\n}\n\n/**\n * Properties for building a template ARN.\n */\nexport interface NetworkSecurityManagerTemplateArnProps {\n\t/** The TemplateId component of the ARN. */\n\treadonly templateId: string;\n\t/** AWS region. Defaults to \"*\". */\n\treadonly region?: string;\n\t/** AWS account ID. Defaults to \"*\". */\n\treadonly account?: string;\n\t/** AWS partition. Defaults to \"aws\". */\n\treadonly partition?: string;\n}\n\n/**\n * Parsed components of a template ARN.\n */\nexport interface NetworkSecurityManagerTemplateArnComponents {\n\t/** AWS partition. */\n\treadonly partition: string;\n\t/** AWS region. */\n\treadonly region: string;\n\t/** AWS account ID. */\n\treadonly account: string;\n\t/** The TemplateId component. */\n\treadonly templateId: string;\n}\n\n/**\n * Properties for building a template-snapshot ARN.\n */\nexport interface NetworkSecurityManagerTemplateSnapshotArnProps {\n\t/** The TemplateId component of the ARN. */\n\treadonly templateId: string;\n\t/** The VersionNumber component of the ARN. */\n\treadonly versionNumber: string;\n\t/** AWS region. Defaults to \"*\". */\n\treadonly region?: string;\n\t/** AWS account ID. Defaults to \"*\". */\n\treadonly account?: string;\n\t/** AWS partition. Defaults to \"aws\". */\n\treadonly partition?: string;\n}\n\n/**\n * Parsed components of a template-snapshot ARN.\n */\nexport interface NetworkSecurityManagerTemplateSnapshotArnComponents {\n\t/** AWS partition. */\n\treadonly partition: string;\n\t/** AWS region. */\n\treadonly region: string;\n\t/** AWS account ID. */\n\treadonly account: string;\n\t/** The TemplateId component. */\n\treadonly templateId: string;\n\t/** The VersionNumber component. */\n\treadonly versionNumber: string;\n}\n\nconst DeploymentArnRegex =\n\t/^arn:(?<partition>[^:]+):network-security-manager:(?<region>[^:]*):(?<account>[^:]*):deployment:(?<deploymentId>[^:/?]+)$/;\nconst DeploymentSnapshotArnRegex =\n\t/^arn:(?<partition>[^:]+):network-security-manager:(?<region>[^:]*):(?<account>[^:]*):deployment:(?<deploymentId>[^:/?]+):(?<versionNumber>[^:/?]+)$/;\nconst PolicyArnRegex =\n\t/^arn:(?<partition>[^:]+):network-security-manager:(?<region>[^:]*):(?<account>[^:]*):policy:(?<policyId>[^:/?]+)$/;\nconst PolicySnapshotArnRegex =\n\t/^arn:(?<partition>[^:]+):network-security-manager:(?<region>[^:]*):(?<account>[^:]*):policy:(?<policyId>[^:/?]+):(?<versionNumber>[^:/?]+)$/;\nconst RuleArnRegex =\n\t/^arn:(?<partition>[^:]+):network-security-manager:(?<region>[^:]*):(?<account>[^:]*):rule:(?<ruleId>[^:/?]+)$/;\nconst RuleSnapshotArnRegex =\n\t/^arn:(?<partition>[^:]+):network-security-manager:(?<region>[^:]*):(?<account>[^:]*):rule:(?<ruleId>[^:/?]+):(?<versionNumber>[^:/?]+)$/;\nconst ScopeArnRegex =\n\t/^arn:(?<partition>[^:]+):network-security-manager:(?<region>[^:]*):(?<account>[^:]*):scope:(?<scopeId>[^:/?]+)$/;\nconst ScopeSnapshotArnRegex =\n\t/^arn:(?<partition>[^:]+):network-security-manager:(?<region>[^:]*):(?<account>[^:]*):scope:(?<scopeId>[^:/?]+):(?<versionNumber>[^:/?]+)$/;\nconst TemplateArnRegex =\n\t/^arn:(?<partition>[^:]+):network-security-manager:(?<region>[^:]*):(?<account>[^:]*):template:(?<templateId>[^:/?]+)$/;\nconst TemplateSnapshotArnRegex =\n\t/^arn:(?<partition>[^:]+):network-security-manager:(?<region>[^:]*):(?<account>[^:]*):template:(?<templateId>[^:/?]+):(?<versionNumber>[^:/?]+)$/;\n\n/**\n * ARN builders, validators, and parsers for network-security-manager resources.\n */\nexport class NetworkSecurityManagerResources {\n\t/**\n\t * Builds an ARN for the deployment resource.\n\t */\n\tstatic deployment(props: NetworkSecurityManagerDeploymentArnProps): string {\n\t\treturn `arn:${props.partition ?? \"aws\"}:network-security-manager:${props.region ?? \"*\"}:${props.account ?? \"*\"}:deployment:${props.deploymentId}`;\n\t}\n\n\t/**\n\t * Validates whether a string is a valid ARN for the deployment resource.\n\t */\n\tstatic isValidDeploymentArn(arn: string): boolean {\n\t\treturn DeploymentArnRegex.test(arn);\n\t}\n\n\t/**\n\t * Parses a deployment ARN into its components.\n\t * @throws Error if the ARN does not match the expected format.\n\t */\n\tstatic parseDeploymentArn(\n\t\tarn: string,\n\t): NetworkSecurityManagerDeploymentArnComponents {\n\t\tconst match = DeploymentArnRegex.exec(arn);\n\t\tif (!match?.groups) {\n\t\t\tthrow new Error(`Invalid deployment ARN: ${arn}`);\n\t\t}\n\t\treturn {\n\t\t\tpartition: match.groups.partition,\n\t\t\tregion: match.groups.region,\n\t\t\taccount: match.groups.account,\n\t\t\tdeploymentId: match.groups!.deploymentId,\n\t\t};\n\t}\n\n\t/**\n\t * Builds an ARN for the deployment-snapshot resource.\n\t */\n\tstatic deploymentSnapshot(\n\t\tprops: NetworkSecurityManagerDeploymentSnapshotArnProps,\n\t): string {\n\t\treturn `arn:${props.partition ?? \"aws\"}:network-security-manager:${props.region ?? \"*\"}:${props.account ?? \"*\"}:deployment:${props.deploymentId}:${props.versionNumber}`;\n\t}\n\n\t/**\n\t * Validates whether a string is a valid ARN for the deployment-snapshot resource.\n\t */\n\tstatic isValidDeploymentSnapshotArn(arn: string): boolean {\n\t\treturn DeploymentSnapshotArnRegex.test(arn);\n\t}\n\n\t/**\n\t * Parses a deployment-snapshot ARN into its components.\n\t * @throws Error if the ARN does not match the expected format.\n\t */\n\tstatic parseDeploymentSnapshotArn(\n\t\tarn: string,\n\t): NetworkSecurityManagerDeploymentSnapshotArnComponents {\n\t\tconst match = DeploymentSnapshotArnRegex.exec(arn);\n\t\tif (!match?.groups) {\n\t\t\tthrow new Error(`Invalid deployment-snapshot ARN: ${arn}`);\n\t\t}\n\t\treturn {\n\t\t\tpartition: match.groups.partition,\n\t\t\tregion: match.groups.region,\n\t\t\taccount: match.groups.account,\n\t\t\tdeploymentId: match.groups!.deploymentId,\n\t\t\tversionNumber: match.groups!.versionNumber,\n\t\t};\n\t}\n\n\t/**\n\t * Builds an ARN for the policy resource.\n\t */\n\tstatic policy(props: NetworkSecurityManagerPolicyArnProps): string {\n\t\treturn `arn:${props.partition ?? \"aws\"}:network-security-manager:${props.region ?? \"*\"}:${props.account ?? \"*\"}:policy:${props.policyId}`;\n\t}\n\n\t/**\n\t * Validates whether a string is a valid ARN for the policy resource.\n\t */\n\tstatic isValidPolicyArn(arn: string): boolean {\n\t\treturn PolicyArnRegex.test(arn);\n\t}\n\n\t/**\n\t * Parses a policy ARN into its components.\n\t * @throws Error if the ARN does not match the expected format.\n\t */\n\tstatic parsePolicyArn(\n\t\tarn: string,\n\t): NetworkSecurityManagerPolicyArnComponents {\n\t\tconst match = PolicyArnRegex.exec(arn);\n\t\tif (!match?.groups) {\n\t\t\tthrow new Error(`Invalid policy ARN: ${arn}`);\n\t\t}\n\t\treturn {\n\t\t\tpartition: match.groups.partition,\n\t\t\tregion: match.groups.region,\n\t\t\taccount: match.groups.account,\n\t\t\tpolicyId: match.groups!.policyId,\n\t\t};\n\t}\n\n\t/**\n\t * Builds an ARN for the policy-snapshot resource.\n\t */\n\tstatic policySnapshot(\n\t\tprops: NetworkSecurityManagerPolicySnapshotArnProps,\n\t): string {\n\t\treturn `arn:${props.partition ?? \"aws\"}:network-security-manager:${props.region ?? \"*\"}:${props.account ?? \"*\"}:policy:${props.policyId}:${props.versionNumber}`;\n\t}\n\n\t/**\n\t * Validates whether a string is a valid ARN for the policy-snapshot resource.\n\t */\n\tstatic isValidPolicySnapshotArn(arn: string): boolean {\n\t\treturn PolicySnapshotArnRegex.test(arn);\n\t}\n\n\t/**\n\t * Parses a policy-snapshot ARN into its components.\n\t * @throws Error if the ARN does not match the expected format.\n\t */\n\tstatic parsePolicySnapshotArn(\n\t\tarn: string,\n\t): NetworkSecurityManagerPolicySnapshotArnComponents {\n\t\tconst match = PolicySnapshotArnRegex.exec(arn);\n\t\tif (!match?.groups) {\n\t\t\tthrow new Error(`Invalid policy-snapshot ARN: ${arn}`);\n\t\t}\n\t\treturn {\n\t\t\tpartition: match.groups.partition,\n\t\t\tregion: match.groups.region,\n\t\t\taccount: match.groups.account,\n\t\t\tpolicyId: match.groups!.policyId,\n\t\t\tversionNumber: match.groups!.versionNumber,\n\t\t};\n\t}\n\n\t/**\n\t * Builds an ARN for the rule resource.\n\t */\n\tstatic rule(props: NetworkSecurityManagerRuleArnProps): string {\n\t\treturn `arn:${props.partition ?? \"aws\"}:network-security-manager:${props.region ?? \"*\"}:${props.account ?? \"*\"}:rule:${props.ruleId}`;\n\t}\n\n\t/**\n\t * Validates whether a string is a valid ARN for the rule resource.\n\t */\n\tstatic isValidRuleArn(arn: string): boolean {\n\t\treturn RuleArnRegex.test(arn);\n\t}\n\n\t/**\n\t * Parses a rule ARN into its components.\n\t * @throws Error if the ARN does not match the expected format.\n\t */\n\tstatic parseRuleArn(arn: string): NetworkSecurityManagerRuleArnComponents {\n\t\tconst match = RuleArnRegex.exec(arn);\n\t\tif (!match?.groups) {\n\t\t\tthrow new Error(`Invalid rule ARN: ${arn}`);\n\t\t}\n\t\treturn {\n\t\t\tpartition: match.groups.partition,\n\t\t\tregion: match.groups.region,\n\t\t\taccount: match.groups.account,\n\t\t\truleId: match.groups!.ruleId,\n\t\t};\n\t}\n\n\t/**\n\t * Builds an ARN for the rule-snapshot resource.\n\t */\n\tstatic ruleSnapshot(\n\t\tprops: NetworkSecurityManagerRuleSnapshotArnProps,\n\t): string {\n\t\treturn `arn:${props.partition ?? \"aws\"}:network-security-manager:${props.region ?? \"*\"}:${props.account ?? \"*\"}:rule:${props.ruleId}:${props.versionNumber}`;\n\t}\n\n\t/**\n\t * Validates whether a string is a valid ARN for the rule-snapshot resource.\n\t */\n\tstatic isValidRuleSnapshotArn(arn: string): boolean {\n\t\treturn RuleSnapshotArnRegex.test(arn);\n\t}\n\n\t/**\n\t * Parses a rule-snapshot ARN into its components.\n\t * @throws Error if the ARN does not match the expected format.\n\t */\n\tstatic parseRuleSnapshotArn(\n\t\tarn: string,\n\t): NetworkSecurityManagerRuleSnapshotArnComponents {\n\t\tconst match = RuleSnapshotArnRegex.exec(arn);\n\t\tif (!match?.groups) {\n\t\t\tthrow new Error(`Invalid rule-snapshot ARN: ${arn}`);\n\t\t}\n\t\treturn {\n\t\t\tpartition: match.groups.partition,\n\t\t\tregion: match.groups.region,\n\t\t\taccount: match.groups.account,\n\t\t\truleId: match.groups!.ruleId,\n\t\t\tversionNumber: match.groups!.versionNumber,\n\t\t};\n\t}\n\n\t/**\n\t * Builds an ARN for the scope resource.\n\t */\n\tstatic scope(props: NetworkSecurityManagerScopeArnProps): string {\n\t\treturn `arn:${props.partition ?? \"aws\"}:network-security-manager:${props.region ?? \"*\"}:${props.account ?? \"*\"}:scope:${props.scopeId}`;\n\t}\n\n\t/**\n\t * Validates whether a string is a valid ARN for the scope resource.\n\t */\n\tstatic isValidScopeArn(arn: string): boolean {\n\t\treturn ScopeArnRegex.test(arn);\n\t}\n\n\t/**\n\t * Parses a scope ARN into its components.\n\t * @throws Error if the ARN does not match the expected format.\n\t */\n\tstatic parseScopeArn(arn: string): NetworkSecurityManagerScopeArnComponents {\n\t\tconst match = ScopeArnRegex.exec(arn);\n\t\tif (!match?.groups) {\n\t\t\tthrow new Error(`Invalid scope ARN: ${arn}`);\n\t\t}\n\t\treturn {\n\t\t\tpartition: match.groups.partition,\n\t\t\tregion: match.groups.region,\n\t\t\taccount: match.groups.account,\n\t\t\tscopeId: match.groups!.scopeId,\n\t\t};\n\t}\n\n\t/**\n\t * Builds an ARN for the scope-snapshot resource.\n\t */\n\tstatic scopeSnapshot(\n\t\tprops: NetworkSecurityManagerScopeSnapshotArnProps,\n\t): string {\n\t\treturn `arn:${props.partition ?? \"aws\"}:network-security-manager:${props.region ?? \"*\"}:${props.account ?? \"*\"}:scope:${props.scopeId}:${props.versionNumber}`;\n\t}\n\n\t/**\n\t * Validates whether a string is a valid ARN for the scope-snapshot resource.\n\t */\n\tstatic isValidScopeSnapshotArn(arn: string): boolean {\n\t\treturn ScopeSnapshotArnRegex.test(arn);\n\t}\n\n\t/**\n\t * Parses a scope-snapshot ARN into its components.\n\t * @throws Error if the ARN does not match the expected format.\n\t */\n\tstatic parseScopeSnapshotArn(\n\t\tarn: string,\n\t): NetworkSecurityManagerScopeSnapshotArnComponents {\n\t\tconst match = ScopeSnapshotArnRegex.exec(arn);\n\t\tif (!match?.groups) {\n\t\t\tthrow new Error(`Invalid scope-snapshot ARN: ${arn}`);\n\t\t}\n\t\treturn {\n\t\t\tpartition: match.groups.partition,\n\t\t\tregion: match.groups.region,\n\t\t\taccount: match.groups.account,\n\t\t\tscopeId: match.groups!.scopeId,\n\t\t\tversionNumber: match.groups!.versionNumber,\n\t\t};\n\t}\n\n\t/**\n\t * Builds an ARN for the template resource.\n\t */\n\tstatic template(props: NetworkSecurityManagerTemplateArnProps): string {\n\t\treturn `arn:${props.partition ?? \"aws\"}:network-security-manager:${props.region ?? \"*\"}:${props.account ?? \"*\"}:template:${props.templateId}`;\n\t}\n\n\t/**\n\t * Validates whether a string is a valid ARN for the template resource.\n\t */\n\tstatic isValidTemplateArn(arn: string): boolean {\n\t\treturn TemplateArnRegex.test(arn);\n\t}\n\n\t/**\n\t * Parses a template ARN into its components.\n\t * @throws Error if the ARN does not match the expected format.\n\t */\n\tstatic parseTemplateArn(\n\t\tarn: string,\n\t): NetworkSecurityManagerTemplateArnComponents {\n\t\tconst match = TemplateArnRegex.exec(arn);\n\t\tif (!match?.groups) {\n\t\t\tthrow new Error(`Invalid template ARN: ${arn}`);\n\t\t}\n\t\treturn {\n\t\t\tpartition: match.groups.partition,\n\t\t\tregion: match.groups.region,\n\t\t\taccount: match.groups.account,\n\t\t\ttemplateId: match.groups!.templateId,\n\t\t};\n\t}\n\n\t/**\n\t * Builds an ARN for the template-snapshot resource.\n\t */\n\tstatic templateSnapshot(\n\t\tprops: NetworkSecurityManagerTemplateSnapshotArnProps,\n\t): string {\n\t\treturn `arn:${props.partition ?? \"aws\"}:network-security-manager:${props.region ?? \"*\"}:${props.account ?? \"*\"}:template:${props.templateId}:${props.versionNumber}`;\n\t}\n\n\t/**\n\t * Validates whether a string is a valid ARN for the template-snapshot resource.\n\t */\n\tstatic isValidTemplateSnapshotArn(arn: string): boolean {\n\t\treturn TemplateSnapshotArnRegex.test(arn);\n\t}\n\n\t/**\n\t * Parses a template-snapshot ARN into its components.\n\t * @throws Error if the ARN does not match the expected format.\n\t */\n\tstatic parseTemplateSnapshotArn(\n\t\tarn: string,\n\t): NetworkSecurityManagerTemplateSnapshotArnComponents {\n\t\tconst match = TemplateSnapshotArnRegex.exec(arn);\n\t\tif (!match?.groups) {\n\t\t\tthrow new Error(`Invalid template-snapshot ARN: ${arn}`);\n\t\t}\n\t\treturn {\n\t\t\tpartition: match.groups.partition,\n\t\t\tregion: match.groups.region,\n\t\t\taccount: match.groups.account,\n\t\t\ttemplateId: match.groups!.templateId,\n\t\t\tversionNumber: match.groups!.versionNumber,\n\t\t};\n\t}\n}\n\n/**\n * API operation to required IAM actions mapping for network-security-manager.\n */\nexport class NetworkSecurityManagerOperations {\n\t/** IAM actions required for the CreateDeployment API call. */\n\tstatic readonly CreateDeployment: string[] = [\n\t\t\"network-security-manager:CreateDeployment\",\n\t\t\"network-security-manager:TagResource\",\n\t];\n\t/** IAM actions required for the CreateDeploymentSnapshot API call. */\n\tstatic readonly CreateDeploymentSnapshot: string[] = [\n\t\t\"network-security-manager:CreateDeploymentSnapshot\",\n\t\t\"network-security-manager:TagResource\",\n\t];\n\t/** IAM actions required for the CreatePolicy API call. */\n\tstatic readonly CreatePolicy: string[] = [\n\t\t\"network-security-manager:CreatePolicy\",\n\t\t\"network-security-manager:TagResource\",\n\t];\n\t/** IAM actions required for the CreatePolicySnapshot API call. */\n\tstatic readonly CreatePolicySnapshot: string[] = [\n\t\t\"network-security-manager:CreatePolicySnapshot\",\n\t\t\"network-security-manager:TagResource\",\n\t];\n\t/** IAM actions required for the CreateRule API call. */\n\tstatic readonly CreateRule: string[] = [\n\t\t\"network-security-manager:CreateRule\",\n\t\t\"network-security-manager:TagResource\",\n\t];\n\t/** IAM actions required for the CreateRuleSnapshot API call. */\n\tstatic readonly CreateRuleSnapshot: string[] = [\n\t\t\"network-security-manager:CreateRuleSnapshot\",\n\t\t\"network-security-manager:TagResource\",\n\t];\n\t/** IAM actions required for the CreateScope API call. */\n\tstatic readonly CreateScope: string[] = [\n\t\t\"network-security-manager:CreateScope\",\n\t\t\"network-security-manager:TagResource\",\n\t];\n\t/** IAM actions required for the CreateScopeSnapshot API call. */\n\tstatic readonly CreateScopeSnapshot: string[] = [\n\t\t\"network-security-manager:CreateScopeSnapshot\",\n\t\t\"network-security-manager:TagResource\",\n\t];\n\t/** IAM actions required for the CreateTemplate API call. */\n\tstatic readonly CreateTemplate: string[] = [\n\t\t\"network-security-manager:CreateTemplate\",\n\t\t\"network-security-manager:TagResource\",\n\t];\n\t/** IAM actions required for the CreateTemplateSnapshot API call. */\n\tstatic readonly CreateTemplateSnapshot: string[] = [\n\t\t\"network-security-manager:CreateTemplateSnapshot\",\n\t\t\"network-security-manager:TagResource\",\n\t];\n\t/** IAM actions required for the DeleteAdminAccount API call. */\n\tstatic readonly DeleteAdminAccount: string[] = [\n\t\t\"network-security-manager:DeleteAdminAccount\",\n\t];\n\t/** IAM actions required for the DeleteDeployment API call. */\n\tstatic readonly DeleteDeployment: string[] = [\n\t\t\"network-security-manager:DeleteDeployment\",\n\t];\n\t/** IAM actions required for the DeletePolicy API call. */\n\tstatic readonly DeletePolicy: string[] = [\n\t\t\"network-security-manager:DeletePolicy\",\n\t];\n\t/** IAM actions required for the DeleteRule API call. */\n\tstatic readonly DeleteRule: string[] = [\n\t\t\"network-security-manager:DeleteRule\",\n\t];\n\t/** IAM actions required for the DeleteScope API call. */\n\tstatic readonly DeleteScope: string[] = [\n\t\t\"network-security-manager:DeleteScope\",\n\t];\n\t/** IAM actions required for the DeleteTemplate API call. */\n\tstatic readonly DeleteTemplate: string[] = [\n\t\t\"network-security-manager:DeleteTemplate\",\n\t];\n\t/** IAM actions required for the GenerateRuleConfiguration API call. */\n\tstatic readonly GenerateRuleConfiguration: string[] = [\n\t\t\"network-security-manager:GenerateRuleConfiguration\",\n\t];\n\t/** IAM actions required for the GetAdminAccount API call. */\n\tstatic readonly opGetAdminAccount: string[] = [\n\t\t\"network-security-manager:GetAdminAccount\",\n\t];\n\t/** IAM actions required for the GetDeployment API call. */\n\tstatic readonly opGetDeployment: string[] = [\n\t\t\"network-security-manager:GetDeployment\",\n\t];\n\t/** IAM actions required for the GetPolicy API call. */\n\tstatic readonly opGetPolicy: string[] = [\n\t\t\"network-security-manager:GetPolicy\",\n\t];\n\t/** IAM actions required for the GetRule API call. */\n\tstatic readonly opGetRule: string[] = [\"network-security-manager:GetRule\"];\n\t/** IAM actions required for the GetScope API call. */\n\tstatic readonly opGetScope: string[] = [\"network-security-manager:GetScope\"];\n\t/** IAM actions required for the GetTemplate API call. */\n\tstatic readonly opGetTemplate: string[] = [\n\t\t\"network-security-manager:GetTemplate\",\n\t];\n\t/** IAM actions required for the ListAdminAccounts API call. */\n\tstatic readonly ListAdminAccounts: string[] = [\n\t\t\"network-security-manager:ListAdminAccounts\",\n\t];\n\t/** IAM actions required for the ListAggregateResourceSynchronizationStatuses API call. */\n\tstatic readonly ListAggregateResourceSynchronizationStatuses: string[] = [\n\t\t\"network-security-manager:ListAggregateResourceSynchronizationStatuses\",\n\t];\n\t/** IAM actions required for the ListDeploymentSnapshots API call. */\n\tstatic readonly ListDeploymentSnapshots: string[] = [\n\t\t\"network-security-manager:ListDeploymentSnapshots\",\n\t];\n\t/** IAM actions required for the ListDeployments API call. */\n\tstatic readonly ListDeployments: string[] = [\n\t\t\"network-security-manager:ListDeployments\",\n\t];\n\t/** IAM actions required for the ListPolicies API call. */\n\tstatic readonly ListPolicies: string[] = [\n\t\t\"network-security-manager:ListPolicies\",\n\t];\n\t/** IAM actions required for the ListPolicySnapshots API call. */\n\tstatic readonly ListPolicySnapshots: string[] = [\n\t\t\"network-security-manager:ListPolicySnapshots\",\n\t];\n\t/** IAM actions required for the ListResourceAssociations API call. */\n\tstatic readonly ListResourceAssociations: string[] = [\n\t\t\"network-security-manager:ListResourceAssociations\",\n\t];\n\t/** IAM actions required for the ListResourceSynchronizationStatuses API call. */\n\tstatic readonly ListResourceSynchronizationStatuses: string[] = [\n\t\t\"network-security-manager:ListResourceSynchronizationStatuses\",\n\t];\n\t/** IAM actions required for the ListRuleSnapshots API call. */\n\tstatic readonly ListRuleSnapshots: string[] = [\n\t\t\"network-security-manager:ListRuleSnapshots\",\n\t];\n\t/** IAM actions required for the ListRules API call. */\n\tstatic readonly ListRules: string[] = [\"network-security-manager:ListRules\"];\n\t/** IAM actions required for the ListScopeSnapshots API call. */\n\tstatic readonly ListScopeSnapshots: string[] = [\n\t\t\"network-security-manager:ListScopeSnapshots\",\n\t];\n\t/** IAM actions required for the ListScopes API call. */\n\tstatic readonly ListScopes: string[] = [\n\t\t\"network-security-manager:ListScopes\",\n\t];\n\t/** IAM actions required for the ListTagsForResource API call. */\n\tstatic readonly ListTagsForResource: string[] = [\n\t\t\"network-security-manager:ListTagsForResource\",\n\t];\n\t/** IAM actions required for the ListTemplateSnapshots API call. */\n\tstatic readonly ListTemplateSnapshots: string[] = [\n\t\t\"network-security-manager:ListTemplateSnapshots\",\n\t];\n\t/** IAM actions required for the ListTemplates API call. */\n\tstatic readonly ListTemplates: string[] = [\n\t\t\"network-security-manager:ListTemplates\",\n\t];\n\t/** IAM actions required for the PutAdminAccount API call. */\n\tstatic readonly PutAdminAccount: string[] = [\n\t\t\"network-security-manager:PutAdminAccount\",\n\t];\n\t/** IAM actions required for the TagResource API call. */\n\tstatic readonly TagResource: string[] = [\n\t\t\"network-security-manager:TagResource\",\n\t];\n\t/** IAM actions required for the UntagResource API call. */\n\tstatic readonly UntagResource: string[] = [\n\t\t\"network-security-manager:UntagResource\",\n\t];\n\t/** IAM actions required for the UpdateDeployment API call. */\n\tstatic readonly UpdateDeployment: string[] = [\n\t\t\"network-security-manager:UpdateDeployment\",\n\t];\n\t/** IAM actions required for the UpdatePolicy API call. */\n\tstatic readonly UpdatePolicy: string[] = [\n\t\t\"network-security-manager:UpdatePolicy\",\n\t];\n\t/** IAM actions required for the UpdateRule API call. */\n\tstatic readonly UpdateRule: string[] = [\n\t\t\"network-security-manager:UpdateRule\",\n\t];\n\t/** IAM actions required for the UpdateScope API call. */\n\tstatic readonly UpdateScope: string[] = [\n\t\t\"network-security-manager:UpdateScope\",\n\t];\n\t/** IAM actions required for the UpdateTemplate API call. */\n\tstatic readonly UpdateTemplate: string[] = [\n\t\t\"network-security-manager:UpdateTemplate\",\n\t];\n}\n\n/**\n * Condition key constants and builders for network-security-manager.\n */\nexport class NetworkSecurityManagerConditions {\n\t/** Condition keys applicable to the CreateDeployment action. */\n\tstatic readonly CreateDeploymentConditionKeys: string[] = [\n\t\t\"aws:RequestTag/${TagKey}\",\n\t\t\"aws:TagKeys\",\n\t];\n\t/** Condition keys applicable to the CreateDeploymentSnapshot action. */\n\tstatic readonly CreateDeploymentSnapshotConditionKeys: string[] = [\n\t\t\"aws:RequestTag/${TagKey}\",\n\t\t\"aws:TagKeys\",\n\t];\n\t/** Condition keys applicable to the CreatePolicy action. */\n\tstatic readonly CreatePolicyConditionKeys: string[] = [\n\t\t\"aws:RequestTag/${TagKey}\",\n\t\t\"aws:TagKeys\",\n\t];\n\t/** Condition keys applicable to the CreatePolicySnapshot action. */\n\tstatic readonly CreatePolicySnapshotConditionKeys: string[] = [\n\t\t\"aws:RequestTag/${TagKey}\",\n\t\t\"aws:TagKeys\",\n\t];\n\t/** Condition keys applicable to the CreateRule action. */\n\tstatic readonly CreateRuleConditionKeys: string[] = [\n\t\t\"aws:RequestTag/${TagKey}\",\n\t\t\"aws:TagKeys\",\n\t];\n\t/** Condition keys applicable to the CreateRuleSnapshot action. */\n\tstatic readonly CreateRuleSnapshotConditionKeys: string[] = [\n\t\t\"aws:RequestTag/${TagKey}\",\n\t\t\"aws:TagKeys\",\n\t];\n\t/** Condition keys applicable to the CreateScope action. */\n\tstatic readonly CreateScopeConditionKeys: string[] = [\n\t\t\"aws:RequestTag/${TagKey}\",\n\t\t\"aws:TagKeys\",\n\t];\n\t/** Condition keys applicable to the CreateScopeSnapshot action. */\n\tstatic readonly CreateScopeSnapshotConditionKeys: string[] = [\n\t\t\"aws:RequestTag/${TagKey}\",\n\t\t\"aws:TagKeys\",\n\t];\n\t/** Condition keys applicable to the CreateTemplate action. */\n\tstatic readonly CreateTemplateConditionKeys: string[] = [\n\t\t\"aws:RequestTag/${TagKey}\",\n\t\t\"aws:TagKeys\",\n\t];\n\t/** Condition keys applicable to the CreateTemplateSnapshot action. */\n\tstatic readonly CreateTemplateSnapshotConditionKeys: string[] = [\n\t\t\"aws:RequestTag/${TagKey}\",\n\t\t\"aws:TagKeys\",\n\t];\n\t/** Condition keys applicable to the ListResourceAssociations action. */\n\tstatic readonly ListResourceAssociationsConditionKeys: string[] = [\n\t\t\"aws:ResourceTag/${TagKey}\",\n\t];\n\t/** Condition keys applicable to the ListResourceSynchronizationStatuses action. */\n\tstatic readonly ListResourceSynchronizationStatusesConditionKeys: string[] = [\n\t\t\"aws:ResourceTag/${TagKey}\",\n\t];\n\t/** Condition keys applicable to the ListTagsForResource action. */\n\tstatic readonly ListTagsForResourceConditionKeys: string[] = [\n\t\t\"aws:ResourceTag/${TagKey}\",\n\t];\n\t/** Condition keys applicable to the TagResource action. */\n\tstatic readonly TagResourceConditionKeys: string[] = [\n\t\t\"aws:RequestTag/${TagKey}\",\n\t\t\"aws:ResourceTag/${TagKey}\",\n\t\t\"aws:TagKeys\",\n\t];\n\t/** Condition keys applicable to the UntagResource action. */\n\tstatic readonly UntagResourceConditionKeys: string[] = [\n\t\t\"aws:ResourceTag/${TagKey}\",\n\t\t\"aws:TagKeys\",\n\t];\n\n\t/** Condition key: aws:RequestTag/${TagKey} (String) */\n\tstatic readonly AWS_REQUEST_TAG = \"aws:RequestTag/${TagKey}\";\n\t/** Condition key: aws:ResourceTag/${TagKey} (String) */\n\tstatic readonly AWS_RESOURCE_TAG = \"aws:ResourceTag/${TagKey}\";\n\t/** Condition key: aws:TagKeys (ArrayOfString) */\n\tstatic readonly AWS_TAG_KEYS = \"aws:TagKeys\";\n\n\t/**\n\t * Generates a condition block for `aws:RequestTag/${TagKey}`.\n\t */\n\tstatic requestTag(value: string): Record<string, Record<string, string>> {\n\t\treturn { StringEquals: { \"aws:RequestTag/${TagKey}\": value } };\n\t}\n\n\t/**\n\t * Generates a condition block for `aws:ResourceTag/${TagKey}`.\n\t */\n\tstatic resourceTag(value: string): Record<string, Record<string, string>> {\n\t\treturn { StringEquals: { \"aws:ResourceTag/${TagKey}\": value } };\n\t}\n\n\t/**\n\t * Generates a condition block for `aws:TagKeys`.\n\t */\n\tstatic tagKeys(values: string[]): Record<string, Record<string, string[]>> {\n\t\treturn { \"ForAllValues:StringEquals\": { \"aws:TagKeys\": values } };\n\t}\n}\n"]}