diff --git a/src/protos/device_state.ts b/src/protos/device_state.ts index d4a1a6b..328483c 100644 --- a/src/protos/device_state.ts +++ b/src/protos/device_state.ts @@ -2380,6 +2380,53 @@ export namespace state { allDoorClose?: boolean; udpInterruption?: boolean; updateTime?: number; + forceDoorAllow?: boolean; + modeLevelDownBtn?: boolean; + confirmBtn?: boolean; + modeLevelUpBtn?: boolean; + atoSendTrainBtn?: boolean; + trainIntegrity?: boolean; + atpOrAtoBypassState?: boolean; + obstacleCheckBtn?: boolean; + driverActiveReportBtn?: boolean; + brakeHeavyFault?: boolean; + leftDoorStateBtn?: boolean; + rightDoorStateBtn?: boolean; + wakeUpBtn?: boolean; + overhaulBtn?: boolean; + undervoltageBtn?: boolean; + sleepBtn?: boolean; + emergentHandleDown?: boolean; + doorLockState?: boolean; + lifeDoorState?: boolean; + trainLowPowerResetState?: boolean; + atpPowerOnBtn?: boolean; + doorModeAA?: boolean; + doorModeAM?: boolean; + doorModeMM?: boolean; + outerEmergentBrakeReport?: boolean; + trainDoorOutLed?: boolean; + localAtpControl?: boolean; + atoBrakeCommand?: boolean; + atoTractionCommandOut?: boolean; + atoLazyCommandOut?: boolean; + atoAlwaysBrake?: boolean; + atoOpenLeftDoor?: boolean; + atoOpenRightDoor?: boolean; + atoCloseLeftDoor?: boolean; + noSpeedSigle?: boolean; + trainStartedLed?: boolean; + mostUseBrake?: boolean; + splittingOut?: boolean; + modeRelay?: boolean; + tractionEffective?: boolean; + brakeEffective?: boolean; + brakeQuarantine?: boolean; + stopNotAllBrake?: boolean; + atoTractionCommand1?: boolean; + atoTractionCommand2?: boolean; + atoTractionCommand3?: boolean; + mockInfo?: number; }) { super(); pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls); @@ -2462,6 +2509,147 @@ export namespace state { if ("updateTime" in data && data.updateTime != undefined) { this.updateTime = data.updateTime; } + if ("forceDoorAllow" in data && data.forceDoorAllow != undefined) { + this.forceDoorAllow = data.forceDoorAllow; + } + if ("modeLevelDownBtn" in data && data.modeLevelDownBtn != undefined) { + this.modeLevelDownBtn = data.modeLevelDownBtn; + } + if ("confirmBtn" in data && data.confirmBtn != undefined) { + this.confirmBtn = data.confirmBtn; + } + if ("modeLevelUpBtn" in data && data.modeLevelUpBtn != undefined) { + this.modeLevelUpBtn = data.modeLevelUpBtn; + } + if ("atoSendTrainBtn" in data && data.atoSendTrainBtn != undefined) { + this.atoSendTrainBtn = data.atoSendTrainBtn; + } + if ("trainIntegrity" in data && data.trainIntegrity != undefined) { + this.trainIntegrity = data.trainIntegrity; + } + if ("atpOrAtoBypassState" in data && data.atpOrAtoBypassState != undefined) { + this.atpOrAtoBypassState = data.atpOrAtoBypassState; + } + if ("obstacleCheckBtn" in data && data.obstacleCheckBtn != undefined) { + this.obstacleCheckBtn = data.obstacleCheckBtn; + } + if ("driverActiveReportBtn" in data && data.driverActiveReportBtn != undefined) { + this.driverActiveReportBtn = data.driverActiveReportBtn; + } + if ("brakeHeavyFault" in data && data.brakeHeavyFault != undefined) { + this.brakeHeavyFault = data.brakeHeavyFault; + } + if ("leftDoorStateBtn" in data && data.leftDoorStateBtn != undefined) { + this.leftDoorStateBtn = data.leftDoorStateBtn; + } + if ("rightDoorStateBtn" in data && data.rightDoorStateBtn != undefined) { + this.rightDoorStateBtn = data.rightDoorStateBtn; + } + if ("wakeUpBtn" in data && data.wakeUpBtn != undefined) { + this.wakeUpBtn = data.wakeUpBtn; + } + if ("overhaulBtn" in data && data.overhaulBtn != undefined) { + this.overhaulBtn = data.overhaulBtn; + } + if ("undervoltageBtn" in data && data.undervoltageBtn != undefined) { + this.undervoltageBtn = data.undervoltageBtn; + } + if ("sleepBtn" in data && data.sleepBtn != undefined) { + this.sleepBtn = data.sleepBtn; + } + if ("emergentHandleDown" in data && data.emergentHandleDown != undefined) { + this.emergentHandleDown = data.emergentHandleDown; + } + if ("doorLockState" in data && data.doorLockState != undefined) { + this.doorLockState = data.doorLockState; + } + if ("lifeDoorState" in data && data.lifeDoorState != undefined) { + this.lifeDoorState = data.lifeDoorState; + } + if ("trainLowPowerResetState" in data && data.trainLowPowerResetState != undefined) { + this.trainLowPowerResetState = data.trainLowPowerResetState; + } + if ("atpPowerOnBtn" in data && data.atpPowerOnBtn != undefined) { + this.atpPowerOnBtn = data.atpPowerOnBtn; + } + if ("doorModeAA" in data && data.doorModeAA != undefined) { + this.doorModeAA = data.doorModeAA; + } + if ("doorModeAM" in data && data.doorModeAM != undefined) { + this.doorModeAM = data.doorModeAM; + } + if ("doorModeMM" in data && data.doorModeMM != undefined) { + this.doorModeMM = data.doorModeMM; + } + if ("outerEmergentBrakeReport" in data && data.outerEmergentBrakeReport != undefined) { + this.outerEmergentBrakeReport = data.outerEmergentBrakeReport; + } + if ("trainDoorOutLed" in data && data.trainDoorOutLed != undefined) { + this.trainDoorOutLed = data.trainDoorOutLed; + } + if ("localAtpControl" in data && data.localAtpControl != undefined) { + this.localAtpControl = data.localAtpControl; + } + if ("atoBrakeCommand" in data && data.atoBrakeCommand != undefined) { + this.atoBrakeCommand = data.atoBrakeCommand; + } + if ("atoTractionCommandOut" in data && data.atoTractionCommandOut != undefined) { + this.atoTractionCommandOut = data.atoTractionCommandOut; + } + if ("atoLazyCommandOut" in data && data.atoLazyCommandOut != undefined) { + this.atoLazyCommandOut = data.atoLazyCommandOut; + } + if ("atoAlwaysBrake" in data && data.atoAlwaysBrake != undefined) { + this.atoAlwaysBrake = data.atoAlwaysBrake; + } + if ("atoOpenLeftDoor" in data && data.atoOpenLeftDoor != undefined) { + this.atoOpenLeftDoor = data.atoOpenLeftDoor; + } + if ("atoOpenRightDoor" in data && data.atoOpenRightDoor != undefined) { + this.atoOpenRightDoor = data.atoOpenRightDoor; + } + if ("atoCloseLeftDoor" in data && data.atoCloseLeftDoor != undefined) { + this.atoCloseLeftDoor = data.atoCloseLeftDoor; + } + if ("noSpeedSigle" in data && data.noSpeedSigle != undefined) { + this.noSpeedSigle = data.noSpeedSigle; + } + if ("trainStartedLed" in data && data.trainStartedLed != undefined) { + this.trainStartedLed = data.trainStartedLed; + } + if ("mostUseBrake" in data && data.mostUseBrake != undefined) { + this.mostUseBrake = data.mostUseBrake; + } + if ("splittingOut" in data && data.splittingOut != undefined) { + this.splittingOut = data.splittingOut; + } + if ("modeRelay" in data && data.modeRelay != undefined) { + this.modeRelay = data.modeRelay; + } + if ("tractionEffective" in data && data.tractionEffective != undefined) { + this.tractionEffective = data.tractionEffective; + } + if ("brakeEffective" in data && data.brakeEffective != undefined) { + this.brakeEffective = data.brakeEffective; + } + if ("brakeQuarantine" in data && data.brakeQuarantine != undefined) { + this.brakeQuarantine = data.brakeQuarantine; + } + if ("stopNotAllBrake" in data && data.stopNotAllBrake != undefined) { + this.stopNotAllBrake = data.stopNotAllBrake; + } + if ("atoTractionCommand1" in data && data.atoTractionCommand1 != undefined) { + this.atoTractionCommand1 = data.atoTractionCommand1; + } + if ("atoTractionCommand2" in data && data.atoTractionCommand2 != undefined) { + this.atoTractionCommand2 = data.atoTractionCommand2; + } + if ("atoTractionCommand3" in data && data.atoTractionCommand3 != undefined) { + this.atoTractionCommand3 = data.atoTractionCommand3; + } + if ("mockInfo" in data && data.mockInfo != undefined) { + this.mockInfo = data.mockInfo; + } } } get lifeSignal() { @@ -2620,6 +2808,288 @@ export namespace state { set updateTime(value: number) { pb_1.Message.setField(this, 26, value); } + get forceDoorAllow() { + return pb_1.Message.getFieldWithDefault(this, 27, false) as boolean; + } + set forceDoorAllow(value: boolean) { + pb_1.Message.setField(this, 27, value); + } + get modeLevelDownBtn() { + return pb_1.Message.getFieldWithDefault(this, 28, false) as boolean; + } + set modeLevelDownBtn(value: boolean) { + pb_1.Message.setField(this, 28, value); + } + get confirmBtn() { + return pb_1.Message.getFieldWithDefault(this, 29, false) as boolean; + } + set confirmBtn(value: boolean) { + pb_1.Message.setField(this, 29, value); + } + get modeLevelUpBtn() { + return pb_1.Message.getFieldWithDefault(this, 30, false) as boolean; + } + set modeLevelUpBtn(value: boolean) { + pb_1.Message.setField(this, 30, value); + } + get atoSendTrainBtn() { + return pb_1.Message.getFieldWithDefault(this, 31, false) as boolean; + } + set atoSendTrainBtn(value: boolean) { + pb_1.Message.setField(this, 31, value); + } + get trainIntegrity() { + return pb_1.Message.getFieldWithDefault(this, 32, false) as boolean; + } + set trainIntegrity(value: boolean) { + pb_1.Message.setField(this, 32, value); + } + get atpOrAtoBypassState() { + return pb_1.Message.getFieldWithDefault(this, 33, false) as boolean; + } + set atpOrAtoBypassState(value: boolean) { + pb_1.Message.setField(this, 33, value); + } + get obstacleCheckBtn() { + return pb_1.Message.getFieldWithDefault(this, 35, false) as boolean; + } + set obstacleCheckBtn(value: boolean) { + pb_1.Message.setField(this, 35, value); + } + get driverActiveReportBtn() { + return pb_1.Message.getFieldWithDefault(this, 36, false) as boolean; + } + set driverActiveReportBtn(value: boolean) { + pb_1.Message.setField(this, 36, value); + } + get brakeHeavyFault() { + return pb_1.Message.getFieldWithDefault(this, 37, false) as boolean; + } + set brakeHeavyFault(value: boolean) { + pb_1.Message.setField(this, 37, value); + } + get leftDoorStateBtn() { + return pb_1.Message.getFieldWithDefault(this, 38, false) as boolean; + } + set leftDoorStateBtn(value: boolean) { + pb_1.Message.setField(this, 38, value); + } + get rightDoorStateBtn() { + return pb_1.Message.getFieldWithDefault(this, 39, false) as boolean; + } + set rightDoorStateBtn(value: boolean) { + pb_1.Message.setField(this, 39, value); + } + get wakeUpBtn() { + return pb_1.Message.getFieldWithDefault(this, 40, false) as boolean; + } + set wakeUpBtn(value: boolean) { + pb_1.Message.setField(this, 40, value); + } + get overhaulBtn() { + return pb_1.Message.getFieldWithDefault(this, 41, false) as boolean; + } + set overhaulBtn(value: boolean) { + pb_1.Message.setField(this, 41, value); + } + get undervoltageBtn() { + return pb_1.Message.getFieldWithDefault(this, 42, false) as boolean; + } + set undervoltageBtn(value: boolean) { + pb_1.Message.setField(this, 42, value); + } + get sleepBtn() { + return pb_1.Message.getFieldWithDefault(this, 43, false) as boolean; + } + set sleepBtn(value: boolean) { + pb_1.Message.setField(this, 43, value); + } + get emergentHandleDown() { + return pb_1.Message.getFieldWithDefault(this, 44, false) as boolean; + } + set emergentHandleDown(value: boolean) { + pb_1.Message.setField(this, 44, value); + } + get doorLockState() { + return pb_1.Message.getFieldWithDefault(this, 45, false) as boolean; + } + set doorLockState(value: boolean) { + pb_1.Message.setField(this, 45, value); + } + get lifeDoorState() { + return pb_1.Message.getFieldWithDefault(this, 46, false) as boolean; + } + set lifeDoorState(value: boolean) { + pb_1.Message.setField(this, 46, value); + } + get trainLowPowerResetState() { + return pb_1.Message.getFieldWithDefault(this, 47, false) as boolean; + } + set trainLowPowerResetState(value: boolean) { + pb_1.Message.setField(this, 47, value); + } + get atpPowerOnBtn() { + return pb_1.Message.getFieldWithDefault(this, 48, false) as boolean; + } + set atpPowerOnBtn(value: boolean) { + pb_1.Message.setField(this, 48, value); + } + get doorModeAA() { + return pb_1.Message.getFieldWithDefault(this, 49, false) as boolean; + } + set doorModeAA(value: boolean) { + pb_1.Message.setField(this, 49, value); + } + get doorModeAM() { + return pb_1.Message.getFieldWithDefault(this, 50, false) as boolean; + } + set doorModeAM(value: boolean) { + pb_1.Message.setField(this, 50, value); + } + get doorModeMM() { + return pb_1.Message.getFieldWithDefault(this, 51, false) as boolean; + } + set doorModeMM(value: boolean) { + pb_1.Message.setField(this, 51, value); + } + get outerEmergentBrakeReport() { + return pb_1.Message.getFieldWithDefault(this, 52, false) as boolean; + } + set outerEmergentBrakeReport(value: boolean) { + pb_1.Message.setField(this, 52, value); + } + get trainDoorOutLed() { + return pb_1.Message.getFieldWithDefault(this, 53, false) as boolean; + } + set trainDoorOutLed(value: boolean) { + pb_1.Message.setField(this, 53, value); + } + get localAtpControl() { + return pb_1.Message.getFieldWithDefault(this, 54, false) as boolean; + } + set localAtpControl(value: boolean) { + pb_1.Message.setField(this, 54, value); + } + get atoBrakeCommand() { + return pb_1.Message.getFieldWithDefault(this, 55, false) as boolean; + } + set atoBrakeCommand(value: boolean) { + pb_1.Message.setField(this, 55, value); + } + get atoTractionCommandOut() { + return pb_1.Message.getFieldWithDefault(this, 56, false) as boolean; + } + set atoTractionCommandOut(value: boolean) { + pb_1.Message.setField(this, 56, value); + } + get atoLazyCommandOut() { + return pb_1.Message.getFieldWithDefault(this, 57, false) as boolean; + } + set atoLazyCommandOut(value: boolean) { + pb_1.Message.setField(this, 57, value); + } + get atoAlwaysBrake() { + return pb_1.Message.getFieldWithDefault(this, 59, false) as boolean; + } + set atoAlwaysBrake(value: boolean) { + pb_1.Message.setField(this, 59, value); + } + get atoOpenLeftDoor() { + return pb_1.Message.getFieldWithDefault(this, 60, false) as boolean; + } + set atoOpenLeftDoor(value: boolean) { + pb_1.Message.setField(this, 60, value); + } + get atoOpenRightDoor() { + return pb_1.Message.getFieldWithDefault(this, 61, false) as boolean; + } + set atoOpenRightDoor(value: boolean) { + pb_1.Message.setField(this, 61, value); + } + get atoCloseLeftDoor() { + return pb_1.Message.getFieldWithDefault(this, 62, false) as boolean; + } + set atoCloseLeftDoor(value: boolean) { + pb_1.Message.setField(this, 62, value); + } + get noSpeedSigle() { + return pb_1.Message.getFieldWithDefault(this, 63, false) as boolean; + } + set noSpeedSigle(value: boolean) { + pb_1.Message.setField(this, 63, value); + } + get trainStartedLed() { + return pb_1.Message.getFieldWithDefault(this, 64, false) as boolean; + } + set trainStartedLed(value: boolean) { + pb_1.Message.setField(this, 64, value); + } + get mostUseBrake() { + return pb_1.Message.getFieldWithDefault(this, 65, false) as boolean; + } + set mostUseBrake(value: boolean) { + pb_1.Message.setField(this, 65, value); + } + get splittingOut() { + return pb_1.Message.getFieldWithDefault(this, 66, false) as boolean; + } + set splittingOut(value: boolean) { + pb_1.Message.setField(this, 66, value); + } + get modeRelay() { + return pb_1.Message.getFieldWithDefault(this, 67, false) as boolean; + } + set modeRelay(value: boolean) { + pb_1.Message.setField(this, 67, value); + } + get tractionEffective() { + return pb_1.Message.getFieldWithDefault(this, 68, false) as boolean; + } + set tractionEffective(value: boolean) { + pb_1.Message.setField(this, 68, value); + } + get brakeEffective() { + return pb_1.Message.getFieldWithDefault(this, 69, false) as boolean; + } + set brakeEffective(value: boolean) { + pb_1.Message.setField(this, 69, value); + } + get brakeQuarantine() { + return pb_1.Message.getFieldWithDefault(this, 70, false) as boolean; + } + set brakeQuarantine(value: boolean) { + pb_1.Message.setField(this, 70, value); + } + get stopNotAllBrake() { + return pb_1.Message.getFieldWithDefault(this, 71, false) as boolean; + } + set stopNotAllBrake(value: boolean) { + pb_1.Message.setField(this, 71, value); + } + get atoTractionCommand1() { + return pb_1.Message.getFieldWithDefault(this, 72, false) as boolean; + } + set atoTractionCommand1(value: boolean) { + pb_1.Message.setField(this, 72, value); + } + get atoTractionCommand2() { + return pb_1.Message.getFieldWithDefault(this, 73, false) as boolean; + } + set atoTractionCommand2(value: boolean) { + pb_1.Message.setField(this, 73, value); + } + get atoTractionCommand3() { + return pb_1.Message.getFieldWithDefault(this, 74, false) as boolean; + } + set atoTractionCommand3(value: boolean) { + pb_1.Message.setField(this, 74, value); + } + get mockInfo() { + return pb_1.Message.getFieldWithDefault(this, 75, 0) as number; + } + set mockInfo(value: number) { + pb_1.Message.setField(this, 75, value); + } static fromObject(data: { lifeSignal?: number; tc1Active?: boolean; @@ -2647,6 +3117,53 @@ export namespace state { allDoorClose?: boolean; udpInterruption?: boolean; updateTime?: number; + forceDoorAllow?: boolean; + modeLevelDownBtn?: boolean; + confirmBtn?: boolean; + modeLevelUpBtn?: boolean; + atoSendTrainBtn?: boolean; + trainIntegrity?: boolean; + atpOrAtoBypassState?: boolean; + obstacleCheckBtn?: boolean; + driverActiveReportBtn?: boolean; + brakeHeavyFault?: boolean; + leftDoorStateBtn?: boolean; + rightDoorStateBtn?: boolean; + wakeUpBtn?: boolean; + overhaulBtn?: boolean; + undervoltageBtn?: boolean; + sleepBtn?: boolean; + emergentHandleDown?: boolean; + doorLockState?: boolean; + lifeDoorState?: boolean; + trainLowPowerResetState?: boolean; + atpPowerOnBtn?: boolean; + doorModeAA?: boolean; + doorModeAM?: boolean; + doorModeMM?: boolean; + outerEmergentBrakeReport?: boolean; + trainDoorOutLed?: boolean; + localAtpControl?: boolean; + atoBrakeCommand?: boolean; + atoTractionCommandOut?: boolean; + atoLazyCommandOut?: boolean; + atoAlwaysBrake?: boolean; + atoOpenLeftDoor?: boolean; + atoOpenRightDoor?: boolean; + atoCloseLeftDoor?: boolean; + noSpeedSigle?: boolean; + trainStartedLed?: boolean; + mostUseBrake?: boolean; + splittingOut?: boolean; + modeRelay?: boolean; + tractionEffective?: boolean; + brakeEffective?: boolean; + brakeQuarantine?: boolean; + stopNotAllBrake?: boolean; + atoTractionCommand1?: boolean; + atoTractionCommand2?: boolean; + atoTractionCommand3?: boolean; + mockInfo?: number; }): TrainVobcState { const message = new TrainVobcState({}); if (data.lifeSignal != null) { @@ -2727,6 +3244,147 @@ export namespace state { if (data.updateTime != null) { message.updateTime = data.updateTime; } + if (data.forceDoorAllow != null) { + message.forceDoorAllow = data.forceDoorAllow; + } + if (data.modeLevelDownBtn != null) { + message.modeLevelDownBtn = data.modeLevelDownBtn; + } + if (data.confirmBtn != null) { + message.confirmBtn = data.confirmBtn; + } + if (data.modeLevelUpBtn != null) { + message.modeLevelUpBtn = data.modeLevelUpBtn; + } + if (data.atoSendTrainBtn != null) { + message.atoSendTrainBtn = data.atoSendTrainBtn; + } + if (data.trainIntegrity != null) { + message.trainIntegrity = data.trainIntegrity; + } + if (data.atpOrAtoBypassState != null) { + message.atpOrAtoBypassState = data.atpOrAtoBypassState; + } + if (data.obstacleCheckBtn != null) { + message.obstacleCheckBtn = data.obstacleCheckBtn; + } + if (data.driverActiveReportBtn != null) { + message.driverActiveReportBtn = data.driverActiveReportBtn; + } + if (data.brakeHeavyFault != null) { + message.brakeHeavyFault = data.brakeHeavyFault; + } + if (data.leftDoorStateBtn != null) { + message.leftDoorStateBtn = data.leftDoorStateBtn; + } + if (data.rightDoorStateBtn != null) { + message.rightDoorStateBtn = data.rightDoorStateBtn; + } + if (data.wakeUpBtn != null) { + message.wakeUpBtn = data.wakeUpBtn; + } + if (data.overhaulBtn != null) { + message.overhaulBtn = data.overhaulBtn; + } + if (data.undervoltageBtn != null) { + message.undervoltageBtn = data.undervoltageBtn; + } + if (data.sleepBtn != null) { + message.sleepBtn = data.sleepBtn; + } + if (data.emergentHandleDown != null) { + message.emergentHandleDown = data.emergentHandleDown; + } + if (data.doorLockState != null) { + message.doorLockState = data.doorLockState; + } + if (data.lifeDoorState != null) { + message.lifeDoorState = data.lifeDoorState; + } + if (data.trainLowPowerResetState != null) { + message.trainLowPowerResetState = data.trainLowPowerResetState; + } + if (data.atpPowerOnBtn != null) { + message.atpPowerOnBtn = data.atpPowerOnBtn; + } + if (data.doorModeAA != null) { + message.doorModeAA = data.doorModeAA; + } + if (data.doorModeAM != null) { + message.doorModeAM = data.doorModeAM; + } + if (data.doorModeMM != null) { + message.doorModeMM = data.doorModeMM; + } + if (data.outerEmergentBrakeReport != null) { + message.outerEmergentBrakeReport = data.outerEmergentBrakeReport; + } + if (data.trainDoorOutLed != null) { + message.trainDoorOutLed = data.trainDoorOutLed; + } + if (data.localAtpControl != null) { + message.localAtpControl = data.localAtpControl; + } + if (data.atoBrakeCommand != null) { + message.atoBrakeCommand = data.atoBrakeCommand; + } + if (data.atoTractionCommandOut != null) { + message.atoTractionCommandOut = data.atoTractionCommandOut; + } + if (data.atoLazyCommandOut != null) { + message.atoLazyCommandOut = data.atoLazyCommandOut; + } + if (data.atoAlwaysBrake != null) { + message.atoAlwaysBrake = data.atoAlwaysBrake; + } + if (data.atoOpenLeftDoor != null) { + message.atoOpenLeftDoor = data.atoOpenLeftDoor; + } + if (data.atoOpenRightDoor != null) { + message.atoOpenRightDoor = data.atoOpenRightDoor; + } + if (data.atoCloseLeftDoor != null) { + message.atoCloseLeftDoor = data.atoCloseLeftDoor; + } + if (data.noSpeedSigle != null) { + message.noSpeedSigle = data.noSpeedSigle; + } + if (data.trainStartedLed != null) { + message.trainStartedLed = data.trainStartedLed; + } + if (data.mostUseBrake != null) { + message.mostUseBrake = data.mostUseBrake; + } + if (data.splittingOut != null) { + message.splittingOut = data.splittingOut; + } + if (data.modeRelay != null) { + message.modeRelay = data.modeRelay; + } + if (data.tractionEffective != null) { + message.tractionEffective = data.tractionEffective; + } + if (data.brakeEffective != null) { + message.brakeEffective = data.brakeEffective; + } + if (data.brakeQuarantine != null) { + message.brakeQuarantine = data.brakeQuarantine; + } + if (data.stopNotAllBrake != null) { + message.stopNotAllBrake = data.stopNotAllBrake; + } + if (data.atoTractionCommand1 != null) { + message.atoTractionCommand1 = data.atoTractionCommand1; + } + if (data.atoTractionCommand2 != null) { + message.atoTractionCommand2 = data.atoTractionCommand2; + } + if (data.atoTractionCommand3 != null) { + message.atoTractionCommand3 = data.atoTractionCommand3; + } + if (data.mockInfo != null) { + message.mockInfo = data.mockInfo; + } return message; } toObject() { @@ -2757,6 +3415,53 @@ export namespace state { allDoorClose?: boolean; udpInterruption?: boolean; updateTime?: number; + forceDoorAllow?: boolean; + modeLevelDownBtn?: boolean; + confirmBtn?: boolean; + modeLevelUpBtn?: boolean; + atoSendTrainBtn?: boolean; + trainIntegrity?: boolean; + atpOrAtoBypassState?: boolean; + obstacleCheckBtn?: boolean; + driverActiveReportBtn?: boolean; + brakeHeavyFault?: boolean; + leftDoorStateBtn?: boolean; + rightDoorStateBtn?: boolean; + wakeUpBtn?: boolean; + overhaulBtn?: boolean; + undervoltageBtn?: boolean; + sleepBtn?: boolean; + emergentHandleDown?: boolean; + doorLockState?: boolean; + lifeDoorState?: boolean; + trainLowPowerResetState?: boolean; + atpPowerOnBtn?: boolean; + doorModeAA?: boolean; + doorModeAM?: boolean; + doorModeMM?: boolean; + outerEmergentBrakeReport?: boolean; + trainDoorOutLed?: boolean; + localAtpControl?: boolean; + atoBrakeCommand?: boolean; + atoTractionCommandOut?: boolean; + atoLazyCommandOut?: boolean; + atoAlwaysBrake?: boolean; + atoOpenLeftDoor?: boolean; + atoOpenRightDoor?: boolean; + atoCloseLeftDoor?: boolean; + noSpeedSigle?: boolean; + trainStartedLed?: boolean; + mostUseBrake?: boolean; + splittingOut?: boolean; + modeRelay?: boolean; + tractionEffective?: boolean; + brakeEffective?: boolean; + brakeQuarantine?: boolean; + stopNotAllBrake?: boolean; + atoTractionCommand1?: boolean; + atoTractionCommand2?: boolean; + atoTractionCommand3?: boolean; + mockInfo?: number; } = {}; if (this.lifeSignal != null) { data.lifeSignal = this.lifeSignal; @@ -2836,6 +3541,147 @@ export namespace state { if (this.updateTime != null) { data.updateTime = this.updateTime; } + if (this.forceDoorAllow != null) { + data.forceDoorAllow = this.forceDoorAllow; + } + if (this.modeLevelDownBtn != null) { + data.modeLevelDownBtn = this.modeLevelDownBtn; + } + if (this.confirmBtn != null) { + data.confirmBtn = this.confirmBtn; + } + if (this.modeLevelUpBtn != null) { + data.modeLevelUpBtn = this.modeLevelUpBtn; + } + if (this.atoSendTrainBtn != null) { + data.atoSendTrainBtn = this.atoSendTrainBtn; + } + if (this.trainIntegrity != null) { + data.trainIntegrity = this.trainIntegrity; + } + if (this.atpOrAtoBypassState != null) { + data.atpOrAtoBypassState = this.atpOrAtoBypassState; + } + if (this.obstacleCheckBtn != null) { + data.obstacleCheckBtn = this.obstacleCheckBtn; + } + if (this.driverActiveReportBtn != null) { + data.driverActiveReportBtn = this.driverActiveReportBtn; + } + if (this.brakeHeavyFault != null) { + data.brakeHeavyFault = this.brakeHeavyFault; + } + if (this.leftDoorStateBtn != null) { + data.leftDoorStateBtn = this.leftDoorStateBtn; + } + if (this.rightDoorStateBtn != null) { + data.rightDoorStateBtn = this.rightDoorStateBtn; + } + if (this.wakeUpBtn != null) { + data.wakeUpBtn = this.wakeUpBtn; + } + if (this.overhaulBtn != null) { + data.overhaulBtn = this.overhaulBtn; + } + if (this.undervoltageBtn != null) { + data.undervoltageBtn = this.undervoltageBtn; + } + if (this.sleepBtn != null) { + data.sleepBtn = this.sleepBtn; + } + if (this.emergentHandleDown != null) { + data.emergentHandleDown = this.emergentHandleDown; + } + if (this.doorLockState != null) { + data.doorLockState = this.doorLockState; + } + if (this.lifeDoorState != null) { + data.lifeDoorState = this.lifeDoorState; + } + if (this.trainLowPowerResetState != null) { + data.trainLowPowerResetState = this.trainLowPowerResetState; + } + if (this.atpPowerOnBtn != null) { + data.atpPowerOnBtn = this.atpPowerOnBtn; + } + if (this.doorModeAA != null) { + data.doorModeAA = this.doorModeAA; + } + if (this.doorModeAM != null) { + data.doorModeAM = this.doorModeAM; + } + if (this.doorModeMM != null) { + data.doorModeMM = this.doorModeMM; + } + if (this.outerEmergentBrakeReport != null) { + data.outerEmergentBrakeReport = this.outerEmergentBrakeReport; + } + if (this.trainDoorOutLed != null) { + data.trainDoorOutLed = this.trainDoorOutLed; + } + if (this.localAtpControl != null) { + data.localAtpControl = this.localAtpControl; + } + if (this.atoBrakeCommand != null) { + data.atoBrakeCommand = this.atoBrakeCommand; + } + if (this.atoTractionCommandOut != null) { + data.atoTractionCommandOut = this.atoTractionCommandOut; + } + if (this.atoLazyCommandOut != null) { + data.atoLazyCommandOut = this.atoLazyCommandOut; + } + if (this.atoAlwaysBrake != null) { + data.atoAlwaysBrake = this.atoAlwaysBrake; + } + if (this.atoOpenLeftDoor != null) { + data.atoOpenLeftDoor = this.atoOpenLeftDoor; + } + if (this.atoOpenRightDoor != null) { + data.atoOpenRightDoor = this.atoOpenRightDoor; + } + if (this.atoCloseLeftDoor != null) { + data.atoCloseLeftDoor = this.atoCloseLeftDoor; + } + if (this.noSpeedSigle != null) { + data.noSpeedSigle = this.noSpeedSigle; + } + if (this.trainStartedLed != null) { + data.trainStartedLed = this.trainStartedLed; + } + if (this.mostUseBrake != null) { + data.mostUseBrake = this.mostUseBrake; + } + if (this.splittingOut != null) { + data.splittingOut = this.splittingOut; + } + if (this.modeRelay != null) { + data.modeRelay = this.modeRelay; + } + if (this.tractionEffective != null) { + data.tractionEffective = this.tractionEffective; + } + if (this.brakeEffective != null) { + data.brakeEffective = this.brakeEffective; + } + if (this.brakeQuarantine != null) { + data.brakeQuarantine = this.brakeQuarantine; + } + if (this.stopNotAllBrake != null) { + data.stopNotAllBrake = this.stopNotAllBrake; + } + if (this.atoTractionCommand1 != null) { + data.atoTractionCommand1 = this.atoTractionCommand1; + } + if (this.atoTractionCommand2 != null) { + data.atoTractionCommand2 = this.atoTractionCommand2; + } + if (this.atoTractionCommand3 != null) { + data.atoTractionCommand3 = this.atoTractionCommand3; + } + if (this.mockInfo != null) { + data.mockInfo = this.mockInfo; + } return data; } serialize(): Uint8Array; @@ -2894,6 +3740,100 @@ export namespace state { writer.writeBool(25, this.udpInterruption); if (this.updateTime != 0) writer.writeInt64(26, this.updateTime); + if (this.forceDoorAllow != false) + writer.writeBool(27, this.forceDoorAllow); + if (this.modeLevelDownBtn != false) + writer.writeBool(28, this.modeLevelDownBtn); + if (this.confirmBtn != false) + writer.writeBool(29, this.confirmBtn); + if (this.modeLevelUpBtn != false) + writer.writeBool(30, this.modeLevelUpBtn); + if (this.atoSendTrainBtn != false) + writer.writeBool(31, this.atoSendTrainBtn); + if (this.trainIntegrity != false) + writer.writeBool(32, this.trainIntegrity); + if (this.atpOrAtoBypassState != false) + writer.writeBool(33, this.atpOrAtoBypassState); + if (this.obstacleCheckBtn != false) + writer.writeBool(35, this.obstacleCheckBtn); + if (this.driverActiveReportBtn != false) + writer.writeBool(36, this.driverActiveReportBtn); + if (this.brakeHeavyFault != false) + writer.writeBool(37, this.brakeHeavyFault); + if (this.leftDoorStateBtn != false) + writer.writeBool(38, this.leftDoorStateBtn); + if (this.rightDoorStateBtn != false) + writer.writeBool(39, this.rightDoorStateBtn); + if (this.wakeUpBtn != false) + writer.writeBool(40, this.wakeUpBtn); + if (this.overhaulBtn != false) + writer.writeBool(41, this.overhaulBtn); + if (this.undervoltageBtn != false) + writer.writeBool(42, this.undervoltageBtn); + if (this.sleepBtn != false) + writer.writeBool(43, this.sleepBtn); + if (this.emergentHandleDown != false) + writer.writeBool(44, this.emergentHandleDown); + if (this.doorLockState != false) + writer.writeBool(45, this.doorLockState); + if (this.lifeDoorState != false) + writer.writeBool(46, this.lifeDoorState); + if (this.trainLowPowerResetState != false) + writer.writeBool(47, this.trainLowPowerResetState); + if (this.atpPowerOnBtn != false) + writer.writeBool(48, this.atpPowerOnBtn); + if (this.doorModeAA != false) + writer.writeBool(49, this.doorModeAA); + if (this.doorModeAM != false) + writer.writeBool(50, this.doorModeAM); + if (this.doorModeMM != false) + writer.writeBool(51, this.doorModeMM); + if (this.outerEmergentBrakeReport != false) + writer.writeBool(52, this.outerEmergentBrakeReport); + if (this.trainDoorOutLed != false) + writer.writeBool(53, this.trainDoorOutLed); + if (this.localAtpControl != false) + writer.writeBool(54, this.localAtpControl); + if (this.atoBrakeCommand != false) + writer.writeBool(55, this.atoBrakeCommand); + if (this.atoTractionCommandOut != false) + writer.writeBool(56, this.atoTractionCommandOut); + if (this.atoLazyCommandOut != false) + writer.writeBool(57, this.atoLazyCommandOut); + if (this.atoAlwaysBrake != false) + writer.writeBool(59, this.atoAlwaysBrake); + if (this.atoOpenLeftDoor != false) + writer.writeBool(60, this.atoOpenLeftDoor); + if (this.atoOpenRightDoor != false) + writer.writeBool(61, this.atoOpenRightDoor); + if (this.atoCloseLeftDoor != false) + writer.writeBool(62, this.atoCloseLeftDoor); + if (this.noSpeedSigle != false) + writer.writeBool(63, this.noSpeedSigle); + if (this.trainStartedLed != false) + writer.writeBool(64, this.trainStartedLed); + if (this.mostUseBrake != false) + writer.writeBool(65, this.mostUseBrake); + if (this.splittingOut != false) + writer.writeBool(66, this.splittingOut); + if (this.modeRelay != false) + writer.writeBool(67, this.modeRelay); + if (this.tractionEffective != false) + writer.writeBool(68, this.tractionEffective); + if (this.brakeEffective != false) + writer.writeBool(69, this.brakeEffective); + if (this.brakeQuarantine != false) + writer.writeBool(70, this.brakeQuarantine); + if (this.stopNotAllBrake != false) + writer.writeBool(71, this.stopNotAllBrake); + if (this.atoTractionCommand1 != false) + writer.writeBool(72, this.atoTractionCommand1); + if (this.atoTractionCommand2 != false) + writer.writeBool(73, this.atoTractionCommand2); + if (this.atoTractionCommand3 != false) + writer.writeBool(74, this.atoTractionCommand3); + if (this.mockInfo != 0) + writer.writeUint32(75, this.mockInfo); if (!w) return writer.getResultBuffer(); } @@ -2981,6 +3921,147 @@ export namespace state { case 26: message.updateTime = reader.readInt64(); break; + case 27: + message.forceDoorAllow = reader.readBool(); + break; + case 28: + message.modeLevelDownBtn = reader.readBool(); + break; + case 29: + message.confirmBtn = reader.readBool(); + break; + case 30: + message.modeLevelUpBtn = reader.readBool(); + break; + case 31: + message.atoSendTrainBtn = reader.readBool(); + break; + case 32: + message.trainIntegrity = reader.readBool(); + break; + case 33: + message.atpOrAtoBypassState = reader.readBool(); + break; + case 35: + message.obstacleCheckBtn = reader.readBool(); + break; + case 36: + message.driverActiveReportBtn = reader.readBool(); + break; + case 37: + message.brakeHeavyFault = reader.readBool(); + break; + case 38: + message.leftDoorStateBtn = reader.readBool(); + break; + case 39: + message.rightDoorStateBtn = reader.readBool(); + break; + case 40: + message.wakeUpBtn = reader.readBool(); + break; + case 41: + message.overhaulBtn = reader.readBool(); + break; + case 42: + message.undervoltageBtn = reader.readBool(); + break; + case 43: + message.sleepBtn = reader.readBool(); + break; + case 44: + message.emergentHandleDown = reader.readBool(); + break; + case 45: + message.doorLockState = reader.readBool(); + break; + case 46: + message.lifeDoorState = reader.readBool(); + break; + case 47: + message.trainLowPowerResetState = reader.readBool(); + break; + case 48: + message.atpPowerOnBtn = reader.readBool(); + break; + case 49: + message.doorModeAA = reader.readBool(); + break; + case 50: + message.doorModeAM = reader.readBool(); + break; + case 51: + message.doorModeMM = reader.readBool(); + break; + case 52: + message.outerEmergentBrakeReport = reader.readBool(); + break; + case 53: + message.trainDoorOutLed = reader.readBool(); + break; + case 54: + message.localAtpControl = reader.readBool(); + break; + case 55: + message.atoBrakeCommand = reader.readBool(); + break; + case 56: + message.atoTractionCommandOut = reader.readBool(); + break; + case 57: + message.atoLazyCommandOut = reader.readBool(); + break; + case 59: + message.atoAlwaysBrake = reader.readBool(); + break; + case 60: + message.atoOpenLeftDoor = reader.readBool(); + break; + case 61: + message.atoOpenRightDoor = reader.readBool(); + break; + case 62: + message.atoCloseLeftDoor = reader.readBool(); + break; + case 63: + message.noSpeedSigle = reader.readBool(); + break; + case 64: + message.trainStartedLed = reader.readBool(); + break; + case 65: + message.mostUseBrake = reader.readBool(); + break; + case 66: + message.splittingOut = reader.readBool(); + break; + case 67: + message.modeRelay = reader.readBool(); + break; + case 68: + message.tractionEffective = reader.readBool(); + break; + case 69: + message.brakeEffective = reader.readBool(); + break; + case 70: + message.brakeQuarantine = reader.readBool(); + break; + case 71: + message.stopNotAllBrake = reader.readBool(); + break; + case 72: + message.atoTractionCommand1 = reader.readBool(); + break; + case 73: + message.atoTractionCommand2 = reader.readBool(); + break; + case 74: + message.atoTractionCommand3 = reader.readBool(); + break; + case 75: + message.mockInfo = reader.readUint32(); + break; default: reader.skipField(); } } @@ -4669,6 +5750,9 @@ export namespace state { baliseCount?: number; messageCounter?: number; telegram?: string; + distance?: number; + aboveBalise?: boolean; + baliseTelegramForPcSimResend?: string; }) { super(); pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls); @@ -4685,6 +5769,15 @@ export namespace state { if ("telegram" in data && data.telegram != undefined) { this.telegram = data.telegram; } + if ("distance" in data && data.distance != undefined) { + this.distance = data.distance; + } + if ("aboveBalise" in data && data.aboveBalise != undefined) { + this.aboveBalise = data.aboveBalise; + } + if ("baliseTelegramForPcSimResend" in data && data.baliseTelegramForPcSimResend != undefined) { + this.baliseTelegramForPcSimResend = data.baliseTelegramForPcSimResend; + } } } get dataSerialNumber() { @@ -4711,11 +5804,32 @@ export namespace state { set telegram(value: string) { pb_1.Message.setField(this, 4, value); } + get distance() { + return pb_1.Message.getFieldWithDefault(this, 5, 0) as number; + } + set distance(value: number) { + pb_1.Message.setField(this, 5, value); + } + get aboveBalise() { + return pb_1.Message.getFieldWithDefault(this, 6, false) as boolean; + } + set aboveBalise(value: boolean) { + pb_1.Message.setField(this, 6, value); + } + get baliseTelegramForPcSimResend() { + return pb_1.Message.getFieldWithDefault(this, 7, "") as string; + } + set baliseTelegramForPcSimResend(value: string) { + pb_1.Message.setField(this, 7, value); + } static fromObject(data: { dataSerialNumber?: number; baliseCount?: number; messageCounter?: number; telegram?: string; + distance?: number; + aboveBalise?: boolean; + baliseTelegramForPcSimResend?: string; }): BTMState { const message = new BTMState({}); if (data.dataSerialNumber != null) { @@ -4730,6 +5844,15 @@ export namespace state { if (data.telegram != null) { message.telegram = data.telegram; } + if (data.distance != null) { + message.distance = data.distance; + } + if (data.aboveBalise != null) { + message.aboveBalise = data.aboveBalise; + } + if (data.baliseTelegramForPcSimResend != null) { + message.baliseTelegramForPcSimResend = data.baliseTelegramForPcSimResend; + } return message; } toObject() { @@ -4738,6 +5861,9 @@ export namespace state { baliseCount?: number; messageCounter?: number; telegram?: string; + distance?: number; + aboveBalise?: boolean; + baliseTelegramForPcSimResend?: string; } = {}; if (this.dataSerialNumber != null) { data.dataSerialNumber = this.dataSerialNumber; @@ -4751,6 +5877,15 @@ export namespace state { if (this.telegram != null) { data.telegram = this.telegram; } + if (this.distance != null) { + data.distance = this.distance; + } + if (this.aboveBalise != null) { + data.aboveBalise = this.aboveBalise; + } + if (this.baliseTelegramForPcSimResend != null) { + data.baliseTelegramForPcSimResend = this.baliseTelegramForPcSimResend; + } return data; } serialize(): Uint8Array; @@ -4765,6 +5900,12 @@ export namespace state { writer.writeUint32(3, this.messageCounter); if (this.telegram.length) writer.writeString(4, this.telegram); + if (this.distance != 0) + writer.writeInt64(5, this.distance); + if (this.aboveBalise != false) + writer.writeBool(6, this.aboveBalise); + if (this.baliseTelegramForPcSimResend.length) + writer.writeString(7, this.baliseTelegramForPcSimResend); if (!w) return writer.getResultBuffer(); } @@ -4786,6 +5927,15 @@ export namespace state { case 4: message.telegram = reader.readString(); break; + case 5: + message.distance = reader.readInt64(); + break; + case 6: + message.aboveBalise = reader.readBool(); + break; + case 7: + message.baliseTelegramForPcSimResend = reader.readString(); + break; default: reader.skipField(); } } @@ -6879,6 +8029,7 @@ export namespace state { id?: number; mgj?: boolean; param?: dependency_3.request.CkmParam; + local?: boolean; }) { super(); pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls); @@ -6892,6 +8043,9 @@ export namespace state { if ("param" in data && data.param != undefined) { this.param = data.param; } + if ("local" in data && data.local != undefined) { + this.local = data.local; + } } } get id() { @@ -6915,10 +8069,17 @@ export namespace state { get has_param() { return pb_1.Message.getField(this, 3) != null; } + get local() { + return pb_1.Message.getFieldWithDefault(this, 4, false) as boolean; + } + set local(value: boolean) { + pb_1.Message.setField(this, 4, value); + } static fromObject(data: { id?: number; mgj?: boolean; param?: ReturnType; + local?: boolean; }): CkmState { const message = new CkmState({}); if (data.id != null) { @@ -6930,6 +8091,9 @@ export namespace state { if (data.param != null) { message.param = dependency_3.request.CkmParam.fromObject(data.param); } + if (data.local != null) { + message.local = data.local; + } return message; } toObject() { @@ -6937,6 +8101,7 @@ export namespace state { id?: number; mgj?: boolean; param?: ReturnType; + local?: boolean; } = {}; if (this.id != null) { data.id = this.id; @@ -6947,6 +8112,9 @@ export namespace state { if (this.param != null) { data.param = this.param.toObject(); } + if (this.local != null) { + data.local = this.local; + } return data; } serialize(): Uint8Array; @@ -6959,6 +8127,8 @@ export namespace state { writer.writeBool(2, this.mgj); if (this.has_param) writer.writeMessage(3, this.param, () => this.param.serialize(writer)); + if (this.local != false) + writer.writeBool(4, this.local); if (!w) return writer.getResultBuffer(); } @@ -6977,6 +8147,9 @@ export namespace state { case 3: reader.readMessage(message.param, () => message.param = dependency_3.request.CkmParam.deserialize(reader)); break; + case 4: + message.local = reader.readBool(); + break; default: reader.skipField(); } } @@ -8467,7 +9640,6 @@ export namespace state { constructor(data?: any[] | { id?: number; val?: boolean; - dt?: dependency_3.request.DriverType; }) { super(); pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls); @@ -8478,9 +9650,6 @@ export namespace state { if ("val" in data && data.val != undefined) { this.val = data.val; } - if ("dt" in data && data.dt != undefined) { - this.dt = data.dt; - } } } get id() { @@ -8495,16 +9664,9 @@ export namespace state { set val(value: boolean) { pb_1.Message.setField(this, 2, value); } - get dt() { - return pb_1.Message.getFieldWithDefault(this, 3, dependency_3.request.DriverType.ONE_END) as dependency_3.request.DriverType; - } - set dt(value: dependency_3.request.DriverType) { - pb_1.Message.setField(this, 3, value); - } static fromObject(data: { id?: number; val?: boolean; - dt?: dependency_3.request.DriverType; }): DriverKeySwitch { const message = new DriverKeySwitch({}); if (data.id != null) { @@ -8513,16 +9675,12 @@ export namespace state { if (data.val != null) { message.val = data.val; } - if (data.dt != null) { - message.dt = data.dt; - } return message; } toObject() { const data: { id?: number; val?: boolean; - dt?: dependency_3.request.DriverType; } = {}; if (this.id != null) { data.id = this.id; @@ -8530,9 +9688,6 @@ export namespace state { if (this.val != null) { data.val = this.val; } - if (this.dt != null) { - data.dt = this.dt; - } return data; } serialize(): Uint8Array; @@ -8543,8 +9698,6 @@ export namespace state { writer.writeUint32(1, this.id); if (this.val != false) writer.writeBool(2, this.val); - if (this.dt != dependency_3.request.DriverType.ONE_END) - writer.writeEnum(3, this.dt); if (!w) return writer.getResultBuffer(); } @@ -8560,9 +9713,6 @@ export namespace state { case 2: message.val = reader.readBool(); break; - case 3: - message.dt = reader.readEnum(); - break; default: reader.skipField(); } } diff --git a/src/protos/stationLayoutGraphics.ts b/src/protos/stationLayoutGraphics.ts index 5a920de..2dbb09c 100644 --- a/src/protos/stationLayoutGraphics.ts +++ b/src/protos/stationLayoutGraphics.ts @@ -7529,6 +7529,7 @@ export namespace graphicData { linkSection?: number; centralizedStations?: number[]; duanNum?: number; + width?: number; }) { super(); pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [4], this.#one_of_decls); @@ -7548,6 +7549,9 @@ export namespace graphicData { if ("duanNum" in data && data.duanNum != undefined) { this.duanNum = data.duanNum; } + if ("width" in data && data.width != undefined) { + this.width = data.width; + } } } get common() { @@ -7583,12 +7587,19 @@ export namespace graphicData { set duanNum(value: number) { pb_1.Message.setField(this, 5, value); } + get width() { + return pb_1.Message.getFieldWithDefault(this, 6, 0) as number; + } + set width(value: number) { + pb_1.Message.setField(this, 6, value); + } static fromObject(data: { common?: ReturnType; code?: string; linkSection?: number; centralizedStations?: number[]; duanNum?: number; + width?: number; }): CarWashing { const message = new CarWashing({}); if (data.common != null) { @@ -7606,6 +7617,9 @@ export namespace graphicData { if (data.duanNum != null) { message.duanNum = data.duanNum; } + if (data.width != null) { + message.width = data.width; + } return message; } toObject() { @@ -7615,6 +7629,7 @@ export namespace graphicData { linkSection?: number; centralizedStations?: number[]; duanNum?: number; + width?: number; } = {}; if (this.common != null) { data.common = this.common.toObject(); @@ -7631,6 +7646,9 @@ export namespace graphicData { if (this.duanNum != null) { data.duanNum = this.duanNum; } + if (this.width != null) { + data.width = this.width; + } return data; } serialize(): Uint8Array; @@ -7647,6 +7665,8 @@ export namespace graphicData { writer.writePackedUint32(4, this.centralizedStations); if (this.duanNum != 0) writer.writeUint32(5, this.duanNum); + if (this.width != 0) + writer.writeUint32(6, this.width); if (!w) return writer.getResultBuffer(); } @@ -7671,6 +7691,9 @@ export namespace graphicData { case 5: message.duanNum = reader.readUint32(); break; + case 6: + message.width = reader.readUint32(); + break; default: reader.skipField(); } }