@aws-amplify/graphql-api-construct 1.18.2 → 1.18.3

package/node_modules/@aws-cdk/cloudformation-diff/lib/iam/iam-changes.js

@@ -0,0 +1,246 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IamChanges = void 0;
+const cfnspec = require("@aws-cdk/cfnspec");
+const chalk = require("chalk");
+const managed_policy_1 = require("./managed-policy");
+const statement_1 = require("./statement");
+const diffable_1 = require("../diffable");
+const render_intrinsics_1 = require("../render-intrinsics");
+const util_1 = require("../util");
+/**
+ * Changes to IAM statements
+ */
+class IamChanges {
+    constructor(props) {
+        this.statements = new diffable_1.DiffableCollection();
+        this.managedPolicies = new diffable_1.DiffableCollection();
+        for (const propertyChange of props.propertyChanges) {
+            this.readPropertyChange(propertyChange);
+        }
+        for (const resourceChange of props.resourceChanges) {
+            this.readResourceChange(resourceChange);
+        }
+        this.statements.calculateDiff();
+        this.managedPolicies.calculateDiff();
+    }
+    get hasChanges() {
+        return this.statements.hasChanges || this.managedPolicies.hasChanges;
+    }
+    /**
+     * Return whether the changes include broadened permissions
+     *
+     * Permissions are broadened if positive statements are added or
+     * negative statements are removed, or if managed policies are added.
+     */
+    get permissionsBroadened() {
+        return this.statements.additions.some(s => !s.isNegativeStatement)
+            || this.statements.removals.some(s => s.isNegativeStatement)
+            || this.managedPolicies.hasAdditions;
+    }
+    /**
+     * Return a summary table of changes
+     */
+    summarizeStatements() {
+        const ret = [];
+        const header = ['', 'Resource', 'Effect', 'Action', 'Principal', 'Condition'];
+        // First generate all lines, then sort on Resource so that similar resources are together
+        for (const statement of this.statements.additions) {
+            const renderedStatement = statement.render();
+            ret.push([
+                '+',
+                renderedStatement.resource,
+                renderedStatement.effect,
+                renderedStatement.action,
+                renderedStatement.principal,
+                renderedStatement.condition,
+            ].map(s => chalk.green(s)));
+        }
+        for (const statement of this.statements.removals) {
+            const renderedStatement = statement.render();
+            ret.push([
+                chalk.red('-'),
+                renderedStatement.resource,
+                renderedStatement.effect,
+                renderedStatement.action,
+                renderedStatement.principal,
+                renderedStatement.condition,
+            ].map(s => chalk.red(s)));
+        }
+        // Sort by 2nd column
+        ret.sort(util_1.makeComparator((row) => [row[1]]));
+        ret.splice(0, 0, header);
+        return ret;
+    }
+    summarizeManagedPolicies() {
+        const ret = [];
+        const header = ['', 'Resource', 'Managed Policy ARN'];
+        for (const att of this.managedPolicies.additions) {
+            ret.push([
+                '+',
+                att.identityArn,
+                att.managedPolicyArn,
+            ].map(s => chalk.green(s)));
+        }
+        for (const att of this.managedPolicies.removals) {
+            ret.push([
+                '-',
+                att.identityArn,
+                att.managedPolicyArn,
+            ].map(s => chalk.red(s)));
+        }
+        // Sort by 2nd column
+        ret.sort(util_1.makeComparator((row) => [row[1]]));
+        ret.splice(0, 0, header);
+        return ret;
+    }
+    /**
+     * Return a machine-readable version of the changes.
+     * This is only used in tests.
+     *
+     * @internal
+     */
+    _toJson() {
+        return util_1.deepRemoveUndefined({
+            statementAdditions: util_1.dropIfEmpty(this.statements.additions.map(s => s._toJson())),
+            statementRemovals: util_1.dropIfEmpty(this.statements.removals.map(s => s._toJson())),
+            managedPolicyAdditions: util_1.dropIfEmpty(this.managedPolicies.additions.map(s => s._toJson())),
+            managedPolicyRemovals: util_1.dropIfEmpty(this.managedPolicies.removals.map(s => s._toJson())),
+        });
+    }
+    readPropertyChange(propertyChange) {
+        switch (propertyChange.scrutinyType) {
+            case cfnspec.schema.PropertyScrutinyType.InlineIdentityPolicies:
+                // AWS::IAM::{ Role | User | Group }.Policies
+                this.statements.addOld(...this.readIdentityPolicies(propertyChange.oldValue, propertyChange.resourceLogicalId));
+                this.statements.addNew(...this.readIdentityPolicies(propertyChange.newValue, propertyChange.resourceLogicalId));
+                break;
+            case cfnspec.schema.PropertyScrutinyType.InlineResourcePolicy:
+                // Any PolicyDocument on a resource (including AssumeRolePolicyDocument)
+                this.statements.addOld(...this.readResourceStatements(propertyChange.oldValue, propertyChange.resourceLogicalId));
+                this.statements.addNew(...this.readResourceStatements(propertyChange.newValue, propertyChange.resourceLogicalId));
+                break;
+            case cfnspec.schema.PropertyScrutinyType.ManagedPolicies:
+                // Just a list of managed policies
+                this.managedPolicies.addOld(...this.readManagedPolicies(propertyChange.oldValue, propertyChange.resourceLogicalId));
+                this.managedPolicies.addNew(...this.readManagedPolicies(propertyChange.newValue, propertyChange.resourceLogicalId));
+                break;
+        }
+    }
+    readResourceChange(resourceChange) {
+        switch (resourceChange.scrutinyType) {
+            case cfnspec.schema.ResourceScrutinyType.IdentityPolicyResource:
+                // AWS::IAM::Policy
+                this.statements.addOld(...this.readIdentityPolicyResource(resourceChange.oldProperties));
+                this.statements.addNew(...this.readIdentityPolicyResource(resourceChange.newProperties));
+                break;
+            case cfnspec.schema.ResourceScrutinyType.ResourcePolicyResource:
+                // AWS::*::{Bucket,Queue,Topic}Policy
+                this.statements.addOld(...this.readResourcePolicyResource(resourceChange.oldProperties));
+                this.statements.addNew(...this.readResourcePolicyResource(resourceChange.newProperties));
+                break;
+            case cfnspec.schema.ResourceScrutinyType.LambdaPermission:
+                this.statements.addOld(...this.readLambdaStatements(resourceChange.oldProperties));
+                this.statements.addNew(...this.readLambdaStatements(resourceChange.newProperties));
+                break;
+        }
+    }
+    /**
+     * Parse a list of policies on an identity
+     */
+    readIdentityPolicies(policies, logicalId) {
+        if (policies === undefined) {
+            return [];
+        }
+        const appliesToPrincipal = 'AWS:${' + logicalId + '}';
+        return util_1.flatMap(policies, (policy) => {
+            // check if the Policy itself is not an intrinsic, like an Fn::If
+            const unparsedStatement = policy.PolicyDocument?.Statement
+                ? policy.PolicyDocument.Statement
+                : policy;
+            return defaultPrincipal(appliesToPrincipal, statement_1.parseStatements(render_intrinsics_1.renderIntrinsics(unparsedStatement)));
+        });
+    }
+    /**
+     * Parse an IAM::Policy resource
+     */
+    readIdentityPolicyResource(properties) {
+        if (properties === undefined) {
+            return [];
+        }
+        properties = render_intrinsics_1.renderIntrinsics(properties);
+        const principals = (properties.Groups || []).concat(properties.Users || []).concat(properties.Roles || []);
+        return util_1.flatMap(principals, (principal) => {
+            const ref = 'AWS:' + principal;
+            return defaultPrincipal(ref, statement_1.parseStatements(properties.PolicyDocument.Statement));
+        });
+    }
+    readResourceStatements(policy, logicalId) {
+        if (policy === undefined) {
+            return [];
+        }
+        const appliesToResource = '${' + logicalId + '.Arn}';
+        return defaultResource(appliesToResource, statement_1.parseStatements(render_intrinsics_1.renderIntrinsics(policy.Statement)));
+    }
+    /**
+     * Parse an AWS::*::{Bucket,Topic,Queue}policy
+     */
+    readResourcePolicyResource(properties) {
+        if (properties === undefined) {
+            return [];
+        }
+        properties = render_intrinsics_1.renderIntrinsics(properties);
+        const policyKeys = Object.keys(properties).filter(key => key.indexOf('Policy') > -1);
+        // Find the key that identifies the resource(s) this policy applies to
+        const resourceKeys = Object.keys(properties).filter(key => !policyKeys.includes(key) && !key.endsWith('Name'));
+        let resources = resourceKeys.length === 1 ? properties[resourceKeys[0]] : ['???'];
+        // For some resources, this is a singleton string, for some it's an array
+        if (!Array.isArray(resources)) {
+            resources = [resources];
+        }
+        return util_1.flatMap(resources, (resource) => {
+            return defaultResource(resource, statement_1.parseStatements(properties[policyKeys[0]].Statement));
+        });
+    }
+    readManagedPolicies(policyArns, logicalId) {
+        if (!policyArns) {
+            return [];
+        }
+        const rep = '${' + logicalId + '}';
+        return managed_policy_1.ManagedPolicyAttachment.parseManagedPolicies(rep, render_intrinsics_1.renderIntrinsics(policyArns));
+    }
+    readLambdaStatements(properties) {
+        if (!properties) {
+            return [];
+        }
+        return [statement_1.parseLambdaPermission(render_intrinsics_1.renderIntrinsics(properties))];
+    }
+}
+exports.IamChanges = IamChanges;
+IamChanges.IamPropertyScrutinies = [
+    cfnspec.schema.PropertyScrutinyType.InlineIdentityPolicies,
+    cfnspec.schema.PropertyScrutinyType.InlineResourcePolicy,
+    cfnspec.schema.PropertyScrutinyType.ManagedPolicies,
+];
+IamChanges.IamResourceScrutinies = [
+    cfnspec.schema.ResourceScrutinyType.ResourcePolicyResource,
+    cfnspec.schema.ResourceScrutinyType.IdentityPolicyResource,
+    cfnspec.schema.ResourceScrutinyType.LambdaPermission,
+];
+/**
+ * Set an undefined or wildcarded principal on these statements
+ */
+function defaultPrincipal(principal, statements) {
+    statements.forEach(s => s.principals.replaceEmpty(principal));
+    statements.forEach(s => s.principals.replaceStar(principal));
+    return statements;
+}
+/**
+ * Set an undefined or wildcarded resource on these statements
+ */
+function defaultResource(resource, statements) {
+    statements.forEach(s => s.resources.replaceEmpty(resource));
+    statements.forEach(s => s.resources.replaceStar(resource));
+    return statements;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"iam-changes.js","sourceRoot":"","sources":["iam-changes.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cfnspec from '@aws-cdk/cfnspec';\nimport * as chalk from 'chalk';\nimport { ManagedPolicyAttachment, ManagedPolicyJson } from './managed-policy';\nimport { parseLambdaPermission, parseStatements, Statement, StatementJson } from './statement';\nimport { PropertyChange, PropertyMap, ResourceChange } from '../diff/types';\nimport { DiffableCollection } from '../diffable';\nimport { renderIntrinsics } from '../render-intrinsics';\nimport { deepRemoveUndefined, dropIfEmpty, flatMap, makeComparator } from '../util';\n\nexport interface IamChangesProps {\n  propertyChanges: PropertyChange[];\n  resourceChanges: ResourceChange[];\n}\n\n/**\n * Changes to IAM statements\n */\nexport class IamChanges {\n  public static IamPropertyScrutinies = [\n    cfnspec.schema.PropertyScrutinyType.InlineIdentityPolicies,\n    cfnspec.schema.PropertyScrutinyType.InlineResourcePolicy,\n    cfnspec.schema.PropertyScrutinyType.ManagedPolicies,\n  ];\n\n  public static IamResourceScrutinies = [\n    cfnspec.schema.ResourceScrutinyType.ResourcePolicyResource,\n    cfnspec.schema.ResourceScrutinyType.IdentityPolicyResource,\n    cfnspec.schema.ResourceScrutinyType.LambdaPermission,\n  ];\n\n  public readonly statements = new DiffableCollection<Statement>();\n  public readonly managedPolicies = new DiffableCollection<ManagedPolicyAttachment>();\n\n  constructor(props: IamChangesProps) {\n    for (const propertyChange of props.propertyChanges) {\n      this.readPropertyChange(propertyChange);\n    }\n    for (const resourceChange of props.resourceChanges) {\n      this.readResourceChange(resourceChange);\n    }\n\n    this.statements.calculateDiff();\n    this.managedPolicies.calculateDiff();\n  }\n\n  public get hasChanges() {\n    return this.statements.hasChanges || this.managedPolicies.hasChanges;\n  }\n\n  /**\n   * Return whether the changes include broadened permissions\n   *\n   * Permissions are broadened if positive statements are added or\n   * negative statements are removed, or if managed policies are added.\n   */\n  public get permissionsBroadened(): boolean {\n    return this.statements.additions.some(s => !s.isNegativeStatement)\n        || this.statements.removals.some(s => s.isNegativeStatement)\n        || this.managedPolicies.hasAdditions;\n  }\n\n  /**\n   * Return a summary table of changes\n   */\n  public summarizeStatements(): string[][] {\n    const ret: string[][] = [];\n\n    const header = ['', 'Resource', 'Effect', 'Action', 'Principal', 'Condition'];\n\n    // First generate all lines, then sort on Resource so that similar resources are together\n    for (const statement of this.statements.additions) {\n      const renderedStatement = statement.render();\n      ret.push([\n        '+',\n        renderedStatement.resource,\n        renderedStatement.effect,\n        renderedStatement.action,\n        renderedStatement.principal,\n        renderedStatement.condition,\n      ].map(s => chalk.green(s)));\n    }\n    for (const statement of this.statements.removals) {\n      const renderedStatement = statement.render();\n      ret.push([\n        chalk.red('-'),\n        renderedStatement.resource,\n        renderedStatement.effect,\n        renderedStatement.action,\n        renderedStatement.principal,\n        renderedStatement.condition,\n      ].map(s => chalk.red(s)));\n    }\n\n    // Sort by 2nd column\n    ret.sort(makeComparator((row: string[]) => [row[1]]));\n\n    ret.splice(0, 0, header);\n\n    return ret;\n  }\n\n  public summarizeManagedPolicies(): string[][] {\n    const ret: string[][] = [];\n    const header = ['', 'Resource', 'Managed Policy ARN'];\n\n    for (const att of this.managedPolicies.additions) {\n      ret.push([\n        '+',\n        att.identityArn,\n        att.managedPolicyArn,\n      ].map(s => chalk.green(s)));\n    }\n    for (const att of this.managedPolicies.removals) {\n      ret.push([\n        '-',\n        att.identityArn,\n        att.managedPolicyArn,\n      ].map(s => chalk.red(s)));\n    }\n\n    // Sort by 2nd column\n    ret.sort(makeComparator((row: string[]) => [row[1]]));\n\n    ret.splice(0, 0, header);\n\n    return ret;\n  }\n\n  /**\n   * Return a machine-readable version of the changes.\n   * This is only used in tests.\n   *\n   * @internal\n   */\n  public _toJson(): IamChangesJson {\n    return deepRemoveUndefined({\n      statementAdditions: dropIfEmpty(this.statements.additions.map(s => s._toJson())),\n      statementRemovals: dropIfEmpty(this.statements.removals.map(s => s._toJson())),\n      managedPolicyAdditions: dropIfEmpty(this.managedPolicies.additions.map(s => s._toJson())),\n      managedPolicyRemovals: dropIfEmpty(this.managedPolicies.removals.map(s => s._toJson())),\n    });\n  }\n\n  private readPropertyChange(propertyChange: PropertyChange) {\n    switch (propertyChange.scrutinyType) {\n      case cfnspec.schema.PropertyScrutinyType.InlineIdentityPolicies:\n        // AWS::IAM::{ Role | User | Group }.Policies\n        this.statements.addOld(...this.readIdentityPolicies(propertyChange.oldValue, propertyChange.resourceLogicalId));\n        this.statements.addNew(...this.readIdentityPolicies(propertyChange.newValue, propertyChange.resourceLogicalId));\n        break;\n      case cfnspec.schema.PropertyScrutinyType.InlineResourcePolicy:\n        // Any PolicyDocument on a resource (including AssumeRolePolicyDocument)\n        this.statements.addOld(...this.readResourceStatements(propertyChange.oldValue, propertyChange.resourceLogicalId));\n        this.statements.addNew(...this.readResourceStatements(propertyChange.newValue, propertyChange.resourceLogicalId));\n        break;\n      case cfnspec.schema.PropertyScrutinyType.ManagedPolicies:\n        // Just a list of managed policies\n        this.managedPolicies.addOld(...this.readManagedPolicies(propertyChange.oldValue, propertyChange.resourceLogicalId));\n        this.managedPolicies.addNew(...this.readManagedPolicies(propertyChange.newValue, propertyChange.resourceLogicalId));\n        break;\n    }\n  }\n\n  private readResourceChange(resourceChange: ResourceChange) {\n    switch (resourceChange.scrutinyType) {\n      case cfnspec.schema.ResourceScrutinyType.IdentityPolicyResource:\n        // AWS::IAM::Policy\n        this.statements.addOld(...this.readIdentityPolicyResource(resourceChange.oldProperties));\n        this.statements.addNew(...this.readIdentityPolicyResource(resourceChange.newProperties));\n        break;\n      case cfnspec.schema.ResourceScrutinyType.ResourcePolicyResource:\n        // AWS::*::{Bucket,Queue,Topic}Policy\n        this.statements.addOld(...this.readResourcePolicyResource(resourceChange.oldProperties));\n        this.statements.addNew(...this.readResourcePolicyResource(resourceChange.newProperties));\n        break;\n      case cfnspec.schema.ResourceScrutinyType.LambdaPermission:\n        this.statements.addOld(...this.readLambdaStatements(resourceChange.oldProperties));\n        this.statements.addNew(...this.readLambdaStatements(resourceChange.newProperties));\n        break;\n    }\n  }\n\n  /**\n   * Parse a list of policies on an identity\n   */\n  private readIdentityPolicies(policies: any, logicalId: string): Statement[] {\n    if (policies === undefined) { return []; }\n\n    const appliesToPrincipal = 'AWS:${' + logicalId + '}';\n\n    return flatMap(policies, (policy: any) => {\n      // check if the Policy itself is not an intrinsic, like an Fn::If\n      const unparsedStatement = policy.PolicyDocument?.Statement\n        ? policy.PolicyDocument.Statement\n        : policy;\n      return defaultPrincipal(appliesToPrincipal, parseStatements(renderIntrinsics(unparsedStatement)));\n    });\n  }\n\n  /**\n   * Parse an IAM::Policy resource\n   */\n  private readIdentityPolicyResource(properties: any): Statement[] {\n    if (properties === undefined) { return []; }\n\n    properties = renderIntrinsics(properties);\n\n    const principals = (properties.Groups || []).concat(properties.Users || []).concat(properties.Roles || []);\n    return flatMap(principals, (principal: string) => {\n      const ref = 'AWS:' + principal;\n      return defaultPrincipal(ref, parseStatements(properties.PolicyDocument.Statement));\n    });\n  }\n\n  private readResourceStatements(policy: any, logicalId: string): Statement[] {\n    if (policy === undefined) { return []; }\n\n    const appliesToResource = '${' + logicalId + '.Arn}';\n    return defaultResource(appliesToResource, parseStatements(renderIntrinsics(policy.Statement)));\n  }\n\n  /**\n   * Parse an AWS::*::{Bucket,Topic,Queue}policy\n   */\n  private readResourcePolicyResource(properties: any): Statement[] {\n    if (properties === undefined) { return []; }\n\n    properties = renderIntrinsics(properties);\n\n    const policyKeys = Object.keys(properties).filter(key => key.indexOf('Policy') > -1);\n\n    // Find the key that identifies the resource(s) this policy applies to\n    const resourceKeys = Object.keys(properties).filter(key => !policyKeys.includes(key) && !key.endsWith('Name'));\n    let resources = resourceKeys.length === 1 ? properties[resourceKeys[0]] : ['???'];\n\n    // For some resources, this is a singleton string, for some it's an array\n    if (!Array.isArray(resources)) {\n      resources = [resources];\n    }\n\n    return flatMap(resources, (resource: string) => {\n      return defaultResource(resource, parseStatements(properties[policyKeys[0]].Statement));\n    });\n  }\n\n  private readManagedPolicies(policyArns: any, logicalId: string): ManagedPolicyAttachment[] {\n    if (!policyArns) { return []; }\n\n    const rep = '${' + logicalId + '}';\n    return ManagedPolicyAttachment.parseManagedPolicies(rep, renderIntrinsics(policyArns));\n  }\n\n  private readLambdaStatements(properties?: PropertyMap): Statement[] {\n    if (!properties) { return []; }\n\n    return [parseLambdaPermission(renderIntrinsics(properties))];\n  }\n}\n\n/**\n * Set an undefined or wildcarded principal on these statements\n */\nfunction defaultPrincipal(principal: string, statements: Statement[]) {\n  statements.forEach(s => s.principals.replaceEmpty(principal));\n  statements.forEach(s => s.principals.replaceStar(principal));\n  return statements;\n}\n\n/**\n * Set an undefined or wildcarded resource on these statements\n */\nfunction defaultResource(resource: string, statements: Statement[]) {\n  statements.forEach(s => s.resources.replaceEmpty(resource));\n  statements.forEach(s => s.resources.replaceStar(resource));\n  return statements;\n}\n\nexport interface IamChangesJson {\n  statementAdditions?: StatementJson[];\n  statementRemovals?: StatementJson[];\n  managedPolicyAdditions?: ManagedPolicyJson[];\n  managedPolicyRemovals?: ManagedPolicyJson[];\n}\n"]}

