@cdktn/provider-docker 12.1.0

package/lib/provider/index.d.ts

@@ -0,0 +1,186 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+import { Construct } from 'constructs';
+import * as cdktf from 'cdktf';
+export interface DockerProviderConfig {
+    /**
+    * PEM-encoded content of Docker host CA certificate
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/kreuzwerker/docker/3.6.2/docs#ca_material DockerProvider#ca_material}
+    */
+    readonly caMaterial?: string;
+    /**
+    * PEM-encoded content of Docker client certificate
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/kreuzwerker/docker/3.6.2/docs#cert_material DockerProvider#cert_material}
+    */
+    readonly certMaterial?: string;
+    /**
+    * Path to directory with Docker TLS config
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/kreuzwerker/docker/3.6.2/docs#cert_path DockerProvider#cert_path}
+    */
+    readonly certPath?: string;
+    /**
+    * The name of the Docker context to use. Can also be set via `DOCKER_CONTEXT` environment variable. Overrides the `host` if set.
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/kreuzwerker/docker/3.6.2/docs#context DockerProvider#context}
+    */
+    readonly context?: string;
+    /**
+    * If set to `true`, the provider will not check if the Docker daemon is running. This is useful for resources/data_sourcess that do not require a running Docker daemon, such as the data source `docker_registry_image`.
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/kreuzwerker/docker/3.6.2/docs#disable_docker_daemon_check DockerProvider#disable_docker_daemon_check}
+    */
+    readonly disableDockerDaemonCheck?: boolean | cdktf.IResolvable;
+    /**
+    * The Docker daemon address
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/kreuzwerker/docker/3.6.2/docs#host DockerProvider#host}
+    */
+    readonly host?: string;
+    /**
+    * PEM-encoded content of Docker client private key
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/kreuzwerker/docker/3.6.2/docs#key_material DockerProvider#key_material}
+    */
+    readonly keyMaterial?: string;
+    /**
+    * Additional SSH option flags to be appended when using `ssh://` protocol
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/kreuzwerker/docker/3.6.2/docs#ssh_opts DockerProvider#ssh_opts}
+    */
+    readonly sshOpts?: string[];
+    /**
+    * Alias name
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/kreuzwerker/docker/3.6.2/docs#alias DockerProvider#alias}
+    */
+    readonly alias?: string;
+    /**
+    * registry_auth block
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/kreuzwerker/docker/3.6.2/docs#registry_auth DockerProvider#registry_auth}
+    */
+    readonly registryAuth?: DockerProviderRegistryAuth[] | cdktf.IResolvable;
+}
+export interface DockerProviderRegistryAuth {
+    /**
+    * Address of the registry
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/kreuzwerker/docker/3.6.2/docs#address DockerProvider#address}
+    */
+    readonly address: string;
+    /**
+    * Setting this to `true` will tell the provider that this registry does not need authentication. Due to the docker internals, the provider will use dummy credentials (see https://github.com/kreuzwerker/terraform-provider-docker/issues/470 for more information). Defaults to `false`.
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/kreuzwerker/docker/3.6.2/docs#auth_disabled DockerProvider#auth_disabled}
+    */
+    readonly authDisabled?: boolean | cdktf.IResolvable;
+    /**
+    * Path to docker json file for registry auth. Defaults to `~/.docker/config.json`. If `DOCKER_CONFIG` is set, the value of `DOCKER_CONFIG` is used as the path. `config_file` has predencen over all other options.
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/kreuzwerker/docker/3.6.2/docs#config_file DockerProvider#config_file}
+    */
+    readonly configFile?: string;
+    /**
+    * Plain content of the docker json file for registry auth. `config_file_content` has precedence over username/password.
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/kreuzwerker/docker/3.6.2/docs#config_file_content DockerProvider#config_file_content}
+    */
+    readonly configFileContent?: string;
+    /**
+    * Password for the registry. Defaults to `DOCKER_REGISTRY_PASS` env variable if set.
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/kreuzwerker/docker/3.6.2/docs#password DockerProvider#password}
+    */
+    readonly password?: string;
+    /**
+    * Username for the registry. Defaults to `DOCKER_REGISTRY_USER` env variable if set.
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/kreuzwerker/docker/3.6.2/docs#username DockerProvider#username}
+    */
+    readonly username?: string;
+}
+export declare function dockerProviderRegistryAuthToTerraform(struct?: DockerProviderRegistryAuth | cdktf.IResolvable): any;
+export declare function dockerProviderRegistryAuthToHclTerraform(struct?: DockerProviderRegistryAuth | cdktf.IResolvable): any;
+/**
+* Represents a {@link https://registry.terraform.io/providers/kreuzwerker/docker/3.6.2/docs docker}
+*/
+export declare class DockerProvider extends cdktf.TerraformProvider {
+    static readonly tfResourceType = "docker";
+    /**
+    * Generates CDKTF code for importing a DockerProvider 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 DockerProvider to import
+    * @param importFromId The id of the existing DockerProvider that should be imported. Refer to the {@link https://registry.terraform.io/providers/kreuzwerker/docker/3.6.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 DockerProvider 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/kreuzwerker/docker/3.6.2/docs docker} 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 DockerProviderConfig = {}
+    */
+    constructor(scope: Construct, id: string, config?: DockerProviderConfig);
+    private _caMaterial?;
+    get caMaterial(): string | undefined;
+    set caMaterial(value: string | undefined);
+    resetCaMaterial(): void;
+    get caMaterialInput(): string | undefined;
+    private _certMaterial?;
+    get certMaterial(): string | undefined;
+    set certMaterial(value: string | undefined);
+    resetCertMaterial(): void;
+    get certMaterialInput(): string | undefined;
+    private _certPath?;
+    get certPath(): string | undefined;
+    set certPath(value: string | undefined);
+    resetCertPath(): void;
+    get certPathInput(): string | undefined;
+    private _context?;
+    get context(): string | undefined;
+    set context(value: string | undefined);
+    resetContext(): void;
+    get contextInput(): string | undefined;
+    private _disableDockerDaemonCheck?;
+    get disableDockerDaemonCheck(): boolean | cdktf.IResolvable | undefined;
+    set disableDockerDaemonCheck(value: boolean | cdktf.IResolvable | undefined);
+    resetDisableDockerDaemonCheck(): void;
+    get disableDockerDaemonCheckInput(): boolean | cdktf.IResolvable | undefined;
+    private _host?;
+    get host(): string | undefined;
+    set host(value: string | undefined);
+    resetHost(): void;
+    get hostInput(): string | undefined;
+    private _keyMaterial?;
+    get keyMaterial(): string | undefined;
+    set keyMaterial(value: string | undefined);
+    resetKeyMaterial(): void;
+    get keyMaterialInput(): string | undefined;
+    private _sshOpts?;
+    get sshOpts(): string[] | undefined;
+    set sshOpts(value: string[] | undefined);
+    resetSshOpts(): void;
+    get sshOptsInput(): string[] | undefined;
+    private _alias?;
+    get alias(): string | undefined;
+    set alias(value: string | undefined);
+    resetAlias(): void;
+    get aliasInput(): string | undefined;
+    private _registryAuth?;
+    get registryAuth(): DockerProviderRegistryAuth[] | cdktf.IResolvable | undefined;
+    set registryAuth(value: DockerProviderRegistryAuth[] | cdktf.IResolvable | undefined);
+    resetRegistryAuth(): void;
+    get registryAuthInput(): cdktf.IResolvable | DockerProviderRegistryAuth[] | undefined;
+    protected synthesizeAttributes(): {
+        [name: string]: any;
+    };
+    protected synthesizeHclAttributes(): {
+        [name: string]: any;
+    };
+}

