@aws-cdk/app-staging-synthesizer-alpha 2.82.0-alpha.0

package/lib/app-staging-synthesizer.js

@@ -0,0 +1,255 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppStagingSynthesizer = 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 helpers_internal_1 = require("aws-cdk-lib/core/lib/helpers-internal");
+const bootstrap_roles_1 = require("./bootstrap-roles");
+const default_staging_stack_1 = require("./default-staging-stack");
+const per_env_staging_factory_1 = require("./per-env-staging-factory");
+const app_global_1 = require("./private/app-global");
+const no_tokens_1 = require("./private/no-tokens");
+const AGNOSTIC_STACKS = new app_global_1.AppScopedGlobal(() => new Set());
+const ENV_AWARE_STACKS = new app_global_1.AppScopedGlobal(() => new Set());
+/**
+ * App Staging Synthesizer
+ */
+class AppStagingSynthesizer extends aws_cdk_lib_1.StackSynthesizer {
+    /**
+     * Use the Default Staging Resources, creating a single stack per environment this app is deployed in
+     */
+    static defaultResources(options) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_app_staging_synthesizer_alpha_DefaultResourcesOptions(options);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.defaultResources);
+            }
+            throw error;
+        }
+        (0, no_tokens_1.validateNoTokens)(options, 'AppStagingSynthesizer');
+        return AppStagingSynthesizer.customFactory({
+            factory: default_staging_stack_1.DefaultStagingStack.factory(options),
+            deploymentIdentities: options.deploymentIdentities,
+            bootstrapQualifier: options.bootstrapQualifier,
+            oncePerEnv: true,
+        });
+    }
+    /**
+     * Use these exact staging resources for every stack that this synthesizer is used for
+     */
+    static customResources(options) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_app_staging_synthesizer_alpha_CustomResourcesOptions(options);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.customResources);
+            }
+            throw error;
+        }
+        return AppStagingSynthesizer.customFactory({
+            deploymentIdentities: options.deploymentIdentities,
+            bootstrapQualifier: options.bootstrapQualifier,
+            oncePerEnv: false,
+            factory: {
+                obtainStagingResources() {
+                    return options.resources;
+                },
+            },
+        });
+    }
+    /**
+     * Supply your own stagingStackFactory method for creating an IStagingStack when
+     * a stack is bound to the synthesizer.
+     *
+     * By default, `oncePerEnv = true`, which means that a new instance of the IStagingStack
+     * will be created in new environments. Set `oncePerEnv = false` to turn off that behavior.
+     */
+    static customFactory(options) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_app_staging_synthesizer_alpha_CustomFactoryOptions(options);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.customFactory);
+            }
+            throw error;
+        }
+        const oncePerEnv = options.oncePerEnv ?? true;
+        const factory = oncePerEnv ? new per_env_staging_factory_1.PerEnvironmentStagingFactory(options.factory) : options.factory;
+        return new AppStagingSynthesizer({
+            factory,
+            bootstrapQualifier: options.bootstrapQualifier,
+            deploymentIdentities: options.deploymentIdentities,
+        });
+    }
+    constructor(props) {
+        super();
+        this.props = props;
+        this.roles = {
+            deploymentRole: props.deploymentIdentities?.roles.deploymentRole ??
+                bootstrap_roles_1.BootstrapRole.fromRoleArn(AppStagingSynthesizer.DEFAULT_DEPLOY_ROLE_ARN),
+            cloudFormationExecutionRole: props.deploymentIdentities?.roles.cloudFormationExecutionRole ??
+                bootstrap_roles_1.BootstrapRole.fromRoleArn(AppStagingSynthesizer.DEFAULT_CLOUDFORMATION_ROLE_ARN),
+            lookupRole: this.props.deploymentIdentities?.roles.lookupRole ??
+                bootstrap_roles_1.BootstrapRole.fromRoleArn(AppStagingSynthesizer.DEFAULT_LOOKUP_ROLE_ARN),
+        };
+    }
+    /**
+     * Returns a version of the synthesizer bound to a stack.
+     */
+    reusableBind(stack) {
+        this.checkEnvironmentGnosticism(stack);
+        const qualifier = this.props.bootstrapQualifier ??
+            stack.node.tryGetContext(aws_cdk_lib_1.BOOTSTRAP_QUALIFIER_CONTEXT) ??
+            AppStagingSynthesizer.DEFAULT_QUALIFIER;
+        const spec = new helpers_internal_1.StringSpecializer(stack, qualifier);
+        const deployRole = this.roles.deploymentRole._specialize(spec);
+        const context = {
+            environmentString: [
+                aws_cdk_lib_1.Token.isUnresolved(stack.account) ? 'ACCOUNT' : stack.account,
+                aws_cdk_lib_1.Token.isUnresolved(stack.region) ? 'REGION' : stack.region,
+            ].join('-'),
+            deployRoleArn: deployRole._arnForCloudFormation(),
+            qualifier,
+        };
+        return new BoundAppStagingSynthesizer(stack, {
+            stagingResources: this.props.factory.obtainStagingResources(stack, context),
+            deployRole,
+            cloudFormationExecutionRole: this.roles.cloudFormationExecutionRole._specialize(spec),
+            lookupRole: this.roles.lookupRole._specialize(spec),
+            qualifier,
+        });
+    }
+    /**
+     * Implemented for legacy purposes; this will never be called.
+     */
+    bind(_stack) {
+        throw new Error('This is a legacy API, call reusableBind instead');
+    }
+    /**
+     * Implemented for legacy purposes; this will never be called.
+     */
+    synthesize(_session) {
+        throw new Error('This is a legacy API, call reusableBind instead');
+    }
+    /**
+     * Implemented for legacy purposes; this will never be called.
+     */
+    addFileAsset(_asset) {
+        throw new Error('This is a legacy API, call reusableBind instead');
+    }
+    /**
+     * Implemented for legacy purposes; this will never be called.
+     */
+    addDockerImageAsset(_asset) {
+        throw new Error('This is a legacy API, call reusableBind instead');
+    }
+    /**
+     * Check that we're only being used for exclusively gnostic or agnostic stacks.
+     *
+     * We can think about whether to loosen this requirement later.
+     */
+    checkEnvironmentGnosticism(stack) {
+        const isAgnostic = aws_cdk_lib_1.Token.isUnresolved(stack.account) || aws_cdk_lib_1.Token.isUnresolved(stack.region);
+        const agnosticStacks = AGNOSTIC_STACKS.for(stack);
+        const envAwareStacks = ENV_AWARE_STACKS.for(stack);
+        (isAgnostic ? agnosticStacks : envAwareStacks).add(stack);
+        if (agnosticStacks.size > 0 && envAwareStacks.size > 0) {
+            const describeStacks = (xs) => Array.from(xs).map(s => s.node.path).join(', ');
+            throw new Error([
+                'It is not safe to use AppStagingSynthesizer for both environment-agnostic and environment-aware stacks at the same time.',
+                'Please either specify environments for all stacks or no stacks in the CDK App.',
+                `Stacks with environment: ${describeStacks(agnosticStacks)}.`,
+                `Stacks without environment: ${describeStacks(envAwareStacks)}.`,
+            ].join(' '));
+        }
+    }
+}
+_a = JSII_RTTI_SYMBOL_1;
+AppStagingSynthesizer[_a] = { fqn: "@aws-cdk/app-staging-synthesizer-alpha.AppStagingSynthesizer", version: "2.82.0-alpha.0" };
+/**
+ * Default ARN qualifier
+ */
+AppStagingSynthesizer.DEFAULT_QUALIFIER = 'hnb659fds';
+/**
+ * Default CloudFormation role ARN.
+ */
+AppStagingSynthesizer.DEFAULT_CLOUDFORMATION_ROLE_ARN = 'arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-${Qualifier}-cfn-exec-role-${AWS::AccountId}-${AWS::Region}';
+/**
+ * Default deploy role ARN.
+ */
+AppStagingSynthesizer.DEFAULT_DEPLOY_ROLE_ARN = 'arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-${Qualifier}-deploy-role-${AWS::AccountId}-${AWS::Region}';
+/**
+ * Default lookup role ARN for missing values.
+ */
+AppStagingSynthesizer.DEFAULT_LOOKUP_ROLE_ARN = 'arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-${Qualifier}-lookup-role-${AWS::AccountId}-${AWS::Region}';
+exports.AppStagingSynthesizer = AppStagingSynthesizer;
+class BoundAppStagingSynthesizer extends aws_cdk_lib_1.StackSynthesizer {
+    constructor(stack, props) {
+        super();
+        this.props = props;
+        this.assetManifest = new aws_cdk_lib_1.AssetManifestBuilder();
+        this.dependencyStacks = new Set();
+        super.bind(stack);
+        this.qualifier = props.qualifier;
+        this.stagingStack = props.stagingResources;
+    }
+    /**
+     * The qualifier used to bootstrap this stack
+     */
+    get bootstrapQualifier() {
+        // Not sure why we need this.
+        return this.qualifier;
+    }
+    synthesize(session) {
+        const templateAssetSource = this.synthesizeTemplate(session, this.props.lookupRole?._arnForCloudAssembly());
+        const templateAsset = this.addFileAsset(templateAssetSource);
+        const dependencies = Array.from(this.dependencyStacks).flatMap((d) => d.artifactId);
+        const assetManifestId = this.assetManifest.emitManifest(this.boundStack, session, {}, dependencies);
+        const lookupRoleArn = this.props.lookupRole?._arnForCloudAssembly();
+        this.emitArtifact(session, {
+            assumeRoleArn: this.props.deployRole?._arnForCloudAssembly(),
+            additionalDependencies: [assetManifestId],
+            stackTemplateAssetObjectUrl: templateAsset.s3ObjectUrlWithPlaceholders,
+            cloudFormationExecutionRoleArn: this.props.cloudFormationExecutionRole?._arnForCloudAssembly(),
+            lookupRole: lookupRoleArn ? { arn: lookupRoleArn } : undefined,
+        });
+    }
+    /**
+     * Add a file asset to the manifest.
+     */
+    addFileAsset(asset) {
+        const { bucketName, assumeRoleArn, prefix, dependencyStack } = this.stagingStack.addFile(asset);
+        const location = this.assetManifest.defaultAddFileAsset(this.boundStack, asset, {
+            bucketName: (0, helpers_internal_1.translateCfnTokenToAssetToken)(bucketName),
+            bucketPrefix: prefix,
+            role: assumeRoleArn ? { assumeRoleArn: (0, helpers_internal_1.translateCfnTokenToAssetToken)(assumeRoleArn) } : undefined,
+        });
+        if (dependencyStack) {
+            this.boundStack.addDependency(dependencyStack, 'stack depends on the staging stack for staging resources');
+            this.dependencyStacks.add(dependencyStack);
+        }
+        return this.cloudFormationLocationFromFileAsset(location);
+    }
+    /**
+     * Add a docker image asset to the manifest.
+     */
+    addDockerImageAsset(asset) {
+        const { repoName, assumeRoleArn, dependencyStack } = this.stagingStack.addDockerImage(asset);
+        const location = this.assetManifest.defaultAddDockerImageAsset(this.boundStack, asset, {
+            repositoryName: (0, helpers_internal_1.translateCfnTokenToAssetToken)(repoName),
+            role: assumeRoleArn ? { assumeRoleArn: (0, helpers_internal_1.translateCfnTokenToAssetToken)(assumeRoleArn) } : undefined,
+        });
+        if (dependencyStack) {
+            this.boundStack.addDependency(dependencyStack, 'stack depends on the staging stack for staging resources');
+            this.dependencyStacks.add(dependencyStack);
+        }
+        return this.cloudFormationLocationFromDockerImageAsset(location);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app-staging-synthesizer.js","sourceRoot":"","sources":["app-staging-synthesizer.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AssetManifestBuilder,\n  BOOTSTRAP_QUALIFIER_CONTEXT,\n  DockerImageAssetLocation,\n  DockerImageAssetSource,\n  FileAssetLocation,\n  FileAssetSource,\n  IBoundStackSynthesizer as IBoundAppStagingSynthesizer,\n  IReusableStackSynthesizer,\n  ISynthesisSession,\n  Stack,\n  StackSynthesizer,\n  Token,\n} from 'aws-cdk-lib';\nimport { StringSpecializer, translateCfnTokenToAssetToken } from 'aws-cdk-lib/core/lib/helpers-internal';\nimport { BootstrapRole, BootstrapRoles, DeploymentIdentities } from './bootstrap-roles';\nimport { DefaultStagingStack, DefaultStagingStackOptions } from './default-staging-stack';\nimport { PerEnvironmentStagingFactory as PerEnvironmentStagingFactory } from './per-env-staging-factory';\nimport { AppScopedGlobal } from './private/app-global';\nimport { validateNoTokens } from './private/no-tokens';\nimport { IStagingResources, IStagingResourcesFactory, ObtainStagingResourcesContext } from './staging-stack';\n\nconst AGNOSTIC_STACKS = new AppScopedGlobal(() => new Set<Stack>());\nconst ENV_AWARE_STACKS = new AppScopedGlobal(() => new Set<Stack>());\n\n/**\n * Options that apply to all AppStagingSynthesizer variants\n */\nexport interface AppStagingSynthesizerOptions {\n  /**\n   * What roles to use to deploy applications\n   *\n   * These are the roles that have permissions to interact with CloudFormation\n   * on your behalf. By default these are the standard bootstrapped CDK roles,\n   * but you can customize them or turn them off and use the CLI credentials\n   * to deploy.\n   *\n   * @default - The standard bootstrapped CDK roles\n   */\n  readonly deploymentIdentities?: DeploymentIdentities;\n\n  /**\n   * Qualifier to disambiguate multiple bootstrapped environments in the same account\n   *\n   * This qualifier is only used to reference bootstrapped resources. It will not\n   * be used in the creation of app-specific staging resources: `appId` is used for that\n   * instead.\n   *\n   * @default - Value of context key '@aws-cdk/core:bootstrapQualifier' if set, otherwise `DEFAULT_QUALIFIER`\n   */\n  readonly bootstrapQualifier?: string;\n}\n\n/**\n * Properties for stackPerEnv static method\n */\nexport interface DefaultResourcesOptions extends AppStagingSynthesizerOptions, DefaultStagingStackOptions {}\n\n/**\n * Properties for customFactory static method\n */\nexport interface CustomFactoryOptions extends AppStagingSynthesizerOptions {\n  /**\n   * The factory that will be used to return staging resources for each stack\n   */\n  readonly factory: IStagingResourcesFactory;\n\n  /**\n   * Reuse the answer from the factory for stacks in the same environment\n   *\n   * @default true\n   */\n  readonly oncePerEnv?: boolean;\n}\n\n/**\n * Properties for customResources static method\n */\nexport interface CustomResourcesOptions extends AppStagingSynthesizerOptions {\n  /**\n   * Use these exact staging resources for every stack that this synthesizer is used for\n   */\n  readonly resources: IStagingResources;\n}\n\n/**\n * Internal properties for AppStagingSynthesizer\n */\ninterface AppStagingSynthesizerProps extends AppStagingSynthesizerOptions {\n  /**\n   * A factory method that creates an IStagingStack when given the stack the\n   * synthesizer is binding.\n   */\n  readonly factory: IStagingResourcesFactory;\n}\n\n/**\n * App Staging Synthesizer\n */\nexport class AppStagingSynthesizer extends StackSynthesizer implements IReusableStackSynthesizer {\n  /**\n   * Default ARN qualifier\n   */\n  public static readonly DEFAULT_QUALIFIER = 'hnb659fds';\n\n  /**\n   * Default CloudFormation role ARN.\n   */\n  public static readonly DEFAULT_CLOUDFORMATION_ROLE_ARN = 'arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-${Qualifier}-cfn-exec-role-${AWS::AccountId}-${AWS::Region}';\n\n  /**\n   * Default deploy role ARN.\n   */\n  public static readonly DEFAULT_DEPLOY_ROLE_ARN = 'arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-${Qualifier}-deploy-role-${AWS::AccountId}-${AWS::Region}';\n\n  /**\n   * Default lookup role ARN for missing values.\n   */\n  public static readonly DEFAULT_LOOKUP_ROLE_ARN = 'arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-${Qualifier}-lookup-role-${AWS::AccountId}-${AWS::Region}';\n\n  /**\n   * Use the Default Staging Resources, creating a single stack per environment this app is deployed in\n   */\n  public static defaultResources(options: DefaultResourcesOptions) {\n    validateNoTokens(options, 'AppStagingSynthesizer');\n\n    return AppStagingSynthesizer.customFactory({\n      factory: DefaultStagingStack.factory(options),\n      deploymentIdentities: options.deploymentIdentities,\n      bootstrapQualifier: options.bootstrapQualifier,\n      oncePerEnv: true,\n    });\n  }\n\n  /**\n   * Use these exact staging resources for every stack that this synthesizer is used for\n   */\n  public static customResources(options: CustomResourcesOptions) {\n    return AppStagingSynthesizer.customFactory({\n      deploymentIdentities: options.deploymentIdentities,\n      bootstrapQualifier: options.bootstrapQualifier,\n      oncePerEnv: false,\n      factory: {\n        obtainStagingResources() {\n          return options.resources;\n        },\n      },\n    });\n  }\n\n  /**\n   * Supply your own stagingStackFactory method for creating an IStagingStack when\n   * a stack is bound to the synthesizer.\n   *\n   * By default, `oncePerEnv = true`, which means that a new instance of the IStagingStack\n   * will be created in new environments. Set `oncePerEnv = false` to turn off that behavior.\n   */\n  public static customFactory(options: CustomFactoryOptions) {\n    const oncePerEnv = options.oncePerEnv ?? true;\n    const factory = oncePerEnv ? new PerEnvironmentStagingFactory(options.factory) : options.factory;\n\n    return new AppStagingSynthesizer({\n      factory,\n      bootstrapQualifier: options.bootstrapQualifier,\n      deploymentIdentities: options.deploymentIdentities,\n    });\n  }\n\n  private readonly roles: Required<BootstrapRoles>;\n\n  private constructor(private readonly props: AppStagingSynthesizerProps) {\n    super();\n\n    this.roles = {\n      deploymentRole: props.deploymentIdentities?.roles.deploymentRole ??\n        BootstrapRole.fromRoleArn(AppStagingSynthesizer.DEFAULT_DEPLOY_ROLE_ARN),\n      cloudFormationExecutionRole: props.deploymentIdentities?.roles.cloudFormationExecutionRole ??\n        BootstrapRole.fromRoleArn(AppStagingSynthesizer.DEFAULT_CLOUDFORMATION_ROLE_ARN),\n      lookupRole: this.props.deploymentIdentities?.roles.lookupRole ??\n        BootstrapRole.fromRoleArn(AppStagingSynthesizer.DEFAULT_LOOKUP_ROLE_ARN),\n    };\n  }\n\n  /**\n   * Returns a version of the synthesizer bound to a stack.\n   */\n  public reusableBind(stack: Stack): IBoundAppStagingSynthesizer {\n    this.checkEnvironmentGnosticism(stack);\n    const qualifier = this.props.bootstrapQualifier ??\n      stack.node.tryGetContext(BOOTSTRAP_QUALIFIER_CONTEXT) ??\n      AppStagingSynthesizer.DEFAULT_QUALIFIER;\n    const spec = new StringSpecializer(stack, qualifier);\n\n    const deployRole = this.roles.deploymentRole._specialize(spec);\n\n    const context: ObtainStagingResourcesContext = {\n      environmentString: [\n        Token.isUnresolved(stack.account) ? 'ACCOUNT' : stack.account,\n        Token.isUnresolved(stack.region) ? 'REGION' : stack.region,\n      ].join('-'),\n      deployRoleArn: deployRole._arnForCloudFormation(),\n      qualifier,\n    };\n\n    return new BoundAppStagingSynthesizer(stack, {\n      stagingResources: this.props.factory.obtainStagingResources(stack, context),\n      deployRole,\n      cloudFormationExecutionRole: this.roles.cloudFormationExecutionRole._specialize(spec),\n      lookupRole: this.roles.lookupRole._specialize(spec),\n      qualifier,\n    });\n  }\n\n  /**\n   * Implemented for legacy purposes; this will never be called.\n   */\n  public bind(_stack: Stack) {\n    throw new Error('This is a legacy API, call reusableBind instead');\n  }\n\n  /**\n   * Implemented for legacy purposes; this will never be called.\n   */\n  public synthesize(_session: ISynthesisSession): void {\n    throw new Error('This is a legacy API, call reusableBind instead');\n  }\n\n  /**\n   * Implemented for legacy purposes; this will never be called.\n   */\n  public addFileAsset(_asset: FileAssetSource): FileAssetLocation {\n    throw new Error('This is a legacy API, call reusableBind instead');\n  }\n\n  /**\n   * Implemented for legacy purposes; this will never be called.\n   */\n  public addDockerImageAsset(_asset: DockerImageAssetSource): DockerImageAssetLocation {\n    throw new Error('This is a legacy API, call reusableBind instead');\n  }\n\n  /**\n   * Check that we're only being used for exclusively gnostic or agnostic stacks.\n   *\n   * We can think about whether to loosen this requirement later.\n   */\n  private checkEnvironmentGnosticism(stack: Stack) {\n    const isAgnostic = Token.isUnresolved(stack.account) || Token.isUnresolved(stack.region);\n    const agnosticStacks = AGNOSTIC_STACKS.for(stack);\n    const envAwareStacks = ENV_AWARE_STACKS.for(stack);\n\n    (isAgnostic ? agnosticStacks : envAwareStacks).add(stack);\n    if (agnosticStacks.size > 0 && envAwareStacks.size > 0) {\n\n      const describeStacks = (xs: Set<Stack>) => Array.from(xs).map(s => s.node.path).join(', ');\n\n      throw new Error([\n        'It is not safe to use AppStagingSynthesizer for both environment-agnostic and environment-aware stacks at the same time.',\n        'Please either specify environments for all stacks or no stacks in the CDK App.',\n        `Stacks with environment: ${describeStacks(agnosticStacks)}.`,\n        `Stacks without environment: ${describeStacks(envAwareStacks)}.`,\n      ].join(' '));\n    }\n  }\n}\n\n/**\n * Internal properties for BoundAppStagingSynthesizer\n */\ninterface BoundAppStagingSynthesizerProps {\n  /**\n   * The bootstrap qualifier\n   */\n  readonly qualifier: string;\n\n  /**\n   * The resources we end up using for this synthesizer\n   */\n  readonly stagingResources: IStagingResources;\n\n  /**\n   * The deploy role\n   */\n  readonly deployRole: BootstrapRole;\n\n  /**\n   * CloudFormation Execution Role\n   */\n  readonly cloudFormationExecutionRole: BootstrapRole;\n\n  /**\n   * Lookup Role\n   */\n  readonly lookupRole: BootstrapRole;\n}\n\nclass BoundAppStagingSynthesizer extends StackSynthesizer implements IBoundAppStagingSynthesizer {\n  private readonly stagingStack: IStagingResources;\n  private readonly assetManifest = new AssetManifestBuilder();\n  private readonly qualifier: string;\n  private readonly dependencyStacks: Set<Stack> = new Set();\n\n  constructor(stack: Stack, private readonly props: BoundAppStagingSynthesizerProps) {\n    super();\n    super.bind(stack);\n\n    this.qualifier = props.qualifier;\n    this.stagingStack = props.stagingResources;\n  }\n  /**\n   * The qualifier used to bootstrap this stack\n   */\n  public get bootstrapQualifier(): string | undefined {\n    // Not sure why we need this.\n    return this.qualifier;\n  }\n\n  public synthesize(session: ISynthesisSession): void {\n    const templateAssetSource = this.synthesizeTemplate(session, this.props.lookupRole?._arnForCloudAssembly());\n    const templateAsset = this.addFileAsset(templateAssetSource);\n\n    const dependencies = Array.from(this.dependencyStacks).flatMap((d) => d.artifactId);\n    const assetManifestId = this.assetManifest.emitManifest(this.boundStack, session, {}, dependencies);\n\n    const lookupRoleArn = this.props.lookupRole?._arnForCloudAssembly();\n\n    this.emitArtifact(session, {\n      assumeRoleArn: this.props.deployRole?._arnForCloudAssembly(),\n      additionalDependencies: [assetManifestId],\n      stackTemplateAssetObjectUrl: templateAsset.s3ObjectUrlWithPlaceholders,\n      cloudFormationExecutionRoleArn: this.props.cloudFormationExecutionRole?._arnForCloudAssembly(),\n      lookupRole: lookupRoleArn ? { arn: lookupRoleArn } : undefined,\n    });\n  }\n\n  /**\n   * Add a file asset to the manifest.\n   */\n  public addFileAsset(asset: FileAssetSource): FileAssetLocation {\n    const { bucketName, assumeRoleArn, prefix, dependencyStack } = this.stagingStack.addFile(asset);\n    const location = this.assetManifest.defaultAddFileAsset(this.boundStack, asset, {\n      bucketName: translateCfnTokenToAssetToken(bucketName),\n      bucketPrefix: prefix,\n      role: assumeRoleArn ? { assumeRoleArn: translateCfnTokenToAssetToken(assumeRoleArn) } : undefined,\n    });\n\n    if (dependencyStack) {\n      this.boundStack.addDependency(dependencyStack, 'stack depends on the staging stack for staging resources');\n      this.dependencyStacks.add(dependencyStack);\n    }\n\n    return this.cloudFormationLocationFromFileAsset(location);\n  }\n\n  /**\n   * Add a docker image asset to the manifest.\n   */\n  public addDockerImageAsset(asset: DockerImageAssetSource): DockerImageAssetLocation {\n    const { repoName, assumeRoleArn, dependencyStack } = this.stagingStack.addDockerImage(asset);\n    const location = this.assetManifest.defaultAddDockerImageAsset(this.boundStack, asset, {\n      repositoryName: translateCfnTokenToAssetToken(repoName),\n      role: assumeRoleArn ? { assumeRoleArn: translateCfnTokenToAssetToken(assumeRoleArn) } : undefined,\n    });\n\n    if (dependencyStack) {\n      this.boundStack.addDependency(dependencyStack, 'stack depends on the staging stack for staging resources');\n      this.dependencyStacks.add(dependencyStack);\n    }\n\n    return this.cloudFormationLocationFromDockerImageAsset(location);\n  }\n}\n"]}

package/lib/bootstrap-roles.d.ts

@@ -0,0 +1,93 @@
+import { StringSpecializer } from 'aws-cdk-lib/core/lib/helpers-internal';
+/**
+ * Bootstrapped role specifier. These roles must exist already.
+ * This class does not create new IAM Roles.
+ */
+export declare class BootstrapRole {
+    private readonly roleArn;
+    /**
+     * Use the currently assumed role/credentials
+     */
+    static cliCredentials(): BootstrapRole;
+    /**
+     * Specify an existing IAM Role to assume
+     */
+    static fromRoleArn(arn: string): BootstrapRole;
+    private static CLI_CREDS;
+    private constructor();
+    /**
+     * Whether or not this is object was created using BootstrapRole.cliCredentials()
+     */
+    isCliCredentials(): boolean;
+    /**
+     * @internal
+     */
+    _arnForCloudFormation(): string | undefined;
+    /**
+     * @internal
+     */
+    _arnForCloudAssembly(): string | undefined;
+    /**
+     * @internal
+     */
+    _specialize(spec: StringSpecializer): BootstrapRole;
+}
+/**
+ * Deployment identities are the class of roles to be assumed by the CDK
+ * when deploying the App.
+ */
+export declare class DeploymentIdentities {
+    /** roles that are bootstrapped to your account. */
+    readonly roles: BootstrapRoles;
+    /**
+     * Use CLI credentials for all deployment identities.
+     */
+    static cliCredentials(): DeploymentIdentities;
+    /**
+     * Specify your own roles for all deployment identities. These roles
+     * must already exist.
+     */
+    static specifyRoles(roles: BootstrapRoles): DeploymentIdentities;
+    private constructor();
+}
+/**
+ * Roles that are bootstrapped to your account.
+ */
+export interface BootstrapRoles {
+    /**
+     * CloudFormation Execution Role
+     *
+     * @default - use bootstrapped role
+     */
+    readonly cloudFormationExecutionRole?: BootstrapRole;
+    /**
+     * Deployment Action Role
+     *
+     * @default - use boostrapped role
+     */
+    readonly deploymentRole?: BootstrapRole;
+    /**
+     * Lookup Role
+     *
+     * @default - use bootstrapped role
+     */
+    readonly lookupRole?: BootstrapRole;
+}
+/**
+ * Roles that are included in the Staging Stack
+ * (for access to Staging Resources)
+ */
+export interface StagingRoles {
+    /**
+     * File Asset Publishing Role
+     *
+     * @default - staging stack creates a file asset publishing role
+     */
+    readonly fileAssetPublishingRole?: BootstrapRole;
+    /**
+     * Docker Asset Publishing Role
+     *
+     * @default - staging stack creates a docker asset publishing role
+     */
+    readonly dockerAssetPublishingRole?: BootstrapRole;
+}

package/lib/bootstrap-roles.js

@@ -0,0 +1,98 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeploymentIdentities = exports.BootstrapRole = void 0;
+const jsiiDeprecationWarnings = require("../.warnings.jsii.js");
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const helpers_internal_1 = require("aws-cdk-lib/core/lib/helpers-internal");
+/**
+ * Bootstrapped role specifier. These roles must exist already.
+ * This class does not create new IAM Roles.
+ */
+class BootstrapRole {
+    /**
+     * Use the currently assumed role/credentials
+     */
+    static cliCredentials() {
+        return new BootstrapRole(BootstrapRole.CLI_CREDS);
+    }
+    /**
+     * Specify an existing IAM Role to assume
+     */
+    static fromRoleArn(arn) {
+        helpers_internal_1.StringSpecializer.validateNoTokens(arn, 'BootstrapRole ARN');
+        return new BootstrapRole(arn);
+    }
+    constructor(roleArn) {
+        this.roleArn = roleArn;
+    }
+    /**
+     * Whether or not this is object was created using BootstrapRole.cliCredentials()
+     */
+    isCliCredentials() {
+        return this.roleArn === BootstrapRole.CLI_CREDS;
+    }
+    /**
+     * @internal
+     */
+    _arnForCloudFormation() {
+        return this.isCliCredentials() ? undefined : (0, helpers_internal_1.translateAssetTokenToCfnToken)(this.roleArn);
+    }
+    /**
+     * @internal
+     */
+    _arnForCloudAssembly() {
+        return this.isCliCredentials() ? undefined : (0, helpers_internal_1.translateCfnTokenToAssetToken)(this.roleArn);
+    }
+    /**
+     * @internal
+     */
+    _specialize(spec) {
+        return new BootstrapRole(spec.specialize(this.roleArn));
+    }
+}
+_a = JSII_RTTI_SYMBOL_1;
+BootstrapRole[_a] = { fqn: "@aws-cdk/app-staging-synthesizer-alpha.BootstrapRole", version: "2.82.0-alpha.0" };
+BootstrapRole.CLI_CREDS = 'cli-credentials';
+exports.BootstrapRole = BootstrapRole;
+/**
+ * Deployment identities are the class of roles to be assumed by the CDK
+ * when deploying the App.
+ */
+class DeploymentIdentities {
+    /**
+     * Use CLI credentials for all deployment identities.
+     */
+    static cliCredentials() {
+        return new DeploymentIdentities({
+            cloudFormationExecutionRole: BootstrapRole.cliCredentials(),
+            deploymentRole: BootstrapRole.cliCredentials(),
+            lookupRole: BootstrapRole.cliCredentials(),
+        });
+    }
+    /**
+     * Specify your own roles for all deployment identities. These roles
+     * must already exist.
+     */
+    static specifyRoles(roles) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_app_staging_synthesizer_alpha_BootstrapRoles(roles);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.specifyRoles);
+            }
+            throw error;
+        }
+        return new DeploymentIdentities(roles);
+    }
+    constructor(
+    /** roles that are bootstrapped to your account. */
+    roles) {
+        this.roles = roles;
+    }
+}
+_b = JSII_RTTI_SYMBOL_1;
+DeploymentIdentities[_b] = { fqn: "@aws-cdk/app-staging-synthesizer-alpha.DeploymentIdentities", version: "2.82.0-alpha.0" };
+exports.DeploymentIdentities = DeploymentIdentities;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYm9vdHN0cmFwLXJvbGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiYm9vdHN0cmFwLXJvbGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7OztBQUFBLDRFQUF3STtBQUV4STs7O0dBR0c7QUFDSCxNQUFhLGFBQWE7SUFDeEI7O09BRUc7SUFDSSxNQUFNLENBQUMsY0FBYztRQUMxQixPQUFPLElBQUksYUFBYSxDQUFDLGFBQWEsQ0FBQyxTQUFTLENBQUMsQ0FBQztLQUNuRDtJQUVEOztPQUVHO0lBQ0ksTUFBTSxDQUFDLFdBQVcsQ0FBQyxHQUFXO1FBQ25DLG9DQUFpQixDQUFDLGdCQUFnQixDQUFDLEdBQUcsRUFBRSxtQkFBbUIsQ0FBQyxDQUFDO1FBQzdELE9BQU8sSUFBSSxhQUFhLENBQUMsR0FBRyxDQUFDLENBQUM7S0FDL0I7SUFJRCxZQUFxQyxPQUFlO1FBQWYsWUFBTyxHQUFQLE9BQU8sQ0FBUTtLQUFJO0lBRXhEOztPQUVHO0lBQ0ksZ0JBQWdCO1FBQ3JCLE9BQU8sSUFBSSxDQUFDLE9BQU8sS0FBSyxhQUFhLENBQUMsU0FBUyxDQUFDO0tBQ2pEO0lBRUQ7O09BRUc7SUFDSSxxQkFBcUI7UUFDMUIsT0FBTyxJQUFJLENBQUMsZ0JBQWdCLEVBQUUsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxJQUFBLGdEQUE2QixFQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsQ0FBQztLQUMxRjtJQUVEOztPQUVHO0lBQ0ksb0JBQW9CO1FBQ3pCLE9BQU8sSUFBSSxDQUFDLGdCQUFnQixFQUFFLENBQUMsQ0FBQyxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUMsSUFBQSxnREFBNkIsRUFBQyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUM7S0FDMUY7SUFFRDs7T0FFRztJQUNJLFdBQVcsQ0FBQyxJQUF1QjtRQUN4QyxPQUFPLElBQUksYUFBYSxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUM7S0FDekQ7Ozs7QUE5QmMsdUJBQVMsR0FBRyxpQkFBaUIsQ0FBQztBQWhCbEMsc0NBQWE7QUFpRDFCOzs7R0FHRztBQUNILE1BQWEsb0JBQW9CO0lBQy9COztPQUVHO0lBQ0ksTUFBTSxDQUFDLGNBQWM7UUFDMUIsT0FBTyxJQUFJLG9CQUFvQixDQUFDO1lBQzlCLDJCQUEyQixFQUFFLGFBQWEsQ0FBQyxjQUFjLEVBQUU7WUFDM0QsY0FBYyxFQUFFLGFBQWEsQ0FBQyxjQUFjLEVBQUU7WUFDOUMsVUFBVSxFQUFFLGFBQWEsQ0FBQyxjQUFjLEVBQUU7U0FDM0MsQ0FBQyxDQUFDO0tBQ0o7SUFFRDs7O09BR0c7SUFDSSxNQUFNLENBQUMsWUFBWSxDQUFDLEtBQXFCOzs7Ozs7Ozs7O1FBQzlDLE9BQU8sSUFBSSxvQkFBb0IsQ0FBQyxLQUFLLENBQUMsQ0FBQztLQUN4QztJQUVEO0lBQ0UsbURBQW1EO0lBQ25DLEtBQXFCO1FBQXJCLFVBQUssR0FBTCxLQUFLLENBQWdCO0tBQ25DOzs7O0FBdkJPLG9EQUFvQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFN0cmluZ1NwZWNpYWxpemVyLCB0cmFuc2xhdGVBc3NldFRva2VuVG9DZm5Ub2tlbiwgdHJhbnNsYXRlQ2ZuVG9rZW5Ub0Fzc2V0VG9rZW4gfSBmcm9tICdhd3MtY2RrLWxpYi9jb3JlL2xpYi9oZWxwZXJzLWludGVybmFsJztcblxuLyoqXG4gKiBCb290c3RyYXBwZWQgcm9sZSBzcGVjaWZpZXIuIFRoZXNlIHJvbGVzIG11c3QgZXhpc3QgYWxyZWFkeS5cbiAqIFRoaXMgY2xhc3MgZG9lcyBub3QgY3JlYXRlIG5ldyBJQU0gUm9sZXMuXG4gKi9cbmV4cG9ydCBjbGFzcyBCb290c3RyYXBSb2xlIHtcbiAgLyoqXG4gICAqIFVzZSB0aGUgY3VycmVudGx5IGFzc3VtZWQgcm9sZS9jcmVkZW50aWFsc1xuICAgKi9cbiAgcHVibGljIHN0YXRpYyBjbGlDcmVkZW50aWFscygpIHtcbiAgICByZXR1cm4gbmV3IEJvb3RzdHJhcFJvbGUoQm9vdHN0cmFwUm9sZS5DTElfQ1JFRFMpO1xuICB9XG5cbiAgLyoqXG4gICAqIFNwZWNpZnkgYW4gZXhpc3RpbmcgSUFNIFJvbGUgdG8gYXNzdW1lXG4gICAqL1xuICBwdWJsaWMgc3RhdGljIGZyb21Sb2xlQXJuKGFybjogc3RyaW5nKSB7XG4gICAgU3RyaW5nU3BlY2lhbGl6ZXIudmFsaWRhdGVOb1Rva2Vucyhhcm4sICdCb290c3RyYXBSb2xlIEFSTicpO1xuICAgIHJldHVybiBuZXcgQm9vdHN0cmFwUm9sZShhcm4pO1xuICB9XG5cbiAgcHJpdmF0ZSBzdGF0aWMgQ0xJX0NSRURTID0gJ2NsaS1jcmVkZW50aWFscyc7XG5cbiAgcHJpdmF0ZSBjb25zdHJ1Y3Rvcihwcml2YXRlIHJlYWRvbmx5IHJvbGVBcm46IHN0cmluZykge31cblxuICAvKipcbiAgICogV2hldGhlciBvciBub3QgdGhpcyBpcyBvYmplY3Qgd2FzIGNyZWF0ZWQgdXNpbmcgQm9vdHN0cmFwUm9sZS5jbGlDcmVkZW50aWFscygpXG4gICAqL1xuICBwdWJsaWMgaXNDbGlDcmVkZW50aWFscygpIHtcbiAgICByZXR1cm4gdGhpcy5yb2xlQXJuID09PSBCb290c3RyYXBSb2xlLkNMSV9DUkVEUztcbiAgfVxuXG4gIC8qKlxuICAgKiBAaW50ZXJuYWxcbiAgICovXG4gIHB1YmxpYyBfYXJuRm9yQ2xvdWRGb3JtYXRpb24oKSB7XG4gICAgcmV0dXJuIHRoaXMuaXNDbGlDcmVkZW50aWFscygpID8gdW5kZWZpbmVkIDogdHJhbnNsYXRlQXNzZXRUb2tlblRvQ2ZuVG9rZW4odGhpcy5yb2xlQXJuKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBAaW50ZXJuYWxcbiAgICovXG4gIHB1YmxpYyBfYXJuRm9yQ2xvdWRBc3NlbWJseSgpIHtcbiAgICByZXR1cm4gdGhpcy5pc0NsaUNyZWRlbnRpYWxzKCkgPyB1bmRlZmluZWQgOiB0cmFuc2xhdGVDZm5Ub2tlblRvQXNzZXRUb2tlbih0aGlzLnJvbGVBcm4pO1xuICB9XG5cbiAgLyoqXG4gICAqIEBpbnRlcm5hbFxuICAgKi9cbiAgcHVibGljIF9zcGVjaWFsaXplKHNwZWM6IFN0cmluZ1NwZWNpYWxpemVyKSB7XG4gICAgcmV0dXJuIG5ldyBCb290c3RyYXBSb2xlKHNwZWMuc3BlY2lhbGl6ZSh0aGlzLnJvbGVBcm4pKTtcbiAgfVxufVxuXG4vKipcbiAqIERlcGxveW1lbnQgaWRlbnRpdGllcyBhcmUgdGhlIGNsYXNzIG9mIHJvbGVzIHRvIGJlIGFzc3VtZWQgYnkgdGhlIENES1xuICogd2hlbiBkZXBsb3lpbmcgdGhlIEFwcC5cbiAqL1xuZXhwb3J0IGNsYXNzIERlcGxveW1lbnRJZGVudGl0aWVzIHtcbiAgLyoqXG4gICAqIFVzZSBDTEkgY3JlZGVudGlhbHMgZm9yIGFsbCBkZXBsb3ltZW50IGlkZW50aXRpZXMuXG4gICAqL1xuICBwdWJsaWMgc3RhdGljIGNsaUNyZWRlbnRpYWxzKCk6IERlcGxveW1lbnRJZGVudGl0aWVzIHtcbiAgICByZXR1cm4gbmV3IERlcGxveW1lbnRJZGVudGl0aWVzKHtcbiAgICAgIGNsb3VkRm9ybWF0aW9uRXhlY3V0aW9uUm9sZTogQm9vdHN0cmFwUm9sZS5jbGlDcmVkZW50aWFscygpLFxuICAgICAgZGVwbG95bWVudFJvbGU6IEJvb3RzdHJhcFJvbGUuY2xpQ3JlZGVudGlhbHMoKSxcbiAgICAgIGxvb2t1cFJvbGU6IEJvb3RzdHJhcFJvbGUuY2xpQ3JlZGVudGlhbHMoKSxcbiAgICB9KTtcbiAgfVxuXG4gIC8qKlxuICAgKiBTcGVjaWZ5IHlvdXIgb3duIHJvbGVzIGZvciBhbGwgZGVwbG95bWVudCBpZGVudGl0aWVzLiBUaGVzZSByb2xlc1xuICAgKiBtdXN0IGFscmVhZHkgZXhpc3QuXG4gICAqL1xuICBwdWJsaWMgc3RhdGljIHNwZWNpZnlSb2xlcyhyb2xlczogQm9vdHN0cmFwUm9sZXMpOiBEZXBsb3ltZW50SWRlbnRpdGllcyB7XG4gICAgcmV0dXJuIG5ldyBEZXBsb3ltZW50SWRlbnRpdGllcyhyb2xlcyk7XG4gIH1cblxuICBwcml2YXRlIGNvbnN0cnVjdG9yKFxuICAgIC8qKiByb2xlcyB0aGF0IGFyZSBib290c3RyYXBwZWQgdG8geW91ciBhY2NvdW50LiAqL1xuICAgIHB1YmxpYyByZWFkb25seSByb2xlczogQm9vdHN0cmFwUm9sZXMsXG4gICkge31cbn1cblxuLyoqXG4gKiBSb2xlcyB0aGF0IGFyZSBib290c3RyYXBwZWQgdG8geW91ciBhY2NvdW50LlxuICovXG5leHBvcnQgaW50ZXJmYWNlIEJvb3RzdHJhcFJvbGVzIHtcbiAgLyoqXG4gICAqIENsb3VkRm9ybWF0aW9uIEV4ZWN1dGlvbiBSb2xlXG4gICAqXG4gICAqIEBkZWZhdWx0IC0gdXNlIGJvb3RzdHJhcHBlZCByb2xlXG4gICAqL1xuICByZWFkb25seSBjbG91ZEZvcm1hdGlvbkV4ZWN1dGlvblJvbGU/OiBCb290c3RyYXBSb2xlO1xuXG4gIC8qKlxuICAgKiBEZXBsb3ltZW50IEFjdGlvbiBSb2xlXG4gICAqXG4gICAqIEBkZWZhdWx0IC0gdXNlIGJvb3N0cmFwcGVkIHJvbGVcbiAgICovXG4gIHJlYWRvbmx5IGRlcGxveW1lbnRSb2xlPzogQm9vdHN0cmFwUm9sZTtcblxuICAvKipcbiAgICogTG9va3VwIFJvbGVcbiAgICpcbiAgICogQGRlZmF1bHQgLSB1c2UgYm9vdHN0cmFwcGVkIHJvbGVcbiAgICovXG4gIHJlYWRvbmx5IGxvb2t1cFJvbGU/OiBCb290c3RyYXBSb2xlO1xufVxuXG4vKipcbiAqIFJvbGVzIHRoYXQgYXJlIGluY2x1ZGVkIGluIHRoZSBTdGFnaW5nIFN0YWNrXG4gKiAoZm9yIGFjY2VzcyB0byBTdGFnaW5nIFJlc291cmNlcylcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBTdGFnaW5nUm9sZXMge1xuICAvKipcbiAgICogRmlsZSBBc3NldCBQdWJsaXNoaW5nIFJvbGVcbiAgICpcbiAgICogQGRlZmF1bHQgLSBzdGFnaW5nIHN0YWNrIGNyZWF0ZXMgYSBmaWxlIGFzc2V0IHB1Ymxpc2hpbmcgcm9sZVxuICAgKi9cbiAgcmVhZG9ubHkgZmlsZUFzc2V0UHVibGlzaGluZ1JvbGU/OiBCb290c3RyYXBSb2xlO1xuXG4gIC8qKlxuICAgKiBEb2NrZXIgQXNzZXQgUHVibGlzaGluZyBSb2xlXG4gICAqXG4gICAqIEBkZWZhdWx0IC0gc3RhZ2luZyBzdGFjayBjcmVhdGVzIGEgZG9ja2VyIGFzc2V0IHB1Ymxpc2hpbmcgcm9sZVxuICAgKi9cbiAgcmVhZG9ubHkgZG9ja2VyQXNzZXRQdWJsaXNoaW5nUm9sZT86IEJvb3RzdHJhcFJvbGU7XG59XG4iXX0=

