src/address_data.ts

// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
// versions:
//   protoc-gen-ts_proto  v2.2.0
//   protoc               v5.28.1
// source: src/address_data.proto

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

export const protobufPackage = "";

export enum Kind {
  RSDT = 0,
  CHIBAN = 1,
  UNRECOGNIZED = -1,
}

export function kindFromJSON(object: any): Kind {
  switch (object) {
    case 0:
    case "RSDT":
      return Kind.RSDT;
    case 1:
    case "CHIBAN":
      return Kind.CHIBAN;
    case -1:
    case "UNRECOGNIZED":
    default:
      return Kind.UNRECOGNIZED;
  }
}

export function kindToJSON(object: Kind): string {
  switch (object) {
    case Kind.RSDT:
      return "RSDT";
    case Kind.CHIBAN:
      return "CHIBAN";
    case Kind.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

export interface Header {
  kind: Kind;
  /** required string name = 2; */
  rows: HeaderRow[];
}

export interface HeaderRow {
  name: string;
  offset: number;
  length: number;
}

export interface Section {
  kind: Kind;
  name: string;
  rsdtRows: RsdtRow[];
  chibanRows: ChibanRow[];
}

export interface RsdtRow {
  blkNum?: number | undefined;
  rsdtNum: number;
  rsdtNum2?: number | undefined;
  point?:
    | LngLatPoint
    | undefined;
  /** These strings are only used if the data cannot be expressed by an integer. */
  blkNumStr?: string | undefined;
  rsdtNumStr?: string | undefined;
  rsdtNum2Str?: string | undefined;
}

export interface ChibanRow {
  prcNum1: number;
  prcNum2?: number | undefined;
  prcNum3?: number | undefined;
  point?:
    | LngLatPoint
    | undefined;
  /** These strings are only used if the data cannot be expressed by an integer. */
  prcNum1Str?: string | undefined;
  prcNum2Str?: string | undefined;
  prcNum3Str?: string | undefined;
}

export interface LngLatPoint {
  lng: number;
  lat: number;
}

function createBaseHeader(): Header {
  return { kind: 0, rows: [] };
}

export const Header: MessageFns<Header> = {
  encode(message: Header, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.kind !== 0) {
      writer.uint32(8).int32(message.kind);
    }
    for (const v of message.rows) {
      HeaderRow.encode(v!, writer.uint32(26).fork()).join();
    }
    return writer;
  },

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

          message.kind = reader.int32() as any;
          continue;
        case 3:
          if (tag !== 26) {
            break;
          }

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

  fromJSON(object: any): Header {
    return {
      kind: isSet(object.kind) ? kindFromJSON(object.kind) : 0,
      rows: globalThis.Array.isArray(object?.rows) ? object.rows.map((e: any) => HeaderRow.fromJSON(e)) : [],
    };
  },

  toJSON(message: Header): unknown {
    const obj: any = {};
    if (message.kind !== 0) {
      obj.kind = kindToJSON(message.kind);
    }
    if (message.rows?.length) {
      obj.rows = message.rows.map((e) => HeaderRow.toJSON(e));
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<Header>, I>>(base?: I): Header {
    return Header.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<Header>, I>>(object: I): Header {
    const message = createBaseHeader();
    message.kind = object.kind ?? 0;
    message.rows = object.rows?.map((e) => HeaderRow.fromPartial(e)) || [];
    return message;
  },
};

function createBaseHeaderRow(): HeaderRow {
  return { name: "", offset: 0, length: 0 };
}

export const HeaderRow: MessageFns<HeaderRow> = {
  encode(message: HeaderRow, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.name !== "") {
      writer.uint32(10).string(message.name);
    }
    if (message.offset !== 0) {
      writer.uint32(16).uint32(message.offset);
    }
    if (message.length !== 0) {
      writer.uint32(24).uint32(message.length);
    }
    return writer;
  },

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

          message.name = reader.string();
          continue;
        case 2:
          if (tag !== 16) {
            break;
          }

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

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

  fromJSON(object: any): HeaderRow {
    return {
      name: isSet(object.name) ? globalThis.String(object.name) : "",
      offset: isSet(object.offset) ? globalThis.Number(object.offset) : 0,
      length: isSet(object.length) ? globalThis.Number(object.length) : 0,
    };
  },

  toJSON(message: HeaderRow): unknown {
    const obj: any = {};
    if (message.name !== "") {
      obj.name = message.name;
    }
    if (message.offset !== 0) {
      obj.offset = Math.round(message.offset);
    }
    if (message.length !== 0) {
      obj.length = Math.round(message.length);
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<HeaderRow>, I>>(base?: I): HeaderRow {
    return HeaderRow.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<HeaderRow>, I>>(object: I): HeaderRow {
    const message = createBaseHeaderRow();
    message.name = object.name ?? "";
    message.offset = object.offset ?? 0;
    message.length = object.length ?? 0;
    return message;
  },
};

function createBaseSection(): Section {
  return { kind: 0, name: "", rsdtRows: [], chibanRows: [] };
}

export const Section: MessageFns<Section> = {
  encode(message: Section, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.kind !== 0) {
      writer.uint32(8).int32(message.kind);
    }
    if (message.name !== "") {
      writer.uint32(18).string(message.name);
    }
    for (const v of message.rsdtRows) {
      RsdtRow.encode(v!, writer.uint32(26).fork()).join();
    }
    for (const v of message.chibanRows) {
      ChibanRow.encode(v!, writer.uint32(34).fork()).join();
    }
    return writer;
  },

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

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

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

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

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

  fromJSON(object: any): Section {
    return {
      kind: isSet(object.kind) ? kindFromJSON(object.kind) : 0,
      name: isSet(object.name) ? globalThis.String(object.name) : "",
      rsdtRows: globalThis.Array.isArray(object?.rsdtRows) ? object.rsdtRows.map((e: any) => RsdtRow.fromJSON(e)) : [],
      chibanRows: globalThis.Array.isArray(object?.chibanRows)
        ? object.chibanRows.map((e: any) => ChibanRow.fromJSON(e))
        : [],
    };
  },

  toJSON(message: Section): unknown {
    const obj: any = {};
    if (message.kind !== 0) {
      obj.kind = kindToJSON(message.kind);
    }
    if (message.name !== "") {
      obj.name = message.name;
    }
    if (message.rsdtRows?.length) {
      obj.rsdtRows = message.rsdtRows.map((e) => RsdtRow.toJSON(e));
    }
    if (message.chibanRows?.length) {
      obj.chibanRows = message.chibanRows.map((e) => ChibanRow.toJSON(e));
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<Section>, I>>(base?: I): Section {
    return Section.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<Section>, I>>(object: I): Section {
    const message = createBaseSection();
    message.kind = object.kind ?? 0;
    message.name = object.name ?? "";
    message.rsdtRows = object.rsdtRows?.map((e) => RsdtRow.fromPartial(e)) || [];
    message.chibanRows = object.chibanRows?.map((e) => ChibanRow.fromPartial(e)) || [];
    return message;
  },
};

function createBaseRsdtRow(): RsdtRow {
  return { blkNum: 0, rsdtNum: 0, rsdtNum2: 0, point: undefined, blkNumStr: "", rsdtNumStr: "", rsdtNum2Str: "" };
}

export const RsdtRow: MessageFns<RsdtRow> = {
  encode(message: RsdtRow, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.blkNum !== undefined && message.blkNum !== 0) {
      writer.uint32(8).uint32(message.blkNum);
    }
    if (message.rsdtNum !== 0) {
      writer.uint32(16).uint32(message.rsdtNum);
    }
    if (message.rsdtNum2 !== undefined && message.rsdtNum2 !== 0) {
      writer.uint32(24).uint32(message.rsdtNum2);
    }
    if (message.point !== undefined) {
      LngLatPoint.encode(message.point, writer.uint32(34).fork()).join();
    }
    if (message.blkNumStr !== undefined && message.blkNumStr !== "") {
      writer.uint32(42).string(message.blkNumStr);
    }
    if (message.rsdtNumStr !== undefined && message.rsdtNumStr !== "") {
      writer.uint32(50).string(message.rsdtNumStr);
    }
    if (message.rsdtNum2Str !== undefined && message.rsdtNum2Str !== "") {
      writer.uint32(58).string(message.rsdtNum2Str);
    }
    return writer;
  },

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

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

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

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

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

          message.blkNumStr = reader.string();
          continue;
        case 6:
          if (tag !== 50) {
            break;
          }

          message.rsdtNumStr = reader.string();
          continue;
        case 7:
          if (tag !== 58) {
            break;
          }

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

  fromJSON(object: any): RsdtRow {
    return {
      blkNum: isSet(object.blkNum) ? globalThis.Number(object.blkNum) : 0,
      rsdtNum: isSet(object.rsdtNum) ? globalThis.Number(object.rsdtNum) : 0,
      rsdtNum2: isSet(object.rsdtNum2) ? globalThis.Number(object.rsdtNum2) : 0,
      point: isSet(object.point) ? LngLatPoint.fromJSON(object.point) : undefined,
      blkNumStr: isSet(object.blkNumStr) ? globalThis.String(object.blkNumStr) : "",
      rsdtNumStr: isSet(object.rsdtNumStr) ? globalThis.String(object.rsdtNumStr) : "",
      rsdtNum2Str: isSet(object.rsdtNum2Str) ? globalThis.String(object.rsdtNum2Str) : "",
    };
  },

  toJSON(message: RsdtRow): unknown {
    const obj: any = {};
    if (message.blkNum !== undefined && message.blkNum !== 0) {
      obj.blkNum = Math.round(message.blkNum);
    }
    if (message.rsdtNum !== 0) {
      obj.rsdtNum = Math.round(message.rsdtNum);
    }
    if (message.rsdtNum2 !== undefined && message.rsdtNum2 !== 0) {
      obj.rsdtNum2 = Math.round(message.rsdtNum2);
    }
    if (message.point !== undefined) {
      obj.point = LngLatPoint.toJSON(message.point);
    }
    if (message.blkNumStr !== undefined && message.blkNumStr !== "") {
      obj.blkNumStr = message.blkNumStr;
    }
    if (message.rsdtNumStr !== undefined && message.rsdtNumStr !== "") {
      obj.rsdtNumStr = message.rsdtNumStr;
    }
    if (message.rsdtNum2Str !== undefined && message.rsdtNum2Str !== "") {
      obj.rsdtNum2Str = message.rsdtNum2Str;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<RsdtRow>, I>>(base?: I): RsdtRow {
    return RsdtRow.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<RsdtRow>, I>>(object: I): RsdtRow {
    const message = createBaseRsdtRow();
    message.blkNum = object.blkNum ?? 0;
    message.rsdtNum = object.rsdtNum ?? 0;
    message.rsdtNum2 = object.rsdtNum2 ?? 0;
    message.point = (object.point !== undefined && object.point !== null)
      ? LngLatPoint.fromPartial(object.point)
      : undefined;
    message.blkNumStr = object.blkNumStr ?? "";
    message.rsdtNumStr = object.rsdtNumStr ?? "";
    message.rsdtNum2Str = object.rsdtNum2Str ?? "";
    return message;
  },
};

function createBaseChibanRow(): ChibanRow {
  return { prcNum1: 0, prcNum2: 0, prcNum3: 0, point: undefined, prcNum1Str: "", prcNum2Str: "", prcNum3Str: "" };
}

export const ChibanRow: MessageFns<ChibanRow> = {
  encode(message: ChibanRow, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.prcNum1 !== 0) {
      writer.uint32(8).uint32(message.prcNum1);
    }
    if (message.prcNum2 !== undefined && message.prcNum2 !== 0) {
      writer.uint32(16).uint32(message.prcNum2);
    }
    if (message.prcNum3 !== undefined && message.prcNum3 !== 0) {
      writer.uint32(24).uint32(message.prcNum3);
    }
    if (message.point !== undefined) {
      LngLatPoint.encode(message.point, writer.uint32(34).fork()).join();
    }
    if (message.prcNum1Str !== undefined && message.prcNum1Str !== "") {
      writer.uint32(42).string(message.prcNum1Str);
    }
    if (message.prcNum2Str !== undefined && message.prcNum2Str !== "") {
      writer.uint32(50).string(message.prcNum2Str);
    }
    if (message.prcNum3Str !== undefined && message.prcNum3Str !== "") {
      writer.uint32(58).string(message.prcNum3Str);
    }
    return writer;
  },

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

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

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

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

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

          message.prcNum1Str = reader.string();
          continue;
        case 6:
          if (tag !== 50) {
            break;
          }

          message.prcNum2Str = reader.string();
          continue;
        case 7:
          if (tag !== 58) {
            break;
          }

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

  fromJSON(object: any): ChibanRow {
    return {
      prcNum1: isSet(object.prcNum1) ? globalThis.Number(object.prcNum1) : 0,
      prcNum2: isSet(object.prcNum2) ? globalThis.Number(object.prcNum2) : 0,
      prcNum3: isSet(object.prcNum3) ? globalThis.Number(object.prcNum3) : 0,
      point: isSet(object.point) ? LngLatPoint.fromJSON(object.point) : undefined,
      prcNum1Str: isSet(object.prcNum1Str) ? globalThis.String(object.prcNum1Str) : "",
      prcNum2Str: isSet(object.prcNum2Str) ? globalThis.String(object.prcNum2Str) : "",
      prcNum3Str: isSet(object.prcNum3Str) ? globalThis.String(object.prcNum3Str) : "",
    };
  },

  toJSON(message: ChibanRow): unknown {
    const obj: any = {};
    if (message.prcNum1 !== 0) {
      obj.prcNum1 = Math.round(message.prcNum1);
    }
    if (message.prcNum2 !== undefined && message.prcNum2 !== 0) {
      obj.prcNum2 = Math.round(message.prcNum2);
    }
    if (message.prcNum3 !== undefined && message.prcNum3 !== 0) {
      obj.prcNum3 = Math.round(message.prcNum3);
    }
    if (message.point !== undefined) {
      obj.point = LngLatPoint.toJSON(message.point);
    }
    if (message.prcNum1Str !== undefined && message.prcNum1Str !== "") {
      obj.prcNum1Str = message.prcNum1Str;
    }
    if (message.prcNum2Str !== undefined && message.prcNum2Str !== "") {
      obj.prcNum2Str = message.prcNum2Str;
    }
    if (message.prcNum3Str !== undefined && message.prcNum3Str !== "") {
      obj.prcNum3Str = message.prcNum3Str;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<ChibanRow>, I>>(base?: I): ChibanRow {
    return ChibanRow.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<ChibanRow>, I>>(object: I): ChibanRow {
    const message = createBaseChibanRow();
    message.prcNum1 = object.prcNum1 ?? 0;
    message.prcNum2 = object.prcNum2 ?? 0;
    message.prcNum3 = object.prcNum3 ?? 0;
    message.point = (object.point !== undefined && object.point !== null)
      ? LngLatPoint.fromPartial(object.point)
      : undefined;
    message.prcNum1Str = object.prcNum1Str ?? "";
    message.prcNum2Str = object.prcNum2Str ?? "";
    message.prcNum3Str = object.prcNum3Str ?? "";
    return message;
  },
};

function createBaseLngLatPoint(): LngLatPoint {
  return { lng: 0, lat: 0 };
}

export const LngLatPoint: MessageFns<LngLatPoint> = {
  encode(message: LngLatPoint, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.lng !== 0) {
      writer.uint32(9).double(message.lng);
    }
    if (message.lat !== 0) {
      writer.uint32(17).double(message.lat);
    }
    return writer;
  },

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

          message.lng = reader.double();
          continue;
        case 2:
          if (tag !== 17) {
            break;
          }

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

  fromJSON(object: any): LngLatPoint {
    return {
      lng: isSet(object.lng) ? globalThis.Number(object.lng) : 0,
      lat: isSet(object.lat) ? globalThis.Number(object.lat) : 0,
    };
  },

  toJSON(message: LngLatPoint): unknown {
    const obj: any = {};
    if (message.lng !== 0) {
      obj.lng = message.lng;
    }
    if (message.lat !== 0) {
      obj.lat = message.lat;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<LngLatPoint>, I>>(base?: I): LngLatPoint {
    return LngLatPoint.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<LngLatPoint>, I>>(object: I): LngLatPoint {
    const message = createBaseLngLatPoint();
    message.lng = object.lng ?? 0;
    message.lat = object.lat ?? 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 {} ? { [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;
}

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;
}