// *** WARNING: this file was generated by pulumi-language-nodejs. ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***

import * as pulumi from "@pulumi/pulumi";
import * as utilities from "./utilities";

// Export members:
export { DatabaseBackupArgs, DatabaseBackupState } from "./databaseBackup";
export type DatabaseBackup = import("./databaseBackup").DatabaseBackup;
export const DatabaseBackup: typeof import("./databaseBackup").DatabaseBackup = null as any;
utilities.lazyLoad(exports, ["DatabaseBackup"], () => require("./databaseBackup"));

export { DatabaseBackupScheduleArgs, DatabaseBackupScheduleState } from "./databaseBackupSchedule";
export type DatabaseBackupSchedule = import("./databaseBackupSchedule").DatabaseBackupSchedule;
export const DatabaseBackupSchedule: typeof import("./databaseBackupSchedule").DatabaseBackupSchedule = null as any;
utilities.lazyLoad(exports, ["DatabaseBackupSchedule"], () => require("./databaseBackupSchedule"));

export { DatabaseClusterArgs, DatabaseClusterState } from "./databaseCluster";
export type DatabaseCluster = import("./databaseCluster").DatabaseCluster;
export const DatabaseCluster: typeof import("./databaseCluster").DatabaseCluster = null as any;
utilities.lazyLoad(exports, ["DatabaseCluster"], () => require("./databaseCluster"));

export { DatabaseInstanceArgs, DatabaseInstanceState } from "./databaseInstance";
export type DatabaseInstance = import("./databaseInstance").DatabaseInstance;
export const DatabaseInstance: typeof import("./databaseInstance").DatabaseInstance = null as any;
utilities.lazyLoad(exports, ["DatabaseInstance"], () => require("./databaseInstance"));

export { DatabaseUserArgs, DatabaseUserState } from "./databaseUser";
export type DatabaseUser = import("./databaseUser").DatabaseUser;
export const DatabaseUser: typeof import("./databaseUser").DatabaseUser = null as any;
utilities.lazyLoad(exports, ["DatabaseUser"], () => require("./databaseUser"));

export { DbBackupArgs, DbBackupState } from "./dbBackup";
export type DbBackup = import("./dbBackup").DbBackup;
export const DbBackup: typeof import("./dbBackup").DbBackup = null as any;
utilities.lazyLoad(exports, ["DbBackup"], () => require("./dbBackup"));

export { DbBackupScheduleArgs, DbBackupScheduleState } from "./dbBackupSchedule";
export type DbBackupSchedule = import("./dbBackupSchedule").DbBackupSchedule;
export const DbBackupSchedule: typeof import("./dbBackupSchedule").DbBackupSchedule = null as any;
utilities.lazyLoad(exports, ["DbBackupSchedule"], () => require("./dbBackupSchedule"));

export { DbMongodbArgs, DbMongodbState } from "./dbMongodb";
export type DbMongodb = import("./dbMongodb").DbMongodb;
export const DbMongodb: typeof import("./dbMongodb").DbMongodb = null as any;
utilities.lazyLoad(exports, ["DbMongodb"], () => require("./dbMongodb"));

export { DbMysql5Args, DbMysql5State } from "./dbMysql5";
export type DbMysql5 = import("./dbMysql5").DbMysql5;
export const DbMysql5: typeof import("./dbMysql5").DbMysql5 = null as any;
utilities.lazyLoad(exports, ["DbMysql5"], () => require("./dbMysql5"));

export { DbMysql8Args, DbMysql8State } from "./dbMysql8";
export type DbMysql8 = import("./dbMysql8").DbMysql8;
export const DbMysql8: typeof import("./dbMysql8").DbMysql8 = null as any;
utilities.lazyLoad(exports, ["DbMysql8"], () => require("./dbMysql8"));

export { DbPostgresArgs, DbPostgresState } from "./dbPostgres";
export type DbPostgres = import("./dbPostgres").DbPostgres;
export const DbPostgres: typeof import("./dbPostgres").DbPostgres = null as any;
utilities.lazyLoad(exports, ["DbPostgres"], () => require("./dbPostgres"));

