@lansweeper/data-platform-outbound-grpc 0.4.0 → 0.4.2

package/gen-proto/outbound_pb.d.ts

@@ -816,6 +816,11 @@ export class Asset extends jspb.Message {
     getOffice365Organization(): Office365Organization | undefined;
     setOffice365Organization(value?: Office365Organization): Asset;
 
+    hasCitrix(): boolean;
+    clearCitrix(): void;
+    getCitrix(): Citrix | undefined;
+    setCitrix(value?: Citrix): Asset;
+
     serializeBinary(): Uint8Array;
     toObject(includeInstance?: boolean): Asset.AsObject;
     static toObject(includeInstance: boolean, msg: Asset): Asset.AsObject;
@@ -865,6 +870,7 @@ export namespace Asset {
         intuneDevice?: IntuneDevice.AsObject,
         vmware?: Vmware.AsObject,
         office365Organization?: Office365Organization.AsObject,
+        citrix?: Citrix.AsObject,
     }
 }
 
@@ -4069,6 +4075,16 @@ export class SpecHardwareInfo extends jspb.Message {
     getModelNumber(): string | undefined;
     setModelNumber(value: string): SpecHardwareInfo;
 
+    hasWakeupTime(): boolean;
+    clearWakeupTime(): void;
+    getWakeupTime(): string | undefined;
+    setWakeupTime(value: string): SpecHardwareInfo;
+
+    hasMachineHardwareName(): boolean;
+    clearMachineHardwareName(): void;
+    getMachineHardwareName(): string | undefined;
+    setMachineHardwareName(value: string): SpecHardwareInfo;
+
     serializeBinary(): Uint8Array;
     toObject(includeInstance?: boolean): SpecHardwareInfo.AsObject;
     static toObject(includeInstance: boolean, msg: SpecHardwareInfo): SpecHardwareInfo.AsObject;
@@ -4091,6 +4107,8 @@ export namespace SpecHardwareInfo {
         bootRomVersion?: string,
         smcVersionSystem?: string,
         modelNumber?: string,
+        wakeupTime?: string,
+        machineHardwareName?: string,
     }
 }
 
@@ -5029,6 +5047,54 @@ export class NetworkInterface extends jspb.Message {
     getIpv6DhcpEnabled(): boolean | undefined;
     setIpv6DhcpEnabled(value: boolean): NetworkInterface;
 
+    hasState(): boolean;
+    clearState(): void;
+    getState(): string | undefined;
+    setState(value: string): NetworkInterface;
+
+    hasLinkEncap(): boolean;
+    clearLinkEncap(): void;
+    getLinkEncap(): string | undefined;
+    setLinkEncap(value: string): NetworkInterface;
+
+    hasBroadcast(): boolean;
+    clearBroadcast(): void;
+    getBroadcast(): string | undefined;
+    setBroadcast(value: string): NetworkInterface;
+
+    hasScope(): boolean;
+    clearScope(): void;
+    getScope(): string | undefined;
+    setScope(value: string): NetworkInterface;
+
+    hasQDisc(): boolean;
+    clearQDisc(): void;
+    getQDisc(): string | undefined;
+    setQDisc(value: string): NetworkInterface;
+
+    hasGroup(): boolean;
+    clearGroup(): void;
+    getGroup(): string | undefined;
+    setGroup(value: string): NetworkInterface;
+
+    hasBridge(): boolean;
+    clearBridge(): void;
+    getBridge(): string | undefined;
+    setBridge(value: string): NetworkInterface;
+
+    hasTags(): boolean;
+    clearTags(): void;
+    getTags(): string | undefined;
+    setTags(value: string): NetworkInterface;
+    clearPhysicalInterfacesList(): void;
+    getPhysicalInterfacesList(): Array<CitrixPhysicalInterface>;
+    setPhysicalInterfacesList(value: Array<CitrixPhysicalInterface>): NetworkInterface;
+    addPhysicalInterfaces(value?: CitrixPhysicalInterface, index?: number): CitrixPhysicalInterface;
+    clearVirtualInterfacesList(): void;
+    getVirtualInterfacesList(): Array<CitrixVirtualInterface>;
+    setVirtualInterfacesList(value: Array<CitrixVirtualInterface>): NetworkInterface;
+    addVirtualInterfaces(value?: CitrixVirtualInterface, index?: number): CitrixVirtualInterface;
+
     serializeBinary(): Uint8Array;
     toObject(includeInstance?: boolean): NetworkInterface.AsObject;
     static toObject(includeInstance: boolean, msg: NetworkInterface): NetworkInterface.AsObject;
@@ -5074,6 +5140,16 @@ export namespace NetworkInterface {
         domainName?: string,
         ipv4DhcpEnabled?: boolean,
         ipv6DhcpEnabled?: boolean,
+        state?: string,
+        linkEncap?: string,
+        broadcast?: string,
+        scope?: string,
+        qDisc?: string,
+        group?: string,
+        bridge?: string,
+        tags?: string,
+        physicalInterfacesList: Array<CitrixPhysicalInterface.AsObject>,
+        virtualInterfacesList: Array<CitrixVirtualInterface.AsObject>,
     }
 }
 
@@ -18056,6 +18132,1799 @@ export namespace VmwareSnapshot {
     }
 }
 
