mavsdk-types 1.0.0

package/winch/winch_pb.d.ts

@@ -0,0 +1,593 @@
+import * as jspb from 'google-protobuf'
+
+import * as mavsdk_options_pb from '../mavsdk_options_pb';
+
+
+export class SubscribeStatusRequest extends jspb.Message {
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): SubscribeStatusRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: SubscribeStatusRequest): SubscribeStatusRequest.AsObject;
+  static serializeBinaryToWriter(message: SubscribeStatusRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): SubscribeStatusRequest;
+  static deserializeBinaryFromReader(message: SubscribeStatusRequest, reader: jspb.BinaryReader): SubscribeStatusRequest;
+}
+
+export namespace SubscribeStatusRequest {
+  export type AsObject = {
+  }
+}
+
+export class StatusResponse extends jspb.Message {
+  getStatus(): Status | undefined;
+  setStatus(value?: Status): StatusResponse;
+  hasStatus(): boolean;
+  clearStatus(): StatusResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): StatusResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: StatusResponse): StatusResponse.AsObject;
+  static serializeBinaryToWriter(message: StatusResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): StatusResponse;
+  static deserializeBinaryFromReader(message: StatusResponse, reader: jspb.BinaryReader): StatusResponse;
+}
+
+export namespace StatusResponse {
+  export type AsObject = {
+    status?: Status.AsObject,
+  }
+}
+
+export class StatusFlags extends jspb.Message {
+  getHealthy(): boolean;
+  setHealthy(value: boolean): StatusFlags;
+
+  getFullyRetracted(): boolean;
+  setFullyRetracted(value: boolean): StatusFlags;
+
+  getMoving(): boolean;
+  setMoving(value: boolean): StatusFlags;
+
+  getClutchEngaged(): boolean;
+  setClutchEngaged(value: boolean): StatusFlags;
+
+  getLocked(): boolean;
+  setLocked(value: boolean): StatusFlags;
+
+  getDropping(): boolean;
+  setDropping(value: boolean): StatusFlags;
+
+  getArresting(): boolean;
+  setArresting(value: boolean): StatusFlags;
+
+  getGroundSense(): boolean;
+  setGroundSense(value: boolean): StatusFlags;
+
+  getRetracting(): boolean;
+  setRetracting(value: boolean): StatusFlags;
+
+  getRedeliver(): boolean;
+  setRedeliver(value: boolean): StatusFlags;
+
+  getAbandonLine(): boolean;
+  setAbandonLine(value: boolean): StatusFlags;
+
+  getLocking(): boolean;
+  setLocking(value: boolean): StatusFlags;
+
+  getLoadLine(): boolean;
+  setLoadLine(value: boolean): StatusFlags;
+
+  getLoadPayload(): boolean;
+  setLoadPayload(value: boolean): StatusFlags;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): StatusFlags.AsObject;
+  static toObject(includeInstance: boolean, msg: StatusFlags): StatusFlags.AsObject;
+  static serializeBinaryToWriter(message: StatusFlags, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): StatusFlags;
+  static deserializeBinaryFromReader(message: StatusFlags, reader: jspb.BinaryReader): StatusFlags;
+}
+
+export namespace StatusFlags {
+  export type AsObject = {
+    healthy: boolean,
+    fullyRetracted: boolean,
+    moving: boolean,
+    clutchEngaged: boolean,
+    locked: boolean,
+    dropping: boolean,
+    arresting: boolean,
+    groundSense: boolean,
+    retracting: boolean,
+    redeliver: boolean,
+    abandonLine: boolean,
+    locking: boolean,
+    loadLine: boolean,
+    loadPayload: boolean,
+  }
+}
+
+export class Status extends jspb.Message {
+  getTimeUsec(): number;
+  setTimeUsec(value: number): Status;
+
+  getLineLengthM(): number;
+  setLineLengthM(value: number): Status;
+
+  getSpeedMS(): number;
+  setSpeedMS(value: number): Status;
+
+  getTensionKg(): number;
+  setTensionKg(value: number): Status;
+
+  getVoltageV(): number;
+  setVoltageV(value: number): Status;
+
+  getCurrentA(): number;
+  setCurrentA(value: number): Status;
+
+  getTemperatureC(): number;
+  setTemperatureC(value: number): Status;
+
+  getStatusFlags(): StatusFlags | undefined;
+  setStatusFlags(value?: StatusFlags): Status;
+  hasStatusFlags(): boolean;
+  clearStatusFlags(): Status;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): Status.AsObject;
+  static toObject(includeInstance: boolean, msg: Status): Status.AsObject;
+  static serializeBinaryToWriter(message: Status, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): Status;
+  static deserializeBinaryFromReader(message: Status, reader: jspb.BinaryReader): Status;
+}
+
+export namespace Status {
+  export type AsObject = {
+    timeUsec: number,
+    lineLengthM: number,
+    speedMS: number,
+    tensionKg: number,
+    voltageV: number,
+    currentA: number,
+    temperatureC: number,
+    statusFlags?: StatusFlags.AsObject,
+  }
+}
+
+export class RelaxRequest extends jspb.Message {
+  getInstance(): number;
+  setInstance(value: number): RelaxRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): RelaxRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: RelaxRequest): RelaxRequest.AsObject;
+  static serializeBinaryToWriter(message: RelaxRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): RelaxRequest;
+  static deserializeBinaryFromReader(message: RelaxRequest, reader: jspb.BinaryReader): RelaxRequest;
+}
+
+export namespace RelaxRequest {
+  export type AsObject = {
+    instance: number,
+  }
+}
+
+export class RelaxResponse extends jspb.Message {
+  getWinchResult(): WinchResult | undefined;
+  setWinchResult(value?: WinchResult): RelaxResponse;
+  hasWinchResult(): boolean;
+  clearWinchResult(): RelaxResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): RelaxResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: RelaxResponse): RelaxResponse.AsObject;
+  static serializeBinaryToWriter(message: RelaxResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): RelaxResponse;
+  static deserializeBinaryFromReader(message: RelaxResponse, reader: jspb.BinaryReader): RelaxResponse;
+}
+
+export namespace RelaxResponse {
+  export type AsObject = {
+    winchResult?: WinchResult.AsObject,
+  }
+}
+
+export class RelativeLengthControlRequest extends jspb.Message {
+  getInstance(): number;
+  setInstance(value: number): RelativeLengthControlRequest;
+
+  getLengthM(): number;
+  setLengthM(value: number): RelativeLengthControlRequest;
+
+  getRateMS(): number;
+  setRateMS(value: number): RelativeLengthControlRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): RelativeLengthControlRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: RelativeLengthControlRequest): RelativeLengthControlRequest.AsObject;
+  static serializeBinaryToWriter(message: RelativeLengthControlRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): RelativeLengthControlRequest;
+  static deserializeBinaryFromReader(message: RelativeLengthControlRequest, reader: jspb.BinaryReader): RelativeLengthControlRequest;
+}
+
+export namespace RelativeLengthControlRequest {
+  export type AsObject = {
+    instance: number,
+    lengthM: number,
+    rateMS: number,
+  }
+}
+
+export class RelativeLengthControlResponse extends jspb.Message {
+  getWinchResult(): WinchResult | undefined;
+  setWinchResult(value?: WinchResult): RelativeLengthControlResponse;
+  hasWinchResult(): boolean;
+  clearWinchResult(): RelativeLengthControlResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): RelativeLengthControlResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: RelativeLengthControlResponse): RelativeLengthControlResponse.AsObject;
+  static serializeBinaryToWriter(message: RelativeLengthControlResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): RelativeLengthControlResponse;
+  static deserializeBinaryFromReader(message: RelativeLengthControlResponse, reader: jspb.BinaryReader): RelativeLengthControlResponse;
+}
+
+export namespace RelativeLengthControlResponse {
+  export type AsObject = {
+    winchResult?: WinchResult.AsObject,
+  }
+}
+
+export class RateControlRequest extends jspb.Message {
+  getInstance(): number;
+  setInstance(value: number): RateControlRequest;
+
+  getRateMS(): number;
+  setRateMS(value: number): RateControlRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): RateControlRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: RateControlRequest): RateControlRequest.AsObject;
+  static serializeBinaryToWriter(message: RateControlRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): RateControlRequest;
+  static deserializeBinaryFromReader(message: RateControlRequest, reader: jspb.BinaryReader): RateControlRequest;
+}
+
+export namespace RateControlRequest {
+  export type AsObject = {
+    instance: number,
+    rateMS: number,
+  }
+}
+
+export class RateControlResponse extends jspb.Message {
+  getWinchResult(): WinchResult | undefined;
+  setWinchResult(value?: WinchResult): RateControlResponse;
+  hasWinchResult(): boolean;
+  clearWinchResult(): RateControlResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): RateControlResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: RateControlResponse): RateControlResponse.AsObject;
+  static serializeBinaryToWriter(message: RateControlResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): RateControlResponse;
+  static deserializeBinaryFromReader(message: RateControlResponse, reader: jspb.BinaryReader): RateControlResponse;
+}
+
+export namespace RateControlResponse {
+  export type AsObject = {
+    winchResult?: WinchResult.AsObject,
+  }
+}
+
+export class LockRequest extends jspb.Message {
+  getInstance(): number;
+  setInstance(value: number): LockRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): LockRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: LockRequest): LockRequest.AsObject;
+  static serializeBinaryToWriter(message: LockRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): LockRequest;
+  static deserializeBinaryFromReader(message: LockRequest, reader: jspb.BinaryReader): LockRequest;
+}
+
+export namespace LockRequest {
+  export type AsObject = {
+    instance: number,
+  }
+}
+
+export class LockResponse extends jspb.Message {
+  getWinchResult(): WinchResult | undefined;
+  setWinchResult(value?: WinchResult): LockResponse;
+  hasWinchResult(): boolean;
+  clearWinchResult(): LockResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): LockResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: LockResponse): LockResponse.AsObject;
+  static serializeBinaryToWriter(message: LockResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): LockResponse;
+  static deserializeBinaryFromReader(message: LockResponse, reader: jspb.BinaryReader): LockResponse;
+}
+
+export namespace LockResponse {
+  export type AsObject = {
+    winchResult?: WinchResult.AsObject,
+  }
+}
+
+export class DeliverRequest extends jspb.Message {
+  getInstance(): number;
+  setInstance(value: number): DeliverRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): DeliverRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: DeliverRequest): DeliverRequest.AsObject;
+  static serializeBinaryToWriter(message: DeliverRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): DeliverRequest;
+  static deserializeBinaryFromReader(message: DeliverRequest, reader: jspb.BinaryReader): DeliverRequest;
+}
+
+export namespace DeliverRequest {
+  export type AsObject = {
+    instance: number,
+  }
+}
+
+export class DeliverResponse extends jspb.Message {
+  getWinchResult(): WinchResult | undefined;
+  setWinchResult(value?: WinchResult): DeliverResponse;
+  hasWinchResult(): boolean;
+  clearWinchResult(): DeliverResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): DeliverResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: DeliverResponse): DeliverResponse.AsObject;
+  static serializeBinaryToWriter(message: DeliverResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): DeliverResponse;
+  static deserializeBinaryFromReader(message: DeliverResponse, reader: jspb.BinaryReader): DeliverResponse;
+}
+
+export namespace DeliverResponse {
+  export type AsObject = {
+    winchResult?: WinchResult.AsObject,
+  }
+}
+
+export class HoldRequest extends jspb.Message {
+  getInstance(): number;
+  setInstance(value: number): HoldRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): HoldRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: HoldRequest): HoldRequest.AsObject;
+  static serializeBinaryToWriter(message: HoldRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): HoldRequest;
+  static deserializeBinaryFromReader(message: HoldRequest, reader: jspb.BinaryReader): HoldRequest;
+}
+
+export namespace HoldRequest {
+  export type AsObject = {
+    instance: number,
+  }
+}
+
+export class HoldResponse extends jspb.Message {
+  getWinchResult(): WinchResult | undefined;
+  setWinchResult(value?: WinchResult): HoldResponse;
+  hasWinchResult(): boolean;
+  clearWinchResult(): HoldResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): HoldResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: HoldResponse): HoldResponse.AsObject;
+  static serializeBinaryToWriter(message: HoldResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): HoldResponse;
+  static deserializeBinaryFromReader(message: HoldResponse, reader: jspb.BinaryReader): HoldResponse;
+}
+
+export namespace HoldResponse {
+  export type AsObject = {
+    winchResult?: WinchResult.AsObject,
+  }
+}
+
+export class RetractRequest extends jspb.Message {
+  getInstance(): number;
+  setInstance(value: number): RetractRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): RetractRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: RetractRequest): RetractRequest.AsObject;
+  static serializeBinaryToWriter(message: RetractRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): RetractRequest;
+  static deserializeBinaryFromReader(message: RetractRequest, reader: jspb.BinaryReader): RetractRequest;
+}
+
+export namespace RetractRequest {
+  export type AsObject = {
+    instance: number,
+  }
+}
+
+export class RetractResponse extends jspb.Message {
+  getWinchResult(): WinchResult | undefined;
+  setWinchResult(value?: WinchResult): RetractResponse;
+  hasWinchResult(): boolean;
+  clearWinchResult(): RetractResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): RetractResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: RetractResponse): RetractResponse.AsObject;
+  static serializeBinaryToWriter(message: RetractResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): RetractResponse;
+  static deserializeBinaryFromReader(message: RetractResponse, reader: jspb.BinaryReader): RetractResponse;
+}
+
+export namespace RetractResponse {
+  export type AsObject = {
+    winchResult?: WinchResult.AsObject,
+  }
+}
+
+export class LoadLineRequest extends jspb.Message {
+  getInstance(): number;
+  setInstance(value: number): LoadLineRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): LoadLineRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: LoadLineRequest): LoadLineRequest.AsObject;
+  static serializeBinaryToWriter(message: LoadLineRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): LoadLineRequest;
+  static deserializeBinaryFromReader(message: LoadLineRequest, reader: jspb.BinaryReader): LoadLineRequest;
+}
+
+export namespace LoadLineRequest {
+  export type AsObject = {
+    instance: number,
+  }
+}
+
+export class LoadLineResponse extends jspb.Message {
+  getWinchResult(): WinchResult | undefined;
+  setWinchResult(value?: WinchResult): LoadLineResponse;
+  hasWinchResult(): boolean;
+  clearWinchResult(): LoadLineResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): LoadLineResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: LoadLineResponse): LoadLineResponse.AsObject;
+  static serializeBinaryToWriter(message: LoadLineResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): LoadLineResponse;
+  static deserializeBinaryFromReader(message: LoadLineResponse, reader: jspb.BinaryReader): LoadLineResponse;
+}
+
+export namespace LoadLineResponse {
+  export type AsObject = {
+    winchResult?: WinchResult.AsObject,
+  }
+}
+
+export class AbandonLineRequest extends jspb.Message {
+  getInstance(): number;
+  setInstance(value: number): AbandonLineRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): AbandonLineRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: AbandonLineRequest): AbandonLineRequest.AsObject;
+  static serializeBinaryToWriter(message: AbandonLineRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): AbandonLineRequest;
+  static deserializeBinaryFromReader(message: AbandonLineRequest, reader: jspb.BinaryReader): AbandonLineRequest;
+}
+
+export namespace AbandonLineRequest {
+  export type AsObject = {
+    instance: number,
+  }
+}
+
+export class AbandonLineResponse extends jspb.Message {
+  getWinchResult(): WinchResult | undefined;
+  setWinchResult(value?: WinchResult): AbandonLineResponse;
+  hasWinchResult(): boolean;
+  clearWinchResult(): AbandonLineResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): AbandonLineResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: AbandonLineResponse): AbandonLineResponse.AsObject;
+  static serializeBinaryToWriter(message: AbandonLineResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): AbandonLineResponse;
+  static deserializeBinaryFromReader(message: AbandonLineResponse, reader: jspb.BinaryReader): AbandonLineResponse;
+}
+
+export namespace AbandonLineResponse {
+  export type AsObject = {
+    winchResult?: WinchResult.AsObject,
+  }
+}
+
+export class LoadPayloadRequest extends jspb.Message {
+  getInstance(): number;
+  setInstance(value: number): LoadPayloadRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): LoadPayloadRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: LoadPayloadRequest): LoadPayloadRequest.AsObject;
+  static serializeBinaryToWriter(message: LoadPayloadRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): LoadPayloadRequest;
+  static deserializeBinaryFromReader(message: LoadPayloadRequest, reader: jspb.BinaryReader): LoadPayloadRequest;
+}
+
+export namespace LoadPayloadRequest {
+  export type AsObject = {
+    instance: number,
+  }
+}
+
+export class LoadPayloadResponse extends jspb.Message {
+  getWinchResult(): WinchResult | undefined;
+  setWinchResult(value?: WinchResult): LoadPayloadResponse;
+  hasWinchResult(): boolean;
+  clearWinchResult(): LoadPayloadResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): LoadPayloadResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: LoadPayloadResponse): LoadPayloadResponse.AsObject;
+  static serializeBinaryToWriter(message: LoadPayloadResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): LoadPayloadResponse;
+  static deserializeBinaryFromReader(message: LoadPayloadResponse, reader: jspb.BinaryReader): LoadPayloadResponse;
+}
+
+export namespace LoadPayloadResponse {
+  export type AsObject = {
+    winchResult?: WinchResult.AsObject,
+  }
+}
+
+export class WinchResult extends jspb.Message {
+  getResult(): WinchResult.Result;
+  setResult(value: WinchResult.Result): WinchResult;
+
+  getResultStr(): string;
+  setResultStr(value: string): WinchResult;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): WinchResult.AsObject;
+  static toObject(includeInstance: boolean, msg: WinchResult): WinchResult.AsObject;
+  static serializeBinaryToWriter(message: WinchResult, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): WinchResult;
+  static deserializeBinaryFromReader(message: WinchResult, reader: jspb.BinaryReader): WinchResult;
+}
+
+export namespace WinchResult {
+  export type AsObject = {
+    result: WinchResult.Result,
+    resultStr: string,
+  }
+
+  export enum Result { 
+    RESULT_UNKNOWN = 0,
+    RESULT_SUCCESS = 1,
+    RESULT_NO_SYSTEM = 2,
+    RESULT_BUSY = 3,
+    RESULT_TIMEOUT = 4,
+    RESULT_UNSUPPORTED = 5,
+    RESULT_FAILED = 6,
+  }
+}
+
+export enum WinchAction { 
+  WINCH_ACTION_RELAXED = 0,
+  WINCH_ACTION_RELATIVE_LENGTH_CONTROL = 1,
+  WINCH_ACTION_RATE_CONTROL = 2,
+  WINCH_ACTION_LOCK = 3,
+  WINCH_ACTION_DELIVER = 4,
+  WINCH_ACTION_HOLD = 5,
+  WINCH_ACTION_RETRACT = 6,
+  WINCH_ACTION_LOAD_LINE = 7,
+  WINCH_ACTION_ABANDON_LINE = 8,
+  WINCH_ACTION_LOAD_PAYLOAD = 9,
+}