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 });
	},
});