export { DbRedisArgs, DbRedisState } from "./dbRedis";
export type DbRedis = import("./dbRedis").DbRedis;
export const DbRedis: typeof import("./dbRedis").DbRedis = null as any;
utilities.lazyLoad(exports, ["DbRedis"], () => require("./dbRedis"));

export { DnsRrArgs, DnsRrState } from "./dnsRr";
export type DnsRr = import("./dnsRr").DnsRr;
export const DnsRr: typeof import("./dnsRr").DnsRr = null as any;
utilities.lazyLoad(exports, ["DnsRr"], () => require("./dnsRr"));

export { FirewallArgs, FirewallState } from "./firewall";
export type Firewall = import("./firewall").Firewall;
export const Firewall: typeof import("./firewall").Firewall = null as any;
utilities.lazyLoad(exports, ["Firewall"], () => require("./firewall"));

export { FirewallRuleArgs, FirewallRuleState } from "./firewallRule";
export type FirewallRule = import("./firewallRule").FirewallRule;
export const FirewallRule: typeof import("./firewallRule").FirewallRule = null as any;
utilities.lazyLoad(exports, ["FirewallRule"], () => require("./firewallRule"));

export { FloatingIpArgs, FloatingIpState } from "./floatingIp";
export type FloatingIp = import("./floatingIp").FloatingIp;
export const FloatingIp: typeof import("./floatingIp").FloatingIp = null as any;
utilities.lazyLoad(exports, ["FloatingIp"], () => require("./floatingIp"));

export { GetConfiguratorArgs, GetConfiguratorResult, GetConfiguratorOutputArgs } from "./getConfigurator";
export const getConfigurator: typeof import("./getConfigurator").getConfigurator = null as any;
export const getConfiguratorOutput: typeof import("./getConfigurator").getConfiguratorOutput = null as any;
utilities.lazyLoad(exports, ["getConfigurator","getConfiguratorOutput"], () => require("./getConfigurator"));

export { GetDatabaseClusterArgs, GetDatabaseClusterResult, GetDatabaseClusterOutputArgs } from "./getDatabaseCluster";
export const getDatabaseCluster: typeof import("./getDatabaseCluster").getDatabaseCluster = null as any;
export const getDatabaseClusterOutput: typeof import("./getDatabaseCluster").getDatabaseClusterOutput = null as any;
utilities.lazyLoad(exports, ["getDatabaseCluster","getDatabaseClusterOutput"], () => require("./getDatabaseCluster"));

export { GetDatabasePresetArgs, GetDatabasePresetResult, GetDatabasePresetOutputArgs } from "./getDatabasePreset";
export const getDatabasePreset: typeof import("./getDatabasePreset").getDatabasePreset = null as any;
export const getDatabasePresetOutput: typeof import("./getDatabasePreset").getDatabasePresetOutput = null as any;
utilities.lazyLoad(exports, ["getDatabasePreset","getDatabasePresetOutput"], () => require("./getDatabasePreset"));

export { GetDbPresetArgs, GetDbPresetResult, GetDbPresetOutputArgs } from "./getDbPreset";
export const getDbPreset: typeof import("./getDbPreset").getDbPreset = null as any;
export const getDbPresetOutput: typeof import("./getDbPreset").getDbPresetOutput = null as any;
utilities.lazyLoad(exports, ["getDbPreset","getDbPresetOutput"], () => require("./getDbPreset"));

export { GetDnsZoneArgs, GetDnsZoneResult, GetDnsZoneOutputArgs } from "./getDnsZone";
export const getDnsZone: typeof import("./getDnsZone").getDnsZone = null as any;
export const getDnsZoneOutput: typeof import("./getDnsZone").getDnsZoneOutput = null as any;
utilities.lazyLoad(exports, ["getDnsZone","getDnsZoneOutput"], () => require("./getDnsZone"));

