@vectora/contracts 1.0.0

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

@@ -0,0 +1,511 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.11.2
+//   protoc               v3.21.12
+// source: mapbox-geocode-v1.proto
+
+/* eslint-disable */
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { ContextItem, Geometry } from "./common-geocode-v1";
+
+export const protobufPackage = "geocode.v1";
+
+export interface ForwardGeocodingRequest {
+  query: string;
+  types: string[];
+  limit?: number | undefined;
+}
+
+export interface ReverseGeocodingRequest {
+  longitude: number;
+  latitude: number;
+  types: string[];
+  limit?: number | undefined;
+}
+
+export interface GeocodingResponse {
+  type: string;
+  query: string[];
+  features: GeocodingFeature[];
+  attribution: string;
+}
+
+export interface GeocodingFeature {
+  id: string;
+  type: string;
+  placeName: string;
+  properties: GeocodingProperties | undefined;
+  geometry: Geometry | undefined;
+  context: ContextItem[];
+}
+
+export interface GeocodingProperties {
+  mapboxId?: string | undefined;
+  wikidata?: string | undefined;
+  address?: string | undefined;
+}
+
+function createBaseForwardGeocodingRequest(): ForwardGeocodingRequest {
+  return { query: "", types: [], limit: undefined };
+}
+
+export const ForwardGeocodingRequest: MessageFns<ForwardGeocodingRequest> = {
+  encode(message: ForwardGeocodingRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.query !== "") {
+      writer.uint32(10).string(message.query);
+    }
+    for (const v of message.types) {
+      writer.uint32(18).string(v!);
+    }
+    if (message.limit !== undefined) {
+      writer.uint32(24).int32(message.limit);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ForwardGeocodingRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseForwardGeocodingRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.query = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.types.push(reader.string());
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+
+          message.limit = reader.int32();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  create<I extends Exact<DeepPartial<ForwardGeocodingRequest>, I>>(base?: I): ForwardGeocodingRequest {
+    return ForwardGeocodingRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<ForwardGeocodingRequest>, I>>(object: I): ForwardGeocodingRequest {
+    const message = createBaseForwardGeocodingRequest();
+    message.query = object.query ?? "";
+    message.types = object.types?.map((e) => e) || [];
+    message.limit = object.limit ?? undefined;
+    return message;
+  },
+};
+
+function createBaseReverseGeocodingRequest(): ReverseGeocodingRequest {
+  return { longitude: 0, latitude: 0, types: [], limit: undefined };
+}
+
+export const ReverseGeocodingRequest: MessageFns<ReverseGeocodingRequest> = {
+  encode(message: ReverseGeocodingRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.longitude !== 0) {
+      writer.uint32(9).double(message.longitude);
+    }
+    if (message.latitude !== 0) {
+      writer.uint32(17).double(message.latitude);
+    }
+    for (const v of message.types) {
+      writer.uint32(26).string(v!);
+    }
+    if (message.limit !== undefined) {
+      writer.uint32(32).int32(message.limit);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ReverseGeocodingRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseReverseGeocodingRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 9) {
+            break;
+          }
+
+          message.longitude = reader.double();
+          continue;
+        }
+        case 2: {
+          if (tag !== 17) {
+            break;
+          }
+
+          message.latitude = reader.double();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.types.push(reader.string());
+          continue;
+        }
+        case 4: {
+          if (tag !== 32) {
+            break;
+          }
+
+          message.limit = reader.int32();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  create<I extends Exact<DeepPartial<ReverseGeocodingRequest>, I>>(base?: I): ReverseGeocodingRequest {
+    return ReverseGeocodingRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<ReverseGeocodingRequest>, I>>(object: I): ReverseGeocodingRequest {
+    const message = createBaseReverseGeocodingRequest();
+    message.longitude = object.longitude ?? 0;
+    message.latitude = object.latitude ?? 0;
+    message.types = object.types?.map((e) => e) || [];
+    message.limit = object.limit ?? undefined;
+    return message;
+  },
+};
+
+function createBaseGeocodingResponse(): GeocodingResponse {
+  return { type: "", query: [], features: [], attribution: "" };
+}
+
+export const GeocodingResponse: MessageFns<GeocodingResponse> = {
+  encode(message: GeocodingResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.type !== "") {
+      writer.uint32(10).string(message.type);
+    }
+    for (const v of message.query) {
+      writer.uint32(18).string(v!);
+    }
+    for (const v of message.features) {
+      GeocodingFeature.encode(v!, writer.uint32(26).fork()).join();
+    }
+    if (message.attribution !== "") {
+      writer.uint32(34).string(message.attribution);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GeocodingResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGeocodingResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.type = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.query.push(reader.string());
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.features.push(GeocodingFeature.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+
+          message.attribution = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  create<I extends Exact<DeepPartial<GeocodingResponse>, I>>(base?: I): GeocodingResponse {
+    return GeocodingResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<GeocodingResponse>, I>>(object: I): GeocodingResponse {
+    const message = createBaseGeocodingResponse();
+    message.type = object.type ?? "";
+    message.query = object.query?.map((e) => e) || [];
+    message.features = object.features?.map((e) => GeocodingFeature.fromPartial(e)) || [];
+    message.attribution = object.attribution ?? "";
+    return message;
+  },
+};
+
+function createBaseGeocodingFeature(): GeocodingFeature {
+  return { id: "", type: "", placeName: "", properties: undefined, geometry: undefined, context: [] };
+}
+
+export const GeocodingFeature: MessageFns<GeocodingFeature> = {
+  encode(message: GeocodingFeature, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.id !== "") {
+      writer.uint32(10).string(message.id);
+    }
+    if (message.type !== "") {
+      writer.uint32(18).string(message.type);
+    }
+    if (message.placeName !== "") {
+      writer.uint32(26).string(message.placeName);
+    }
+    if (message.properties !== undefined) {
+      GeocodingProperties.encode(message.properties, writer.uint32(34).fork()).join();
+    }
+    if (message.geometry !== undefined) {
+      Geometry.encode(message.geometry, writer.uint32(42).fork()).join();
+    }
+    for (const v of message.context) {
+      ContextItem.encode(v!, writer.uint32(50).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GeocodingFeature {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGeocodingFeature();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.id = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.type = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.placeName = reader.string();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+
+          message.properties = GeocodingProperties.decode(reader, reader.uint32());
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+
+          message.geometry = Geometry.decode(reader, reader.uint32());
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+
+          message.context.push(ContextItem.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  create<I extends Exact<DeepPartial<GeocodingFeature>, I>>(base?: I): GeocodingFeature {
+    return GeocodingFeature.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<GeocodingFeature>, I>>(object: I): GeocodingFeature {
+    const message = createBaseGeocodingFeature();
+    message.id = object.id ?? "";
+    message.type = object.type ?? "";
+    message.placeName = object.placeName ?? "";
+    message.properties = (object.properties !== undefined && object.properties !== null)
+      ? GeocodingProperties.fromPartial(object.properties)
+      : undefined;
+    message.geometry = (object.geometry !== undefined && object.geometry !== null)
+      ? Geometry.fromPartial(object.geometry)
+      : undefined;
+    message.context = object.context?.map((e) => ContextItem.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseGeocodingProperties(): GeocodingProperties {
+  return { mapboxId: undefined, wikidata: undefined, address: undefined };
+}
+
+export const GeocodingProperties: MessageFns<GeocodingProperties> = {
+  encode(message: GeocodingProperties, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.mapboxId !== undefined) {
+      writer.uint32(10).string(message.mapboxId);
+    }
+    if (message.wikidata !== undefined) {
+      writer.uint32(18).string(message.wikidata);
+    }
+    if (message.address !== undefined) {
+      writer.uint32(26).string(message.address);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GeocodingProperties {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGeocodingProperties();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.mapboxId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.wikidata = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.address = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  create<I extends Exact<DeepPartial<GeocodingProperties>, I>>(base?: I): GeocodingProperties {
+    return GeocodingProperties.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<GeocodingProperties>, I>>(object: I): GeocodingProperties {
+    const message = createBaseGeocodingProperties();
+    message.mapboxId = object.mapboxId ?? undefined;
+    message.wikidata = object.wikidata ?? undefined;
+    message.address = object.address ?? undefined;
+    return message;
+  },
+};
+
+export interface GeocodingService {
+  ForwardGeocoding(request: ForwardGeocodingRequest): Promise<GeocodingResponse>;
+  ReverseGeocoding(request: ReverseGeocodingRequest): Promise<GeocodingResponse>;
+}
+
+export const GeocodingServiceServiceName = "geocode.v1.GeocodingService";
+export class GeocodingServiceClientImpl implements GeocodingService {
+  private readonly rpc: Rpc;
+  private readonly service: string;
+  constructor(rpc: Rpc, opts?: { service?: string }) {
+    this.service = opts?.service || GeocodingServiceServiceName;
+    this.rpc = rpc;
+    this.ForwardGeocoding = this.ForwardGeocoding.bind(this);
+    this.ReverseGeocoding = this.ReverseGeocoding.bind(this);
+  }
+  ForwardGeocoding(request: ForwardGeocodingRequest): Promise<GeocodingResponse> {
+    const data = ForwardGeocodingRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "ForwardGeocoding", data);
+    return promise.then((data) => GeocodingResponse.decode(new BinaryReader(data)));
+  }
+
+  ReverseGeocoding(request: ReverseGeocodingRequest): Promise<GeocodingResponse> {
+    const data = ReverseGeocodingRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "ReverseGeocoding", data);
+    return promise.then((data) => GeocodingResponse.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;
+}