pulumi-incus/sdk/nodejs/index.ts

// *** 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 { CertificateArgs, CertificateState } from "./certificate";
export type Certificate = import("./certificate").Certificate;
export const Certificate: typeof import("./certificate").Certificate = null as any;
utilities.lazyLoad(exports, ["Certificate"], () => require("./certificate"));

export { ClusterGroupArgs, ClusterGroupState } from "./clusterGroup";
export type ClusterGroup = import("./clusterGroup").ClusterGroup;
export const ClusterGroup: typeof import("./clusterGroup").ClusterGroup = null as any;
utilities.lazyLoad(exports, ["ClusterGroup"], () => require("./clusterGroup"));

export { ClusterGroupMemberArgs, ClusterGroupMemberState } from "./clusterGroupMember";
export type ClusterGroupMember = import("./clusterGroupMember").ClusterGroupMember;
export const ClusterGroupMember: typeof import("./clusterGroupMember").ClusterGroupMember = null as any;
utilities.lazyLoad(exports, ["ClusterGroupMember"], () => require("./clusterGroupMember"));

export { GetClusterArgs, GetClusterResult, GetClusterOutputArgs } from "./getCluster";
export const getCluster: typeof import("./getCluster").getCluster = null as any;
export const getClusterOutput: typeof import("./getCluster").getClusterOutput = null as any;
utilities.lazyLoad(exports, ["getCluster","getClusterOutput"], () => require("./getCluster"));

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 { GetInstanceArgs, GetInstanceResult, GetInstanceOutputArgs } from "./getInstance";
export const getInstance: typeof import("./getInstance").getInstance = null as any;
export const getInstanceOutput: typeof import("./getInstance").getInstanceOutput = null as any;
utilities.lazyLoad(exports, ["getInstance","getInstanceOutput"], () => require("./getInstance"));

export { GetNetworkArgs, GetNetworkResult, GetNetworkOutputArgs } from "./getNetwork";
export const getNetwork: typeof import("./getNetwork").getNetwork = null as any;
export const getNetworkOutput: typeof import("./getNetwork").getNetworkOutput = null as any;
utilities.lazyLoad(exports, ["getNetwork","getNetworkOutput"], () => require("./getNetwork"));

export { GetNetworkAclArgs, GetNetworkAclResult, GetNetworkAclOutputArgs } from "./getNetworkAcl";
export const getNetworkAcl: typeof import("./getNetworkAcl").getNetworkAcl = null as any;
export const getNetworkAclOutput: typeof import("./getNetworkAcl").getNetworkAclOutput = null as any;
utilities.lazyLoad(exports, ["getNetworkAcl","getNetworkAclOutput"], () => require("./getNetworkAcl"));

export { GetNetworkAddressSetArgs, GetNetworkAddressSetResult, GetNetworkAddressSetOutputArgs } from "./getNetworkAddressSet";
export const getNetworkAddressSet: typeof import("./getNetworkAddressSet").getNetworkAddressSet = null as any;
export const getNetworkAddressSetOutput: typeof import("./getNetworkAddressSet").getNetworkAddressSetOutput = null as any;
utilities.lazyLoad(exports, ["getNetworkAddressSet","getNetworkAddressSetOutput"], () => require("./getNetworkAddressSet"));

export { GetNetworkForwardArgs, GetNetworkForwardResult, GetNetworkForwardOutputArgs } from "./getNetworkForward";
export const getNetworkForward: typeof import("./getNetworkForward").getNetworkForward = null as any;
export const getNetworkForwardOutput: typeof import("./getNetworkForward").getNetworkForwardOutput = null as any;
utilities.lazyLoad(exports, ["getNetworkForward","getNetworkForwardOutput"], () => require("./getNetworkForward"));

export { GetNetworkIntegrationArgs, GetNetworkIntegrationResult, GetNetworkIntegrationOutputArgs } from "./getNetworkIntegration";
export const getNetworkIntegration: typeof import("./getNetworkIntegration").getNetworkIntegration = null as any;
export const getNetworkIntegrationOutput: typeof import("./getNetworkIntegration").getNetworkIntegrationOutput = null as any;
utilities.lazyLoad(exports, ["getNetworkIntegration","getNetworkIntegrationOutput"], () => require("./getNetworkIntegration"));

