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

export { ConnectionConfigArgs, ConnectionConfigState } from "./connectionConfig";
export type ConnectionConfig = import("./connectionConfig").ConnectionConfig;
export const ConnectionConfig: typeof import("./connectionConfig").ConnectionConfig = null as any;
utilities.lazyLoad(exports, ["ConnectionConfig"], () => require("./connectionConfig"));

export { ConnectorArgs, ConnectorState } from "./connector";
export type Connector = import("./connector").Connector;
export const Connector: typeof import("./connector").Connector = null as any;
utilities.lazyLoad(exports, ["Connector"], () => require("./connector"));

export { ConnectorCertificatesArgs, ConnectorCertificatesState } from "./connectorCertificates";
export type ConnectorCertificates = import("./connectorCertificates").ConnectorCertificates;
export const ConnectorCertificates: typeof import("./connectorCertificates").ConnectorCertificates = null as any;
utilities.lazyLoad(exports, ["ConnectorCertificates"], () => require("./connectorCertificates"));

export { ConnectorFingerprintsArgs, ConnectorFingerprintsState } from "./connectorFingerprints";
export type ConnectorFingerprints = import("./connectorFingerprints").ConnectorFingerprints;
export const ConnectorFingerprints: typeof import("./connectorFingerprints").ConnectorFingerprints = null as any;
utilities.lazyLoad(exports, ["ConnectorFingerprints"], () => require("./connectorFingerprints"));

export { ConnectorScheduleArgs, ConnectorScheduleState } from "./connectorSchedule";
export type ConnectorSchedule = import("./connectorSchedule").ConnectorSchedule;
export const ConnectorSchedule: typeof import("./connectorSchedule").ConnectorSchedule = null as any;
utilities.lazyLoad(exports, ["ConnectorSchedule"], () => require("./connectorSchedule"));

export { ConnectorSchemaConfigArgs, ConnectorSchemaConfigState } from "./connectorSchemaConfig";
export type ConnectorSchemaConfig = import("./connectorSchemaConfig").ConnectorSchemaConfig;
export const ConnectorSchemaConfig: typeof import("./connectorSchemaConfig").ConnectorSchemaConfig = null as any;
utilities.lazyLoad(exports, ["ConnectorSchemaConfig"], () => require("./connectorSchemaConfig"));

export { DestinationArgs, DestinationState } from "./destination";
export type Destination = import("./destination").Destination;
export const Destination: typeof import("./destination").Destination = null as any;
utilities.lazyLoad(exports, ["Destination"], () => require("./destination"));

export { DestinationCertificatesArgs, DestinationCertificatesState } from "./destinationCertificates";
export type DestinationCertificates = import("./destinationCertificates").DestinationCertificates;
export const DestinationCertificates: typeof import("./destinationCertificates").DestinationCertificates = null as any;
utilities.lazyLoad(exports, ["DestinationCertificates"], () => require("./destinationCertificates"));

export { DestinationFingerprintsArgs, DestinationFingerprintsState } from "./destinationFingerprints";
export type DestinationFingerprints = import("./destinationFingerprints").DestinationFingerprints;
export const DestinationFingerprints: typeof import("./destinationFingerprints").DestinationFingerprints = null as any;
utilities.lazyLoad(exports, ["DestinationFingerprints"], () => require("./destinationFingerprints"));

export { ExternalLoggingArgs, ExternalLoggingState } from "./externalLogging";
export type ExternalLogging = import("./externalLogging").ExternalLogging;
export const ExternalLogging: typeof import("./externalLogging").ExternalLogging = null as any;
utilities.lazyLoad(exports, ["ExternalLogging"], () => require("./externalLogging"));

export { GetConnectionArgs, GetConnectionResult, GetConnectionOutputArgs } from "./getConnection";
export const getConnection: typeof import("./getConnection").getConnection = null as any;
export const getConnectionOutput: typeof import("./getConnection").getConnectionOutput = null as any;
utilities.lazyLoad(exports, ["getConnection","getConnectionOutput"], () => require("./getConnection"));

export { GetConnectionCertificatesArgs, GetConnectionCertificatesResult, GetConnectionCertificatesOutputArgs } from "./getConnectionCertificates";
export const getConnectionCertificates: typeof import("./getConnectionCertificates").getConnectionCertificates = null as any;
export const getConnectionCertificatesOutput: typeof import("./getConnectionCertificates").getConnectionCertificatesOutput = null as any;
utilities.lazyLoad(exports, ["getConnectionCertificates","getConnectionCertificatesOutput"], () => require("./getConnectionCertificates"));