package/node_modules/@aws-cdk/cloudformation-diff/lib/iam/managed-policy.d.ts

@@ -0,0 +1,18 @@
+export declare class ManagedPolicyAttachment {
+    readonly identityArn: string;
+    readonly managedPolicyArn: string;
+    static parseManagedPolicies(identityArn: string, arns: string | string[]): ManagedPolicyAttachment[];
+    constructor(identityArn: string, managedPolicyArn: string);
+    equal(other: ManagedPolicyAttachment): boolean;
+    /**
+     * Return a machine-readable version of the changes.
+     * This is only used in tests.
+     *
+     * @internal
+     */
+    _toJson(): ManagedPolicyJson;
+}
+export interface ManagedPolicyJson {
+    identityArn: string;
+    managedPolicyArn: string;
+}

package/node_modules/@aws-cdk/cloudformation-diff/lib/iam/managed-policy.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManagedPolicyAttachment = void 0;
+class ManagedPolicyAttachment {
+    constructor(identityArn, managedPolicyArn) {
+        this.identityArn = identityArn;
+        this.managedPolicyArn = managedPolicyArn;
+    }
+    static parseManagedPolicies(identityArn, arns) {
+        return typeof arns === 'string'
+            ? [new ManagedPolicyAttachment(identityArn, arns)]
+            : arns.map((arn) => new ManagedPolicyAttachment(identityArn, arn));
+    }
+    equal(other) {
+        return this.identityArn === other.identityArn
+            && this.managedPolicyArn === other.managedPolicyArn;
+    }
+    /**
+     * Return a machine-readable version of the changes.
+     * This is only used in tests.
+     *
+     * @internal
+     */
+    _toJson() {
+        return { identityArn: this.identityArn, managedPolicyArn: this.managedPolicyArn };
+    }
+}
+exports.ManagedPolicyAttachment = ManagedPolicyAttachment;
+//# sourceMappingURL=data:application/json;base64,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

