// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
// versions:
//   protoc-gen-ts_proto  v2.11.2
//   protoc               v5.28.2
// source: model_definitions.proto

/* eslint-disable */
import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";

export const protobufPackage = "blitzkit";

export interface ModelDefinitions {
  models: { [key: number]: ModelDefinition };
}

export interface ModelDefinitions_ModelsEntry {
  key: number;
  value: ModelDefinition | undefined;
}

export interface ModelDefinition {
  armor: Armor | undefined;
  turret_origin: Vector3 | undefined;
  initial_turret_rotation?: InitialTurretRotation | undefined;
  turrets: { [key: number]: TurretModelDefinition };
  tracks: { [key: number]: TrackModelDefinition };
  bounding_box: BoundingBox | undefined;
}

export interface ModelDefinition_TurretsEntry {
  key: number;
  value: TurretModelDefinition | undefined;
}

export interface ModelDefinition_TracksEntry {
  key: number;
  value: TrackModelDefinition | undefined;
}

export interface Armor {
  thickness: { [key: number]: number };
  spaced: number[];
}

export interface Armor_ThicknessEntry {
  key: number;
  value: number;
}

export interface Vector3 {
  x: number;
  y: number;
  z: number;
}

export interface InitialTurretRotation {
  yaw: number;
  pitch: number;
  roll: number;
}

export interface TurretModelDefinition {
  bounding_box: BoundingBox | undefined;
  armor: Armor | undefined;
  model_id: number;
  gun_origin: Vector3 | undefined;
  guns: { [key: number]: GunModelDefinition };
  yaw?: YawLimits | undefined;
}

export interface TurretModelDefinition_GunsEntry {
  key: number;
  value: GunModelDefinition | undefined;
}

export interface YawLimits {
  min: number;
  max: number;
}

export interface BoundingBox {
  min: Vector3 | undefined;
  max: Vector3 | undefined;
}

export interface TrackModelDefinition {
  thickness: number;
  origin: Vector3 | undefined;
}

export interface GunModelDefinition {
  armor: Armor | undefined;
  thickness: number;
  model_id: number;
  pitch: PitchLimits | undefined;
  mask?: number | undefined;
}

export interface PitchLimits {
  min: number;
  max: number;
  front?: PitchLimitsExtrema | undefined;
  back?: PitchLimitsExtrema | undefined;
  transition?: number | undefined;
}

export interface PitchLimitsExtrema {
  min: number;
  max: number;
  range: number;
}

function createBaseModelDefinitions(): ModelDefinitions {
  return { models: {} };
}