export { GetConnectionFingerprintsArgs, GetConnectionFingerprintsResult, GetConnectionFingerprintsOutputArgs } from "./getConnectionFingerprints";
export const getConnectionFingerprints: typeof import("./getConnectionFingerprints").getConnectionFingerprints = null as any;
export const getConnectionFingerprintsOutput: typeof import("./getConnectionFingerprints").getConnectionFingerprintsOutput = null as any;
utilities.lazyLoad(exports, ["getConnectionFingerprints","getConnectionFingerprintsOutput"], () => require("./getConnectionFingerprints"));

export { GetConnectionsArgs, GetConnectionsResult, GetConnectionsOutputArgs } from "./getConnections";
export const getConnections: typeof import("./getConnections").getConnections = null as any;
export const getConnectionsOutput: typeof import("./getConnections").getConnectionsOutput = null as any;
utilities.lazyLoad(exports, ["getConnections","getConnectionsOutput"], () => require("./getConnections"));

export { GetConnectorArgs, GetConnectorResult, GetConnectorOutputArgs } from "./getConnector";
export const getConnector: typeof import("./getConnector").getConnector = null as any;
export const getConnectorOutput: typeof import("./getConnector").getConnectorOutput = null as any;
utilities.lazyLoad(exports, ["getConnector","getConnectorOutput"], () => require("./getConnector"));

export { GetConnectorCertificatesArgs, GetConnectorCertificatesResult, GetConnectorCertificatesOutputArgs } from "./getConnectorCertificates";
export const getConnectorCertificates: typeof import("./getConnectorCertificates").getConnectorCertificates = null as any;
export const getConnectorCertificatesOutput: typeof import("./getConnectorCertificates").getConnectorCertificatesOutput = null as any;
utilities.lazyLoad(exports, ["getConnectorCertificates","getConnectorCertificatesOutput"], () => require("./getConnectorCertificates"));

export { GetConnectorFingerprintsArgs, GetConnectorFingerprintsResult, GetConnectorFingerprintsOutputArgs } from "./getConnectorFingerprints";
export const getConnectorFingerprints: typeof import("./getConnectorFingerprints").getConnectorFingerprints = null as any;
export const getConnectorFingerprintsOutput: typeof import("./getConnectorFingerprints").getConnectorFingerprintsOutput = null as any;
utilities.lazyLoad(exports, ["getConnectorFingerprints","getConnectorFingerprintsOutput"], () => require("./getConnectorFingerprints"));

export { GetConnectorsArgs, GetConnectorsResult, GetConnectorsOutputArgs } from "./getConnectors";
export const getConnectors: typeof import("./getConnectors").getConnectors = null as any;
export const getConnectorsOutput: typeof import("./getConnectors").getConnectorsOutput = null as any;
utilities.lazyLoad(exports, ["getConnectors","getConnectorsOutput"], () => require("./getConnectors"));

export { GetConnectorsMetadataArgs, GetConnectorsMetadataResult, GetConnectorsMetadataOutputArgs } from "./getConnectorsMetadata";
export const getConnectorsMetadata: typeof import("./getConnectorsMetadata").getConnectorsMetadata = null as any;
export const getConnectorsMetadataOutput: typeof import("./getConnectorsMetadata").getConnectorsMetadataOutput = null as any;
utilities.lazyLoad(exports, ["getConnectorsMetadata","getConnectorsMetadataOutput"], () => require("./getConnectorsMetadata"));

export { GetDestinationArgs, GetDestinationResult, GetDestinationOutputArgs } from "./getDestination";
export const getDestination: typeof import("./getDestination").getDestination = null as any;
export const getDestinationOutput: typeof import("./getDestination").getDestinationOutput = null as any;
utilities.lazyLoad(exports, ["getDestination","getDestinationOutput"], () => require("./getDestination"));

export { GetDestinationCertificatesArgs, GetDestinationCertificatesResult, GetDestinationCertificatesOutputArgs } from "./getDestinationCertificates";
export const getDestinationCertificates: typeof import("./getDestinationCertificates").getDestinationCertificates = null as any;
export const getDestinationCertificatesOutput: typeof import("./getDestinationCertificates").getDestinationCertificatesOutput = null as any;
utilities.lazyLoad(exports, ["getDestinationCertificates","getDestinationCertificatesOutput"], () => require("./getDestinationCertificates"));

export { GetDestinationFingerprintsArgs, GetDestinationFingerprintsResult, GetDestinationFingerprintsOutputArgs } from "./getDestinationFingerprints";
export const getDestinationFingerprints: typeof import("./getDestinationFingerprints").getDestinationFingerprints = null as any;
export const getDestinationFingerprintsOutput: typeof import("./getDestinationFingerprints").getDestinationFingerprintsOutput = null as any;
utilities.lazyLoad(exports, ["getDestinationFingerprints","getDestinationFingerprintsOutput"], () => require("./getDestinationFingerprints"));