export { GetFloatingIpArgs, GetFloatingIpResult, GetFloatingIpOutputArgs } from "./getFloatingIp";
export const getFloatingIp: typeof import("./getFloatingIp").getFloatingIp = null as any;
export const getFloatingIpOutput: typeof import("./getFloatingIp").getFloatingIpOutput = null as any;
utilities.lazyLoad(exports, ["getFloatingIp","getFloatingIpOutput"], () => require("./getFloatingIp"));

export { GetImageArgs, GetImageResult, GetImageOutputArgs } from "./getImage";
export const getImage: typeof import("./getImage").getImage = null as any;
export const getImageOutput: typeof import("./getImage").getImageOutput = null as any;
utilities.lazyLoad(exports, ["getImage","getImageOutput"], () => require("./getImage"));

export { GetK8sPresetArgs, GetK8sPresetResult, GetK8sPresetOutputArgs } from "./getK8sPreset";
export const getK8sPreset: typeof import("./getK8sPreset").getK8sPreset = null as any;
export const getK8sPresetOutput: typeof import("./getK8sPreset").getK8sPresetOutput = null as any;
utilities.lazyLoad(exports, ["getK8sPreset","getK8sPresetOutput"], () => require("./getK8sPreset"));

export { GetLbPresetArgs, GetLbPresetResult, GetLbPresetOutputArgs } from "./getLbPreset";
export const getLbPreset: typeof import("./getLbPreset").getLbPreset = null as any;
export const getLbPresetOutput: typeof import("./getLbPreset").getLbPresetOutput = null as any;
utilities.lazyLoad(exports, ["getLbPreset","getLbPresetOutput"], () => require("./getLbPreset"));

export { GetNetworkDriveArgs, GetNetworkDriveResult, GetNetworkDriveOutputArgs } from "./getNetworkDrive";
export const getNetworkDrive: typeof import("./getNetworkDrive").getNetworkDrive = null as any;
export const getNetworkDriveOutput: typeof import("./getNetworkDrive").getNetworkDriveOutput = null as any;
utilities.lazyLoad(exports, ["getNetworkDrive","getNetworkDriveOutput"], () => require("./getNetworkDrive"));

export { GetNetworkDrivePresetArgs, GetNetworkDrivePresetResult, GetNetworkDrivePresetOutputArgs } from "./getNetworkDrivePreset";
export const getNetworkDrivePreset: typeof import("./getNetworkDrivePreset").getNetworkDrivePreset = null as any;
export const getNetworkDrivePresetOutput: typeof import("./getNetworkDrivePreset").getNetworkDrivePresetOutput = null as any;
utilities.lazyLoad(exports, ["getNetworkDrivePreset","getNetworkDrivePresetOutput"], () => require("./getNetworkDrivePreset"));

export { GetOsArgs, GetOsResult, GetOsOutputArgs } from "./getOs";
export const getOs: typeof import("./getOs").getOs = null as any;
export const getOsOutput: typeof import("./getOs").getOsOutput = null as any;
utilities.lazyLoad(exports, ["getOs","getOsOutput"], () => require("./getOs"));

export { GetPresetsArgs, GetPresetsResult, GetPresetsOutputArgs } from "./getPresets";
export const getPresets: typeof import("./getPresets").getPresets = null as any;
export const getPresetsOutput: typeof import("./getPresets").getPresetsOutput = null as any;
utilities.lazyLoad(exports, ["getPresets","getPresetsOutput"], () => require("./getPresets"));

export { GetProjectsArgs, GetProjectsResult, GetProjectsOutputArgs } from "./getProjects";
export const getProjects: typeof import("./getProjects").getProjects = null as any;
export const getProjectsOutput: typeof import("./getProjects").getProjectsOutput = null as any;
utilities.lazyLoad(exports, ["getProjects","getProjectsOutput"], () => require("./getProjects"));

export { GetS3BucketArgs, GetS3BucketResult, GetS3BucketOutputArgs } from "./getS3Bucket";
export const getS3Bucket: typeof import("./getS3Bucket").getS3Bucket = null as any;
export const getS3BucketOutput: typeof import("./getS3Bucket").getS3BucketOutput = null as any;
utilities.lazyLoad(exports, ["getS3Bucket","getS3BucketOutput"], () => require("./getS3Bucket"));

