@vectora/contracts 1.0.0

package/gen/ts/mapbox-matrix-v1.ts

@@ -0,0 +1,369 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.11.2
+//   protoc               v3.21.12
+// source: mapbox-matrix-v1.proto
+
+/* eslint-disable */
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { Point } from "./common-geocode-v1";
+
+export const protobufPackage = "matrix.v1";
+
+export interface MatrixRequest {
+  coordinates: Point[];
+  profile: string;
+  annotations: string[];
+}
+
+export interface MatrixResponse {
+  code: string;
+  durations: MatrixRow[];
+  distances: MatrixRow[];
+  destinations: MatrixWaypoint[];
+  sources: MatrixWaypoint[];
+}
+
+export interface MatrixRow {
+  values: number[];
+}
+
+export interface MatrixWaypoint {
+  name: string;
+  location: number[];
+}
+
+function createBaseMatrixRequest(): MatrixRequest {
+  return { coordinates: [], profile: "", annotations: [] };
+}
+
+export const MatrixRequest: MessageFns<MatrixRequest> = {
+  encode(message: MatrixRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.coordinates) {
+      Point.encode(v!, writer.uint32(10).fork()).join();
+    }
+    if (message.profile !== "") {
+      writer.uint32(18).string(message.profile);
+    }
+    for (const v of message.annotations) {
+      writer.uint32(26).string(v!);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): MatrixRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMatrixRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.coordinates.push(Point.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.profile = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.annotations.push(reader.string());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  create<I extends Exact<DeepPartial<MatrixRequest>, I>>(base?: I): MatrixRequest {
+    return MatrixRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MatrixRequest>, I>>(object: I): MatrixRequest {
+    const message = createBaseMatrixRequest();
+    message.coordinates = object.coordinates?.map((e) => Point.fromPartial(e)) || [];
+    message.profile = object.profile ?? "";
+    message.annotations = object.annotations?.map((e) => e) || [];
+    return message;
+  },
+};
+
+function createBaseMatrixResponse(): MatrixResponse {
+  return { code: "", durations: [], distances: [], destinations: [], sources: [] };
+}
+
+export const MatrixResponse: MessageFns<MatrixResponse> = {
+  encode(message: MatrixResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.code !== "") {
+      writer.uint32(10).string(message.code);
+    }
+    for (const v of message.durations) {
+      MatrixRow.encode(v!, writer.uint32(18).fork()).join();
+    }
+    for (const v of message.distances) {
+      MatrixRow.encode(v!, writer.uint32(26).fork()).join();
+    }
+    for (const v of message.destinations) {
+      MatrixWaypoint.encode(v!, writer.uint32(34).fork()).join();
+    }
+    for (const v of message.sources) {
+      MatrixWaypoint.encode(v!, writer.uint32(42).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): MatrixResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMatrixResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.code = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.durations.push(MatrixRow.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.distances.push(MatrixRow.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+
+          message.destinations.push(MatrixWaypoint.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+
+          message.sources.push(MatrixWaypoint.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  create<I extends Exact<DeepPartial<MatrixResponse>, I>>(base?: I): MatrixResponse {
+    return MatrixResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MatrixResponse>, I>>(object: I): MatrixResponse {
+    const message = createBaseMatrixResponse();
+    message.code = object.code ?? "";
+    message.durations = object.durations?.map((e) => MatrixRow.fromPartial(e)) || [];
+    message.distances = object.distances?.map((e) => MatrixRow.fromPartial(e)) || [];
+    message.destinations = object.destinations?.map((e) => MatrixWaypoint.fromPartial(e)) || [];
+    message.sources = object.sources?.map((e) => MatrixWaypoint.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseMatrixRow(): MatrixRow {
+  return { values: [] };
+}
+
+export const MatrixRow: MessageFns<MatrixRow> = {
+  encode(message: MatrixRow, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    writer.uint32(10).fork();
+    for (const v of message.values) {
+      writer.double(v);
+    }
+    writer.join();
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): MatrixRow {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMatrixRow();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag === 9) {
+            message.values.push(reader.double());
+
+            continue;
+          }
+
+          if (tag === 10) {
+            const end2 = reader.uint32() + reader.pos;
+            while (reader.pos < end2) {
+              message.values.push(reader.double());
+            }
+
+            continue;
+          }
+
+          break;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  create<I extends Exact<DeepPartial<MatrixRow>, I>>(base?: I): MatrixRow {
+    return MatrixRow.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MatrixRow>, I>>(object: I): MatrixRow {
+    const message = createBaseMatrixRow();
+    message.values = object.values?.map((e) => e) || [];
+    return message;
+  },
+};
+
+function createBaseMatrixWaypoint(): MatrixWaypoint {
+  return { name: "", location: [] };
+}
+
+export const MatrixWaypoint: MessageFns<MatrixWaypoint> = {
+  encode(message: MatrixWaypoint, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.name !== "") {
+      writer.uint32(10).string(message.name);
+    }
+    writer.uint32(18).fork();
+    for (const v of message.location) {
+      writer.double(v);
+    }
+    writer.join();
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): MatrixWaypoint {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMatrixWaypoint();
+    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 === 17) {
+            message.location.push(reader.double());
+
+            continue;
+          }
+
+          if (tag === 18) {
+            const end2 = reader.uint32() + reader.pos;
+            while (reader.pos < end2) {
+              message.location.push(reader.double());
+            }
+
+            continue;
+          }
+
+          break;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  create<I extends Exact<DeepPartial<MatrixWaypoint>, I>>(base?: I): MatrixWaypoint {
+    return MatrixWaypoint.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MatrixWaypoint>, I>>(object: I): MatrixWaypoint {
+    const message = createBaseMatrixWaypoint();
+    message.name = object.name ?? "";
+    message.location = object.location?.map((e) => e) || [];
+    return message;
+  },
+};
+
+export interface MatrixService {
+  GetMatrix(request: MatrixRequest): Promise<MatrixResponse>;
+}
+
+export const MatrixServiceServiceName = "matrix.v1.MatrixService";
+export class MatrixServiceClientImpl implements MatrixService {
+  private readonly rpc: Rpc;
+  private readonly service: string;
+  constructor(rpc: Rpc, opts?: { service?: string }) {
+    this.service = opts?.service || MatrixServiceServiceName;
+    this.rpc = rpc;
+    this.GetMatrix = this.GetMatrix.bind(this);
+  }
+  GetMatrix(request: MatrixRequest): Promise<MatrixResponse> {
+    const data = MatrixRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "GetMatrix", data);
+    return promise.then((data) => MatrixResponse.decode(new BinaryReader(data)));
+  }
+}
+
+interface Rpc {
+  request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
+}
+
+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 };
+
+export interface MessageFns<T> {
+  encode(message: T, writer?: BinaryWriter): BinaryWriter;
+  decode(input: BinaryReader | Uint8Array, length?: number): T;
+  create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+  fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}