@vectora/contracts 1.0.0

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

@@ -0,0 +1,472 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.11.2
+//   protoc               v3.21.12
+// source: mapbox-optimization-v1.proto
+
+/* eslint-disable */
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { LineString, Point } from "./common-geocode-v1";
+import { RouteLeg } from "./mapbox-direction-v1";
+
+export const protobufPackage = "optimization.v1";
+
+export interface OptimizationRequest {
+  coordinates: Point[];
+  profile: string;
+  roundtrip?: boolean | undefined;
+  source?: string | undefined;
+  destination?: string | undefined;
+  geometries?: string | undefined;
+  steps?: boolean | undefined;
+}
+
+export interface OptimizationResponse {
+  code: string;
+  waypoints: OptimizationWaypoint[];
+  trips: OptimizationTrip[];
+}
+
+export interface OptimizationTrip {
+  geometry: LineString | undefined;
+  legs: RouteLeg[];
+  distance: number;
+  duration: number;
+  weight: number;
+}
+
+export interface OptimizationWaypoint {
+  name: string;
+  location: number[];
+  waypointIndex: number;
+  tripsIndex: number;
+}
+
+function createBaseOptimizationRequest(): OptimizationRequest {
+  return {
+    coordinates: [],
+    profile: "",
+    roundtrip: undefined,
+    source: undefined,
+    destination: undefined,
+    geometries: undefined,
+    steps: undefined,
+  };
+}
+
+export const OptimizationRequest: MessageFns<OptimizationRequest> = {
+  encode(message: OptimizationRequest, 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);
+    }
+    if (message.roundtrip !== undefined) {
+      writer.uint32(24).bool(message.roundtrip);
+    }
+    if (message.source !== undefined) {
+      writer.uint32(34).string(message.source);
+    }
+    if (message.destination !== undefined) {
+      writer.uint32(42).string(message.destination);
+    }
+    if (message.geometries !== undefined) {
+      writer.uint32(50).string(message.geometries);
+    }
+    if (message.steps !== undefined) {
+      writer.uint32(56).bool(message.steps);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): OptimizationRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseOptimizationRequest();
+    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 !== 24) {
+            break;
+          }
+
+          message.roundtrip = reader.bool();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+
+          message.source = reader.string();
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+
+          message.destination = reader.string();
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+
+          message.geometries = reader.string();
+          continue;
+        }
+        case 7: {
+          if (tag !== 56) {
+            break;
+          }
+
+          message.steps = reader.bool();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  create<I extends Exact<DeepPartial<OptimizationRequest>, I>>(base?: I): OptimizationRequest {
+    return OptimizationRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<OptimizationRequest>, I>>(object: I): OptimizationRequest {
+    const message = createBaseOptimizationRequest();
+    message.coordinates = object.coordinates?.map((e) => Point.fromPartial(e)) || [];
+    message.profile = object.profile ?? "";
+    message.roundtrip = object.roundtrip ?? undefined;
+    message.source = object.source ?? undefined;
+    message.destination = object.destination ?? undefined;
+    message.geometries = object.geometries ?? undefined;
+    message.steps = object.steps ?? undefined;
+    return message;
+  },
+};
+
+function createBaseOptimizationResponse(): OptimizationResponse {
+  return { code: "", waypoints: [], trips: [] };
+}
+
+export const OptimizationResponse: MessageFns<OptimizationResponse> = {
+  encode(message: OptimizationResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.code !== "") {
+      writer.uint32(10).string(message.code);
+    }
+    for (const v of message.waypoints) {
+      OptimizationWaypoint.encode(v!, writer.uint32(18).fork()).join();
+    }
+    for (const v of message.trips) {
+      OptimizationTrip.encode(v!, writer.uint32(26).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): OptimizationResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseOptimizationResponse();
+    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.waypoints.push(OptimizationWaypoint.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.trips.push(OptimizationTrip.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  create<I extends Exact<DeepPartial<OptimizationResponse>, I>>(base?: I): OptimizationResponse {
+    return OptimizationResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<OptimizationResponse>, I>>(object: I): OptimizationResponse {
+    const message = createBaseOptimizationResponse();
+    message.code = object.code ?? "";
+    message.waypoints = object.waypoints?.map((e) => OptimizationWaypoint.fromPartial(e)) || [];
+    message.trips = object.trips?.map((e) => OptimizationTrip.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseOptimizationTrip(): OptimizationTrip {
+  return { geometry: undefined, legs: [], distance: 0, duration: 0, weight: 0 };
+}
+
+export const OptimizationTrip: MessageFns<OptimizationTrip> = {
+  encode(message: OptimizationTrip, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.geometry !== undefined) {
+      LineString.encode(message.geometry, writer.uint32(10).fork()).join();
+    }
+    for (const v of message.legs) {
+      RouteLeg.encode(v!, writer.uint32(18).fork()).join();
+    }
+    if (message.distance !== 0) {
+      writer.uint32(25).double(message.distance);
+    }
+    if (message.duration !== 0) {
+      writer.uint32(33).double(message.duration);
+    }
+    if (message.weight !== 0) {
+      writer.uint32(41).double(message.weight);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): OptimizationTrip {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseOptimizationTrip();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.geometry = LineString.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.legs.push(RouteLeg.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 3: {
+          if (tag !== 25) {
+            break;
+          }
+
+          message.distance = reader.double();
+          continue;
+        }
+        case 4: {
+          if (tag !== 33) {
+            break;
+          }
+
+          message.duration = reader.double();
+          continue;
+        }
+        case 5: {
+          if (tag !== 41) {
+            break;
+          }
+
+          message.weight = reader.double();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  create<I extends Exact<DeepPartial<OptimizationTrip>, I>>(base?: I): OptimizationTrip {
+    return OptimizationTrip.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<OptimizationTrip>, I>>(object: I): OptimizationTrip {
+    const message = createBaseOptimizationTrip();
+    message.geometry = (object.geometry !== undefined && object.geometry !== null)
+      ? LineString.fromPartial(object.geometry)
+      : undefined;
+    message.legs = object.legs?.map((e) => RouteLeg.fromPartial(e)) || [];
+    message.distance = object.distance ?? 0;
+    message.duration = object.duration ?? 0;
+    message.weight = object.weight ?? 0;
+    return message;
+  },
+};
+
+function createBaseOptimizationWaypoint(): OptimizationWaypoint {
+  return { name: "", location: [], waypointIndex: 0, tripsIndex: 0 };
+}
+
+export const OptimizationWaypoint: MessageFns<OptimizationWaypoint> = {
+  encode(message: OptimizationWaypoint, 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();
+    if (message.waypointIndex !== 0) {
+      writer.uint32(24).int32(message.waypointIndex);
+    }
+    if (message.tripsIndex !== 0) {
+      writer.uint32(32).int32(message.tripsIndex);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): OptimizationWaypoint {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseOptimizationWaypoint();
+    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;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+
+          message.waypointIndex = reader.int32();
+          continue;
+        }
+        case 4: {
+          if (tag !== 32) {
+            break;
+          }
+
+          message.tripsIndex = reader.int32();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  create<I extends Exact<DeepPartial<OptimizationWaypoint>, I>>(base?: I): OptimizationWaypoint {
+    return OptimizationWaypoint.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<OptimizationWaypoint>, I>>(object: I): OptimizationWaypoint {
+    const message = createBaseOptimizationWaypoint();
+    message.name = object.name ?? "";
+    message.location = object.location?.map((e) => e) || [];
+    message.waypointIndex = object.waypointIndex ?? 0;
+    message.tripsIndex = object.tripsIndex ?? 0;
+    return message;
+  },
+};
+
+export interface OptimizationService {
+  GetOptimizedRoute(request: OptimizationRequest): Promise<OptimizationResponse>;
+}
+
+export const OptimizationServiceServiceName = "optimization.v1.OptimizationService";
+export class OptimizationServiceClientImpl implements OptimizationService {
+  private readonly rpc: Rpc;
+  private readonly service: string;
+  constructor(rpc: Rpc, opts?: { service?: string }) {
+    this.service = opts?.service || OptimizationServiceServiceName;
+    this.rpc = rpc;
+    this.GetOptimizedRoute = this.GetOptimizedRoute.bind(this);
+  }
+  GetOptimizedRoute(request: OptimizationRequest): Promise<OptimizationResponse> {
+    const data = OptimizationRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "GetOptimizedRoute", data);
+    return promise.then((data) => OptimizationResponse.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;
+}