@cdktn/provider-random 12.1.0

package/lib/pet/index.js

@@ -0,0 +1,163 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pet = 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/pet random_pet}
+*/
+class Pet extends cdktf.TerraformResource {
+    // ==============
+    // STATIC Methods
+    // ==============
+    /**
+    * Generates CDKTF code for importing a Pet 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 Pet to import
+    * @param importFromId The id of the existing Pet that should be imported. Refer to the {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/pet#import import section} in the documentation of this resource for the id to use
+    * @param provider? Optional instance of the provider where the Pet to import is found
+    */
+    static generateConfigForImport(scope, importToId, importFromId, provider) {
+        return new cdktf.ImportableResource(scope, importToId, { terraformResourceType: "random_pet", importId: importFromId, provider });
+    }
+    // ===========
+    // INITIALIZER
+    // ===========
+    /**
+    * Create a new {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/pet random_pet} 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 PetConfig = {}
+    */
+    constructor(scope, id, config = {}) {
+        super(scope, id, {
+            terraformResourceType: 'random_pet',
+            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._prefix = config.prefix;
+        this._separator = config.separator;
+    }
+    // ==========
+    // 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;
+    }
+    resetLength() {
+        this._length = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get lengthInput() {
+        return this._length;
+    }
+    get prefix() {
+        return this.getStringAttribute('prefix');
+    }
+    set prefix(value) {
+        this._prefix = value;
+    }
+    resetPrefix() {
+        this._prefix = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get prefixInput() {
+        return this._prefix;
+    }
+    get separator() {
+        return this.getStringAttribute('separator');
+    }
+    set separator(value) {
+        this._separator = value;
+    }
+    resetSeparator() {
+        this._separator = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get separatorInput() {
+        return this._separator;
+    }
+    // =========
+    // SYNTHESIS
+    // =========
+    synthesizeAttributes() {
+        return {
+            keepers: cdktf.hashMapper(cdktf.stringToTerraform)(this._keepers),
+            length: cdktf.numberToTerraform(this._length),
+            prefix: cdktf.stringToTerraform(this._prefix),
+            separator: cdktf.stringToTerraform(this._separator),
+        };
+    }
+    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",
+            },
+            prefix: {
+                value: cdktf.stringToHclTerraform(this._prefix),
+                isBlock: false,
+                type: "simple",
+                storageClassType: "string",
+            },
+            separator: {
+                value: cdktf.stringToHclTerraform(this._separator),
+                isBlock: false,
+                type: "simple",
+                storageClassType: "string",
+            },
+        };
+        // remove undefined attributes
+        return Object.fromEntries(Object.entries(attrs).filter(([_, value]) => value !== undefined && value.value !== undefined));
+    }
+}
+exports.Pet = Pet;
+_a = JSII_RTTI_SYMBOL_1;
+Pet[_a] = { fqn: "@cdktn/provider-random.pet.Pet", version: "12.1.0" };
+// =================
+// STATIC PROPERTIES
+// =================
+Pet.tfResourceType = "random_pet";
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/pet/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/pet\n// generated from terraform resource schema\n\nimport { Construct } from 'constructs';\nimport * as cdktf from 'cdktf';\n\n// Configuration\n\nexport interface PetConfig 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/pet#keepers Pet#keepers}\n  */\n  readonly keepers?: { [key: string]: string };\n  /**\n  * The length (in words) of the pet name. Defaults to 2\n  *\n  * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/pet#length Pet#length}\n  */\n  readonly length?: number;\n  /**\n  * A string to prefix the name with.\n  *\n  * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/pet#prefix Pet#prefix}\n  */\n  readonly prefix?: string;\n  /**\n  * The character to separate words in the pet name. Defaults to \"-\"\n  *\n  * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/pet#separator Pet#separator}\n  */\n  readonly separator?: string;\n}\n\n/**\n* Represents a {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/pet random_pet}\n*/\nexport class Pet extends cdktf.TerraformResource {\n\n  // =================\n  // STATIC PROPERTIES\n  // =================\n  public static readonly tfResourceType = \"random_pet\";\n\n  // ==============\n  // STATIC Methods\n  // ==============\n  /**\n  * Generates CDKTF code for importing a Pet 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 Pet to import\n  * @param importFromId The id of the existing Pet that should be imported. Refer to the {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/pet#import import section} in the documentation of this resource for the id to use\n  * @param provider? Optional instance of the provider where the Pet 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_pet\", 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/pet random_pet} 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 PetConfig = {}\n  */\n  public constructor(scope: Construct, id: string, config: PetConfig = {}) {\n    super(scope, id, {\n      terraformResourceType: 'random_pet',\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._prefix = config.prefix;\n    this._separator = config.separator;\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: true, optional: true, required: false\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  public resetLength() {\n    this._length = undefined;\n  }\n  // Temporarily expose input value. Use with caution.\n  public get lengthInput() {\n    return this._length;\n  }\n\n  // prefix - computed: false, optional: true, required: false\n  private _prefix?: string; \n  public get prefix() {\n    return this.getStringAttribute('prefix');\n  }\n  public set prefix(value: string) {\n    this._prefix = value;\n  }\n  public resetPrefix() {\n    this._prefix = undefined;\n  }\n  // Temporarily expose input value. Use with caution.\n  public get prefixInput() {\n    return this._prefix;\n  }\n\n  // separator - computed: true, optional: true, required: false\n  private _separator?: string; \n  public get separator() {\n    return this.getStringAttribute('separator');\n  }\n  public set separator(value: string) {\n    this._separator = value;\n  }\n  public resetSeparator() {\n    this._separator = undefined;\n  }\n  // Temporarily expose input value. Use with caution.\n  public get separatorInput() {\n    return this._separator;\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      prefix: cdktf.stringToTerraform(this._prefix),\n      separator: cdktf.stringToTerraform(this._separator),\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      prefix: {\n        value: cdktf.stringToHclTerraform(this._prefix),\n        isBlock: false,\n        type: \"simple\",\n        storageClassType: \"string\",\n      },\n      separator: {\n        value: cdktf.stringToHclTerraform(this._separator),\n        isBlock: false,\n        type: \"simple\",\n        storageClassType: \"string\",\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/provider/index.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+import { Construct } from 'constructs';
+import * as cdktf from 'cdktf';
+export interface RandomProviderConfig {
+    /**
+    * Alias name
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs#alias RandomProvider#alias}
+    */
+    readonly alias?: string;
+}
+/**
+* Represents a {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs random}
+*/
+export declare class RandomProvider extends cdktf.TerraformProvider {
+    static readonly tfResourceType = "random";
+    /**
+    * Generates CDKTF code for importing a RandomProvider 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 RandomProvider to import
+    * @param importFromId The id of the existing RandomProvider that should be imported. Refer to the {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs#import import section} in the documentation of this resource for the id to use
+    * @param provider? Optional instance of the provider where the RandomProvider 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 random} 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 RandomProviderConfig = {}
+    */
+    constructor(scope: Construct, id: string, config?: RandomProviderConfig);
+    private _alias?;
+    get alias(): string | undefined;
+    set alias(value: string | undefined);
+    resetAlias(): void;
+    get aliasInput(): string | undefined;
+    protected synthesizeAttributes(): {
+        [name: string]: any;
+    };
+    protected synthesizeHclAttributes(): {
+        [name: string]: any;
+    };
+}

package/lib/provider/index.js

@@ -0,0 +1,87 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RandomProvider = 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 random}
+*/
+class RandomProvider extends cdktf.TerraformProvider {
+    // ==============
+    // STATIC Methods
+    // ==============
+    /**
+    * Generates CDKTF code for importing a RandomProvider 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 RandomProvider to import
+    * @param importFromId The id of the existing RandomProvider that should be imported. Refer to the {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs#import import section} in the documentation of this resource for the id to use
+    * @param provider? Optional instance of the provider where the RandomProvider to import is found
+    */
+    static generateConfigForImport(scope, importToId, importFromId, provider) {
+        return new cdktf.ImportableResource(scope, importToId, { terraformResourceType: "random", importId: importFromId, provider });
+    }
+    // ===========
+    // INITIALIZER
+    // ===========
+    /**
+    * Create a new {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs random} 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 RandomProviderConfig = {}
+    */
+    constructor(scope, id, config = {}) {
+        super(scope, id, {
+            terraformResourceType: 'random',
+            terraformGeneratorMetadata: {
+                providerName: 'random',
+                providerVersion: '3.7.2',
+                providerVersionConstraint: '~> 3.1'
+            },
+            terraformProviderSource: 'hashicorp/random'
+        });
+        this._alias = config.alias;
+    }
+    get alias() {
+        return this._alias;
+    }
+    set alias(value) {
+        this._alias = value;
+    }
+    resetAlias() {
+        this._alias = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get aliasInput() {
+        return this._alias;
+    }
+    // =========
+    // SYNTHESIS
+    // =========
+    synthesizeAttributes() {
+        return {
+            alias: cdktf.stringToTerraform(this._alias),
+        };
+    }
+    synthesizeHclAttributes() {
+        const attrs = {
+            alias: {
+                value: cdktf.stringToHclTerraform(this._alias),
+                isBlock: false,
+                type: "simple",
+                storageClassType: "string",
+            },
+        };
+        // remove undefined attributes
+        return Object.fromEntries(Object.entries(attrs).filter(([_, value]) => value !== undefined && value.value !== undefined));
+    }
+}
+exports.RandomProvider = RandomProvider;
+_a = JSII_RTTI_SYMBOL_1;
+RandomProvider[_a] = { fqn: "@cdktn/provider-random.provider.RandomProvider", version: "12.1.0" };
+// =================
+// STATIC PROPERTIES
+// =================
+RandomProvider.tfResourceType = "random";
+//# sourceMappingURL=data:application/json;base64,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

package/lib/shuffle/index.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+import { Construct } from 'constructs';
+import * as cdktf from 'cdktf';
+export interface ShuffleConfig extends cdktf.TerraformMetaArguments {
+    /**
+    * The list of strings to shuffle.
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/shuffle#input Shuffle#input}
+    */
+    readonly input: string[];
+    /**
+    * 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/shuffle#keepers Shuffle#keepers}
+    */
+    readonly keepers?: {
+        [key: string]: string;
+    };
+    /**
+    * The number of results to return. Defaults to the number of items in the `input` list. If fewer items are requested, some elements will be excluded from the result. If more items are requested, items will be repeated in the result but not more frequently than the number of items in the input list.
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/shuffle#result_count Shuffle#result_count}
+    */
+    readonly resultCount?: number;
+    /**
+    * Arbitrary string with which to seed the random number generator, in order to produce less-volatile permutations of the list.
+    *
+    * **Important:** Even with an identical seed, it is not guaranteed that the same permutation will be produced across different versions of Terraform. This argument causes the result to be *less volatile*, but not fixed for all time.
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/shuffle#seed Shuffle#seed}
+    */
+    readonly seed?: string;
+}
+/**
+* Represents a {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/shuffle random_shuffle}
+*/
+export declare class Shuffle extends cdktf.TerraformResource {
+    static readonly tfResourceType = "random_shuffle";
+    /**
+    * Generates CDKTF code for importing a Shuffle 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 Shuffle to import
+    * @param importFromId The id of the existing Shuffle that should be imported. Refer to the {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/shuffle#import import section} in the documentation of this resource for the id to use
+    * @param provider? Optional instance of the provider where the Shuffle 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/shuffle random_shuffle} 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 ShuffleConfig
+    */
+    constructor(scope: Construct, id: string, config: ShuffleConfig);
+    get id(): string;
+    private _input?;
+    get input(): string[];
+    set input(value: string[]);
+    get inputInput(): string[] | undefined;
+    private _keepers?;
+    get keepers(): {
+        [key: string]: string;
+    };
+    set keepers(value: {
+        [key: string]: string;
+    });
+    resetKeepers(): void;
+    get keepersInput(): {
+        [key: string]: string;
+    } | undefined;
+    get result(): string[];
+    private _resultCount?;
+    get resultCount(): number;
+    set resultCount(value: number);
+    resetResultCount(): void;
+    get resultCountInput(): number | undefined;
+    private _seed?;
+    get seed(): string;
+    set seed(value: string);
+    resetSeed(): void;
+    get seedInput(): string | undefined;
+    protected synthesizeAttributes(): {
+        [name: string]: any;
+    };
+    protected synthesizeHclAttributes(): {
+        [name: string]: any;
+    };
+}

package/lib/shuffle/index.js

@@ -0,0 +1,164 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Shuffle = 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/shuffle random_shuffle}
+*/
+class Shuffle extends cdktf.TerraformResource {
+    // ==============
+    // STATIC Methods
+    // ==============
+    /**
+    * Generates CDKTF code for importing a Shuffle 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 Shuffle to import
+    * @param importFromId The id of the existing Shuffle that should be imported. Refer to the {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/shuffle#import import section} in the documentation of this resource for the id to use
+    * @param provider? Optional instance of the provider where the Shuffle to import is found
+    */
+    static generateConfigForImport(scope, importToId, importFromId, provider) {
+        return new cdktf.ImportableResource(scope, importToId, { terraformResourceType: "random_shuffle", importId: importFromId, provider });
+    }
+    // ===========
+    // INITIALIZER
+    // ===========
+    /**
+    * Create a new {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/shuffle random_shuffle} 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 ShuffleConfig
+    */
+    constructor(scope, id, config) {
+        super(scope, id, {
+            terraformResourceType: 'random_shuffle',
+            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._input = config.input;
+        this._keepers = config.keepers;
+        this._resultCount = config.resultCount;
+        this._seed = config.seed;
+    }
+    // ==========
+    // ATTRIBUTES
+    // ==========
+    // id - computed: true, optional: false, required: false
+    get id() {
+        return this.getStringAttribute('id');
+    }
+    get input() {
+        return this.getListAttribute('input');
+    }
+    set input(value) {
+        this._input = value;
+    }
+    // Temporarily expose input value. Use with caution.
+    get inputInput() {
+        return this._input;
+    }
+    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;
+    }
+    // result - computed: true, optional: false, required: false
+    get result() {
+        return this.getListAttribute('result');
+    }
+    get resultCount() {
+        return this.getNumberAttribute('result_count');
+    }
+    set resultCount(value) {
+        this._resultCount = value;
+    }
+    resetResultCount() {
+        this._resultCount = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get resultCountInput() {
+        return this._resultCount;
+    }
+    get seed() {
+        return this.getStringAttribute('seed');
+    }
+    set seed(value) {
+        this._seed = value;
+    }
+    resetSeed() {
+        this._seed = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get seedInput() {
+        return this._seed;
+    }
+    // =========
+    // SYNTHESIS
+    // =========
+    synthesizeAttributes() {
+        return {
+            input: cdktf.listMapper(cdktf.stringToTerraform, false)(this._input),
+            keepers: cdktf.hashMapper(cdktf.stringToTerraform)(this._keepers),
+            result_count: cdktf.numberToTerraform(this._resultCount),
+            seed: cdktf.stringToTerraform(this._seed),
+        };
+    }
+    synthesizeHclAttributes() {
+        const attrs = {
+            input: {
+                value: cdktf.listMapperHcl(cdktf.stringToHclTerraform, false)(this._input),
+                isBlock: false,
+                type: "list",
+                storageClassType: "stringList",
+            },
+            keepers: {
+                value: cdktf.hashMapperHcl(cdktf.stringToHclTerraform)(this._keepers),
+                isBlock: false,
+                type: "map",
+                storageClassType: "stringMap",
+            },
+            result_count: {
+                value: cdktf.numberToHclTerraform(this._resultCount),
+                isBlock: false,
+                type: "simple",
+                storageClassType: "number",
+            },
+            seed: {
+                value: cdktf.stringToHclTerraform(this._seed),
+                isBlock: false,
+                type: "simple",
+                storageClassType: "string",
+            },
+        };
+        // remove undefined attributes
+        return Object.fromEntries(Object.entries(attrs).filter(([_, value]) => value !== undefined && value.value !== undefined));
+    }
+}
+exports.Shuffle = Shuffle;
+_a = JSII_RTTI_SYMBOL_1;
+Shuffle[_a] = { fqn: "@cdktn/provider-random.shuffle.Shuffle", version: "12.1.0" };
+// =================
+// STATIC PROPERTIES
+// =================
+Shuffle.tfResourceType = "random_shuffle";
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/shuffle/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/shuffle\n// generated from terraform resource schema\n\nimport { Construct } from 'constructs';\nimport * as cdktf from 'cdktf';\n\n// Configuration\n\nexport interface ShuffleConfig extends cdktf.TerraformMetaArguments {\n  /**\n  * The list of strings to shuffle.\n  *\n  * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/shuffle#input Shuffle#input}\n  */\n  readonly input: string[];\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/shuffle#keepers Shuffle#keepers}\n  */\n  readonly keepers?: { [key: string]: string };\n  /**\n  * The number of results to return. Defaults to the number of items in the `input` list. If fewer items are requested, some elements will be excluded from the result. If more items are requested, items will be repeated in the result but not more frequently than the number of items in the input list.\n  *\n  * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/shuffle#result_count Shuffle#result_count}\n  */\n  readonly resultCount?: number;\n  /**\n  * Arbitrary string with which to seed the random number generator, in order to produce less-volatile permutations of the list.\n  * \n  * **Important:** Even with an identical seed, it is not guaranteed that the same permutation will be produced across different versions of Terraform. This argument causes the result to be *less volatile*, but not fixed for all time.\n  *\n  * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/shuffle#seed Shuffle#seed}\n  */\n  readonly seed?: string;\n}\n\n/**\n* Represents a {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/shuffle random_shuffle}\n*/\nexport class Shuffle extends cdktf.TerraformResource {\n\n  // =================\n  // STATIC PROPERTIES\n  // =================\n  public static readonly tfResourceType = \"random_shuffle\";\n\n  // ==============\n  // STATIC Methods\n  // ==============\n  /**\n  * Generates CDKTF code for importing a Shuffle 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 Shuffle to import\n  * @param importFromId The id of the existing Shuffle that should be imported. Refer to the {@link https://registry.terraform.io/providers/hashicorp/random/3.7.2/docs/resources/shuffle#import import section} in the documentation of this resource for the id to use\n  * @param provider? Optional instance of the provider where the Shuffle 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_shuffle\", 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/shuffle random_shuffle} 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 ShuffleConfig\n  */\n  public constructor(scope: Construct, id: string, config: ShuffleConfig) {\n    super(scope, id, {\n      terraformResourceType: 'random_shuffle',\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._input = config.input;\n    this._keepers = config.keepers;\n    this._resultCount = config.resultCount;\n    this._seed = config.seed;\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  // input - computed: false, optional: false, required: true\n  private _input?: string[]; \n  public get input() {\n    return this.getListAttribute('input');\n  }\n  public set input(value: string[]) {\n    this._input = value;\n  }\n  // Temporarily expose input value. Use with caution.\n  public get inputInput() {\n    return this._input;\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  // result - computed: true, optional: false, required: false\n  public get result() {\n    return this.getListAttribute('result');\n  }\n\n  // result_count - computed: false, optional: true, required: false\n  private _resultCount?: number; \n  public get resultCount() {\n    return this.getNumberAttribute('result_count');\n  }\n  public set resultCount(value: number) {\n    this._resultCount = value;\n  }\n  public resetResultCount() {\n    this._resultCount = undefined;\n  }\n  // Temporarily expose input value. Use with caution.\n  public get resultCountInput() {\n    return this._resultCount;\n  }\n\n  // seed - computed: false, optional: true, required: false\n  private _seed?: string; \n  public get seed() {\n    return this.getStringAttribute('seed');\n  }\n  public set seed(value: string) {\n    this._seed = value;\n  }\n  public resetSeed() {\n    this._seed = undefined;\n  }\n  // Temporarily expose input value. Use with caution.\n  public get seedInput() {\n    return this._seed;\n  }\n\n  // =========\n  // SYNTHESIS\n  // =========\n\n  protected synthesizeAttributes(): { [name: string]: any } {\n    return {\n      input: cdktf.listMapper(cdktf.stringToTerraform, false)(this._input),\n      keepers: cdktf.hashMapper(cdktf.stringToTerraform)(this._keepers),\n      result_count: cdktf.numberToTerraform(this._resultCount),\n      seed: cdktf.stringToTerraform(this._seed),\n    };\n  }\n\n  protected synthesizeHclAttributes(): { [name: string]: any } {\n    const attrs = {\n      input: {\n        value: cdktf.listMapperHcl(cdktf.stringToHclTerraform, false)(this._input),\n        isBlock: false,\n        type: \"list\",\n        storageClassType: \"stringList\",\n      },\n      keepers: {\n        value: cdktf.hashMapperHcl(cdktf.stringToHclTerraform)(this._keepers),\n        isBlock: false,\n        type: \"map\",\n        storageClassType: \"stringMap\",\n      },\n      result_count: {\n        value: cdktf.numberToHclTerraform(this._resultCount),\n        isBlock: false,\n        type: \"simple\",\n        storageClassType: \"number\",\n      },\n      seed: {\n        value: cdktf.stringToHclTerraform(this._seed),\n        isBlock: false,\n        type: \"simple\",\n        storageClassType: \"string\",\n      },\n    };\n\n    // remove undefined attributes\n    return Object.fromEntries(Object.entries(attrs).filter(([_, value]) => value !== undefined && value.value !== undefined ))\n  }\n}\n"]}