export { GetNetworkLoadBalancerArgs, GetNetworkLoadBalancerResult, GetNetworkLoadBalancerOutputArgs } from "./getNetworkLoadBalancer";
export const getNetworkLoadBalancer: typeof import("./getNetworkLoadBalancer").getNetworkLoadBalancer = null as any;
export const getNetworkLoadBalancerOutput: typeof import("./getNetworkLoadBalancer").getNetworkLoadBalancerOutput = null as any;
utilities.lazyLoad(exports, ["getNetworkLoadBalancer","getNetworkLoadBalancerOutput"], () => require("./getNetworkLoadBalancer"));

export { GetNetworkPeerArgs, GetNetworkPeerResult, GetNetworkPeerOutputArgs } from "./getNetworkPeer";
export const getNetworkPeer: typeof import("./getNetworkPeer").getNetworkPeer = null as any;
export const getNetworkPeerOutput: typeof import("./getNetworkPeer").getNetworkPeerOutput = null as any;
utilities.lazyLoad(exports, ["getNetworkPeer","getNetworkPeerOutput"], () => require("./getNetworkPeer"));

export { GetNetworkZoneArgs, GetNetworkZoneResult, GetNetworkZoneOutputArgs } from "./getNetworkZone";
export const getNetworkZone: typeof import("./getNetworkZone").getNetworkZone = null as any;
export const getNetworkZoneOutput: typeof import("./getNetworkZone").getNetworkZoneOutput = null as any;
utilities.lazyLoad(exports, ["getNetworkZone","getNetworkZoneOutput"], () => require("./getNetworkZone"));

export { GetProfileArgs, GetProfileResult, GetProfileOutputArgs } from "./getProfile";
export const getProfile: typeof import("./getProfile").getProfile = null as any;
export const getProfileOutput: typeof import("./getProfile").getProfileOutput = null as any;
utilities.lazyLoad(exports, ["getProfile","getProfileOutput"], () => require("./getProfile"));

export { GetProjectArgs, GetProjectResult, GetProjectOutputArgs } from "./getProject";
export const getProject: typeof import("./getProject").getProject = null as any;
export const getProjectOutput: typeof import("./getProject").getProjectOutput = null as any;
utilities.lazyLoad(exports, ["getProject","getProjectOutput"], () => require("./getProject"));

export { GetStorageBucketArgs, GetStorageBucketResult, GetStorageBucketOutputArgs } from "./getStorageBucket";
export const getStorageBucket: typeof import("./getStorageBucket").getStorageBucket = null as any;
export const getStorageBucketOutput: typeof import("./getStorageBucket").getStorageBucketOutput = null as any;
utilities.lazyLoad(exports, ["getStorageBucket","getStorageBucketOutput"], () => require("./getStorageBucket"));

export { GetStoragePoolArgs, GetStoragePoolResult, GetStoragePoolOutputArgs } from "./getStoragePool";
export const getStoragePool: typeof import("./getStoragePool").getStoragePool = null as any;
export const getStoragePoolOutput: typeof import("./getStoragePool").getStoragePoolOutput = null as any;
utilities.lazyLoad(exports, ["getStoragePool","getStoragePoolOutput"], () => require("./getStoragePool"));

export { GetStorageVolumeArgs, GetStorageVolumeResult, GetStorageVolumeOutputArgs } from "./getStorageVolume";
export const getStorageVolume: typeof import("./getStorageVolume").getStorageVolume = null as any;
export const getStorageVolumeOutput: typeof import("./getStorageVolume").getStorageVolumeOutput = null as any;
utilities.lazyLoad(exports, ["getStorageVolume","getStorageVolumeOutput"], () => require("./getStorageVolume"));

export { ImageArgs, ImageState } from "./image";
export type Image = import("./image").Image;
export const Image: typeof import("./image").Image = null as any;
utilities.lazyLoad(exports, ["Image"], () => require("./image"));

export { InstanceArgs, InstanceState } from "./instance";
export type Instance = import("./instance").Instance;
export const Instance: typeof import("./instance").Instance = null as any;
utilities.lazyLoad(exports, ["Instance"], () => require("./instance"));

export { InstanceSnapshotArgs, InstanceSnapshotState } from "./instanceSnapshot";
export type InstanceSnapshot = import("./instanceSnapshot").InstanceSnapshot;
export const InstanceSnapshot: typeof import("./instanceSnapshot").InstanceSnapshot = null as any;
utilities.lazyLoad(exports, ["InstanceSnapshot"], () => require("./instanceSnapshot"));

export { NetworkArgs, NetworkState } from "./network";
export type Network = import("./network").Network;
export const Network: typeof import("./network").Network = null as any;
utilities.lazyLoad(exports, ["Network"], () => require("./network"));

