@cdktn/provider-random 12.1.0

package/lib/string-resource/index.d.ts

@@ -0,0 +1,177 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+import { Construct } from 'constructs';
+import * as cdktf from 'cdktf';
+export interface StringResourceConfig extends cdktf.TerraformMetaArguments {
+    /**
+    * Arbitrary map of values that, when changed, will trigger recreation of resource. See [the main provider documentation](../index.html) for more information.
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/string#keepers StringResource#keepers}
+    */
+    readonly keepers?: {
+        [key: string]: string;
+    };
+    /**
+    * The length of the string desired. The minimum value for length is 1 and, length must also be >= (`min_upper` + `min_lower` + `min_numeric` + `min_special`).
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/string#length StringResource#length}
+    */
+    readonly length: number;
+    /**
+    * Include lowercase alphabet characters in the result. Default value is `true`.
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/string#lower StringResource#lower}
+    */
+    readonly lower?: boolean | cdktf.IResolvable;
+    /**
+    * Minimum number of lowercase alphabet characters in the result. Default value is `0`.
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/string#min_lower StringResource#min_lower}
+    */
+    readonly minLower?: number;
+    /**
+    * Minimum number of numeric characters in the result. Default value is `0`.
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/string#min_numeric StringResource#min_numeric}
+    */
+    readonly minNumeric?: number;
+    /**
+    * Minimum number of special characters in the result. Default value is `0`.
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/string#min_special StringResource#min_special}
+    */
+    readonly minSpecial?: number;
+    /**
+    * Minimum number of uppercase alphabet characters in the result. Default value is `0`.
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/string#min_upper StringResource#min_upper}
+    */
+    readonly minUpper?: number;
+    /**
+    * Include numeric characters in the result. Default value is `true`. If `number`, `upper`, `lower`, and `special` are all configured, at least one of them must be set to `true`. **NOTE**: This is deprecated, use `numeric` instead.
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/string#number StringResource#number}
+    */
+    readonly number?: boolean | cdktf.IResolvable;
+    /**
+    * Include numeric characters in the result. Default value is `true`. If `numeric`, `upper`, `lower`, and `special` are all configured, at least one of them must be set to `true`.
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/string#numeric StringResource#numeric}
+    */
+    readonly numeric?: boolean | cdktf.IResolvable;
+    /**
+    * Supply your own list of special characters to use for string generation.  This overrides the default character list in the special argument.  The `special` argument must still be set to true for any overwritten characters to be used in generation.
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/string#override_special StringResource#override_special}
+    */
+    readonly overrideSpecial?: string;
+    /**
+    * Include special characters in the result. These are `!@#$%&*()-_=+[]{}<>:?`. Default value is `true`.
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/string#special StringResource#special}
+    */
+    readonly special?: boolean | cdktf.IResolvable;
+    /**
+    * Include uppercase alphabet characters in the result. Default value is `true`.
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/string#upper StringResource#upper}
+    */
+    readonly upper?: boolean | cdktf.IResolvable;
+}
+/**
+* Represents a {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/string random_string}
+*/
+export declare class StringResource extends cdktf.TerraformResource {
+    static readonly tfResourceType = "random_string";
+    /**
+    * Generates CDKTF code for importing a StringResource resource upon running "cdktf plan <stack-name>"
+    * @param scope The scope in which to define this construct
+    * @param importToId The construct id used in the generated config for the StringResource to import
+    * @param importFromId The id of the existing StringResource that should be imported. Refer to the {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/string#import import section} in the documentation of this resource for the id to use
+    * @param provider? Optional instance of the provider where the StringResource to import is found
+    */
+    static generateConfigForImport(scope: Construct, importToId: string, importFromId: string, provider?: cdktf.TerraformProvider): cdktf.ImportableResource;
+    /**
+    * Create a new {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/string random_string} Resource
+    *
+    * @param scope The scope in which to define this construct
+    * @param id The scoped construct ID. Must be unique amongst siblings in the same scope
+    * @param options StringResourceConfig
+    */
+    constructor(scope: Construct, id: string, config: StringResourceConfig);
+    get id(): string;
+    private _keepers?;
+    get keepers(): {
+        [key: string]: string;
+    };
+    set keepers(value: {
+        [key: string]: string;
+    });
+    resetKeepers(): void;
+    get keepersInput(): {
+        [key: string]: string;
+    } | undefined;
+    private _length?;
+    get length(): number;
+    set length(value: number);
+    get lengthInput(): number | undefined;
+    private _lower?;
+    get lower(): boolean | cdktf.IResolvable;
+    set lower(value: boolean | cdktf.IResolvable);
+    resetLower(): void;
+    get lowerInput(): boolean | cdktf.IResolvable | undefined;
+    private _minLower?;
+    get minLower(): number;
+    set minLower(value: number);
+    resetMinLower(): void;
+    get minLowerInput(): number | undefined;
+    private _minNumeric?;
+    get minNumeric(): number;
+    set minNumeric(value: number);
+    resetMinNumeric(): void;
+    get minNumericInput(): number | undefined;
+    private _minSpecial?;
+    get minSpecial(): number;
+    set minSpecial(value: number);
+    resetMinSpecial(): void;
+    get minSpecialInput(): number | undefined;
+    private _minUpper?;
+    get minUpper(): number;
+    set minUpper(value: number);
+    resetMinUpper(): void;
+    get minUpperInput(): number | undefined;
+    private _number?;
+    get number(): boolean | cdktf.IResolvable;
+    set number(value: boolean | cdktf.IResolvable);
+    resetNumber(): void;
+    get numberInput(): boolean | cdktf.IResolvable | undefined;
+    private _numeric?;
+    get numeric(): boolean | cdktf.IResolvable;
+    set numeric(value: boolean | cdktf.IResolvable);
+    resetNumeric(): void;
+    get numericInput(): boolean | cdktf.IResolvable | undefined;
+    private _overrideSpecial?;
+    get overrideSpecial(): string;
+    set overrideSpecial(value: string);
+    resetOverrideSpecial(): void;
+    get overrideSpecialInput(): string | undefined;
+    get result(): string;
+    private _special?;
+    get special(): boolean | cdktf.IResolvable;
+    set special(value: boolean | cdktf.IResolvable);
+    resetSpecial(): void;
+    get specialInput(): boolean | cdktf.IResolvable | undefined;
+    private _upper?;
+    get upper(): boolean | cdktf.IResolvable;
+    set upper(value: boolean | cdktf.IResolvable);
+    resetUpper(): void;
+    get upperInput(): boolean | cdktf.IResolvable | undefined;
+    protected synthesizeAttributes(): {
+        [name: string]: any;
+    };
+    protected synthesizeHclAttributes(): {
+        [name: string]: any;
+    };
+}

