//@ts-nocheck
import * as _m0 from "protobufjs/minimal";

export const protobufPackage = "protocol.module";

export enum ModuleType {
  UNKNOWN = 0,
  Cargo = 1,
  LandingThruster = 2,
  Hub = 3,
  UNRECOGNIZED = -1,
}

export function moduleTypeFromJSON(object: any): ModuleType {
  switch (object) {
    case 0:
    case "UNKNOWN":
      return ModuleType.UNKNOWN;
    case 1:
    case "Cargo":
      return ModuleType.Cargo;
    case 2:
    case "LandingThruster":
      return ModuleType.LandingThruster;
    case 3:
    case "Hub":
      return ModuleType.Hub;
    case -1:
    case "UNRECOGNIZED":
    default:
      return ModuleType.UNRECOGNIZED;
  }
}

export function moduleTypeToJSON(object: ModuleType): string {
  switch (object) {
    case ModuleType.UNKNOWN:
      return "UNKNOWN";
    case ModuleType.Cargo:
      return "Cargo";
    case ModuleType.LandingThruster:
      return "LandingThruster";
    case ModuleType.Hub:
      return "Hub";
    case ModuleType.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

export interface Module {
  moduleType: ModuleType;
  rotation: number;
  x: number;
  y: number;
}

function createBaseModule(): Module {
  return { moduleType: 0, rotation: 0, x: 0, y: 0 };
}

export const Module = {
  encode(message: Module, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    if (message.moduleType !== 0) {
      writer.uint32(8).int32(message.moduleType);
    }
    if (message.rotation !== 0) {
      writer.uint32(17).double(message.rotation);
    }
    if (message.x !== 0) {
      writer.uint32(25).double(message.x);
    }
    if (message.y !== 0) {
      writer.uint32(33).double(message.y);
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): Module {
    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseModule();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag != 8) {
            break;
          }

          message.moduleType = reader.int32() as any;
          continue;
        case 2:
          if (tag != 17) {
            break;
          }

          message.rotation = reader.double();
          continue;
        case 3:
          if (tag != 25) {
            break;
          }

          message.x = reader.double();
          continue;
        case 4:
          if (tag != 33) {
            break;
          }

          message.y = reader.double();
          continue;
      }
      if ((tag & 7) == 4 || tag == 0) {
        break;
      }
      reader.skipType(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): Module {
    return {
      moduleType: isSet(object.moduleType) ? moduleTypeFromJSON(object.moduleType) : 0,
      rotation: isSet(object.rotation) ? Number(object.rotation) : 0,
      x: isSet(object.x) ? Number(object.x) : 0,
      y: isSet(object.y) ? Number(object.y) : 0,
    };
  },

  toJSON(message: Module): unknown {
    const obj: any = {};
    message.moduleType !== undefined && (obj.moduleType = moduleTypeToJSON(message.moduleType));
    message.rotation !== undefined && (obj.rotation = message.rotation);
    message.x !== undefined && (obj.x = message.x);
    message.y !== undefined && (obj.y = message.y);
    return obj;
  },

  create<I extends Exact<DeepPartial<Module>, I>>(base?: I): Module {
    return Module.fromPartial(base ?? {});
  },

  fromPartial<I extends Exact<DeepPartial<Module>, I>>(object: I): Module {
    const message = createBaseModule();
    message.moduleType = object.moduleType ?? 0;
    message.rotation = object.rotation ?? 0;
    message.x = object.x ?? 0;
    message.y = object.y ?? 0;
    return message;
  },
};

type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;

export type DeepPartial<T> = T extends Builtin ? T
  : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
  : Partial<T>;

type KeysOfUnion<T> = T extends T ? keyof T : never;
export type Exact<P, I extends P> = P extends Builtin ? P
  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };

function isSet(value: any): boolean {
  return value !== null && value !== undefined;
}