@lansweeper/data-platform-outbound-grpc 0.3.21 → 0.3.23

package/gen-proto/outbound_pb.d.ts

@@ -1010,6 +1010,10 @@ export class Computer extends jspb.Message {
     getTpmList(): Array<TrustedPlatformModule>;
     setTpmList(value: Array<TrustedPlatformModule>): Computer;
     addTpm(value?: TrustedPlatformModule, index?: number): TrustedPlatformModule;
+    clearQuickFixEngineeringList(): void;
+    getQuickFixEngineeringList(): Array<ComputerQuickFixEngineering>;
+    setQuickFixEngineeringList(value: Array<ComputerQuickFixEngineering>): Computer;
+    addQuickFixEngineering(value?: ComputerQuickFixEngineering, index?: number): ComputerQuickFixEngineering;
     clearUsbControllerList(): void;
     getUsbControllerList(): Array<ComputerConnectedUsbController>;
     setUsbControllerList(value: Array<ComputerConnectedUsbController>): Computer;
@@ -1110,6 +1114,31 @@ export class Computer extends jspb.Message {
     getMacSataControllerList(): Array<ComputerMacSATAController>;
     setMacSataControllerList(value: Array<ComputerMacSATAController>): Computer;
     addMacSataController(value?: ComputerMacSATAController, index?: number): ComputerMacSATAController;
+    clearMacDisplayList(): void;
+    getMacDisplayList(): Array<ComputerMacDisplay>;
+    setMacDisplayList(value: Array<ComputerMacDisplay>): Computer;
+    addMacDisplay(value?: ComputerMacDisplay, index?: number): ComputerMacDisplay;
+    clearMacFirewireList(): void;
+    getMacFirewireList(): Array<ComputerMacFirewire>;
+    setMacFirewireList(value: Array<ComputerMacFirewire>): Computer;
+    addMacFirewire(value?: ComputerMacFirewire, index?: number): ComputerMacFirewire;
+
+    hasLinuxMemoryController(): boolean;
+    clearLinuxMemoryController(): void;
+    getLinuxMemoryController(): ComputerLinuxMemoryController | undefined;
+    setLinuxMemoryController(value?: ComputerLinuxMemoryController): Computer;
+    clearLinuxMemoryModuleList(): void;
+    getLinuxMemoryModuleList(): Array<ComputerLinuxMemoryModule>;
+    setLinuxMemoryModuleList(value: Array<ComputerLinuxMemoryModule>): Computer;
+    addLinuxMemoryModule(value?: ComputerLinuxMemoryModule, index?: number): ComputerLinuxMemoryModule;
+    clearLinuxVolumeGroupList(): void;
+    getLinuxVolumeGroupList(): Array<ComputerLinuxVolumeGroup>;
+    setLinuxVolumeGroupList(value: Array<ComputerLinuxVolumeGroup>): Computer;
+    addLinuxVolumeGroup(value?: ComputerLinuxVolumeGroup, index?: number): ComputerLinuxVolumeGroup;
+    clearLinuxPhysicalHardDiskList(): void;
+    getLinuxPhysicalHardDiskList(): Array<ComputerLinuxPhysicalHardDisk>;
+    setLinuxPhysicalHardDiskList(value: Array<ComputerLinuxPhysicalHardDisk>): Computer;
+    addLinuxPhysicalHardDisk(value?: ComputerLinuxPhysicalHardDisk, index?: number): ComputerLinuxPhysicalHardDisk;
 
     hasBios(): boolean;
     clearBios(): void;
@@ -1311,6 +1340,7 @@ export namespace Computer {
         hardDriveList: Array<HardDrive.AsObject>,
         driveVolumeList: Array<DriveVolume.AsObject>,
         tpmList: Array<TrustedPlatformModule.AsObject>,
+        quickFixEngineeringList: Array<ComputerQuickFixEngineering.AsObject>,
         usbControllerList: Array<ComputerConnectedUsbController.AsObject>,
         usbDeviceInfoList: Array<ComputerConnectedUsbDeviceInfo.AsObject>,
         modemList: Array<ComputerConnectedModem.AsObject>,
@@ -1335,6 +1365,12 @@ export namespace Computer {
         macNvmExpress?: ComputerMacNVMExpress.AsObject,
         macSpiDeviceList: Array<ComputerMacSPIDevice.AsObject>,
         macSataControllerList: Array<ComputerMacSATAController.AsObject>,
+        macDisplayList: Array<ComputerMacDisplay.AsObject>,
+        macFirewireList: Array<ComputerMacFirewire.AsObject>,
+        linuxMemoryController?: ComputerLinuxMemoryController.AsObject,
+        linuxMemoryModuleList: Array<ComputerLinuxMemoryModule.AsObject>,
+        linuxVolumeGroupList: Array<ComputerLinuxVolumeGroup.AsObject>,
+        linuxPhysicalHardDiskList: Array<ComputerLinuxPhysicalHardDisk.AsObject>,
         bios?: Bios.AsObject,
         osPatchList: Array<OperatingSystemPatch.AsObject>,
         osFeatureList: Array<OperatingSystemFeature.AsObject>,
@@ -2850,6 +2886,11 @@ export class CoreFields extends jspb.Message {
     clearFqdn(): void;
     getFqdn(): string | undefined;
     setFqdn(value: string): CoreFields;
+
+    hasDnsName(): boolean;
+    clearDnsName(): void;
+    getDnsName(): string | undefined;
+    setDnsName(value: string): CoreFields;
     getConfidence(): number;
     setConfidence(value: number): CoreFields;
 
@@ -2879,6 +2920,7 @@ export namespace CoreFields {
         macVendor?: string,
         sensorId?: string,
         fqdn?: string,
+        dnsName?: string,
         confidence: number,
         classicScannedBy?: number,
     }
@@ -6106,6 +6148,65 @@ export namespace ComputerInfrared {
     }
 }
 
+export class ComputerQuickFixEngineering extends jspb.Message { 
+
+    hasHotFixId(): boolean;
+    clearHotFixId(): void;
+    getHotFixId(): string | undefined;
+    setHotFixId(value: string): ComputerQuickFixEngineering;
+
+    hasDescription(): boolean;
+    clearDescription(): void;
+    getDescription(): string | undefined;
+    setDescription(value: string): ComputerQuickFixEngineering;
+
+    hasInstalledBy(): boolean;
+    clearInstalledBy(): void;
+    getInstalledBy(): string | undefined;
+    setInstalledBy(value: string): ComputerQuickFixEngineering;
+
+    hasInstalledOn(): boolean;
+    clearInstalledOn(): void;
+    getInstalledOn(): string | undefined;
+    setInstalledOn(value: string): ComputerQuickFixEngineering;
+
+    hasFixComment(): boolean;
+    clearFixComment(): void;
+    getFixComment(): string | undefined;
+    setFixComment(value: string): ComputerQuickFixEngineering;
+
+    hasServicePackInEffect(): boolean;
+    clearServicePackInEffect(): void;
+    getServicePackInEffect(): string | undefined;
+    setServicePackInEffect(value: string): ComputerQuickFixEngineering;
+
+    hasHash(): boolean;
+    clearHash(): void;
+    getHash(): string | undefined;
+    setHash(value: string): ComputerQuickFixEngineering;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): ComputerQuickFixEngineering.AsObject;
+    static toObject(includeInstance: boolean, msg: ComputerQuickFixEngineering): ComputerQuickFixEngineering.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: ComputerQuickFixEngineering, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): ComputerQuickFixEngineering;
+    static deserializeBinaryFromReader(message: ComputerQuickFixEngineering, reader: jspb.BinaryReader): ComputerQuickFixEngineering;
+}
+
+export namespace ComputerQuickFixEngineering {
+    export type AsObject = {
+        hotFixId?: string,
+        description?: string,
+        installedBy?: string,
+        installedOn?: string,
+        fixComment?: string,
+        servicePackInEffect?: string,
+        hash?: string,
+    }
+}
+
 export class PointingDevice extends jspb.Message { 
 
     hasCaption(): boolean;
@@ -7676,6 +7777,388 @@ export namespace NVMExpress {
     }
 }
 
+export class ComputerLinuxMemoryController extends jspb.Message { 
+
+    hasSupportedInterleave(): boolean;
+    clearSupportedInterleave(): void;
+    getSupportedInterleave(): string | undefined;
+    setSupportedInterleave(value: string): ComputerLinuxMemoryController;
+
+    hasCurrentInterleave(): boolean;
+    clearCurrentInterleave(): void;
+    getCurrentInterleave(): string | undefined;
+    setCurrentInterleave(value: string): ComputerLinuxMemoryController;
+
+    hasMaxMemoryModuleSize(): boolean;
+    clearMaxMemoryModuleSize(): void;
+    getMaxMemoryModuleSize(): string | undefined;
+    setMaxMemoryModuleSize(value: string): ComputerLinuxMemoryController;
+
+    hasMaxTotalMemorySize(): boolean;
+    clearMaxTotalMemorySize(): void;
+    getMaxTotalMemorySize(): string | undefined;
+    setMaxTotalMemorySize(value: string): ComputerLinuxMemoryController;
+
+    hasSupportedSpeeds(): boolean;
+    clearSupportedSpeeds(): void;
+    getSupportedSpeeds(): string | undefined;
+    setSupportedSpeeds(value: string): ComputerLinuxMemoryController;
+
+    hasSupportedMemTypes(): boolean;
+    clearSupportedMemTypes(): void;
+    getSupportedMemTypes(): string | undefined;
+    setSupportedMemTypes(value: string): ComputerLinuxMemoryController;
+
+    hasMemoryModuleVoltage(): boolean;
+    clearMemoryModuleVoltage(): void;
+    getMemoryModuleVoltage(): string | undefined;
+    setMemoryModuleVoltage(value: string): ComputerLinuxMemoryController;
+
+    hasNumberOfSlots(): boolean;
+    clearNumberOfSlots(): void;
+    getNumberOfSlots(): string | undefined;
+    setNumberOfSlots(value: string): ComputerLinuxMemoryController;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): ComputerLinuxMemoryController.AsObject;
+    static toObject(includeInstance: boolean, msg: ComputerLinuxMemoryController): ComputerLinuxMemoryController.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: ComputerLinuxMemoryController, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): ComputerLinuxMemoryController;
+    static deserializeBinaryFromReader(message: ComputerLinuxMemoryController, reader: jspb.BinaryReader): ComputerLinuxMemoryController;
+}
+
+export namespace ComputerLinuxMemoryController {
+    export type AsObject = {
+        supportedInterleave?: string,
+        currentInterleave?: string,
+        maxMemoryModuleSize?: string,
+        maxTotalMemorySize?: string,
+        supportedSpeeds?: string,
+        supportedMemTypes?: string,
+        memoryModuleVoltage?: string,
+        numberOfSlots?: string,
+    }
+}
+
+export class ComputerLinuxVolumeGroup extends jspb.Message { 
+
+    hasName(): boolean;
+    clearName(): void;
+    getName(): string | undefined;
+    setName(value: string): ComputerLinuxVolumeGroup;
+
+    hasUuid(): boolean;
+    clearUuid(): void;
+    getUuid(): string | undefined;
+    setUuid(value: string): ComputerLinuxVolumeGroup;
+
+    hasSize(): boolean;
+    clearSize(): void;
+    getSize(): number | undefined;
+    setSize(value: number): ComputerLinuxVolumeGroup;
+
+    hasFree(): boolean;
+    clearFree(): void;
+    getFree(): number | undefined;
+    setFree(value: number): ComputerLinuxVolumeGroup;
+
+    hasPermissions(): boolean;
+    clearPermissions(): void;
+    getPermissions(): string | undefined;
+    setPermissions(value: string): ComputerLinuxVolumeGroup;
+
+    hasStatus(): boolean;
+    clearStatus(): void;
+    getStatus(): string | undefined;
+    setStatus(value: string): ComputerLinuxVolumeGroup;
+
+    hasFormat(): boolean;
+    clearFormat(): void;
+    getFormat(): string | undefined;
+    setFormat(value: string): ComputerLinuxVolumeGroup;
+    clearLinuxLogicalVolumesList(): void;
+    getLinuxLogicalVolumesList(): Array<ComputerLinuxLogicalVolume>;
+    setLinuxLogicalVolumesList(value: Array<ComputerLinuxLogicalVolume>): ComputerLinuxVolumeGroup;
+    addLinuxLogicalVolumes(value?: ComputerLinuxLogicalVolume, index?: number): ComputerLinuxLogicalVolume;
+    clearLinuxPhysicalVolumesList(): void;
+    getLinuxPhysicalVolumesList(): Array<ComputerLinuxPhysicalVolume>;
+    setLinuxPhysicalVolumesList(value: Array<ComputerLinuxPhysicalVolume>): ComputerLinuxVolumeGroup;
+    addLinuxPhysicalVolumes(value?: ComputerLinuxPhysicalVolume, index?: number): ComputerLinuxPhysicalVolume;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): ComputerLinuxVolumeGroup.AsObject;
+    static toObject(includeInstance: boolean, msg: ComputerLinuxVolumeGroup): ComputerLinuxVolumeGroup.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: ComputerLinuxVolumeGroup, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): ComputerLinuxVolumeGroup;
+    static deserializeBinaryFromReader(message: ComputerLinuxVolumeGroup, reader: jspb.BinaryReader): ComputerLinuxVolumeGroup;
+}
+
+export namespace ComputerLinuxVolumeGroup {
+    export type AsObject = {
+        name?: string,
+        uuid?: string,
+        size?: number,
+        free?: number,
+        permissions?: string,
+        status?: string,
+        format?: string,
+        linuxLogicalVolumesList: Array<ComputerLinuxLogicalVolume.AsObject>,
+        linuxPhysicalVolumesList: Array<ComputerLinuxPhysicalVolume.AsObject>,
+    }
+}
+
+export class ComputerLinuxLogicalVolume extends jspb.Message { 
+
+    hasRelatedGroup(): boolean;
+    clearRelatedGroup(): void;
+    getRelatedGroup(): string | undefined;
+    setRelatedGroup(value: string): ComputerLinuxLogicalVolume;
+
+    hasName(): boolean;
+    clearName(): void;
+    getName(): string | undefined;
+    setName(value: string): ComputerLinuxLogicalVolume;
+
+    hasUuid(): boolean;
+    clearUuid(): void;
+    getUuid(): string | undefined;
+    setUuid(value: string): ComputerLinuxLogicalVolume;
+
+    hasDeviceMapperPath(): boolean;
+    clearDeviceMapperPath(): void;
+    getDeviceMapperPath(): string | undefined;
+    setDeviceMapperPath(value: string): ComputerLinuxLogicalVolume;
+
+    hasSize(): boolean;
+    clearSize(): void;
+    getSize(): number | undefined;
+    setSize(value: number): ComputerLinuxLogicalVolume;
+
+    hasBlockDevice(): boolean;
+    clearBlockDevice(): void;
+    getBlockDevice(): string | undefined;
+    setBlockDevice(value: string): ComputerLinuxLogicalVolume;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): ComputerLinuxLogicalVolume.AsObject;
+    static toObject(includeInstance: boolean, msg: ComputerLinuxLogicalVolume): ComputerLinuxLogicalVolume.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: ComputerLinuxLogicalVolume, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): ComputerLinuxLogicalVolume;
+    static deserializeBinaryFromReader(message: ComputerLinuxLogicalVolume, reader: jspb.BinaryReader): ComputerLinuxLogicalVolume;
+}
+
+export namespace ComputerLinuxLogicalVolume {
+    export type AsObject = {
+        relatedGroup?: string,
+        name?: string,
+        uuid?: string,
+        deviceMapperPath?: string,
+        size?: number,
+        blockDevice?: string,
+    }
+}
+
+export class ComputerLinuxPhysicalVolume extends jspb.Message { 
+
+    hasRelatedGroup(): boolean;
+    clearRelatedGroup(): void;
+    getRelatedGroup(): string | undefined;
+    setRelatedGroup(value: string): ComputerLinuxPhysicalVolume;
+
+    hasName(): boolean;
+    clearName(): void;
+    getName(): string | undefined;
+    setName(value: string): ComputerLinuxPhysicalVolume;
+
+    hasUuid(): boolean;
+    clearUuid(): void;
+    getUuid(): string | undefined;
+    setUuid(value: string): ComputerLinuxPhysicalVolume;
+
+    hasSize(): boolean;
+    clearSize(): void;
+    getSize(): number | undefined;
+    setSize(value: number): ComputerLinuxPhysicalVolume;
+
+    hasFree(): boolean;
+    clearFree(): void;
+    getFree(): number | undefined;
+    setFree(value: number): ComputerLinuxPhysicalVolume;
+
+    hasUsed(): boolean;
+    clearUsed(): void;
+    getUsed(): number | undefined;
+    setUsed(value: number): ComputerLinuxPhysicalVolume;
+
+    hasInUse(): boolean;
+    clearInUse(): void;
+    getInUse(): string | undefined;
+    setInUse(value: string): ComputerLinuxPhysicalVolume;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): ComputerLinuxPhysicalVolume.AsObject;
+    static toObject(includeInstance: boolean, msg: ComputerLinuxPhysicalVolume): ComputerLinuxPhysicalVolume.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: ComputerLinuxPhysicalVolume, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): ComputerLinuxPhysicalVolume;
+    static deserializeBinaryFromReader(message: ComputerLinuxPhysicalVolume, reader: jspb.BinaryReader): ComputerLinuxPhysicalVolume;
+}
+
+export namespace ComputerLinuxPhysicalVolume {
+    export type AsObject = {
+        relatedGroup?: string,
+        name?: string,
+        uuid?: string,
+        size?: number,
+        free?: number,
+        used?: number,
+        inUse?: string,
+    }
+}
+
+export class ComputerLinuxPhysicalHardDisk extends jspb.Message { 
+
+    hasName(): boolean;
+    clearName(): void;
+    getName(): string | undefined;
+    setName(value: string): ComputerLinuxPhysicalHardDisk;
+
+    hasState(): boolean;
+    clearState(): void;
+    getState(): string | undefined;
+    setState(value: string): ComputerLinuxPhysicalHardDisk;
+
+    hasSize(): boolean;
+    clearSize(): void;
+    getSize(): number | undefined;
+    setSize(value: number): ComputerLinuxPhysicalHardDisk;
+
+    hasHctl(): boolean;
+    clearHctl(): void;
+    getHctl(): string | undefined;
+    setHctl(value: string): ComputerLinuxPhysicalHardDisk;
+
+    hasMajmin(): boolean;
+    clearMajmin(): void;
+    getMajmin(): string | undefined;
+    setMajmin(value: string): ComputerLinuxPhysicalHardDisk;
+
+    hasHotplug(): boolean;
+    clearHotplug(): void;
+    getHotplug(): boolean | undefined;
+    setHotplug(value: boolean): ComputerLinuxPhysicalHardDisk;
+
+    hasModel(): boolean;
+    clearModel(): void;
+    getModel(): string | undefined;
+    setModel(value: string): ComputerLinuxPhysicalHardDisk;
+
+    hasSerial(): boolean;
+    clearSerial(): void;
+    getSerial(): string | undefined;
+    setSerial(value: string): ComputerLinuxPhysicalHardDisk;
+
+    hasVendor(): boolean;
+    clearVendor(): void;
+    getVendor(): string | undefined;
+    setVendor(value: string): ComputerLinuxPhysicalHardDisk;
+
+    hasRev(): boolean;
+    clearRev(): void;
+    getRev(): string | undefined;
+    setRev(value: string): ComputerLinuxPhysicalHardDisk;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): ComputerLinuxPhysicalHardDisk.AsObject;
+    static toObject(includeInstance: boolean, msg: ComputerLinuxPhysicalHardDisk): ComputerLinuxPhysicalHardDisk.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: ComputerLinuxPhysicalHardDisk, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): ComputerLinuxPhysicalHardDisk;
+    static deserializeBinaryFromReader(message: ComputerLinuxPhysicalHardDisk, reader: jspb.BinaryReader): ComputerLinuxPhysicalHardDisk;
+}
+
+export namespace ComputerLinuxPhysicalHardDisk {
+    export type AsObject = {
+        name?: string,
+        state?: string,
+        size?: number,
+        hctl?: string,
+        majmin?: string,
+        hotplug?: boolean,
+        model?: string,
+        serial?: string,
+        vendor?: string,
+        rev?: string,
+    }
+}
+
+export class ComputerLinuxMemoryModule extends jspb.Message { 
+
+    hasSocket(): boolean;
+    clearSocket(): void;
+    getSocket(): string | undefined;
+    setSocket(value: string): ComputerLinuxMemoryModule;
+
+    hasBankConnections(): boolean;
+    clearBankConnections(): void;
+    getBankConnections(): string | undefined;
+    setBankConnections(value: string): ComputerLinuxMemoryModule;
+
+    hasCurrentSpeed(): boolean;
+    clearCurrentSpeed(): void;
+    getCurrentSpeed(): string | undefined;
+    setCurrentSpeed(value: string): ComputerLinuxMemoryModule;
+
+    hasType(): boolean;
+    clearType(): void;
+    getType(): string | undefined;
+    setType(value: string): ComputerLinuxMemoryModule;
+
+    hasInstalledSize(): boolean;
+    clearInstalledSize(): void;
+    getInstalledSize(): string | undefined;
+    setInstalledSize(value: string): ComputerLinuxMemoryModule;
+
+    hasEnabledSize(): boolean;
+    clearEnabledSize(): void;
+    getEnabledSize(): string | undefined;
+    setEnabledSize(value: string): ComputerLinuxMemoryModule;
+
+    hasErrorStatus(): boolean;
+    clearErrorStatus(): void;
+    getErrorStatus(): string | undefined;
+    setErrorStatus(value: string): ComputerLinuxMemoryModule;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): ComputerLinuxMemoryModule.AsObject;
+    static toObject(includeInstance: boolean, msg: ComputerLinuxMemoryModule): ComputerLinuxMemoryModule.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: ComputerLinuxMemoryModule, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): ComputerLinuxMemoryModule;
+    static deserializeBinaryFromReader(message: ComputerLinuxMemoryModule, reader: jspb.BinaryReader): ComputerLinuxMemoryModule;
+}
+
+export namespace ComputerLinuxMemoryModule {
+    export type AsObject = {
+        socket?: string,
+        bankConnections?: string,
+        currentSpeed?: string,
+        type?: string,
+        installedSize?: string,
+        enabledSize?: string,
+        errorStatus?: string,
+    }
+}
+
 export class ComputerMacSATAController extends jspb.Message { 
 
     hasName(): boolean;
@@ -12653,6 +13136,118 @@ export namespace ComputerMacCardReader {
     }
 }
 