export { NetworkAclArgs, NetworkAclState } from "./networkAcl";
export type NetworkAcl = import("./networkAcl").NetworkAcl;
export const NetworkAcl: typeof import("./networkAcl").NetworkAcl = null as any;
utilities.lazyLoad(exports, ["NetworkAcl"], () => require("./networkAcl"));

export { NetworkAddressSetArgs, NetworkAddressSetState } from "./networkAddressSet";
export type NetworkAddressSet = import("./networkAddressSet").NetworkAddressSet;
export const NetworkAddressSet: typeof import("./networkAddressSet").NetworkAddressSet = null as any;
utilities.lazyLoad(exports, ["NetworkAddressSet"], () => require("./networkAddressSet"));

export { NetworkForwardArgs, NetworkForwardState } from "./networkForward";
export type NetworkForward = import("./networkForward").NetworkForward;
export const NetworkForward: typeof import("./networkForward").NetworkForward = null as any;
utilities.lazyLoad(exports, ["NetworkForward"], () => require("./networkForward"));

export { NetworkIntegrationArgs, NetworkIntegrationState } from "./networkIntegration";
export type NetworkIntegration = import("./networkIntegration").NetworkIntegration;
export const NetworkIntegration: typeof import("./networkIntegration").NetworkIntegration = null as any;
utilities.lazyLoad(exports, ["NetworkIntegration"], () => require("./networkIntegration"));

export { NetworkLoadBalancerArgs, NetworkLoadBalancerState } from "./networkLoadBalancer";
export type NetworkLoadBalancer = import("./networkLoadBalancer").NetworkLoadBalancer;
export const NetworkLoadBalancer: typeof import("./networkLoadBalancer").NetworkLoadBalancer = null as any;
utilities.lazyLoad(exports, ["NetworkLoadBalancer"], () => require("./networkLoadBalancer"));

export { NetworkPeerArgs, NetworkPeerState } from "./networkPeer";
export type NetworkPeer = import("./networkPeer").NetworkPeer;
export const NetworkPeer: typeof import("./networkPeer").NetworkPeer = null as any;
utilities.lazyLoad(exports, ["NetworkPeer"], () => require("./networkPeer"));

export { NetworkZoneArgs, NetworkZoneState } from "./networkZone";
export type NetworkZone = import("./networkZone").NetworkZone;
export const NetworkZone: typeof import("./networkZone").NetworkZone = null as any;
utilities.lazyLoad(exports, ["NetworkZone"], () => require("./networkZone"));

export { NetworkZoneRecordArgs, NetworkZoneRecordState } from "./networkZoneRecord";
export type NetworkZoneRecord = import("./networkZoneRecord").NetworkZoneRecord;
export const NetworkZoneRecord: typeof import("./networkZoneRecord").NetworkZoneRecord = null as any;
utilities.lazyLoad(exports, ["NetworkZoneRecord"], () => require("./networkZoneRecord"));

export { ProfileArgs, ProfileState } from "./profile";
export type Profile = import("./profile").Profile;
export const Profile: typeof import("./profile").Profile = null as any;
utilities.lazyLoad(exports, ["Profile"], () => require("./profile"));

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 * from "./provider";
import { Provider } from "./provider";

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 { StorageBucketArgs, StorageBucketState } from "./storageBucket";
export type StorageBucket = import("./storageBucket").StorageBucket;
export const StorageBucket: typeof import("./storageBucket").StorageBucket = null as any;
utilities.lazyLoad(exports, ["StorageBucket"], () => require("./storageBucket"));

export { StorageBucketKeyArgs, StorageBucketKeyState } from "./storageBucketKey";
export type StorageBucketKey = import("./storageBucketKey").StorageBucketKey;
export const StorageBucketKey: typeof import("./storageBucketKey").StorageBucketKey = null as any;
utilities.lazyLoad(exports, ["StorageBucketKey"], () => require("./storageBucketKey"));

export { StoragePoolArgs, StoragePoolState } from "./storagePool";
export type StoragePool = import("./storagePool").StoragePool;
export const StoragePool: typeof import("./storagePool").StoragePool = null as any;
utilities.lazyLoad(exports, ["StoragePool"], () => require("./storagePool"));

export { StorageVolumeArgs, StorageVolumeState } from "./storageVolume";
export type StorageVolume = import("./storageVolume").StorageVolume;
export const StorageVolume: typeof import("./storageVolume").StorageVolume = null as any;
utilities.lazyLoad(exports, ["StorageVolume"], () => require("./storageVolume"));


