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

package/lib/policy/policy-engine-base.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolicyEngineBase = void 0;
+const jsiiDeprecationWarnings = require("../../.warnings.jsii.js");
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_cloudwatch_1 = require("aws-cdk-lib/aws-cloudwatch");
+const iam = require("aws-cdk-lib/aws-iam");
+// Internal imports
+const perms_1 = require("./perms");
+/******************************************************************************
+ *                        ABSTRACT BASE CLASS
+ *****************************************************************************/
+/**
+ * Abstract base class for a PolicyEngine.
+ * Contains methods and attributes valid for PolicyEngines either created with CDK or imported.
+ */
+class PolicyEngineBase extends aws_cdk_lib_1.Resource {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-bedrock-agentcore-alpha.PolicyEngineBase", version: "2.252.0-alpha.0" };
+    /**
+     * A reference to this PolicyEngine resource.
+     */
+    get policyEngineRef() {
+        return {
+            policyEngineArn: this.policyEngineArn,
+        };
+    }
+    constructor(scope, id, props = {}) {
+        super(scope, id, props);
+    }
+    /**
+     * Grants IAM actions to the IAM Principal
+     *
+     * [disable-awslint:no-grants]
+     *
+     * @param grantee - The IAM principal to grant permissions to
+     * @param actions - The actions to grant
+     * @returns An IAM Grant object representing the granted permissions
+     */
+    grant(grantee, ...actions) {
+        return iam.Grant.addToPrincipal({
+            grantee,
+            actions,
+            resourceArns: [this.policyEngineArn],
+        });
+    }
+    /**
+     * Grants read permissions on the PolicyEngine (data plane).
+     *
+     * This grants runtime read access to policy engine configuration. Use this for
+     * monitoring, observability, or read-only administrative roles that need to inspect
+     * policy engine settings at runtime.
+     *
+     * [disable-awslint:no-grants]
+     *
+     * @param grantee - The IAM principal to grant read permissions to
+     * @returns An IAM Grant object representing the granted permissions
+     */
+    grantRead(grantee) {
+        return this.grant(grantee, ...perms_1.POLICY_ENGINE_READ_PERMS);
+    }
+    /**
+     * Grants permissions to evaluate policies at runtime (data plane operations).
+     *
+     * This is the primary permission needed by Gateway execution roles to evaluate
+     * authorization decisions during agent requests. Grant this to roles that need
+     * to call AuthorizeAction or PartiallyAuthorizeActions at runtime.
+     *
+     * [disable-awslint:no-grants]
+     *
+     * @param grantee - The IAM principal to grant evaluation permissions to
+     * @returns An IAM Grant object representing the granted permissions
+     */
+    grantEvaluate(grantee) {
+        return this.grant(grantee, ...perms_1.POLICY_ENGINE_EVALUATE_PERMS);
+    }
+    /**
+     * Grants the full set of permissions required for a gateway execution role to use
+     * this policy engine, correctly scoped to both the policy engine and gateway ARNs.
+     *
+     * Per the AWS docs:
+     * - `GetPolicyEngine` → policy engine ARN only
+     * - `AuthorizeAction` + `PartiallyAuthorizeActions` → policy engine ARN **and** gateway ARN
+     *
+     * [disable-awslint:no-grants]
+     *
+     * @param grantee - The IAM principal (gateway execution role) to grant permissions to
+     * @param gateway - The gateway that will use this policy engine [disable-awslint:prefer-ref-interface]
+     * @returns A combined IAM Grant representing all granted permissions
+     */
+    grantEvaluateForGateway(grantee, gateway) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_bedrock_agentcore_alpha_IGateway(gateway);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.grantEvaluateForGateway);
+            }
+            throw error;
+        }
+        const getPolicyEngineGrant = this.grant(grantee, 'bedrock-agentcore:GetPolicyEngine');
+        // using  gateway.name here to avoid a circular dependency between PolicyEngine and Gateway that
+        // arises if we try to reference gateway.gatewayArn.
+        // Additionally, BedrockAgentCore appends a random suffix to gateway names at creation time, so the exact ARN
+        // is unknowable at synthesis. Using `${gateway.name}-*` allows us to correctly match the actual ARN at runtime.
+        const gatewayResourceName = aws_cdk_lib_1.Token.isUnresolved(gateway.name) ? '*' : `${gateway.name}-*`;
+        const gatewayArn = aws_cdk_lib_1.Stack.of(this).formatArn({
+            service: 'bedrock-agentcore',
+            resource: 'gateway',
+            resourceName: gatewayResourceName,
+        });
+        const authorizationGrant = iam.Grant.addToPrincipal({
+            grantee,
+            actions: [
+                'bedrock-agentcore:AuthorizeAction',
+                'bedrock-agentcore:PartiallyAuthorizeActions',
+            ],
+            resourceArns: [this.policyEngineArn, gatewayArn],
+        });
+        return getPolicyEngineGrant.combine(authorizationGrant);
+    }
+    /**
+     * Return the given named metric for this policy engine.
+     *
+     * By default, the metric will be calculated as a sum over a period of 5 minutes.
+     * You can customize this by using the `statistic` and `period` properties.
+     *
+     * @param metricName The name of the metric
+     * @param dimensions Additional dimensions for the metric
+     * @param props Optional metric configuration
+     */
+    metric(metricName, dimensions, props) {
+        const metricProps = {
+            namespace: 'AWS/Bedrock-AgentCore',
+            metricName,
+            dimensionsMap: { ...dimensions, Resource: this.policyEngineArn },
+            ...props,
+        };
+        return this.configureMetric(metricProps);
+    }
+    /**
+     * Return a metric containing the total number of authorizations for this policy engine.
+     *
+     * This metric tracks all authorization requests processed by the policy engine.
+     *
+     * @param props Optional metric configuration
+     */
+    metricAuthorizations(props) {
+        return this.metric('Authorizations', {}, { statistic: aws_cloudwatch_1.Stats.SUM, ...props });
+    }
+    /**
+     * Return a metric measuring the authorization latency for this policy engine.
+     *
+     * This metric represents the time taken to evaluate authorization policies.
+     *
+     * @param props Optional metric configuration
+     */
+    metricAuthorizationLatency(props) {
+        return this.metric('AuthorizationLatency', {}, { statistic: aws_cloudwatch_1.Stats.AVERAGE, ...props });
+    }
+    /**
+     * Return a metric containing the number of denied authorization requests for this policy engine.
+     *
+     * This metric tracks authorization requests that were explicitly denied by policies.
+     *
+     * @param props Optional metric configuration
+     */
+    metricDeniedRequests(props) {
+        return this.metric('DeniedRequests', {}, { statistic: aws_cloudwatch_1.Stats.SUM, ...props });
+    }
+    /**
+     * Return a metric containing the number of errors during authorization for this policy engine.
+     *
+     * This metric tracks errors encountered during policy evaluation.
+     *
+     * @param props Optional metric configuration
+     */
+    metricErrors(props) {
+        return this.metric('Errors', {}, { statistic: aws_cloudwatch_1.Stats.SUM, ...props });
+    }
+    /**
+     * Internal method to create a metric.
+     */
+    configureMetric(props) {
+        return new aws_cloudwatch_1.Metric({
+            ...props,
+            region: props?.region ?? this.stack.region,
+            account: props?.account ?? this.stack.account,
+        });
+    }
+}
+exports.PolicyEngineBase = PolicyEngineBase;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"policy-engine-base.js","sourceRoot":"","sources":["policy-engine-base.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 type { IResource, ResourceProps } from 'aws-cdk-lib';\nimport { Resource, Stack, Token } from 'aws-cdk-lib';\nimport type { IPolicyEngineRef, PolicyEngineReference } from 'aws-cdk-lib/aws-bedrockagentcore';\nimport type { DimensionsMap, MetricOptions, MetricProps } from 'aws-cdk-lib/aws-cloudwatch';\nimport { Metric, Stats } from 'aws-cdk-lib/aws-cloudwatch';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport type * as kms from 'aws-cdk-lib/aws-kms';\nimport type { Construct } from 'constructs';\n// Internal imports\nimport { POLICY_ENGINE_EVALUATE_PERMS, POLICY_ENGINE_READ_PERMS } from './perms';\nimport type { IGateway } from '../gateway/gateway-base';\n\n/******************************************************************************\n *                                Interface\n *****************************************************************************/\n\n/**\n * Contains all properties and methods for both created and imported policy engines.\n */\nexport interface IPolicyEngine extends IResource, IPolicyEngineRef, iam.IGrantable {\n  /**\n   * The ARN of the policy engine resource\n   * @attribute\n   */\n  readonly policyEngineArn: string;\n\n  /**\n   * The ID of the policy engine\n   * @attribute\n   */\n  readonly policyEngineId: string;\n\n  /**\n   * The name of the policy engine\n   * @attribute\n   */\n  readonly policyEngineName: string;\n\n  /**\n   * The description of the policy engine\n   */\n  readonly description?: string;\n\n  /**\n   * The KMS key used for encryption\n   */\n  readonly kmsKey?: kms.IKey;\n\n  /**\n   * Grants IAM actions to the IAM Principal\n   *\n   * @param grantee - The IAM principal to grant permissions to\n   * @param actions - The actions to grant\n   */\n  grant(grantee: iam.IGrantable, ...actions: string[]): iam.Grant;\n\n  /**\n   * Grants read permissions on the PolicyEngine.\n   *\n   * This grants runtime read access to policy engine configuration. Use this for\n   * monitoring, observability, or read-only administrative roles.\n   *\n   * @param grantee - The IAM principal to grant read permissions to\n   */\n  grantRead(grantee: iam.IGrantable): iam.Grant;\n\n  /**\n   * Grants permissions to evaluate policies at runtime .\n   *\n   * This is the primary permission needed by Gateway execution roles to evaluate\n   * authorization decisions during agent requests. Grant this to roles that need\n   * to call AuthorizeAction or PartiallyAuthorizeActions.\n   *\n   * @param grantee - The IAM principal to grant evaluation permissions to\n   */\n  grantEvaluate(grantee: iam.IGrantable): iam.Grant;\n\n  /**\n   * Grants the full set of permissions required for a gateway execution role to use\n   * this policy engine, correctly scoped to both the policy engine and gateway ARNs.\n   *\n   * Per the AWS docs, `AuthorizeAction` and `PartiallyAuthorizeActions` require\n   * both the policy engine ARN and the gateway ARN as resources, while\n   * `GetPolicyEngine` only needs the policy engine ARN.\n   *\n   * This follows the same pattern as Lambda's `grantInvokeVersion(grantee, version)`.\n   *\n   * @param grantee - The IAM principal (gateway execution role) to grant permissions to\n   * @param gateway - The gateway that will use this policy engine [disable-awslint:prefer-ref-interface]\n   */\n  grantEvaluateForGateway(grantee: iam.IGrantable, gateway: IGateway): iam.Grant;\n\n  /**\n   * Return the given named metric for this policy engine.\n   *\n   * @param metricName The name of the metric\n   * @param dimensions Additional dimensions for the metric\n   * @param props Optional metric configuration\n   */\n  metric(metricName: string, dimensions: DimensionsMap, props?: MetricOptions): Metric;\n\n  /**\n   * Return a metric measuring the authorization latency for this policy engine.\n   *\n   * This metric represents the time taken to evaluate authorization policies.\n   *\n   * @param props Optional metric configuration\n   */\n  metricAuthorizationLatency(props?: MetricOptions): Metric;\n\n  /**\n   * Return a metric containing the number of denied authorization requests for this policy engine.\n   *\n   * This metric tracks authorization requests that were explicitly denied by policies.\n   *\n   * @param props Optional metric configuration\n   */\n  metricDeniedRequests(props?: MetricOptions): Metric;\n\n  /**\n   * Return a metric containing the number of errors during authorization for this policy engine.\n   *\n   * This metric tracks errors encountered during policy evaluation.\n   *\n   * @param props Optional metric configuration\n   */\n  metricErrors(props?: MetricOptions): Metric;\n}\n\n/**\n * Attributes for importing an existing PolicyEngine\n */\nexport interface PolicyEngineAttributes {\n  /**\n   * The ARN of the policy engine\n   */\n  readonly policyEngineArn: string;\n\n  /**\n   * The KMS key ARN used for encryption (optional)\n   *\n   * @default - No KMS key\n   */\n  readonly kmsKeyArn?: string;\n}\n\n/******************************************************************************\n *                        ABSTRACT BASE CLASS\n *****************************************************************************/\n\n/**\n * Abstract base class for a PolicyEngine.\n * Contains methods and attributes valid for PolicyEngines either created with CDK or imported.\n */\nexport abstract class PolicyEngineBase extends Resource implements IPolicyEngine {\n  public abstract readonly policyEngineArn: string;\n  public abstract readonly policyEngineId: string;\n  public abstract readonly policyEngineName: string;\n  public abstract readonly description?: string;\n  public abstract readonly kmsKey?: kms.IKey;\n\n  /**\n   * The principal to grant permissions to\n   */\n  public abstract readonly grantPrincipal: iam.IPrincipal;\n\n  /**\n   * A reference to this PolicyEngine resource.\n   */\n  public get policyEngineRef(): PolicyEngineReference {\n    return {\n      policyEngineArn: this.policyEngineArn,\n    };\n  }\n\n  constructor(scope: Construct, id: string, props: ResourceProps = {}) {\n    super(scope, id, props);\n  }\n\n  /**\n   * Grants IAM actions to the IAM Principal\n   *\n   * [disable-awslint:no-grants]\n   *\n   * @param grantee - The IAM principal to grant permissions to\n   * @param actions - The actions to grant\n   * @returns An IAM Grant object representing the granted permissions\n   */\n  public grant(grantee: iam.IGrantable, ...actions: string[]): iam.Grant {\n    return iam.Grant.addToPrincipal({\n      grantee,\n      actions,\n      resourceArns: [this.policyEngineArn],\n    });\n  }\n\n  /**\n   * Grants read permissions on the PolicyEngine (data plane).\n   *\n   * This grants runtime read access to policy engine configuration. Use this for\n   * monitoring, observability, or read-only administrative roles that need to inspect\n   * policy engine settings at runtime.\n   *\n   * [disable-awslint:no-grants]\n   *\n   * @param grantee - The IAM principal to grant read permissions to\n   * @returns An IAM Grant object representing the granted permissions\n   */\n  public grantRead(grantee: iam.IGrantable): iam.Grant {\n    return this.grant(grantee, ...POLICY_ENGINE_READ_PERMS);\n  }\n\n  /**\n   * Grants permissions to evaluate policies at runtime (data plane operations).\n   *\n   * This is the primary permission needed by Gateway execution roles to evaluate\n   * authorization decisions during agent requests. Grant this to roles that need\n   * to call AuthorizeAction or PartiallyAuthorizeActions at runtime.\n   *\n   * [disable-awslint:no-grants]\n   *\n   * @param grantee - The IAM principal to grant evaluation permissions to\n   * @returns An IAM Grant object representing the granted permissions\n   */\n  public grantEvaluate(grantee: iam.IGrantable): iam.Grant {\n    return this.grant(grantee, ...POLICY_ENGINE_EVALUATE_PERMS);\n  }\n\n  /**\n   * Grants the full set of permissions required for a gateway execution role to use\n   * this policy engine, correctly scoped to both the policy engine and gateway ARNs.\n   *\n   * Per the AWS docs:\n   * - `GetPolicyEngine` → policy engine ARN only\n   * - `AuthorizeAction` + `PartiallyAuthorizeActions` → policy engine ARN **and** gateway ARN\n   *\n   * [disable-awslint:no-grants]\n   *\n   * @param grantee - The IAM principal (gateway execution role) to grant permissions to\n   * @param gateway - The gateway that will use this policy engine [disable-awslint:prefer-ref-interface]\n   * @returns A combined IAM Grant representing all granted permissions\n   */\n  public grantEvaluateForGateway(grantee: iam.IGrantable, gateway: IGateway): iam.Grant {\n    const getPolicyEngineGrant = this.grant(grantee, 'bedrock-agentcore:GetPolicyEngine');\n\n    // using  gateway.name here to avoid a circular dependency between PolicyEngine and Gateway that\n    // arises if we try to reference gateway.gatewayArn.\n    // Additionally, BedrockAgentCore appends a random suffix to gateway names at creation time, so the exact ARN\n    // is unknowable at synthesis. Using `${gateway.name}-*` allows us to correctly match the actual ARN at runtime.\n    const gatewayResourceName = Token.isUnresolved(gateway.name) ? '*' : `${gateway.name}-*`;\n    const gatewayArn = Stack.of(this).formatArn({\n      service: 'bedrock-agentcore',\n      resource: 'gateway',\n      resourceName: gatewayResourceName,\n    });\n\n    const authorizationGrant = iam.Grant.addToPrincipal({\n      grantee,\n      actions: [\n        'bedrock-agentcore:AuthorizeAction',\n        'bedrock-agentcore:PartiallyAuthorizeActions',\n      ],\n      resourceArns: [this.policyEngineArn, gatewayArn],\n    });\n\n    return getPolicyEngineGrant.combine(authorizationGrant);\n  }\n\n  /**\n   * Return the given named metric for this policy engine.\n   *\n   * By default, the metric will be calculated as a sum over a period of 5 minutes.\n   * You can customize this by using the `statistic` and `period` properties.\n   *\n   * @param metricName The name of the metric\n   * @param dimensions Additional dimensions for the metric\n   * @param props Optional metric configuration\n   */\n  public metric(metricName: string, dimensions: DimensionsMap, props?: MetricOptions): Metric {\n    const metricProps: MetricProps = {\n      namespace: 'AWS/Bedrock-AgentCore',\n      metricName,\n      dimensionsMap: { ...dimensions, Resource: this.policyEngineArn },\n      ...props,\n    };\n    return this.configureMetric(metricProps);\n  }\n\n  /**\n   * Return a metric containing the total number of authorizations for this policy engine.\n   *\n   * This metric tracks all authorization requests processed by the policy engine.\n   *\n   * @param props Optional metric configuration\n   */\n  public metricAuthorizations(props?: MetricOptions): Metric {\n    return this.metric('Authorizations', {}, { statistic: Stats.SUM, ...props });\n  }\n\n  /**\n   * Return a metric measuring the authorization latency for this policy engine.\n   *\n   * This metric represents the time taken to evaluate authorization policies.\n   *\n   * @param props Optional metric configuration\n   */\n  public metricAuthorizationLatency(props?: MetricOptions): Metric {\n    return this.metric('AuthorizationLatency', {}, { statistic: Stats.AVERAGE, ...props });\n  }\n\n  /**\n   * Return a metric containing the number of denied authorization requests for this policy engine.\n   *\n   * This metric tracks authorization requests that were explicitly denied by policies.\n   *\n   * @param props Optional metric configuration\n   */\n  public metricDeniedRequests(props?: MetricOptions): Metric {\n    return this.metric('DeniedRequests', {}, { statistic: Stats.SUM, ...props });\n  }\n\n  /**\n   * Return a metric containing the number of errors during authorization for this policy engine.\n   *\n   * This metric tracks errors encountered during policy evaluation.\n   *\n   * @param props Optional metric configuration\n   */\n  public metricErrors(props?: MetricOptions): Metric {\n    return this.metric('Errors', {}, { statistic: Stats.SUM, ...props });\n  }\n\n  /**\n   * Internal method to create a metric.\n   */\n  private configureMetric(props: MetricProps) {\n    return new Metric({\n      ...props,\n      region: props?.region ?? this.stack.region,\n      account: props?.account ?? this.stack.account,\n    });\n  }\n}\n"]}