export { GetDestinationsArgs, GetDestinationsResult, GetDestinationsOutputArgs } from "./getDestinations";
export const getDestinations: typeof import("./getDestinations").getDestinations = null as any;
export const getDestinationsOutput: typeof import("./getDestinations").getDestinationsOutput = null as any;
utilities.lazyLoad(exports, ["getDestinations","getDestinationsOutput"], () => require("./getDestinations"));

export { GetExternalLoggingArgs, GetExternalLoggingResult, GetExternalLoggingOutputArgs } from "./getExternalLogging";
export const getExternalLogging: typeof import("./getExternalLogging").getExternalLogging = null as any;
export const getExternalLoggingOutput: typeof import("./getExternalLogging").getExternalLoggingOutput = null as any;
utilities.lazyLoad(exports, ["getExternalLogging","getExternalLoggingOutput"], () => require("./getExternalLogging"));

export { GetExternalLogsArgs, GetExternalLogsResult, GetExternalLogsOutputArgs } from "./getExternalLogs";
export const getExternalLogs: typeof import("./getExternalLogs").getExternalLogs = null as any;
export const getExternalLogsOutput: typeof import("./getExternalLogs").getExternalLogsOutput = null as any;
utilities.lazyLoad(exports, ["getExternalLogs","getExternalLogsOutput"], () => require("./getExternalLogs"));

export { GetGroupArgs, GetGroupResult, GetGroupOutputArgs } from "./getGroup";
export const getGroup: typeof import("./getGroup").getGroup = null as any;
export const getGroupOutput: typeof import("./getGroup").getGroupOutput = null as any;
utilities.lazyLoad(exports, ["getGroup","getGroupOutput"], () => require("./getGroup"));

export { GetGroupConnectionsArgs, GetGroupConnectionsResult, GetGroupConnectionsOutputArgs } from "./getGroupConnections";
export const getGroupConnections: typeof import("./getGroupConnections").getGroupConnections = null as any;
export const getGroupConnectionsOutput: typeof import("./getGroupConnections").getGroupConnectionsOutput = null as any;
utilities.lazyLoad(exports, ["getGroupConnections","getGroupConnectionsOutput"], () => require("./getGroupConnections"));

export { GetGroupConnectorsArgs, GetGroupConnectorsResult, GetGroupConnectorsOutputArgs } from "./getGroupConnectors";
export const getGroupConnectors: typeof import("./getGroupConnectors").getGroupConnectors = null as any;
export const getGroupConnectorsOutput: typeof import("./getGroupConnectors").getGroupConnectorsOutput = null as any;
utilities.lazyLoad(exports, ["getGroupConnectors","getGroupConnectorsOutput"], () => require("./getGroupConnectors"));

export { GetGroupServiceAccountArgs, GetGroupServiceAccountResult, GetGroupServiceAccountOutputArgs } from "./getGroupServiceAccount";
export const getGroupServiceAccount: typeof import("./getGroupServiceAccount").getGroupServiceAccount = null as any;
export const getGroupServiceAccountOutput: typeof import("./getGroupServiceAccount").getGroupServiceAccountOutput = null as any;
utilities.lazyLoad(exports, ["getGroupServiceAccount","getGroupServiceAccountOutput"], () => require("./getGroupServiceAccount"));

export { GetGroupSshKeyArgs, GetGroupSshKeyResult, GetGroupSshKeyOutputArgs } from "./getGroupSshKey";
export const getGroupSshKey: typeof import("./getGroupSshKey").getGroupSshKey = null as any;
export const getGroupSshKeyOutput: typeof import("./getGroupSshKey").getGroupSshKeyOutput = null as any;
utilities.lazyLoad(exports, ["getGroupSshKey","getGroupSshKeyOutput"], () => require("./getGroupSshKey"));

export { GetGroupUsersArgs, GetGroupUsersResult, GetGroupUsersOutputArgs } from "./getGroupUsers";
export const getGroupUsers: typeof import("./getGroupUsers").getGroupUsers = null as any;
export const getGroupUsersOutput: typeof import("./getGroupUsers").getGroupUsersOutput = null as any;
utilities.lazyLoad(exports, ["getGroupUsers","getGroupUsersOutput"], () => require("./getGroupUsers"));

export { GetGroupsArgs, GetGroupsResult, GetGroupsOutputArgs } from "./getGroups";
export const getGroups: typeof import("./getGroups").getGroups = null as any;
export const getGroupsOutput: typeof import("./getGroups").getGroupsOutput = null as any;
utilities.lazyLoad(exports, ["getGroups","getGroupsOutput"], () => require("./getGroups"));