export { GetS3ConfiguratorArgs, GetS3ConfiguratorResult, GetS3ConfiguratorOutputArgs } from "./getS3Configurator";
export const getS3Configurator: typeof import("./getS3Configurator").getS3Configurator = null as any;
export const getS3ConfiguratorOutput: typeof import("./getS3Configurator").getS3ConfiguratorOutput = null as any;
utilities.lazyLoad(exports, ["getS3Configurator","getS3ConfiguratorOutput"], () => require("./getS3Configurator"));

export { GetS3PresetArgs, GetS3PresetResult, GetS3PresetOutputArgs } from "./getS3Preset";
export const getS3Preset: typeof import("./getS3Preset").getS3Preset = null as any;
export const getS3PresetOutput: typeof import("./getS3Preset").getS3PresetOutput = null as any;
utilities.lazyLoad(exports, ["getS3Preset","getS3PresetOutput"], () => require("./getS3Preset"));

export { GetSoftwareArgs, GetSoftwareResult, GetSoftwareOutputArgs } from "./getSoftware";
export const getSoftware: typeof import("./getSoftware").getSoftware = null as any;
export const getSoftwareOutput: typeof import("./getSoftware").getSoftwareOutput = null as any;
utilities.lazyLoad(exports, ["getSoftware","getSoftwareOutput"], () => require("./getSoftware"));

export { GetSshKeysArgs, GetSshKeysResult, GetSshKeysOutputArgs } from "./getSshKeys";
export const getSshKeys: typeof import("./getSshKeys").getSshKeys = null as any;
export const getSshKeysOutput: typeof import("./getSshKeys").getSshKeysOutput = null as any;
utilities.lazyLoad(exports, ["getSshKeys","getSshKeysOutput"], () => require("./getSshKeys"));

export { K8sClusterArgs, K8sClusterState } from "./k8sCluster";
export type K8sCluster = import("./k8sCluster").K8sCluster;
export const K8sCluster: typeof import("./k8sCluster").K8sCluster = null as any;
utilities.lazyLoad(exports, ["K8sCluster"], () => require("./k8sCluster"));

export { K8sNodeGroupArgs, K8sNodeGroupState } from "./k8sNodeGroup";
export type K8sNodeGroup = import("./k8sNodeGroup").K8sNodeGroup;
export const K8sNodeGroup: typeof import("./k8sNodeGroup").K8sNodeGroup = null as any;
utilities.lazyLoad(exports, ["K8sNodeGroup"], () => require("./k8sNodeGroup"));

export { LbArgs, LbState } from "./lb";
export type Lb = import("./lb").Lb;
export const Lb: typeof import("./lb").Lb = null as any;
utilities.lazyLoad(exports, ["Lb"], () => require("./lb"));

export { LbRuleArgs, LbRuleState } from "./lbRule";
export type LbRule = import("./lbRule").LbRule;
export const LbRule: typeof import("./lbRule").LbRule = null as any;
utilities.lazyLoad(exports, ["LbRule"], () => require("./lbRule"));

export { NetworkDriveArgs, NetworkDriveState } from "./networkDrive";
export type NetworkDrive = import("./networkDrive").NetworkDrive;
export const NetworkDrive: typeof import("./networkDrive").NetworkDrive = null as any;
utilities.lazyLoad(exports, ["NetworkDrive"], () => require("./networkDrive"));

export { ProjectArgs, ProjectState } from "./project";
export type Project = import("./project").Project;
export const Project: typeof import("./project").Project = null as any;
utilities.lazyLoad(exports, ["Project"], () => require("./project"));

export { ProviderArgs } from "./provider";
export type Provider = import("./provider").Provider;
export const Provider: typeof import("./provider").Provider = null as any;
utilities.lazyLoad(exports, ["Provider"], () => require("./provider"));