+export class Citrix extends jspb.Message { 
+
+    hasVcenter(): boolean;
+    clearVcenter(): void;
+    getVcenter(): CitrixPool | undefined;
+    setVcenter(value?: CitrixPool): Citrix;
+
+    hasHost(): boolean;
+    clearHost(): void;
+    getHost(): CitrixHost | undefined;
+    setHost(value?: CitrixHost): Citrix;
+
+    hasGuestVm(): boolean;
+    clearGuestVm(): void;
+    getGuestVm(): CitrixGuest | undefined;
+    setGuestVm(value?: CitrixGuest): Citrix;
+
+    getCitrixDataCase(): Citrix.CitrixDataCase;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): Citrix.AsObject;
+    static toObject(includeInstance: boolean, msg: Citrix): Citrix.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: Citrix, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): Citrix;
+    static deserializeBinaryFromReader(message: Citrix, reader: jspb.BinaryReader): Citrix;
+}
+
+export namespace Citrix {
+    export type AsObject = {
+        vcenter?: CitrixPool.AsObject,
+        host?: CitrixHost.AsObject,
+        guestVm?: CitrixGuest.AsObject,
+    }
+
+    export enum CitrixDataCase {
+        CITRIX_DATA_NOT_SET = 0,
+        VCENTER = 1,
+        HOST = 2,
+        GUEST_VM = 3,
+    }
+
+}
+
+export class CitrixPool extends jspb.Message { 
+
+    hasName(): boolean;
+    clearName(): void;
+    getName(): string | undefined;
+    setName(value: string): CitrixPool;
+
+    hasDescription(): boolean;
+    clearDescription(): void;
+    getDescription(): string | undefined;
+    setDescription(value: string): CitrixPool;
+
+    hasRedoLog(): boolean;
+    clearRedoLog(): void;
+    getRedoLog(): boolean | undefined;
+    setRedoLog(value: boolean): CitrixPool;
+
+    hasTags(): boolean;
+    clearTags(): void;
+    getTags(): string | undefined;
+    setTags(value: string): CitrixPool;
+
+    hasVSwitchController(): boolean;
+    clearVSwitchController(): void;
+    getVSwitchController(): string | undefined;
+    setVSwitchController(value: string): CitrixPool;
+
+    hasHighAvailability(): boolean;
+    clearHighAvailability(): void;
+    getHighAvailability(): boolean | undefined;
+    setHighAvailability(value: boolean): CitrixPool;
+
+    hasHighAvailabilityAllowOvercommit(): boolean;
+    clearHighAvailabilityAllowOvercommit(): void;
+    getHighAvailabilityAllowOvercommit(): boolean | undefined;
+    setHighAvailabilityAllowOvercommit(value: boolean): CitrixPool;
+
+    hasHighAvailabilityOvercommitted(): boolean;
+    clearHighAvailabilityOvercommitted(): void;
+    getHighAvailabilityOvercommitted(): boolean | undefined;
+    setHighAvailabilityOvercommitted(value: boolean): CitrixPool;
+
+    hasHighAvailabilityHostFailuresToTolerate(): boolean;
+    clearHighAvailabilityHostFailuresToTolerate(): void;
+    getHighAvailabilityHostFailuresToTolerate(): number | undefined;
+    setHighAvailabilityHostFailuresToTolerate(value: number): CitrixPool;
+
+    hasHighAvailabilityPlanExistsFor(): boolean;
+    clearHighAvailabilityPlanExistsFor(): void;
+    getHighAvailabilityPlanExistsFor(): number | undefined;
+    setHighAvailabilityPlanExistsFor(value: number): CitrixPool;
+
+    hasWorkloadBalancing(): boolean;
+    clearWorkloadBalancing(): void;
+    getWorkloadBalancing(): boolean | undefined;
+    setWorkloadBalancing(value: boolean): CitrixPool;
+
+    hasWorkloadBalancingUrl(): boolean;
+    clearWorkloadBalancingUrl(): void;
+    getWorkloadBalancingUrl(): string | undefined;
+    setWorkloadBalancingUrl(value: string): CitrixPool;
+
+    hasWorkloadBalancingUsername(): boolean;
+    clearWorkloadBalancingUsername(): void;
+    getWorkloadBalancingUsername(): string | undefined;
+    setWorkloadBalancingUsername(value: string): CitrixPool;
+
+    hasWorkloadBalancingVerifyCert(): boolean;
+    clearWorkloadBalancingVerifyCert(): void;
+    getWorkloadBalancingVerifyCert(): boolean | undefined;
+    setWorkloadBalancingVerifyCert(value: boolean): CitrixPool;
+
+    hasMasterHostUuid(): boolean;
+    clearMasterHostUuid(): void;
+    getMasterHostUuid(): string | undefined;
+    setMasterHostUuid(value: string): CitrixPool;
+
+    hasCrashDumpStorageRef(): boolean;
+    clearCrashDumpStorageRef(): void;
+    getCrashDumpStorageRef(): string | undefined;
+    setCrashDumpStorageRef(value: string): CitrixPool;
+
+    hasSuspendImageStorageRef(): boolean;
+    clearSuspendImageStorageRef(): void;
+    getSuspendImageStorageRef(): string | undefined;
+    setSuspendImageStorageRef(value: string): CitrixPool;
+    clearAppliancesList(): void;
+    getAppliancesList(): Array<CitrixAppliance>;
+    setAppliancesList(value: Array<CitrixAppliance>): CitrixPool;
+    addAppliances(value?: CitrixAppliance, index?: number): CitrixAppliance;
+    clearNetworksList(): void;
+    getNetworksList(): Array<NetworkInterfaces>;
+    setNetworksList(value: Array<NetworkInterfaces>): CitrixPool;
+    addNetworks(value?: NetworkInterfaces, index?: number): NetworkInterfaces;
+    clearOtherConfigurationsList(): void;
+    getOtherConfigurationsList(): Array<CitrixPoolOtherConfiguration>;
+    setOtherConfigurationsList(value: Array<CitrixPoolOtherConfiguration>): CitrixPool;
+    addOtherConfigurations(value?: CitrixPoolOtherConfiguration, index?: number): CitrixPoolOtherConfiguration;
+    clearPatchesList(): void;
+    getPatchesList(): Array<CitrixPoolPatch>;
+    setPatchesList(value: Array<CitrixPoolPatch>): CitrixPool;
+    addPatches(value?: CitrixPoolPatch, index?: number): CitrixPoolPatch;
+    clearRestrictionsList(): void;
+    getRestrictionsList(): Array<CitrixPoolRestriction>;
+    setRestrictionsList(value: Array<CitrixPoolRestriction>): CitrixPool;
+    addRestrictions(value?: CitrixPoolRestriction, index?: number): CitrixPoolRestriction;
+    clearTemplateNameList(): void;
+    getTemplateNameList(): Array<string>;
+    setTemplateNameList(value: Array<string>): CitrixPool;
+    addTemplateName(value: string, index?: number): string;
+    clearPhysicalInterfacesList(): void;
+    getPhysicalInterfacesList(): Array<CitrixPhysicalInterface>;
+    setPhysicalInterfacesList(value: Array<CitrixPhysicalInterface>): CitrixPool;
+    addPhysicalInterfaces(value?: CitrixPhysicalInterface, index?: number): CitrixPhysicalInterface;
+    clearVirtualInterfacesList(): void;
+    getVirtualInterfacesList(): Array<CitrixVirtualInterface>;
+    setVirtualInterfacesList(value: Array<CitrixVirtualInterface>): CitrixPool;
+    addVirtualInterfaces(value?: CitrixVirtualInterface, index?: number): CitrixVirtualInterface;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): CitrixPool.AsObject;
+    static toObject(includeInstance: boolean, msg: CitrixPool): CitrixPool.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: CitrixPool, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): CitrixPool;
+    static deserializeBinaryFromReader(message: CitrixPool, reader: jspb.BinaryReader): CitrixPool;
+}
+
+export namespace CitrixPool {
+    export type AsObject = {
+        name?: string,
+        description?: string,
+        redoLog?: boolean,
+        tags?: string,
+        vSwitchController?: string,
+        highAvailability?: boolean,
+        highAvailabilityAllowOvercommit?: boolean,
+        highAvailabilityOvercommitted?: boolean,
+        highAvailabilityHostFailuresToTolerate?: number,
+        highAvailabilityPlanExistsFor?: number,
+        workloadBalancing?: boolean,
+        workloadBalancingUrl?: string,
+        workloadBalancingUsername?: string,
+        workloadBalancingVerifyCert?: boolean,
+        masterHostUuid?: string,
+        crashDumpStorageRef?: string,
+        suspendImageStorageRef?: string,
+        appliancesList: Array<CitrixAppliance.AsObject>,
+        networksList: Array<NetworkInterfaces.AsObject>,
+        otherConfigurationsList: Array<CitrixPoolOtherConfiguration.AsObject>,
+        patchesList: Array<CitrixPoolPatch.AsObject>,
+        restrictionsList: Array<CitrixPoolRestriction.AsObject>,
+        templateNameList: Array<string>,
+        physicalInterfacesList: Array<CitrixPhysicalInterface.AsObject>,
+        virtualInterfacesList: Array<CitrixVirtualInterface.AsObject>,
+    }
+}
+
+export class CitrixAppliance extends jspb.Message { 
+
+    hasName(): boolean;
+    clearName(): void;
+    getName(): string | undefined;
+    setName(value: string): CitrixAppliance;
+
+    hasDescription(): boolean;
+    clearDescription(): void;
+    getDescription(): string | undefined;
+    setDescription(value: string): CitrixAppliance;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): CitrixAppliance.AsObject;
+    static toObject(includeInstance: boolean, msg: CitrixAppliance): CitrixAppliance.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: CitrixAppliance, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): CitrixAppliance;
+    static deserializeBinaryFromReader(message: CitrixAppliance, reader: jspb.BinaryReader): CitrixAppliance;
+}
+
+export namespace CitrixAppliance {
+    export type AsObject = {
+        name?: string,
+        description?: string,
+    }
+}
+
+export class CitrixPoolOtherConfiguration extends jspb.Message { 
+
+    hasKey(): boolean;
+    clearKey(): void;
+    getKey(): string | undefined;
+    setKey(value: string): CitrixPoolOtherConfiguration;
+
+    hasValue(): boolean;
+    clearValue(): void;
+    getValue(): string | undefined;
+    setValue(value: string): CitrixPoolOtherConfiguration;
+
+    hasIsCustomField(): boolean;
+    clearIsCustomField(): void;
+    getIsCustomField(): boolean | undefined;
+    setIsCustomField(value: boolean): CitrixPoolOtherConfiguration;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): CitrixPoolOtherConfiguration.AsObject;
+    static toObject(includeInstance: boolean, msg: CitrixPoolOtherConfiguration): CitrixPoolOtherConfiguration.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: CitrixPoolOtherConfiguration, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): CitrixPoolOtherConfiguration;
+    static deserializeBinaryFromReader(message: CitrixPoolOtherConfiguration, reader: jspb.BinaryReader): CitrixPoolOtherConfiguration;
+}
+
+export namespace CitrixPoolOtherConfiguration {
+    export type AsObject = {
+        key?: string,
+        value?: string,
+        isCustomField?: boolean,
+    }
+}
+
+export class CitrixPoolRestriction extends jspb.Message { 
+
+    hasKey(): boolean;
+    clearKey(): void;
+    getKey(): string | undefined;
+    setKey(value: string): CitrixPoolRestriction;
+
+    hasValue(): boolean;
+    clearValue(): void;
+    getValue(): string | undefined;
+    setValue(value: string): CitrixPoolRestriction;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): CitrixPoolRestriction.AsObject;
+    static toObject(includeInstance: boolean, msg: CitrixPoolRestriction): CitrixPoolRestriction.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: CitrixPoolRestriction, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): CitrixPoolRestriction;
+    static deserializeBinaryFromReader(message: CitrixPoolRestriction, reader: jspb.BinaryReader): CitrixPoolRestriction;
+}
+
+export namespace CitrixPoolRestriction {
+    export type AsObject = {
+        key?: string,
+        value?: string,
+    }
+}
+
+export class CitrixPoolPatch extends jspb.Message { 
+
+    hasName(): boolean;
+    clearName(): void;
+    getName(): string | undefined;
+    setName(value: string): CitrixPoolPatch;
+
+    hasDescription(): boolean;
+    clearDescription(): void;
+    getDescription(): string | undefined;
+    setDescription(value: string): CitrixPoolPatch;
+
+    hasSize(): boolean;
+    clearSize(): void;
+    getSize(): number | undefined;
+    setSize(value: number): CitrixPoolPatch;
+
+    hasVersion(): boolean;
+    clearVersion(): void;
+    getVersion(): string | undefined;
+    setVersion(value: string): CitrixPoolPatch;
+
+    hasAfterApplyGuidance(): boolean;
+    clearAfterApplyGuidance(): void;
+    getAfterApplyGuidance(): string | undefined;
+    setAfterApplyGuidance(value: string): CitrixPoolPatch;
+
+    hasApplied(): boolean;
+    clearApplied(): void;
+    getApplied(): boolean | undefined;
+    setApplied(value: boolean): CitrixPoolPatch;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): CitrixPoolPatch.AsObject;
+    static toObject(includeInstance: boolean, msg: CitrixPoolPatch): CitrixPoolPatch.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: CitrixPoolPatch, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): CitrixPoolPatch;
+    static deserializeBinaryFromReader(message: CitrixPoolPatch, reader: jspb.BinaryReader): CitrixPoolPatch;
+}
+
+export namespace CitrixPoolPatch {
+    export type AsObject = {
+        name?: string,
+        description?: string,
+        size?: number,
+        version?: string,
+        afterApplyGuidance?: string,
+        applied?: boolean,
+    }
+}
+
+export class CitrixHost extends jspb.Message { 
+
+    hasHostname(): boolean;
+    clearHostname(): void;
+    getHostname(): string | undefined;
+    setHostname(value: string): CitrixHost;
+
+    hasName(): boolean;
+    clearName(): void;
+    getName(): string | undefined;
+    setName(value: string): CitrixHost;
+
+    hasDescription(): boolean;
+    clearDescription(): void;
+    getDescription(): string | undefined;
+    setDescription(value: string): CitrixHost;
+
+    hasIsMaster(): boolean;
+    clearIsMaster(): void;
+    getIsMaster(): boolean | undefined;
+    setIsMaster(value: boolean): CitrixHost;
+
+    hasAddress(): boolean;
+    clearAddress(): void;
+    getAddress(): string | undefined;
+    setAddress(value: string): CitrixHost;
+
+    hasEdition(): boolean;
+    clearEdition(): void;
+    getEdition(): string | undefined;
+    setEdition(value: string): CitrixHost;
+
+    hasEnabled(): boolean;
+    clearEnabled(): void;
+    getEnabled(): boolean | undefined;
+    setEnabled(value: boolean): CitrixHost;
+
+    hasExternalAuthenticationServiceName(): boolean;
+    clearExternalAuthenticationServiceName(): void;
+    getExternalAuthenticationServiceName(): string | undefined;
+    setExternalAuthenticationServiceName(value: string): CitrixHost;
+
+    hasExternalAuthenticationType(): boolean;
+    clearExternalAuthenticationType(): void;
+    getExternalAuthenticationType(): string | undefined;
+    setExternalAuthenticationType(value: string): CitrixHost;
+
+    hasMemoryOverhead(): boolean;
+    clearMemoryOverhead(): void;
+    getMemoryOverhead(): number | undefined;
+    setMemoryOverhead(value: number): CitrixHost;
+
+    hasPowerOnMode(): boolean;
+    clearPowerOnMode(): void;
+    getPowerOnMode(): string | undefined;
+    setPowerOnMode(value: string): CitrixHost;
+
+    hasSchedulerPolicy(): boolean;
+    clearSchedulerPolicy(): void;
+    getSchedulerPolicy(): string | undefined;
+    setSchedulerPolicy(value: string): CitrixHost;
+
+    hasTags(): boolean;
+    clearTags(): void;
+    getTags(): string | undefined;
+    setTags(value: string): CitrixHost;
+
+    hasDisplay(): boolean;
+    clearDisplay(): void;
+    getDisplay(): string | undefined;
+    setDisplay(value: string): CitrixHost;
+
+    hasLastUpdated(): boolean;
+    clearLastUpdated(): void;
+    getLastUpdated(): google_protobuf_timestamp_pb.Timestamp | undefined;
+    setLastUpdated(value?: google_protobuf_timestamp_pb.Timestamp): CitrixHost;
+
+    hasLive(): boolean;
+    clearLive(): void;
+    getLive(): boolean | undefined;
+    setLive(value: boolean): CitrixHost;
+
+    hasMemoryFree(): boolean;
+    clearMemoryFree(): void;
+    getMemoryFree(): number | undefined;
+    setMemoryFree(value: number): CitrixHost;
+
+    hasMemoryTotal(): boolean;
+    clearMemoryTotal(): void;
+    getMemoryTotal(): number | undefined;
+    setMemoryTotal(value: number): CitrixHost;
+
+    hasHostUuid(): boolean;
+    clearHostUuid(): void;
+    getHostUuid(): string | undefined;
+    setHostUuid(value: string): CitrixHost;
+
+    hasCrashDumpStorageRef(): boolean;
+    clearCrashDumpStorageRef(): void;
+    getCrashDumpStorageRef(): string | undefined;
+    setCrashDumpStorageRef(value: string): CitrixHost;
+
+    hasLocalCacheStorageRef(): boolean;
+    clearLocalCacheStorageRef(): void;
+    getLocalCacheStorageRef(): string | undefined;
+    setLocalCacheStorageRef(value: string): CitrixHost;
+
+    hasSuspendImageStorageRef(): boolean;
+    clearSuspendImageStorageRef(): void;
+    getSuspendImageStorageRef(): string | undefined;
+    setSuspendImageStorageRef(value: string): CitrixHost;
+    clearStoragesList(): void;
+    getStoragesList(): Array<CitrixStorage>;
+    setStoragesList(value: Array<CitrixStorage>): CitrixHost;
+    addStorages(value?: CitrixStorage, index?: number): CitrixStorage;
+    clearPhysicalInterfacesList(): void;
+    getPhysicalInterfacesList(): Array<CitrixPhysicalInterface>;
+    setPhysicalInterfacesList(value: Array<CitrixPhysicalInterface>): CitrixHost;
+    addPhysicalInterfaces(value?: CitrixPhysicalInterface, index?: number): CitrixPhysicalInterface;
+    clearPcisList(): void;
+    getPcisList(): Array<CitrixPci>;
+    setPcisList(value: Array<CitrixPci>): CitrixHost;
+    addPcis(value?: CitrixPci, index?: number): CitrixPci;
+    clearExtraInfosList(): void;
+    getExtraInfosList(): Array<CitrixHostExtraInfo>;
+    setExtraInfosList(value: Array<CitrixHostExtraInfo>): CitrixHost;
+    addExtraInfos(value?: CitrixHostExtraInfo, index?: number): CitrixHostExtraInfo;
+    clearPatchesList(): void;
+    getPatchesList(): Array<CitrixHostPatch>;
+    setPatchesList(value: Array<CitrixHostPatch>): CitrixHost;
+    addPatches(value?: CitrixHostPatch, index?: number): CitrixHostPatch;
+    clearPhysicalCpusList(): void;
+    getPhysicalCpusList(): Array<CitrixHostPhysicalCpu>;
+    setPhysicalCpusList(value: Array<CitrixHostPhysicalCpu>): CitrixHost;
+    addPhysicalCpus(value?: CitrixHostPhysicalCpu, index?: number): CitrixHostPhysicalCpu;
+    clearCrashDumpsList(): void;
+    getCrashDumpsList(): Array<CitrixHostCrashDump>;
+    setCrashDumpsList(value: Array<CitrixHostCrashDump>): CitrixHost;
+    addCrashDumps(value?: CitrixHostCrashDump, index?: number): CitrixHostCrashDump;
+    getCitrixPoolUuid(): string;
+    setCitrixPoolUuid(value: string): CitrixHost;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): CitrixHost.AsObject;
+    static toObject(includeInstance: boolean, msg: CitrixHost): CitrixHost.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: CitrixHost, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): CitrixHost;
+    static deserializeBinaryFromReader(message: CitrixHost, reader: jspb.BinaryReader): CitrixHost;
+}
+
+export namespace CitrixHost {
+    export type AsObject = {
+        hostname?: string,
+        name?: string,
+        description?: string,
+        isMaster?: boolean,
+        address?: string,
+        edition?: string,
+        enabled?: boolean,
+        externalAuthenticationServiceName?: string,
+        externalAuthenticationType?: string,
+        memoryOverhead?: number,
+        powerOnMode?: string,
+        schedulerPolicy?: string,
+        tags?: string,
+        display?: string,
+        lastUpdated?: google_protobuf_timestamp_pb.Timestamp.AsObject,
+        live?: boolean,
+        memoryFree?: number,
+        memoryTotal?: number,
+        hostUuid?: string,
+        crashDumpStorageRef?: string,
+        localCacheStorageRef?: string,
+        suspendImageStorageRef?: string,
+        storagesList: Array<CitrixStorage.AsObject>,
+        physicalInterfacesList: Array<CitrixPhysicalInterface.AsObject>,
+        pcisList: Array<CitrixPci.AsObject>,
+        extraInfosList: Array<CitrixHostExtraInfo.AsObject>,
+        patchesList: Array<CitrixHostPatch.AsObject>,
+        physicalCpusList: Array<CitrixHostPhysicalCpu.AsObject>,
+        crashDumpsList: Array<CitrixHostCrashDump.AsObject>,
+        citrixPoolUuid: string,
+    }
+}
+
+export class CitrixHostCrashDump extends jspb.Message { 
+
+    hasSize(): boolean;
+    clearSize(): void;
+    getSize(): number | undefined;
+    setSize(value: number): CitrixHostCrashDump;
+
+    hasTimestamp(): boolean;
+    clearTimestamp(): void;
+    getTimestamp(): google_protobuf_timestamp_pb.Timestamp | undefined;
+    setTimestamp(value?: google_protobuf_timestamp_pb.Timestamp): CitrixHostCrashDump;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): CitrixHostCrashDump.AsObject;
+    static toObject(includeInstance: boolean, msg: CitrixHostCrashDump): CitrixHostCrashDump.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: CitrixHostCrashDump, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): CitrixHostCrashDump;
+    static deserializeBinaryFromReader(message: CitrixHostCrashDump, reader: jspb.BinaryReader): CitrixHostCrashDump;
+}
+
+export namespace CitrixHostCrashDump {
+    export type AsObject = {
+        size?: number,
+        timestamp?: google_protobuf_timestamp_pb.Timestamp.AsObject,
+    }
+}
+
+export class CitrixHostPhysicalCpu extends jspb.Message { 
+
+    hasFamily(): boolean;
+    clearFamily(): void;
+    getFamily(): number | undefined;
+    setFamily(value: number): CitrixHostPhysicalCpu;
+
+    hasFeatures(): boolean;
+    clearFeatures(): void;
+    getFeatures(): string | undefined;
+    setFeatures(value: string): CitrixHostPhysicalCpu;
+
+    hasFlags(): boolean;
+    clearFlags(): void;
+    getFlags(): string | undefined;
+    setFlags(value: string): CitrixHostPhysicalCpu;
+
+    hasModel(): boolean;
+    clearModel(): void;
+    getModel(): number | undefined;
+    setModel(value: number): CitrixHostPhysicalCpu;
+
+    hasModelName(): boolean;
+    clearModelName(): void;
+    getModelName(): string | undefined;
+    setModelName(value: string): CitrixHostPhysicalCpu;
+
+    hasNumberOfCpus(): boolean;
+    clearNumberOfCpus(): void;
+    getNumberOfCpus(): number | undefined;
+    setNumberOfCpus(value: number): CitrixHostPhysicalCpu;
+
+    hasSpeed(): boolean;
+    clearSpeed(): void;
+    getSpeed(): number | undefined;
+    setSpeed(value: number): CitrixHostPhysicalCpu;
+
+    hasStepping(): boolean;
+    clearStepping(): void;
+    getStepping(): string | undefined;
+    setStepping(value: string): CitrixHostPhysicalCpu;
+
+    hasVendor(): boolean;
+    clearVendor(): void;
+    getVendor(): string | undefined;
+    setVendor(value: string): CitrixHostPhysicalCpu;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): CitrixHostPhysicalCpu.AsObject;
+    static toObject(includeInstance: boolean, msg: CitrixHostPhysicalCpu): CitrixHostPhysicalCpu.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: CitrixHostPhysicalCpu, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): CitrixHostPhysicalCpu;
+    static deserializeBinaryFromReader(message: CitrixHostPhysicalCpu, reader: jspb.BinaryReader): CitrixHostPhysicalCpu;
+}
+
+export namespace CitrixHostPhysicalCpu {
+    export type AsObject = {
+        family?: number,
+        features?: string,
+        flags?: string,
+        model?: number,
+        modelName?: string,
+        numberOfCpus?: number,
+        speed?: number,
+        stepping?: string,
+        vendor?: string,
+    }
+}
+
+export class CitrixHostPatch extends jspb.Message { 
+
+    hasName(): boolean;
+    clearName(): void;
+    getName(): string | undefined;
+    setName(value: string): CitrixHostPatch;
+
+    hasDescription(): boolean;
+    clearDescription(): void;
+    getDescription(): string | undefined;
+    setDescription(value: string): CitrixHostPatch;
+
+    hasSize(): boolean;
+    clearSize(): void;
+    getSize(): number | undefined;
+    setSize(value: number): CitrixHostPatch;
+
+    hasApplied(): boolean;
+    clearApplied(): void;
+    getApplied(): google_protobuf_timestamp_pb.Timestamp | undefined;
+    setApplied(value?: google_protobuf_timestamp_pb.Timestamp): CitrixHostPatch;
+
+    hasVersion(): boolean;
+    clearVersion(): void;
+    getVersion(): string | undefined;
+    setVersion(value: string): CitrixHostPatch;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): CitrixHostPatch.AsObject;
+    static toObject(includeInstance: boolean, msg: CitrixHostPatch): CitrixHostPatch.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: CitrixHostPatch, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): CitrixHostPatch;
+    static deserializeBinaryFromReader(message: CitrixHostPatch, reader: jspb.BinaryReader): CitrixHostPatch;
+}
+
+export namespace CitrixHostPatch {
+    export type AsObject = {
+        name?: string,
+        description?: string,
+        size?: number,
+        applied?: google_protobuf_timestamp_pb.Timestamp.AsObject,
+        version?: string,
+    }
+}
+
+export class CitrixStorage extends jspb.Message { 
+
+    hasName(): boolean;
+    clearName(): void;
+    getName(): string | undefined;
+    setName(value: string): CitrixStorage;
+
+    hasDescription(): boolean;
+    clearDescription(): void;
+    getDescription(): string | undefined;
+    setDescription(value: string): CitrixStorage;
+
+    hasPhysicalSize(): boolean;
+    clearPhysicalSize(): void;
+    getPhysicalSize(): number | undefined;
+    setPhysicalSize(value: number): CitrixStorage;
+
+    hasPhysicalUtilization(): boolean;
+    clearPhysicalUtilization(): void;
+    getPhysicalUtilization(): number | undefined;
+    setPhysicalUtilization(value: number): CitrixStorage;
+
+    hasType(): boolean;
+    clearType(): void;
+    getType(): string | undefined;
+    setType(value: string): CitrixStorage;
+
+    hasContentType(): boolean;
+    clearContentType(): void;
+    getContentType(): string | undefined;
+    setContentType(value: string): CitrixStorage;
+
+    hasClustered(): boolean;
+    clearClustered(): void;
+    getClustered(): boolean | undefined;
+    setClustered(value: boolean): CitrixStorage;
+
+    hasIsToolsStorage(): boolean;
+    clearIsToolsStorage(): void;
+    getIsToolsStorage(): boolean | undefined;
+    setIsToolsStorage(value: boolean): CitrixStorage;
+
+    hasLocalCache(): boolean;
+    clearLocalCache(): void;
+    getLocalCache(): boolean | undefined;
+    setLocalCache(value: boolean): CitrixStorage;
+
+    hasShared(): boolean;
+    clearShared(): void;
+    getShared(): boolean | undefined;
+    setShared(value: boolean): CitrixStorage;
+
+    hasTags(): boolean;
+    clearTags(): void;
+    getTags(): string | undefined;
+    setTags(value: string): CitrixStorage;
+
+    hasVirtualAllocation(): boolean;
+    clearVirtualAllocation(): void;
+    getVirtualAllocation(): number | undefined;
+    setVirtualAllocation(value: number): CitrixStorage;
+    clearHostUuidsList(): void;
+    getHostUuidsList(): Array<string>;
+    setHostUuidsList(value: Array<string>): CitrixStorage;
+    addHostUuids(value: string, index?: number): string;
+
+    hasStorageRef(): boolean;
+    clearStorageRef(): void;
+    getStorageRef(): string | undefined;
+    setStorageRef(value: string): CitrixStorage;
+    clearPhysicalBlockDevicesList(): void;
+    getPhysicalBlockDevicesList(): Array<CitrixPhysicalBlockDevice>;
+    setPhysicalBlockDevicesList(value: Array<CitrixPhysicalBlockDevice>): CitrixStorage;
+    addPhysicalBlockDevices(value?: CitrixPhysicalBlockDevice, index?: number): CitrixPhysicalBlockDevice;
+    clearVirtualDiskImagesList(): void;
+    getVirtualDiskImagesList(): Array<CitrixVirtualDiskImage>;
+    setVirtualDiskImagesList(value: Array<CitrixVirtualDiskImage>): CitrixStorage;
+    addVirtualDiskImages(value?: CitrixVirtualDiskImage, index?: number): CitrixVirtualDiskImage;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): CitrixStorage.AsObject;
+    static toObject(includeInstance: boolean, msg: CitrixStorage): CitrixStorage.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: CitrixStorage, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): CitrixStorage;
+    static deserializeBinaryFromReader(message: CitrixStorage, reader: jspb.BinaryReader): CitrixStorage;
+}
+
+export namespace CitrixStorage {
+    export type AsObject = {
+        name?: string,
+        description?: string,
+        physicalSize?: number,
+        physicalUtilization?: number,
+        type?: string,
+        contentType?: string,
+        clustered?: boolean,
+        isToolsStorage?: boolean,
+        localCache?: boolean,
+        shared?: boolean,
+        tags?: string,
+        virtualAllocation?: number,
+        hostUuidsList: Array<string>,
+        storageRef?: string,
+        physicalBlockDevicesList: Array<CitrixPhysicalBlockDevice.AsObject>,
+        virtualDiskImagesList: Array<CitrixVirtualDiskImage.AsObject>,
+    }
+}
+
+export class CitrixPhysicalBlockDevice extends jspb.Message { 
+
+    hasCurrentlyAttached(): boolean;
+    clearCurrentlyAttached(): void;
+    getCurrentlyAttached(): boolean | undefined;
+    setCurrentlyAttached(value: boolean): CitrixPhysicalBlockDevice;
+
+    hasLocation(): boolean;
+    clearLocation(): void;
+    getLocation(): string | undefined;
+    setLocation(value: string): CitrixPhysicalBlockDevice;
+
+    hasUsername(): boolean;
+    clearUsername(): void;
+    getUsername(): string | undefined;
+    setUsername(value: string): CitrixPhysicalBlockDevice;
+
+    hasType(): boolean;
+    clearType(): void;
+    getType(): string | undefined;
+    setType(value: string): CitrixPhysicalBlockDevice;
+
+    hasVersion(): boolean;
+    clearVersion(): void;
+    getVersion(): string | undefined;
+    setVersion(value: string): CitrixPhysicalBlockDevice;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): CitrixPhysicalBlockDevice.AsObject;
+    static toObject(includeInstance: boolean, msg: CitrixPhysicalBlockDevice): CitrixPhysicalBlockDevice.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: CitrixPhysicalBlockDevice, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): CitrixPhysicalBlockDevice;
+    static deserializeBinaryFromReader(message: CitrixPhysicalBlockDevice, reader: jspb.BinaryReader): CitrixPhysicalBlockDevice;
+}
+
+export namespace CitrixPhysicalBlockDevice {
+    export type AsObject = {
+        currentlyAttached?: boolean,
+        location?: string,
+        username?: string,
+        type?: string,
+        version?: string,
+    }
+}
+
+export class CitrixVirtualDiskImage extends jspb.Message { 
+
+    hasName(): boolean;
+    clearName(): void;
+    getName(): string | undefined;
+    setName(value: string): CitrixVirtualDiskImage;
+
+    hasDescription(): boolean;
+    clearDescription(): void;
+    getDescription(): string | undefined;
+    setDescription(value: string): CitrixVirtualDiskImage;
+
+    hasAllowCaching(): boolean;
+    clearAllowCaching(): void;
+    getAllowCaching(): boolean | undefined;
+    setAllowCaching(value: boolean): CitrixVirtualDiskImage;
+
+    hasIsASnapshot(): boolean;
+    clearIsASnapshot(): void;
+    getIsASnapshot(): boolean | undefined;
+    setIsASnapshot(value: boolean): CitrixVirtualDiskImage;
+
+    hasLocation(): boolean;
+    clearLocation(): void;
+    getLocation(): string | undefined;
+    setLocation(value: string): CitrixVirtualDiskImage;
+
+    hasManaged(): boolean;
+    clearManaged(): void;
+    getManaged(): boolean | undefined;
+    setManaged(value: boolean): CitrixVirtualDiskImage;
+
+    hasMetadataLatest(): boolean;
+    clearMetadataLatest(): void;
+    getMetadataLatest(): boolean | undefined;
+    setMetadataLatest(value: boolean): CitrixVirtualDiskImage;
+
+    hasMissing(): boolean;
+    clearMissing(): void;
+    getMissing(): boolean | undefined;
+    setMissing(value: boolean): CitrixVirtualDiskImage;
+
+    hasOnBoot(): boolean;
+    clearOnBoot(): void;
+    getOnBoot(): string | undefined;
+    setOnBoot(value: string): CitrixVirtualDiskImage;
+
+    hasPhysicalUtilisation(): boolean;
+    clearPhysicalUtilisation(): void;
+    getPhysicalUtilisation(): number | undefined;
+    setPhysicalUtilisation(value: number): CitrixVirtualDiskImage;
+
+    hasReadOnly(): boolean;
+    clearReadOnly(): void;
+    getReadOnly(): boolean | undefined;
+    setReadOnly(value: boolean): CitrixVirtualDiskImage;
+
+    hasSharable(): boolean;
+    clearSharable(): void;
+    getSharable(): boolean | undefined;
+    setSharable(value: boolean): CitrixVirtualDiskImage;
+
+    hasStorageLock(): boolean;
+    clearStorageLock(): void;
+    getStorageLock(): boolean | undefined;
+    setStorageLock(value: boolean): CitrixVirtualDiskImage;
+
+    hasTags(): boolean;
+    clearTags(): void;
+    getTags(): string | undefined;
+    setTags(value: string): CitrixVirtualDiskImage;
+
+    hasType(): boolean;
+    clearType(): void;
+    getType(): string | undefined;
+    setType(value: string): CitrixVirtualDiskImage;
+
+    hasVirtualSize(): boolean;
+    clearVirtualSize(): void;
+    getVirtualSize(): number | undefined;
+    setVirtualSize(value: number): CitrixVirtualDiskImage;
+
+    hasHostUuid(): boolean;
+    clearHostUuid(): void;
+    getHostUuid(): string | undefined;
+    setHostUuid(value: string): CitrixVirtualDiskImage;
+    clearVirtualBlockDeviceUuidsList(): void;
+    getVirtualBlockDeviceUuidsList(): Array<string>;
+    setVirtualBlockDeviceUuidsList(value: Array<string>): CitrixVirtualDiskImage;
+    addVirtualBlockDeviceUuids(value: string, index?: number): string;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): CitrixVirtualDiskImage.AsObject;
+    static toObject(includeInstance: boolean, msg: CitrixVirtualDiskImage): CitrixVirtualDiskImage.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: CitrixVirtualDiskImage, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): CitrixVirtualDiskImage;
+    static deserializeBinaryFromReader(message: CitrixVirtualDiskImage, reader: jspb.BinaryReader): CitrixVirtualDiskImage;
+}
+
+export namespace CitrixVirtualDiskImage {
+    export type AsObject = {
+        name?: string,
+        description?: string,
+        allowCaching?: boolean,
+        isASnapshot?: boolean,
+        location?: string,
+        managed?: boolean,
+        metadataLatest?: boolean,
+        missing?: boolean,
+        onBoot?: string,
+        physicalUtilisation?: number,
+        readOnly?: boolean,
+        sharable?: boolean,
+        storageLock?: boolean,
+        tags?: string,
+        type?: string,
+        virtualSize?: number,
+        hostUuid?: string,
+        virtualBlockDeviceUuidsList: Array<string>,
+    }
+}
+
+export class CitrixPci extends jspb.Message { 
+
+    hasClassName(): boolean;
+    clearClassName(): void;
+    getClassName(): string | undefined;
+    setClassName(value: string): CitrixPci;
+
+    hasDeviceName(): boolean;
+    clearDeviceName(): void;
+    getDeviceName(): string | undefined;
+    setDeviceName(value: string): CitrixPci;
+
+    hasSubsystemDeviceName(): boolean;
+    clearSubsystemDeviceName(): void;
+    getSubsystemDeviceName(): string | undefined;
+    setSubsystemDeviceName(value: string): CitrixPci;
+
+    hasSubsystemVendorName(): boolean;
+    clearSubsystemVendorName(): void;
+    getSubsystemVendorName(): string | undefined;
+    setSubsystemVendorName(value: string): CitrixPci;
+
+    hasVendorName(): boolean;
+    clearVendorName(): void;
+    getVendorName(): string | undefined;
+    setVendorName(value: string): CitrixPci;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): CitrixPci.AsObject;
+    static toObject(includeInstance: boolean, msg: CitrixPci): CitrixPci.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: CitrixPci, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): CitrixPci;
+    static deserializeBinaryFromReader(message: CitrixPci, reader: jspb.BinaryReader): CitrixPci;
+}
+
+export namespace CitrixPci {
+    export type AsObject = {
+        className?: string,
+        deviceName?: string,
+        subsystemDeviceName?: string,
+        subsystemVendorName?: string,
+        vendorName?: string,
+    }
+}
+
+export class CitrixHostExtraInfo extends jspb.Message { 
+
+    hasInfoTypeId(): boolean;
+    clearInfoTypeId(): void;
+    getInfoTypeId(): number | undefined;
+    setInfoTypeId(value: number): CitrixHostExtraInfo;
+
+    hasKey(): boolean;
+    clearKey(): void;
+    getKey(): string | undefined;
+    setKey(value: string): CitrixHostExtraInfo;
+
+    hasValue(): boolean;
+    clearValue(): void;
+    getValue(): string | undefined;
+    setValue(value: string): CitrixHostExtraInfo;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): CitrixHostExtraInfo.AsObject;
+    static toObject(includeInstance: boolean, msg: CitrixHostExtraInfo): CitrixHostExtraInfo.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: CitrixHostExtraInfo, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): CitrixHostExtraInfo;
+    static deserializeBinaryFromReader(message: CitrixHostExtraInfo, reader: jspb.BinaryReader): CitrixHostExtraInfo;
+}
+
+export namespace CitrixHostExtraInfo {
+    export type AsObject = {
+        infoTypeId?: number,
+        key?: string,
+        value?: string,
+    }
+}
+
+export class CitrixGuest extends jspb.Message { 
+
+    hasName(): boolean;
+    clearName(): void;
+    getName(): string | undefined;
+    setName(value: string): CitrixGuest;
+
+    hasDescription(): boolean;
+    clearDescription(): void;
+    getDescription(): string | undefined;
+    setDescription(value: string): CitrixGuest;
+
+    hasMemory(): boolean;
+    clearMemory(): void;
+    getMemory(): number | undefined;
+    setMemory(value: number): CitrixGuest;
+
+    hasCpuCount(): boolean;
+    clearCpuCount(): void;
+    getCpuCount(): number | undefined;
+    setCpuCount(value: number): CitrixGuest;
+
+    hasState(): boolean;
+    clearState(): void;
+    getState(): string | undefined;
+    setState(value: string): CitrixGuest;
+
+    hasLive(): boolean;
+    clearLive(): void;
+    getLive(): boolean | undefined;
+    setLive(value: boolean): CitrixGuest;
+
+    hasLastUpdated(): boolean;
+    clearLastUpdated(): void;
+    getLastUpdated(): google_protobuf_timestamp_pb.Timestamp | undefined;
+    setLastUpdated(value?: google_protobuf_timestamp_pb.Timestamp): CitrixGuest;
+
+    hasHvmBootPolicy(): boolean;
+    clearHvmBootPolicy(): void;
+    getHvmBootPolicy(): string | undefined;
+    setHvmBootPolicy(value: string): CitrixGuest;
+
+    hasHvmShadowMultiplier(): boolean;
+    clearHvmShadowMultiplier(): void;
+    getHvmShadowMultiplier(): number | undefined;
+    setHvmShadowMultiplier(value: number): CitrixGuest;
+
+    hasPciBus(): boolean;
+    clearPciBus(): void;
+    getPciBus(): string | undefined;
+    setPciBus(value: string): CitrixGuest;
+
+    hasPvArguments(): boolean;
+    clearPvArguments(): void;
+    getPvArguments(): string | undefined;
+    setPvArguments(value: string): CitrixGuest;
+
+    hasPvBootloader(): boolean;
+    clearPvBootloader(): void;
+    getPvBootloader(): string | undefined;
+    setPvBootloader(value: string): CitrixGuest;
+
+    hasPvBootloaderArguments(): boolean;
+    clearPvBootloaderArguments(): void;
+    getPvBootloaderArguments(): string | undefined;
+    setPvBootloaderArguments(value: string): CitrixGuest;
+
+    hasPvKernel(): boolean;
+    clearPvKernel(): void;
+    getPvKernel(): string | undefined;
+    setPvKernel(value: string): CitrixGuest;
+
+    hasPvLegacyArguments(): boolean;
+    clearPvLegacyArguments(): void;
+    getPvLegacyArguments(): string | undefined;
+    setPvLegacyArguments(value: string): CitrixGuest;
+
+    hasPvRamdisk(): boolean;
+    clearPvRamdisk(): void;
+    getPvRamdisk(): string | undefined;
+    setPvRamdisk(value: string): CitrixGuest;
+
+    hasActionsAfterCrash(): boolean;
+    clearActionsAfterCrash(): void;
+    getActionsAfterCrash(): string | undefined;
+    setActionsAfterCrash(value: string): CitrixGuest;
+
+    hasActionsAfterReboot(): boolean;
+    clearActionsAfterReboot(): void;
+    getActionsAfterReboot(): string | undefined;
+    setActionsAfterReboot(value: string): CitrixGuest;
+
+    hasActionsAfterShutdown(): boolean;
+    clearActionsAfterShutdown(): void;
+    getActionsAfterShutdown(): string | undefined;
+    setActionsAfterShutdown(value: string): CitrixGuest;
+
+    hasHaAlwaysRun(): boolean;
+    clearHaAlwaysRun(): void;
+    getHaAlwaysRun(): boolean | undefined;
+    setHaAlwaysRun(value: boolean): CitrixGuest;
+
+    hasHaRestartPriority(): boolean;
+    clearHaRestartPriority(): void;
+    getHaRestartPriority(): string | undefined;
+    setHaRestartPriority(value: string): CitrixGuest;
+
+    hasHardwarePlatformVersion(): boolean;
+    clearHardwarePlatformVersion(): void;
+    getHardwarePlatformVersion(): number | undefined;
+    setHardwarePlatformVersion(value: number): CitrixGuest;
+
+    hasLastBootedRecord(): boolean;
+    clearLastBootedRecord(): void;
+    getLastBootedRecord(): string | undefined;
+    setLastBootedRecord(value: string): CitrixGuest;
+
+    hasMemoryDynamicMax(): boolean;
+    clearMemoryDynamicMax(): void;
+    getMemoryDynamicMax(): number | undefined;
+    setMemoryDynamicMax(value: number): CitrixGuest;
+
+    hasMemoryDynamicMin(): boolean;
+    clearMemoryDynamicMin(): void;
+    getMemoryDynamicMin(): number | undefined;
+    setMemoryDynamicMin(value: number): CitrixGuest;
+
+    hasMemoryOverhead(): boolean;
+    clearMemoryOverhead(): void;
+    getMemoryOverhead(): number | undefined;
+    setMemoryOverhead(value: number): CitrixGuest;
+
+    hasMemoryStaticMax(): boolean;
+    clearMemoryStaticMax(): void;
+    getMemoryStaticMax(): number | undefined;
+    setMemoryStaticMax(value: number): CitrixGuest;
+
+    hasMemoryStaticMin(): boolean;
+    clearMemoryStaticMin(): void;
+    getMemoryStaticMin(): number | undefined;
+    setMemoryStaticMin(value: number): CitrixGuest;
+
+    hasMemoryTarget(): boolean;
+    clearMemoryTarget(): void;
+    getMemoryTarget(): number | undefined;
+    setMemoryTarget(value: number): CitrixGuest;
+
+    hasOrder(): boolean;
+    clearOrder(): void;
+    getOrder(): number | undefined;
+    setOrder(value: number): CitrixGuest;
+
+    hasPowerState(): boolean;
+    clearPowerState(): void;
+    getPowerState(): string | undefined;
+    setPowerState(value: string): CitrixGuest;
+
+    hasShutdownDelay(): boolean;
+    clearShutdownDelay(): void;
+    getShutdownDelay(): number | undefined;
+    setShutdownDelay(value: number): CitrixGuest;
+
+    hasStartDelay(): boolean;
+    clearStartDelay(): void;
+    getStartDelay(): number | undefined;
+    setStartDelay(value: number): CitrixGuest;
+
+    hasTags(): boolean;
+    clearTags(): void;
+    getTags(): string | undefined;
+    setTags(value: string): CitrixGuest;
+
+    hasUserVersion(): boolean;
+    clearUserVersion(): void;
+    getUserVersion(): number | undefined;
+    setUserVersion(value: number): CitrixGuest;
+
+    hasVersion(): boolean;
+    clearVersion(): void;
+    getVersion(): number | undefined;
+    setVersion(value: number): CitrixGuest;
+
+    hasInstallTime(): boolean;
+    clearInstallTime(): void;
+    getInstallTime(): google_protobuf_timestamp_pb.Timestamp | undefined;
+    setInstallTime(value?: google_protobuf_timestamp_pb.Timestamp): CitrixGuest;
+
+    hasStartTime(): boolean;
+    clearStartTime(): void;
+    getStartTime(): google_protobuf_timestamp_pb.Timestamp | undefined;
+    setStartTime(value?: google_protobuf_timestamp_pb.Timestamp): CitrixGuest;
+
+    hasHostUuid(): boolean;
+    clearHostUuid(): void;
+    getHostUuid(): string | undefined;
+    setHostUuid(value: string): CitrixGuest;
+
+    hasGuestUuid(): boolean;
+    clearGuestUuid(): void;
+    getGuestUuid(): string | undefined;
+    setGuestUuid(value: string): CitrixGuest;
+    clearVirtualInterfacesList(): void;
+    getVirtualInterfacesList(): Array<CitrixVirtualInterface>;
+    setVirtualInterfacesList(value: Array<CitrixVirtualInterface>): CitrixGuest;
+    addVirtualInterfaces(value?: CitrixVirtualInterface, index?: number): CitrixVirtualInterface;
+    clearExtraInfosList(): void;
+    getExtraInfosList(): Array<CitrixGuestExtraInfo>;
+    setExtraInfosList(value: Array<CitrixGuestExtraInfo>): CitrixGuest;
+    addExtraInfos(value?: CitrixGuestExtraInfo, index?: number): CitrixGuestExtraInfo;
+    clearVirtualBlockDevicesList(): void;
+    getVirtualBlockDevicesList(): Array<CitrixVirtualBlockDevice>;
+    setVirtualBlockDevicesList(value: Array<CitrixVirtualBlockDevice>): CitrixGuest;
+    addVirtualBlockDevices(value?: CitrixVirtualBlockDevice, index?: number): CitrixVirtualBlockDevice;
+    getCitrixHostUuid(): string;
+    setCitrixHostUuid(value: string): CitrixGuest;
+    getCitrixPoolUuid(): string;
+    setCitrixPoolUuid(value: string): CitrixGuest;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): CitrixGuest.AsObject;
+    static toObject(includeInstance: boolean, msg: CitrixGuest): CitrixGuest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: CitrixGuest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): CitrixGuest;
+    static deserializeBinaryFromReader(message: CitrixGuest, reader: jspb.BinaryReader): CitrixGuest;
+}
+
+export namespace CitrixGuest {
+    export type AsObject = {
+        name?: string,
+        description?: string,
+        memory?: number,
+        cpuCount?: number,
+        state?: string,
+        live?: boolean,
+        lastUpdated?: google_protobuf_timestamp_pb.Timestamp.AsObject,
+        hvmBootPolicy?: string,
+        hvmShadowMultiplier?: number,
+        pciBus?: string,
+        pvArguments?: string,
+        pvBootloader?: string,
+        pvBootloaderArguments?: string,
+        pvKernel?: string,
+        pvLegacyArguments?: string,
+        pvRamdisk?: string,
+        actionsAfterCrash?: string,
+        actionsAfterReboot?: string,
+        actionsAfterShutdown?: string,
+        haAlwaysRun?: boolean,
+        haRestartPriority?: string,
+        hardwarePlatformVersion?: number,
+        lastBootedRecord?: string,
+        memoryDynamicMax?: number,
+        memoryDynamicMin?: number,
+        memoryOverhead?: number,
+        memoryStaticMax?: number,
+        memoryStaticMin?: number,
+        memoryTarget?: number,
+        order?: number,
+        powerState?: string,
+        shutdownDelay?: number,
+        startDelay?: number,
+        tags?: string,
+        userVersion?: number,
+        version?: number,
+        installTime?: google_protobuf_timestamp_pb.Timestamp.AsObject,
+        startTime?: google_protobuf_timestamp_pb.Timestamp.AsObject,
+        hostUuid?: string,
+        guestUuid?: string,
+        virtualInterfacesList: Array<CitrixVirtualInterface.AsObject>,
+        extraInfosList: Array<CitrixGuestExtraInfo.AsObject>,
+        virtualBlockDevicesList: Array<CitrixVirtualBlockDevice.AsObject>,
+        citrixHostUuid: string,
+        citrixPoolUuid: string,
+    }
+}
+
+export class CitrixGuestExtraInfo extends jspb.Message { 
+
+    hasInfoTypeId(): boolean;
+    clearInfoTypeId(): void;
+    getInfoTypeId(): number | undefined;
+    setInfoTypeId(value: number): CitrixGuestExtraInfo;
+
+    hasKey(): boolean;
+    clearKey(): void;
+    getKey(): string | undefined;
+    setKey(value: string): CitrixGuestExtraInfo;
+
+    hasValue(): boolean;
+    clearValue(): void;
+    getValue(): string | undefined;
+    setValue(value: string): CitrixGuestExtraInfo;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): CitrixGuestExtraInfo.AsObject;
+    static toObject(includeInstance: boolean, msg: CitrixGuestExtraInfo): CitrixGuestExtraInfo.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: CitrixGuestExtraInfo, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): CitrixGuestExtraInfo;
+    static deserializeBinaryFromReader(message: CitrixGuestExtraInfo, reader: jspb.BinaryReader): CitrixGuestExtraInfo;
+}
+
+export namespace CitrixGuestExtraInfo {
+    export type AsObject = {
+        infoTypeId?: number,
+        key?: string,
+        value?: string,
+    }
+}
+
+export class CitrixVirtualBlockDevice extends jspb.Message { 
+
+    hasBootable(): boolean;
+    clearBootable(): void;
+    getBootable(): boolean | undefined;
+    setBootable(value: boolean): CitrixVirtualBlockDevice;
+
+    hasCurrentlyAttached(): boolean;
+    clearCurrentlyAttached(): void;
+    getCurrentlyAttached(): boolean | undefined;
+    setCurrentlyAttached(value: boolean): CitrixVirtualBlockDevice;
+
+    hasDevice(): boolean;
+    clearDevice(): void;
+    getDevice(): string | undefined;
+    setDevice(value: string): CitrixVirtualBlockDevice;
+
+    hasEmpty(): boolean;
+    clearEmpty(): void;
+    getEmpty(): boolean | undefined;
+    setEmpty(value: boolean): CitrixVirtualBlockDevice;
+
+    hasMode(): boolean;
+    clearMode(): void;
+    getMode(): string | undefined;
+    setMode(value: string): CitrixVirtualBlockDevice;
+
+    hasQosAlgorithmParameters(): boolean;
+    clearQosAlgorithmParameters(): void;
+    getQosAlgorithmParameters(): string | undefined;
+    setQosAlgorithmParameters(value: string): CitrixVirtualBlockDevice;
+
+    hasQosAlgorithmType(): boolean;
+    clearQosAlgorithmType(): void;
+    getQosAlgorithmType(): string | undefined;
+    setQosAlgorithmType(value: string): CitrixVirtualBlockDevice;
+
+    hasQosSupportedAlgorithms(): boolean;
+    clearQosSupportedAlgorithms(): void;
+    getQosSupportedAlgorithms(): string | undefined;
+    setQosSupportedAlgorithms(value: string): CitrixVirtualBlockDevice;
+
+    hasRuntimeProperties(): boolean;
+    clearRuntimeProperties(): void;
+    getRuntimeProperties(): string | undefined;
+    setRuntimeProperties(value: string): CitrixVirtualBlockDevice;
+
+    hasStatusCode(): boolean;
+    clearStatusCode(): void;
+    getStatusCode(): number | undefined;
+    setStatusCode(value: number): CitrixVirtualBlockDevice;
+
+    hasStatusDetails(): boolean;
+    clearStatusDetails(): void;
+    getStatusDetails(): string | undefined;
+    setStatusDetails(value: string): CitrixVirtualBlockDevice;
+
+    hasStorageLock(): boolean;
+    clearStorageLock(): void;
+    getStorageLock(): boolean | undefined;
+    setStorageLock(value: boolean): CitrixVirtualBlockDevice;
+
+    hasType(): boolean;
+    clearType(): void;
+    getType(): string | undefined;
+    setType(value: string): CitrixVirtualBlockDevice;
+
+    hasUnpluggable(): boolean;
+    clearUnpluggable(): void;
+    getUnpluggable(): boolean | undefined;
+    setUnpluggable(value: boolean): CitrixVirtualBlockDevice;
+
+    hasUserDevice(): boolean;
+    clearUserDevice(): void;
+    getUserDevice(): string | undefined;
+    setUserDevice(value: string): CitrixVirtualBlockDevice;
+
+    hasVirtualBlockDeviceUuid(): boolean;
+    clearVirtualBlockDeviceUuid(): void;
+    getVirtualBlockDeviceUuid(): string | undefined;
+    setVirtualBlockDeviceUuid(value: string): CitrixVirtualBlockDevice;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): CitrixVirtualBlockDevice.AsObject;
+    static toObject(includeInstance: boolean, msg: CitrixVirtualBlockDevice): CitrixVirtualBlockDevice.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: CitrixVirtualBlockDevice, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): CitrixVirtualBlockDevice;
+    static deserializeBinaryFromReader(message: CitrixVirtualBlockDevice, reader: jspb.BinaryReader): CitrixVirtualBlockDevice;
+}
+
+export namespace CitrixVirtualBlockDevice {
+    export type AsObject = {
+        bootable?: boolean,
+        currentlyAttached?: boolean,
+        device?: string,
+        empty?: boolean,
+        mode?: string,
+        qosAlgorithmParameters?: string,
+        qosAlgorithmType?: string,
+        qosSupportedAlgorithms?: string,
+        runtimeProperties?: string,
+        statusCode?: number,
+        statusDetails?: string,
+        storageLock?: boolean,
+        type?: string,
+        unpluggable?: boolean,
+        userDevice?: string,
+        virtualBlockDeviceUuid?: string,
+    }
+}
+
+export class CitrixPhysicalInterface extends jspb.Message { 
+
+    hasDeviceName(): boolean;
+    clearDeviceName(): void;
+    getDeviceName(): string | undefined;
+    setDeviceName(value: string): CitrixPhysicalInterface;
+
+    hasMac(): boolean;
+    clearMac(): void;
+    getMac(): string | undefined;
+    setMac(value: string): CitrixPhysicalInterface;
+
+    hasMtu(): boolean;
+    clearMtu(): void;
+    getMtu(): number | undefined;
+    setMtu(value: number): CitrixPhysicalInterface;
+
+    hasDns(): boolean;
+    clearDns(): void;
+    getDns(): string | undefined;
+    setDns(value: string): CitrixPhysicalInterface;
+
+    hasIp(): boolean;
+    clearIp(): void;
+    getIp(): string | undefined;
+    setIp(value: string): CitrixPhysicalInterface;
+
+    hasNetmask(): boolean;
+    clearNetmask(): void;
+    getNetmask(): string | undefined;
+    setNetmask(value: string): CitrixPhysicalInterface;
+
+    hasGateway(): boolean;
+    clearGateway(): void;
+    getGateway(): string | undefined;
+    setGateway(value: string): CitrixPhysicalInterface;
+
+    hasVendor(): boolean;
+    clearVendor(): void;
+    getVendor(): string | undefined;
+    setVendor(value: string): CitrixPhysicalInterface;
+
+    hasSpeed(): boolean;
+    clearSpeed(): void;
+    getSpeed(): number | undefined;
+    setSpeed(value: number): CitrixPhysicalInterface;
+
+    hasLastUpdated(): boolean;
+    clearLastUpdated(): void;
+    getLastUpdated(): google_protobuf_timestamp_pb.Timestamp | undefined;
+    setLastUpdated(value?: google_protobuf_timestamp_pb.Timestamp): CitrixPhysicalInterface;
+
+    hasCurrentlyAttached(): boolean;
+    clearCurrentlyAttached(): void;
+    getCurrentlyAttached(): boolean | undefined;
+    setCurrentlyAttached(value: boolean): CitrixPhysicalInterface;
+
+    hasDisallowUnplug(): boolean;
+    clearDisallowUnplug(): void;
+    getDisallowUnplug(): boolean | undefined;
+    setDisallowUnplug(value: boolean): CitrixPhysicalInterface;
+
+    hasIpV6(): boolean;
+    clearIpV6(): void;
+    getIpV6(): string | undefined;
+    setIpV6(value: string): CitrixPhysicalInterface;
+
+    hasDevice(): boolean;
+    clearDevice(): void;
+    getDevice(): string | undefined;
+    setDevice(value: string): CitrixPhysicalInterface;
+
+    hasIpConfigurationMode(): boolean;
+    clearIpConfigurationMode(): void;
+    getIpConfigurationMode(): string | undefined;
+    setIpConfigurationMode(value: string): CitrixPhysicalInterface;
+
+    hasIpV6ConfigurationMode(): boolean;
+    clearIpV6ConfigurationMode(): void;
+    getIpV6ConfigurationMode(): string | undefined;
+    setIpV6ConfigurationMode(value: string): CitrixPhysicalInterface;
+
+    hasIpV6Gateway(): boolean;
+    clearIpV6Gateway(): void;
+    getIpV6Gateway(): string | undefined;
+    setIpV6Gateway(value: string): CitrixPhysicalInterface;
+
+    hasManaged(): boolean;
+    clearManaged(): void;
+    getManaged(): boolean | undefined;
+    setManaged(value: boolean): CitrixPhysicalInterface;
+
+    hasManagement(): boolean;
+    clearManagement(): void;
+    getManagement(): boolean | undefined;
+    setManagement(value: boolean): CitrixPhysicalInterface;
+
+    hasPhysical(): boolean;
+    clearPhysical(): void;
+    getPhysical(): boolean | undefined;
+    setPhysical(value: boolean): CitrixPhysicalInterface;
+
+    hasPrimaryAddressType(): boolean;
+    clearPrimaryAddressType(): void;
+    getPrimaryAddressType(): string | undefined;
+    setPrimaryAddressType(value: string): CitrixPhysicalInterface;
+
+    hasCarrier(): boolean;
+    clearCarrier(): void;
+    getCarrier(): boolean | undefined;
+    setCarrier(value: boolean): CitrixPhysicalInterface;
+
+    hasDuplex(): boolean;
+    clearDuplex(): void;
+    getDuplex(): boolean | undefined;
+    setDuplex(value: boolean): CitrixPhysicalInterface;
+
+    hasDeviceId(): boolean;
+    clearDeviceId(): void;
+    getDeviceId(): string | undefined;
+    setDeviceId(value: string): CitrixPhysicalInterface;
+
+    hasPciBusPath(): boolean;
+    clearPciBusPath(): void;
+    getPciBusPath(): string | undefined;
+    setPciBusPath(value: string): CitrixPhysicalInterface;
+
+    hasVendorId(): boolean;
+    clearVendorId(): void;
+    getVendorId(): string | undefined;
+    setVendorId(value: string): CitrixPhysicalInterface;
+
+    hasVendorName(): boolean;
+    clearVendorName(): void;
+    getVendorName(): string | undefined;
+    setVendorName(value: string): CitrixPhysicalInterface;
+
+    hasHostUuid(): boolean;
+    clearHostUuid(): void;
+    getHostUuid(): string | undefined;
+    setHostUuid(value: string): CitrixPhysicalInterface;
+
+    hasInterfaceUuid(): boolean;
+    clearInterfaceUuid(): void;
+    getInterfaceUuid(): string | undefined;
+    setInterfaceUuid(value: string): CitrixPhysicalInterface;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): CitrixPhysicalInterface.AsObject;
+    static toObject(includeInstance: boolean, msg: CitrixPhysicalInterface): CitrixPhysicalInterface.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: CitrixPhysicalInterface, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): CitrixPhysicalInterface;
+    static deserializeBinaryFromReader(message: CitrixPhysicalInterface, reader: jspb.BinaryReader): CitrixPhysicalInterface;
+}
+
+export namespace CitrixPhysicalInterface {
+    export type AsObject = {
+        deviceName?: string,
+        mac?: string,
+        mtu?: number,
+        dns?: string,
+        ip?: string,
+        netmask?: string,
+        gateway?: string,
+        vendor?: string,
+        speed?: number,
+        lastUpdated?: google_protobuf_timestamp_pb.Timestamp.AsObject,
+        currentlyAttached?: boolean,
+        disallowUnplug?: boolean,
+        ipV6?: string,
+        device?: string,
+        ipConfigurationMode?: string,
+        ipV6ConfigurationMode?: string,
+        ipV6Gateway?: string,
+        managed?: boolean,
+        management?: boolean,
+        physical?: boolean,
+        primaryAddressType?: string,
+        carrier?: boolean,
+        duplex?: boolean,
+        deviceId?: string,
+        pciBusPath?: string,
+        vendorId?: string,
+        vendorName?: string,
+        hostUuid?: string,
+        interfaceUuid?: string,
+    }
+}
+
+export class CitrixVirtualInterfaceAddress extends jspb.Message { 
+
+    hasIpVersion(): boolean;
+    clearIpVersion(): void;
+    getIpVersion(): number | undefined;
+    setIpVersion(value: number): CitrixVirtualInterfaceAddress;
+
+    hasIp(): boolean;
+    clearIp(): void;
+    getIp(): string | undefined;
+    setIp(value: string): CitrixVirtualInterfaceAddress;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): CitrixVirtualInterfaceAddress.AsObject;
+    static toObject(includeInstance: boolean, msg: CitrixVirtualInterfaceAddress): CitrixVirtualInterfaceAddress.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: CitrixVirtualInterfaceAddress, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): CitrixVirtualInterfaceAddress;
+    static deserializeBinaryFromReader(message: CitrixVirtualInterfaceAddress, reader: jspb.BinaryReader): CitrixVirtualInterfaceAddress;
+}
+
+export namespace CitrixVirtualInterfaceAddress {
+    export type AsObject = {
+        ipVersion?: number,
+        ip?: string,
+    }
+}
+
+export class CitrixVirtualInterface extends jspb.Message { 
+
+    hasDevice(): boolean;
+    clearDevice(): void;
+    getDevice(): string | undefined;
+    setDevice(value: string): CitrixVirtualInterface;
+
+    hasMac(): boolean;
+    clearMac(): void;
+    getMac(): string | undefined;
+    setMac(value: string): CitrixVirtualInterface;
+
+    hasMacAutoGenerated(): boolean;
+    clearMacAutoGenerated(): void;
+    getMacAutoGenerated(): boolean | undefined;
+    setMacAutoGenerated(value: boolean): CitrixVirtualInterface;
+
+    hasMtu(): boolean;
+    clearMtu(): void;
+    getMtu(): number | undefined;
+    setMtu(value: number): CitrixVirtualInterface;
+
+    hasStatusCode(): boolean;
+    clearStatusCode(): void;
+    getStatusCode(): number | undefined;
+    setStatusCode(value: number): CitrixVirtualInterface;
+
+    hasStatusDetails(): boolean;
+    clearStatusDetails(): void;
+    getStatusDetails(): string | undefined;
+    setStatusDetails(value: string): CitrixVirtualInterface;
+
+    hasCurrentlyAttached(): boolean;
+    clearCurrentlyAttached(): void;
+    getCurrentlyAttached(): boolean | undefined;
+    setCurrentlyAttached(value: boolean): CitrixVirtualInterface;
+
+    hasQosAlgorithmType(): boolean;
+    clearQosAlgorithmType(): void;
+    getQosAlgorithmType(): string | undefined;
+    setQosAlgorithmType(value: string): CitrixVirtualInterface;
+
+    hasQosAlgorithms(): boolean;
+    clearQosAlgorithms(): void;
+    getQosAlgorithms(): string | undefined;
+    setQosAlgorithms(value: string): CitrixVirtualInterface;
+
+    hasLockingMode(): boolean;
+    clearLockingMode(): void;
+    getLockingMode(): string | undefined;
+    setLockingMode(value: string): CitrixVirtualInterface;
+
+    hasHostUuid(): boolean;
+    clearHostUuid(): void;
+    getHostUuid(): string | undefined;
+    setHostUuid(value: string): CitrixVirtualInterface;
+
+    hasVmRef(): boolean;
+    clearVmRef(): void;
+    getVmRef(): string | undefined;
+    setVmRef(value: string): CitrixVirtualInterface;
+
+    hasInterfaceUuid(): boolean;
+    clearInterfaceUuid(): void;
+    getInterfaceUuid(): string | undefined;
+    setInterfaceUuid(value: string): CitrixVirtualInterface;
+    clearAddressesList(): void;
+    getAddressesList(): Array<CitrixVirtualInterfaceAddress>;
+    setAddressesList(value: Array<CitrixVirtualInterfaceAddress>): CitrixVirtualInterface;
+    addAddresses(value?: CitrixVirtualInterfaceAddress, index?: number): CitrixVirtualInterfaceAddress;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): CitrixVirtualInterface.AsObject;
+    static toObject(includeInstance: boolean, msg: CitrixVirtualInterface): CitrixVirtualInterface.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: CitrixVirtualInterface, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): CitrixVirtualInterface;
+    static deserializeBinaryFromReader(message: CitrixVirtualInterface, reader: jspb.BinaryReader): CitrixVirtualInterface;
+}
+
+export namespace CitrixVirtualInterface {
+    export type AsObject = {
+        device?: string,
+        mac?: string,
+        macAutoGenerated?: boolean,
+        mtu?: number,
+        statusCode?: number,
+        statusDetails?: string,
+        currentlyAttached?: boolean,
+        qosAlgorithmType?: string,
+        qosAlgorithms?: string,
+        lockingMode?: string,
+        hostUuid?: string,
+        vmRef?: string,
+        interfaceUuid?: string,
+        addressesList: Array<CitrixVirtualInterfaceAddress.AsObject>,
+    }
+}
+
 export class IpLocationConfig extends jspb.Message { 
     getName(): string;
     setName(value: string): IpLocationConfig;