export { GetHybridDeploymentAgentArgs, GetHybridDeploymentAgentResult, GetHybridDeploymentAgentOutputArgs } from "./getHybridDeploymentAgent";
export const getHybridDeploymentAgent: typeof import("./getHybridDeploymentAgent").getHybridDeploymentAgent = null as any;
export const getHybridDeploymentAgentOutput: typeof import("./getHybridDeploymentAgent").getHybridDeploymentAgentOutput = null as any;
utilities.lazyLoad(exports, ["getHybridDeploymentAgent","getHybridDeploymentAgentOutput"], () => require("./getHybridDeploymentAgent"));

export { GetHybridDeploymentAgentsResult } from "./getHybridDeploymentAgents";
export const getHybridDeploymentAgents: typeof import("./getHybridDeploymentAgents").getHybridDeploymentAgents = null as any;
export const getHybridDeploymentAgentsOutput: typeof import("./getHybridDeploymentAgents").getHybridDeploymentAgentsOutput = null as any;
utilities.lazyLoad(exports, ["getHybridDeploymentAgents","getHybridDeploymentAgentsOutput"], () => require("./getHybridDeploymentAgents"));

export { GetPrivateLinkArgs, GetPrivateLinkResult, GetPrivateLinkOutputArgs } from "./getPrivateLink";
export const getPrivateLink: typeof import("./getPrivateLink").getPrivateLink = null as any;
export const getPrivateLinkOutput: typeof import("./getPrivateLink").getPrivateLinkOutput = null as any;
utilities.lazyLoad(exports, ["getPrivateLink","getPrivateLinkOutput"], () => require("./getPrivateLink"));

export { GetPrivateLinksArgs, GetPrivateLinksResult, GetPrivateLinksOutputArgs } from "./getPrivateLinks";
export const getPrivateLinks: typeof import("./getPrivateLinks").getPrivateLinks = null as any;
export const getPrivateLinksOutput: typeof import("./getPrivateLinks").getPrivateLinksOutput = null as any;
utilities.lazyLoad(exports, ["getPrivateLinks","getPrivateLinksOutput"], () => require("./getPrivateLinks"));

export { GetProxyAgentArgs, GetProxyAgentResult, GetProxyAgentOutputArgs } from "./getProxyAgent";
export const getProxyAgent: typeof import("./getProxyAgent").getProxyAgent = null as any;
export const getProxyAgentOutput: typeof import("./getProxyAgent").getProxyAgentOutput = null as any;
utilities.lazyLoad(exports, ["getProxyAgent","getProxyAgentOutput"], () => require("./getProxyAgent"));

export { GetProxyAgentsArgs, GetProxyAgentsResult, GetProxyAgentsOutputArgs } from "./getProxyAgents";
export const getProxyAgents: typeof import("./getProxyAgents").getProxyAgents = null as any;
export const getProxyAgentsOutput: typeof import("./getProxyAgents").getProxyAgentsOutput = null as any;
utilities.lazyLoad(exports, ["getProxyAgents","getProxyAgentsOutput"], () => require("./getProxyAgents"));

export { GetQuickstartPackageArgs, GetQuickstartPackageResult, GetQuickstartPackageOutputArgs } from "./getQuickstartPackage";
export const getQuickstartPackage: typeof import("./getQuickstartPackage").getQuickstartPackage = null as any;
export const getQuickstartPackageOutput: typeof import("./getQuickstartPackage").getQuickstartPackageOutput = null as any;
utilities.lazyLoad(exports, ["getQuickstartPackage","getQuickstartPackageOutput"], () => require("./getQuickstartPackage"));

export { GetQuickstartPackagesArgs, GetQuickstartPackagesResult, GetQuickstartPackagesOutputArgs } from "./getQuickstartPackages";
export const getQuickstartPackages: typeof import("./getQuickstartPackages").getQuickstartPackages = null as any;
export const getQuickstartPackagesOutput: typeof import("./getQuickstartPackages").getQuickstartPackagesOutput = null as any;
utilities.lazyLoad(exports, ["getQuickstartPackages","getQuickstartPackagesOutput"], () => require("./getQuickstartPackages"));

export { GetRolesArgs, GetRolesResult, GetRolesOutputArgs } from "./getRoles";
export const getRoles: typeof import("./getRoles").getRoles = null as any;
export const getRolesOutput: typeof import("./getRoles").getRolesOutput = null as any;
utilities.lazyLoad(exports, ["getRoles","getRolesOutput"], () => require("./getRoles"));

export { GetTeamArgs, GetTeamResult, GetTeamOutputArgs } from "./getTeam";
export const getTeam: typeof import("./getTeam").getTeam = null as any;
export const getTeamOutput: typeof import("./getTeam").getTeamOutput = null as any;
utilities.lazyLoad(exports, ["getTeam","getTeamOutput"], () => require("./getTeam"));

