@aws-cdk/aws-bedrock-agentcore-alpha 2.250.0-alpha.0 → 2.252.0-alpha.0

package/lib/policy/policy-statement.js

@@ -0,0 +1,927 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolicyStatement = exports.AttributeAccessor = exports.ConditionalAttributeAccessor = exports.ConditionalPolicyStatement = exports.ConditionBuilder = void 0;
+const jsiiDeprecationWarnings = require("../../.warnings.jsii.js");
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ *  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance
+ *  with the License. A copy of the License is located at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES
+ *  OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions
+ *  and limitations under the License.
+ */
+const errors_1 = require("aws-cdk-lib/core/lib/errors");
+const helpers_internal_1 = require("aws-cdk-lib/core/lib/helpers-internal");
+/**
+ * Effect of the policy statement - whether to permit or forbid the action.
+ * @internal
+ */
+var PolicyEffect;
+(function (PolicyEffect) {
+    /**
+     * Permit the action if conditions are met
+     */
+    PolicyEffect["PERMIT"] = "permit";
+    /**
+     * Forbid (deny) the action if conditions are met
+     */
+    PolicyEffect["FORBID"] = "forbid";
+})(PolicyEffect || (PolicyEffect = {}));
+/**
+ * Scope for principals - whether to apply to all principals or specific ones.
+ * @internal
+ */
+var PrincipalScope;
+(function (PrincipalScope) {
+    /**
+     * Apply to all principals
+     */
+    PrincipalScope["ALL"] = "all";
+    /**
+     * Apply to specific principal(s)
+     */
+    PrincipalScope["SPECIFIC"] = "specific";
+})(PrincipalScope || (PrincipalScope = {}));
+/**
+ * Scope for actions - whether to apply to all actions or specific ones.
+ * @internal
+ */
+var ActionScope;
+(function (ActionScope) {
+    /**
+     * Apply to all actions
+     */
+    ActionScope["ALL"] = "all";
+    /**
+     * Apply to specific action(s)
+     */
+    ActionScope["SPECIFIC"] = "specific";
+})(ActionScope || (ActionScope = {}));
+/**
+ * Scope for resources - whether to apply to all resources, resource types, or specific ones.
+ * @internal
+ */
+var ResourceScope;
+(function (ResourceScope) {
+    /**
+     * Apply to all resources (wildcard - may be rejected by service)
+     */
+    ResourceScope["ALL"] = "all";
+    /**
+     * Apply to all resources of a specific type
+     */
+    ResourceScope["TYPE"] = "type";
+    /**
+     * Apply to specific resource(s)
+     */
+    ResourceScope["SPECIFIC"] = "specific";
+})(ResourceScope || (ResourceScope = {}));
+/**
+ * A single condition expression in Cedar policy language.
+ */
+class ConditionExpression {
+    attribute;
+    operator;
+    value;
+    constructor(attribute, operator, value) {
+        this.attribute = attribute;
+        this.operator = operator;
+        this.value = value;
+    }
+    toCedar() {
+        const formattedValue = typeof this.value === 'string' && !this.value.startsWith('ip(')
+            ? `"${this.value}"`
+            : this.value;
+        return `${this.attribute} ${this.operator} ${formattedValue}`;
+    }
+}
+/**
+ * Builder for condition expressions in Cedar policies.
+ *
+ * Conditions define when a policy statement should apply or not apply.
+ * Supports logical operators (AND, OR) and various comparison operators.
+ */
+class ConditionBuilder {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-bedrock-agentcore-alpha.ConditionBuilder", version: "2.252.0-alpha.0" };
+    conditions = [];
+    operators = [];
+    /**
+     * Access a principal attribute for comparison.
+     *
+     * Principal attributes come from the authenticated user/service making the request.
+     * Common attributes: username, role, department, groups, etc.
+     *
+     * @param attribute - The attribute name (e.g., 'department', 'role', 'username')
+     */
+    principalAttribute(attribute) {
+        return new AttributeAccessor(`principal.${attribute}`, this);
+    }
+    /**
+     * Access a resource attribute for comparison.
+     *
+     * Resource attributes come from the target resource being accessed.
+     * Common attributes: arn, type, tags, owner, etc.
+     *
+     * @param attribute - The attribute name (e.g., 'confidential', 'owner', 'classification')
+     */
+    resourceAttribute(attribute) {
+        return new AttributeAccessor(`resource.${attribute}`, this);
+    }
+    /**
+     * Access a context attribute for comparison.
+     *
+     * Context attributes come from the request environment.
+     * Common attributes: sourceIp, timestamp, environment, region, etc.
+     *
+     * @param attribute - The attribute name (e.g., 'sourceIp', 'environment', 'timestamp')
+     */
+    contextAttribute(attribute) {
+        return new AttributeAccessor(`context.${attribute}`, this);
+    }
+    /**
+     * Logical AND operator - all conditions must be true.
+     */
+    and() {
+        this.operators.push('&&');
+        return this;
+    }
+    /**
+     * Logical OR operator - at least one condition must be true.
+     */
+    or() {
+        this.operators.push('||');
+        return this;
+    }
+    /**
+     * Internal method to add a condition expression.
+     * @internal
+     */
+    _addCondition(condition) {
+        this.conditions.push(condition);
+        return this;
+    }
+    /**
+     * Generate Cedar condition syntax.
+     * @internal
+     */
+    _toCedar() {
+        if (this.conditions.length === 0) {
+            return '';
+        }
+        let cedar = '';
+        for (let i = 0; i < this.conditions.length; i++) {
+            cedar += `${this.conditions[i].toCedar()}`;
+            if (i < this.operators.length) {
+                cedar += ` ${this.operators[i]} `;
+            }
+        }
+        return cedar;
+    }
+}
+exports.ConditionBuilder = ConditionBuilder;
+/**
+ * Wrapper class for conditionally building policy statements.
+ *
+ * This class allows chaining condition methods and returning to the parent
+ * PolicyStatement when done. It proxies condition building methods from
+ * ConditionBuilder.
+ */
+class ConditionalPolicyStatement {
+    policyStatement;
+    conditionBuilder;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-bedrock-agentcore-alpha.ConditionalPolicyStatement", version: "2.252.0-alpha.0" };
+    constructor(policyStatement, conditionBuilder) {
+        this.policyStatement = policyStatement;
+        this.conditionBuilder = conditionBuilder;
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_bedrock_agentcore_alpha_PolicyStatement(policyStatement);
+            jsiiDeprecationWarnings._aws_cdk_aws_bedrock_agentcore_alpha_ConditionBuilder(conditionBuilder);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, ConditionalPolicyStatement);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Access a principal attribute for comparison.
+     *
+     * @param attribute - The attribute name (e.g., 'department', 'role', 'username')
+     */
+    principalAttribute(attribute) {
+        return new ConditionalAttributeAccessor(`principal.${attribute}`, this, this.conditionBuilder);
+    }
+    /**
+     * Access a resource attribute for comparison.
+     *
+     * @param attribute - The attribute name (e.g., 'confidential', 'owner', 'classification')
+     */
+    resourceAttribute(attribute) {
+        return new ConditionalAttributeAccessor(`resource.${attribute}`, this, this.conditionBuilder);
+    }
+    /**
+     * Access a context attribute for comparison.
+     *
+     * @param attribute - The attribute name (e.g., 'sourceIp', 'environment', 'timestamp')
+     */
+    contextAttribute(attribute) {
+        return new ConditionalAttributeAccessor(`context.${attribute}`, this, this.conditionBuilder);
+    }
+    /**
+     * Logical AND operator - all conditions must be true.
+     */
+    and() {
+        this.conditionBuilder.and();
+        return this;
+    }
+    /**
+     * Logical OR operator - at least one condition must be true.
+     */
+    or() {
+        this.conditionBuilder.or();
+        return this;
+    }
+    /**
+     * Complete condition building and return to the PolicyStatement.
+     *
+     * Use this to finish building when/unless conditions and continue
+     * configuring the policy statement.
+     */
+    done() {
+        return this.policyStatement;
+    }
+    /**
+     * Alias for done() to support fluent unless() chaining.
+     */
+    unless() {
+        return this.policyStatement.unless();
+    }
+}
+exports.ConditionalPolicyStatement = ConditionalPolicyStatement;
+/**
+ * Accessor for building type-safe attribute comparisons within conditional statements.
+ *
+ * Returns ConditionalPolicyStatement to allow chaining back to policy building.
+ */
+class ConditionalAttributeAccessor {
+    path;
+    parent;
+    conditionBuilder;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-bedrock-agentcore-alpha.ConditionalAttributeAccessor", version: "2.252.0-alpha.0" };
+    constructor(path, parent, conditionBuilder) {
+        this.path = path;
+        this.parent = parent;
+        this.conditionBuilder = conditionBuilder;
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_bedrock_agentcore_alpha_ConditionalPolicyStatement(parent);
+            jsiiDeprecationWarnings._aws_cdk_aws_bedrock_agentcore_alpha_ConditionBuilder(conditionBuilder);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, ConditionalAttributeAccessor);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Equality comparison (==)
+     */
+    equalTo(value) {
+        this.conditionBuilder._addCondition(new ConditionExpression(this.path, '==', value));
+        return this.parent;
+    }
+    /**
+     * Inequality comparison (!=)
+     */
+    notEqualTo(value) {
+        this.conditionBuilder._addCondition(new ConditionExpression(this.path, '!=', value));
+        return this.parent;
+    }
+    /**
+     * Less than comparison (<)
+     */
+    lessThan(value) {
+        this.conditionBuilder._addCondition(new ConditionExpression(this.path, '<', value));
+        return this.parent;
+    }
+    /**
+     * Less than or equals comparison (<=)
+     */
+    lessThanOrEqualTo(value) {
+        this.conditionBuilder._addCondition(new ConditionExpression(this.path, '<=', value));
+        return this.parent;
+    }
+    /**
+     * Greater than comparison (>)
+     */
+    greaterThan(value) {
+        this.conditionBuilder._addCondition(new ConditionExpression(this.path, '>', value));
+        return this.parent;
+    }
+    /**
+     * Greater than or equals comparison (>=)
+     */
+    greaterThanOrEqualTo(value) {
+        this.conditionBuilder._addCondition(new ConditionExpression(this.path, '>=', value));
+        return this.parent;
+    }
+    /**
+     * IP range check - tests if IP address is in CIDR range.
+     *
+     * @param ipRange - CIDR notation (e.g., '192.168.1.0/24')
+     */
+    isInRange(ipRange) {
+        this.conditionBuilder._addCondition(new ConditionExpression(this.path, 'isInRange', `ip("${ipRange}")`));
+        return this.parent;
+    }
+    /**
+     * String contains check.
+     */
+    contains(value) {
+        this.conditionBuilder._addCondition(new ConditionExpression(this.path, 'contains', value));
+        return this.parent;
+    }
+    /**
+     * Check if attribute is in a set/list.
+     */
+    isIn(values) {
+        const formattedValues = values.map(v => typeof v === 'string' ? `"${v}"` : v).join(', ');
+        this.conditionBuilder._addCondition(new ConditionExpression(this.path, 'in', `[${formattedValues}]`));
+        return this.parent;
+    }
+}
+exports.ConditionalAttributeAccessor = ConditionalAttributeAccessor;
+/**
+ * Accessor for building type-safe attribute comparisons.
+ *
+ * Provides methods for common comparison operators with proper type checking.
+ */
+class AttributeAccessor {
+    path;
+    parent;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-bedrock-agentcore-alpha.AttributeAccessor", version: "2.252.0-alpha.0" };
+    constructor(path, parent) {
+        this.path = path;
+        this.parent = parent;
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_bedrock_agentcore_alpha_ConditionBuilder(parent);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, AttributeAccessor);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Equality comparison (==)
+     */
+    equalTo(value) {
+        return this.parent._addCondition(new ConditionExpression(this.path, '==', value));
+    }
+    /**
+     * Inequality comparison (!=)
+     */
+    notEqualTo(value) {
+        return this.parent._addCondition(new ConditionExpression(this.path, '!=', value));
+    }
+    /**
+     * Less than comparison (<)
+     */
+    lessThan(value) {
+        return this.parent._addCondition(new ConditionExpression(this.path, '<', value));
+    }
+    /**
+     * Less than or equals comparison (<=)
+     */
+    lessThanOrEqualTo(value) {
+        return this.parent._addCondition(new ConditionExpression(this.path, '<=', value));
+    }
+    /**
+     * Greater than comparison (>)
+     */
+    greaterThan(value) {
+        return this.parent._addCondition(new ConditionExpression(this.path, '>', value));
+    }
+    /**
+     * Greater than or equals comparison (>=)
+     */
+    greaterThanOrEqualTo(value) {
+        return this.parent._addCondition(new ConditionExpression(this.path, '>=', value));
+    }
+    /**
+     * IP range check - tests if IP address is in CIDR range.
+     *
+     * @param ipRange - CIDR notation (e.g., '192.168.1.0/24')
+     */
+    isInRange(ipRange) {
+        return this.parent._addCondition(new ConditionExpression(this.path, 'isInRange', `ip("${ipRange}")`));
+    }
+    /**
+     * String contains check.
+     */
+    contains(value) {
+        return this.parent._addCondition(new ConditionExpression(this.path, 'contains', value));
+    }
+    /**
+     * Check if attribute is in a set/list.
+     */
+    isIn(values) {
+        const formattedValues = values.map(v => typeof v === 'string' ? `"${v}"` : v).join(', ');
+        return this.parent._addCondition(new ConditionExpression(this.path, 'in', `[${formattedValues}]`));
+    }
+}
+exports.AttributeAccessor = AttributeAccessor;
+/**
+ * Type-safe builder for creating Cedar authorization policy statements.
+ *
+ * This builder provides a fluent API for constructing Cedar policies without
+ * requiring knowledge of Cedar syntax. It supports:
+ * - Permit and forbid effects
+ * - Principal, action, and resource specifications
+ * - Conditional logic (when/unless clauses)
+ * - Raw Cedar for advanced cases
+ *
+ * The builder generates valid Cedar policy statements that can be used with
+ * the Policy construct.
+ *
+ * @example
+ * import { Policy, PolicyEngine, PolicyStatement } from '@aws-cdk/aws-bedrock-agentcore-alpha';
+ * declare const engine: PolicyEngine;
+ *
+ * // Example 1: Simple permit policy
+ * // Builder format:
+ * new Policy(this, 'AllowAll', {
+ *   policyEngine: engine,
+ *   statement: PolicyStatement.permit()
+ *     .forAllPrincipals()
+ *     .onAllActions()
+ *     .onAllResources(),
+ * });
+ *
+ * // Generated Cedar:
+ * // permit(
+ * //   principal,
+ * //   action,
+ * //   resource
+ * // );
+ *
+ * @example
+ * import { Policy, PolicyEngine, PolicyStatement } from '@aws-cdk/aws-bedrock-agentcore-alpha';
+ * declare const engine: PolicyEngine;
+ * declare const gatewayArn: string;
+ *
+ * // Example 2: Specific actions policy
+ * // Builder format:
+ * new Policy(this, 'AllowSpecificActions', {
+ *   policyEngine: engine,
+ *   statement: PolicyStatement.permit()
+ *     .forPrincipalInGroup('Group', 'Engineers')
+ *     .onActions([
+ *       'AgentCore::Action::exampleaction1',
+ *       'AgentCore::Action::exampleaction2',
+ *     ])
+ *     .onResource('AgentCore::Gateway', gatewayArn),
+ * });
+ *
+ * // Generated Cedar:
+ * // permit(
+ * //   principal in Group::"Engineers",
+ * //   action in [AgentCore::Action::"exampleaction1", AgentCore::Action::"exampleaction2"],
+ * //   resource == AgentCore::Gateway::"arn:aws:bedrock:us-east-1:123:gateway/gw-123"
+ * // );
+ *
+ * @example
+ * import { Policy, PolicyEngine, PolicyStatement } from '@aws-cdk/aws-bedrock-agentcore-alpha';
+ * declare const engine: PolicyEngine;
+ *
+ * // Example 3: Policy with conditions
+ * // Builder format:
+ * new Policy(this, 'ConditionalPolicy', {
+ *   policyEngine: engine,
+ *   statement: PolicyStatement.permit()
+ *     .forAllPrincipals()
+ *     .onAllActions()
+ *     .onAllResources()
+ *     .when()
+ *       .principalAttribute('department').equalTo('Engineering')
+ *       .and()
+ *       .contextAttribute('sourceIp').isInRange('192.168.1.0/24')
+ *       .done()
+ *     .unless()
+ *       .principalAttribute('suspended').equalTo(true)
+ *       .done(),
+ * });
+ *
+ * // Generated Cedar:
+ * // permit(
+ * //   principal,
+ * //   action,
+ * //   resource
+ * // )
+ * // when {
+ * //   principal.department == "Engineering" && context.sourceIp isInRange ip("192.168.1.0/24")
+ * // }
+ * // unless {
+ * //   principal.suspended == true
+ * // };
+ *
+ * @example
+ * import { Policy, PolicyEngine, PolicyStatement } from '@aws-cdk/aws-bedrock-agentcore-alpha';
+ * declare const engine: PolicyEngine;
+ *
+ * // Example 4: Raw Cedar policy
+ * // For advanced Cedar features not supported by the builder
+ * new Policy(this, 'CustomPolicy', {
+ *   policyEngine: engine,
+ *   definition: 'permit(principal, action, resource) when { context.custom > 10 };',
+ * });
+ *
+ * // Or using fromCedar():
+ * new Policy(this, 'ImportedPolicy', {
+ *   policyEngine: engine,
+ *   statement: PolicyStatement.fromCedar(
+ *     'forbid(principal, action, resource) when { resource.confidential == true };'
+ *   ),
+ * });
+ */
+class PolicyStatement {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-bedrock-agentcore-alpha.PolicyStatement", version: "2.252.0-alpha.0" };
+    /**
+     * Create a permit statement - allows the action if conditions are met.
+     *
+     * Permit statements grant access when their conditions evaluate to true.
+     * Multiple permit statements can apply; any matching permit allows access.
+     */
+    static permit() {
+        return new PolicyStatement(PolicyEffect.PERMIT);
+    }
+    /**
+     * Create a forbid statement - denies the action if conditions are met.
+     *
+     * Forbid statements deny access when their conditions evaluate to true.
+     * Forbid always takes precedence over permit (explicit deny).
+     */
+    static forbid() {
+        return new PolicyStatement(PolicyEffect.FORBID);
+    }
+    /**
+     * Create from raw Cedar policy statement string.
+     *
+     * Use this for advanced Cedar features not supported by the builder,
+     * or when migrating existing Cedar policies.
+     *
+     * Validation is deferred to the Policy construct's validationMode setting.
+     *
+     * @param cedarStatement - Complete Cedar policy statement including effect, principal, action, resource, and conditions
+     */
+    static fromCedar(cedarStatement) {
+        const statement = new PolicyStatement(PolicyEffect.PERMIT);
+        statement.rawCedar = cedarStatement.trim();
+        return statement;
+    }
+    effect;
+    principalConfig;
+    actionConfig;
+    resourceConfig;
+    whenConditions;
+    unlessConditions;
+    rawCedar;
+    constructor(effect) {
+        this.effect = effect;
+    }
+    /**
+     * Apply to all principals (any user, service, or entity).
+     *
+     * Generates: `principal` in Cedar
+     */
+    forAllPrincipals() {
+        this.validateNotRawCedar();
+        this.principalConfig = { scope: PrincipalScope.ALL };
+        return this;
+    }
+    /**
+     * Apply to a specific principal entity.
+     *
+     * Generates: `principal == EntityType::"entityId"` in Cedar
+     *
+     * @param entityType - The entity type (e.g., 'AgentCore::OAuthUser')
+     * @param entityId - Optional specific entity ID
+     */
+    forPrincipal(entityType, entityId) {
+        this.validateNotRawCedar();
+        this.principalConfig = {
+            scope: PrincipalScope.SPECIFIC,
+            entityType,
+            entityId,
+        };
+        return this;
+    }
+    /**
+     * Apply to principals that are members of a specific group.
+     *
+     * Generates: `principal in Group::"groupId"` in Cedar
+     *
+     * @param groupType - The group entity type (e.g., 'Group')
+     * @param groupId - The group identifier (e.g., 'Admins', 'Engineers')
+     */
+    forPrincipalInGroup(groupType, groupId) {
+        this.validateNotRawCedar();
+        this.principalConfig = {
+            scope: PrincipalScope.SPECIFIC,
+            memberOf: { entityType: groupType, entityId: groupId },
+        };
+        return this;
+    }
+    /**
+     * Apply to all actions (any operation).
+     *
+     * Generates: `action` in Cedar
+     */
+    onAllActions() {
+        this.validateNotRawCedar();
+        this.actionConfig = { scope: ActionScope.ALL };
+        return this;
+    }
+    /**
+     * Apply to specific action(s).
+     *
+     * Generates: `action == Action::"name"` or `action in [Action::"name1", Action::"name2"]` in Cedar
+     *
+     * @param actions - Array of action names (e.g., ['AgentCore::Action::InsuranceAPI__get_policy'])
+     */
+    onActions(actions) {
+        this.validateNotRawCedar();
+        if (actions.length === 0) {
+            throw new errors_1.UnscopedValidationError((0, helpers_internal_1.lit) `AtLeastOneAction`, 'At least one action must be specified');
+        }
+        this.actionConfig = {
+            scope: ActionScope.SPECIFIC,
+            actions,
+        };
+        return this;
+    }
+    /**
+     * Apply to a single specific action.
+     *
+     * Generates: `action == Action::"name"` in Cedar
+     *
+     * @param action - Action name (e.g., 'AgentCore::Action::InsuranceAPI__get_policy')
+     */
+    onAction(action) {
+        return this.onActions([action]);
+    }
+    /**
+     * Apply to all resources of a specific type.
+     *
+     * **AWS Requirement**: AWS Bedrock AgentCore Policy service does not allow wildcard
+     * resources (`resource`). This method provides type-constrained resources which are
+     * required for policy validation to succeed.
+     *
+     * Generates: `resource is EntityType` in Cedar
+     *
+     * @param entityType - The entity type (default: 'AgentCore::Gateway')
+     *
+     * @example
+     * import { PolicyStatement } from '@aws-cdk/aws-bedrock-agentcore-alpha';
+     *
+     * // Constrain to Gateway resources (default)
+     * PolicyStatement.permit()
+     *   .forAllPrincipals()
+     *   .onAllActions()
+     *   .onAllResources()  // → "resource is AgentCore::Gateway"
+     *
+     * // Constrain to Runtime resources
+     * PolicyStatement.permit()
+     *   .forAllPrincipals()
+     *   .onAllActions()
+     *   .onAllResources('AgentCore::Runtime')  // → "resource is AgentCore::Runtime"
+     */
+    onAllResources(entityType = 'AgentCore::Gateway') {
+        this.validateNotRawCedar();
+        this.resourceConfig = {
+            scope: ResourceScope.TYPE,
+            entityType,
+        };
+        return this;
+    }
+    /**
+     * Apply to all resources of a specific type (explicit method).
+     *
+     * **AWS Requirement**: Resource type constraints are required by AWS Bedrock
+     * AgentCore when using wildcard principals or actions.
+     *
+     * Generates: `resource is EntityType` in Cedar
+     *
+     * @param entityType - The entity type (e.g., 'AgentCore::Gateway', 'AgentCore::Runtime')
+     *
+     * @example
+     * import { PolicyStatement } from '@aws-cdk/aws-bedrock-agentcore-alpha';
+     *
+     * PolicyStatement.permit()
+     *   .forAllPrincipals()
+     *   .onAllActions()
+     *   .onResourceType('AgentCore::Gateway')  // → "resource is AgentCore::Gateway"
+     */
+    onResourceType(entityType) {
+        this.validateNotRawCedar();
+        this.resourceConfig = {
+            scope: ResourceScope.TYPE,
+            entityType,
+        };
+        return this;
+    }
+    /**
+     * Apply to a specific resource instance.
+     *
+     * **AWS Requirement**: When using specific actions (e.g., `action == Action::"Delete"`),
+     * you must constrain the resource to a specific instance, not just a type.
+     *
+     * Generates: `resource == EntityType::"arn"` in Cedar
+     *
+     * @param entityType - The entity type (e.g., 'AgentCore::Gateway')
+     * @param entityArn - The resource ARN or identifier
+     *
+     * @example
+     * import { PolicyStatement } from '@aws-cdk/aws-bedrock-agentcore-alpha';
+     * declare const gatewayArn: string;
+     *
+     * PolicyStatement.forbid()
+     *   .forAllPrincipals()
+     *   .onAction('AgentCore::Action::Delete')
+     *   .onResource('AgentCore::Gateway', gatewayArn)  // Must be specific resource
+     */
+    onResource(entityType, entityArn) {
+        this.validateNotRawCedar();
+        this.resourceConfig = {
+            scope: ResourceScope.SPECIFIC,
+            entityType,
+            entityArn,
+        };
+        return this;
+    }
+    /**
+     * Add when conditions - policy applies only if these conditions are true.
+     *
+     * When conditions define positive requirements that must be met.
+     * Multiple conditions can be combined with AND/OR operators.
+     *
+     * Returns a ConditionBuilder that you can chain condition methods on.
+     * Call done() when finished to return to the PolicyStatement.
+     */
+    when() {
+        this.validateNotRawCedar();
+        this.whenConditions = new ConditionBuilder();
+        return new ConditionalPolicyStatement(this, this.whenConditions);
+    }
+    /**
+     * Add unless conditions - policy applies only if these conditions are false.
+     *
+     * Unless conditions define negative requirements (exclusions).
+     * The policy applies when these conditions are NOT met.
+     *
+     * Returns a ConditionBuilder that you can chain condition methods on.
+     * Call done() when finished to return to the PolicyStatement.
+     */
+    unless() {
+        this.validateNotRawCedar();
+        this.unlessConditions = new ConditionBuilder();
+        return new ConditionalPolicyStatement(this, this.unlessConditions);
+    }
+    /**
+     * Generate the Cedar policy statement string.
+     *
+     * Converts the builder state into valid Cedar policy syntax.
+     * This is called internally by the Policy construct.
+     *
+     * @returns Valid Cedar policy statement
+     */
+    toCedar() {
+        // If raw Cedar was provided, return it directly
+        if (this.rawCedar) {
+            return this.rawCedar;
+        }
+        // Validate that all required parts are configured
+        if (!this.principalConfig) {
+            throw new errors_1.UnscopedValidationError((0, helpers_internal_1.lit) `PrincipalRequired`, 'Principal must be specified using forAllPrincipals() or forPrincipal()');
+        }
+        if (!this.actionConfig) {
+            throw new errors_1.UnscopedValidationError((0, helpers_internal_1.lit) `ActionRequired`, 'Action must be specified using onAllActions() or onActions()');
+        }
+        if (!this.resourceConfig) {
+            throw new errors_1.UnscopedValidationError((0, helpers_internal_1.lit) `ResourceRequired`, 'Resource must be specified using onAllResources() or onResource()');
+        }
+        let cedar = `${this.effect}(\n`;
+        // Principal
+        cedar += `  ${this.principalToCedar()},\n`;
+        // Action
+        cedar += `  ${this.actionToCedar()},\n`;
+        // Resource
+        cedar += `  ${this.resourceToCedar()}\n`;
+        cedar += ')';
+        // When conditions
+        if (this.whenConditions) {
+            const whenCedar = this.whenConditions._toCedar();
+            if (whenCedar) {
+                cedar += `\nwhen {\n  ${whenCedar}\n}`;
+            }
+        }
+        // Unless conditions
+        if (this.unlessConditions) {
+            const unlessCedar = this.unlessConditions._toCedar();
+            if (unlessCedar) {
+                cedar += `\nunless {\n  ${unlessCedar}\n}`;
+            }
+        }
+        cedar += ';';
+        return cedar;
+    }
+    principalToCedar() {
+        if (!this.principalConfig) {
+            throw new errors_1.UnscopedValidationError((0, helpers_internal_1.lit) `PrincipalConfigRequired`, 'Principal configuration is required');
+        }
+        if (this.principalConfig.scope === PrincipalScope.ALL) {
+            return 'principal';
+        }
+        // Check for group membership
+        if (this.principalConfig.memberOf) {
+            const { entityType, entityId } = this.principalConfig.memberOf;
+            return `principal in ${entityType}::"${entityId}"`;
+        }
+        // Specific principal
+        if (this.principalConfig.entityId) {
+            return `principal == ${this.principalConfig.entityType}::"${this.principalConfig.entityId}"`;
+        }
+        // Principal type only (is operator)
+        return `principal is ${this.principalConfig.entityType}`;
+    }
+    actionToCedar() {
+        if (!this.actionConfig) {
+            throw new errors_1.UnscopedValidationError((0, helpers_internal_1.lit) `ActionConfigRequired`, 'Action configuration is required');
+        }
+        if (this.actionConfig.scope === ActionScope.ALL) {
+            return 'action';
+        }
+        const actions = this.actionConfig.actions;
+        // Format action: if it contains "::" it's already namespaced, just ensure quotes
+        // Otherwise treat as action identifier
+        const formatAction = (action) => {
+            if (action.includes('::')) {
+                // Already namespaced like "AgentCore::Action::actionname"
+                // Need to ensure the action name part is quoted
+                const parts = action.split('::');
+                if (parts.length >= 3) {
+                    const actionName = parts.slice(2).join('::');
+                    const namespace = parts.slice(0, 2).join('::');
+                    return `${namespace}::"${actionName}"`;
+                }
+            }
+            // Otherwise return as-is (will be validated by Cedar)
+            return action;
+        };
+        if (actions.length === 1) {
+            return `action == ${formatAction(actions[0])}`;
+        }
+        // Multiple actions
+        const formattedActions = actions.map(a => formatAction(a)).join(', ');
+        return `action in [${formattedActions}]`;
+    }
+    resourceToCedar() {
+        if (!this.resourceConfig) {
+            throw new errors_1.UnscopedValidationError((0, helpers_internal_1.lit) `ResourceConfigRequired`, 'Resource configuration is required');
+        }
+        switch (this.resourceConfig.scope) {
+            case ResourceScope.ALL:
+                // Note: Wildcard resources may be rejected by AWS Bedrock AgentCore service
+                return 'resource';
+            case ResourceScope.TYPE:
+                // Resource type constraint: "resource is EntityType"
+                if (!this.resourceConfig.entityType) {
+                    throw new errors_1.UnscopedValidationError((0, helpers_internal_1.lit) `EntityTypeRequired`, 'Entity type is required for TYPE resource scope');
+                }
+                return `resource is ${this.resourceConfig.entityType}`;
+            case ResourceScope.SPECIFIC:
+                // Specific resource: "resource == EntityType::"arn""
+                if (!this.resourceConfig.entityType || !this.resourceConfig.entityArn) {
+                    throw new errors_1.UnscopedValidationError((0, helpers_internal_1.lit) `EntityTypeAndArnRequired`, 'Entity type and ARN are required for SPECIFIC resource scope');
+                }
+                return `resource == ${this.resourceConfig.entityType}::"${this.resourceConfig.entityArn}"`;
+            default:
+                throw new errors_1.UnscopedValidationError((0, helpers_internal_1.lit) `UnknownResourceScope`, `Unknown resource scope: ${this.resourceConfig.scope}`);
+        }
+    }
+    validateNotRawCedar() {
+        if (this.rawCedar) {
+            throw new errors_1.UnscopedValidationError((0, helpers_internal_1.lit) `RawCedarConflict`, 'Cannot use builder methods with raw Cedar. ' +
+                'Either use PolicyStatement.fromCedar() or builder methods, not both.');
+        }
+    }
+}
+exports.PolicyStatement = PolicyStatement;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"policy-statement.js","sourceRoot":"","sources":["policy-statement.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n *  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n *\n *  Licensed under the Apache License, Version 2.0 (the \"License\"). You may not use this file except in compliance\n *  with the License. A copy of the License is located at\n *\n *      http://www.apache.org/licenses/LICENSE-2.0\n *\n *  or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES\n *  OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions\n *  and limitations under the License.\n */\n\nimport { UnscopedValidationError } from 'aws-cdk-lib/core/lib/errors';\nimport { lit } from 'aws-cdk-lib/core/lib/helpers-internal';\n\n/**\n * Effect of the policy statement - whether to permit or forbid the action.\n * @internal\n */\nenum PolicyEffect {\n  /**\n   * Permit the action if conditions are met\n   */\n  PERMIT = 'permit',\n\n  /**\n   * Forbid (deny) the action if conditions are met\n   */\n  FORBID = 'forbid',\n}\n\n/**\n * Scope for principals - whether to apply to all principals or specific ones.\n * @internal\n */\nenum PrincipalScope {\n  /**\n   * Apply to all principals\n   */\n  ALL = 'all',\n\n  /**\n   * Apply to specific principal(s)\n   */\n  SPECIFIC = 'specific',\n}\n\n/**\n * Scope for actions - whether to apply to all actions or specific ones.\n * @internal\n */\nenum ActionScope {\n  /**\n   * Apply to all actions\n   */\n  ALL = 'all',\n\n  /**\n   * Apply to specific action(s)\n   */\n  SPECIFIC = 'specific',\n}\n\n/**\n * Scope for resources - whether to apply to all resources, resource types, or specific ones.\n * @internal\n */\nenum ResourceScope {\n  /**\n   * Apply to all resources (wildcard - may be rejected by service)\n   */\n  ALL = 'all',\n\n  /**\n   * Apply to all resources of a specific type\n   */\n  TYPE = 'type',\n\n  /**\n   * Apply to specific resource(s)\n   */\n  SPECIFIC = 'specific',\n}\n\n/**\n * Configuration for principal specification in a policy statement.\n */\ninterface PrincipalConfig {\n  readonly scope: PrincipalScope;\n  readonly entityType?: string;\n  readonly entityId?: string;\n  readonly memberOf?: {\n    readonly entityType: string;\n    readonly entityId: string;\n  };\n}\n\n/**\n * Configuration for action specification in a policy statement.\n */\ninterface ActionConfig {\n  readonly scope: ActionScope;\n  readonly actions?: string[];\n}\n\n/**\n * Configuration for resource specification in a policy statement.\n */\ninterface ResourceConfig {\n  readonly scope: ResourceScope;\n  readonly entityType?: string;\n  readonly entityArn?: string;\n}\n\n/**\n * A single condition expression in Cedar policy language.\n */\nclass ConditionExpression {\n  constructor(\n    private readonly attribute: string,\n    private readonly operator: string,\n    private readonly value: string | number | boolean,\n  ) {}\n\n  public toCedar(): string {\n    const formattedValue = typeof this.value === 'string' && !this.value.startsWith('ip(')\n      ? `\"${this.value}\"`\n      : this.value;\n    return `${this.attribute} ${this.operator} ${formattedValue}`;\n  }\n}\n\n/**\n * Builder for condition expressions in Cedar policies.\n *\n * Conditions define when a policy statement should apply or not apply.\n * Supports logical operators (AND, OR) and various comparison operators.\n */\nexport class ConditionBuilder {\n  private conditions: ConditionExpression[] = [];\n  private operators: ('&&' | '||')[] = [];\n\n  /**\n   * Access a principal attribute for comparison.\n   *\n   * Principal attributes come from the authenticated user/service making the request.\n   * Common attributes: username, role, department, groups, etc.\n   *\n   * @param attribute - The attribute name (e.g., 'department', 'role', 'username')\n   */\n  public principalAttribute(attribute: string): AttributeAccessor {\n    return new AttributeAccessor(`principal.${attribute}`, this);\n  }\n\n  /**\n   * Access a resource attribute for comparison.\n   *\n   * Resource attributes come from the target resource being accessed.\n   * Common attributes: arn, type, tags, owner, etc.\n   *\n   * @param attribute - The attribute name (e.g., 'confidential', 'owner', 'classification')\n   */\n  public resourceAttribute(attribute: string): AttributeAccessor {\n    return new AttributeAccessor(`resource.${attribute}`, this);\n  }\n\n  /**\n   * Access a context attribute for comparison.\n   *\n   * Context attributes come from the request environment.\n   * Common attributes: sourceIp, timestamp, environment, region, etc.\n   *\n   * @param attribute - The attribute name (e.g., 'sourceIp', 'environment', 'timestamp')\n   */\n  public contextAttribute(attribute: string): AttributeAccessor {\n    return new AttributeAccessor(`context.${attribute}`, this);\n  }\n\n  /**\n   * Logical AND operator - all conditions must be true.\n   */\n  public and(): this {\n    this.operators.push('&&');\n    return this;\n  }\n\n  /**\n   * Logical OR operator - at least one condition must be true.\n   */\n  public or(): this {\n    this.operators.push('||');\n    return this;\n  }\n\n  /**\n   * Internal method to add a condition expression.\n   * @internal\n   */\n  public _addCondition(condition: ConditionExpression): this {\n    this.conditions.push(condition);\n    return this;\n  }\n\n  /**\n   * Generate Cedar condition syntax.\n   * @internal\n   */\n  public _toCedar(): string {\n    if (this.conditions.length === 0) {\n      return '';\n    }\n\n    let cedar = '';\n    for (let i = 0; i < this.conditions.length; i++) {\n      cedar += `${this.conditions[i].toCedar()}`;\n      if (i < this.operators.length) {\n        cedar += ` ${this.operators[i]} `;\n      }\n    }\n    return cedar;\n  }\n}\n\n/**\n * Wrapper class for conditionally building policy statements.\n *\n * This class allows chaining condition methods and returning to the parent\n * PolicyStatement when done. It proxies condition building methods from\n * ConditionBuilder.\n */\nexport class ConditionalPolicyStatement {\n  constructor(\n    private readonly policyStatement: PolicyStatement,\n    private readonly conditionBuilder: ConditionBuilder,\n  ) {}\n\n  /**\n   * Access a principal attribute for comparison.\n   *\n   * @param attribute - The attribute name (e.g., 'department', 'role', 'username')\n   */\n  public principalAttribute(attribute: string): ConditionalAttributeAccessor {\n    return new ConditionalAttributeAccessor(`principal.${attribute}`, this, this.conditionBuilder);\n  }\n\n  /**\n   * Access a resource attribute for comparison.\n   *\n   * @param attribute - The attribute name (e.g., 'confidential', 'owner', 'classification')\n   */\n  public resourceAttribute(attribute: string): ConditionalAttributeAccessor {\n    return new ConditionalAttributeAccessor(`resource.${attribute}`, this, this.conditionBuilder);\n  }\n\n  /**\n   * Access a context attribute for comparison.\n   *\n   * @param attribute - The attribute name (e.g., 'sourceIp', 'environment', 'timestamp')\n   */\n  public contextAttribute(attribute: string): ConditionalAttributeAccessor {\n    return new ConditionalAttributeAccessor(`context.${attribute}`, this, this.conditionBuilder);\n  }\n\n  /**\n   * Logical AND operator - all conditions must be true.\n   */\n  public and(): this {\n    this.conditionBuilder.and();\n    return this;\n  }\n\n  /**\n   * Logical OR operator - at least one condition must be true.\n   */\n  public or(): this {\n    this.conditionBuilder.or();\n    return this;\n  }\n\n  /**\n   * Complete condition building and return to the PolicyStatement.\n   *\n   * Use this to finish building when/unless conditions and continue\n   * configuring the policy statement.\n   */\n  public done(): PolicyStatement {\n    return this.policyStatement;\n  }\n\n  /**\n   * Alias for done() to support fluent unless() chaining.\n   */\n  public unless(): ConditionalPolicyStatement {\n    return this.policyStatement.unless();\n  }\n}\n\n/**\n * Accessor for building type-safe attribute comparisons within conditional statements.\n *\n * Returns ConditionalPolicyStatement to allow chaining back to policy building.\n */\nexport class ConditionalAttributeAccessor {\n  constructor(\n    private readonly path: string,\n    private readonly parent: ConditionalPolicyStatement,\n    private readonly conditionBuilder: ConditionBuilder,\n  ) {}\n\n  /**\n   * Equality comparison (==)\n   */\n  public equalTo(value: string | number | boolean): ConditionalPolicyStatement {\n    this.conditionBuilder._addCondition(\n      new ConditionExpression(this.path, '==', value),\n    );\n    return this.parent;\n  }\n\n  /**\n   * Inequality comparison (!=)\n   */\n  public notEqualTo(value: string | number | boolean): ConditionalPolicyStatement {\n    this.conditionBuilder._addCondition(\n      new ConditionExpression(this.path, '!=', value),\n    );\n    return this.parent;\n  }\n\n  /**\n   * Less than comparison (<)\n   */\n  public lessThan(value: number): ConditionalPolicyStatement {\n    this.conditionBuilder._addCondition(\n      new ConditionExpression(this.path, '<', value),\n    );\n    return this.parent;\n  }\n\n  /**\n   * Less than or equals comparison (<=)\n   */\n  public lessThanOrEqualTo(value: number): ConditionalPolicyStatement {\n    this.conditionBuilder._addCondition(\n      new ConditionExpression(this.path, '<=', value),\n    );\n    return this.parent;\n  }\n\n  /**\n   * Greater than comparison (>)\n   */\n  public greaterThan(value: number): ConditionalPolicyStatement {\n    this.conditionBuilder._addCondition(\n      new ConditionExpression(this.path, '>', value),\n    );\n    return this.parent;\n  }\n\n  /**\n   * Greater than or equals comparison (>=)\n   */\n  public greaterThanOrEqualTo(value: number): ConditionalPolicyStatement {\n    this.conditionBuilder._addCondition(\n      new ConditionExpression(this.path, '>=', value),\n    );\n    return this.parent;\n  }\n\n  /**\n   * IP range check - tests if IP address is in CIDR range.\n   *\n   * @param ipRange - CIDR notation (e.g., '192.168.1.0/24')\n   */\n  public isInRange(ipRange: string): ConditionalPolicyStatement {\n    this.conditionBuilder._addCondition(\n      new ConditionExpression(this.path, 'isInRange', `ip(\"${ipRange}\")`),\n    );\n    return this.parent;\n  }\n\n  /**\n   * String contains check.\n   */\n  public contains(value: string): ConditionalPolicyStatement {\n    this.conditionBuilder._addCondition(\n      new ConditionExpression(this.path, 'contains', value),\n    );\n    return this.parent;\n  }\n\n  /**\n   * Check if attribute is in a set/list.\n   */\n  public isIn(values: (string | number)[]): ConditionalPolicyStatement {\n    const formattedValues = values.map(v =>\n      typeof v === 'string' ? `\"${v}\"` : v,\n    ).join(', ');\n    this.conditionBuilder._addCondition(\n      new ConditionExpression(this.path, 'in', `[${formattedValues}]`),\n    );\n    return this.parent;\n  }\n}\n\n/**\n * Accessor for building type-safe attribute comparisons.\n *\n * Provides methods for common comparison operators with proper type checking.\n */\nexport class AttributeAccessor {\n  constructor(\n    private readonly path: string,\n    private readonly parent: ConditionBuilder,\n  ) {}\n\n  /**\n   * Equality comparison (==)\n   */\n  public equalTo(value: string | number | boolean): ConditionBuilder {\n    return this.parent._addCondition(\n      new ConditionExpression(this.path, '==', value),\n    );\n  }\n\n  /**\n   * Inequality comparison (!=)\n   */\n  public notEqualTo(value: string | number | boolean): ConditionBuilder {\n    return this.parent._addCondition(\n      new ConditionExpression(this.path, '!=', value),\n    );\n  }\n\n  /**\n   * Less than comparison (<)\n   */\n  public lessThan(value: number): ConditionBuilder {\n    return this.parent._addCondition(\n      new ConditionExpression(this.path, '<', value),\n    );\n  }\n\n  /**\n   * Less than or equals comparison (<=)\n   */\n  public lessThanOrEqualTo(value: number): ConditionBuilder {\n    return this.parent._addCondition(\n      new ConditionExpression(this.path, '<=', value),\n    );\n  }\n\n  /**\n   * Greater than comparison (>)\n   */\n  public greaterThan(value: number): ConditionBuilder {\n    return this.parent._addCondition(\n      new ConditionExpression(this.path, '>', value),\n    );\n  }\n\n  /**\n   * Greater than or equals comparison (>=)\n   */\n  public greaterThanOrEqualTo(value: number): ConditionBuilder {\n    return this.parent._addCondition(\n      new ConditionExpression(this.path, '>=', value),\n    );\n  }\n\n  /**\n   * IP range check - tests if IP address is in CIDR range.\n   *\n   * @param ipRange - CIDR notation (e.g., '192.168.1.0/24')\n   */\n  public isInRange(ipRange: string): ConditionBuilder {\n    return this.parent._addCondition(\n      new ConditionExpression(this.path, 'isInRange', `ip(\"${ipRange}\")`),\n    );\n  }\n\n  /**\n   * String contains check.\n   */\n  public contains(value: string): ConditionBuilder {\n    return this.parent._addCondition(\n      new ConditionExpression(this.path, 'contains', value),\n    );\n  }\n\n  /**\n   * Check if attribute is in a set/list.\n   */\n  public isIn(values: (string | number)[]): ConditionBuilder {\n    const formattedValues = values.map(v =>\n      typeof v === 'string' ? `\"${v}\"` : v,\n    ).join(', ');\n    return this.parent._addCondition(\n      new ConditionExpression(this.path, 'in', `[${formattedValues}]`),\n    );\n  }\n}\n\n/**\n * Type-safe builder for creating Cedar authorization policy statements.\n *\n * This builder provides a fluent API for constructing Cedar policies without\n * requiring knowledge of Cedar syntax. It supports:\n * - Permit and forbid effects\n * - Principal, action, and resource specifications\n * - Conditional logic (when/unless clauses)\n * - Raw Cedar for advanced cases\n *\n * The builder generates valid Cedar policy statements that can be used with\n * the Policy construct.\n *\n * @example\n * import { Policy, PolicyEngine, PolicyStatement } from '@aws-cdk/aws-bedrock-agentcore-alpha';\n * declare const engine: PolicyEngine;\n *\n * // Example 1: Simple permit policy\n * // Builder format:\n * new Policy(this, 'AllowAll', {\n *   policyEngine: engine,\n *   statement: PolicyStatement.permit()\n *     .forAllPrincipals()\n *     .onAllActions()\n *     .onAllResources(),\n * });\n *\n * // Generated Cedar:\n * // permit(\n * //   principal,\n * //   action,\n * //   resource\n * // );\n *\n * @example\n * import { Policy, PolicyEngine, PolicyStatement } from '@aws-cdk/aws-bedrock-agentcore-alpha';\n * declare const engine: PolicyEngine;\n * declare const gatewayArn: string;\n *\n * // Example 2: Specific actions policy\n * // Builder format:\n * new Policy(this, 'AllowSpecificActions', {\n *   policyEngine: engine,\n *   statement: PolicyStatement.permit()\n *     .forPrincipalInGroup('Group', 'Engineers')\n *     .onActions([\n *       'AgentCore::Action::exampleaction1',\n *       'AgentCore::Action::exampleaction2',\n *     ])\n *     .onResource('AgentCore::Gateway', gatewayArn),\n * });\n *\n * // Generated Cedar:\n * // permit(\n * //   principal in Group::\"Engineers\",\n * //   action in [AgentCore::Action::\"exampleaction1\", AgentCore::Action::\"exampleaction2\"],\n * //   resource == AgentCore::Gateway::\"arn:aws:bedrock:us-east-1:123:gateway/gw-123\"\n * // );\n *\n * @example\n * import { Policy, PolicyEngine, PolicyStatement } from '@aws-cdk/aws-bedrock-agentcore-alpha';\n * declare const engine: PolicyEngine;\n *\n * // Example 3: Policy with conditions\n * // Builder format:\n * new Policy(this, 'ConditionalPolicy', {\n *   policyEngine: engine,\n *   statement: PolicyStatement.permit()\n *     .forAllPrincipals()\n *     .onAllActions()\n *     .onAllResources()\n *     .when()\n *       .principalAttribute('department').equalTo('Engineering')\n *       .and()\n *       .contextAttribute('sourceIp').isInRange('192.168.1.0/24')\n *       .done()\n *     .unless()\n *       .principalAttribute('suspended').equalTo(true)\n *       .done(),\n * });\n *\n * // Generated Cedar:\n * // permit(\n * //   principal,\n * //   action,\n * //   resource\n * // )\n * // when {\n * //   principal.department == \"Engineering\" && context.sourceIp isInRange ip(\"192.168.1.0/24\")\n * // }\n * // unless {\n * //   principal.suspended == true\n * // };\n *\n * @example\n * import { Policy, PolicyEngine, PolicyStatement } from '@aws-cdk/aws-bedrock-agentcore-alpha';\n * declare const engine: PolicyEngine;\n *\n * // Example 4: Raw Cedar policy\n * // For advanced Cedar features not supported by the builder\n * new Policy(this, 'CustomPolicy', {\n *   policyEngine: engine,\n *   definition: 'permit(principal, action, resource) when { context.custom > 10 };',\n * });\n *\n * // Or using fromCedar():\n * new Policy(this, 'ImportedPolicy', {\n *   policyEngine: engine,\n *   statement: PolicyStatement.fromCedar(\n *     'forbid(principal, action, resource) when { resource.confidential == true };'\n *   ),\n * });\n */\nexport class PolicyStatement {\n  /**\n   * Create a permit statement - allows the action if conditions are met.\n   *\n   * Permit statements grant access when their conditions evaluate to true.\n   * Multiple permit statements can apply; any matching permit allows access.\n   */\n  public static permit(): PolicyStatement {\n    return new PolicyStatement(PolicyEffect.PERMIT);\n  }\n\n  /**\n   * Create a forbid statement - denies the action if conditions are met.\n   *\n   * Forbid statements deny access when their conditions evaluate to true.\n   * Forbid always takes precedence over permit (explicit deny).\n   */\n  public static forbid(): PolicyStatement {\n    return new PolicyStatement(PolicyEffect.FORBID);\n  }\n\n  /**\n   * Create from raw Cedar policy statement string.\n   *\n   * Use this for advanced Cedar features not supported by the builder,\n   * or when migrating existing Cedar policies.\n   *\n   * Validation is deferred to the Policy construct's validationMode setting.\n   *\n   * @param cedarStatement - Complete Cedar policy statement including effect, principal, action, resource, and conditions\n   */\n  public static fromCedar(cedarStatement: string): PolicyStatement {\n    const statement = new PolicyStatement(PolicyEffect.PERMIT);\n    statement.rawCedar = cedarStatement.trim();\n    return statement;\n  }\n\n  private effect: PolicyEffect;\n  private principalConfig?: PrincipalConfig;\n  private actionConfig?: ActionConfig;\n  private resourceConfig?: ResourceConfig;\n  private whenConditions?: ConditionBuilder;\n  private unlessConditions?: ConditionBuilder;\n  private rawCedar?: string;\n\n  private constructor(effect: PolicyEffect) {\n    this.effect = effect;\n  }\n\n  /**\n   * Apply to all principals (any user, service, or entity).\n   *\n   * Generates: `principal` in Cedar\n   */\n  public forAllPrincipals(): this {\n    this.validateNotRawCedar();\n    this.principalConfig = { scope: PrincipalScope.ALL };\n    return this;\n  }\n\n  /**\n   * Apply to a specific principal entity.\n   *\n   * Generates: `principal == EntityType::\"entityId\"` in Cedar\n   *\n   * @param entityType - The entity type (e.g., 'AgentCore::OAuthUser')\n   * @param entityId - Optional specific entity ID\n   */\n  public forPrincipal(entityType: string, entityId?: string): this {\n    this.validateNotRawCedar();\n    this.principalConfig = {\n      scope: PrincipalScope.SPECIFIC,\n      entityType,\n      entityId,\n    };\n    return this;\n  }\n\n  /**\n   * Apply to principals that are members of a specific group.\n   *\n   * Generates: `principal in Group::\"groupId\"` in Cedar\n   *\n   * @param groupType - The group entity type (e.g., 'Group')\n   * @param groupId - The group identifier (e.g., 'Admins', 'Engineers')\n   */\n  public forPrincipalInGroup(groupType: string, groupId: string): this {\n    this.validateNotRawCedar();\n    this.principalConfig = {\n      scope: PrincipalScope.SPECIFIC,\n      memberOf: { entityType: groupType, entityId: groupId },\n    };\n    return this;\n  }\n\n  /**\n   * Apply to all actions (any operation).\n   *\n   * Generates: `action` in Cedar\n   */\n  public onAllActions(): this {\n    this.validateNotRawCedar();\n    this.actionConfig = { scope: ActionScope.ALL };\n    return this;\n  }\n\n  /**\n   * Apply to specific action(s).\n   *\n   * Generates: `action == Action::\"name\"` or `action in [Action::\"name1\", Action::\"name2\"]` in Cedar\n   *\n   * @param actions - Array of action names (e.g., ['AgentCore::Action::InsuranceAPI__get_policy'])\n   */\n  public onActions(actions: string[]): this {\n    this.validateNotRawCedar();\n    if (actions.length === 0) {\n      throw new UnscopedValidationError(lit`AtLeastOneAction`, 'At least one action must be specified');\n    }\n    this.actionConfig = {\n      scope: ActionScope.SPECIFIC,\n      actions,\n    };\n    return this;\n  }\n\n  /**\n   * Apply to a single specific action.\n   *\n   * Generates: `action == Action::\"name\"` in Cedar\n   *\n   * @param action - Action name (e.g., 'AgentCore::Action::InsuranceAPI__get_policy')\n   */\n  public onAction(action: string): this {\n    return this.onActions([action]);\n  }\n\n  /**\n   * Apply to all resources of a specific type.\n   *\n   * **AWS Requirement**: AWS Bedrock AgentCore Policy service does not allow wildcard\n   * resources (`resource`). This method provides type-constrained resources which are\n   * required for policy validation to succeed.\n   *\n   * Generates: `resource is EntityType` in Cedar\n   *\n   * @param entityType - The entity type (default: 'AgentCore::Gateway')\n   *\n   * @example\n   * import { PolicyStatement } from '@aws-cdk/aws-bedrock-agentcore-alpha';\n   *\n   * // Constrain to Gateway resources (default)\n   * PolicyStatement.permit()\n   *   .forAllPrincipals()\n   *   .onAllActions()\n   *   .onAllResources()  // → \"resource is AgentCore::Gateway\"\n   *\n   * // Constrain to Runtime resources\n   * PolicyStatement.permit()\n   *   .forAllPrincipals()\n   *   .onAllActions()\n   *   .onAllResources('AgentCore::Runtime')  // → \"resource is AgentCore::Runtime\"\n   */\n  public onAllResources(entityType: string = 'AgentCore::Gateway'): this {\n    this.validateNotRawCedar();\n    this.resourceConfig = {\n      scope: ResourceScope.TYPE,\n      entityType,\n    };\n    return this;\n  }\n\n  /**\n   * Apply to all resources of a specific type (explicit method).\n   *\n   * **AWS Requirement**: Resource type constraints are required by AWS Bedrock\n   * AgentCore when using wildcard principals or actions.\n   *\n   * Generates: `resource is EntityType` in Cedar\n   *\n   * @param entityType - The entity type (e.g., 'AgentCore::Gateway', 'AgentCore::Runtime')\n   *\n   * @example\n   * import { PolicyStatement } from '@aws-cdk/aws-bedrock-agentcore-alpha';\n   *\n   * PolicyStatement.permit()\n   *   .forAllPrincipals()\n   *   .onAllActions()\n   *   .onResourceType('AgentCore::Gateway')  // → \"resource is AgentCore::Gateway\"\n   */\n  public onResourceType(entityType: string): this {\n    this.validateNotRawCedar();\n    this.resourceConfig = {\n      scope: ResourceScope.TYPE,\n      entityType,\n    };\n    return this;\n  }\n\n  /**\n   * Apply to a specific resource instance.\n   *\n   * **AWS Requirement**: When using specific actions (e.g., `action == Action::\"Delete\"`),\n   * you must constrain the resource to a specific instance, not just a type.\n   *\n   * Generates: `resource == EntityType::\"arn\"` in Cedar\n   *\n   * @param entityType - The entity type (e.g., 'AgentCore::Gateway')\n   * @param entityArn - The resource ARN or identifier\n   *\n   * @example\n   * import { PolicyStatement } from '@aws-cdk/aws-bedrock-agentcore-alpha';\n   * declare const gatewayArn: string;\n   *\n   * PolicyStatement.forbid()\n   *   .forAllPrincipals()\n   *   .onAction('AgentCore::Action::Delete')\n   *   .onResource('AgentCore::Gateway', gatewayArn)  // Must be specific resource\n   */\n  public onResource(entityType: string, entityArn: string): this {\n    this.validateNotRawCedar();\n    this.resourceConfig = {\n      scope: ResourceScope.SPECIFIC,\n      entityType,\n      entityArn,\n    };\n    return this;\n  }\n\n  /**\n   * Add when conditions - policy applies only if these conditions are true.\n   *\n   * When conditions define positive requirements that must be met.\n   * Multiple conditions can be combined with AND/OR operators.\n   *\n   * Returns a ConditionBuilder that you can chain condition methods on.\n   * Call done() when finished to return to the PolicyStatement.\n   */\n  public when(): ConditionalPolicyStatement {\n    this.validateNotRawCedar();\n    this.whenConditions = new ConditionBuilder();\n    return new ConditionalPolicyStatement(this, this.whenConditions);\n  }\n\n  /**\n   * Add unless conditions - policy applies only if these conditions are false.\n   *\n   * Unless conditions define negative requirements (exclusions).\n   * The policy applies when these conditions are NOT met.\n   *\n   * Returns a ConditionBuilder that you can chain condition methods on.\n   * Call done() when finished to return to the PolicyStatement.\n   */\n  public unless(): ConditionalPolicyStatement {\n    this.validateNotRawCedar();\n    this.unlessConditions = new ConditionBuilder();\n    return new ConditionalPolicyStatement(this, this.unlessConditions);\n  }\n\n  /**\n   * Generate the Cedar policy statement string.\n   *\n   * Converts the builder state into valid Cedar policy syntax.\n   * This is called internally by the Policy construct.\n   *\n   * @returns Valid Cedar policy statement\n   */\n  public toCedar(): string {\n    // If raw Cedar was provided, return it directly\n    if (this.rawCedar) {\n      return this.rawCedar;\n    }\n\n    // Validate that all required parts are configured\n    if (!this.principalConfig) {\n      throw new UnscopedValidationError(lit`PrincipalRequired`, 'Principal must be specified using forAllPrincipals() or forPrincipal()');\n    }\n    if (!this.actionConfig) {\n      throw new UnscopedValidationError(lit`ActionRequired`, 'Action must be specified using onAllActions() or onActions()');\n    }\n    if (!this.resourceConfig) {\n      throw new UnscopedValidationError(lit`ResourceRequired`, 'Resource must be specified using onAllResources() or onResource()');\n    }\n\n    let cedar = `${this.effect}(\\n`;\n\n    // Principal\n    cedar += `  ${this.principalToCedar()},\\n`;\n\n    // Action\n    cedar += `  ${this.actionToCedar()},\\n`;\n\n    // Resource\n    cedar += `  ${this.resourceToCedar()}\\n`;\n\n    cedar += ')';\n\n    // When conditions\n    if (this.whenConditions) {\n      const whenCedar = this.whenConditions._toCedar();\n      if (whenCedar) {\n        cedar += `\\nwhen {\\n  ${whenCedar}\\n}`;\n      }\n    }\n\n    // Unless conditions\n    if (this.unlessConditions) {\n      const unlessCedar = this.unlessConditions._toCedar();\n      if (unlessCedar) {\n        cedar += `\\nunless {\\n  ${unlessCedar}\\n}`;\n      }\n    }\n\n    cedar += ';';\n    return cedar;\n  }\n\n  private principalToCedar(): string {\n    if (!this.principalConfig) {\n      throw new UnscopedValidationError(lit`PrincipalConfigRequired`, 'Principal configuration is required');\n    }\n\n    if (this.principalConfig.scope === PrincipalScope.ALL) {\n      return 'principal';\n    }\n\n    // Check for group membership\n    if (this.principalConfig.memberOf) {\n      const { entityType, entityId } = this.principalConfig.memberOf;\n      return `principal in ${entityType}::\"${entityId}\"`;\n    }\n\n    // Specific principal\n    if (this.principalConfig.entityId) {\n      return `principal == ${this.principalConfig.entityType}::\"${this.principalConfig.entityId}\"`;\n    }\n\n    // Principal type only (is operator)\n    return `principal is ${this.principalConfig.entityType}`;\n  }\n\n  private actionToCedar(): string {\n    if (!this.actionConfig) {\n      throw new UnscopedValidationError(lit`ActionConfigRequired`, 'Action configuration is required');\n    }\n\n    if (this.actionConfig.scope === ActionScope.ALL) {\n      return 'action';\n    }\n\n    const actions = this.actionConfig.actions!;\n\n    // Format action: if it contains \"::\" it's already namespaced, just ensure quotes\n    // Otherwise treat as action identifier\n    const formatAction = (action: string): string => {\n      if (action.includes('::')) {\n        // Already namespaced like \"AgentCore::Action::actionname\"\n        // Need to ensure the action name part is quoted\n        const parts = action.split('::');\n        if (parts.length >= 3) {\n          const actionName = parts.slice(2).join('::');\n          const namespace = parts.slice(0, 2).join('::');\n          return `${namespace}::\"${actionName}\"`;\n        }\n      }\n      // Otherwise return as-is (will be validated by Cedar)\n      return action;\n    };\n\n    if (actions.length === 1) {\n      return `action == ${formatAction(actions[0])}`;\n    }\n\n    // Multiple actions\n    const formattedActions = actions.map(a => formatAction(a)).join(', ');\n    return `action in [${formattedActions}]`;\n  }\n\n  private resourceToCedar(): string {\n    if (!this.resourceConfig) {\n      throw new UnscopedValidationError(lit`ResourceConfigRequired`, 'Resource configuration is required');\n    }\n\n    switch (this.resourceConfig.scope) {\n      case ResourceScope.ALL:\n        // Note: Wildcard resources may be rejected by AWS Bedrock AgentCore service\n        return 'resource';\n\n      case ResourceScope.TYPE:\n        // Resource type constraint: \"resource is EntityType\"\n        if (!this.resourceConfig.entityType) {\n          throw new UnscopedValidationError(lit`EntityTypeRequired`, 'Entity type is required for TYPE resource scope');\n        }\n        return `resource is ${this.resourceConfig.entityType}`;\n\n      case ResourceScope.SPECIFIC:\n        // Specific resource: \"resource == EntityType::\"arn\"\"\n        if (!this.resourceConfig.entityType || !this.resourceConfig.entityArn) {\n          throw new UnscopedValidationError(lit`EntityTypeAndArnRequired`, 'Entity type and ARN are required for SPECIFIC resource scope');\n        }\n        return `resource == ${this.resourceConfig.entityType}::\"${this.resourceConfig.entityArn}\"`;\n\n      default:\n        throw new UnscopedValidationError(lit`UnknownResourceScope`, `Unknown resource scope: ${this.resourceConfig.scope}`);\n    }\n  }\n\n  private validateNotRawCedar(): void {\n    if (this.rawCedar) {\n      throw new UnscopedValidationError(\n        lit`RawCedarConflict`,\n        'Cannot use builder methods with raw Cedar. ' +\n        'Either use PolicyStatement.fromCedar() or builder methods, not both.',\n      );\n    }\n  }\n}\n"]}