// 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 "incus:index/certificate:Certificate":
                return new Certificate(name, <any>undefined, { urn })
            case "incus:index/clusterGroup:ClusterGroup":
                return new ClusterGroup(name, <any>undefined, { urn })
            case "incus:index/clusterGroupMember:ClusterGroupMember":
                return new ClusterGroupMember(name, <any>undefined, { urn })
            case "incus:index/image:Image":
                return new Image(name, <any>undefined, { urn })
            case "incus:index/instance:Instance":
                return new Instance(name, <any>undefined, { urn })
            case "incus:index/instanceSnapshot:InstanceSnapshot":
                return new InstanceSnapshot(name, <any>undefined, { urn })
            case "incus:index/network:Network":
                return new Network(name, <any>undefined, { urn })
            case "incus:index/networkAcl:NetworkAcl":
                return new NetworkAcl(name, <any>undefined, { urn })
            case "incus:index/networkAddressSet:NetworkAddressSet":
                return new NetworkAddressSet(name, <any>undefined, { urn })
            case "incus:index/networkForward:NetworkForward":
                return new NetworkForward(name, <any>undefined, { urn })
            case "incus:index/networkIntegration:NetworkIntegration":
                return new NetworkIntegration(name, <any>undefined, { urn })
            case "incus:index/networkLoadBalancer:NetworkLoadBalancer":
                return new NetworkLoadBalancer(name, <any>undefined, { urn })
            case "incus:index/networkPeer:NetworkPeer":
                return new NetworkPeer(name, <any>undefined, { urn })
            case "incus:index/networkZone:NetworkZone":
                return new NetworkZone(name, <any>undefined, { urn })
            case "incus:index/networkZoneRecord:NetworkZoneRecord":
                return new NetworkZoneRecord(name, <any>undefined, { urn })
            case "incus:index/profile:Profile":
                return new Profile(name, <any>undefined, { urn })
            case "incus:index/project:Project":
                return new Project(name, <any>undefined, { urn })
            case "incus:index/server:Server":
                return new Server(name, <any>undefined, { urn })
            case "incus:index/storageBucket:StorageBucket":
                return new StorageBucket(name, <any>undefined, { urn })
            case "incus:index/storageBucketKey:StorageBucketKey":
                return new StorageBucketKey(name, <any>undefined, { urn })
            case "incus:index/storagePool:StoragePool":
                return new StoragePool(name, <any>undefined, { urn })
            case "incus:index/storageVolume:StorageVolume":
                return new StorageVolume(name, <any>undefined, { urn })
            default:
                throw new Error(`unknown resource type ${type}`);
        }
    },
};
pulumi.runtime.registerResourceModule("incus", "index/certificate", _module)
pulumi.runtime.registerResourceModule("incus", "index/clusterGroup", _module)
pulumi.runtime.registerResourceModule("incus", "index/clusterGroupMember", _module)
pulumi.runtime.registerResourceModule("incus", "index/image", _module)
pulumi.runtime.registerResourceModule("incus", "index/instance", _module)
pulumi.runtime.registerResourceModule("incus", "index/instanceSnapshot", _module)
pulumi.runtime.registerResourceModule("incus", "index/network", _module)
pulumi.runtime.registerResourceModule("incus", "index/networkAcl", _module)
pulumi.runtime.registerResourceModule("incus", "index/networkAddressSet", _module)
pulumi.runtime.registerResourceModule("incus", "index/networkForward", _module)
pulumi.runtime.registerResourceModule("incus", "index/networkIntegration", _module)
pulumi.runtime.registerResourceModule("incus", "index/networkLoadBalancer", _module)
pulumi.runtime.registerResourceModule("incus", "index/networkPeer", _module)
pulumi.runtime.registerResourceModule("incus", "index/networkZone", _module)
pulumi.runtime.registerResourceModule("incus", "index/networkZoneRecord", _module)
pulumi.runtime.registerResourceModule("incus", "index/profile", _module)
pulumi.runtime.registerResourceModule("incus", "index/project", _module)
pulumi.runtime.registerResourceModule("incus", "index/server", _module)
pulumi.runtime.registerResourceModule("incus", "index/storageBucket", _module)
pulumi.runtime.registerResourceModule("incus", "index/storageBucketKey", _module)
pulumi.runtime.registerResourceModule("incus", "index/storagePool", _module)
pulumi.runtime.registerResourceModule("incus", "index/storageVolume", _module)
pulumi.runtime.registerResourcePackage("incus", {
    version: utilities.getVersion(),
    constructProvider: (name: string, type: string, urn: string): pulumi.ProviderResource => {
        if (type !== "pulumi:providers:incus") {
            throw new Error(`unknown provider type ${type}`);
        }
        return new Provider(name, <any>undefined, { urn });
    },
});