export { GetTeamConnectionMembershipsArgs, GetTeamConnectionMembershipsResult, GetTeamConnectionMembershipsOutputArgs } from "./getTeamConnectionMemberships";
export const getTeamConnectionMemberships: typeof import("./getTeamConnectionMemberships").getTeamConnectionMemberships = null as any;
export const getTeamConnectionMembershipsOutput: typeof import("./getTeamConnectionMemberships").getTeamConnectionMembershipsOutput = null as any;
utilities.lazyLoad(exports, ["getTeamConnectionMemberships","getTeamConnectionMembershipsOutput"], () => require("./getTeamConnectionMemberships"));

export { GetTeamConnectorMembershipsArgs, GetTeamConnectorMembershipsResult, GetTeamConnectorMembershipsOutputArgs } from "./getTeamConnectorMemberships";
export const getTeamConnectorMemberships: typeof import("./getTeamConnectorMemberships").getTeamConnectorMemberships = null as any;
export const getTeamConnectorMembershipsOutput: typeof import("./getTeamConnectorMemberships").getTeamConnectorMembershipsOutput = null as any;
utilities.lazyLoad(exports, ["getTeamConnectorMemberships","getTeamConnectorMembershipsOutput"], () => require("./getTeamConnectorMemberships"));

export { GetTeamGroupMembershipsArgs, GetTeamGroupMembershipsResult, GetTeamGroupMembershipsOutputArgs } from "./getTeamGroupMemberships";
export const getTeamGroupMemberships: typeof import("./getTeamGroupMemberships").getTeamGroupMemberships = null as any;
export const getTeamGroupMembershipsOutput: typeof import("./getTeamGroupMemberships").getTeamGroupMembershipsOutput = null as any;
utilities.lazyLoad(exports, ["getTeamGroupMemberships","getTeamGroupMembershipsOutput"], () => require("./getTeamGroupMemberships"));

export { GetTeamUserMembershipsArgs, GetTeamUserMembershipsResult, GetTeamUserMembershipsOutputArgs } from "./getTeamUserMemberships";
export const getTeamUserMemberships: typeof import("./getTeamUserMemberships").getTeamUserMemberships = null as any;
export const getTeamUserMembershipsOutput: typeof import("./getTeamUserMemberships").getTeamUserMembershipsOutput = null as any;
utilities.lazyLoad(exports, ["getTeamUserMemberships","getTeamUserMembershipsOutput"], () => require("./getTeamUserMemberships"));

export { GetTeamsArgs, GetTeamsResult, GetTeamsOutputArgs } from "./getTeams";
export const getTeams: typeof import("./getTeams").getTeams = null as any;
export const getTeamsOutput: typeof import("./getTeams").getTeamsOutput = null as any;
utilities.lazyLoad(exports, ["getTeams","getTeamsOutput"], () => require("./getTeams"));

export { GetTransformationArgs, GetTransformationResult, GetTransformationOutputArgs } from "./getTransformation";
export const getTransformation: typeof import("./getTransformation").getTransformation = null as any;
export const getTransformationOutput: typeof import("./getTransformation").getTransformationOutput = null as any;
utilities.lazyLoad(exports, ["getTransformation","getTransformationOutput"], () => require("./getTransformation"));

export { GetTransformationProjectArgs, GetTransformationProjectResult, GetTransformationProjectOutputArgs } from "./getTransformationProject";
export const getTransformationProject: typeof import("./getTransformationProject").getTransformationProject = null as any;
export const getTransformationProjectOutput: typeof import("./getTransformationProject").getTransformationProjectOutput = null as any;
utilities.lazyLoad(exports, ["getTransformationProject","getTransformationProjectOutput"], () => require("./getTransformationProject"));

export { GetTransformationProjectsResult } from "./getTransformationProjects";
export const getTransformationProjects: typeof import("./getTransformationProjects").getTransformationProjects = null as any;
export const getTransformationProjectsOutput: typeof import("./getTransformationProjects").getTransformationProjectsOutput = null as any;
utilities.lazyLoad(exports, ["getTransformationProjects","getTransformationProjectsOutput"], () => require("./getTransformationProjects"));

export { GetTransformationsArgs, GetTransformationsResult, GetTransformationsOutputArgs } from "./getTransformations";
export const getTransformations: typeof import("./getTransformations").getTransformations = null as any;
export const getTransformationsOutput: typeof import("./getTransformations").getTransformationsOutput = null as any;
utilities.lazyLoad(exports, ["getTransformations","getTransformationsOutput"], () => require("./getTransformations"));