export { S3BucketArgs, S3BucketState } from "./s3bucket";
export type S3Bucket = import("./s3bucket").S3Bucket;
export const S3Bucket: typeof import("./s3bucket").S3Bucket = null as any;
utilities.lazyLoad(exports, ["S3Bucket"], () => require("./s3bucket"));

export { S3BucketDirectoryArgs, S3BucketDirectoryState } from "./s3bucketDirectory";
export type S3BucketDirectory = import("./s3bucketDirectory").S3BucketDirectory;
export const S3BucketDirectory: typeof import("./s3bucketDirectory").S3BucketDirectory = null as any;
utilities.lazyLoad(exports, ["S3BucketDirectory"], () => require("./s3bucketDirectory"));

export { S3BucketFileArgs, S3BucketFileState } from "./s3bucketFile";
export type S3BucketFile = import("./s3bucketFile").S3BucketFile;
export const S3BucketFile: typeof import("./s3bucketFile").S3BucketFile = null as any;
utilities.lazyLoad(exports, ["S3BucketFile"], () => require("./s3bucketFile"));

export { S3BucketSubdomainArgs, S3BucketSubdomainState } from "./s3bucketSubdomain";
export type S3BucketSubdomain = import("./s3bucketSubdomain").S3BucketSubdomain;
export const S3BucketSubdomain: typeof import("./s3bucketSubdomain").S3BucketSubdomain = null as any;
utilities.lazyLoad(exports, ["S3BucketSubdomain"], () => require("./s3bucketSubdomain"));

export { ServerArgs, ServerState } from "./server";
export type Server = import("./server").Server;
export const Server: typeof import("./server").Server = null as any;
utilities.lazyLoad(exports, ["Server"], () => require("./server"));

export { ServerDiskArgs, ServerDiskState } from "./serverDisk";
export type ServerDisk = import("./serverDisk").ServerDisk;
export const ServerDisk: typeof import("./serverDisk").ServerDisk = null as any;
utilities.lazyLoad(exports, ["ServerDisk"], () => require("./serverDisk"));

export { ServerDiskBackupArgs, ServerDiskBackupState } from "./serverDiskBackup";
export type ServerDiskBackup = import("./serverDiskBackup").ServerDiskBackup;
export const ServerDiskBackup: typeof import("./serverDiskBackup").ServerDiskBackup = null as any;
utilities.lazyLoad(exports, ["ServerDiskBackup"], () => require("./serverDiskBackup"));

export { ServerDiskBackupScheduleArgs, ServerDiskBackupScheduleState } from "./serverDiskBackupSchedule";
export type ServerDiskBackupSchedule = import("./serverDiskBackupSchedule").ServerDiskBackupSchedule;
export const ServerDiskBackupSchedule: typeof import("./serverDiskBackupSchedule").ServerDiskBackupSchedule = null as any;
utilities.lazyLoad(exports, ["ServerDiskBackupSchedule"], () => require("./serverDiskBackupSchedule"));

export { ServerIpArgs, ServerIpState } from "./serverIp";
export type ServerIp = import("./serverIp").ServerIp;
export const ServerIp: typeof import("./serverIp").ServerIp = null as any;
utilities.lazyLoad(exports, ["ServerIp"], () => require("./serverIp"));

export { SshKeyArgs, SshKeyState } from "./sshKey";
export type SshKey = import("./sshKey").SshKey;
export const SshKey: typeof import("./sshKey").SshKey = null as any;
utilities.lazyLoad(exports, ["SshKey"], () => require("./sshKey"));

export { VpcArgs, VpcState } from "./vpc";
export type Vpc = import("./vpc").Vpc;
export const Vpc: typeof import("./vpc").Vpc = null as any;
utilities.lazyLoad(exports, ["Vpc"], () => require("./vpc"));


// Export sub-modules:
import * as config from "./config";
import * as types from "./types";

export {
    config,
    types,
};