+export class ComputerMacDisplay extends jspb.Message { 
+
+    hasName(): boolean;
+    clearName(): void;
+    getName(): string | undefined;
+    setName(value: string): ComputerMacDisplay;
+
+    hasDeviceType(): boolean;
+    clearDeviceType(): void;
+    getDeviceType(): string | undefined;
+    setDeviceType(value: string): ComputerMacDisplay;
+
+    hasDisplayType(): boolean;
+    clearDisplayType(): void;
+    getDisplayType(): string | undefined;
+    setDisplayType(value: string): ComputerMacDisplay;
+
+    hasBuiltIn(): boolean;
+    clearBuiltIn(): void;
+    getBuiltIn(): boolean | undefined;
+    setBuiltIn(value: boolean): ComputerMacDisplay;
+
+    hasDepth(): boolean;
+    clearDepth(): void;
+    getDepth(): string | undefined;
+    setDepth(value: string): ComputerMacDisplay;
+
+    hasMain(): boolean;
+    clearMain(): void;
+    getMain(): boolean | undefined;
+    setMain(value: boolean): ComputerMacDisplay;
+
+    hasMirror(): boolean;
+    clearMirror(): void;
+    getMirror(): string | undefined;
+    setMirror(value: string): ComputerMacDisplay;
+
+    hasOnline(): boolean;
+    clearOnline(): void;
+    getOnline(): boolean | undefined;
+    setOnline(value: boolean): ComputerMacDisplay;
+
+    hasResolution(): boolean;
+    clearResolution(): void;
+    getResolution(): string | undefined;
+    setResolution(value: string): ComputerMacDisplay;
+
+    hasCoreImage(): boolean;
+    clearCoreImage(): void;
+    getCoreImage(): string | undefined;
+    setCoreImage(value: string): ComputerMacDisplay;
+
+    hasQuartzExtreme(): boolean;
+    clearQuartzExtreme(): void;
+    getQuartzExtreme(): string | undefined;
+    setQuartzExtreme(value: string): ComputerMacDisplay;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): ComputerMacDisplay.AsObject;
+    static toObject(includeInstance: boolean, msg: ComputerMacDisplay): ComputerMacDisplay.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: ComputerMacDisplay, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): ComputerMacDisplay;
+    static deserializeBinaryFromReader(message: ComputerMacDisplay, reader: jspb.BinaryReader): ComputerMacDisplay;
+}
+
+export namespace ComputerMacDisplay {
+    export type AsObject = {
+        name?: string,
+        deviceType?: string,
+        displayType?: string,
+        builtIn?: boolean,
+        depth?: string,
+        main?: boolean,
+        mirror?: string,
+        online?: boolean,
+        resolution?: string,
+        coreImage?: string,
+        quartzExtreme?: string,
+    }
+}
+
+export class ComputerMacFirewire extends jspb.Message { 
+
+    hasName(): boolean;
+    clearName(): void;
+    getName(): string | undefined;
+    setName(value: string): ComputerMacFirewire;
+
+    hasMaxSpeed(): boolean;
+    clearMaxSpeed(): void;
+    getMaxSpeed(): string | undefined;
+    setMaxSpeed(value: string): ComputerMacFirewire;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): ComputerMacFirewire.AsObject;
+    static toObject(includeInstance: boolean, msg: ComputerMacFirewire): ComputerMacFirewire.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: ComputerMacFirewire, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): ComputerMacFirewire;
+    static deserializeBinaryFromReader(message: ComputerMacFirewire, reader: jspb.BinaryReader): ComputerMacFirewire;
+}
+
+export namespace ComputerMacFirewire {
+    export type AsObject = {
+        name?: string,
+        maxSpeed?: string,
+    }
+}
+
 export class ComputerWindowsDisplayController extends jspb.Message { 
 
     hasBitsPerPixel(): boolean;