export { GetUserArgs, GetUserResult, GetUserOutputArgs } from "./getUser";
export const getUser: typeof import("./getUser").getUser = null as any;
export const getUserOutput: typeof import("./getUser").getUserOutput = null as any;
utilities.lazyLoad(exports, ["getUser","getUserOutput"], () => require("./getUser"));

export { GetUserConnectionMembershipsArgs, GetUserConnectionMembershipsResult, GetUserConnectionMembershipsOutputArgs } from "./getUserConnectionMemberships";
export const getUserConnectionMemberships: typeof import("./getUserConnectionMemberships").getUserConnectionMemberships = null as any;
export const getUserConnectionMembershipsOutput: typeof import("./getUserConnectionMemberships").getUserConnectionMembershipsOutput = null as any;
utilities.lazyLoad(exports, ["getUserConnectionMemberships","getUserConnectionMembershipsOutput"], () => require("./getUserConnectionMemberships"));

export { GetUserConnectorMembershipsArgs, GetUserConnectorMembershipsResult, GetUserConnectorMembershipsOutputArgs } from "./getUserConnectorMemberships";
export const getUserConnectorMemberships: typeof import("./getUserConnectorMemberships").getUserConnectorMemberships = null as any;
export const getUserConnectorMembershipsOutput: typeof import("./getUserConnectorMemberships").getUserConnectorMembershipsOutput = null as any;
utilities.lazyLoad(exports, ["getUserConnectorMemberships","getUserConnectorMembershipsOutput"], () => require("./getUserConnectorMemberships"));

export { GetUserGroupMembershipsArgs, GetUserGroupMembershipsResult, GetUserGroupMembershipsOutputArgs } from "./getUserGroupMemberships";
export const getUserGroupMemberships: typeof import("./getUserGroupMemberships").getUserGroupMemberships = null as any;
export const getUserGroupMembershipsOutput: typeof import("./getUserGroupMemberships").getUserGroupMembershipsOutput = null as any;
utilities.lazyLoad(exports, ["getUserGroupMemberships","getUserGroupMembershipsOutput"], () => require("./getUserGroupMemberships"));

export { GetUsersArgs, GetUsersResult, GetUsersOutputArgs } from "./getUsers";
export const getUsers: typeof import("./getUsers").getUsers = null as any;
export const getUsersOutput: typeof import("./getUsers").getUsersOutput = null as any;
utilities.lazyLoad(exports, ["getUsers","getUsersOutput"], () => require("./getUsers"));

export { GetWebhookArgs, GetWebhookResult, GetWebhookOutputArgs } from "./getWebhook";
export const getWebhook: typeof import("./getWebhook").getWebhook = null as any;
export const getWebhookOutput: typeof import("./getWebhook").getWebhookOutput = null as any;
utilities.lazyLoad(exports, ["getWebhook","getWebhookOutput"], () => require("./getWebhook"));

export { GetWebhooksResult } from "./getWebhooks";
export const getWebhooks: typeof import("./getWebhooks").getWebhooks = null as any;
export const getWebhooksOutput: typeof import("./getWebhooks").getWebhooksOutput = null as any;
utilities.lazyLoad(exports, ["getWebhooks","getWebhooksOutput"], () => require("./getWebhooks"));

export { GroupArgs, GroupState } from "./group";
export type Group = import("./group").Group;
export const Group: typeof import("./group").Group = null as any;
utilities.lazyLoad(exports, ["Group"], () => require("./group"));

export { GroupUsersArgs, GroupUsersState } from "./groupUsers";
export type GroupUsers = import("./groupUsers").GroupUsers;
export const GroupUsers: typeof import("./groupUsers").GroupUsers = null as any;
utilities.lazyLoad(exports, ["GroupUsers"], () => require("./groupUsers"));

export { HybridDeploymentAgentArgs, HybridDeploymentAgentState } from "./hybridDeploymentAgent";
export type HybridDeploymentAgent = import("./hybridDeploymentAgent").HybridDeploymentAgent;
export const HybridDeploymentAgent: typeof import("./hybridDeploymentAgent").HybridDeploymentAgent = null as any;
utilities.lazyLoad(exports, ["HybridDeploymentAgent"], () => require("./hybridDeploymentAgent"));

export { PrivateLinkArgs, PrivateLinkState } from "./privateLink";
export type PrivateLink = import("./privateLink").PrivateLink;
export const PrivateLink: typeof import("./privateLink").PrivateLink = null as any;
utilities.lazyLoad(exports, ["PrivateLink"], () => require("./privateLink"));

export * from "./provider";
import { Provider } from "./provider";

export { ProxyAgentArgs, ProxyAgentState } from "./proxyAgent";
export type ProxyAgent = import("./proxyAgent").ProxyAgent;
export const ProxyAgent: typeof import("./proxyAgent").ProxyAgent = null as any;
utilities.lazyLoad(exports, ["ProxyAgent"], () => require("./proxyAgent"));