package/lib/default-staging-stack.d.ts

@@ -0,0 +1,151 @@
+import { App, DockerImageAssetSource, Duration, FileAssetSource, ISynthesisSession, Stack, StackProps } from 'aws-cdk-lib';
+import * as ecr from 'aws-cdk-lib/aws-ecr';
+import * as s3 from 'aws-cdk-lib/aws-s3';
+import { BootstrapRole } from './bootstrap-roles';
+import { FileStagingLocation, IStagingResources, IStagingResourcesFactory, ImageStagingLocation } from './staging-stack';
+export declare const DEPLOY_TIME_PREFIX = "deploy-time/";
+/**
+ * User configurable options to the DefaultStagingStack.
+ */
+export interface DefaultStagingStackOptions {
+    /**
+     * A unique identifier for the application that the staging stack belongs to.
+     *
+     * This identifier will be used in the name of staging resources
+     * created for this application, and should be unique across CDK apps.
+     *
+     * The identifier should include lowercase characters and dashes ('-') only
+     * and have a maximum of 20 characters.
+     */
+    readonly appId: string;
+    /**
+     * Explicit name for the staging bucket
+     *
+     * @default - a well-known name unique to this app/env.
+     */
+    readonly stagingBucketName?: string;
+    /**
+     * Pass in an existing role to be used as the file publishing role.
+     *
+     * @default - a new role will be created
+     */
+    readonly fileAssetPublishingRole?: BootstrapRole;
+    /**
+     * Pass in an existing role to be used as the image publishing role.
+     *
+     * @default - a new role will be created
+     */
+    readonly imageAssetPublishingRole?: BootstrapRole;
+    /**
+     * The lifetime for deploy time file assets.
+     *
+     * Assets that are only necessary at deployment time (for instance,
+     * CloudFormation templates and Lambda source code bundles) will be
+     * automatically deleted after this many days. Assets that may be
+     * read from the staging bucket during your application's run time
+     * will not be deleted.
+     *
+     * Set this to the length of time you wish to be able to roll back to
+     * previous versions of your application without having to do a new
+     * `cdk synth` and re-upload of assets.
+     *
+     * @default - Duration.days(30)
+     */
+    readonly deployTimeFileAssetLifetime?: Duration;
+    /**
+     * The maximum number of image versions to store in a repository.
+     *
+     * Previous versions of an image can be stored for rollback purposes.
+     * Once a repository has more than 3 image versions stored, the oldest
+     * version will be discarded. This allows for sensible garbage collection
+     * while maintaining a few previous versions for rollback scenarios.
+     *
+     * @default - up to 3 versions stored
+     */
+    readonly imageAssetVersionCount?: number;
+}
+/**
+ * Default Staging Stack Properties
+ */
+export interface DefaultStagingStackProps extends DefaultStagingStackOptions, StackProps {
+    /**
+     * The ARN of the deploy action role, if given
+     *
+     * This role will need permissions to read from to the staging resources.
+     *
+     * @default - The CLI credentials are assumed, no additional permissions are granted.
+     */
+    readonly deployRoleArn?: string;
+    /**
+     * The qualifier used to specialize strings
+     *
+     * Shouldn't be necessary but who knows what people might do.
+     */
+    readonly qualifier: string;
+}
+/**
+ * A default Staging Stack that implements IStagingResources.
+ *
+ * @example
+ * const defaultStagingStack = DefaultStagingStack.factory({ appId: 'my-app-id' });
+ */
+export declare class DefaultStagingStack extends Stack implements IStagingResources {
+    private readonly props;
+    /**
+     * Return a factory that will create DefaultStagingStacks
+     */
+    static factory(options: DefaultStagingStackOptions): IStagingResourcesFactory;
+    /**
+     * Default asset publishing role name for file (S3) assets.
+     */
+    private get fileRoleName();
+    /**
+     * Default asset publishing role name for docker (ECR) assets.
+     */
+    private get imageRoleName();
+    /**
+     * The app-scoped, evironment-keyed staging bucket.
+     */
+    readonly stagingBucket?: s3.Bucket;
+    /**
+     * The app-scoped, environment-keyed ecr repositories associated with this app.
+     */
+    readonly stagingRepos: Record<string, ecr.Repository>;
+    /**
+     * The stack to add dependencies to.
+     */
+    readonly dependencyStack: Stack;
+    private readonly appId;
+    private readonly stagingBucketName?;
+    /**
+     * File publish role ARN in asset manifest format
+     */
+    private readonly providedFileRole?;
+    private fileRole?;
+    private fileRoleManifestArn?;
+    /**
+     * Image publishing role ARN in asset manifest format
+     */
+    private readonly providedImageRole?;
+    private imageRole?;
+    private didImageRole;
+    private imageRoleManifestArn?;
+    private readonly deployRoleArn?;
+    constructor(scope: App, id: string, props: DefaultStagingStackProps);
+    private validateAppId;
+    private ensureFileRole;
+    private ensureImageRole;
+    private createBucketKey;
+    private getCreateBucket;
+    /**
+     * Returns the well-known name of the repo
+     */
+    private getCreateRepo;
+    addFile(asset: FileAssetSource): FileStagingLocation;
+    addDockerImage(asset: DockerImageAssetSource): ImageStagingLocation;
+    /**
+     * Synthesizes the cloudformation template into a cloud assembly.
+     * @internal
+     */
+    _synthesizeTemplate(session: ISynthesisSession, lookupRoleArn?: string | undefined): void;
+}