package/lib/provider/index.js

@@ -0,0 +1,342 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DockerProvider = void 0;
+exports.dockerProviderRegistryAuthToTerraform = dockerProviderRegistryAuthToTerraform;
+exports.dockerProviderRegistryAuthToHclTerraform = dockerProviderRegistryAuthToHclTerraform;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const cdktf = require("cdktf");
+function dockerProviderRegistryAuthToTerraform(struct) {
+    if (!cdktf.canInspect(struct) || cdktf.Tokenization.isResolvable(struct)) {
+        return struct;
+    }
+    if (cdktf.isComplexElement(struct)) {
+        throw new Error("A complex element was used as configuration, this is not supported: https://cdk.tf/complex-object-as-configuration");
+    }
+    return {
+        address: cdktf.stringToTerraform(struct.address),
+        auth_disabled: cdktf.booleanToTerraform(struct.authDisabled),
+        config_file: cdktf.stringToTerraform(struct.configFile),
+        config_file_content: cdktf.stringToTerraform(struct.configFileContent),
+        password: cdktf.stringToTerraform(struct.password),
+        username: cdktf.stringToTerraform(struct.username),
+    };
+}
+function dockerProviderRegistryAuthToHclTerraform(struct) {
+    if (!cdktf.canInspect(struct) || cdktf.Tokenization.isResolvable(struct)) {
+        return struct;
+    }
+    if (cdktf.isComplexElement(struct)) {
+        throw new Error("A complex element was used as configuration, this is not supported: https://cdk.tf/complex-object-as-configuration");
+    }
+    const attrs = {
+        address: {
+            value: cdktf.stringToHclTerraform(struct.address),
+            isBlock: false,
+            type: "simple",
+            storageClassType: "string",
+        },
+        auth_disabled: {
+            value: cdktf.booleanToHclTerraform(struct.authDisabled),
+            isBlock: false,
+            type: "simple",
+            storageClassType: "boolean",
+        },
+        config_file: {
+            value: cdktf.stringToHclTerraform(struct.configFile),
+            isBlock: false,
+            type: "simple",
+            storageClassType: "string",
+        },
+        config_file_content: {
+            value: cdktf.stringToHclTerraform(struct.configFileContent),
+            isBlock: false,
+            type: "simple",
+            storageClassType: "string",
+        },
+        password: {
+            value: cdktf.stringToHclTerraform(struct.password),
+            isBlock: false,
+            type: "simple",
+            storageClassType: "string",
+        },
+        username: {
+            value: cdktf.stringToHclTerraform(struct.username),
+            isBlock: false,
+            type: "simple",
+            storageClassType: "string",
+        },
+    };
+    // remove undefined attributes
+    return Object.fromEntries(Object.entries(attrs).filter(([_, value]) => value !== undefined && value.value !== undefined));
+}
+/**
+* Represents a {@link https://registry.terraform.io/providers/kreuzwerker/docker/3.6.2/docs docker}
+*/
+class DockerProvider extends cdktf.TerraformProvider {
+    // ==============
+    // STATIC Methods
+    // ==============
+    /**
+    * Generates CDKTF code for importing a DockerProvider 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 DockerProvider to import
+    * @param importFromId The id of the existing DockerProvider that should be imported. Refer to the {@link https://registry.terraform.io/providers/kreuzwerker/docker/3.6.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 DockerProvider to import is found
+    */
+    static generateConfigForImport(scope, importToId, importFromId, provider) {
+        return new cdktf.ImportableResource(scope, importToId, { terraformResourceType: "docker", importId: importFromId, provider });
+    }
+    // ===========
+    // INITIALIZER
+    // ===========
+    /**
+    * Create a new {@link https://registry.terraform.io/providers/kreuzwerker/docker/3.6.2/docs docker} 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 DockerProviderConfig = {}
+    */
+    constructor(scope, id, config = {}) {
+        super(scope, id, {
+            terraformResourceType: 'docker',
+            terraformGeneratorMetadata: {
+                providerName: 'docker',
+                providerVersion: '3.6.2',
+                providerVersionConstraint: '~> 3.0'
+            },
+            terraformProviderSource: 'kreuzwerker/docker'
+        });
+        this._caMaterial = config.caMaterial;
+        this._certMaterial = config.certMaterial;
+        this._certPath = config.certPath;
+        this._context = config.context;
+        this._disableDockerDaemonCheck = config.disableDockerDaemonCheck;
+        this._host = config.host;
+        this._keyMaterial = config.keyMaterial;
+        this._sshOpts = config.sshOpts;
+        this._alias = config.alias;
+        this._registryAuth = config.registryAuth;
+    }
+    get caMaterial() {
+        return this._caMaterial;
+    }
+    set caMaterial(value) {
+        this._caMaterial = value;
+    }
+    resetCaMaterial() {
+        this._caMaterial = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get caMaterialInput() {
+        return this._caMaterial;
+    }
+    get certMaterial() {
+        return this._certMaterial;
+    }
+    set certMaterial(value) {
+        this._certMaterial = value;
+    }
+    resetCertMaterial() {
+        this._certMaterial = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get certMaterialInput() {
+        return this._certMaterial;
+    }
+    get certPath() {
+        return this._certPath;
+    }
+    set certPath(value) {
+        this._certPath = value;
+    }
+    resetCertPath() {
+        this._certPath = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get certPathInput() {
+        return this._certPath;
+    }
+    get context() {
+        return this._context;
+    }
+    set context(value) {
+        this._context = value;
+    }
+    resetContext() {
+        this._context = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get contextInput() {
+        return this._context;
+    }
+    get disableDockerDaemonCheck() {
+        return this._disableDockerDaemonCheck;
+    }
+    set disableDockerDaemonCheck(value) {
+        this._disableDockerDaemonCheck = value;
+    }
+    resetDisableDockerDaemonCheck() {
+        this._disableDockerDaemonCheck = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get disableDockerDaemonCheckInput() {
+        return this._disableDockerDaemonCheck;
+    }
+    get host() {
+        return this._host;
+    }
+    set host(value) {
+        this._host = value;
+    }
+    resetHost() {
+        this._host = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get hostInput() {
+        return this._host;
+    }
+    get keyMaterial() {
+        return this._keyMaterial;
+    }
+    set keyMaterial(value) {
+        this._keyMaterial = value;
+    }
+    resetKeyMaterial() {
+        this._keyMaterial = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get keyMaterialInput() {
+        return this._keyMaterial;
+    }
+    get sshOpts() {
+        return this._sshOpts;
+    }
+    set sshOpts(value) {
+        this._sshOpts = value;
+    }
+    resetSshOpts() {
+        this._sshOpts = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get sshOptsInput() {
+        return this._sshOpts;
+    }
+    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;
+    }
+    get registryAuth() {
+        return this._registryAuth;
+    }
+    set registryAuth(value) {
+        this._registryAuth = value;
+    }
+    resetRegistryAuth() {
+        this._registryAuth = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get registryAuthInput() {
+        return this._registryAuth;
+    }
+    // =========
+    // SYNTHESIS
+    // =========
+    synthesizeAttributes() {
+        return {
+            ca_material: cdktf.stringToTerraform(this._caMaterial),
+            cert_material: cdktf.stringToTerraform(this._certMaterial),
+            cert_path: cdktf.stringToTerraform(this._certPath),
+            context: cdktf.stringToTerraform(this._context),
+            disable_docker_daemon_check: cdktf.booleanToTerraform(this._disableDockerDaemonCheck),
+            host: cdktf.stringToTerraform(this._host),
+            key_material: cdktf.stringToTerraform(this._keyMaterial),
+            ssh_opts: cdktf.listMapper(cdktf.stringToTerraform, false)(this._sshOpts),
+            alias: cdktf.stringToTerraform(this._alias),
+            registry_auth: cdktf.listMapper(dockerProviderRegistryAuthToTerraform, true)(this._registryAuth),
+        };
+    }
+    synthesizeHclAttributes() {
+        const attrs = {
+            ca_material: {
+                value: cdktf.stringToHclTerraform(this._caMaterial),
+                isBlock: false,
+                type: "simple",
+                storageClassType: "string",
+            },
+            cert_material: {
+                value: cdktf.stringToHclTerraform(this._certMaterial),
+                isBlock: false,
+                type: "simple",
+                storageClassType: "string",
+            },
+            cert_path: {
+                value: cdktf.stringToHclTerraform(this._certPath),
+                isBlock: false,
+                type: "simple",
+                storageClassType: "string",
+            },
+            context: {
+                value: cdktf.stringToHclTerraform(this._context),
+                isBlock: false,
+                type: "simple",
+                storageClassType: "string",
+            },
+            disable_docker_daemon_check: {
+                value: cdktf.booleanToHclTerraform(this._disableDockerDaemonCheck),
+                isBlock: false,
+                type: "simple",
+                storageClassType: "boolean",
+            },
+            host: {
+                value: cdktf.stringToHclTerraform(this._host),
+                isBlock: false,
+                type: "simple",
+                storageClassType: "string",
+            },
+            key_material: {
+                value: cdktf.stringToHclTerraform(this._keyMaterial),
+                isBlock: false,
+                type: "simple",
+                storageClassType: "string",
+            },
+            ssh_opts: {
+                value: cdktf.listMapperHcl(cdktf.stringToHclTerraform, false)(this._sshOpts),
+                isBlock: false,
+                type: "list",
+                storageClassType: "stringList",
+            },
+            alias: {
+                value: cdktf.stringToHclTerraform(this._alias),
+                isBlock: false,
+                type: "simple",
+                storageClassType: "string",
+            },
+            registry_auth: {
+                value: cdktf.listMapperHcl(dockerProviderRegistryAuthToHclTerraform, true)(this._registryAuth),
+                isBlock: true,
+                type: "set",
+                storageClassType: "DockerProviderRegistryAuthList",
+            },
+        };
+        // remove undefined attributes
+        return Object.fromEntries(Object.entries(attrs).filter(([_, value]) => value !== undefined && value.value !== undefined));
+    }
+}
+exports.DockerProvider = DockerProvider;
+_a = JSII_RTTI_SYMBOL_1;
+DockerProvider[_a] = { fqn: "@cdktn/provider-docker.provider.DockerProvider", version: "12.1.0" };
+// =================
+// STATIC PROPERTIES
+// =================
+DockerProvider.tfResourceType = "docker";
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/provider/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/kreuzwerker/docker/3.6.2/docs\n// generated from terraform resource schema\n\nimport { Construct } from 'constructs';\nimport * as cdktf from 'cdktf';\n\n// Configuration\n\nexport interface DockerProviderConfig {\n  /**\n  * PEM-encoded content of Docker host CA certificate\n  *\n  * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/kreuzwerker/docker/3.6.2/docs#ca_material DockerProvider#ca_material}\n  */\n  readonly caMaterial?: string;\n  /**\n  * PEM-encoded content of Docker client certificate\n  *\n  * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/kreuzwerker/docker/3.6.2/docs#cert_material DockerProvider#cert_material}\n  */\n  readonly certMaterial?: string;\n  /**\n  * Path to directory with Docker TLS config\n  *\n  * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/kreuzwerker/docker/3.6.2/docs#cert_path DockerProvider#cert_path}\n  */\n  readonly certPath?: string;\n  /**\n  * The name of the Docker context to use. Can also be set via `DOCKER_CONTEXT` environment variable. Overrides the `host` if set.\n  *\n  * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/kreuzwerker/docker/3.6.2/docs#context DockerProvider#context}\n  */\n  readonly context?: string;\n  /**\n  * If set to `true`, the provider will not check if the Docker daemon is running. This is useful for resources/data_sourcess that do not require a running Docker daemon, such as the data source `docker_registry_image`.\n  *\n  * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/kreuzwerker/docker/3.6.2/docs#disable_docker_daemon_check DockerProvider#disable_docker_daemon_check}\n  */\n  readonly disableDockerDaemonCheck?: boolean | cdktf.IResolvable;\n  /**\n  * The Docker daemon address\n  *\n  * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/kreuzwerker/docker/3.6.2/docs#host DockerProvider#host}\n  */\n  readonly host?: string;\n  /**\n  * PEM-encoded content of Docker client private key\n  *\n  * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/kreuzwerker/docker/3.6.2/docs#key_material DockerProvider#key_material}\n  */\n  readonly keyMaterial?: string;\n  /**\n  * Additional SSH option flags to be appended when using `ssh://` protocol\n  *\n  * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/kreuzwerker/docker/3.6.2/docs#ssh_opts DockerProvider#ssh_opts}\n  */\n  readonly sshOpts?: string[];\n  /**\n  * Alias name\n  *\n  * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/kreuzwerker/docker/3.6.2/docs#alias DockerProvider#alias}\n  */\n  readonly alias?: string;\n  /**\n  * registry_auth block\n  *\n  * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/kreuzwerker/docker/3.6.2/docs#registry_auth DockerProvider#registry_auth}\n  */\n  readonly registryAuth?: DockerProviderRegistryAuth[] | cdktf.IResolvable;\n}\nexport interface DockerProviderRegistryAuth {\n  /**\n  * Address of the registry\n  *\n  * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/kreuzwerker/docker/3.6.2/docs#address DockerProvider#address}\n  */\n  readonly address: string;\n  /**\n  * Setting this to `true` will tell the provider that this registry does not need authentication. Due to the docker internals, the provider will use dummy credentials (see https://github.com/kreuzwerker/terraform-provider-docker/issues/470 for more information). Defaults to `false`.\n  *\n  * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/kreuzwerker/docker/3.6.2/docs#auth_disabled DockerProvider#auth_disabled}\n  */\n  readonly authDisabled?: boolean | cdktf.IResolvable;\n  /**\n  * Path to docker json file for registry auth. Defaults to `~/.docker/config.json`. If `DOCKER_CONFIG` is set, the value of `DOCKER_CONFIG` is used as the path. `config_file` has predencen over all other options.\n  *\n  * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/kreuzwerker/docker/3.6.2/docs#config_file DockerProvider#config_file}\n  */\n  readonly configFile?: string;\n  /**\n  * Plain content of the docker json file for registry auth. `config_file_content` has precedence over username/password.\n  *\n  * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/kreuzwerker/docker/3.6.2/docs#config_file_content DockerProvider#config_file_content}\n  */\n  readonly configFileContent?: string;\n  /**\n  * Password for the registry. Defaults to `DOCKER_REGISTRY_PASS` env variable if set.\n  *\n  * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/kreuzwerker/docker/3.6.2/docs#password DockerProvider#password}\n  */\n  readonly password?: string;\n  /**\n  * Username for the registry. Defaults to `DOCKER_REGISTRY_USER` env variable if set.\n  *\n  * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/kreuzwerker/docker/3.6.2/docs#username DockerProvider#username}\n  */\n  readonly username?: string;\n}\n\nexport function dockerProviderRegistryAuthToTerraform(struct?: DockerProviderRegistryAuth | cdktf.IResolvable): any {\n  if (!cdktf.canInspect(struct) || cdktf.Tokenization.isResolvable(struct)) { return struct; }\n  if (cdktf.isComplexElement(struct)) {\n    throw new Error(\"A complex element was used as configuration, this is not supported: https://cdk.tf/complex-object-as-configuration\");\n  }\n  return {\n    address: cdktf.stringToTerraform(struct!.address),\n    auth_disabled: cdktf.booleanToTerraform(struct!.authDisabled),\n    config_file: cdktf.stringToTerraform(struct!.configFile),\n    config_file_content: cdktf.stringToTerraform(struct!.configFileContent),\n    password: cdktf.stringToTerraform(struct!.password),\n    username: cdktf.stringToTerraform(struct!.username),\n  }\n}\n\n\nexport function dockerProviderRegistryAuthToHclTerraform(struct?: DockerProviderRegistryAuth | cdktf.IResolvable): any {\n  if (!cdktf.canInspect(struct) || cdktf.Tokenization.isResolvable(struct)) { return struct; }\n  if (cdktf.isComplexElement(struct)) {\n    throw new Error(\"A complex element was used as configuration, this is not supported: https://cdk.tf/complex-object-as-configuration\");\n  }\n  const attrs = {\n    address: {\n      value: cdktf.stringToHclTerraform(struct!.address),\n      isBlock: false,\n      type: \"simple\",\n      storageClassType: \"string\",\n    },\n    auth_disabled: {\n      value: cdktf.booleanToHclTerraform(struct!.authDisabled),\n      isBlock: false,\n      type: \"simple\",\n      storageClassType: \"boolean\",\n    },\n    config_file: {\n      value: cdktf.stringToHclTerraform(struct!.configFile),\n      isBlock: false,\n      type: \"simple\",\n      storageClassType: \"string\",\n    },\n    config_file_content: {\n      value: cdktf.stringToHclTerraform(struct!.configFileContent),\n      isBlock: false,\n      type: \"simple\",\n      storageClassType: \"string\",\n    },\n    password: {\n      value: cdktf.stringToHclTerraform(struct!.password),\n      isBlock: false,\n      type: \"simple\",\n      storageClassType: \"string\",\n    },\n    username: {\n      value: cdktf.stringToHclTerraform(struct!.username),\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\n/**\n* Represents a {@link https://registry.terraform.io/providers/kreuzwerker/docker/3.6.2/docs docker}\n*/\nexport class DockerProvider extends cdktf.TerraformProvider {\n\n  // =================\n  // STATIC PROPERTIES\n  // =================\n  public static readonly tfResourceType = \"docker\";\n\n  // ==============\n  // STATIC Methods\n  // ==============\n  /**\n  * Generates CDKTF code for importing a DockerProvider 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 DockerProvider to import\n  * @param importFromId The id of the existing DockerProvider that should be imported. Refer to the {@link https://registry.terraform.io/providers/kreuzwerker/docker/3.6.2/docs#import import section} in the documentation of this resource for the id to use\n  * @param provider? Optional instance of the provider where the DockerProvider 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: \"docker\", importId: importFromId, provider });\n      }\n\n  // ===========\n  // INITIALIZER\n  // ===========\n\n  /**\n  * Create a new {@link https://registry.terraform.io/providers/kreuzwerker/docker/3.6.2/docs docker} 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 DockerProviderConfig = {}\n  */\n  public constructor(scope: Construct, id: string, config: DockerProviderConfig = {}) {\n    super(scope, id, {\n      terraformResourceType: 'docker',\n      terraformGeneratorMetadata: {\n        providerName: 'docker',\n        providerVersion: '3.6.2',\n        providerVersionConstraint: '~> 3.0'\n      },\n      terraformProviderSource: 'kreuzwerker/docker'\n    });\n    this._caMaterial = config.caMaterial;\n    this._certMaterial = config.certMaterial;\n    this._certPath = config.certPath;\n    this._context = config.context;\n    this._disableDockerDaemonCheck = config.disableDockerDaemonCheck;\n    this._host = config.host;\n    this._keyMaterial = config.keyMaterial;\n    this._sshOpts = config.sshOpts;\n    this._alias = config.alias;\n    this._registryAuth = config.registryAuth;\n  }\n\n  // ==========\n  // ATTRIBUTES\n  // ==========\n\n  // ca_material - computed: false, optional: true, required: false\n  private _caMaterial?: string; \n  public get caMaterial() {\n    return this._caMaterial;\n  }\n  public set caMaterial(value: string | undefined) {\n    this._caMaterial = value;\n  }\n  public resetCaMaterial() {\n    this._caMaterial = undefined;\n  }\n  // Temporarily expose input value. Use with caution.\n  public get caMaterialInput() {\n    return this._caMaterial;\n  }\n\n  // cert_material - computed: false, optional: true, required: false\n  private _certMaterial?: string; \n  public get certMaterial() {\n    return this._certMaterial;\n  }\n  public set certMaterial(value: string | undefined) {\n    this._certMaterial = value;\n  }\n  public resetCertMaterial() {\n    this._certMaterial = undefined;\n  }\n  // Temporarily expose input value. Use with caution.\n  public get certMaterialInput() {\n    return this._certMaterial;\n  }\n\n  // cert_path - computed: false, optional: true, required: false\n  private _certPath?: string; \n  public get certPath() {\n    return this._certPath;\n  }\n  public set certPath(value: string | undefined) {\n    this._certPath = value;\n  }\n  public resetCertPath() {\n    this._certPath = undefined;\n  }\n  // Temporarily expose input value. Use with caution.\n  public get certPathInput() {\n    return this._certPath;\n  }\n\n  // context - computed: false, optional: true, required: false\n  private _context?: string; \n  public get context() {\n    return this._context;\n  }\n  public set context(value: string | undefined) {\n    this._context = value;\n  }\n  public resetContext() {\n    this._context = undefined;\n  }\n  // Temporarily expose input value. Use with caution.\n  public get contextInput() {\n    return this._context;\n  }\n\n  // disable_docker_daemon_check - computed: false, optional: true, required: false\n  private _disableDockerDaemonCheck?: boolean | cdktf.IResolvable; \n  public get disableDockerDaemonCheck() {\n    return this._disableDockerDaemonCheck;\n  }\n  public set disableDockerDaemonCheck(value: boolean | cdktf.IResolvable | undefined) {\n    this._disableDockerDaemonCheck = value;\n  }\n  public resetDisableDockerDaemonCheck() {\n    this._disableDockerDaemonCheck = undefined;\n  }\n  // Temporarily expose input value. Use with caution.\n  public get disableDockerDaemonCheckInput() {\n    return this._disableDockerDaemonCheck;\n  }\n\n  // host - computed: false, optional: true, required: false\n  private _host?: string; \n  public get host() {\n    return this._host;\n  }\n  public set host(value: string | undefined) {\n    this._host = value;\n  }\n  public resetHost() {\n    this._host = undefined;\n  }\n  // Temporarily expose input value. Use with caution.\n  public get hostInput() {\n    return this._host;\n  }\n\n  // key_material - computed: false, optional: true, required: false\n  private _keyMaterial?: string; \n  public get keyMaterial() {\n    return this._keyMaterial;\n  }\n  public set keyMaterial(value: string | undefined) {\n    this._keyMaterial = value;\n  }\n  public resetKeyMaterial() {\n    this._keyMaterial = undefined;\n  }\n  // Temporarily expose input value. Use with caution.\n  public get keyMaterialInput() {\n    return this._keyMaterial;\n  }\n\n  // ssh_opts - computed: false, optional: true, required: false\n  private _sshOpts?: string[]; \n  public get sshOpts() {\n    return this._sshOpts;\n  }\n  public set sshOpts(value: string[] | undefined) {\n    this._sshOpts = value;\n  }\n  public resetSshOpts() {\n    this._sshOpts = undefined;\n  }\n  // Temporarily expose input value. Use with caution.\n  public get sshOptsInput() {\n    return this._sshOpts;\n  }\n\n  // alias - computed: false, optional: true, required: false\n  private _alias?: string; \n  public get alias() {\n    return this._alias;\n  }\n  public set alias(value: string | undefined) {\n    this._alias = value;\n  }\n  public resetAlias() {\n    this._alias = undefined;\n  }\n  // Temporarily expose input value. Use with caution.\n  public get aliasInput() {\n    return this._alias;\n  }\n\n  // registry_auth - computed: false, optional: true, required: false\n  private _registryAuth?: DockerProviderRegistryAuth[] | cdktf.IResolvable; \n  public get registryAuth() {\n    return this._registryAuth;\n  }\n  public set registryAuth(value: DockerProviderRegistryAuth[] | cdktf.IResolvable | undefined) {\n    this._registryAuth = value;\n  }\n  public resetRegistryAuth() {\n    this._registryAuth = undefined;\n  }\n  // Temporarily expose input value. Use with caution.\n  public get registryAuthInput() {\n    return this._registryAuth;\n  }\n\n  // =========\n  // SYNTHESIS\n  // =========\n\n  protected synthesizeAttributes(): { [name: string]: any } {\n    return {\n      ca_material: cdktf.stringToTerraform(this._caMaterial),\n      cert_material: cdktf.stringToTerraform(this._certMaterial),\n      cert_path: cdktf.stringToTerraform(this._certPath),\n      context: cdktf.stringToTerraform(this._context),\n      disable_docker_daemon_check: cdktf.booleanToTerraform(this._disableDockerDaemonCheck),\n      host: cdktf.stringToTerraform(this._host),\n      key_material: cdktf.stringToTerraform(this._keyMaterial),\n      ssh_opts: cdktf.listMapper(cdktf.stringToTerraform, false)(this._sshOpts),\n      alias: cdktf.stringToTerraform(this._alias),\n      registry_auth: cdktf.listMapper(dockerProviderRegistryAuthToTerraform, true)(this._registryAuth),\n    };\n  }\n\n  protected synthesizeHclAttributes(): { [name: string]: any } {\n    const attrs = {\n      ca_material: {\n        value: cdktf.stringToHclTerraform(this._caMaterial),\n        isBlock: false,\n        type: \"simple\",\n        storageClassType: \"string\",\n      },\n      cert_material: {\n        value: cdktf.stringToHclTerraform(this._certMaterial),\n        isBlock: false,\n        type: \"simple\",\n        storageClassType: \"string\",\n      },\n      cert_path: {\n        value: cdktf.stringToHclTerraform(this._certPath),\n        isBlock: false,\n        type: \"simple\",\n        storageClassType: \"string\",\n      },\n      context: {\n        value: cdktf.stringToHclTerraform(this._context),\n        isBlock: false,\n        type: \"simple\",\n        storageClassType: \"string\",\n      },\n      disable_docker_daemon_check: {\n        value: cdktf.booleanToHclTerraform(this._disableDockerDaemonCheck),\n        isBlock: false,\n        type: \"simple\",\n        storageClassType: \"boolean\",\n      },\n      host: {\n        value: cdktf.stringToHclTerraform(this._host),\n        isBlock: false,\n        type: \"simple\",\n        storageClassType: \"string\",\n      },\n      key_material: {\n        value: cdktf.stringToHclTerraform(this._keyMaterial),\n        isBlock: false,\n        type: \"simple\",\n        storageClassType: \"string\",\n      },\n      ssh_opts: {\n        value: cdktf.listMapperHcl(cdktf.stringToHclTerraform, false)(this._sshOpts),\n        isBlock: false,\n        type: \"list\",\n        storageClassType: \"stringList\",\n      },\n      alias: {\n        value: cdktf.stringToHclTerraform(this._alias),\n        isBlock: false,\n        type: \"simple\",\n        storageClassType: \"string\",\n      },\n      registry_auth: {\n        value: cdktf.listMapperHcl(dockerProviderRegistryAuthToHclTerraform, true)(this._registryAuth),\n        isBlock: true,\n        type: \"set\",\n        storageClassType: \"DockerProviderRegistryAuthList\",\n      },\n    };\n\n    // remove undefined attributes\n    return Object.fromEntries(Object.entries(attrs).filter(([_, value]) => value !== undefined && value.value !== undefined ))\n  }\n}\n"]}