@gemeentenijmegen/webapp 1.1.13 → 1.1.14

package/node_modules/constructs/API.md

@@ -0,0 +1,1295 @@
+# API Reference <a name="API Reference" id="api-reference"></a>
+
+## Constructs <a name="Constructs" id="Constructs"></a>
+
+### Construct <a name="Construct" id="constructs.Construct"></a>
+
+- *Implements:* <a href="#constructs.IConstruct">IConstruct</a>
+
+Represents the building block of the construct graph.
+
+All constructs besides the root construct must be created within the scope of
+another construct.
+
+#### Initializers <a name="Initializers" id="constructs.Construct.Initializer"></a>
+
+```typescript
+import { Construct } from 'constructs'
+
+new Construct(scope: Construct, id: string)
+```
+
+| **Name** | **Type** | **Description** |
+| --- | --- | --- |
+| <code><a href="#constructs.Construct.Initializer.parameter.scope">scope</a></code> | <code><a href="#constructs.Construct">Construct</a></code> | The scope in which to define this construct. |
+| <code><a href="#constructs.Construct.Initializer.parameter.id">id</a></code> | <code>string</code> | The scoped construct ID. |
+
+---
+
+##### `scope`<sup>Required</sup> <a name="scope" id="constructs.Construct.Initializer.parameter.scope"></a>
+
+- *Type:* <a href="#constructs.Construct">Construct</a>
+
+The scope in which to define this construct.
+
+---
+
+##### `id`<sup>Required</sup> <a name="id" id="constructs.Construct.Initializer.parameter.id"></a>
+
+- *Type:* string
+
+The scoped construct ID.
+
+Must be unique amongst siblings. If
+the ID includes a path separator (`/`), then it will be replaced by double
+dash `--`.
+
+---
+
+#### Methods <a name="Methods" id="Methods"></a>
+
+| **Name** | **Description** |
+| --- | --- |
+| <code><a href="#constructs.Construct.toString">toString</a></code> | Returns a string representation of this construct. |
+| <code><a href="#constructs.Construct.with">with</a></code> | Applies one or more mixins to this construct. |
+
+---
+
+##### `toString` <a name="toString" id="constructs.Construct.toString"></a>
+
+```typescript
+public toString(): string
+```
+
+Returns a string representation of this construct.
+
+##### `with` <a name="with" id="constructs.Construct.with"></a>
+
+```typescript
+public with(mixins: ...IMixin[]): IConstruct
+```
+
+Applies one or more mixins to this construct.
+
+Mixins are applied in order. The list of constructs is captured at the
+start of the call, so constructs added by a mixin will not be visited.
+Use multiple `with()` calls if subsequent mixins should apply to added
+constructs.
+
+###### `mixins`<sup>Required</sup> <a name="mixins" id="constructs.Construct.with.parameter.mixins"></a>
+
+- *Type:* ...<a href="#constructs.IMixin">IMixin</a>[]
+
+The mixins to apply.
+
+---
+
+#### Static Functions <a name="Static Functions" id="Static Functions"></a>
+
+| **Name** | **Description** |
+| --- | --- |
+| <code><a href="#constructs.Construct.isConstruct">isConstruct</a></code> | Checks if `x` is a construct. |
+
+---
+
+##### `isConstruct` <a name="isConstruct" id="constructs.Construct.isConstruct"></a>
+
+```typescript
+import { Construct } from 'constructs'
+
+Construct.isConstruct(x: any)
+```
+
+Checks if `x` is a construct.
+
+Use this method instead of `instanceof` to properly detect `Construct`
+instances, even when the construct library is symlinked.
+
+Explanation: in JavaScript, multiple copies of the `constructs` library on
+disk are seen as independent, completely different libraries. As a
+consequence, the class `Construct` in each copy of the `constructs` library
+is seen as a different class, and an instance of one class will not test as
+`instanceof` the other class. `npm install` will not create installations
+like this, but users may manually symlink construct libraries together or
+use a monorepo tool: in those cases, multiple copies of the `constructs`
+library can be accidentally installed, and `instanceof` will behave
+unpredictably. It is safest to avoid using `instanceof`, and using
+this type-testing method instead.
+
+###### `x`<sup>Required</sup> <a name="x" id="constructs.Construct.isConstruct.parameter.x"></a>
+
+- *Type:* any
+
+Any object.
+
+---
+
+#### Properties <a name="Properties" id="Properties"></a>
+
+| **Name** | **Type** | **Description** |
+| --- | --- | --- |
+| <code><a href="#constructs.Construct.property.node">node</a></code> | <code><a href="#constructs.Node">Node</a></code> | The tree node. |
+
+---
+
+##### `node`<sup>Required</sup> <a name="node" id="constructs.Construct.property.node"></a>
+
+```typescript
+public readonly node: Node;
+```
+
+- *Type:* <a href="#constructs.Node">Node</a>
+
+The tree node.
+
+---
+
+
+### RootConstruct <a name="RootConstruct" id="constructs.RootConstruct"></a>
+
+Creates a new root construct node.
+
+The root construct represents the top of the construct tree and is not contained within a parent scope itself.
+For root constructs, the id is optional.
+
+#### Initializers <a name="Initializers" id="constructs.RootConstruct.Initializer"></a>
+
+```typescript
+import { RootConstruct } from 'constructs'
+
+new RootConstruct(id?: string)
+```
+
+| **Name** | **Type** | **Description** |
+| --- | --- | --- |
+| <code><a href="#constructs.RootConstruct.Initializer.parameter.id">id</a></code> | <code>string</code> | The scoped construct ID. |
+
+---
+
+##### `id`<sup>Optional</sup> <a name="id" id="constructs.RootConstruct.Initializer.parameter.id"></a>
+
+- *Type:* string
+
+The scoped construct ID.
+
+Must be unique amongst siblings. If
+the ID includes a path separator (`/`), then it will be replaced by double
+dash `--`.
+
+---
+
+#### Methods <a name="Methods" id="Methods"></a>
+
+| **Name** | **Description** |
+| --- | --- |
+| <code><a href="#constructs.RootConstruct.toString">toString</a></code> | Returns a string representation of this construct. |
+| <code><a href="#constructs.RootConstruct.with">with</a></code> | Applies one or more mixins to this construct. |
+
+---
+
+##### `toString` <a name="toString" id="constructs.RootConstruct.toString"></a>
+
+```typescript
+public toString(): string
+```
+
+Returns a string representation of this construct.
+
+##### `with` <a name="with" id="constructs.RootConstruct.with"></a>
+
+```typescript
+public with(mixins: ...IMixin[]): IConstruct
+```
+
+Applies one or more mixins to this construct.
+
+Mixins are applied in order. The list of constructs is captured at the
+start of the call, so constructs added by a mixin will not be visited.
+Use multiple `with()` calls if subsequent mixins should apply to added
+constructs.
+
+###### `mixins`<sup>Required</sup> <a name="mixins" id="constructs.RootConstruct.with.parameter.mixins"></a>
+
+- *Type:* ...<a href="#constructs.IMixin">IMixin</a>[]
+
+The mixins to apply.
+
+---
+
+#### Static Functions <a name="Static Functions" id="Static Functions"></a>
+
+| **Name** | **Description** |
+| --- | --- |
+| <code><a href="#constructs.RootConstruct.isConstruct">isConstruct</a></code> | Checks if `x` is a construct. |
+
+---
+
+##### `isConstruct` <a name="isConstruct" id="constructs.RootConstruct.isConstruct"></a>
+
+```typescript
+import { RootConstruct } from 'constructs'
+
+RootConstruct.isConstruct(x: any)
+```
+
+Checks if `x` is a construct.
+
+Use this method instead of `instanceof` to properly detect `Construct`
+instances, even when the construct library is symlinked.
+
+Explanation: in JavaScript, multiple copies of the `constructs` library on
+disk are seen as independent, completely different libraries. As a
+consequence, the class `Construct` in each copy of the `constructs` library
+is seen as a different class, and an instance of one class will not test as
+`instanceof` the other class. `npm install` will not create installations
+like this, but users may manually symlink construct libraries together or
+use a monorepo tool: in those cases, multiple copies of the `constructs`
+library can be accidentally installed, and `instanceof` will behave
+unpredictably. It is safest to avoid using `instanceof`, and using
+this type-testing method instead.
+
+###### `x`<sup>Required</sup> <a name="x" id="constructs.RootConstruct.isConstruct.parameter.x"></a>
+
+- *Type:* any
+
+Any object.
+
+---
+
+#### Properties <a name="Properties" id="Properties"></a>
+
+| **Name** | **Type** | **Description** |
+| --- | --- | --- |
+| <code><a href="#constructs.RootConstruct.property.node">node</a></code> | <code><a href="#constructs.Node">Node</a></code> | The tree node. |
+
+---
+
+##### `node`<sup>Required</sup> <a name="node" id="constructs.RootConstruct.property.node"></a>
+
+```typescript
+public readonly node: Node;
+```
+
+- *Type:* <a href="#constructs.Node">Node</a>
+
+The tree node.
+
+---
+
+
+## Structs <a name="Structs" id="Structs"></a>
+
+### MetadataEntry <a name="MetadataEntry" id="constructs.MetadataEntry"></a>
+
+An entry in the construct metadata table.
+
+#### Initializer <a name="Initializer" id="constructs.MetadataEntry.Initializer"></a>
+
+```typescript
+import { MetadataEntry } from 'constructs'
+
+const metadataEntry: MetadataEntry = { ... }
+```
+
+#### Properties <a name="Properties" id="Properties"></a>
+
+| **Name** | **Type** | **Description** |
+| --- | --- | --- |
+| <code><a href="#constructs.MetadataEntry.property.data">data</a></code> | <code>any</code> | The data. |
+| <code><a href="#constructs.MetadataEntry.property.type">type</a></code> | <code>string</code> | The metadata entry type. |
+| <code><a href="#constructs.MetadataEntry.property.trace">trace</a></code> | <code>string[]</code> | Stack trace at the point of adding the metadata. |
+
+---
+
+##### `data`<sup>Required</sup> <a name="data" id="constructs.MetadataEntry.property.data"></a>
+
+```typescript
+public readonly data: any;
+```
+
+- *Type:* any
+
+The data.
+
+---
+
+##### `type`<sup>Required</sup> <a name="type" id="constructs.MetadataEntry.property.type"></a>
+
+```typescript
+public readonly type: string;
+```
+
+- *Type:* string
+
+The metadata entry type.
+
+---
+
+##### `trace`<sup>Optional</sup> <a name="trace" id="constructs.MetadataEntry.property.trace"></a>
+
+```typescript
+public readonly trace: string[];
+```
+
+- *Type:* string[]
+- *Default:* no trace information
+
+Stack trace at the point of adding the metadata.
+
+Only available if `addMetadata()` is called with `stackTrace: true`.
+
+---
+
+### MetadataOptions <a name="MetadataOptions" id="constructs.MetadataOptions"></a>
+
+Options for `construct.addMetadata()`.
+
+#### Initializer <a name="Initializer" id="constructs.MetadataOptions.Initializer"></a>
+
+```typescript
+import { MetadataOptions } from 'constructs'
+
+const metadataOptions: MetadataOptions = { ... }
+```
+
+#### Properties <a name="Properties" id="Properties"></a>
+
+| **Name** | **Type** | **Description** |
+| --- | --- | --- |
+| <code><a href="#constructs.MetadataOptions.property.stackTrace">stackTrace</a></code> | <code>boolean</code> | Include stack trace with metadata entry. |
+| <code><a href="#constructs.MetadataOptions.property.traceFromFunction">traceFromFunction</a></code> | <code>any</code> | A JavaScript function to begin tracing from. |
+
+---
+
+##### `stackTrace`<sup>Optional</sup> <a name="stackTrace" id="constructs.MetadataOptions.property.stackTrace"></a>
+
+```typescript
+public readonly stackTrace: boolean;
+```
+
+- *Type:* boolean
+- *Default:* false
+
+Include stack trace with metadata entry.
+
+---
+
+##### `traceFromFunction`<sup>Optional</sup> <a name="traceFromFunction" id="constructs.MetadataOptions.property.traceFromFunction"></a>
+
+```typescript
+public readonly traceFromFunction: any;
+```
+
+- *Type:* any
+- *Default:* addMetadata()
+
+A JavaScript function to begin tracing from.
+
+This option is ignored unless `stackTrace` is `true`.
+
+---
+
+## Classes <a name="Classes" id="Classes"></a>
+
+### Dependable <a name="Dependable" id="constructs.Dependable"></a>
+
+Trait for IDependable.
+
+Traits are interfaces that are privately implemented by objects. Instead of
+showing up in the public interface of a class, they need to be queried
+explicitly. This is used to implement certain framework features that are
+not intended to be used by Construct consumers, and so should be hidden
+from accidental use.
+
+*Example*
+
+```typescript
+// Usage
+const roots = Dependable.of(construct).dependencyRoots;
+
+// Definition
+Dependable.implement(construct, {
+      dependencyRoots: [construct],
+});
+```
+
+
+#### Initializers <a name="Initializers" id="constructs.Dependable.Initializer"></a>
+
+```typescript
+import { Dependable } from 'constructs'
+
+new Dependable()
+```
+
+| **Name** | **Type** | **Description** |
+| --- | --- | --- |
+
+---
+
+
+#### Static Functions <a name="Static Functions" id="Static Functions"></a>
+
+| **Name** | **Description** |
+| --- | --- |
+| <code><a href="#constructs.Dependable.get">get</a></code> | Return the matching Dependable for the given class instance. |
+| <code><a href="#constructs.Dependable.implement">implement</a></code> | Turn any object into an IDependable. |
+| <code><a href="#constructs.Dependable.of">of</a></code> | Return the matching Dependable for the given class instance. |
+
+---
+
+##### ~~`get`~~ <a name="get" id="constructs.Dependable.get"></a>
+
+```typescript
+import { Dependable } from 'constructs'
+
+Dependable.get(instance: IDependable)
+```
+
+Return the matching Dependable for the given class instance.
+
+###### `instance`<sup>Required</sup> <a name="instance" id="constructs.Dependable.get.parameter.instance"></a>
+
+- *Type:* <a href="#constructs.IDependable">IDependable</a>
+
+---
+
+##### `implement` <a name="implement" id="constructs.Dependable.implement"></a>
+
+```typescript
+import { Dependable } from 'constructs'
+
+Dependable.implement(instance: IDependable, trait: Dependable)
+```
+
+Turn any object into an IDependable.
+
+###### `instance`<sup>Required</sup> <a name="instance" id="constructs.Dependable.implement.parameter.instance"></a>
+
+- *Type:* <a href="#constructs.IDependable">IDependable</a>
+
+---
+
+###### `trait`<sup>Required</sup> <a name="trait" id="constructs.Dependable.implement.parameter.trait"></a>
+
+- *Type:* <a href="#constructs.Dependable">Dependable</a>
+
+---
+
+##### `of` <a name="of" id="constructs.Dependable.of"></a>
+
+```typescript
+import { Dependable } from 'constructs'
+
+Dependable.of(instance: IDependable)
+```
+
+Return the matching Dependable for the given class instance.
+
+###### `instance`<sup>Required</sup> <a name="instance" id="constructs.Dependable.of.parameter.instance"></a>
+
+- *Type:* <a href="#constructs.IDependable">IDependable</a>
+
+---
+
+#### Properties <a name="Properties" id="Properties"></a>
+
+| **Name** | **Type** | **Description** |
+| --- | --- | --- |
+| <code><a href="#constructs.Dependable.property.dependencyRoots">dependencyRoots</a></code> | <code><a href="#constructs.IConstruct">IConstruct</a>[]</code> | The set of constructs that form the root of this dependable. |
+
+---
+
+##### `dependencyRoots`<sup>Required</sup> <a name="dependencyRoots" id="constructs.Dependable.property.dependencyRoots"></a>
+
+```typescript
+public readonly dependencyRoots: IConstruct[];
+```
+
+- *Type:* <a href="#constructs.IConstruct">IConstruct</a>[]
+
+The set of constructs that form the root of this dependable.
+
+All resources under all returned constructs are included in the ordering
+dependency.
+
+---
+
+
+### DependencyGroup <a name="DependencyGroup" id="constructs.DependencyGroup"></a>
+
+- *Implements:* <a href="#constructs.IDependable">IDependable</a>
+
+A set of constructs to be used as a dependable.
+
+This class can be used when a set of constructs which are disjoint in the
+construct tree needs to be combined to be used as a single dependable.
+
+#### Initializers <a name="Initializers" id="constructs.DependencyGroup.Initializer"></a>
+
+```typescript
+import { DependencyGroup } from 'constructs'
+
+new DependencyGroup(deps: ...IDependable[])
+```
+
+| **Name** | **Type** | **Description** |
+| --- | --- | --- |
+| <code><a href="#constructs.DependencyGroup.Initializer.parameter.deps">deps</a></code> | <code>...<a href="#constructs.IDependable">IDependable</a>[]</code> | *No description.* |
+
+---
+
+##### `deps`<sup>Required</sup> <a name="deps" id="constructs.DependencyGroup.Initializer.parameter.deps"></a>
+
+- *Type:* ...<a href="#constructs.IDependable">IDependable</a>[]
+
+---
+
+#### Methods <a name="Methods" id="Methods"></a>
+
+| **Name** | **Description** |
+| --- | --- |
+| <code><a href="#constructs.DependencyGroup.add">add</a></code> | Add a construct to the dependency roots. |
+
+---
+
+##### `add` <a name="add" id="constructs.DependencyGroup.add"></a>
+
+```typescript
+public add(scopes: ...IDependable[]): void
+```
+
+Add a construct to the dependency roots.
+
+###### `scopes`<sup>Required</sup> <a name="scopes" id="constructs.DependencyGroup.add.parameter.scopes"></a>
+
+- *Type:* ...<a href="#constructs.IDependable">IDependable</a>[]
+
+---
+
+
+
+
+### Node <a name="Node" id="constructs.Node"></a>
+
+Represents the construct node in the scope tree.
+
+#### Initializers <a name="Initializers" id="constructs.Node.Initializer"></a>
+
+```typescript
+import { Node } from 'constructs'
+
+new Node(host: Construct, scope: IConstruct, id: string)
+```
+
+| **Name** | **Type** | **Description** |
+| --- | --- | --- |
+| <code><a href="#constructs.Node.Initializer.parameter.host">host</a></code> | <code><a href="#constructs.Construct">Construct</a></code> | *No description.* |
+| <code><a href="#constructs.Node.Initializer.parameter.scope">scope</a></code> | <code><a href="#constructs.IConstruct">IConstruct</a></code> | *No description.* |
+| <code><a href="#constructs.Node.Initializer.parameter.id">id</a></code> | <code>string</code> | *No description.* |
+
+---
+
+##### `host`<sup>Required</sup> <a name="host" id="constructs.Node.Initializer.parameter.host"></a>
+
+- *Type:* <a href="#constructs.Construct">Construct</a>
+
+---
+
+##### `scope`<sup>Required</sup> <a name="scope" id="constructs.Node.Initializer.parameter.scope"></a>
+
+- *Type:* <a href="#constructs.IConstruct">IConstruct</a>
+
+---
+
+##### `id`<sup>Required</sup> <a name="id" id="constructs.Node.Initializer.parameter.id"></a>
+
+- *Type:* string
+
+---
+
+#### Methods <a name="Methods" id="Methods"></a>
+
+| **Name** | **Description** |
+| --- | --- |
+| <code><a href="#constructs.Node.addDependency">addDependency</a></code> | Add an ordering dependency on another construct. |
+| <code><a href="#constructs.Node.addMetadata">addMetadata</a></code> | Adds a metadata entry to this construct. |
+| <code><a href="#constructs.Node.addValidation">addValidation</a></code> | Adds a validation to this construct. |
+| <code><a href="#constructs.Node.findAll">findAll</a></code> | Return this construct and all of its children in the given order. |
+| <code><a href="#constructs.Node.findChild">findChild</a></code> | Return a direct child by id. |
+| <code><a href="#constructs.Node.getAllContext">getAllContext</a></code> | Retrieves the all context of a node from tree context. |
+| <code><a href="#constructs.Node.getContext">getContext</a></code> | Retrieves a value from tree context if present. Otherwise, would throw an error. |
+| <code><a href="#constructs.Node.lock">lock</a></code> | Locks this construct from allowing more children to be added. |
+| <code><a href="#constructs.Node.setContext">setContext</a></code> | This can be used to set contextual values. |
+| <code><a href="#constructs.Node.tryFindChild">tryFindChild</a></code> | Return a direct child by id, or undefined. |
+| <code><a href="#constructs.Node.tryGetContext">tryGetContext</a></code> | Retrieves a value from tree context. |
+| <code><a href="#constructs.Node.tryRemoveChild">tryRemoveChild</a></code> | Remove the child with the given name, if present. |
+| <code><a href="#constructs.Node.validate">validate</a></code> | Validates this construct. |
+| <code><a href="#constructs.Node.with">with</a></code> | Applies one or more mixins to this construct. |
+
+---
+
+##### `addDependency` <a name="addDependency" id="constructs.Node.addDependency"></a>
+
+```typescript
+public addDependency(deps: ...IDependable[]): void
+```
+
+Add an ordering dependency on another construct.
+
+An `IDependable`
+
+###### `deps`<sup>Required</sup> <a name="deps" id="constructs.Node.addDependency.parameter.deps"></a>
+
+- *Type:* ...<a href="#constructs.IDependable">IDependable</a>[]
+
+---
+
+##### `addMetadata` <a name="addMetadata" id="constructs.Node.addMetadata"></a>
+
+```typescript
+public addMetadata(type: string, data: any, options?: MetadataOptions): void
+```
+
+Adds a metadata entry to this construct.
+
+Entries are arbitrary values and will also include a stack trace to allow tracing back to
+the code location for when the entry was added. It can be used, for example, to include source
+mapping in CloudFormation templates to improve diagnostics.
+Note that construct metadata is not the same as CloudFormation resource metadata and is never written to the CloudFormation template.
+The metadata entries are written to the Cloud Assembly Manifest if the `treeMetadata` property is specified in the props of the App that contains this Construct.
+
+###### `type`<sup>Required</sup> <a name="type" id="constructs.Node.addMetadata.parameter.type"></a>
+
+- *Type:* string
+
+a string denoting the type of metadata.
+
+---
+
+###### `data`<sup>Required</sup> <a name="data" id="constructs.Node.addMetadata.parameter.data"></a>
+
+- *Type:* any
+
+the value of the metadata (can be a Token).
+
+If null/undefined, metadata will not be added.
+
+---
+
+###### `options`<sup>Optional</sup> <a name="options" id="constructs.Node.addMetadata.parameter.options"></a>
+
+- *Type:* <a href="#constructs.MetadataOptions">MetadataOptions</a>
+
+options.
+
+---
+
+##### `addValidation` <a name="addValidation" id="constructs.Node.addValidation"></a>
+
+```typescript
+public addValidation(validation: IValidation): void
+```
+
+Adds a validation to this construct.
+
+When `node.validate()` is called, the `validate()` method will be called on
+all validations and all errors will be returned.
+
+###### `validation`<sup>Required</sup> <a name="validation" id="constructs.Node.addValidation.parameter.validation"></a>
+
+- *Type:* <a href="#constructs.IValidation">IValidation</a>
+
+The validation object.
+
+---
+
+##### `findAll` <a name="findAll" id="constructs.Node.findAll"></a>
+
+```typescript
+public findAll(order?: ConstructOrder): IConstruct[]
+```
+
+Return this construct and all of its children in the given order.
+
+###### `order`<sup>Optional</sup> <a name="order" id="constructs.Node.findAll.parameter.order"></a>
+
+- *Type:* <a href="#constructs.ConstructOrder">ConstructOrder</a>
+
+---
+
+##### `findChild` <a name="findChild" id="constructs.Node.findChild"></a>
+
+```typescript
+public findChild(id: string): IConstruct
+```
+
+Return a direct child by id.
+
+Throws an error if the child is not found.
+
+###### `id`<sup>Required</sup> <a name="id" id="constructs.Node.findChild.parameter.id"></a>
+
+- *Type:* string
+
+Identifier of direct child.
+
+---
+
+##### `getAllContext` <a name="getAllContext" id="constructs.Node.getAllContext"></a>
+
+```typescript
+public getAllContext(defaults?: object): any
+```
+
+Retrieves the all context of a node from tree context.
+
+Context is usually initialized at the root, but can be overridden at any point in the tree.
+
+###### `defaults`<sup>Optional</sup> <a name="defaults" id="constructs.Node.getAllContext.parameter.defaults"></a>
+
+- *Type:* object
+
+Any keys to override the retrieved context.
+
+---
+
+##### `getContext` <a name="getContext" id="constructs.Node.getContext"></a>
+
+```typescript
+public getContext(key: string): any
+```
+
+Retrieves a value from tree context if present. Otherwise, would throw an error.
+
+Context is usually initialized at the root, but can be overridden at any point in the tree.
+
+###### `key`<sup>Required</sup> <a name="key" id="constructs.Node.getContext.parameter.key"></a>
+
+- *Type:* string
+
+The context key.
+
+---
+
+##### `lock` <a name="lock" id="constructs.Node.lock"></a>
+
+```typescript
+public lock(): void
+```
+
+Locks this construct from allowing more children to be added.
+
+After this
+call, no more children can be added to this construct or to any children.
+
+##### `setContext` <a name="setContext" id="constructs.Node.setContext"></a>
+
+```typescript
+public setContext(key: string, value: any): void
+```
+
+This can be used to set contextual values.
+
+Context must be set before any children are added, since children may consult context info during construction.
+If the key already exists, it will be overridden.
+
+###### `key`<sup>Required</sup> <a name="key" id="constructs.Node.setContext.parameter.key"></a>
+
+- *Type:* string
+
+The context key.
+
+---
+
+###### `value`<sup>Required</sup> <a name="value" id="constructs.Node.setContext.parameter.value"></a>
+
+- *Type:* any
+
+The context value.
+
+---
+
+##### `tryFindChild` <a name="tryFindChild" id="constructs.Node.tryFindChild"></a>
+
+```typescript
+public tryFindChild(id: string): IConstruct
+```
+
+Return a direct child by id, or undefined.
+
+###### `id`<sup>Required</sup> <a name="id" id="constructs.Node.tryFindChild.parameter.id"></a>
+
+- *Type:* string
+
+Identifier of direct child.
+
+---
+
+##### `tryGetContext` <a name="tryGetContext" id="constructs.Node.tryGetContext"></a>
+
+```typescript
+public tryGetContext(key: string): any
+```
+
+Retrieves a value from tree context.
+
+Context is usually initialized at the root, but can be overridden at any point in the tree.
+
+###### `key`<sup>Required</sup> <a name="key" id="constructs.Node.tryGetContext.parameter.key"></a>
+
+- *Type:* string
+
+The context key.
+
+---
+
+##### `tryRemoveChild` <a name="tryRemoveChild" id="constructs.Node.tryRemoveChild"></a>
+
+```typescript
+public tryRemoveChild(childName: string): boolean
+```
+
+Remove the child with the given name, if present.
+
+###### `childName`<sup>Required</sup> <a name="childName" id="constructs.Node.tryRemoveChild.parameter.childName"></a>
+
+- *Type:* string
+
+---
+
+##### `validate` <a name="validate" id="constructs.Node.validate"></a>
+
+```typescript
+public validate(): string[]
+```
+
+Validates this construct.
+
+Invokes the `validate()` method on all validations added through
+`addValidation()`.
+
+##### `with` <a name="with" id="constructs.Node.with"></a>
+
+```typescript
+public with(mixins: ...IMixin[]): IConstruct
+```
+
+Applies one or more mixins to this construct.
+
+Mixins are applied in order. The list of constructs is captured at the
+start of the call, so constructs added by a mixin will not be visited.
+Use multiple `with()` calls if subsequent mixins should apply to added
+constructs.
+
+###### `mixins`<sup>Required</sup> <a name="mixins" id="constructs.Node.with.parameter.mixins"></a>
+
+- *Type:* ...<a href="#constructs.IMixin">IMixin</a>[]
+
+The mixins to apply.
+
+---
+
+#### Static Functions <a name="Static Functions" id="Static Functions"></a>
+
+| **Name** | **Description** |
+| --- | --- |
+| <code><a href="#constructs.Node.of">of</a></code> | Returns the node associated with a construct. |
+
+---
+
+##### ~~`of`~~ <a name="of" id="constructs.Node.of"></a>
+
+```typescript
+import { Node } from 'constructs'
+
+Node.of(construct: IConstruct)
+```
+
+Returns the node associated with a construct.
+
+###### `construct`<sup>Required</sup> <a name="construct" id="constructs.Node.of.parameter.construct"></a>
+
+- *Type:* <a href="#constructs.IConstruct">IConstruct</a>
+
+the construct.
+
+---
+
+#### Properties <a name="Properties" id="Properties"></a>
+
+| **Name** | **Type** | **Description** |
+| --- | --- | --- |
+| <code><a href="#constructs.Node.property.addr">addr</a></code> | <code>string</code> | Returns an opaque tree-unique address for this construct. |
+| <code><a href="#constructs.Node.property.children">children</a></code> | <code><a href="#constructs.IConstruct">IConstruct</a>[]</code> | All direct children of this construct. |
+| <code><a href="#constructs.Node.property.dependencies">dependencies</a></code> | <code><a href="#constructs.IConstruct">IConstruct</a>[]</code> | Return all dependencies registered on this node (non-recursive). |
+| <code><a href="#constructs.Node.property.id">id</a></code> | <code>string</code> | The id of this construct within the current scope. |
+| <code><a href="#constructs.Node.property.locked">locked</a></code> | <code>boolean</code> | Returns true if this construct or the scopes in which it is defined are locked. |
+| <code><a href="#constructs.Node.property.metadata">metadata</a></code> | <code><a href="#constructs.MetadataEntry">MetadataEntry</a>[]</code> | An immutable array of metadata objects associated with this construct. |
+| <code><a href="#constructs.Node.property.path">path</a></code> | <code>string</code> | The full, absolute path of this construct in the tree. |
+| <code><a href="#constructs.Node.property.root">root</a></code> | <code><a href="#constructs.IConstruct">IConstruct</a></code> | Returns the root of the construct tree. |
+| <code><a href="#constructs.Node.property.scopes">scopes</a></code> | <code><a href="#constructs.IConstruct">IConstruct</a>[]</code> | All parent scopes of this construct. |
+| <code><a href="#constructs.Node.property.scope">scope</a></code> | <code><a href="#constructs.IConstruct">IConstruct</a></code> | Returns the scope in which this construct is defined. |
+| <code><a href="#constructs.Node.property.defaultChild">defaultChild</a></code> | <code><a href="#constructs.IConstruct">IConstruct</a></code> | Returns the child construct that has the id `Default` or `Resource`. |
+
+---
+
+##### `addr`<sup>Required</sup> <a name="addr" id="constructs.Node.property.addr"></a>
+
+```typescript
+public readonly addr: string;
+```
+
+- *Type:* string
+
+Returns an opaque tree-unique address for this construct.
+
+Addresses are 42 characters hexadecimal strings. They begin with "c8"
+followed by 40 lowercase hexadecimal characters (0-9a-f).
+
+Addresses are calculated using a SHA-1 of the components of the construct
+path.
+
+To enable refactoring of construct trees, constructs with the ID `Default`
+will be excluded from the calculation. In those cases constructs in the
+same tree may have the same address.
+
+---
+
+*Example*
+
+```typescript
+c83a2846e506bcc5f10682b564084bca2d275709ee
+```
+
+
+##### `children`<sup>Required</sup> <a name="children" id="constructs.Node.property.children"></a>
+
+```typescript
+public readonly children: IConstruct[];
+```
+
+- *Type:* <a href="#constructs.IConstruct">IConstruct</a>[]
+
+All direct children of this construct.
+
+---
+
+##### `dependencies`<sup>Required</sup> <a name="dependencies" id="constructs.Node.property.dependencies"></a>
+
+```typescript
+public readonly dependencies: IConstruct[];
+```
+
+- *Type:* <a href="#constructs.IConstruct">IConstruct</a>[]
+
+Return all dependencies registered on this node (non-recursive).
+
+---
+
+##### `id`<sup>Required</sup> <a name="id" id="constructs.Node.property.id"></a>
+
+```typescript
+public readonly id: string;
+```
+
+- *Type:* string
+
+The id of this construct within the current scope.
+
+This is a scope-unique id. To obtain an app-unique id for this construct, use `addr`.
+
+---
+
+##### `locked`<sup>Required</sup> <a name="locked" id="constructs.Node.property.locked"></a>
+
+```typescript
+public readonly locked: boolean;
+```
+
+- *Type:* boolean
+
+Returns true if this construct or the scopes in which it is defined are locked.
+
+---
+
+##### `metadata`<sup>Required</sup> <a name="metadata" id="constructs.Node.property.metadata"></a>
+
+```typescript
+public readonly metadata: MetadataEntry[];
+```
+
+- *Type:* <a href="#constructs.MetadataEntry">MetadataEntry</a>[]
+
+An immutable array of metadata objects associated with this construct.
+
+This can be used, for example, to implement support for deprecation notices, source mapping, etc.
+
+---
+
+##### `path`<sup>Required</sup> <a name="path" id="constructs.Node.property.path"></a>
+
+```typescript
+public readonly path: string;
+```
+
+- *Type:* string
+
+The full, absolute path of this construct in the tree.
+
+Components are separated by '/'.
+
+---
+
+##### `root`<sup>Required</sup> <a name="root" id="constructs.Node.property.root"></a>
+
+```typescript
+public readonly root: IConstruct;
+```
+
+- *Type:* <a href="#constructs.IConstruct">IConstruct</a>
+
+Returns the root of the construct tree.
+
+---
+
+##### `scopes`<sup>Required</sup> <a name="scopes" id="constructs.Node.property.scopes"></a>
+
+```typescript
+public readonly scopes: IConstruct[];
+```
+
+- *Type:* <a href="#constructs.IConstruct">IConstruct</a>[]
+
+All parent scopes of this construct.
+
+---
+
+##### `scope`<sup>Optional</sup> <a name="scope" id="constructs.Node.property.scope"></a>
+
+```typescript
+public readonly scope: IConstruct;
+```
+
+- *Type:* <a href="#constructs.IConstruct">IConstruct</a>
+
+Returns the scope in which this construct is defined.
+
+The value is `undefined` at the root of the construct scope tree.
+
+---
+
+##### `defaultChild`<sup>Optional</sup> <a name="defaultChild" id="constructs.Node.property.defaultChild"></a>
+
+```typescript
+public readonly defaultChild: IConstruct;
+```
+
+- *Type:* <a href="#constructs.IConstruct">IConstruct</a>
+
+Returns the child construct that has the id `Default` or `Resource`.
+
+This is usually the construct that provides the bulk of the underlying functionality.
+Useful for modifications of the underlying construct that are not available at the higher levels.
+Override the defaultChild property.
+
+This should only be used in the cases where the correct
+default child is not named 'Resource' or 'Default' as it
+should be.
+
+If you set this to undefined, the default behavior of finding
+the child named 'Resource' or 'Default' will be used.
+
+---
+
+#### Constants <a name="Constants" id="Constants"></a>
+
+| **Name** | **Type** | **Description** |
+| --- | --- | --- |
+| <code><a href="#constructs.Node.property.PATH_SEP">PATH_SEP</a></code> | <code>string</code> | Separator used to delimit construct path components. |
+
+---
+
+##### `PATH_SEP`<sup>Required</sup> <a name="PATH_SEP" id="constructs.Node.property.PATH_SEP"></a>
+
+```typescript
+public readonly PATH_SEP: string;
+```
+
+- *Type:* string
+
+Separator used to delimit construct path components.
+
+---
+
+## Protocols <a name="Protocols" id="Protocols"></a>
+
+### IConstruct <a name="IConstruct" id="constructs.IConstruct"></a>
+
+- *Extends:* <a href="#constructs.IDependable">IDependable</a>
+
+- *Implemented By:* <a href="#constructs.Construct">Construct</a>, <a href="#constructs.RootConstruct">RootConstruct</a>, <a href="#constructs.IConstruct">IConstruct</a>
+
+Represents a construct.
+
+#### Methods <a name="Methods" id="Methods"></a>
+
+| **Name** | **Description** |
+| --- | --- |
+| <code><a href="#constructs.IConstruct.with">with</a></code> | Applies one or more mixins to this construct. |
+
+---
+
+##### `with` <a name="with" id="constructs.IConstruct.with"></a>
+
+```typescript
+public with(mixins: ...IMixin[]): IConstruct
+```
+
+Applies one or more mixins to this construct.
+
+Mixins are applied in order. The list of constructs is captured at the
+start of the call, so constructs added by a mixin will not be visited.
+
+###### `mixins`<sup>Required</sup> <a name="mixins" id="constructs.IConstruct.with.parameter.mixins"></a>
+
+- *Type:* ...<a href="#constructs.IMixin">IMixin</a>[]
+
+The mixins to apply.
+
+---
+
+#### Properties <a name="Properties" id="Properties"></a>
+
+| **Name** | **Type** | **Description** |
+| --- | --- | --- |
+| <code><a href="#constructs.IConstruct.property.node">node</a></code> | <code><a href="#constructs.Node">Node</a></code> | The tree node. |
+
+---
+
+##### `node`<sup>Required</sup> <a name="node" id="constructs.IConstruct.property.node"></a>
+
+```typescript
+public readonly node: Node;
+```
+
+- *Type:* <a href="#constructs.Node">Node</a>
+
+The tree node.
+
+---
+
+### IDependable <a name="IDependable" id="constructs.IDependable"></a>
+
+- *Implemented By:* <a href="#constructs.Construct">Construct</a>, <a href="#constructs.DependencyGroup">DependencyGroup</a>, <a href="#constructs.RootConstruct">RootConstruct</a>, <a href="#constructs.IConstruct">IConstruct</a>, <a href="#constructs.IDependable">IDependable</a>
+
+Trait marker for classes that can be depended upon.
+
+The presence of this interface indicates that an object has
+an `IDependable` implementation.
+
+This interface can be used to take an (ordering) dependency on a set of
+constructs. An ordering dependency implies that the resources represented by
+those constructs are deployed before the resources depending ON them are
+deployed.
+
+
+
+### IMixin <a name="IMixin" id="constructs.IMixin"></a>
+
+- *Implemented By:* <a href="#constructs.IMixin">IMixin</a>
+
+A mixin is a reusable piece of functionality that can be applied to constructs to add behavior, properties, or modify existing functionality without inheritance.
+
+#### Methods <a name="Methods" id="Methods"></a>
+
+| **Name** | **Description** |
+| --- | --- |
+| <code><a href="#constructs.IMixin.applyTo">applyTo</a></code> | Applies the mixin functionality to the target construct. |
+| <code><a href="#constructs.IMixin.supports">supports</a></code> | Determines whether this mixin can be applied to the given construct. |
+
+---
+
+##### `applyTo` <a name="applyTo" id="constructs.IMixin.applyTo"></a>
+
+```typescript
+public applyTo(construct: IConstruct): void
+```
+
+Applies the mixin functionality to the target construct.
+
+###### `construct`<sup>Required</sup> <a name="construct" id="constructs.IMixin.applyTo.parameter.construct"></a>
+
+- *Type:* <a href="#constructs.IConstruct">IConstruct</a>
+
+---
+
+##### `supports` <a name="supports" id="constructs.IMixin.supports"></a>
+
+```typescript
+public supports(construct: IConstruct): boolean
+```
+
+Determines whether this mixin can be applied to the given construct.
+
+###### `construct`<sup>Required</sup> <a name="construct" id="constructs.IMixin.supports.parameter.construct"></a>
+
+- *Type:* <a href="#constructs.IConstruct">IConstruct</a>
+
+---
+
+
+### IValidation <a name="IValidation" id="constructs.IValidation"></a>
+
+- *Implemented By:* <a href="#constructs.IValidation">IValidation</a>
+
+Implement this interface in order for the construct to be able to validate itself.
+
+#### Methods <a name="Methods" id="Methods"></a>
+
+| **Name** | **Description** |
+| --- | --- |
+| <code><a href="#constructs.IValidation.validate">validate</a></code> | Validate the current construct. |
+
+---
+
+##### `validate` <a name="validate" id="constructs.IValidation.validate"></a>
+
+```typescript
+public validate(): string[]
+```
+
+Validate the current construct.
+
+This method can be implemented by derived constructs in order to perform
+validation logic. It is called on all constructs before synthesis.
+
+
+## Enums <a name="Enums" id="Enums"></a>
+
+### ConstructOrder <a name="ConstructOrder" id="constructs.ConstructOrder"></a>
+
+In what order to return constructs.
+
+#### Members <a name="Members" id="Members"></a>
+
+| **Name** | **Description** |
+| --- | --- |
+| <code><a href="#constructs.ConstructOrder.PREORDER">PREORDER</a></code> | Depth-first, pre-order. |
+| <code><a href="#constructs.ConstructOrder.POSTORDER">POSTORDER</a></code> | Depth-first, post-order (leaf nodes first). |
+
+---
+
+##### `PREORDER` <a name="PREORDER" id="constructs.ConstructOrder.PREORDER"></a>
+
+Depth-first, pre-order.
+
+---
+
+
+##### `POSTORDER` <a name="POSTORDER" id="constructs.ConstructOrder.POSTORDER"></a>
+
+Depth-first, post-order (leaf nodes first).
+
+---
+