const _module = {
    version: utilities.getVersion(),
    construct: (name: string, type: string, urn: string): pulumi.Resource => {
        switch (type) {
            case "timeweb-cloud:index/databaseBackup:DatabaseBackup":
                return new DatabaseBackup(name, <any>undefined, { urn })
            case "timeweb-cloud:index/databaseBackupSchedule:DatabaseBackupSchedule":
                return new DatabaseBackupSchedule(name, <any>undefined, { urn })
            case "timeweb-cloud:index/databaseCluster:DatabaseCluster":
                return new DatabaseCluster(name, <any>undefined, { urn })
            case "timeweb-cloud:index/databaseInstance:DatabaseInstance":
                return new DatabaseInstance(name, <any>undefined, { urn })
            case "timeweb-cloud:index/databaseUser:DatabaseUser":
                return new DatabaseUser(name, <any>undefined, { urn })
            case "timeweb-cloud:index/dbBackup:DbBackup":
                return new DbBackup(name, <any>undefined, { urn })
            case "timeweb-cloud:index/dbBackupSchedule:DbBackupSchedule":
                return new DbBackupSchedule(name, <any>undefined, { urn })
            case "timeweb-cloud:index/dbMongodb:DbMongodb":
                return new DbMongodb(name, <any>undefined, { urn })
            case "timeweb-cloud:index/dbMysql5:DbMysql5":
                return new DbMysql5(name, <any>undefined, { urn })
            case "timeweb-cloud:index/dbMysql8:DbMysql8":
                return new DbMysql8(name, <any>undefined, { urn })
            case "timeweb-cloud:index/dbPostgres:DbPostgres":
                return new DbPostgres(name, <any>undefined, { urn })
            case "timeweb-cloud:index/dbRedis:DbRedis":
                return new DbRedis(name, <any>undefined, { urn })
            case "timeweb-cloud:index/dnsRr:DnsRr":
                return new DnsRr(name, <any>undefined, { urn })
            case "timeweb-cloud:index/firewall:Firewall":
                return new Firewall(name, <any>undefined, { urn })
            case "timeweb-cloud:index/firewallRule:FirewallRule":
                return new FirewallRule(name, <any>undefined, { urn })
            case "timeweb-cloud:index/floatingIp:FloatingIp":
                return new FloatingIp(name, <any>undefined, { urn })
            case "timeweb-cloud:index/k8sCluster:K8sCluster":
                return new K8sCluster(name, <any>undefined, { urn })
            case "timeweb-cloud:index/k8sNodeGroup:K8sNodeGroup":
                return new K8sNodeGroup(name, <any>undefined, { urn })
            case "timeweb-cloud:index/lb:Lb":
                return new Lb(name, <any>undefined, { urn })
            case "timeweb-cloud:index/lbRule:LbRule":
                return new LbRule(name, <any>undefined, { urn })
            case "timeweb-cloud:index/networkDrive:NetworkDrive":
                return new NetworkDrive(name, <any>undefined, { urn })
            case "timeweb-cloud:index/project:Project":
                return new Project(name, <any>undefined, { urn })
            case "timeweb-cloud:index/s3Bucket:S3Bucket":
                return new S3Bucket(name, <any>undefined, { urn })
            case "timeweb-cloud:index/s3BucketDirectory:S3BucketDirectory":
                return new S3BucketDirectory(name, <any>undefined, { urn })
            case "timeweb-cloud:index/s3BucketFile:S3BucketFile":
                return new S3BucketFile(name, <any>undefined, { urn })
            case "timeweb-cloud:index/s3BucketSubdomain:S3BucketSubdomain":
                return new S3BucketSubdomain(name, <any>undefined, { urn })
            case "timeweb-cloud:index/server:Server":
                return new Server(name, <any>undefined, { urn })
            case "timeweb-cloud:index/serverDisk:ServerDisk":
                return new ServerDisk(name, <any>undefined, { urn })
            case "timeweb-cloud:index/serverDiskBackup:ServerDiskBackup":
                return new ServerDiskBackup(name, <any>undefined, { urn })
            case "timeweb-cloud:index/serverDiskBackupSchedule:ServerDiskBackupSchedule":
                return new ServerDiskBackupSchedule(name, <any>undefined, { urn })
            case "timeweb-cloud:index/serverIp:ServerIp":
                return new ServerIp(name, <any>undefined, { urn })
            case "timeweb-cloud:index/sshKey:SshKey":
                return new SshKey(name, <any>undefined, { urn })
            case "timeweb-cloud:index/vpc:Vpc":
                return new Vpc(name, <any>undefined, { urn })
            default:
                throw new Error(`unknown resource type ${type}`);
        }
    },
};
pulumi.runtime.registerResourceModule("timeweb-cloud", "index/databaseBackup", _module)
pulumi.runtime.registerResourceModule("timeweb-cloud", "index/databaseBackupSchedule", _module)
pulumi.runtime.registerResourceModule("timeweb-cloud", "index/databaseCluster", _module)
pulumi.runtime.registerResourceModule("timeweb-cloud", "index/databaseInstance", _module)
pulumi.runtime.registerResourceModule("timeweb-cloud", "index/databaseUser", _module)
pulumi.runtime.registerResourceModule("timeweb-cloud", "index/dbBackup", _module)
pulumi.runtime.registerResourceModule("timeweb-cloud", "index/dbBackupSchedule", _module)
pulumi.runtime.registerResourceModule("timeweb-cloud", "index/dbMongodb", _module)
pulumi.runtime.registerResourceModule("timeweb-cloud", "index/dbMysql5", _module)
pulumi.runtime.registerResourceModule("timeweb-cloud", "index/dbMysql8", _module)
pulumi.runtime.registerResourceModule("timeweb-cloud", "index/dbPostgres", _module)
pulumi.runtime.registerResourceModule("timeweb-cloud", "index/dbRedis", _module)
pulumi.runtime.registerResourceModule("timeweb-cloud", "index/dnsRr", _module)
pulumi.runtime.registerResourceModule("timeweb-cloud", "index/firewall", _module)
pulumi.runtime.registerResourceModule("timeweb-cloud", "index/firewallRule", _module)
pulumi.runtime.registerResourceModule("timeweb-cloud", "index/floatingIp", _module)
pulumi.runtime.registerResourceModule("timeweb-cloud", "index/k8sCluster", _module)
pulumi.runtime.registerResourceModule("timeweb-cloud", "index/k8sNodeGroup", _module)
pulumi.runtime.registerResourceModule("timeweb-cloud", "index/lb", _module)
pulumi.runtime.registerResourceModule("timeweb-cloud", "index/lbRule", _module)
pulumi.runtime.registerResourceModule("timeweb-cloud", "index/networkDrive", _module)
pulumi.runtime.registerResourceModule("timeweb-cloud", "index/project", _module)
pulumi.runtime.registerResourceModule("timeweb-cloud", "index/s3Bucket", _module)
pulumi.runtime.registerResourceModule("timeweb-cloud", "index/s3BucketDirectory", _module)
pulumi.runtime.registerResourceModule("timeweb-cloud", "index/s3BucketFile", _module)
pulumi.runtime.registerResourceModule("timeweb-cloud", "index/s3BucketSubdomain", _module)
pulumi.runtime.registerResourceModule("timeweb-cloud", "index/server", _module)
pulumi.runtime.registerResourceModule("timeweb-cloud", "index/serverDisk", _module)
pulumi.runtime.registerResourceModule("timeweb-cloud", "index/serverDiskBackup", _module)
pulumi.runtime.registerResourceModule("timeweb-cloud", "index/serverDiskBackupSchedule", _module)
pulumi.runtime.registerResourceModule("timeweb-cloud", "index/serverIp", _module)
pulumi.runtime.registerResourceModule("timeweb-cloud", "index/sshKey", _module)
pulumi.runtime.registerResourceModule("timeweb-cloud", "index/vpc", _module)
pulumi.runtime.registerResourcePackage("timeweb-cloud", {
    version: utilities.getVersion(),
    constructProvider: (name: string, type: string, urn: string): pulumi.ProviderResource => {
        if (type !== "pulumi:providers:timeweb-cloud") {
            throw new Error(`unknown provider type ${type}`);
        }
        return new Provider(name, <any>undefined, { urn });
    },
});