export { TeamArgs, TeamState } from "./team";
export type Team = import("./team").Team;
export const Team: typeof import("./team").Team = null as any;
utilities.lazyLoad(exports, ["Team"], () => require("./team"));

export { TeamConnectorMembershipArgs, TeamConnectorMembershipState } from "./teamConnectorMembership";
export type TeamConnectorMembership = import("./teamConnectorMembership").TeamConnectorMembership;
export const TeamConnectorMembership: typeof import("./teamConnectorMembership").TeamConnectorMembership = null as any;
utilities.lazyLoad(exports, ["TeamConnectorMembership"], () => require("./teamConnectorMembership"));

export { TeamGroupMembershipArgs, TeamGroupMembershipState } from "./teamGroupMembership";
export type TeamGroupMembership = import("./teamGroupMembership").TeamGroupMembership;
export const TeamGroupMembership: typeof import("./teamGroupMembership").TeamGroupMembership = null as any;
utilities.lazyLoad(exports, ["TeamGroupMembership"], () => require("./teamGroupMembership"));

export { TeamUserMembershipArgs, TeamUserMembershipState } from "./teamUserMembership";
export type TeamUserMembership = import("./teamUserMembership").TeamUserMembership;
export const TeamUserMembership: typeof import("./teamUserMembership").TeamUserMembership = null as any;
utilities.lazyLoad(exports, ["TeamUserMembership"], () => require("./teamUserMembership"));

export { TransformationArgs, TransformationState } from "./transformation";
export type Transformation = import("./transformation").Transformation;
export const Transformation: typeof import("./transformation").Transformation = null as any;
utilities.lazyLoad(exports, ["Transformation"], () => require("./transformation"));

export { TransformationProjectArgs, TransformationProjectState } from "./transformationProject";
export type TransformationProject = import("./transformationProject").TransformationProject;
export const TransformationProject: typeof import("./transformationProject").TransformationProject = null as any;
utilities.lazyLoad(exports, ["TransformationProject"], () => require("./transformationProject"));

export { UserArgs, UserState } from "./user";
export type User = import("./user").User;
export const User: typeof import("./user").User = null as any;
utilities.lazyLoad(exports, ["User"], () => require("./user"));

export { UserConnectorMembershipArgs, UserConnectorMembershipState } from "./userConnectorMembership";
export type UserConnectorMembership = import("./userConnectorMembership").UserConnectorMembership;
export const UserConnectorMembership: typeof import("./userConnectorMembership").UserConnectorMembership = null as any;
utilities.lazyLoad(exports, ["UserConnectorMembership"], () => require("./userConnectorMembership"));

export { UserGroupMembershipArgs, UserGroupMembershipState } from "./userGroupMembership";
export type UserGroupMembership = import("./userGroupMembership").UserGroupMembership;
export const UserGroupMembership: typeof import("./userGroupMembership").UserGroupMembership = null as any;
utilities.lazyLoad(exports, ["UserGroupMembership"], () => require("./userGroupMembership"));

export { WebhookArgs, WebhookState } from "./webhook";
export type Webhook = import("./webhook").Webhook;
export const Webhook: typeof import("./webhook").Webhook = null as any;
utilities.lazyLoad(exports, ["Webhook"], () => require("./webhook"));