package/lib/string-resource/index.js

@@ -0,0 +1,332 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringResource = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const cdktf = require("cdktf");
+/**
+* Represents a {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/string random_string}
+*/
+class StringResource extends cdktf.TerraformResource {
+    // ==============
+    // STATIC Methods
+    // ==============
+    /**
+    * Generates CDKTF code for importing a StringResource resource upon running "cdktf plan <stack-name>"
+    * @param scope The scope in which to define this construct
+    * @param importToId The construct id used in the generated config for the StringResource to import
+    * @param importFromId The id of the existing StringResource that should be imported. Refer to the {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/string#import import section} in the documentation of this resource for the id to use
+    * @param provider? Optional instance of the provider where the StringResource to import is found
+    */
+    static generateConfigForImport(scope, importToId, importFromId, provider) {
+        return new cdktf.ImportableResource(scope, importToId, { terraformResourceType: "random_string", importId: importFromId, provider });
+    }
+    // ===========
+    // INITIALIZER
+    // ===========
+    /**
+    * Create a new {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/string random_string} Resource
+    *
+    * @param scope The scope in which to define this construct
+    * @param id The scoped construct ID. Must be unique amongst siblings in the same scope
+    * @param options StringResourceConfig
+    */
+    constructor(scope, id, config) {
+        super(scope, id, {
+            terraformResourceType: 'random_string',
+            terraformGeneratorMetadata: {
+                providerName: 'random',
+                providerVersion: '3.7.2',
+                providerVersionConstraint: '~> 3.1'
+            },
+            provider: config.provider,
+            dependsOn: config.dependsOn,
+            count: config.count,
+            lifecycle: config.lifecycle,
+            provisioners: config.provisioners,
+            connection: config.connection,
+            forEach: config.forEach
+        });
+        this._keepers = config.keepers;
+        this._length = config.length;
+        this._lower = config.lower;
+        this._minLower = config.minLower;
+        this._minNumeric = config.minNumeric;
+        this._minSpecial = config.minSpecial;
+        this._minUpper = config.minUpper;
+        this._number = config.number;
+        this._numeric = config.numeric;
+        this._overrideSpecial = config.overrideSpecial;
+        this._special = config.special;
+        this._upper = config.upper;
+    }
+    // ==========
+    // ATTRIBUTES
+    // ==========
+    // id - computed: true, optional: false, required: false
+    get id() {
+        return this.getStringAttribute('id');
+    }
+    get keepers() {
+        return this.getStringMapAttribute('keepers');
+    }
+    set keepers(value) {
+        this._keepers = value;
+    }
+    resetKeepers() {
+        this._keepers = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get keepersInput() {
+        return this._keepers;
+    }
+    get length() {
+        return this.getNumberAttribute('length');
+    }
+    set length(value) {
+        this._length = value;
+    }
+    // Temporarily expose input value. Use with caution.
+    get lengthInput() {
+        return this._length;
+    }
+    get lower() {
+        return this.getBooleanAttribute('lower');
+    }
+    set lower(value) {
+        this._lower = value;
+    }
+    resetLower() {
+        this._lower = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get lowerInput() {
+        return this._lower;
+    }
+    get minLower() {
+        return this.getNumberAttribute('min_lower');
+    }
+    set minLower(value) {
+        this._minLower = value;
+    }
+    resetMinLower() {
+        this._minLower = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get minLowerInput() {
+        return this._minLower;
+    }
+    get minNumeric() {
+        return this.getNumberAttribute('min_numeric');
+    }
+    set minNumeric(value) {
+        this._minNumeric = value;
+    }
+    resetMinNumeric() {
+        this._minNumeric = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get minNumericInput() {
+        return this._minNumeric;
+    }
+    get minSpecial() {
+        return this.getNumberAttribute('min_special');
+    }
+    set minSpecial(value) {
+        this._minSpecial = value;
+    }
+    resetMinSpecial() {
+        this._minSpecial = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get minSpecialInput() {
+        return this._minSpecial;
+    }
+    get minUpper() {
+        return this.getNumberAttribute('min_upper');
+    }
+    set minUpper(value) {
+        this._minUpper = value;
+    }
+    resetMinUpper() {
+        this._minUpper = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get minUpperInput() {
+        return this._minUpper;
+    }
+    get number() {
+        return this.getBooleanAttribute('number');
+    }
+    set number(value) {
+        this._number = value;
+    }
+    resetNumber() {
+        this._number = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get numberInput() {
+        return this._number;
+    }
+    get numeric() {
+        return this.getBooleanAttribute('numeric');
+    }
+    set numeric(value) {
+        this._numeric = value;
+    }
+    resetNumeric() {
+        this._numeric = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get numericInput() {
+        return this._numeric;
+    }
+    get overrideSpecial() {
+        return this.getStringAttribute('override_special');
+    }
+    set overrideSpecial(value) {
+        this._overrideSpecial = value;
+    }
+    resetOverrideSpecial() {
+        this._overrideSpecial = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get overrideSpecialInput() {
+        return this._overrideSpecial;
+    }
+    // result - computed: true, optional: false, required: false
+    get result() {
+        return this.getStringAttribute('result');
+    }
+    get special() {
+        return this.getBooleanAttribute('special');
+    }
+    set special(value) {
+        this._special = value;
+    }
+    resetSpecial() {
+        this._special = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get specialInput() {
+        return this._special;
+    }
+    get upper() {
+        return this.getBooleanAttribute('upper');
+    }
+    set upper(value) {
+        this._upper = value;
+    }
+    resetUpper() {
+        this._upper = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get upperInput() {
+        return this._upper;
+    }
+    // =========
+    // SYNTHESIS
+    // =========
+    synthesizeAttributes() {
+        return {
+            keepers: cdktf.hashMapper(cdktf.stringToTerraform)(this._keepers),
+            length: cdktf.numberToTerraform(this._length),
+            lower: cdktf.booleanToTerraform(this._lower),
+            min_lower: cdktf.numberToTerraform(this._minLower),
+            min_numeric: cdktf.numberToTerraform(this._minNumeric),
+            min_special: cdktf.numberToTerraform(this._minSpecial),
+            min_upper: cdktf.numberToTerraform(this._minUpper),
+            number: cdktf.booleanToTerraform(this._number),
+            numeric: cdktf.booleanToTerraform(this._numeric),
+            override_special: cdktf.stringToTerraform(this._overrideSpecial),
+            special: cdktf.booleanToTerraform(this._special),
+            upper: cdktf.booleanToTerraform(this._upper),
+        };
+    }
+    synthesizeHclAttributes() {
+        const attrs = {
+            keepers: {
+                value: cdktf.hashMapperHcl(cdktf.stringToHclTerraform)(this._keepers),
+                isBlock: false,
+                type: "map",
+                storageClassType: "stringMap",
+            },
+            length: {
+                value: cdktf.numberToHclTerraform(this._length),
+                isBlock: false,
+                type: "simple",
+                storageClassType: "number",
+            },
+            lower: {
+                value: cdktf.booleanToHclTerraform(this._lower),
+                isBlock: false,
+                type: "simple",
+                storageClassType: "boolean",
+            },
+            min_lower: {
+                value: cdktf.numberToHclTerraform(this._minLower),
+                isBlock: false,
+                type: "simple",
+                storageClassType: "number",
+            },
+            min_numeric: {
+                value: cdktf.numberToHclTerraform(this._minNumeric),
+                isBlock: false,
+                type: "simple",
+                storageClassType: "number",
+            },
+            min_special: {
+                value: cdktf.numberToHclTerraform(this._minSpecial),
+                isBlock: false,
+                type: "simple",
+                storageClassType: "number",
+            },
+            min_upper: {
+                value: cdktf.numberToHclTerraform(this._minUpper),
+                isBlock: false,
+                type: "simple",
+                storageClassType: "number",
+            },
+            number: {
+                value: cdktf.booleanToHclTerraform(this._number),
+                isBlock: false,
+                type: "simple",
+                storageClassType: "boolean",
+            },
+            numeric: {
+                value: cdktf.booleanToHclTerraform(this._numeric),
+                isBlock: false,
+                type: "simple",
+                storageClassType: "boolean",
+            },
+            override_special: {
+                value: cdktf.stringToHclTerraform(this._overrideSpecial),
+                isBlock: false,
+                type: "simple",
+                storageClassType: "string",
+            },
+            special: {
+                value: cdktf.booleanToHclTerraform(this._special),
+                isBlock: false,
+                type: "simple",
+                storageClassType: "boolean",
+            },
+            upper: {
+                value: cdktf.booleanToHclTerraform(this._upper),
+                isBlock: false,
+                type: "simple",
+                storageClassType: "boolean",
+            },
+        };
+        // remove undefined attributes
+        return Object.fromEntries(Object.entries(attrs).filter(([_, value]) => value !== undefined && value.value !== undefined));
+    }
+}
+exports.StringResource = StringResource;
+_a = JSII_RTTI_SYMBOL_1;
+StringResource[_a] = { fqn: "@cdktn/provider-random.stringResource.StringResource", version: "12.1.0" };
+// =================
+// STATIC PROPERTIES
+// =================
+StringResource.tfResourceType = "random_string";
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/string-resource/index.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Copyright (c) HashiCorp, Inc.\n * SPDX-License-Identifier: MPL-2.0\n */\n\n// https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/string\n// generated from terraform resource schema\n\nimport { Construct } from 'constructs';\nimport * as cdktf from 'cdktf';\n\n// Configuration\n\nexport interface StringResourceConfig extends cdktf.TerraformMetaArguments {\n  /**\n  * Arbitrary map of values that, when changed, will trigger recreation of resource. See [the main provider documentation](../index.html) for more information.\n  *\n  * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/string#keepers StringResource#keepers}\n  */\n  readonly keepers?: { [key: string]: string };\n  /**\n  * The length of the string desired. The minimum value for length is 1 and, length must also be >= (`min_upper` + `min_lower` + `min_numeric` + `min_special`).\n  *\n  * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/string#length StringResource#length}\n  */\n  readonly length: number;\n  /**\n  * Include lowercase alphabet characters in the result. Default value is `true`.\n  *\n  * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/string#lower StringResource#lower}\n  */\n  readonly lower?: boolean | cdktf.IResolvable;\n  /**\n  * Minimum number of lowercase alphabet characters in the result. Default value is `0`.\n  *\n  * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/string#min_lower StringResource#min_lower}\n  */\n  readonly minLower?: number;\n  /**\n  * Minimum number of numeric characters in the result. Default value is `0`.\n  *\n  * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/string#min_numeric StringResource#min_numeric}\n  */\n  readonly minNumeric?: number;\n  /**\n  * Minimum number of special characters in the result. Default value is `0`.\n  *\n  * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/string#min_special StringResource#min_special}\n  */\n  readonly minSpecial?: number;\n  /**\n  * Minimum number of uppercase alphabet characters in the result. Default value is `0`.\n  *\n  * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/string#min_upper StringResource#min_upper}\n  */\n  readonly minUpper?: number;\n  /**\n  * Include numeric characters in the result. Default value is `true`. If `number`, `upper`, `lower`, and `special` are all configured, at least one of them must be set to `true`. **NOTE**: This is deprecated, use `numeric` instead.\n  *\n  * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/string#number StringResource#number}\n  */\n  readonly number?: boolean | cdktf.IResolvable;\n  /**\n  * Include numeric characters in the result. Default value is `true`. If `numeric`, `upper`, `lower`, and `special` are all configured, at least one of them must be set to `true`.\n  *\n  * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/string#numeric StringResource#numeric}\n  */\n  readonly numeric?: boolean | cdktf.IResolvable;\n  /**\n  * Supply your own list of special characters to use for string generation.  This overrides the default character list in the special argument.  The `special` argument must still be set to true for any overwritten characters to be used in generation.\n  *\n  * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/string#override_special StringResource#override_special}\n  */\n  readonly overrideSpecial?: string;\n  /**\n  * Include special characters in the result. These are `!@#$%&*()-_=+[]{}<>:?`. Default value is `true`.\n  *\n  * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/string#special StringResource#special}\n  */\n  readonly special?: boolean | cdktf.IResolvable;\n  /**\n  * Include uppercase alphabet characters in the result. Default value is `true`.\n  *\n  * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/string#upper StringResource#upper}\n  */\n  readonly upper?: boolean | cdktf.IResolvable;\n}\n\n/**\n* Represents a {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/string random_string}\n*/\nexport class StringResource extends cdktf.TerraformResource {\n\n  // =================\n  // STATIC PROPERTIES\n  // =================\n  public static readonly tfResourceType = \"random_string\";\n\n  // ==============\n  // STATIC Methods\n  // ==============\n  /**\n  * Generates CDKTF code for importing a StringResource resource upon running \"cdktf plan <stack-name>\"\n  * @param scope The scope in which to define this construct\n  * @param importToId The construct id used in the generated config for the StringResource to import\n  * @param importFromId The id of the existing StringResource that should be imported. Refer to the {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/string#import import section} in the documentation of this resource for the id to use\n  * @param provider? Optional instance of the provider where the StringResource to import is found\n  */\n  public static generateConfigForImport(scope: Construct, importToId: string, importFromId: string, provider?: cdktf.TerraformProvider) {\n        return new cdktf.ImportableResource(scope, importToId, { terraformResourceType: \"random_string\", importId: importFromId, provider });\n      }\n\n  // ===========\n  // INITIALIZER\n  // ===========\n\n  /**\n  * Create a new {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/string random_string} Resource\n  *\n  * @param scope The scope in which to define this construct\n  * @param id The scoped construct ID. Must be unique amongst siblings in the same scope\n  * @param options StringResourceConfig\n  */\n  public constructor(scope: Construct, id: string, config: StringResourceConfig) {\n    super(scope, id, {\n      terraformResourceType: 'random_string',\n      terraformGeneratorMetadata: {\n        providerName: 'random',\n        providerVersion: '3.7.2',\n        providerVersionConstraint: '~> 3.1'\n      },\n      provider: config.provider,\n      dependsOn: config.dependsOn,\n      count: config.count,\n      lifecycle: config.lifecycle,\n      provisioners: config.provisioners,\n      connection: config.connection,\n      forEach: config.forEach\n    });\n    this._keepers = config.keepers;\n    this._length = config.length;\n    this._lower = config.lower;\n    this._minLower = config.minLower;\n    this._minNumeric = config.minNumeric;\n    this._minSpecial = config.minSpecial;\n    this._minUpper = config.minUpper;\n    this._number = config.number;\n    this._numeric = config.numeric;\n    this._overrideSpecial = config.overrideSpecial;\n    this._special = config.special;\n    this._upper = config.upper;\n  }\n\n  // ==========\n  // ATTRIBUTES\n  // ==========\n\n  // id - computed: true, optional: false, required: false\n  public get id() {\n    return this.getStringAttribute('id');\n  }\n\n  // keepers - computed: false, optional: true, required: false\n  private _keepers?: { [key: string]: string }; \n  public get keepers() {\n    return this.getStringMapAttribute('keepers');\n  }\n  public set keepers(value: { [key: string]: string }) {\n    this._keepers = value;\n  }\n  public resetKeepers() {\n    this._keepers = undefined;\n  }\n  // Temporarily expose input value. Use with caution.\n  public get keepersInput() {\n    return this._keepers;\n  }\n\n  // length - computed: false, optional: false, required: true\n  private _length?: number; \n  public get length() {\n    return this.getNumberAttribute('length');\n  }\n  public set length(value: number) {\n    this._length = value;\n  }\n  // Temporarily expose input value. Use with caution.\n  public get lengthInput() {\n    return this._length;\n  }\n\n  // lower - computed: true, optional: true, required: false\n  private _lower?: boolean | cdktf.IResolvable; \n  public get lower() {\n    return this.getBooleanAttribute('lower');\n  }\n  public set lower(value: boolean | cdktf.IResolvable) {\n    this._lower = value;\n  }\n  public resetLower() {\n    this._lower = undefined;\n  }\n  // Temporarily expose input value. Use with caution.\n  public get lowerInput() {\n    return this._lower;\n  }\n\n  // min_lower - computed: true, optional: true, required: false\n  private _minLower?: number; \n  public get minLower() {\n    return this.getNumberAttribute('min_lower');\n  }\n  public set minLower(value: number) {\n    this._minLower = value;\n  }\n  public resetMinLower() {\n    this._minLower = undefined;\n  }\n  // Temporarily expose input value. Use with caution.\n  public get minLowerInput() {\n    return this._minLower;\n  }\n\n  // min_numeric - computed: true, optional: true, required: false\n  private _minNumeric?: number; \n  public get minNumeric() {\n    return this.getNumberAttribute('min_numeric');\n  }\n  public set minNumeric(value: number) {\n    this._minNumeric = value;\n  }\n  public resetMinNumeric() {\n    this._minNumeric = undefined;\n  }\n  // Temporarily expose input value. Use with caution.\n  public get minNumericInput() {\n    return this._minNumeric;\n  }\n\n  // min_special - computed: true, optional: true, required: false\n  private _minSpecial?: number; \n  public get minSpecial() {\n    return this.getNumberAttribute('min_special');\n  }\n  public set minSpecial(value: number) {\n    this._minSpecial = value;\n  }\n  public resetMinSpecial() {\n    this._minSpecial = undefined;\n  }\n  // Temporarily expose input value. Use with caution.\n  public get minSpecialInput() {\n    return this._minSpecial;\n  }\n\n  // min_upper - computed: true, optional: true, required: false\n  private _minUpper?: number; \n  public get minUpper() {\n    return this.getNumberAttribute('min_upper');\n  }\n  public set minUpper(value: number) {\n    this._minUpper = value;\n  }\n  public resetMinUpper() {\n    this._minUpper = undefined;\n  }\n  // Temporarily expose input value. Use with caution.\n  public get minUpperInput() {\n    return this._minUpper;\n  }\n\n  // number - computed: true, optional: true, required: false\n  private _number?: boolean | cdktf.IResolvable; \n  public get number() {\n    return this.getBooleanAttribute('number');\n  }\n  public set number(value: boolean | cdktf.IResolvable) {\n    this._number = value;\n  }\n  public resetNumber() {\n    this._number = undefined;\n  }\n  // Temporarily expose input value. Use with caution.\n  public get numberInput() {\n    return this._number;\n  }\n\n  // numeric - computed: true, optional: true, required: false\n  private _numeric?: boolean | cdktf.IResolvable; \n  public get numeric() {\n    return this.getBooleanAttribute('numeric');\n  }\n  public set numeric(value: boolean | cdktf.IResolvable) {\n    this._numeric = value;\n  }\n  public resetNumeric() {\n    this._numeric = undefined;\n  }\n  // Temporarily expose input value. Use with caution.\n  public get numericInput() {\n    return this._numeric;\n  }\n\n  // override_special - computed: false, optional: true, required: false\n  private _overrideSpecial?: string; \n  public get overrideSpecial() {\n    return this.getStringAttribute('override_special');\n  }\n  public set overrideSpecial(value: string) {\n    this._overrideSpecial = value;\n  }\n  public resetOverrideSpecial() {\n    this._overrideSpecial = undefined;\n  }\n  // Temporarily expose input value. Use with caution.\n  public get overrideSpecialInput() {\n    return this._overrideSpecial;\n  }\n\n  // result - computed: true, optional: false, required: false\n  public get result() {\n    return this.getStringAttribute('result');\n  }\n\n  // special - computed: true, optional: true, required: false\n  private _special?: boolean | cdktf.IResolvable; \n  public get special() {\n    return this.getBooleanAttribute('special');\n  }\n  public set special(value: boolean | cdktf.IResolvable) {\n    this._special = value;\n  }\n  public resetSpecial() {\n    this._special = undefined;\n  }\n  // Temporarily expose input value. Use with caution.\n  public get specialInput() {\n    return this._special;\n  }\n\n  // upper - computed: true, optional: true, required: false\n  private _upper?: boolean | cdktf.IResolvable; \n  public get upper() {\n    return this.getBooleanAttribute('upper');\n  }\n  public set upper(value: boolean | cdktf.IResolvable) {\n    this._upper = value;\n  }\n  public resetUpper() {\n    this._upper = undefined;\n  }\n  // Temporarily expose input value. Use with caution.\n  public get upperInput() {\n    return this._upper;\n  }\n\n  // =========\n  // SYNTHESIS\n  // =========\n\n  protected synthesizeAttributes(): { [name: string]: any } {\n    return {\n      keepers: cdktf.hashMapper(cdktf.stringToTerraform)(this._keepers),\n      length: cdktf.numberToTerraform(this._length),\n      lower: cdktf.booleanToTerraform(this._lower),\n      min_lower: cdktf.numberToTerraform(this._minLower),\n      min_numeric: cdktf.numberToTerraform(this._minNumeric),\n      min_special: cdktf.numberToTerraform(this._minSpecial),\n      min_upper: cdktf.numberToTerraform(this._minUpper),\n      number: cdktf.booleanToTerraform(this._number),\n      numeric: cdktf.booleanToTerraform(this._numeric),\n      override_special: cdktf.stringToTerraform(this._overrideSpecial),\n      special: cdktf.booleanToTerraform(this._special),\n      upper: cdktf.booleanToTerraform(this._upper),\n    };\n  }\n\n  protected synthesizeHclAttributes(): { [name: string]: any } {\n    const attrs = {\n      keepers: {\n        value: cdktf.hashMapperHcl(cdktf.stringToHclTerraform)(this._keepers),\n        isBlock: false,\n        type: \"map\",\n        storageClassType: \"stringMap\",\n      },\n      length: {\n        value: cdktf.numberToHclTerraform(this._length),\n        isBlock: false,\n        type: \"simple\",\n        storageClassType: \"number\",\n      },\n      lower: {\n        value: cdktf.booleanToHclTerraform(this._lower),\n        isBlock: false,\n        type: \"simple\",\n        storageClassType: \"boolean\",\n      },\n      min_lower: {\n        value: cdktf.numberToHclTerraform(this._minLower),\n        isBlock: false,\n        type: \"simple\",\n        storageClassType: \"number\",\n      },\n      min_numeric: {\n        value: cdktf.numberToHclTerraform(this._minNumeric),\n        isBlock: false,\n        type: \"simple\",\n        storageClassType: \"number\",\n      },\n      min_special: {\n        value: cdktf.numberToHclTerraform(this._minSpecial),\n        isBlock: false,\n        type: \"simple\",\n        storageClassType: \"number\",\n      },\n      min_upper: {\n        value: cdktf.numberToHclTerraform(this._minUpper),\n        isBlock: false,\n        type: \"simple\",\n        storageClassType: \"number\",\n      },\n      number: {\n        value: cdktf.booleanToHclTerraform(this._number),\n        isBlock: false,\n        type: \"simple\",\n        storageClassType: \"boolean\",\n      },\n      numeric: {\n        value: cdktf.booleanToHclTerraform(this._numeric),\n        isBlock: false,\n        type: \"simple\",\n        storageClassType: \"boolean\",\n      },\n      override_special: {\n        value: cdktf.stringToHclTerraform(this._overrideSpecial),\n        isBlock: false,\n        type: \"simple\",\n        storageClassType: \"string\",\n      },\n      special: {\n        value: cdktf.booleanToHclTerraform(this._special),\n        isBlock: false,\n        type: \"simple\",\n        storageClassType: \"boolean\",\n      },\n      upper: {\n        value: cdktf.booleanToHclTerraform(this._upper),\n        isBlock: false,\n        type: \"simple\",\n        storageClassType: \"boolean\",\n      },\n    };\n\n    // remove undefined attributes\n    return Object.fromEntries(Object.entries(attrs).filter(([_, value]) => value !== undefined && value.value !== undefined ))\n  }\n}\n"]}

package/lib/uuid/index.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+import { Construct } from 'constructs';
+import * as cdktf from 'cdktf';
+export interface UuidConfig extends cdktf.TerraformMetaArguments {
+    /**
+    * Arbitrary map of values that, when changed, will trigger recreation of resource. See [the main provider documentation](../index.html) for more information.
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/uuid#keepers Uuid#keepers}
+    */
+    readonly keepers?: {
+        [key: string]: string;
+    };
+}
+/**
+* Represents a {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/uuid random_uuid}
+*/
+export declare class Uuid extends cdktf.TerraformResource {
+    static readonly tfResourceType = "random_uuid";
+    /**
+    * Generates CDKTF code for importing a Uuid resource upon running "cdktf plan <stack-name>"
+    * @param scope The scope in which to define this construct
+    * @param importToId The construct id used in the generated config for the Uuid to import
+    * @param importFromId The id of the existing Uuid that should be imported. Refer to the {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/uuid#import import section} in the documentation of this resource for the id to use
+    * @param provider? Optional instance of the provider where the Uuid to import is found
+    */
+    static generateConfigForImport(scope: Construct, importToId: string, importFromId: string, provider?: cdktf.TerraformProvider): cdktf.ImportableResource;
+    /**
+    * Create a new {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/uuid random_uuid} Resource
+    *
+    * @param scope The scope in which to define this construct
+    * @param id The scoped construct ID. Must be unique amongst siblings in the same scope
+    * @param options UuidConfig = {}
+    */
+    constructor(scope: Construct, id: string, config?: UuidConfig);
+    get id(): string;
+    private _keepers?;
+    get keepers(): {
+        [key: string]: string;
+    };
+    set keepers(value: {
+        [key: string]: string;
+    });
+    resetKeepers(): void;
+    get keepersInput(): {
+        [key: string]: string;
+    } | undefined;
+    get result(): string;
+    protected synthesizeAttributes(): {
+        [name: string]: any;
+    };
+    protected synthesizeHclAttributes(): {
+        [name: string]: any;
+    };
+}