package/lib/policy/policy-engine.d.ts

@@ -0,0 +1,150 @@
+/**
+ *  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.
+ */
+import * as iam from 'aws-cdk-lib/aws-iam';
+import * as kms from 'aws-cdk-lib/aws-kms';
+import type { Construct } from 'constructs';
+import { Policy } from './policy';
+import { PolicyEngineBase } from './policy-engine-base';
+import type { IPolicyEngine, PolicyEngineAttributes } from './policy-engine-base';
+import type { AddPolicyOptions } from './policy-types';
+/**
+ * Properties for creating a PolicyEngine resource
+ */
+export interface PolicyEngineProps {
+    /**
+     * The name of the policy engine.
+     * Valid characters: a-z, A-Z, 0-9, _ (underscore)
+     * Must start with a letter, 1-48 characters
+     * Pattern: ^[A-Za-z][A-Za-z0-9_]*$
+     *
+     * @default - Auto-generated unique name
+     */
+    readonly policyEngineName?: string;
+    /**
+     * Optional description for the policy engine.
+     * Maximum 4,096 characters.
+     *
+     * @default - No description
+     */
+    readonly description?: string;
+    /**
+     * Custom KMS key for encryption.
+     * [disable-awslint:prefer-ref-interface]
+     *
+     * @default - AWS owned key
+     */
+    readonly kmsKey?: kms.IKey;
+    /**
+     * Tags for the policy engine.
+     * Maximum 50 tags.
+     *
+     * @default - No tags
+     */
+    readonly tags?: {
+        [key: string]: string;
+    };
+}
+/**
+ * Container that manages Cedar authorization policies associated with gateways.
+ * PolicyEngine enables deterministic authorization control for Bedrock agents,
+ * allowing fine-grained access control to tools and actions via Cedar policy language.
+ *
+ * @see https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/policy-engine.html
+ * @resource AWS::BedrockAgentCore::PolicyEngine
+ */
+export declare class PolicyEngine extends PolicyEngineBase {
+    /** Uniquely identifies this class. */
+    static readonly PROPERTY_INJECTION_ID: string;
+    /**
+     * Creates a PolicyEngine reference from an existing policy engine's attributes.
+     *
+     * @param scope - The construct scope
+     * @param id - Identifier of the construct
+     * @param attrs - Attributes of the existing policy engine
+     * @returns An IPolicyEngine reference to the existing policy engine
+     */
+    static fromPolicyEngineAttributes(scope: Construct, id: string, attrs: PolicyEngineAttributes): IPolicyEngine;
+    /**
+     * The ARN of the policy engine resource.
+     * @attribute
+     */
+    readonly policyEngineArn: string;
+    /**
+     * The name of the policy engine.
+     *
+     * [disable-awslint:attribute-tag]
+     */
+    readonly policyEngineName: string;
+    /**
+     * The ID of the policy engine.
+     * @attribute
+     */
+    readonly policyEngineId: string;
+    /**
+     * The description of the policy engine.
+     */
+    readonly description?: string;
+    /**
+     * Tags applied to this policy engine resource.
+     * @default - No tags applied
+     */
+    readonly tags?: {
+        [key: string]: string;
+    };
+    /**
+     * The principal to grant permissions to.
+     */
+    readonly grantPrincipal: iam.IPrincipal;
+    /**
+     * The KMS key used to encrypt the policy engine.
+     */
+    readonly kmsKey?: kms.IKey;
+    /**
+     * List of policies added to this policy engine via addPolicy().
+     * @internal
+     */
+    private readonly _policies;
+    /**
+     * The last policy added to this engine, used for automatic sequential chaining.
+     * @internal
+     */
+    private _lastPolicy?;
+    /**
+     * Get the list of policies added to this policy engine.
+     *
+     * Returns an array of Policy constructs that were added using addPolicy().
+     * This allows you to iterate over all policies associated with this engine.
+     *
+     * @returns A copy of the policies array
+     */
+    get policies(): Policy[];
+    private readonly __resource;
+    constructor(scope: Construct, id: string, props?: PolicyEngineProps);
+    /**
+     * Add a policy to this policy engine.
+     * Convenience method that creates a Policy construct with this engine as the parent.
+     *
+     * **Automatic Sequential Chaining**: By default, policies are automatically chained
+     * sequentially to prevent concurrent creation issues with the AWS Bedrock AgentCore
+     * service. Each new policy will depend on the previous policy added to this engine.
+     *
+     * This ensures policies are created one at a time, avoiding "Resource stabilization
+     * failed" errors that occur with concurrent policy operations.
+     *
+     * @param id - Unique identifier for the policy construct
+     * @param options - Options for creating the policy
+     * @returns The created Policy construct
+     *
+     */
+    addPolicy(id: string, options: AddPolicyOptions): Policy;
+}