export const ModelDefinitions: MessageFns<ModelDefinitions> = {
  encode(message: ModelDefinitions, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    globalThis.Object.entries(message.models).forEach(([key, value]: [string, ModelDefinition]) => {
      ModelDefinitions_ModelsEntry.encode({ key: key as any, value }, writer.uint32(10).fork()).join();
    });
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ModelDefinitions {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseModelDefinitions();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          const entry1 = ModelDefinitions_ModelsEntry.decode(reader, reader.uint32());
          if (entry1.value !== undefined) {
            message.models[entry1.key] = entry1.value;
          }
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): ModelDefinitions {
    return {
      models: isObject(object.models)
        ? (globalThis.Object.entries(object.models) as [string, any][]).reduce(
          (acc: { [key: number]: ModelDefinition }, [key, value]: [string, any]) => {
            acc[globalThis.Number(key)] = ModelDefinition.fromJSON(value);
            return acc;
          },
          {},
        )
        : {},
    };
  },

  toJSON(message: ModelDefinitions): unknown {
    const obj: any = {};
    if (message.models) {
      const entries = globalThis.Object.entries(message.models) as [string, ModelDefinition][];
      if (entries.length > 0) {
        obj.models = {};
        entries.forEach(([k, v]) => {
          obj.models[k] = ModelDefinition.toJSON(v);
        });
      }
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<ModelDefinitions>, I>>(base?: I): ModelDefinitions {
    return ModelDefinitions.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<ModelDefinitions>, I>>(object: I): ModelDefinitions {
    const message = createBaseModelDefinitions();
    message.models = (globalThis.Object.entries(object.models ?? {}) as [string, ModelDefinition][]).reduce(
      (acc: { [key: number]: ModelDefinition }, [key, value]: [string, ModelDefinition]) => {
        if (value !== undefined) {
          acc[globalThis.Number(key)] = ModelDefinition.fromPartial(value);
        }
        return acc;
      },
      {},
    );
    return message;
  },
};

function createBaseModelDefinitions_ModelsEntry(): ModelDefinitions_ModelsEntry {
  return { key: 0, value: undefined };
}

export const ModelDefinitions_ModelsEntry: MessageFns<ModelDefinitions_ModelsEntry> = {
  encode(message: ModelDefinitions_ModelsEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.key !== 0) {
      writer.uint32(8).uint32(message.key);
    }
    if (message.value !== undefined) {
      ModelDefinition.encode(message.value, writer.uint32(18).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ModelDefinitions_ModelsEntry {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseModelDefinitions_ModelsEntry();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 8) {
            break;
          }

          message.key = reader.uint32();
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }

          message.value = ModelDefinition.decode(reader, reader.uint32());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): ModelDefinitions_ModelsEntry {
    return {
      key: isSet(object.key) ? globalThis.Number(object.key) : 0,
      value: isSet(object.value) ? ModelDefinition.fromJSON(object.value) : undefined,
    };
  },

  toJSON(message: ModelDefinitions_ModelsEntry): unknown {
    const obj: any = {};
    if (message.key !== 0) {
      obj.key = Math.round(message.key);
    }
    if (message.value !== undefined) {
      obj.value = ModelDefinition.toJSON(message.value);
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<ModelDefinitions_ModelsEntry>, I>>(base?: I): ModelDefinitions_ModelsEntry {
    return ModelDefinitions_ModelsEntry.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<ModelDefinitions_ModelsEntry>, I>>(object: I): ModelDefinitions_ModelsEntry {
    const message = createBaseModelDefinitions_ModelsEntry();
    message.key = object.key ?? 0;
    message.value = (object.value !== undefined && object.value !== null)
      ? ModelDefinition.fromPartial(object.value)
      : undefined;
    return message;
  },
};

function createBaseModelDefinition(): ModelDefinition {
  return {
    armor: undefined,
    turret_origin: undefined,
    initial_turret_rotation: undefined,
    turrets: {},
    tracks: {},
    bounding_box: undefined,
  };
}

export const ModelDefinition: MessageFns<ModelDefinition> = {
  encode(message: ModelDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.armor !== undefined) {
      Armor.encode(message.armor, writer.uint32(10).fork()).join();
    }
    if (message.turret_origin !== undefined) {
      Vector3.encode(message.turret_origin, writer.uint32(18).fork()).join();
    }
    if (message.initial_turret_rotation !== undefined) {
      InitialTurretRotation.encode(message.initial_turret_rotation, writer.uint32(26).fork()).join();
    }
    globalThis.Object.entries(message.turrets).forEach(([key, value]: [string, TurretModelDefinition]) => {
      ModelDefinition_TurretsEntry.encode({ key: key as any, value }, writer.uint32(34).fork()).join();
    });
    globalThis.Object.entries(message.tracks).forEach(([key, value]: [string, TrackModelDefinition]) => {
      ModelDefinition_TracksEntry.encode({ key: key as any, value }, writer.uint32(42).fork()).join();
    });
    if (message.bounding_box !== undefined) {
      BoundingBox.encode(message.bounding_box, writer.uint32(50).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ModelDefinition {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseModelDefinition();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.armor = Armor.decode(reader, reader.uint32());
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }

          message.turret_origin = Vector3.decode(reader, reader.uint32());
          continue;
        }
        case 3: {
          if (tag !== 26) {
            break;
          }

          message.initial_turret_rotation = InitialTurretRotation.decode(reader, reader.uint32());
          continue;
        }
        case 4: {
          if (tag !== 34) {
            break;
          }

          const entry4 = ModelDefinition_TurretsEntry.decode(reader, reader.uint32());
          if (entry4.value !== undefined) {
            message.turrets[entry4.key] = entry4.value;
          }
          continue;
        }
        case 5: {
          if (tag !== 42) {
            break;
          }

          const entry5 = ModelDefinition_TracksEntry.decode(reader, reader.uint32());
          if (entry5.value !== undefined) {
            message.tracks[entry5.key] = entry5.value;
          }
          continue;
        }
        case 6: {
          if (tag !== 50) {
            break;
          }

          message.bounding_box = BoundingBox.decode(reader, reader.uint32());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): ModelDefinition {
    return {
      armor: isSet(object.armor) ? Armor.fromJSON(object.armor) : undefined,
      turret_origin: isSet(object.turretOrigin)
        ? Vector3.fromJSON(object.turretOrigin)
        : isSet(object.turret_origin)
        ? Vector3.fromJSON(object.turret_origin)
        : undefined,
      initial_turret_rotation: isSet(object.initialTurretRotation)
        ? InitialTurretRotation.fromJSON(object.initialTurretRotation)
        : isSet(object.initial_turret_rotation)
        ? InitialTurretRotation.fromJSON(object.initial_turret_rotation)
        : undefined,
      turrets: isObject(object.turrets)
        ? (globalThis.Object.entries(object.turrets) as [string, any][]).reduce(
          (acc: { [key: number]: TurretModelDefinition }, [key, value]: [string, any]) => {
            acc[globalThis.Number(key)] = TurretModelDefinition.fromJSON(value);
            return acc;
          },
          {},
        )
        : {},
      tracks: isObject(object.tracks)
        ? (globalThis.Object.entries(object.tracks) as [string, any][]).reduce(
          (acc: { [key: number]: TrackModelDefinition }, [key, value]: [string, any]) => {
            acc[globalThis.Number(key)] = TrackModelDefinition.fromJSON(value);
            return acc;
          },
          {},
        )
        : {},
      bounding_box: isSet(object.boundingBox)
        ? BoundingBox.fromJSON(object.boundingBox)
        : isSet(object.bounding_box)
        ? BoundingBox.fromJSON(object.bounding_box)
        : undefined,
    };
  },

  toJSON(message: ModelDefinition): unknown {
    const obj: any = {};
    if (message.armor !== undefined) {
      obj.armor = Armor.toJSON(message.armor);
    }
    if (message.turret_origin !== undefined) {
      obj.turretOrigin = Vector3.toJSON(message.turret_origin);
    }
    if (message.initial_turret_rotation !== undefined) {
      obj.initialTurretRotation = InitialTurretRotation.toJSON(message.initial_turret_rotation);
    }
    if (message.turrets) {
      const entries = globalThis.Object.entries(message.turrets) as [string, TurretModelDefinition][];
      if (entries.length > 0) {
        obj.turrets = {};
        entries.forEach(([k, v]) => {
          obj.turrets[k] = TurretModelDefinition.toJSON(v);
        });
      }
    }
    if (message.tracks) {
      const entries = globalThis.Object.entries(message.tracks) as [string, TrackModelDefinition][];
      if (entries.length > 0) {
        obj.tracks = {};
        entries.forEach(([k, v]) => {
          obj.tracks[k] = TrackModelDefinition.toJSON(v);
        });
      }
    }
    if (message.bounding_box !== undefined) {
      obj.boundingBox = BoundingBox.toJSON(message.bounding_box);
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<ModelDefinition>, I>>(base?: I): ModelDefinition {
    return ModelDefinition.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<ModelDefinition>, I>>(object: I): ModelDefinition {
    const message = createBaseModelDefinition();
    message.armor = (object.armor !== undefined && object.armor !== null) ? Armor.fromPartial(object.armor) : undefined;
    message.turret_origin = (object.turret_origin !== undefined && object.turret_origin !== null)
      ? Vector3.fromPartial(object.turret_origin)
      : undefined;
    message.initial_turret_rotation =
      (object.initial_turret_rotation !== undefined && object.initial_turret_rotation !== null)
        ? InitialTurretRotation.fromPartial(object.initial_turret_rotation)
        : undefined;
    message.turrets = (globalThis.Object.entries(object.turrets ?? {}) as [string, TurretModelDefinition][]).reduce(
      (acc: { [key: number]: TurretModelDefinition }, [key, value]: [string, TurretModelDefinition]) => {
        if (value !== undefined) {
          acc[globalThis.Number(key)] = TurretModelDefinition.fromPartial(value);
        }
        return acc;
      },
      {},
    );
    message.tracks = (globalThis.Object.entries(object.tracks ?? {}) as [string, TrackModelDefinition][]).reduce(
      (acc: { [key: number]: TrackModelDefinition }, [key, value]: [string, TrackModelDefinition]) => {
        if (value !== undefined) {
          acc[globalThis.Number(key)] = TrackModelDefinition.fromPartial(value);
        }
        return acc;
      },
      {},
    );
    message.bounding_box = (object.bounding_box !== undefined && object.bounding_box !== null)
      ? BoundingBox.fromPartial(object.bounding_box)
      : undefined;
    return message;
  },
};

function createBaseModelDefinition_TurretsEntry(): ModelDefinition_TurretsEntry {
  return { key: 0, value: undefined };
}

export const ModelDefinition_TurretsEntry: MessageFns<ModelDefinition_TurretsEntry> = {
  encode(message: ModelDefinition_TurretsEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.key !== 0) {
      writer.uint32(8).uint32(message.key);
    }
    if (message.value !== undefined) {
      TurretModelDefinition.encode(message.value, writer.uint32(18).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ModelDefinition_TurretsEntry {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseModelDefinition_TurretsEntry();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 8) {
            break;
          }

          message.key = reader.uint32();
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }

          message.value = TurretModelDefinition.decode(reader, reader.uint32());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): ModelDefinition_TurretsEntry {
    return {
      key: isSet(object.key) ? globalThis.Number(object.key) : 0,
      value: isSet(object.value) ? TurretModelDefinition.fromJSON(object.value) : undefined,
    };
  },

  toJSON(message: ModelDefinition_TurretsEntry): unknown {
    const obj: any = {};
    if (message.key !== 0) {
      obj.key = Math.round(message.key);
    }
    if (message.value !== undefined) {
      obj.value = TurretModelDefinition.toJSON(message.value);
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<ModelDefinition_TurretsEntry>, I>>(base?: I): ModelDefinition_TurretsEntry {
    return ModelDefinition_TurretsEntry.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<ModelDefinition_TurretsEntry>, I>>(object: I): ModelDefinition_TurretsEntry {
    const message = createBaseModelDefinition_TurretsEntry();
    message.key = object.key ?? 0;
    message.value = (object.value !== undefined && object.value !== null)
      ? TurretModelDefinition.fromPartial(object.value)
      : undefined;
    return message;
  },
};

function createBaseModelDefinition_TracksEntry(): ModelDefinition_TracksEntry {
  return { key: 0, value: undefined };
}

export const ModelDefinition_TracksEntry: MessageFns<ModelDefinition_TracksEntry> = {
  encode(message: ModelDefinition_TracksEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.key !== 0) {
      writer.uint32(8).uint32(message.key);
    }
    if (message.value !== undefined) {
      TrackModelDefinition.encode(message.value, writer.uint32(18).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ModelDefinition_TracksEntry {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseModelDefinition_TracksEntry();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 8) {
            break;
          }

          message.key = reader.uint32();
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }

          message.value = TrackModelDefinition.decode(reader, reader.uint32());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): ModelDefinition_TracksEntry {
    return {
      key: isSet(object.key) ? globalThis.Number(object.key) : 0,
      value: isSet(object.value) ? TrackModelDefinition.fromJSON(object.value) : undefined,
    };
  },

  toJSON(message: ModelDefinition_TracksEntry): unknown {
    const obj: any = {};
    if (message.key !== 0) {
      obj.key = Math.round(message.key);
    }
    if (message.value !== undefined) {
      obj.value = TrackModelDefinition.toJSON(message.value);
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<ModelDefinition_TracksEntry>, I>>(base?: I): ModelDefinition_TracksEntry {
    return ModelDefinition_TracksEntry.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<ModelDefinition_TracksEntry>, I>>(object: I): ModelDefinition_TracksEntry {
    const message = createBaseModelDefinition_TracksEntry();
    message.key = object.key ?? 0;
    message.value = (object.value !== undefined && object.value !== null)
      ? TrackModelDefinition.fromPartial(object.value)
      : undefined;
    return message;
  },
};

function createBaseArmor(): Armor {
  return { thickness: {}, spaced: [] };
}

export const Armor: MessageFns<Armor> = {
  encode(message: Armor, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    globalThis.Object.entries(message.thickness).forEach(([key, value]: [string, number]) => {
      Armor_ThicknessEntry.encode({ key: key as any, value }, writer.uint32(10).fork()).join();
    });
    for (const v of message.spaced) {
      writer.uint32(16).uint32(v!);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): Armor {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseArmor();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          const entry1 = Armor_ThicknessEntry.decode(reader, reader.uint32());
          if (entry1.value !== undefined) {
            message.thickness[entry1.key] = entry1.value;
          }
          continue;
        }
        case 2: {
          if (tag === 16) {
            message.spaced.push(reader.uint32());

            continue;
          }

          if (tag === 18) {
            const end2 = reader.uint32() + reader.pos;
            while (reader.pos < end2) {
              message.spaced.push(reader.uint32());
            }

            continue;
          }

          break;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): Armor {
    return {
      thickness: isObject(object.thickness)
        ? (globalThis.Object.entries(object.thickness) as [string, any][]).reduce(
          (acc: { [key: number]: number }, [key, value]: [string, any]) => {
            acc[globalThis.Number(key)] = globalThis.Number(value);
            return acc;
          },
          {},
        )
        : {},
      spaced: globalThis.Array.isArray(object?.spaced) ? object.spaced.map((e: any) => globalThis.Number(e)) : [],
    };
  },

  toJSON(message: Armor): unknown {
    const obj: any = {};
    if (message.thickness) {
      const entries = globalThis.Object.entries(message.thickness) as [string, number][];
      if (entries.length > 0) {
        obj.thickness = {};
        entries.forEach(([k, v]) => {
          obj.thickness[k] = v;
        });
      }
    }
    if (message.spaced?.length) {
      obj.spaced = message.spaced.map((e) => Math.round(e));
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<Armor>, I>>(base?: I): Armor {
    return Armor.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<Armor>, I>>(object: I): Armor {
    const message = createBaseArmor();
    message.thickness = (globalThis.Object.entries(object.thickness ?? {}) as [string, number][]).reduce(
      (acc: { [key: number]: number }, [key, value]: [string, number]) => {
        if (value !== undefined) {
          acc[globalThis.Number(key)] = globalThis.Number(value);
        }
        return acc;
      },
      {},
    );
    message.spaced = object.spaced?.map((e) => e) || [];
    return message;
  },
};

function createBaseArmor_ThicknessEntry(): Armor_ThicknessEntry {
  return { key: 0, value: 0 };
}

export const Armor_ThicknessEntry: MessageFns<Armor_ThicknessEntry> = {
  encode(message: Armor_ThicknessEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.key !== 0) {
      writer.uint32(8).uint32(message.key);
    }
    if (message.value !== 0) {
      writer.uint32(21).float(message.value);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): Armor_ThicknessEntry {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseArmor_ThicknessEntry();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 8) {
            break;
          }

          message.key = reader.uint32();
          continue;
        }
        case 2: {
          if (tag !== 21) {
            break;
          }

          message.value = reader.float();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): Armor_ThicknessEntry {
    return {
      key: isSet(object.key) ? globalThis.Number(object.key) : 0,
      value: isSet(object.value) ? globalThis.Number(object.value) : 0,
    };
  },

  toJSON(message: Armor_ThicknessEntry): unknown {
    const obj: any = {};
    if (message.key !== 0) {
      obj.key = Math.round(message.key);
    }
    if (message.value !== 0) {
      obj.value = message.value;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<Armor_ThicknessEntry>, I>>(base?: I): Armor_ThicknessEntry {
    return Armor_ThicknessEntry.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<Armor_ThicknessEntry>, I>>(object: I): Armor_ThicknessEntry {
    const message = createBaseArmor_ThicknessEntry();
    message.key = object.key ?? 0;
    message.value = object.value ?? 0;
    return message;
  },
};

function createBaseVector3(): Vector3 {
  return { x: 0, y: 0, z: 0 };
}

export const Vector3: MessageFns<Vector3> = {
  encode(message: Vector3, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.x !== 0) {
      writer.uint32(13).float(message.x);
    }
    if (message.y !== 0) {
      writer.uint32(21).float(message.y);
    }
    if (message.z !== 0) {
      writer.uint32(29).float(message.z);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): Vector3 {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseVector3();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 13) {
            break;
          }

          message.x = reader.float();
          continue;
        }
        case 2: {
          if (tag !== 21) {
            break;
          }

          message.y = reader.float();
          continue;
        }
        case 3: {
          if (tag !== 29) {
            break;
          }

          message.z = reader.float();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): Vector3 {
    return {
      x: isSet(object.x) ? globalThis.Number(object.x) : 0,
      y: isSet(object.y) ? globalThis.Number(object.y) : 0,
      z: isSet(object.z) ? globalThis.Number(object.z) : 0,
    };
  },

  toJSON(message: Vector3): unknown {
    const obj: any = {};
    if (message.x !== 0) {
      obj.x = message.x;
    }
    if (message.y !== 0) {
      obj.y = message.y;
    }
    if (message.z !== 0) {
      obj.z = message.z;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<Vector3>, I>>(base?: I): Vector3 {
    return Vector3.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<Vector3>, I>>(object: I): Vector3 {
    const message = createBaseVector3();
    message.x = object.x ?? 0;
    message.y = object.y ?? 0;
    message.z = object.z ?? 0;
    return message;
  },
};

function createBaseInitialTurretRotation(): InitialTurretRotation {
  return { yaw: 0, pitch: 0, roll: 0 };
}

export const InitialTurretRotation: MessageFns<InitialTurretRotation> = {
  encode(message: InitialTurretRotation, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.yaw !== 0) {
      writer.uint32(13).float(message.yaw);
    }
    if (message.pitch !== 0) {
      writer.uint32(21).float(message.pitch);
    }
    if (message.roll !== 0) {
      writer.uint32(29).float(message.roll);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): InitialTurretRotation {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseInitialTurretRotation();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 13) {
            break;
          }

          message.yaw = reader.float();
          continue;
        }
        case 2: {
          if (tag !== 21) {
            break;
          }

          message.pitch = reader.float();
          continue;
        }
        case 3: {
          if (tag !== 29) {
            break;
          }

          message.roll = reader.float();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): InitialTurretRotation {
    return {
      yaw: isSet(object.yaw) ? globalThis.Number(object.yaw) : 0,
      pitch: isSet(object.pitch) ? globalThis.Number(object.pitch) : 0,
      roll: isSet(object.roll) ? globalThis.Number(object.roll) : 0,
    };
  },

  toJSON(message: InitialTurretRotation): unknown {
    const obj: any = {};
    if (message.yaw !== 0) {
      obj.yaw = message.yaw;
    }
    if (message.pitch !== 0) {
      obj.pitch = message.pitch;
    }
    if (message.roll !== 0) {
      obj.roll = message.roll;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<InitialTurretRotation>, I>>(base?: I): InitialTurretRotation {
    return InitialTurretRotation.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<InitialTurretRotation>, I>>(object: I): InitialTurretRotation {
    const message = createBaseInitialTurretRotation();
    message.yaw = object.yaw ?? 0;
    message.pitch = object.pitch ?? 0;
    message.roll = object.roll ?? 0;
    return message;
  },
};

function createBaseTurretModelDefinition(): TurretModelDefinition {
  return { bounding_box: undefined, armor: undefined, model_id: 0, gun_origin: undefined, guns: {}, yaw: undefined };
}

export const TurretModelDefinition: MessageFns<TurretModelDefinition> = {
  encode(message: TurretModelDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.bounding_box !== undefined) {
      BoundingBox.encode(message.bounding_box, writer.uint32(10).fork()).join();
    }
    if (message.armor !== undefined) {
      Armor.encode(message.armor, writer.uint32(18).fork()).join();
    }
    if (message.model_id !== 0) {
      writer.uint32(24).uint32(message.model_id);
    }
    if (message.gun_origin !== undefined) {
      Vector3.encode(message.gun_origin, writer.uint32(34).fork()).join();
    }
    globalThis.Object.entries(message.guns).forEach(([key, value]: [string, GunModelDefinition]) => {
      TurretModelDefinition_GunsEntry.encode({ key: key as any, value }, writer.uint32(42).fork()).join();
    });
    if (message.yaw !== undefined) {
      YawLimits.encode(message.yaw, writer.uint32(50).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): TurretModelDefinition {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseTurretModelDefinition();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.bounding_box = BoundingBox.decode(reader, reader.uint32());
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }

          message.armor = Armor.decode(reader, reader.uint32());
          continue;
        }
        case 3: {
          if (tag !== 24) {
            break;
          }

          message.model_id = reader.uint32();
          continue;
        }
        case 4: {
          if (tag !== 34) {
            break;
          }

          message.gun_origin = Vector3.decode(reader, reader.uint32());
          continue;
        }
        case 5: {
          if (tag !== 42) {
            break;
          }

          const entry5 = TurretModelDefinition_GunsEntry.decode(reader, reader.uint32());
          if (entry5.value !== undefined) {
            message.guns[entry5.key] = entry5.value;
          }
          continue;
        }
        case 6: {
          if (tag !== 50) {
            break;
          }

          message.yaw = YawLimits.decode(reader, reader.uint32());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): TurretModelDefinition {
    return {
      bounding_box: isSet(object.boundingBox)
        ? BoundingBox.fromJSON(object.boundingBox)
        : isSet(object.bounding_box)
        ? BoundingBox.fromJSON(object.bounding_box)
        : undefined,
      armor: isSet(object.armor) ? Armor.fromJSON(object.armor) : undefined,
      model_id: isSet(object.modelId)
        ? globalThis.Number(object.modelId)
        : isSet(object.model_id)
        ? globalThis.Number(object.model_id)
        : 0,
      gun_origin: isSet(object.gunOrigin)
        ? Vector3.fromJSON(object.gunOrigin)
        : isSet(object.gun_origin)
        ? Vector3.fromJSON(object.gun_origin)
        : undefined,
      guns: isObject(object.guns)
        ? (globalThis.Object.entries(object.guns) as [string, any][]).reduce(
          (acc: { [key: number]: GunModelDefinition }, [key, value]: [string, any]) => {
            acc[globalThis.Number(key)] = GunModelDefinition.fromJSON(value);
            return acc;
          },
          {},
        )
        : {},
      yaw: isSet(object.yaw) ? YawLimits.fromJSON(object.yaw) : undefined,
    };
  },

  toJSON(message: TurretModelDefinition): unknown {
    const obj: any = {};
    if (message.bounding_box !== undefined) {
      obj.boundingBox = BoundingBox.toJSON(message.bounding_box);
    }
    if (message.armor !== undefined) {
      obj.armor = Armor.toJSON(message.armor);
    }
    if (message.model_id !== 0) {
      obj.modelId = Math.round(message.model_id);
    }
    if (message.gun_origin !== undefined) {
      obj.gunOrigin = Vector3.toJSON(message.gun_origin);
    }
    if (message.guns) {
      const entries = globalThis.Object.entries(message.guns) as [string, GunModelDefinition][];
      if (entries.length > 0) {
        obj.guns = {};
        entries.forEach(([k, v]) => {
          obj.guns[k] = GunModelDefinition.toJSON(v);
        });
      }
    }
    if (message.yaw !== undefined) {
      obj.yaw = YawLimits.toJSON(message.yaw);
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<TurretModelDefinition>, I>>(base?: I): TurretModelDefinition {
    return TurretModelDefinition.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<TurretModelDefinition>, I>>(object: I): TurretModelDefinition {
    const message = createBaseTurretModelDefinition();
    message.bounding_box = (object.bounding_box !== undefined && object.bounding_box !== null)
      ? BoundingBox.fromPartial(object.bounding_box)
      : undefined;
    message.armor = (object.armor !== undefined && object.armor !== null) ? Armor.fromPartial(object.armor) : undefined;
    message.model_id = object.model_id ?? 0;
    message.gun_origin = (object.gun_origin !== undefined && object.gun_origin !== null)
      ? Vector3.fromPartial(object.gun_origin)
      : undefined;
    message.guns = (globalThis.Object.entries(object.guns ?? {}) as [string, GunModelDefinition][]).reduce(
      (acc: { [key: number]: GunModelDefinition }, [key, value]: [string, GunModelDefinition]) => {
        if (value !== undefined) {
          acc[globalThis.Number(key)] = GunModelDefinition.fromPartial(value);
        }
        return acc;
      },
      {},
    );
    message.yaw = (object.yaw !== undefined && object.yaw !== null) ? YawLimits.fromPartial(object.yaw) : undefined;
    return message;
  },
};

function createBaseTurretModelDefinition_GunsEntry(): TurretModelDefinition_GunsEntry {
  return { key: 0, value: undefined };
}

export const TurretModelDefinition_GunsEntry: MessageFns<TurretModelDefinition_GunsEntry> = {
  encode(message: TurretModelDefinition_GunsEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.key !== 0) {
      writer.uint32(8).uint32(message.key);
    }
    if (message.value !== undefined) {
      GunModelDefinition.encode(message.value, writer.uint32(18).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): TurretModelDefinition_GunsEntry {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseTurretModelDefinition_GunsEntry();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 8) {
            break;
          }

          message.key = reader.uint32();
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }

          message.value = GunModelDefinition.decode(reader, reader.uint32());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): TurretModelDefinition_GunsEntry {
    return {
      key: isSet(object.key) ? globalThis.Number(object.key) : 0,
      value: isSet(object.value) ? GunModelDefinition.fromJSON(object.value) : undefined,
    };
  },

  toJSON(message: TurretModelDefinition_GunsEntry): unknown {
    const obj: any = {};
    if (message.key !== 0) {
      obj.key = Math.round(message.key);
    }
    if (message.value !== undefined) {
      obj.value = GunModelDefinition.toJSON(message.value);
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<TurretModelDefinition_GunsEntry>, I>>(base?: I): TurretModelDefinition_GunsEntry {
    return TurretModelDefinition_GunsEntry.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<TurretModelDefinition_GunsEntry>, I>>(
    object: I,
  ): TurretModelDefinition_GunsEntry {
    const message = createBaseTurretModelDefinition_GunsEntry();
    message.key = object.key ?? 0;
    message.value = (object.value !== undefined && object.value !== null)
      ? GunModelDefinition.fromPartial(object.value)
      : undefined;
    return message;
  },
};

function createBaseYawLimits(): YawLimits {
  return { min: 0, max: 0 };
}

export const YawLimits: MessageFns<YawLimits> = {
  encode(message: YawLimits, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.min !== 0) {
      writer.uint32(13).float(message.min);
    }
    if (message.max !== 0) {
      writer.uint32(21).float(message.max);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): YawLimits {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseYawLimits();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 13) {
            break;
          }

          message.min = reader.float();
          continue;
        }
        case 2: {
          if (tag !== 21) {
            break;
          }

          message.max = reader.float();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): YawLimits {
    return {
      min: isSet(object.min) ? globalThis.Number(object.min) : 0,
      max: isSet(object.max) ? globalThis.Number(object.max) : 0,
    };
  },

  toJSON(message: YawLimits): unknown {
    const obj: any = {};
    if (message.min !== 0) {
      obj.min = message.min;
    }
    if (message.max !== 0) {
      obj.max = message.max;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<YawLimits>, I>>(base?: I): YawLimits {
    return YawLimits.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<YawLimits>, I>>(object: I): YawLimits {
    const message = createBaseYawLimits();
    message.min = object.min ?? 0;
    message.max = object.max ?? 0;
    return message;
  },
};

function createBaseBoundingBox(): BoundingBox {
  return { min: undefined, max: undefined };
}

export const BoundingBox: MessageFns<BoundingBox> = {
  encode(message: BoundingBox, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.min !== undefined) {
      Vector3.encode(message.min, writer.uint32(10).fork()).join();
    }
    if (message.max !== undefined) {
      Vector3.encode(message.max, writer.uint32(18).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): BoundingBox {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseBoundingBox();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.min = Vector3.decode(reader, reader.uint32());
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }

          message.max = Vector3.decode(reader, reader.uint32());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): BoundingBox {
    return {
      min: isSet(object.min) ? Vector3.fromJSON(object.min) : undefined,
      max: isSet(object.max) ? Vector3.fromJSON(object.max) : undefined,
    };
  },

  toJSON(message: BoundingBox): unknown {
    const obj: any = {};
    if (message.min !== undefined) {
      obj.min = Vector3.toJSON(message.min);
    }
    if (message.max !== undefined) {
      obj.max = Vector3.toJSON(message.max);
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<BoundingBox>, I>>(base?: I): BoundingBox {
    return BoundingBox.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<BoundingBox>, I>>(object: I): BoundingBox {
    const message = createBaseBoundingBox();
    message.min = (object.min !== undefined && object.min !== null) ? Vector3.fromPartial(object.min) : undefined;
    message.max = (object.max !== undefined && object.max !== null) ? Vector3.fromPartial(object.max) : undefined;
    return message;
  },
};

function createBaseTrackModelDefinition(): TrackModelDefinition {
  return { thickness: 0, origin: undefined };
}

export const TrackModelDefinition: MessageFns<TrackModelDefinition> = {
  encode(message: TrackModelDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.thickness !== 0) {
      writer.uint32(13).float(message.thickness);
    }
    if (message.origin !== undefined) {
      Vector3.encode(message.origin, writer.uint32(18).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): TrackModelDefinition {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseTrackModelDefinition();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 13) {
            break;
          }

          message.thickness = reader.float();
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }

          message.origin = Vector3.decode(reader, reader.uint32());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): TrackModelDefinition {
    return {
      thickness: isSet(object.thickness) ? globalThis.Number(object.thickness) : 0,
      origin: isSet(object.origin) ? Vector3.fromJSON(object.origin) : undefined,
    };
  },

  toJSON(message: TrackModelDefinition): unknown {
    const obj: any = {};
    if (message.thickness !== 0) {
      obj.thickness = message.thickness;
    }
    if (message.origin !== undefined) {
      obj.origin = Vector3.toJSON(message.origin);
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<TrackModelDefinition>, I>>(base?: I): TrackModelDefinition {
    return TrackModelDefinition.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<TrackModelDefinition>, I>>(object: I): TrackModelDefinition {
    const message = createBaseTrackModelDefinition();
    message.thickness = object.thickness ?? 0;
    message.origin = (object.origin !== undefined && object.origin !== null)
      ? Vector3.fromPartial(object.origin)
      : undefined;
    return message;
  },
};

function createBaseGunModelDefinition(): GunModelDefinition {
  return { armor: undefined, thickness: 0, model_id: 0, pitch: undefined, mask: 0 };
}

export const GunModelDefinition: MessageFns<GunModelDefinition> = {
  encode(message: GunModelDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.armor !== undefined) {
      Armor.encode(message.armor, writer.uint32(10).fork()).join();
    }
    if (message.thickness !== 0) {
      writer.uint32(21).float(message.thickness);
    }
    if (message.model_id !== 0) {
      writer.uint32(24).uint32(message.model_id);
    }
    if (message.pitch !== undefined) {
      PitchLimits.encode(message.pitch, writer.uint32(34).fork()).join();
    }
    if (message.mask !== undefined && message.mask !== 0) {
      writer.uint32(45).float(message.mask);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): GunModelDefinition {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseGunModelDefinition();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.armor = Armor.decode(reader, reader.uint32());
          continue;
        }
        case 2: {
          if (tag !== 21) {
            break;
          }

          message.thickness = reader.float();
          continue;
        }
        case 3: {
          if (tag !== 24) {
            break;
          }

          message.model_id = reader.uint32();
          continue;
        }
        case 4: {
          if (tag !== 34) {
            break;
          }

          message.pitch = PitchLimits.decode(reader, reader.uint32());
          continue;
        }
        case 5: {
          if (tag !== 45) {
            break;
          }

          message.mask = reader.float();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): GunModelDefinition {
    return {
      armor: isSet(object.armor) ? Armor.fromJSON(object.armor) : undefined,
      thickness: isSet(object.thickness) ? globalThis.Number(object.thickness) : 0,
      model_id: isSet(object.modelId)
        ? globalThis.Number(object.modelId)
        : isSet(object.model_id)
        ? globalThis.Number(object.model_id)
        : 0,
      pitch: isSet(object.pitch) ? PitchLimits.fromJSON(object.pitch) : undefined,
      mask: isSet(object.mask) ? globalThis.Number(object.mask) : 0,
    };
  },

  toJSON(message: GunModelDefinition): unknown {
    const obj: any = {};
    if (message.armor !== undefined) {
      obj.armor = Armor.toJSON(message.armor);
    }
    if (message.thickness !== 0) {
      obj.thickness = message.thickness;
    }
    if (message.model_id !== 0) {
      obj.modelId = Math.round(message.model_id);
    }
    if (message.pitch !== undefined) {
      obj.pitch = PitchLimits.toJSON(message.pitch);
    }
    if (message.mask !== undefined && message.mask !== 0) {
      obj.mask = message.mask;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<GunModelDefinition>, I>>(base?: I): GunModelDefinition {
    return GunModelDefinition.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<GunModelDefinition>, I>>(object: I): GunModelDefinition {
    const message = createBaseGunModelDefinition();
    message.armor = (object.armor !== undefined && object.armor !== null) ? Armor.fromPartial(object.armor) : undefined;
    message.thickness = object.thickness ?? 0;
    message.model_id = object.model_id ?? 0;
    message.pitch = (object.pitch !== undefined && object.pitch !== null)
      ? PitchLimits.fromPartial(object.pitch)
      : undefined;
    message.mask = object.mask ?? 0;
    return message;
  },
};

function createBasePitchLimits(): PitchLimits {
  return { min: 0, max: 0, front: undefined, back: undefined, transition: 0 };
}

export const PitchLimits: MessageFns<PitchLimits> = {
  encode(message: PitchLimits, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.min !== 0) {
      writer.uint32(13).float(message.min);
    }
    if (message.max !== 0) {
      writer.uint32(21).float(message.max);
    }
    if (message.front !== undefined) {
      PitchLimitsExtrema.encode(message.front, writer.uint32(26).fork()).join();
    }
    if (message.back !== undefined) {
      PitchLimitsExtrema.encode(message.back, writer.uint32(34).fork()).join();
    }
    if (message.transition !== undefined && message.transition !== 0) {
      writer.uint32(45).float(message.transition);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): PitchLimits {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBasePitchLimits();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 13) {
            break;
          }

          message.min = reader.float();
          continue;
        }
        case 2: {
          if (tag !== 21) {
            break;
          }

          message.max = reader.float();
          continue;
        }
        case 3: {
          if (tag !== 26) {
            break;
          }

          message.front = PitchLimitsExtrema.decode(reader, reader.uint32());
          continue;
        }
        case 4: {
          if (tag !== 34) {
            break;
          }

          message.back = PitchLimitsExtrema.decode(reader, reader.uint32());
          continue;
        }
        case 5: {
          if (tag !== 45) {
            break;
          }

          message.transition = reader.float();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): PitchLimits {
    return {
      min: isSet(object.min) ? globalThis.Number(object.min) : 0,
      max: isSet(object.max) ? globalThis.Number(object.max) : 0,
      front: isSet(object.front) ? PitchLimitsExtrema.fromJSON(object.front) : undefined,
      back: isSet(object.back) ? PitchLimitsExtrema.fromJSON(object.back) : undefined,
      transition: isSet(object.transition) ? globalThis.Number(object.transition) : 0,
    };
  },

  toJSON(message: PitchLimits): unknown {
    const obj: any = {};
    if (message.min !== 0) {
      obj.min = message.min;
    }
    if (message.max !== 0) {
      obj.max = message.max;
    }
    if (message.front !== undefined) {
      obj.front = PitchLimitsExtrema.toJSON(message.front);
    }
    if (message.back !== undefined) {
      obj.back = PitchLimitsExtrema.toJSON(message.back);
    }
    if (message.transition !== undefined && message.transition !== 0) {
      obj.transition = message.transition;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<PitchLimits>, I>>(base?: I): PitchLimits {
    return PitchLimits.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<PitchLimits>, I>>(object: I): PitchLimits {
    const message = createBasePitchLimits();
    message.min = object.min ?? 0;
    message.max = object.max ?? 0;
    message.front = (object.front !== undefined && object.front !== null)
      ? PitchLimitsExtrema.fromPartial(object.front)
      : undefined;
    message.back = (object.back !== undefined && object.back !== null)
      ? PitchLimitsExtrema.fromPartial(object.back)
      : undefined;
    message.transition = object.transition ?? 0;
    return message;
  },
};

function createBasePitchLimitsExtrema(): PitchLimitsExtrema {
  return { min: 0, max: 0, range: 0 };
}

export const PitchLimitsExtrema: MessageFns<PitchLimitsExtrema> = {
  encode(message: PitchLimitsExtrema, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.min !== 0) {
      writer.uint32(13).float(message.min);
    }
    if (message.max !== 0) {
      writer.uint32(21).float(message.max);
    }
    if (message.range !== 0) {
      writer.uint32(29).float(message.range);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): PitchLimitsExtrema {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBasePitchLimitsExtrema();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 13) {
            break;
          }

          message.min = reader.float();
          continue;
        }
        case 2: {
          if (tag !== 21) {
            break;
          }

          message.max = reader.float();
          continue;
        }
        case 3: {
          if (tag !== 29) {
            break;
          }

          message.range = reader.float();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): PitchLimitsExtrema {
    return {
      min: isSet(object.min) ? globalThis.Number(object.min) : 0,
      max: isSet(object.max) ? globalThis.Number(object.max) : 0,
      range: isSet(object.range) ? globalThis.Number(object.range) : 0,
    };
  },

  toJSON(message: PitchLimitsExtrema): unknown {
    const obj: any = {};
    if (message.min !== 0) {
      obj.min = message.min;
    }
    if (message.max !== 0) {
      obj.max = message.max;
    }
    if (message.range !== 0) {
      obj.range = message.range;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<PitchLimitsExtrema>, I>>(base?: I): PitchLimitsExtrema {
    return PitchLimitsExtrema.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<PitchLimitsExtrema>, I>>(object: I): PitchLimitsExtrema {
    const message = createBasePitchLimitsExtrema();
    message.min = object.min ?? 0;
    message.max = object.max ?? 0;
    message.range = object.range ?? 0;
    return message;
  },
};

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

export type DeepPartial<T> = T extends Builtin ? T
  : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>>
  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
  : T extends { $case: string; value: unknown } ? { $case: T["$case"]; value?: DeepPartial<T["value"]> }
  : 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 isObject(value: any): boolean {
  return typeof value === "object" && value !== null;
}

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

export interface MessageFns<T> {
  encode(message: T, writer?: BinaryWriter): BinaryWriter;
  decode(input: BinaryReader | Uint8Array, length?: number): T;
  fromJSON(object: any): T;
  toJSON(message: T): unknown;
  create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
  fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
}