package/node_modules/@aws-cdk/cloudformation-diff/lib/iam/statement.d.ts

@@ -0,0 +1,127 @@
+export declare class Statement {
+    /**
+     * Statement ID
+     */
+    readonly sid: string | undefined;
+    /**
+     * Statement effect
+     */
+    readonly effect: Effect;
+    /**
+     * Resources
+     */
+    readonly resources: Targets;
+    /**
+     * Principals
+     */
+    readonly principals: Targets;
+    /**
+     * Actions
+     */
+    readonly actions: Targets;
+    /**
+     * Object with conditions
+     */
+    readonly condition?: any;
+    private readonly serializedIntrinsic;
+    constructor(statement: UnknownMap | string);
+    /**
+     * Whether this statement is equal to the other statement
+     */
+    equal(other: Statement): boolean;
+    render(): RenderedStatement;
+    /**
+     * Return a machine-readable version of the changes.
+     * This is only used in tests.
+     *
+     * @internal
+     */
+    _toJson(): StatementJson;
+    /**
+     * Whether this is a negative statement
+     *
+     * A statement is negative if any of its targets are negative, inverted
+     * if the Effect is Deny.
+     */
+    get isNegativeStatement(): boolean;
+}
+export interface RenderedStatement {
+    readonly resource: string;
+    readonly effect: string;
+    readonly action: string;
+    readonly principal: string;
+    readonly condition: string;
+}
+export interface StatementJson {
+    sid?: string;
+    effect: string;
+    resources: TargetsJson;
+    actions: TargetsJson;
+    principals: TargetsJson;
+    condition?: any;
+}
+export interface TargetsJson {
+    not: boolean;
+    values: string[];
+}
+/**
+ * Parse a list of statements from undefined, a Statement, or a list of statements
+ */
+export declare function parseStatements(x: any): Statement[];
+/**
+ * Parse a Statement from a Lambda::Permission object
+ *
+ * This is actually what Lambda adds to the policy document if you call AddPermission.
+ */
+export declare function parseLambdaPermission(x: any): Statement;
+/**
+ * Targets for a field
+ */
+export declare class Targets {
+    /**
+     * The values of the targets
+     */
+    readonly values: string[];
+    /**
+     * Whether positive or negative matchers
+     */
+    readonly not: boolean;
+    constructor(statement: UnknownMap, positiveKey: string, negativeKey: string);
+    get empty(): boolean;
+    /**
+     * Whether this set of targets is equal to the other set of targets
+     */
+    equal(other: Targets): any;
+    /**
+     * If the current value set is empty, put this in it
+     */
+    replaceEmpty(replacement: string): void;
+    /**
+     * If the actions contains a '*', replace with this string.
+     */
+    replaceStar(replacement: string): void;
+    /**
+     * Render into a summary table cell
+     */
+    render(): string;
+    /**
+     * Return a machine-readable version of the changes.
+     * This is only used in tests.
+     *
+     * @internal
+     */
+    _toJson(): TargetsJson;
+}
+declare type UnknownMap = {
+    [key: string]: unknown;
+};
+export declare enum Effect {
+    Unknown = "Unknown",
+    Allow = "Allow",
+    Deny = "Deny"
+}
+/**
+ * Render the Condition column
+ */
+export declare function renderCondition(condition: any): string;
+export {};