// 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 "fivetran:index/connection:Connection":
                return new Connection(name, <any>undefined, { urn })
            case "fivetran:index/connectionConfig:ConnectionConfig":
                return new ConnectionConfig(name, <any>undefined, { urn })
            case "fivetran:index/connector:Connector":
                return new Connector(name, <any>undefined, { urn })
            case "fivetran:index/connectorCertificates:ConnectorCertificates":
                return new ConnectorCertificates(name, <any>undefined, { urn })
            case "fivetran:index/connectorFingerprints:ConnectorFingerprints":
                return new ConnectorFingerprints(name, <any>undefined, { urn })
            case "fivetran:index/connectorSchedule:ConnectorSchedule":
                return new ConnectorSchedule(name, <any>undefined, { urn })
            case "fivetran:index/connectorSchemaConfig:ConnectorSchemaConfig":
                return new ConnectorSchemaConfig(name, <any>undefined, { urn })
            case "fivetran:index/destination:Destination":
                return new Destination(name, <any>undefined, { urn })
            case "fivetran:index/destinationCertificates:DestinationCertificates":
                return new DestinationCertificates(name, <any>undefined, { urn })
            case "fivetran:index/destinationFingerprints:DestinationFingerprints":
                return new DestinationFingerprints(name, <any>undefined, { urn })
            case "fivetran:index/externalLogging:ExternalLogging":
                return new ExternalLogging(name, <any>undefined, { urn })
            case "fivetran:index/group:Group":
                return new Group(name, <any>undefined, { urn })
            case "fivetran:index/groupUsers:GroupUsers":
                return new GroupUsers(name, <any>undefined, { urn })
            case "fivetran:index/hybridDeploymentAgent:HybridDeploymentAgent":
                return new HybridDeploymentAgent(name, <any>undefined, { urn })
            case "fivetran:index/privateLink:PrivateLink":
                return new PrivateLink(name, <any>undefined, { urn })
            case "fivetran:index/proxyAgent:ProxyAgent":
                return new ProxyAgent(name, <any>undefined, { urn })
            case "fivetran:index/team:Team":
                return new Team(name, <any>undefined, { urn })
            case "fivetran:index/teamConnectorMembership:TeamConnectorMembership":
                return new TeamConnectorMembership(name, <any>undefined, { urn })
            case "fivetran:index/teamGroupMembership:TeamGroupMembership":
                return new TeamGroupMembership(name, <any>undefined, { urn })
            case "fivetran:index/teamUserMembership:TeamUserMembership":
                return new TeamUserMembership(name, <any>undefined, { urn })
            case "fivetran:index/transformation:Transformation":
                return new Transformation(name, <any>undefined, { urn })
            case "fivetran:index/transformationProject:TransformationProject":
                return new TransformationProject(name, <any>undefined, { urn })
            case "fivetran:index/user:User":
                return new User(name, <any>undefined, { urn })
            case "fivetran:index/userConnectorMembership:UserConnectorMembership":
                return new UserConnectorMembership(name, <any>undefined, { urn })
            case "fivetran:index/userGroupMembership:UserGroupMembership":
                return new UserGroupMembership(name, <any>undefined, { urn })
            case "fivetran:index/webhook:Webhook":
                return new Webhook(name, <any>undefined, { urn })
            default:
                throw new Error(`unknown resource type ${type}`);
        }
    },
};
pulumi.runtime.registerResourceModule("fivetran", "index/connection", _module)
pulumi.runtime.registerResourceModule("fivetran", "index/connectionConfig", _module)
pulumi.runtime.registerResourceModule("fivetran", "index/connector", _module)
pulumi.runtime.registerResourceModule("fivetran", "index/connectorCertificates", _module)
pulumi.runtime.registerResourceModule("fivetran", "index/connectorFingerprints", _module)
pulumi.runtime.registerResourceModule("fivetran", "index/connectorSchedule", _module)
pulumi.runtime.registerResourceModule("fivetran", "index/connectorSchemaConfig", _module)
pulumi.runtime.registerResourceModule("fivetran", "index/destination", _module)
pulumi.runtime.registerResourceModule("fivetran", "index/destinationCertificates", _module)
pulumi.runtime.registerResourceModule("fivetran", "index/destinationFingerprints", _module)
pulumi.runtime.registerResourceModule("fivetran", "index/externalLogging", _module)
pulumi.runtime.registerResourceModule("fivetran", "index/group", _module)
pulumi.runtime.registerResourceModule("fivetran", "index/groupUsers", _module)
pulumi.runtime.registerResourceModule("fivetran", "index/hybridDeploymentAgent", _module)
pulumi.runtime.registerResourceModule("fivetran", "index/privateLink", _module)
pulumi.runtime.registerResourceModule("fivetran", "index/proxyAgent", _module)
pulumi.runtime.registerResourceModule("fivetran", "index/team", _module)
pulumi.runtime.registerResourceModule("fivetran", "index/teamConnectorMembership", _module)
pulumi.runtime.registerResourceModule("fivetran", "index/teamGroupMembership", _module)
pulumi.runtime.registerResourceModule("fivetran", "index/teamUserMembership", _module)
pulumi.runtime.registerResourceModule("fivetran", "index/transformation", _module)
pulumi.runtime.registerResourceModule("fivetran", "index/transformationProject", _module)
pulumi.runtime.registerResourceModule("fivetran", "index/user", _module)
pulumi.runtime.registerResourceModule("fivetran", "index/userConnectorMembership", _module)
pulumi.runtime.registerResourceModule("fivetran", "index/userGroupMembership", _module)
pulumi.runtime.registerResourceModule("fivetran", "index/webhook", _module)
pulumi.runtime.registerResourcePackage("fivetran", {
    version: utilities.getVersion(),
    constructProvider: (name: string, type: string, urn: string): pulumi.ProviderResource => {
        if (type !== "pulumi:providers:fivetran") {
            throw new Error(`unknown provider type ${type}`);
        }
        return new Provider(name, <any>undefined, { urn });
    },
});