# NestedStackProps

Initialization props for the `NestedStack` construct.

Extends: NestedStackProps
Used as props by: NestedStack

- Source: [`core/lib/nested-stack.ts`](https://github.com/aws/aws-cdk/blob/v2.274.0/packages/aws-cdk-lib/core/lib/nested-stack.ts#L27)
- Type last changed: v2.238.0 · 9 Feb 2026

## Example

```ts
import type { Construct } from 'constructs';
import type { NestedStackProps } from '../../core';
import { App, CfnOutput, NestedStack, Stack } from '../../core';
import type { Method } from '../lib';
import { Deployment, MockIntegration, PassthroughBehavior, RestApi, Stage } from '../lib';

/**
 * This file showcases how to split up a RestApi's Resources and Methods across nested stacks.
 *
 * The root stack 'RootStack' first defines a RestApi.
 * Two nested stacks BooksStack and PetsStack, create corresponding Resources '/books' and '/pets'.
 * They are then deployed to a 'prod' Stage via a third nested stack - DeployStack.
 *
 * To verify this worked, go to the APIGateway
 */

class RootStack extends Stack {
  constructor(scope: Construct) {
    super(scope, 'integ-restapi-import-RootStack');

    const restApi = new RestApi(this, 'RestApi', {
      cloudWatchRole: true,
      deploy: false,
    });
    restApi.root.addMethod('ANY');

    const petsStack = new PetsStack(this, {
      restApiId: restApi.restApiId,
      rootResourceId: restApi.restApiRootResourceId,
    });
    const booksStack = new BooksStack(this, {
      restApiId: restApi.restApiId,
      rootResourceId: restApi.restApiRootResourceId,
    });
    new DeployStack(this, {
      restApiId: restApi.restApiId,
      methods: petsStack.methods.concat(booksStack.methods),
    });

    new CfnOutput(this, 'PetsURL', {
      value: `https://${restApi.restApiId}.execute-api.${this.region}.amazonaws.com/prod/pets`,
    });

    new CfnOutput(this, 'BooksURL', {
      value: `https://${restApi.restApiId}.execute-api.${this.region}.amazonaws.com/prod/books`,
    });
  }
}

interface ResourceNestedStackProps extends NestedStackProps {
  readonly restApiId: string;

  readonly rootResourceId: string;
}

class PetsStack extends NestedStack {
  public readonly methods: Method[] = [];

  constructor(scope: Construct, props: ResourceNestedStackProps) {
    super(scope, 'integ-restapi-import-PetsStack', props);

    const api = RestApi.fromRestApiAttributes(this, 'RestApi', {
      restApiId: props.restApiId,
      rootResourceId: props.rootResourceId,
    });

    const method = api.root.addResource('pets').addMethod('GET', new MockIntegration({
      integrationResponses: [{
        statusCode: '200',
      }],
      passthroughBehavior: PassthroughBehavior.NEVER,
      requestTemplates: {
        'application/json': '{ "statusCode": 200 }',
      },
    }), {
      methodResponses: [{ statusCode: '200' }],
    });

    this.methods.push(method);
  }
}

class BooksStack extends NestedStack {
  public readonly methods: Method[] = [];

  constructor(scope: Construct, props: ResourceNestedStackProps) {
    super(scope, 'integ-restapi-import-BooksStack', props);

    const api = RestApi.fromRestApiAttributes(this, 'RestApi', {
      restApiId: props.restApiId,
      rootResourceId: props.rootResourceId,
    });

    const method = api.root.addResource('books').addMethod('GET', new MockIntegration({
      integrationResponses: [{
        statusCode: '200',
      }],
      passthroughBehavior: PassthroughBehavior.NEVER,
      requestTemplates: {
        'application/json': '{ "statusCode": 200 }',
      },
    }), {
      methodResponses: [{ statusCode: '200' }],
    });

    this.methods.push(method);
  }
}

interface DeployStackProps extends NestedStackProps {
  readonly restApiId: string;

  readonly methods?: Method[];
}

class DeployStack extends NestedStack {
  constructor(scope: Construct, props: DeployStackProps) {
    super(scope, 'integ-restapi-import-DeployStack', props);

    const deployment = new Deployment(this, 'Deployment', {
      api: RestApi.fromRestApiId(this, 'RestApi', props.restApiId),
    });
    if (props.methods) {
      for (const method of props.methods) {
        deployment.node.addDependency(method);
      }
    }
    new Stage(this, 'Stage', { deployment });
  }
}

new RootStack(new App());
```

## Properties

- `description`: string — A description of the stack.

  **Default:** No description.

- `notificationArns`: string[] — The Simple Notification Service (SNS) topics to publish stack related events.

  **Default:** notifications are not sent for this stack.

- `parameters`: { [key: string]: string } — The set value pairs that represent the parameters passed to CloudFormation when this nested stack is created.

  **Default:** no user-defined parameters are passed to the nested stack

  Each parameter has a name corresponding
  to a parameter defined in the embedded template and a value representing
  the value that you want to set for the parameter.

  The nested stack construct will automatically synthesize parameters in order
  to bind references from the parent stack(s) into the nested stack.

- `removalPolicy`: [RemovalPolicy](/cdk/api/v2/docs/aws-cdk-lib.RemovalPolicy.html) = RemovalPolicy.DESTROY — Policy to apply when the nested stack is removed.

  The default is `Destroy`, because all Removal Policies of resources inside the
  Nested Stack should already have been set correctly. You normally should
  not need to set this value.

- `suppressTemplateIndentation`: boolean — Enable this flag to suppress indentation in generated CloudFormation templates.

  **Default:** the value of `@aws-cdk/core:suppressTemplateIndentation`, or `false` if that is not set.

  If not specified, the value of the `@aws-cdk/core:suppressTemplateIndentation`
  context key will be used. If that is not specified, then the
  default value `false` will be used.

- `timeout`: [Duration](/cdk/api/v2/docs/aws-cdk-lib.Duration.html) — The length of time that CloudFormation waits for the nested stack to reach the CREATE_COMPLETE state.

  **Default:** no timeout

  When CloudFormation detects that the nested stack has reached the
  CREATE_COMPLETE state, it marks the nested stack resource as
  CREATE_COMPLETE in the parent stack and resumes creating the parent stack.
  If the timeout period expires before the nested stack reaches
  CREATE_COMPLETE, CloudFormation marks the nested stack as failed and rolls
  back both the nested stack and parent stack.