@tomtom-org/maps-sdk 0.29.0

package/services/dist/services.cjs.js

@@ -0,0 +1,5009 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const core = require("@tomtom-org/maps-sdk/core");
+var APICode = /* @__PURE__ */ ((APICode2) => {
+  APICode2[APICode2["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
+  APICode2[APICode2["FORBIDDEN"] = 403] = "FORBIDDEN";
+  return APICode2;
+})(APICode || {});
+class SDKError extends Error {
+  /**
+   * Creates a new SDKError instance.
+   *
+   * @param message - Human-readable error description
+   * @param service - Name of the service where the error occurred
+   * @param issues - Optional array of Zod validation issues for detailed error information
+   */
+  constructor(message, service, issues) {
+    super(message);
+    this.service = service;
+    this.issues = issues;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, SDKError);
+    }
+  }
+}
+const APIErrorCode = {
+  [APICode.TOO_MANY_REQUESTS]: "Too Many Requests: The API Key is over QPS (Queries per second)",
+  [APICode.FORBIDDEN]: "Request failed with status code 403"
+};
+class SDKServiceError extends SDKError {
+  /**
+   * Creates a new SDKServiceError instance.
+   *
+   * If the status code matches a known error in {@link APIErrorCode},
+   * the message will be automatically replaced with the standardized message.
+   *
+   * @param message - Error message from the API or custom message
+   * @param service - Name of the service that generated the error
+   * @param status - HTTP status code of the failed request
+   */
+  constructor(message, service, status) {
+    super(message, service);
+    this.status = status;
+    if (this.status && APIErrorCode[this.status]) {
+      this.message = APIErrorCode[this.status];
+    }
+  }
+}
+const parseDefaultResponseError = (error, serviceName) => {
+  const { data, message, status } = error;
+  const errorMessage = data?.error || data?.errorText || message;
+  return new SDKServiceError(errorMessage, serviceName, status);
+};
+const buildResponseError = (error, serviceName, parseResponseError) => {
+  if (error.status) {
+    const fetchError = error;
+    if (parseResponseError) {
+      return parseResponseError(fetchError, serviceName);
+    }
+    return parseDefaultResponseError(fetchError, serviceName);
+  }
+  return new SDKError(error.message, serviceName);
+};
+const buildValidationError = (error, serviceName) => new SDKError(error.message, serviceName, error.issues);
+function $constructor(name, initializer2, params) {
+  function init(inst, def) {
+    var _a;
+    Object.defineProperty(inst, "_zod", {
+      value: inst._zod ?? {},
+      enumerable: false
+    });
+    (_a = inst._zod).traits ?? (_a.traits = /* @__PURE__ */ new Set());
+    inst._zod.traits.add(name);
+    initializer2(inst, def);
+    for (const k in _.prototype) {
+      if (!(k in inst))
+        Object.defineProperty(inst, k, { value: _.prototype[k].bind(inst) });
+    }
+    inst._zod.constr = _;
+    inst._zod.def = def;
+  }
+  const Parent = params?.Parent ?? Object;
+  class Definition extends Parent {
+  }
+  Object.defineProperty(Definition, "name", { value: name });
+  function _(def) {
+    var _a;
+    const inst = params?.Parent ? new Definition() : this;
+    init(inst, def);
+    (_a = inst._zod).deferred ?? (_a.deferred = []);
+    for (const fn of inst._zod.deferred) {
+      fn();
+    }
+    return inst;
+  }
+  Object.defineProperty(_, "init", { value: init });
+  Object.defineProperty(_, Symbol.hasInstance, {
+    value: (inst) => {
+      if (params?.Parent && inst instanceof params.Parent)
+        return true;
+      return inst?._zod?.traits?.has(name);
+    }
+  });
+  Object.defineProperty(_, "name", { value: name });
+  return _;
+}
+class $ZodAsyncError extends Error {
+  constructor() {
+    super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
+  }
+}
+const globalConfig = {};
+function config(newConfig) {
+  return globalConfig;
+}
+function getEnumValues(entries) {
+  const numericValues = Object.values(entries).filter((v) => typeof v === "number");
+  const values = Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
+  return values;
+}
+function jsonStringifyReplacer(_, value) {
+  if (typeof value === "bigint")
+    return value.toString();
+  return value;
+}
+function cached(getter) {
+  return {
+    get value() {
+      {
+        const value = getter();
+        Object.defineProperty(this, "value", { value });
+        return value;
+      }
+    }
+  };
+}
+function nullish(input) {
+  return input === null || input === void 0;
+}
+function cleanRegex(source) {
+  const start = source.startsWith("^") ? 1 : 0;
+  const end = source.endsWith("$") ? source.length - 1 : source.length;
+  return source.slice(start, end);
+}
+const EVALUATING = Symbol("evaluating");
+function defineLazy(object2, key, getter) {
+  let value = void 0;
+  Object.defineProperty(object2, key, {
+    get() {
+      if (value === EVALUATING) {
+        return void 0;
+      }
+      if (value === void 0) {
+        value = EVALUATING;
+        value = getter();
+      }
+      return value;
+    },
+    set(v) {
+      Object.defineProperty(object2, key, {
+        value: v
+        // configurable: true,
+      });
+    },
+    configurable: true
+  });
+}
+function assignProp(target, prop, value) {
+  Object.defineProperty(target, prop, {
+    value,
+    writable: true,
+    enumerable: true,
+    configurable: true
+  });
+}
+function mergeDefs(...defs) {
+  const mergedDescriptors = {};
+  for (const def of defs) {
+    const descriptors = Object.getOwnPropertyDescriptors(def);
+    Object.assign(mergedDescriptors, descriptors);
+  }
+  return Object.defineProperties({}, mergedDescriptors);
+}
+const captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => {
+};
+function isObject$1(data) {
+  return typeof data === "object" && data !== null && !Array.isArray(data);
+}
+function isPlainObject$1(o) {
+  if (isObject$1(o) === false)
+    return false;
+  const ctor = o.constructor;
+  if (ctor === void 0)
+    return true;
+  const prot = ctor.prototype;
+  if (isObject$1(prot) === false)
+    return false;
+  if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) {
+    return false;
+  }
+  return true;
+}
+const propertyKeyTypes = /* @__PURE__ */ new Set(["string", "number", "symbol"]);
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function clone(inst, def, params) {
+  const cl = new inst._zod.constr(def ?? inst._zod.def);
+  if (!def || params?.parent)
+    cl._zod.parent = inst;
+  return cl;
+}
+function normalizeParams(_params) {
+  const params = _params;
+  if (!params)
+    return {};
+  if (typeof params === "string")
+    return { error: () => params };
+  if (params?.message !== void 0) {
+    if (params?.error !== void 0)
+      throw new Error("Cannot specify both `message` and `error` params");
+    params.error = params.message;
+  }
+  delete params.message;
+  if (typeof params.error === "string")
+    return { ...params, error: () => params.error };
+  return params;
+}
+function optionalKeys(shape) {
+  return Object.keys(shape).filter((k) => {
+    return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional";
+  });
+}
+function extend$1(schema, shape) {
+  if (!isPlainObject$1(shape)) {
+    throw new Error("Invalid input to extend: expected a plain object");
+  }
+  const checks = schema._zod.def.checks;
+  const hasChecks = checks && checks.length > 0;
+  if (hasChecks) {
+    throw new Error("Object schemas containing refinements cannot be extended. Use `.safeExtend()` instead.");
+  }
+  const def = mergeDefs(schema._zod.def, {
+    get shape() {
+      const _shape = { ...schema._zod.def.shape, ...shape };
+      assignProp(this, "shape", _shape);
+      return _shape;
+    },
+    checks: []
+  });
+  return clone(schema, def);
+}
+function partial$1(Class, schema, mask) {
+  const def = mergeDefs(schema._zod.def, {
+    get shape() {
+      const oldShape = schema._zod.def.shape;
+      const shape = { ...oldShape };
+      {
+        for (const key in oldShape) {
+          shape[key] = Class ? new Class({
+            type: "optional",
+            innerType: oldShape[key]
+          }) : oldShape[key];
+        }
+      }
+      assignProp(this, "shape", shape);
+      return shape;
+    },
+    checks: []
+  });
+  return clone(schema, def);
+}
+function aborted(x, startIndex = 0) {
+  if (x.aborted === true)
+    return true;
+  for (let i = startIndex; i < x.issues.length; i++) {
+    if (x.issues[i]?.continue !== true) {
+      return true;
+    }
+  }
+  return false;
+}
+function prefixIssues(path, issues) {
+  return issues.map((iss) => {
+    var _a;
+    (_a = iss).path ?? (_a.path = []);
+    iss.path.unshift(path);
+    return iss;
+  });
+}
+function unwrapMessage(message) {
+  return typeof message === "string" ? message : message?.message;
+}
+function finalizeIssue(iss, ctx, config2) {
+  const full = { ...iss, path: iss.path ?? [] };
+  if (!iss.message) {
+    const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config2.customError?.(iss)) ?? unwrapMessage(config2.localeError?.(iss)) ?? "Invalid input";
+    full.message = message;
+  }
+  delete full.inst;
+  delete full.continue;
+  if (!ctx?.reportInput) {
+    delete full.input;
+  }
+  return full;
+}
+function getLengthableOrigin(input) {
+  if (Array.isArray(input))
+    return "array";
+  if (typeof input === "string")
+    return "string";
+  return "unknown";
+}
+function issue(...args) {
+  const [iss, input, inst] = args;
+  if (typeof iss === "string") {
+    return {
+      message: iss,
+      code: "custom",
+      input,
+      inst
+    };
+  }
+  return { ...iss };
+}
+const initializer = (inst, def) => {
+  inst.name = "$ZodError";
+  Object.defineProperty(inst, "_zod", {
+    value: inst._zod,
+    enumerable: false
+  });
+  Object.defineProperty(inst, "issues", {
+    value: def,
+    enumerable: false
+  });
+  inst.message = JSON.stringify(def, jsonStringifyReplacer, 2);
+  Object.defineProperty(inst, "toString", {
+    value: () => inst.message,
+    enumerable: false
+  });
+};
+const $ZodError = $constructor("$ZodError", initializer);
+const $ZodRealError = $constructor("$ZodError", initializer, { Parent: Error });
+function toDotPath(_path) {
+  const segs = [];
+  const path = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path) {
+    if (typeof seg === "number")
+      segs.push(`[${seg}]`);
+    else if (typeof seg === "symbol")
+      segs.push(`[${JSON.stringify(String(seg))}]`);
+    else if (/[^\w$]/.test(seg))
+      segs.push(`[${JSON.stringify(seg)}]`);
+    else {
+      if (segs.length)
+        segs.push(".");
+      segs.push(seg);
+    }
+  }
+  return segs.join("");
+}
+function prettifyError(error) {
+  const lines = [];
+  const issues = [...error.issues].sort((a, b) => (a.path ?? []).length - (b.path ?? []).length);
+  for (const issue2 of issues) {
+    lines.push(`✖ ${issue2.message}`);
+    if (issue2.path?.length)
+      lines.push(`  → at ${toDotPath(issue2.path)}`);
+  }
+  return lines.join("\n");
+}
+const _parse = (_Err) => (schema, value, _ctx, _params) => {
+  const ctx = _ctx ? Object.assign(_ctx, { async: false }) : { async: false };
+  const result = schema._zod.run({ value, issues: [] }, ctx);
+  if (result instanceof Promise) {
+    throw new $ZodAsyncError();
+  }
+  if (result.issues.length) {
+    const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
+    captureStackTrace(e, _params?.callee);
+    throw e;
+  }
+  return result.value;
+};
+const parse = /* @__PURE__ */ _parse($ZodRealError);
+const _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
+  const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
+  let result = schema._zod.run({ value, issues: [] }, ctx);
+  if (result instanceof Promise)
+    result = await result;
+  if (result.issues.length) {
+    const e = new (params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
+    captureStackTrace(e, params?.callee);
+    throw e;
+  }
+  return result.value;
+};
+const parseAsync = /* @__PURE__ */ _parseAsync($ZodRealError);
+const _safeParse = (_Err) => (schema, value, _ctx) => {
+  const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
+  const result = schema._zod.run({ value, issues: [] }, ctx);
+  if (result instanceof Promise) {
+    throw new $ZodAsyncError();
+  }
+  return result.issues.length ? {
+    success: false,
+    error: new (_Err ?? $ZodError)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+  } : { success: true, data: result.value };
+};
+const safeParse = /* @__PURE__ */ _safeParse($ZodRealError);
+const _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
+  const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
+  let result = schema._zod.run({ value, issues: [] }, ctx);
+  if (result instanceof Promise)
+    result = await result;
+  return result.issues.length ? {
+    success: false,
+    error: new _Err(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+  } : { success: true, data: result.value };
+};
+const safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);
+const string$1 = (params) => {
+  const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
+  return new RegExp(`^${regex}$`);
+};
+const number$1 = /^-?\d+(?:\.\d+)?/;
+const boolean$1 = /^(?:true|false)$/i;
+const _undefined$2 = /^undefined$/i;
+const $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => {
+  var _a;
+  inst._zod ?? (inst._zod = {});
+  inst._zod.def = def;
+  (_a = inst._zod).onattach ?? (_a.onattach = []);
+});
+const numericOriginMap = {
+  number: "number",
+  bigint: "bigint",
+  object: "date"
+};
+const $ZodCheckLessThan = /* @__PURE__ */ $constructor("$ZodCheckLessThan", (inst, def) => {
+  $ZodCheck.init(inst, def);
+  const origin = numericOriginMap[typeof def.value];
+  inst._zod.onattach.push((inst2) => {
+    const bag = inst2._zod.bag;
+    const curr = (def.inclusive ? bag.maximum : bag.exclusiveMaximum) ?? Number.POSITIVE_INFINITY;
+    if (def.value < curr) {
+      if (def.inclusive)
+        bag.maximum = def.value;
+      else
+        bag.exclusiveMaximum = def.value;
+    }
+  });
+  inst._zod.check = (payload) => {
+    if (def.inclusive ? payload.value <= def.value : payload.value < def.value) {
+      return;
+    }
+    payload.issues.push({
+      origin,
+      code: "too_big",
+      maximum: def.value,
+      input: payload.value,
+      inclusive: def.inclusive,
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+const $ZodCheckGreaterThan = /* @__PURE__ */ $constructor("$ZodCheckGreaterThan", (inst, def) => {
+  $ZodCheck.init(inst, def);
+  const origin = numericOriginMap[typeof def.value];
+  inst._zod.onattach.push((inst2) => {
+    const bag = inst2._zod.bag;
+    const curr = (def.inclusive ? bag.minimum : bag.exclusiveMinimum) ?? Number.NEGATIVE_INFINITY;
+    if (def.value > curr) {
+      if (def.inclusive)
+        bag.minimum = def.value;
+      else
+        bag.exclusiveMinimum = def.value;
+    }
+  });
+  inst._zod.check = (payload) => {
+    if (def.inclusive ? payload.value >= def.value : payload.value > def.value) {
+      return;
+    }
+    payload.issues.push({
+      origin,
+      code: "too_small",
+      minimum: def.value,
+      input: payload.value,
+      inclusive: def.inclusive,
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+const $ZodCheckMaxLength = /* @__PURE__ */ $constructor("$ZodCheckMaxLength", (inst, def) => {
+  var _a;
+  $ZodCheck.init(inst, def);
+  (_a = inst._zod.def).when ?? (_a.when = (payload) => {
+    const val = payload.value;
+    return !nullish(val) && val.length !== void 0;
+  });
+  inst._zod.onattach.push((inst2) => {
+    const curr = inst2._zod.bag.maximum ?? Number.POSITIVE_INFINITY;
+    if (def.maximum < curr)
+      inst2._zod.bag.maximum = def.maximum;
+  });
+  inst._zod.check = (payload) => {
+    const input = payload.value;
+    const length = input.length;
+    if (length <= def.maximum)
+      return;
+    const origin = getLengthableOrigin(input);
+    payload.issues.push({
+      origin,
+      code: "too_big",
+      maximum: def.maximum,
+      inclusive: true,
+      input,
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+const $ZodCheckMinLength = /* @__PURE__ */ $constructor("$ZodCheckMinLength", (inst, def) => {
+  var _a;
+  $ZodCheck.init(inst, def);
+  (_a = inst._zod.def).when ?? (_a.when = (payload) => {
+    const val = payload.value;
+    return !nullish(val) && val.length !== void 0;
+  });
+  inst._zod.onattach.push((inst2) => {
+    const curr = inst2._zod.bag.minimum ?? Number.NEGATIVE_INFINITY;
+    if (def.minimum > curr)
+      inst2._zod.bag.minimum = def.minimum;
+  });
+  inst._zod.check = (payload) => {
+    const input = payload.value;
+    const length = input.length;
+    if (length >= def.minimum)
+      return;
+    const origin = getLengthableOrigin(input);
+    payload.issues.push({
+      origin,
+      code: "too_small",
+      minimum: def.minimum,
+      inclusive: true,
+      input,
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+const $ZodCheckLengthEquals = /* @__PURE__ */ $constructor("$ZodCheckLengthEquals", (inst, def) => {
+  var _a;
+  $ZodCheck.init(inst, def);
+  (_a = inst._zod.def).when ?? (_a.when = (payload) => {
+    const val = payload.value;
+    return !nullish(val) && val.length !== void 0;
+  });
+  inst._zod.onattach.push((inst2) => {
+    const bag = inst2._zod.bag;
+    bag.minimum = def.length;
+    bag.maximum = def.length;
+    bag.length = def.length;
+  });
+  inst._zod.check = (payload) => {
+    const input = payload.value;
+    const length = input.length;
+    if (length === def.length)
+      return;
+    const origin = getLengthableOrigin(input);
+    const tooBig = length > def.length;
+    payload.issues.push({
+      origin,
+      ...tooBig ? { code: "too_big", maximum: def.length } : { code: "too_small", minimum: def.length },
+      inclusive: true,
+      exact: true,
+      input: payload.value,
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+const version = {
+  major: 4,
+  minor: 1,
+  patch: 12
+};
+const $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
+  var _a;
+  inst ?? (inst = {});
+  inst._zod.def = def;
+  inst._zod.bag = inst._zod.bag || {};
+  inst._zod.version = version;
+  const checks = [...inst._zod.def.checks ?? []];
+  if (inst._zod.traits.has("$ZodCheck")) {
+    checks.unshift(inst);
+  }
+  for (const ch of checks) {
+    for (const fn of ch._zod.onattach) {
+      fn(inst);
+    }
+  }
+  if (checks.length === 0) {
+    (_a = inst._zod).deferred ?? (_a.deferred = []);
+    inst._zod.deferred?.push(() => {
+      inst._zod.run = inst._zod.parse;
+    });
+  } else {
+    const runChecks = (payload, checks2, ctx) => {
+      let isAborted = aborted(payload);
+      let asyncResult;
+      for (const ch of checks2) {
+        if (ch._zod.def.when) {
+          const shouldRun = ch._zod.def.when(payload);
+          if (!shouldRun)
+            continue;
+        } else if (isAborted) {
+          continue;
+        }
+        const currLen = payload.issues.length;
+        const _ = ch._zod.check(payload);
+        if (_ instanceof Promise && ctx?.async === false) {
+          throw new $ZodAsyncError();
+        }
+        if (asyncResult || _ instanceof Promise) {
+          asyncResult = (asyncResult ?? Promise.resolve()).then(async () => {
+            await _;
+            const nextLen = payload.issues.length;
+            if (nextLen === currLen)
+              return;
+            if (!isAborted)
+              isAborted = aborted(payload, currLen);
+          });
+        } else {
+          const nextLen = payload.issues.length;
+          if (nextLen === currLen)
+            continue;
+          if (!isAborted)
+            isAborted = aborted(payload, currLen);
+        }
+      }
+      if (asyncResult) {
+        return asyncResult.then(() => {
+          return payload;
+        });
+      }
+      return payload;
+    };
+    const handleCanaryResult = (canary, payload, ctx) => {
+      if (aborted(canary)) {
+        canary.aborted = true;
+        return canary;
+      }
+      const checkResult = runChecks(payload, checks, ctx);
+      if (checkResult instanceof Promise) {
+        if (ctx.async === false)
+          throw new $ZodAsyncError();
+        return checkResult.then((checkResult2) => inst._zod.parse(checkResult2, ctx));
+      }
+      return inst._zod.parse(checkResult, ctx);
+    };
+    inst._zod.run = (payload, ctx) => {
+      if (ctx.skipChecks) {
+        return inst._zod.parse(payload, ctx);
+      }
+      if (ctx.direction === "backward") {
+        const canary = inst._zod.parse({ value: payload.value, issues: [] }, { ...ctx, skipChecks: true });
+        if (canary instanceof Promise) {
+          return canary.then((canary2) => {
+            return handleCanaryResult(canary2, payload, ctx);
+          });
+        }
+        return handleCanaryResult(canary, payload, ctx);
+      }
+      const result = inst._zod.parse(payload, ctx);
+      if (result instanceof Promise) {
+        if (ctx.async === false)
+          throw new $ZodAsyncError();
+        return result.then((result2) => runChecks(result2, checks, ctx));
+      }
+      return runChecks(result, checks, ctx);
+    };
+  }
+  inst["~standard"] = {
+    validate: (value) => {
+      try {
+        const r = safeParse(inst, value);
+        return r.success ? { value: r.data } : { issues: r.error?.issues };
+      } catch (_) {
+        return safeParseAsync(inst, value).then((r) => r.success ? { value: r.data } : { issues: r.error?.issues });
+      }
+    },
+    vendor: "zod",
+    version: 1
+  };
+});
+const $ZodString = /* @__PURE__ */ $constructor("$ZodString", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.pattern = [...inst?._zod.bag?.patterns ?? []].pop() ?? string$1(inst._zod.bag);
+  inst._zod.parse = (payload, _) => {
+    if (def.coerce)
+      try {
+        payload.value = String(payload.value);
+      } catch (_2) {
+      }
+    if (typeof payload.value === "string")
+      return payload;
+    payload.issues.push({
+      expected: "string",
+      code: "invalid_type",
+      input: payload.value,
+      inst
+    });
+    return payload;
+  };
+});
+const $ZodNumber = /* @__PURE__ */ $constructor("$ZodNumber", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.pattern = inst._zod.bag.pattern ?? number$1;
+  inst._zod.parse = (payload, _ctx) => {
+    if (def.coerce)
+      try {
+        payload.value = Number(payload.value);
+      } catch (_) {
+      }
+    const input = payload.value;
+    if (typeof input === "number" && !Number.isNaN(input) && Number.isFinite(input)) {
+      return payload;
+    }
+    const received = typeof input === "number" ? Number.isNaN(input) ? "NaN" : !Number.isFinite(input) ? "Infinity" : void 0 : void 0;
+    payload.issues.push({
+      expected: "number",
+      code: "invalid_type",
+      input,
+      inst,
+      ...received ? { received } : {}
+    });
+    return payload;
+  };
+});
+const $ZodBoolean = /* @__PURE__ */ $constructor("$ZodBoolean", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.pattern = boolean$1;
+  inst._zod.parse = (payload, _ctx) => {
+    if (def.coerce)
+      try {
+        payload.value = Boolean(payload.value);
+      } catch (_) {
+      }
+    const input = payload.value;
+    if (typeof input === "boolean")
+      return payload;
+    payload.issues.push({
+      expected: "boolean",
+      code: "invalid_type",
+      input,
+      inst
+    });
+    return payload;
+  };
+});
+const $ZodUndefined = /* @__PURE__ */ $constructor("$ZodUndefined", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.pattern = _undefined$2;
+  inst._zod.values = /* @__PURE__ */ new Set([void 0]);
+  inst._zod.optin = "optional";
+  inst._zod.optout = "optional";
+  inst._zod.parse = (payload, _ctx) => {
+    const input = payload.value;
+    if (typeof input === "undefined")
+      return payload;
+    payload.issues.push({
+      expected: "undefined",
+      code: "invalid_type",
+      input,
+      inst
+    });
+    return payload;
+  };
+});
+const $ZodAny = /* @__PURE__ */ $constructor("$ZodAny", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.parse = (payload) => payload;
+});
+const $ZodDate = /* @__PURE__ */ $constructor("$ZodDate", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.parse = (payload, _ctx) => {
+    if (def.coerce) {
+      try {
+        payload.value = new Date(payload.value);
+      } catch (_err) {
+      }
+    }
+    const input = payload.value;
+    const isDate = input instanceof Date;
+    const isValidDate = isDate && !Number.isNaN(input.getTime());
+    if (isValidDate)
+      return payload;
+    payload.issues.push({
+      expected: "date",
+      code: "invalid_type",
+      input,
+      ...isDate ? { received: "Invalid Date" } : {},
+      inst
+    });
+    return payload;
+  };
+});
+function handleArrayResult(result, final, index) {
+  if (result.issues.length) {
+    final.issues.push(...prefixIssues(index, result.issues));
+  }
+  final.value[index] = result.value;
+}
+const $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.parse = (payload, ctx) => {
+    const input = payload.value;
+    if (!Array.isArray(input)) {
+      payload.issues.push({
+        expected: "array",
+        code: "invalid_type",
+        input,
+        inst
+      });
+      return payload;
+    }
+    payload.value = Array(input.length);
+    const proms = [];
+    for (let i = 0; i < input.length; i++) {
+      const item = input[i];
+      const result = def.element._zod.run({
+        value: item,
+        issues: []
+      }, ctx);
+      if (result instanceof Promise) {
+        proms.push(result.then((result2) => handleArrayResult(result2, payload, i)));
+      } else {
+        handleArrayResult(result, payload, i);
+      }
+    }
+    if (proms.length) {
+      return Promise.all(proms).then(() => payload);
+    }
+    return payload;
+  };
+});
+function handlePropertyResult(result, final, key, input) {
+  if (result.issues.length) {
+    final.issues.push(...prefixIssues(key, result.issues));
+  }
+  if (result.value === void 0) {
+    if (key in input) {
+      final.value[key] = void 0;
+    }
+  } else {
+    final.value[key] = result.value;
+  }
+}
+function normalizeDef(def) {
+  const keys = Object.keys(def.shape);
+  for (const k of keys) {
+    if (!def.shape?.[k]?._zod?.traits?.has("$ZodType")) {
+      throw new Error(`Invalid element at key "${k}": expected a Zod schema`);
+    }
+  }
+  const okeys = optionalKeys(def.shape);
+  return {
+    ...def,
+    keys,
+    keySet: new Set(keys),
+    numKeys: keys.length,
+    optionalKeys: new Set(okeys)
+  };
+}
+function handleCatchall(proms, input, payload, ctx, def, inst) {
+  const unrecognized = [];
+  const keySet = def.keySet;
+  const _catchall = def.catchall._zod;
+  const t = _catchall.def.type;
+  for (const key of Object.keys(input)) {
+    if (keySet.has(key))
+      continue;
+    if (t === "never") {
+      unrecognized.push(key);
+      continue;
+    }
+    const r = _catchall.run({ value: input[key], issues: [] }, ctx);
+    if (r instanceof Promise) {
+      proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input)));
+    } else {
+      handlePropertyResult(r, payload, key, input);
+    }
+  }
+  if (unrecognized.length) {
+    payload.issues.push({
+      code: "unrecognized_keys",
+      keys: unrecognized,
+      input,
+      inst
+    });
+  }
+  if (!proms.length)
+    return payload;
+  return Promise.all(proms).then(() => {
+    return payload;
+  });
+}
+const $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
+  $ZodType.init(inst, def);
+  const desc = Object.getOwnPropertyDescriptor(def, "shape");
+  if (!desc?.get) {
+    const sh = def.shape;
+    Object.defineProperty(def, "shape", {
+      get: () => {
+        const newSh = { ...sh };
+        Object.defineProperty(def, "shape", {
+          value: newSh
+        });
+        return newSh;
+      }
+    });
+  }
+  const _normalized = cached(() => normalizeDef(def));
+  defineLazy(inst._zod, "propValues", () => {
+    const shape = def.shape;
+    const propValues = {};
+    for (const key in shape) {
+      const field = shape[key]._zod;
+      if (field.values) {
+        propValues[key] ?? (propValues[key] = /* @__PURE__ */ new Set());
+        for (const v of field.values)
+          propValues[key].add(v);
+      }
+    }
+    return propValues;
+  });
+  const isObject2 = isObject$1;
+  const catchall = def.catchall;
+  let value;
+  inst._zod.parse = (payload, ctx) => {
+    value ?? (value = _normalized.value);
+    const input = payload.value;
+    if (!isObject2(input)) {
+      payload.issues.push({
+        expected: "object",
+        code: "invalid_type",
+        input,
+        inst
+      });
+      return payload;
+    }
+    payload.value = {};
+    const proms = [];
+    const shape = value.shape;
+    for (const key of value.keys) {
+      const el = shape[key];
+      const r = el._zod.run({ value: input[key], issues: [] }, ctx);
+      if (r instanceof Promise) {
+        proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input)));
+      } else {
+        handlePropertyResult(r, payload, key, input);
+      }
+    }
+    if (!catchall) {
+      return proms.length ? Promise.all(proms).then(() => payload) : payload;
+    }
+    return handleCatchall(proms, input, payload, ctx, _normalized.value, inst);
+  };
+});
+function handleUnionResults(results, final, inst, ctx) {
+  for (const result of results) {
+    if (result.issues.length === 0) {
+      final.value = result.value;
+      return final;
+    }
+  }
+  const nonaborted = results.filter((r) => !aborted(r));
+  if (nonaborted.length === 1) {
+    final.value = nonaborted[0].value;
+    return nonaborted[0];
+  }
+  final.issues.push({
+    code: "invalid_union",
+    input: final.value,
+    inst,
+    errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+  });
+  return final;
+}
+const $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => {
+  $ZodType.init(inst, def);
+  defineLazy(inst._zod, "optin", () => def.options.some((o) => o._zod.optin === "optional") ? "optional" : void 0);
+  defineLazy(inst._zod, "optout", () => def.options.some((o) => o._zod.optout === "optional") ? "optional" : void 0);
+  defineLazy(inst._zod, "values", () => {
+    if (def.options.every((o) => o._zod.values)) {
+      return new Set(def.options.flatMap((option) => Array.from(option._zod.values)));
+    }
+    return void 0;
+  });
+  defineLazy(inst._zod, "pattern", () => {
+    if (def.options.every((o) => o._zod.pattern)) {
+      const patterns = def.options.map((o) => o._zod.pattern);
+      return new RegExp(`^(${patterns.map((p) => cleanRegex(p.source)).join("|")})$`);
+    }
+    return void 0;
+  });
+  const single = def.options.length === 1;
+  const first = def.options[0]._zod.run;
+  inst._zod.parse = (payload, ctx) => {
+    if (single) {
+      return first(payload, ctx);
+    }
+    let async = false;
+    const results = [];
+    for (const option of def.options) {
+      const result = option._zod.run({
+        value: payload.value,
+        issues: []
+      }, ctx);
+      if (result instanceof Promise) {
+        results.push(result);
+        async = true;
+      } else {
+        if (result.issues.length === 0)
+          return result;
+        results.push(result);
+      }
+    }
+    if (!async)
+      return handleUnionResults(results, payload, inst, ctx);
+    return Promise.all(results).then((results2) => {
+      return handleUnionResults(results2, payload, inst, ctx);
+    });
+  };
+});
+const $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("$ZodDiscriminatedUnion", (inst, def) => {
+  $ZodUnion.init(inst, def);
+  const _super = inst._zod.parse;
+  defineLazy(inst._zod, "propValues", () => {
+    const propValues = {};
+    for (const option of def.options) {
+      const pv = option._zod.propValues;
+      if (!pv || Object.keys(pv).length === 0)
+        throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(option)}"`);
+      for (const [k, v] of Object.entries(pv)) {
+        if (!propValues[k])
+          propValues[k] = /* @__PURE__ */ new Set();
+        for (const val of v) {
+          propValues[k].add(val);
+        }
+      }
+    }
+    return propValues;
+  });
+  const disc = cached(() => {
+    const opts = def.options;
+    const map = /* @__PURE__ */ new Map();
+    for (const o of opts) {
+      const values = o._zod.propValues?.[def.discriminator];
+      if (!values || values.size === 0)
+        throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(o)}"`);
+      for (const v of values) {
+        if (map.has(v)) {
+          throw new Error(`Duplicate discriminator value "${String(v)}"`);
+        }
+        map.set(v, o);
+      }
+    }
+    return map;
+  });
+  inst._zod.parse = (payload, ctx) => {
+    const input = payload.value;
+    if (!isObject$1(input)) {
+      payload.issues.push({
+        code: "invalid_type",
+        expected: "object",
+        input,
+        inst
+      });
+      return payload;
+    }
+    const opt = disc.value.get(input?.[def.discriminator]);
+    if (opt) {
+      return opt._zod.run(payload, ctx);
+    }
+    if (def.unionFallback) {
+      return _super(payload, ctx);
+    }
+    payload.issues.push({
+      code: "invalid_union",
+      errors: [],
+      note: "No matching discriminator",
+      discriminator: def.discriminator,
+      input,
+      path: [def.discriminator],
+      inst
+    });
+    return payload;
+  };
+});
+const $ZodTuple = /* @__PURE__ */ $constructor("$ZodTuple", (inst, def) => {
+  $ZodType.init(inst, def);
+  const items = def.items;
+  const optStart = items.length - [...items].reverse().findIndex((item) => item._zod.optin !== "optional");
+  inst._zod.parse = (payload, ctx) => {
+    const input = payload.value;
+    if (!Array.isArray(input)) {
+      payload.issues.push({
+        input,
+        inst,
+        expected: "tuple",
+        code: "invalid_type"
+      });
+      return payload;
+    }
+    payload.value = [];
+    const proms = [];
+    if (!def.rest) {
+      const tooBig = input.length > items.length;
+      const tooSmall = input.length < optStart - 1;
+      if (tooBig || tooSmall) {
+        payload.issues.push({
+          ...tooBig ? { code: "too_big", maximum: items.length } : { code: "too_small", minimum: items.length },
+          input,
+          inst,
+          origin: "array"
+        });
+        return payload;
+      }
+    }
+    let i = -1;
+    for (const item of items) {
+      i++;
+      if (i >= input.length) {
+        if (i >= optStart)
+          continue;
+      }
+      const result = item._zod.run({
+        value: input[i],
+        issues: []
+      }, ctx);
+      if (result instanceof Promise) {
+        proms.push(result.then((result2) => handleTupleResult(result2, payload, i)));
+      } else {
+        handleTupleResult(result, payload, i);
+      }
+    }
+    if (def.rest) {
+      const rest = input.slice(items.length);
+      for (const el of rest) {
+        i++;
+        const result = def.rest._zod.run({
+          value: el,
+          issues: []
+        }, ctx);
+        if (result instanceof Promise) {
+          proms.push(result.then((result2) => handleTupleResult(result2, payload, i)));
+        } else {
+          handleTupleResult(result, payload, i);
+        }
+      }
+    }
+    if (proms.length)
+      return Promise.all(proms).then(() => payload);
+    return payload;
+  };
+});
+function handleTupleResult(result, final, index) {
+  if (result.issues.length) {
+    final.issues.push(...prefixIssues(index, result.issues));
+  }
+  final.value[index] = result.value;
+}
+const $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
+  $ZodType.init(inst, def);
+  const values = getEnumValues(def.entries);
+  const valuesSet = new Set(values);
+  inst._zod.values = valuesSet;
+  inst._zod.pattern = new RegExp(`^(${values.filter((k) => propertyKeyTypes.has(typeof k)).map((o) => typeof o === "string" ? escapeRegex(o) : o.toString()).join("|")})$`);
+  inst._zod.parse = (payload, _ctx) => {
+    const input = payload.value;
+    if (valuesSet.has(input)) {
+      return payload;
+    }
+    payload.issues.push({
+      code: "invalid_value",
+      values,
+      input,
+      inst
+    });
+    return payload;
+  };
+});
+const $ZodLiteral = /* @__PURE__ */ $constructor("$ZodLiteral", (inst, def) => {
+  $ZodType.init(inst, def);
+  if (def.values.length === 0) {
+    throw new Error("Cannot create literal schema with no valid values");
+  }
+  inst._zod.values = new Set(def.values);
+  inst._zod.pattern = new RegExp(`^(${def.values.map((o) => typeof o === "string" ? escapeRegex(o) : o ? escapeRegex(o.toString()) : String(o)).join("|")})$`);
+  inst._zod.parse = (payload, _ctx) => {
+    const input = payload.value;
+    if (inst._zod.values.has(input)) {
+      return payload;
+    }
+    payload.issues.push({
+      code: "invalid_value",
+      values: def.values,
+      input,
+      inst
+    });
+    return payload;
+  };
+});
+function handleOptionalResult(result, input) {
+  if (result.issues.length && input === void 0) {
+    return { issues: [], value: void 0 };
+  }
+  return result;
+}
+const $ZodOptional = /* @__PURE__ */ $constructor("$ZodOptional", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.optin = "optional";
+  inst._zod.optout = "optional";
+  defineLazy(inst._zod, "values", () => {
+    return def.innerType._zod.values ? /* @__PURE__ */ new Set([...def.innerType._zod.values, void 0]) : void 0;
+  });
+  defineLazy(inst._zod, "pattern", () => {
+    const pattern = def.innerType._zod.pattern;
+    return pattern ? new RegExp(`^(${cleanRegex(pattern.source)})?$`) : void 0;
+  });
+  inst._zod.parse = (payload, ctx) => {
+    if (def.innerType._zod.optin === "optional") {
+      const result = def.innerType._zod.run(payload, ctx);
+      if (result instanceof Promise)
+        return result.then((r) => handleOptionalResult(r, payload.value));
+      return handleOptionalResult(result, payload.value);
+    }
+    if (payload.value === void 0) {
+      return payload;
+    }
+    return def.innerType._zod.run(payload, ctx);
+  };
+});
+const $ZodCustom = /* @__PURE__ */ $constructor("$ZodCustom", (inst, def) => {
+  $ZodCheck.init(inst, def);
+  $ZodType.init(inst, def);
+  inst._zod.parse = (payload, _) => {
+    return payload;
+  };
+  inst._zod.check = (payload) => {
+    const input = payload.value;
+    const r = def.fn(input);
+    if (r instanceof Promise) {
+      return r.then((r2) => handleRefineResult(r2, payload, input, inst));
+    }
+    handleRefineResult(r, payload, input, inst);
+    return;
+  };
+});
+function handleRefineResult(result, payload, input, inst) {
+  if (!result) {
+    const _iss = {
+      code: "custom",
+      input,
+      inst,
+      // incorporates params.error into issue reporting
+      path: [...inst._zod.def.path ?? []],
+      // incorporates params.error into issue reporting
+      continue: !inst._zod.def.abort
+      // params: inst._zod.def.params,
+    };
+    if (inst._zod.def.params)
+      _iss.params = inst._zod.def.params;
+    payload.issues.push(issue(_iss));
+  }
+}
+function _string(Class, params) {
+  return new Class({
+    type: "string",
+    ...normalizeParams(params)
+  });
+}
+function _number(Class, params) {
+  return new Class({
+    type: "number",
+    checks: [],
+    ...normalizeParams(params)
+  });
+}
+function _boolean(Class, params) {
+  return new Class({
+    type: "boolean",
+    ...normalizeParams(params)
+  });
+}
+function _undefined$1(Class, params) {
+  return new Class({
+    type: "undefined",
+    ...normalizeParams(params)
+  });
+}
+function _any(Class) {
+  return new Class({
+    type: "any"
+  });
+}
+function _date(Class, params) {
+  return new Class({
+    type: "date",
+    ...normalizeParams(params)
+  });
+}
+function _lte(value, params) {
+  return new $ZodCheckLessThan({
+    check: "less_than",
+    ...normalizeParams(params),
+    value,
+    inclusive: true
+  });
+}
+function _gt(value, params) {
+  return new $ZodCheckGreaterThan({
+    check: "greater_than",
+    ...normalizeParams(params),
+    value,
+    inclusive: false
+  });
+}
+function _gte(value, params) {
+  return new $ZodCheckGreaterThan({
+    check: "greater_than",
+    ...normalizeParams(params),
+    value,
+    inclusive: true
+  });
+}
+function _positive(params) {
+  return _gt(0, params);
+}
+function _maxLength(maximum, params) {
+  const ch = new $ZodCheckMaxLength({
+    check: "max_length",
+    ...normalizeParams(params),
+    maximum
+  });
+  return ch;
+}
+function _minLength(minimum, params) {
+  return new $ZodCheckMinLength({
+    check: "min_length",
+    ...normalizeParams(params),
+    minimum
+  });
+}
+function _length(length, params) {
+  return new $ZodCheckLengthEquals({
+    check: "length_equals",
+    ...normalizeParams(params),
+    length
+  });
+}
+function _refine(Class, fn, _params) {
+  const schema = new Class({
+    type: "custom",
+    check: "custom",
+    fn,
+    ...normalizeParams(_params)
+  });
+  return schema;
+}
+const ZodMiniType = /* @__PURE__ */ $constructor("ZodMiniType", (inst, def) => {
+  if (!inst._zod)
+    throw new Error("Uninitialized schema in ZodMiniType.");
+  $ZodType.init(inst, def);
+  inst.def = def;
+  inst.type = def.type;
+  inst.parse = (data, params) => parse(inst, data, params, { callee: inst.parse });
+  inst.safeParse = (data, params) => safeParse(inst, data, params);
+  inst.parseAsync = async (data, params) => parseAsync(inst, data, params, { callee: inst.parseAsync });
+  inst.safeParseAsync = async (data, params) => safeParseAsync(inst, data, params);
+  inst.check = (...checks) => {
+    return inst.clone(
+      {
+        ...def,
+        checks: [
+          ...def.checks ?? [],
+          ...checks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch)
+        ]
+      }
+      // { parent: true }
+    );
+  };
+  inst.clone = (_def, params) => clone(inst, _def, params);
+  inst.brand = () => inst;
+  inst.register = ((reg, meta) => {
+    reg.add(inst, meta);
+    return inst;
+  });
+});
+const ZodMiniString = /* @__PURE__ */ $constructor("ZodMiniString", (inst, def) => {
+  $ZodString.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+function string(params) {
+  return _string(ZodMiniString, params);
+}
+const ZodMiniNumber = /* @__PURE__ */ $constructor("ZodMiniNumber", (inst, def) => {
+  $ZodNumber.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+function number(params) {
+  return _number(ZodMiniNumber, params);
+}
+const ZodMiniBoolean = /* @__PURE__ */ $constructor("ZodMiniBoolean", (inst, def) => {
+  $ZodBoolean.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+function boolean(params) {
+  return _boolean(ZodMiniBoolean, params);
+}
+const ZodMiniUndefined = /* @__PURE__ */ $constructor("ZodMiniUndefined", (inst, def) => {
+  $ZodUndefined.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+function _undefined(params) {
+  return _undefined$1(ZodMiniUndefined, params);
+}
+const ZodMiniAny = /* @__PURE__ */ $constructor("ZodMiniAny", (inst, def) => {
+  $ZodAny.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+function any() {
+  return _any(ZodMiniAny);
+}
+const ZodMiniDate = /* @__PURE__ */ $constructor("ZodMiniDate", (inst, def) => {
+  $ZodDate.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+function date(params) {
+  return _date(ZodMiniDate, params);
+}
+const ZodMiniArray = /* @__PURE__ */ $constructor("ZodMiniArray", (inst, def) => {
+  $ZodArray.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+function array(element, params) {
+  return new ZodMiniArray({
+    type: "array",
+    element,
+    ...normalizeParams(params)
+  });
+}
+function keyof(schema) {
+  const shape = schema._zod.def.shape;
+  return _enum(Object.keys(shape));
+}
+const ZodMiniObject = /* @__PURE__ */ $constructor("ZodMiniObject", (inst, def) => {
+  $ZodObject.init(inst, def);
+  ZodMiniType.init(inst, def);
+  defineLazy(inst, "shape", () => def.shape);
+});
+function object(shape, params) {
+  const def = {
+    type: "object",
+    shape: shape ?? {},
+    ...normalizeParams(params)
+  };
+  return new ZodMiniObject(def);
+}
+function extend(schema, shape) {
+  return extend$1(schema, shape);
+}
+function partial(schema, mask) {
+  return partial$1(ZodMiniOptional, schema);
+}
+const ZodMiniUnion = /* @__PURE__ */ $constructor("ZodMiniUnion", (inst, def) => {
+  $ZodUnion.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+function union(options, params) {
+  return new ZodMiniUnion({
+    type: "union",
+    options,
+    ...normalizeParams(params)
+  });
+}
+const ZodMiniDiscriminatedUnion = /* @__PURE__ */ $constructor("ZodMiniDiscriminatedUnion", (inst, def) => {
+  $ZodDiscriminatedUnion.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+function discriminatedUnion(discriminator, options, params) {
+  return new ZodMiniDiscriminatedUnion({
+    type: "union",
+    options,
+    discriminator,
+    ...normalizeParams(params)
+  });
+}
+const ZodMiniTuple = /* @__PURE__ */ $constructor("ZodMiniTuple", (inst, def) => {
+  $ZodTuple.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+function tuple(items, _paramsOrRest, _params) {
+  const hasRest = _paramsOrRest instanceof $ZodType;
+  const params = hasRest ? _params : _paramsOrRest;
+  const rest = hasRest ? _paramsOrRest : null;
+  return new ZodMiniTuple({
+    type: "tuple",
+    items,
+    rest,
+    ...normalizeParams(params)
+  });
+}
+const ZodMiniEnum = /* @__PURE__ */ $constructor("ZodMiniEnum", (inst, def) => {
+  $ZodEnum.init(inst, def);
+  ZodMiniType.init(inst, def);
+  inst.options = Object.values(def.entries);
+});
+function _enum(values, params) {
+  const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
+  return new ZodMiniEnum({
+    type: "enum",
+    entries,
+    ...normalizeParams(params)
+  });
+}
+const ZodMiniLiteral = /* @__PURE__ */ $constructor("ZodMiniLiteral", (inst, def) => {
+  $ZodLiteral.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+function literal(value, params) {
+  return new ZodMiniLiteral({
+    type: "literal",
+    values: Array.isArray(value) ? value : [value],
+    ...normalizeParams(params)
+  });
+}
+const ZodMiniOptional = /* @__PURE__ */ $constructor("ZodMiniOptional", (inst, def) => {
+  $ZodOptional.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+function optional(innerType) {
+  return new ZodMiniOptional({
+    type: "optional",
+    innerType
+  });
+}
+const ZodMiniCustom = /* @__PURE__ */ $constructor("ZodMiniCustom", (inst, def) => {
+  $ZodCustom.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+function refine(fn, _params = {}) {
+  return _refine(ZodMiniCustom, fn, _params);
+}
+const commonServiceRequestSchema = partial(
+  object({
+    apiKey: string(),
+    commonBaseURL: string(),
+    customServiceBaseURL: string(),
+    language: string()
+  })
+);
+class ValidationError extends Error {
+  constructor(zodError) {
+    super(prettifyError(zodError));
+    this.issues = zodError.issues;
+  }
+}
+const validateRequestSchema = (params, config2) => {
+  const requestSchema = config2?.schema ? extend(commonServiceRequestSchema, config2.schema.shape) : commonServiceRequestSchema;
+  const mergedSchema = requestSchema.check(
+    refine(
+      (data) => "commonBaseURL" in data || "customServiceBaseURL" in data,
+      "commonBaseURL or customServiceBaseURL is required"
+    )
+  );
+  let refinedMergedSchema;
+  if (config2?.refinements?.length) {
+    refinedMergedSchema = mergedSchema;
+    for (const refinement of config2.refinements) {
+      refinedMergedSchema = refinedMergedSchema.check(refine(refinement.check, refinement.message));
+    }
+  }
+  const validation = (refinedMergedSchema ?? mergedSchema).safeParse(params);
+  if (!validation.success) {
+    throw new ValidationError(validation.error);
+  }
+  return params;
+};
+const callService = async (params, template, serviceName) => {
+  const customApiVersion = template.getAPIVersion?.(params);
+  const mergedParams = core.mergeFromGlobal({ ...params, ...customApiVersion && { apiVersion: customApiVersion } });
+  if (params.validateRequest === void 0 || params.validateRequest) {
+    try {
+      validateRequestSchema(mergedParams, template.requestValidation);
+    } catch (e) {
+      return Promise.reject(buildValidationError(e, serviceName));
+    }
+  }
+  const apiRequest = template.buildRequest(mergedParams);
+  const headers = core.generateTomTomHeaders(mergedParams);
+  params.onAPIRequest?.(apiRequest);
+  try {
+    const apiResponse = await template.sendRequest(apiRequest, headers);
+    params.onAPIResponse?.(apiRequest, apiResponse);
+    return template.parseResponse(await apiResponse.data, mergedParams);
+  } catch (e) {
+    params.onAPIResponse?.(apiRequest, e);
+    return Promise.reject(buildResponseError(e, serviceName, template.parseResponseError));
+  }
+};
+const returnOrThrow = async (response) => {
+  if (response.ok) {
+    return { data: await response.json(), status: response.status };
+  }
+  let message;
+  let errorBody;
+  const contentType = response.headers.get("content-type");
+  if (!response.bodyUsed) {
+    if (contentType?.includes("application/json")) {
+      errorBody = await response.json();
+      message = errorBody?.errorText ?? errorBody?.message ?? errorBody?.detailedError?.message;
+    } else if (contentType?.includes("text/xml")) {
+      errorBody = await response.text();
+      message = response.statusText;
+    }
+  } else {
+    message = response.statusText;
+  }
+  throw { status: response.status, message, data: errorBody };
+};
+const get = async (url, headers) => returnOrThrow(await fetch(url, { headers }));
+const post = async (input, headers) => returnOrThrow(
+  await fetch(input.url, {
+    method: "POST",
+    body: JSON.stringify(input.data),
+    headers: { ...headers, "Content-Type": "application/json" }
+  })
+);
+const fetchWith = async (input, headers) => {
+  const method = input.method;
+  if (method === "GET") {
+    return get(input.url, headers);
+  }
+  if (method === "POST") {
+    return post(input, headers);
+  }
+  throw Error(`Unsupported HTTP method received: ${method}`);
+};
+const lineStringCoordsSchema = array(array(number()));
+const geometrySchema = object({
+  type: _enum([
+    "Point",
+    "MultiPoint",
+    "LineString",
+    "MultiLineString",
+    "Polygon",
+    "MultiPolygon",
+    "GeometryCollection",
+    "Circle"
+  ]),
+  coordinates: union([
+    array(number()),
+    lineStringCoordsSchema,
+    array(array(array(number()))),
+    array(array(array(array(number()))))
+  ]),
+  radius: optional(number()),
+  radiusMeters: optional(number()),
+  bbox: optional(array(number()))
+}).check(
+  refine(
+    (data) => data.type === "Circle" ? Boolean(data.radius) : true,
+    'type: "Circle" must have radius property'
+  )
+);
+const featureSchema = object({
+  type: literal("Feature"),
+  geometry: geometrySchema,
+  id: optional(union([string(), number()])),
+  properties: any(),
+  bbox: optional(array(number()))
+});
+const featureCollectionSchema = object({
+  type: literal("FeatureCollection"),
+  features: array(featureSchema),
+  id: optional(union([string(), number()])),
+  properties: any(),
+  bbox: optional(array(number()))
+});
+const hasLngLatSchema = union([
+  tuple([number().check(_gte(-180), _lte(180)), number().check(_gte(-90), _lte(90))]),
+  tuple([
+    number().check(_gte(-180), _lte(180)),
+    number().check(_gte(-90), _lte(90)),
+    number()
+  ]),
+  object({
+    type: literal("Point"),
+    coordinates: array(number())
+  }),
+  featureSchema
+]);
+const geoJsonbBoxSchema = union([array(number()).check(_length(4)), array(number()).check(_length(6))]);
+const geoJSONObjectSchema = union([geometrySchema, featureSchema, featureCollectionSchema]);
+const hasBBoxSchema = union([geoJsonbBoxSchema, geoJSONObjectSchema, array(geoJSONObjectSchema)]);
+const autocompleteSearchRequestMandatory = object({
+  query: string()
+});
+const autocompleteSearchRequestOptional = partial(
+  object({
+    position: hasLngLatSchema,
+    limit: number().check(_lte(100)),
+    radiusMeters: number(),
+    countries: array(string()),
+    resultType: array(string())
+  })
+);
+const autocompleteSearchRequestSchema = extend(
+  autocompleteSearchRequestMandatory,
+  autocompleteSearchRequestOptional.shape
+);
+var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+var root = freeGlobal || freeSelf || Function("return this")();
+var Symbol$1 = root.Symbol;
+var objectProto$b = Object.prototype;
+var hasOwnProperty$8 = objectProto$b.hasOwnProperty;
+var nativeObjectToString$1 = objectProto$b.toString;
+var symToStringTag$1 = Symbol$1 ? Symbol$1.toStringTag : void 0;
+function getRawTag(value) {
+  var isOwn = hasOwnProperty$8.call(value, symToStringTag$1), tag = value[symToStringTag$1];
+  try {
+    value[symToStringTag$1] = void 0;
+    var unmasked = true;
+  } catch (e) {
+  }
+  var result = nativeObjectToString$1.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag$1] = tag;
+    } else {
+      delete value[symToStringTag$1];
+    }
+  }
+  return result;
+}
+var objectProto$a = Object.prototype;
+var nativeObjectToString = objectProto$a.toString;
+function objectToString(value) {
+  return nativeObjectToString.call(value);
+}
+var nullTag = "[object Null]", undefinedTag = "[object Undefined]";
+var symToStringTag = Symbol$1 ? Symbol$1.toStringTag : void 0;
+function baseGetTag(value) {
+  if (value == null) {
+    return value === void 0 ? undefinedTag : nullTag;
+  }
+  return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+}
+function isObjectLike(value) {
+  return value != null && typeof value == "object";
+}
+var symbolTag$2 = "[object Symbol]";
+function isSymbol(value) {
+  return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag$2;
+}
+function arrayMap(array2, iteratee) {
+  var index = -1, length = array2 == null ? 0 : array2.length, result = Array(length);
+  while (++index < length) {
+    result[index] = iteratee(array2[index], index, array2);
+  }
+  return result;
+}
+var isArray = Array.isArray;
+var symbolProto$1 = Symbol$1 ? Symbol$1.prototype : void 0, symbolToString = symbolProto$1 ? symbolProto$1.toString : void 0;
+function baseToString(value) {
+  if (typeof value == "string") {
+    return value;
+  }
+  if (isArray(value)) {
+    return arrayMap(value, baseToString) + "";
+  }
+  if (isSymbol(value)) {
+    return symbolToString ? symbolToString.call(value) : "";
+  }
+  var result = value + "";
+  return result == "0" && 1 / value == -Infinity ? "-0" : result;
+}
+function isObject(value) {
+  var type = typeof value;
+  return value != null && (type == "object" || type == "function");
+}
+function identity(value) {
+  return value;
+}
+var asyncTag = "[object AsyncFunction]", funcTag$2 = "[object Function]", genTag$1 = "[object GeneratorFunction]", proxyTag = "[object Proxy]";
+function isFunction(value) {
+  if (!isObject(value)) {
+    return false;
+  }
+  var tag = baseGetTag(value);
+  return tag == funcTag$2 || tag == genTag$1 || tag == asyncTag || tag == proxyTag;
+}
+var coreJsData = root["__core-js_shared__"];
+var maskSrcKey = (function() {
+  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
+  return uid ? "Symbol(src)_1." + uid : "";
+})();
+function isMasked(func) {
+  return !!maskSrcKey && maskSrcKey in func;
+}
+var funcProto$2 = Function.prototype;
+var funcToString$2 = funcProto$2.toString;
+function toSource(func) {
+  if (func != null) {
+    try {
+      return funcToString$2.call(func);
+    } catch (e) {
+    }
+    try {
+      return func + "";
+    } catch (e) {
+    }
+  }
+  return "";
+}
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+var funcProto$1 = Function.prototype, objectProto$9 = Object.prototype;
+var funcToString$1 = funcProto$1.toString;
+var hasOwnProperty$7 = objectProto$9.hasOwnProperty;
+var reIsNative = RegExp(
+  "^" + funcToString$1.call(hasOwnProperty$7).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+);
+function baseIsNative(value) {
+  if (!isObject(value) || isMasked(value)) {
+    return false;
+  }
+  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
+  return pattern.test(toSource(value));
+}
+function getValue(object2, key) {
+  return object2 == null ? void 0 : object2[key];
+}
+function getNative(object2, key) {
+  var value = getValue(object2, key);
+  return baseIsNative(value) ? value : void 0;
+}
+var WeakMap = getNative(root, "WeakMap");
+function apply(func, thisArg, args) {
+  switch (args.length) {
+    case 0:
+      return func.call(thisArg);
+    case 1:
+      return func.call(thisArg, args[0]);
+    case 2:
+      return func.call(thisArg, args[0], args[1]);
+    case 3:
+      return func.call(thisArg, args[0], args[1], args[2]);
+  }
+  return func.apply(thisArg, args);
+}
+var HOT_COUNT = 800, HOT_SPAN = 16;
+var nativeNow = Date.now;
+function shortOut(func) {
+  var count = 0, lastCalled = 0;
+  return function() {
+    var stamp = nativeNow(), remaining = HOT_SPAN - (stamp - lastCalled);
+    lastCalled = stamp;
+    if (remaining > 0) {
+      if (++count >= HOT_COUNT) {
+        return arguments[0];
+      }
+    } else {
+      count = 0;
+    }
+    return func.apply(void 0, arguments);
+  };
+}
+function constant(value) {
+  return function() {
+    return value;
+  };
+}
+var defineProperty = (function() {
+  try {
+    var func = getNative(Object, "defineProperty");
+    func({}, "", {});
+    return func;
+  } catch (e) {
+  }
+})();
+var baseSetToString = !defineProperty ? identity : function(func, string2) {
+  return defineProperty(func, "toString", {
+    "configurable": true,
+    "enumerable": false,
+    "value": constant(string2),
+    "writable": true
+  });
+};
+var setToString = shortOut(baseSetToString);
+function arrayEach(array2, iteratee) {
+  var index = -1, length = array2 == null ? 0 : array2.length;
+  while (++index < length) {
+    if (iteratee(array2[index], index, array2) === false) {
+      break;
+    }
+  }
+  return array2;
+}
+var MAX_SAFE_INTEGER$1 = 9007199254740991;
+var reIsUint = /^(?:0|[1-9]\d*)$/;
+function isIndex(value, length) {
+  var type = typeof value;
+  length = length == null ? MAX_SAFE_INTEGER$1 : length;
+  return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
+}
+function baseAssignValue(object2, key, value) {
+  if (key == "__proto__" && defineProperty) {
+    defineProperty(object2, key, {
+      "configurable": true,
+      "enumerable": true,
+      "value": value,
+      "writable": true
+    });
+  } else {
+    object2[key] = value;
+  }
+}
+function eq(value, other) {
+  return value === other || value !== value && other !== other;
+}
+var objectProto$8 = Object.prototype;
+var hasOwnProperty$6 = objectProto$8.hasOwnProperty;
+function assignValue(object2, key, value) {
+  var objValue = object2[key];
+  if (!(hasOwnProperty$6.call(object2, key) && eq(objValue, value)) || value === void 0 && !(key in object2)) {
+    baseAssignValue(object2, key, value);
+  }
+}
+function copyObject(source, props, object2, customizer) {
+  var isNew = !object2;
+  object2 || (object2 = {});
+  var index = -1, length = props.length;
+  while (++index < length) {
+    var key = props[index];
+    var newValue = void 0;
+    if (newValue === void 0) {
+      newValue = source[key];
+    }
+    if (isNew) {
+      baseAssignValue(object2, key, newValue);
+    } else {
+      assignValue(object2, key, newValue);
+    }
+  }
+  return object2;
+}
+var nativeMax = Math.max;
+function overRest(func, start, transform) {
+  start = nativeMax(start === void 0 ? func.length - 1 : start, 0);
+  return function() {
+    var args = arguments, index = -1, length = nativeMax(args.length - start, 0), array2 = Array(length);
+    while (++index < length) {
+      array2[index] = args[start + index];
+    }
+    index = -1;
+    var otherArgs = Array(start + 1);
+    while (++index < start) {
+      otherArgs[index] = args[index];
+    }
+    otherArgs[start] = transform(array2);
+    return apply(func, this, otherArgs);
+  };
+}
+var MAX_SAFE_INTEGER = 9007199254740991;
+function isLength(value) {
+  return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+}
+function isArrayLike(value) {
+  return value != null && isLength(value.length) && !isFunction(value);
+}
+var objectProto$7 = Object.prototype;
+function isPrototype(value) {
+  var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto$7;
+  return value === proto;
+}
+function baseTimes(n, iteratee) {
+  var index = -1, result = Array(n);
+  while (++index < n) {
+    result[index] = iteratee(index);
+  }
+  return result;
+}
+var argsTag$2 = "[object Arguments]";
+function baseIsArguments(value) {
+  return isObjectLike(value) && baseGetTag(value) == argsTag$2;
+}
+var objectProto$6 = Object.prototype;
+var hasOwnProperty$5 = objectProto$6.hasOwnProperty;
+var propertyIsEnumerable$1 = objectProto$6.propertyIsEnumerable;
+var isArguments = baseIsArguments(/* @__PURE__ */ (function() {
+  return arguments;
+})()) ? baseIsArguments : function(value) {
+  return isObjectLike(value) && hasOwnProperty$5.call(value, "callee") && !propertyIsEnumerable$1.call(value, "callee");
+};
+function stubFalse() {
+  return false;
+}
+var freeExports$2 = typeof exports == "object" && exports && !exports.nodeType && exports;
+var freeModule$2 = freeExports$2 && typeof module == "object" && module && !module.nodeType && module;
+var moduleExports$2 = freeModule$2 && freeModule$2.exports === freeExports$2;
+var Buffer$1 = moduleExports$2 ? root.Buffer : void 0;
+var nativeIsBuffer = Buffer$1 ? Buffer$1.isBuffer : void 0;
+var isBuffer = nativeIsBuffer || stubFalse;
+var argsTag$1 = "[object Arguments]", arrayTag$1 = "[object Array]", boolTag$2 = "[object Boolean]", dateTag$2 = "[object Date]", errorTag$1 = "[object Error]", funcTag$1 = "[object Function]", mapTag$4 = "[object Map]", numberTag$2 = "[object Number]", objectTag$3 = "[object Object]", regexpTag$2 = "[object RegExp]", setTag$4 = "[object Set]", stringTag$2 = "[object String]", weakMapTag$2 = "[object WeakMap]";
+var arrayBufferTag$2 = "[object ArrayBuffer]", dataViewTag$3 = "[object DataView]", float32Tag$2 = "[object Float32Array]", float64Tag$2 = "[object Float64Array]", int8Tag$2 = "[object Int8Array]", int16Tag$2 = "[object Int16Array]", int32Tag$2 = "[object Int32Array]", uint8Tag$2 = "[object Uint8Array]", uint8ClampedTag$2 = "[object Uint8ClampedArray]", uint16Tag$2 = "[object Uint16Array]", uint32Tag$2 = "[object Uint32Array]";
+var typedArrayTags = {};
+typedArrayTags[float32Tag$2] = typedArrayTags[float64Tag$2] = typedArrayTags[int8Tag$2] = typedArrayTags[int16Tag$2] = typedArrayTags[int32Tag$2] = typedArrayTags[uint8Tag$2] = typedArrayTags[uint8ClampedTag$2] = typedArrayTags[uint16Tag$2] = typedArrayTags[uint32Tag$2] = true;
+typedArrayTags[argsTag$1] = typedArrayTags[arrayTag$1] = typedArrayTags[arrayBufferTag$2] = typedArrayTags[boolTag$2] = typedArrayTags[dataViewTag$3] = typedArrayTags[dateTag$2] = typedArrayTags[errorTag$1] = typedArrayTags[funcTag$1] = typedArrayTags[mapTag$4] = typedArrayTags[numberTag$2] = typedArrayTags[objectTag$3] = typedArrayTags[regexpTag$2] = typedArrayTags[setTag$4] = typedArrayTags[stringTag$2] = typedArrayTags[weakMapTag$2] = false;
+function baseIsTypedArray(value) {
+  return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
+}
+function baseUnary(func) {
+  return function(value) {
+    return func(value);
+  };
+}
+var freeExports$1 = typeof exports == "object" && exports && !exports.nodeType && exports;
+var freeModule$1 = freeExports$1 && typeof module == "object" && module && !module.nodeType && module;
+var moduleExports$1 = freeModule$1 && freeModule$1.exports === freeExports$1;
+var freeProcess = moduleExports$1 && freeGlobal.process;
+var nodeUtil = (function() {
+  try {
+    var types = freeModule$1 && freeModule$1.require && freeModule$1.require("util").types;
+    if (types) {
+      return types;
+    }
+    return freeProcess && freeProcess.binding && freeProcess.binding("util");
+  } catch (e) {
+  }
+})();
+var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
+var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+function arrayLikeKeys(value, inherited) {
+  var isArr = isArray(value), isArg = !isArr && isArguments(value), isBuff = !isArr && !isArg && isBuffer(value), isType = !isArr && !isArg && !isBuff && isTypedArray(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes(value.length, String) : [], length = result.length;
+  for (var key in value) {
+    if (!(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode.
+    (key == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
+    isBuff && (key == "offset" || key == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
+    isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || // Skip index properties.
+    isIndex(key, length)))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+function overArg(func, transform) {
+  return function(arg) {
+    return func(transform(arg));
+  };
+}
+function nativeKeysIn(object2) {
+  var result = [];
+  if (object2 != null) {
+    for (var key in Object(object2)) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+var objectProto$5 = Object.prototype;
+var hasOwnProperty$4 = objectProto$5.hasOwnProperty;
+function baseKeysIn(object2) {
+  if (!isObject(object2)) {
+    return nativeKeysIn(object2);
+  }
+  var isProto = isPrototype(object2), result = [];
+  for (var key in object2) {
+    if (!(key == "constructor" && (isProto || !hasOwnProperty$4.call(object2, key)))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+function keysIn(object2) {
+  return isArrayLike(object2) ? arrayLikeKeys(object2) : baseKeysIn(object2);
+}
+var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, reIsPlainProp = /^\w*$/;
+function isKey(value, object2) {
+  if (isArray(value)) {
+    return false;
+  }
+  var type = typeof value;
+  if (type == "number" || type == "symbol" || type == "boolean" || value == null || isSymbol(value)) {
+    return true;
+  }
+  return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object2 != null && value in Object(object2);
+}
+var nativeCreate = getNative(Object, "create");
+function hashClear() {
+  this.__data__ = nativeCreate ? nativeCreate(null) : {};
+  this.size = 0;
+}
+function hashDelete(key) {
+  var result = this.has(key) && delete this.__data__[key];
+  this.size -= result ? 1 : 0;
+  return result;
+}
+var HASH_UNDEFINED$1 = "__lodash_hash_undefined__";
+var objectProto$4 = Object.prototype;
+var hasOwnProperty$3 = objectProto$4.hasOwnProperty;
+function hashGet(key) {
+  var data = this.__data__;
+  if (nativeCreate) {
+    var result = data[key];
+    return result === HASH_UNDEFINED$1 ? void 0 : result;
+  }
+  return hasOwnProperty$3.call(data, key) ? data[key] : void 0;
+}
+var objectProto$3 = Object.prototype;
+var hasOwnProperty$2 = objectProto$3.hasOwnProperty;
+function hashHas(key) {
+  var data = this.__data__;
+  return nativeCreate ? data[key] !== void 0 : hasOwnProperty$2.call(data, key);
+}
+var HASH_UNDEFINED = "__lodash_hash_undefined__";
+function hashSet(key, value) {
+  var data = this.__data__;
+  this.size += this.has(key) ? 0 : 1;
+  data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED : value;
+  return this;
+}
+function Hash(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+Hash.prototype.clear = hashClear;
+Hash.prototype["delete"] = hashDelete;
+Hash.prototype.get = hashGet;
+Hash.prototype.has = hashHas;
+Hash.prototype.set = hashSet;
+function listCacheClear() {
+  this.__data__ = [];
+  this.size = 0;
+}
+function assocIndexOf(array2, key) {
+  var length = array2.length;
+  while (length--) {
+    if (eq(array2[length][0], key)) {
+      return length;
+    }
+  }
+  return -1;
+}
+var arrayProto = Array.prototype;
+var splice = arrayProto.splice;
+function listCacheDelete(key) {
+  var data = this.__data__, index = assocIndexOf(data, key);
+  if (index < 0) {
+    return false;
+  }
+  var lastIndex = data.length - 1;
+  if (index == lastIndex) {
+    data.pop();
+  } else {
+    splice.call(data, index, 1);
+  }
+  --this.size;
+  return true;
+}
+function listCacheGet(key) {
+  var data = this.__data__, index = assocIndexOf(data, key);
+  return index < 0 ? void 0 : data[index][1];
+}
+function listCacheHas(key) {
+  return assocIndexOf(this.__data__, key) > -1;
+}
+function listCacheSet(key, value) {
+  var data = this.__data__, index = assocIndexOf(data, key);
+  if (index < 0) {
+    ++this.size;
+    data.push([key, value]);
+  } else {
+    data[index][1] = value;
+  }
+  return this;
+}
+function ListCache(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+ListCache.prototype.clear = listCacheClear;
+ListCache.prototype["delete"] = listCacheDelete;
+ListCache.prototype.get = listCacheGet;
+ListCache.prototype.has = listCacheHas;
+ListCache.prototype.set = listCacheSet;
+var Map$1 = getNative(root, "Map");
+function mapCacheClear() {
+  this.size = 0;
+  this.__data__ = {
+    "hash": new Hash(),
+    "map": new (Map$1 || ListCache)(),
+    "string": new Hash()
+  };
+}
+function isKeyable(value) {
+  var type = typeof value;
+  return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+}
+function getMapData(map, key) {
+  var data = map.__data__;
+  return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+}
+function mapCacheDelete(key) {
+  var result = getMapData(this, key)["delete"](key);
+  this.size -= result ? 1 : 0;
+  return result;
+}
+function mapCacheGet(key) {
+  return getMapData(this, key).get(key);
+}
+function mapCacheHas(key) {
+  return getMapData(this, key).has(key);
+}
+function mapCacheSet(key, value) {
+  var data = getMapData(this, key), size = data.size;
+  data.set(key, value);
+  this.size += data.size == size ? 0 : 1;
+  return this;
+}
+function MapCache(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+MapCache.prototype.clear = mapCacheClear;
+MapCache.prototype["delete"] = mapCacheDelete;
+MapCache.prototype.get = mapCacheGet;
+MapCache.prototype.has = mapCacheHas;
+MapCache.prototype.set = mapCacheSet;
+var FUNC_ERROR_TEXT = "Expected a function";
+function memoize(func, resolver) {
+  if (typeof func != "function" || resolver != null && typeof resolver != "function") {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  var memoized = function() {
+    var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    var result = func.apply(this, args);
+    memoized.cache = cache.set(key, result) || cache;
+    return result;
+  };
+  memoized.cache = new (memoize.Cache || MapCache)();
+  return memoized;
+}
+memoize.Cache = MapCache;
+var MAX_MEMOIZE_SIZE = 500;
+function memoizeCapped(func) {
+  var result = memoize(func, function(key) {
+    if (cache.size === MAX_MEMOIZE_SIZE) {
+      cache.clear();
+    }
+    return key;
+  });
+  var cache = result.cache;
+  return result;
+}
+var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+var reEscapeChar = /\\(\\)?/g;
+var stringToPath = memoizeCapped(function(string2) {
+  var result = [];
+  if (string2.charCodeAt(0) === 46) {
+    result.push("");
+  }
+  string2.replace(rePropName, function(match, number2, quote, subString) {
+    result.push(quote ? subString.replace(reEscapeChar, "$1") : number2 || match);
+  });
+  return result;
+});
+function toString(value) {
+  return value == null ? "" : baseToString(value);
+}
+function castPath(value, object2) {
+  if (isArray(value)) {
+    return value;
+  }
+  return isKey(value, object2) ? [value] : stringToPath(toString(value));
+}
+function toKey(value) {
+  if (typeof value == "string" || isSymbol(value)) {
+    return value;
+  }
+  var result = value + "";
+  return result == "0" && 1 / value == -Infinity ? "-0" : result;
+}
+function baseGet(object2, path) {
+  path = castPath(path, object2);
+  var index = 0, length = path.length;
+  while (object2 != null && index < length) {
+    object2 = object2[toKey(path[index++])];
+  }
+  return index && index == length ? object2 : void 0;
+}
+function arrayPush(array2, values) {
+  var index = -1, length = values.length, offset = array2.length;
+  while (++index < length) {
+    array2[offset + index] = values[index];
+  }
+  return array2;
+}
+var spreadableSymbol = Symbol$1 ? Symbol$1.isConcatSpreadable : void 0;
+function isFlattenable(value) {
+  return isArray(value) || isArguments(value) || !!(spreadableSymbol && value && value[spreadableSymbol]);
+}
+function baseFlatten(array2, depth, predicate, isStrict, result) {
+  var index = -1, length = array2.length;
+  predicate || (predicate = isFlattenable);
+  result || (result = []);
+  while (++index < length) {
+    var value = array2[index];
+    if (predicate(value)) {
+      {
+        arrayPush(result, value);
+      }
+    } else {
+      result[result.length] = value;
+    }
+  }
+  return result;
+}
+function flatten(array2) {
+  var length = array2 == null ? 0 : array2.length;
+  return length ? baseFlatten(array2) : [];
+}
+function flatRest(func) {
+  return setToString(overRest(func, void 0, flatten), func + "");
+}
+var getPrototype = overArg(Object.getPrototypeOf, Object);
+var objectTag$2 = "[object Object]";
+var funcProto = Function.prototype, objectProto$2 = Object.prototype;
+var funcToString = funcProto.toString;
+var hasOwnProperty$1 = objectProto$2.hasOwnProperty;
+var objectCtorString = funcToString.call(Object);
+function isPlainObject(value) {
+  if (!isObjectLike(value) || baseGetTag(value) != objectTag$2) {
+    return false;
+  }
+  var proto = getPrototype(value);
+  if (proto === null) {
+    return true;
+  }
+  var Ctor = hasOwnProperty$1.call(proto, "constructor") && proto.constructor;
+  return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString;
+}
+function baseSlice(array2, start, end) {
+  var index = -1, length = array2.length;
+  if (start < 0) {
+    start = -start > length ? 0 : length + start;
+  }
+  end = end > length ? length : end;
+  if (end < 0) {
+    end += length;
+  }
+  length = start > end ? 0 : end - start >>> 0;
+  start >>>= 0;
+  var result = Array(length);
+  while (++index < length) {
+    result[index] = array2[index + start];
+  }
+  return result;
+}
+function stackClear() {
+  this.__data__ = new ListCache();
+  this.size = 0;
+}
+function stackDelete(key) {
+  var data = this.__data__, result = data["delete"](key);
+  this.size = data.size;
+  return result;
+}
+function stackGet(key) {
+  return this.__data__.get(key);
+}
+function stackHas(key) {
+  return this.__data__.has(key);
+}
+var LARGE_ARRAY_SIZE = 200;
+function stackSet(key, value) {
+  var data = this.__data__;
+  if (data instanceof ListCache) {
+    var pairs = data.__data__;
+    if (!Map$1 || pairs.length < LARGE_ARRAY_SIZE - 1) {
+      pairs.push([key, value]);
+      this.size = ++data.size;
+      return this;
+    }
+    data = this.__data__ = new MapCache(pairs);
+  }
+  data.set(key, value);
+  this.size = data.size;
+  return this;
+}
+function Stack(entries) {
+  var data = this.__data__ = new ListCache(entries);
+  this.size = data.size;
+}
+Stack.prototype.clear = stackClear;
+Stack.prototype["delete"] = stackDelete;
+Stack.prototype.get = stackGet;
+Stack.prototype.has = stackHas;
+Stack.prototype.set = stackSet;
+var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
+var freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module;
+var moduleExports = freeModule && freeModule.exports === freeExports;
+var Buffer = moduleExports ? root.Buffer : void 0;
+Buffer ? Buffer.allocUnsafe : void 0;
+function cloneBuffer(buffer, isDeep) {
+  {
+    return buffer.slice();
+  }
+}
+function arrayFilter(array2, predicate) {
+  var index = -1, length = array2 == null ? 0 : array2.length, resIndex = 0, result = [];
+  while (++index < length) {
+    var value = array2[index];
+    if (predicate(value, index, array2)) {
+      result[resIndex++] = value;
+    }
+  }
+  return result;
+}
+function stubArray() {
+  return [];
+}
+var objectProto$1 = Object.prototype;
+var propertyIsEnumerable = objectProto$1.propertyIsEnumerable;
+var nativeGetSymbols$1 = Object.getOwnPropertySymbols;
+var getSymbols = !nativeGetSymbols$1 ? stubArray : function(object2) {
+  if (object2 == null) {
+    return [];
+  }
+  object2 = Object(object2);
+  return arrayFilter(nativeGetSymbols$1(object2), function(symbol) {
+    return propertyIsEnumerable.call(object2, symbol);
+  });
+};
+var nativeGetSymbols = Object.getOwnPropertySymbols;
+var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object2) {
+  var result = [];
+  while (object2) {
+    arrayPush(result, getSymbols(object2));
+    object2 = getPrototype(object2);
+  }
+  return result;
+};
+function baseGetAllKeys(object2, keysFunc, symbolsFunc) {
+  var result = keysFunc(object2);
+  return isArray(object2) ? result : arrayPush(result, symbolsFunc(object2));
+}
+function getAllKeysIn(object2) {
+  return baseGetAllKeys(object2, keysIn, getSymbolsIn);
+}
+var DataView = getNative(root, "DataView");
+var Promise$1 = getNative(root, "Promise");
+var Set$1 = getNative(root, "Set");
+var mapTag$3 = "[object Map]", objectTag$1 = "[object Object]", promiseTag = "[object Promise]", setTag$3 = "[object Set]", weakMapTag$1 = "[object WeakMap]";
+var dataViewTag$2 = "[object DataView]";
+var dataViewCtorString = toSource(DataView), mapCtorString = toSource(Map$1), promiseCtorString = toSource(Promise$1), setCtorString = toSource(Set$1), weakMapCtorString = toSource(WeakMap);
+var getTag = baseGetTag;
+if (DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag$2 || Map$1 && getTag(new Map$1()) != mapTag$3 || Promise$1 && getTag(Promise$1.resolve()) != promiseTag || Set$1 && getTag(new Set$1()) != setTag$3 || WeakMap && getTag(new WeakMap()) != weakMapTag$1) {
+  getTag = function(value) {
+    var result = baseGetTag(value), Ctor = result == objectTag$1 ? value.constructor : void 0, ctorString = Ctor ? toSource(Ctor) : "";
+    if (ctorString) {
+      switch (ctorString) {
+        case dataViewCtorString:
+          return dataViewTag$2;
+        case mapCtorString:
+          return mapTag$3;
+        case promiseCtorString:
+          return promiseTag;
+        case setCtorString:
+          return setTag$3;
+        case weakMapCtorString:
+          return weakMapTag$1;
+      }
+    }
+    return result;
+  };
+}
+var objectProto = Object.prototype;
+var hasOwnProperty = objectProto.hasOwnProperty;
+function initCloneArray(array2) {
+  var length = array2.length, result = new array2.constructor(length);
+  if (length && typeof array2[0] == "string" && hasOwnProperty.call(array2, "index")) {
+    result.index = array2.index;
+    result.input = array2.input;
+  }
+  return result;
+}
+var Uint8Array = root.Uint8Array;
+function cloneArrayBuffer(arrayBuffer) {
+  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
+  new Uint8Array(result).set(new Uint8Array(arrayBuffer));
+  return result;
+}
+function cloneDataView(dataView, isDeep) {
+  var buffer = cloneArrayBuffer(dataView.buffer);
+  return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
+}
+var reFlags = /\w*$/;
+function cloneRegExp(regexp) {
+  var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
+  result.lastIndex = regexp.lastIndex;
+  return result;
+}
+var symbolProto = Symbol$1 ? Symbol$1.prototype : void 0, symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
+function cloneSymbol(symbol) {
+  return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
+}
+function cloneTypedArray(typedArray, isDeep) {
+  var buffer = cloneArrayBuffer(typedArray.buffer);
+  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
+}
+var boolTag$1 = "[object Boolean]", dateTag$1 = "[object Date]", mapTag$2 = "[object Map]", numberTag$1 = "[object Number]", regexpTag$1 = "[object RegExp]", setTag$2 = "[object Set]", stringTag$1 = "[object String]", symbolTag$1 = "[object Symbol]";
+var arrayBufferTag$1 = "[object ArrayBuffer]", dataViewTag$1 = "[object DataView]", float32Tag$1 = "[object Float32Array]", float64Tag$1 = "[object Float64Array]", int8Tag$1 = "[object Int8Array]", int16Tag$1 = "[object Int16Array]", int32Tag$1 = "[object Int32Array]", uint8Tag$1 = "[object Uint8Array]", uint8ClampedTag$1 = "[object Uint8ClampedArray]", uint16Tag$1 = "[object Uint16Array]", uint32Tag$1 = "[object Uint32Array]";
+function initCloneByTag(object2, tag, isDeep) {
+  var Ctor = object2.constructor;
+  switch (tag) {
+    case arrayBufferTag$1:
+      return cloneArrayBuffer(object2);
+    case boolTag$1:
+    case dateTag$1:
+      return new Ctor(+object2);
+    case dataViewTag$1:
+      return cloneDataView(object2);
+    case float32Tag$1:
+    case float64Tag$1:
+    case int8Tag$1:
+    case int16Tag$1:
+    case int32Tag$1:
+    case uint8Tag$1:
+    case uint8ClampedTag$1:
+    case uint16Tag$1:
+    case uint32Tag$1:
+      return cloneTypedArray(object2);
+    case mapTag$2:
+      return new Ctor();
+    case numberTag$1:
+    case stringTag$1:
+      return new Ctor(object2);
+    case regexpTag$1:
+      return cloneRegExp(object2);
+    case setTag$2:
+      return new Ctor();
+    case symbolTag$1:
+      return cloneSymbol(object2);
+  }
+}
+var mapTag$1 = "[object Map]";
+function baseIsMap(value) {
+  return isObjectLike(value) && getTag(value) == mapTag$1;
+}
+var nodeIsMap = nodeUtil && nodeUtil.isMap;
+var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;
+var setTag$1 = "[object Set]";
+function baseIsSet(value) {
+  return isObjectLike(value) && getTag(value) == setTag$1;
+}
+var nodeIsSet = nodeUtil && nodeUtil.isSet;
+var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;
+var argsTag = "[object Arguments]", arrayTag = "[object Array]", boolTag = "[object Boolean]", dateTag = "[object Date]", errorTag = "[object Error]", funcTag = "[object Function]", genTag = "[object GeneratorFunction]", mapTag = "[object Map]", numberTag = "[object Number]", objectTag = "[object Object]", regexpTag = "[object RegExp]", setTag = "[object Set]", stringTag = "[object String]", symbolTag = "[object Symbol]", weakMapTag = "[object WeakMap]";
+var arrayBufferTag = "[object ArrayBuffer]", dataViewTag = "[object DataView]", float32Tag = "[object Float32Array]", float64Tag = "[object Float64Array]", int8Tag = "[object Int8Array]", int16Tag = "[object Int16Array]", int32Tag = "[object Int32Array]", uint8Tag = "[object Uint8Array]", uint8ClampedTag = "[object Uint8ClampedArray]", uint16Tag = "[object Uint16Array]", uint32Tag = "[object Uint32Array]";
+var cloneableTags = {};
+cloneableTags[argsTag] = cloneableTags[arrayTag] = cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] = cloneableTags[boolTag] = cloneableTags[dateTag] = cloneableTags[float32Tag] = cloneableTags[float64Tag] = cloneableTags[int8Tag] = cloneableTags[int16Tag] = cloneableTags[int32Tag] = cloneableTags[mapTag] = cloneableTags[numberTag] = cloneableTags[objectTag] = cloneableTags[regexpTag] = cloneableTags[setTag] = cloneableTags[stringTag] = cloneableTags[symbolTag] = cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] = cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
+cloneableTags[errorTag] = cloneableTags[funcTag] = cloneableTags[weakMapTag] = false;
+function baseClone(value, bitmask, customizer, key, object2, stack) {
+  var result;
+  if (customizer) {
+    result = object2 ? customizer(value, key, object2, stack) : customizer(value);
+  }
+  if (result !== void 0) {
+    return result;
+  }
+  if (!isObject(value)) {
+    return value;
+  }
+  var isArr = isArray(value);
+  if (isArr) {
+    result = initCloneArray(value);
+  } else {
+    var tag = getTag(value), isFunc = tag == funcTag || tag == genTag;
+    if (isBuffer(value)) {
+      return cloneBuffer(value);
+    }
+    if (tag == objectTag || tag == argsTag || isFunc && !object2) {
+      result = {};
+    } else {
+      if (!cloneableTags[tag]) {
+        return object2 ? value : {};
+      }
+      result = initCloneByTag(value, tag);
+    }
+  }
+  stack || (stack = new Stack());
+  var stacked = stack.get(value);
+  if (stacked) {
+    return stacked;
+  }
+  stack.set(value, result);
+  if (isSet(value)) {
+    value.forEach(function(subValue) {
+      result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));
+    });
+  } else if (isMap(value)) {
+    value.forEach(function(subValue, key2) {
+      result.set(key2, baseClone(subValue, bitmask, customizer, key2, value, stack));
+    });
+  }
+  var keysFunc = getAllKeysIn;
+  var props = isArr ? void 0 : keysFunc(value);
+  arrayEach(props || value, function(subValue, key2) {
+    if (props) {
+      key2 = subValue;
+      subValue = value[key2];
+    }
+    assignValue(result, key2, baseClone(subValue, bitmask, customizer, key2, value, stack));
+  });
+  return result;
+}
+function last(array2) {
+  var length = array2 == null ? 0 : array2.length;
+  return length ? array2[length - 1] : void 0;
+}
+function parent(object2, path) {
+  return path.length < 2 ? object2 : baseGet(object2, baseSlice(path, 0, -1));
+}
+function isNil(value) {
+  return value == null;
+}
+function baseUnset(object2, path) {
+  path = castPath(path, object2);
+  object2 = parent(object2, path);
+  return object2 == null || delete object2[toKey(last(path))];
+}
+function customOmitClone(value) {
+  return isPlainObject(value) ? void 0 : value;
+}
+var CLONE_DEEP_FLAG = 1, CLONE_FLAT_FLAG = 2, CLONE_SYMBOLS_FLAG = 4;
+var omit = flatRest(function(object2, paths) {
+  var result = {};
+  if (object2 == null) {
+    return result;
+  }
+  var isDeep = false;
+  paths = arrayMap(paths, function(path) {
+    path = castPath(path, object2);
+    isDeep || (isDeep = path.length > 1);
+    return path;
+  });
+  copyObject(object2, getAllKeysIn(object2), result);
+  if (isDeep) {
+    result = baseClone(result, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone);
+  }
+  var length = paths.length;
+  while (length--) {
+    baseUnset(result, paths[length]);
+  }
+  return result;
+});
+const poiCategoriesToID = {
+  SPORTS_CENTER: 7320,
+  STADIUM: 7374,
+  RESTAURANT: 7315,
+  CAFE_PUB: 9376,
+  HEALTH_CARE_SERVICE: 9663,
+  HOSPITAL: 7321,
+  HOSPITAL_POLYCLINIC: 7321,
+  DOCTOR: 9373,
+  SHOP: 9361,
+  MARIJUANA_DISPENSARY: 9364,
+  MARKET: 7332,
+  PUBLIC_AMENITY: 9932,
+  ROAD_TRAFFIC_CONTROL_CENTER: 7301,
+  POST_OFFICE: 7324,
+  COLLEGE_UNIVERSITY: 7377,
+  OPEN_PARKING_AREA: 7369,
+  CLUB_ASSOCIATION: 9937,
+  CAMPING_GROUND: 7360,
+  HOLIDAY_RENTAL: 7304,
+  VACATION_RENTAL: 7304,
+  AMUSEMENT_PARK: 9902,
+  RESIDENTIAL_ACCOMMODATION: 7303,
+  AGRICULTURAL_BUSINESS: 7335,
+  AGRICULTURE: 7335,
+  AIRPORT: 7383,
+  COMPANY: 9352,
+  NIGHTLIFE: 9379,
+  REPAIR_SHOP: 7310,
+  REPAIR_FACILITY: 7310,
+  HOTEL_MOTEL: 7314,
+  SCHOOL: 7372,
+  AUTOMOTIVE_DEALER: 9910,
+  MOVIE_THEATER: 7342,
+  CINEMA: 7342,
+  THEATER: 7318,
+  PARK_RECREATION_AREA: 9362,
+  PLACE_OF_WORSHIP: 7339,
+  IMPORTANT_TOURIST_ATTRACTION: 7376,
+  TOURIST_ATTRACTION: 7376,
+  TRAIL_SYSTEM: 7302,
+  TRAILS: 7302,
+  RAILWAY_STATION: 7380,
+  PUBLIC_TRANSPORT_STOP: 9942,
+  EXCHANGE: 9160,
+  MARINA: 7347,
+  WEIGH_STATION: 7359,
+  CAR_WASH: 9155,
+  LEISURE_CENTER: 9378,
+  ACCESS_GATEWAY: 7389,
+  GEOGRAPHIC_FEATURE: 8099,
+  URBAN_STATION: 7380004,
+  ADVENTURE_VEHICLE_TRAIL: 7302003,
+  ADVERTISING_COMPANY: 9352003,
+  AFGHAN_RESTAURANT: 7315081,
+  AFRICAN_RESTAURANT: 7315002,
+  AGRICULTURAL_SUPPLIES: 9361073,
+  AGRICULTURAL_TECHNOLOGY: 9352012,
+  AIRFIELD: 7383005,
+  AIRLINE_COMPANY: 9352034,
+  AIRLINE_ACCESS: 7389002,
+  ALGERIAN_RESTAURANT: 7315082,
+  AMBULANCE_UNIT: 9663005,
+  AMERICAN_RESTAURANT: 7315003,
+  AMPHITHEATER: 7318007,
+  AMUSEMENT_ARCADE: 9902002,
+  AMUSEMENT_PLACE: 9902004,
+  ANIMAL_SERVICES: 9361048,
+  ANIMAL_SHELTER: 9352045,
+  ANTIQUE_ART_SHOP: 9361049,
+  APARTMENT_RENTAL: 7304006,
+  AQUATIC_ZOO: 9927004,
+  ARABIAN_RESTAURANT: 7315083,
+  ARCH: 7376012,
+  ARGENTINIAN_RESTAURANT: 7315084,
+  ARMENIAN_RESTAURANT: 7315085,
+  ART_SCHOOL: 7372012,
+  ASHRAM: 7339007,
+  ASIAN_RESTAURANT: 7315062,
+  ATHLETICS_TRACK: 7374002,
+  ATV_DEALER: 9910009,
+  AUSTRALIAN_RESTAURANT: 7315086,
+  AUSTRIAN_RESTAURANT: 7315004,
+  AUTOMOBILE_COMPANY: 9352013,
+  AUTOMOBILE_MANUFACTURING: 9352041,
+  BAGS_LEATHERWEAR: 9361058,
+  BANQUET_ROOMS: 7315146,
+  BAR: 9379004,
+  BARBECUE_RESTAURANT: 7315005,
+  BASEBALL_PARK: 7374009,
+  BASKETBALL_ARENA: 7374012,
+  BASQUE_RESTAURANT: 7315087,
+  BATTLEFIELD: 9362002,
+  BAY: 8099016,
+  BEACH_CLUB: 9937002,
+  BEAUTY_SALON: 9361067,
+  BEAUTY_SUPPLIES: 9361050,
+  B_B_GUEST_HOUSE: 7314002,
+  BELGIAN_RESTAURANT: 7315006,
+  BETTING_STATION: 9361072,
+  BISTRO: 7315007,
+  BLOOD_BANK: 9663004,
+  BOAT_DEALER: 9910004,
+  BOAT_LAUNCHING_RAMP: 9362032,
+  BOATING_EQUIPMENT_ACCESSORIES: 9361083,
+  BODYSHOP: 7310002,
+  BOLIVIAN_RESTAURANT: 7315088,
+  BOOK_SHOP: 9361002,
+  BOSNIAN_RESTAURANT: 7315089,
+  BOWLING_CENTER: 9378002,
+  BRAZILIAN_RESTAURANT: 7315072,
+  BRIDGE: 7376010,
+  BRIDGE_TUNNEL_OPERATIONS: 9352035,
+  BRITISH_RESTAURANT: 7315008,
+  BUFFET_RESTAURANT: 7315142,
+  BUILDING: 7376002,
+  BULGARIAN_RESTAURANT: 7315090,
+  BUNGALOW_RENTAL: 7304004,
+  BURMESE_RESTAURANT: 7315091,
+  BUS_DEALER: 9910008,
+  BUS_CHARTER_COMPANY: 9352025,
+  BUS_LINES: 9352027,
+  BUS_STOP: 9942002,
+  BUSINESS_SERVICES: 9352039,
+  CABARET_THEATER: 7318006,
+  CABINS_LODGES: 7314007,
+  CABLE_TELEPHONE_COMPANY: 9352040,
+  CAFE: 9376002,
+  CAFETERIA: 7315147,
+  CALIFORNIAN_RESTAURANT: 7315009,
+  CAMBODIAN_RESTAURANT: 7315092,
+  CANADIAN_RESTAURANT: 7315010,
+  CAPE: 8099020,
+  CAR_DEALER: 9910002,
+  CAR_GLASS_REPLACEMENT_SHOP: 7310003,
+  CARAVAN_SITE: 7360003,
+  CARIBBEAN_RESTAURANT: 7315011,
+  CATERING_SERVICES: 9352043,
+  CAVE: 8099003,
+  C_DS_DVD_VIDEOS: 9361003,
+  VIDEO_RENTAL_SHOP: 9361044,
+  CEMETERY: 9362003,
+  CHALET_RENTAL: 7304005,
+  CHEMICAL_COMPANY: 9352014,
+  CHICKEN_RESTAURANT: 7315070,
+  CHILD_CARE_FACILITY: 7372003,
+  CHILEAN_RESTAURANT: 7315093,
+  CHINESE_RESTAURANT: 7315012,
+  CHRISTMAS_HOLIDAY_SHOP: 9361082,
+  CHURCH: 7339002,
+  CLEANING_SERVICES: 9352029,
+  CHILDRENS_CLOTHES: 9361004,
+  FOOTWEAR_SHOE_REPAIRS: 9361005,
+  CLOTHING_SHOP: 9361006,
+  MENS_CLOTHING: 9361007,
+  SPECIALTY_CLOTHING_SHOP: 9361079,
+  WOMENS_CLOTHING: 9361008,
+  COACH_STOP: 9942005,
+  COCKTAIL_BAR: 9379006,
+  COFFEE_SHOP: 9376006,
+  COLOMBIAN_RESTAURANT: 7315094,
+  COMEDY_CLUB: 9379009,
+  COMPUTER_DATA_SERVICES: 9352004,
+  SOFTWARE_COMPANY: 9352005,
+  CONCERT_HALL: 7318002,
+  CONDOMINIUM_COMPLEX: 7303006,
+  CONSTRUCTION_COMPANY: 9352032,
+  CONSTRUCTION_MATERIAL_EQUIPMENT: 9361042,
+  CONVENIENCE_STORE: 9361009,
+  CORSICAN_RESTAURANT: 7315095,
+  COTTAGE_RENTAL: 7304002,
+  COVE: 8099017,
+  CREOLE_RESTAURANT: 7315063,
+  CREPERIE: 7315013,
+  CRICKET_GROUND: 7374003,
+  CUBAN_RESTAURANT: 7315096,
+  CULINARY_SCHOOL: 7372015,
+  CYPRIOT_RESTAURANT: 7315097,
+  CZECH_RESTAURANT: 7315068,
+  DAM: 7376007,
+  DANCE_STUDIO_SCHOOL: 9378003,
+  DANISH_RESTAURANT: 7315098,
+  DELICATESSEN: 9361060,
+  DINNER_THEATER: 7318008,
+  DISCO_CLUB: 9379002,
+  DIVERSIFIED_FINANCIALS: 9352006,
+  DOMINICAN_RESTAURANT: 7315099,
+  DONGBEI_RESTAURANT: 7315057,
+  DOUGHNUT_RESTAURANT: 7315079,
+  DRIVE_THROUGH_BOTTLE_SHOP: 9361076,
+  DRIVE_IN_MOVIES: 7342003,
+  DRIVING_SCHOOL: 7372016,
+  DRUG_STORE: 9361051,
+  DRY_CLEANER: 9361010,
+  DUNE: 8099005,
+  DUTCH_RESTAURANT: 7315014,
+  EGYPTIAN_RESTAURANT: 7315100,
+  ELECTRICAL_APPLIANCES_SHOP: 9361052,
+  CAMERAS_PHOTOGRAPHY: 9361011,
+  COMPUTER_COMPUTER_SUPPLIES: 9361012,
+  CONSUMER_ELECTRONICS: 9361013,
+  OFFICE_EQUIPMENT: 9361014,
+  ENGLISH_RESTAURANT: 7315101,
+  EQUIPMENT_RENTAL: 9352038,
+  EROTIC_RESTAURANT: 7315132,
+  ETHIOPIAN_RESTAURANT: 7315102,
+  EXOTIC_RESTAURANT: 7315133,
+  FACTORY_OUTLET: 9361016,
+  FAIRGROUND: 9362017,
+  FARM: 7335004,
+  FARMERS_MARKET: 7332004,
+  FAST_FOOD: 7315015,
+  PHILIPPINE_RESTAURANT: 7315016,
+  FINNISH_RESTAURANT: 7315104,
+  FISHING_HUNTING_AREA: 9362016,
+  FITNESS_CLUB_CENTER: 7320002,
+  FLATS_APARTMENT_COMPLEX: 7303003,
+  FLORISTS: 9361017,
+  FLYING_CLUB: 9378004,
+  FONDUE_RESTAURANT: 7315134,
+  BAKERY: 9361018,
+  BUTCHER: 9361019,
+  FISHMONGER: 9361020,
+  FOOD_MARKET: 9361021,
+  GREENGROCER: 9361022,
+  GROCERY_STORE: 9361023,
+  OTHER_FOOD_SHOPS: 9361024,
+  WINE_SPIRITS: 9361025,
+  FOOTBALL_STADIUM: 7374010,
+  FOREST_AREA: 9362015,
+  FRENCH_RESTAURANT: 7315017,
+  FUNERAL_SERVICE_MORTUARIES: 9352036,
+  FURNITURE_HOME_FURNISHINGS: 9361054,
+  FUSION_RESTAURANT: 7315071,
+  CAR_REPAIR_AND_SERVICE: 7310004,
+  GENERAL_PRACTITIONER: 9373002,
+  GERMAN_RESTAURANT: 7315018,
+  GIFTS_CARDS_NOVELTIES_SOUVENIRS: 9361026,
+  GLASSWARE_CERAMIC_SHOP: 9361055,
+  GOLD_EXCHANGE: 9160003,
+  GREEK_RESTAURANT: 7315019,
+  GRILL_RESTAURANT: 7315020,
+  GUANGDONG_RESTAURANT: 7315054,
+  GURUDWARA: 7339006,
+  HAIRDRESSER: 9361027,
+  HAMBURGER_RESTAURANT: 7315069,
+  HARBOR: 8099018,
+  HARDWARE_STORE: 9361069,
+  HAWAIIAN_RESTAURANT: 7315021,
+  HIGH_SCHOOL: 7372006,
+  HIKING_TRAIL: 7302004,
+  HILL: 8099025,
+  HISTORIC_SITE: 9362004,
+  HISTORICAL_PARK: 9362005,
+  HOBBY_SHOP: 9361053,
+  HOCKEY_CLUB: 9937003,
+  HOME_APPLIANCE_REPAIR: 9352044,
+  HORSE_RACING_TRACK: 7374005,
+  HORSE_RIDING_CENTER: 7320003,
+  HORTICULTURE: 7335002,
+  HOSPITAL_FOR_WOMEN_AND_CHILDREN: 7321005,
+  HOSPITAL_OF_CHINESE_MEDICINE: 7321004,
+  HOSTEL: 7314004,
+  HOT_POT_RESTAURANT: 7315058,
+  HOTEL: 7314003,
+  CARPET_FLOOR_COVERINGS: 9361028,
+  CURTAINS_TEXTILES: 9361029,
+  DO_IT_YOURSELF_CENTERS: 9361030,
+  HOUSE_GARDEN_FURNITURE_FITTINGS: 9361031,
+  GARDEN_CENTERS_SERVICES: 9361032,
+  GLASS_WINDOWS_STORE: 9361080,
+  KITCHENS_BATHROOMS: 9361033,
+  LIGHTING_SHOPS: 9361034,
+  PAINTING_DECORATING: 9361035,
+  HUNAN_RESTAURANT: 7315052,
+  HUNGARIAN_RESTAURANT: 7315022,
+  ICE_CREAM_PARLOR: 7315078,
+  ICE_HOCKEY_ARENA: 7374008,
+  IMPORT_EXPORT_AND_DISTRIBUTION: 9352042,
+  INDIAN_RESTAURANT: 7315023,
+  INDONESIAN_RESTAURANT: 7315024,
+  INFORMAL_MARKET: 7332002,
+  INSURANCE_COMPANY: 9352007,
+  INTERNATIONAL_RESTAURANT: 7315073,
+  INTERNATIONAL_RAILROAD_STATION: 7380002,
+  INTERNET_CAFE: 9376004,
+  INVESTMENT_ADVISOR: 9352037,
+  IRANIAN_RESTAURANT: 7315105,
+  IRISH_RESTAURANT: 7315065,
+  ISLAND: 8099022,
+  ISRAELI_RESTAURANT: 7315106,
+  ITALIAN_RESTAURANT: 7315025,
+  JAMAICAN_RESTAURANT: 7315066,
+  JAPANESE_RESTAURANT: 7315026,
+  JAZZ_CLUB: 9379008,
+  JEWELRY_CLOCKS_WATCHES: 9361036,
+  JEWISH_RESTAURANT: 7315027,
+  JUNIOR_COLLEGE_COMMUNITY_COLLEGE: 7377003,
+  KARAOKE_CLUB: 9379010,
+  KOREAN_RESTAURANT: 7315028,
+  KOSHER_RESTAURANT: 7315067,
+  LAGOON: 8099019,
+  LAKESHORE: 9362006,
+  LANGUAGE_SCHOOL: 7372010,
+  LATIN_AMERICAN_RESTAURANT: 7315029,
+  LAUNDRY: 9361045,
+  LEBANESE_RESTAURANT: 7315030,
+  LEGAL_SERVICES: 9352023,
+  LOCAL_POST_OFFICE: 7324003,
+  LOCAL_SPECIALITIES_SHOP: 9361056,
+  LOCALE: 8099027,
+  LOTTERY_SHOP: 9361071,
+  LUXEMBOURGIAN_RESTAURANT: 7315107,
+  MACROBIOTIC_RESTAURANT: 7315135,
+  MAGHRIB_RESTAURANT: 7315108,
+  DELIVERY_SERVICE: 9352008,
+  MALTESE_RESTAURANT: 7315031,
+  MANUFACTURING_COMPANY: 9352011,
+  MARINE_ELECTRONIC_EQUIPMENT: 9361065,
+  MARSH: 8099023,
+  MAURITIAN_RESTAURANT: 7315109,
+  MAUSOLEUM_GRAVE: 7376011,
+  MECHANICAL_ENGINEERING: 9352016,
+  MEDICAL_SUPPLIES_EQUIPMENT: 9361043,
+  MEDITERRANEAN_RESTAURANT: 7315032,
+  MEMORIAL: 9362007,
+  SUBWAY_STATION: 7380005,
+  MEXICAN_RESTAURANT: 7315033,
+  MICROBREWERY: 9376007,
+  MIDDLE_EASTERN_RESTAURANT: 7315034,
+  MIDDLE_SCHOOL: 7372014,
+  MILITARY_AIRPORT: 7383004,
+  MINERAL_HOT_SPRINGS: 8099021,
+  MINING_COMPANY: 9352031,
+  MOBILE_PHONE_SHOP: 9361075,
+  MONGOLIAN_RESTAURANT: 7315110,
+  MONUMENT: 7376003,
+  MOROCCAN_RESTAURANT: 7315074,
+  MOSQUE: 7339003,
+  MOTEL: 7314006,
+  MOTOR_RACING_STADIUM: 7374011,
+  MOTORCYCLE_DEALER: 9910003,
+  MOTORCYCLE_REPAIR: 7310008,
+  MOUNTAIN_BIKE_TRAIL: 7302002,
+  MOUNTAIN_PEAK: 8099002,
+  MOVING_STORAGE_COMPANY: 9352033,
+  MULTI_PURPOSE_STADIUM: 7374006,
+  MUSIC_CENTER: 7318003,
+  MUSIC_INSTRUMENTS_STORE: 9361059,
+  MUSSELS_RESTAURANT: 7315136,
+  NAIL_SALON: 9361068,
+  NATIONAL_RAILROAD_STATION: 7380003,
+  NATURAL_RECREATION_ATTRACTION: 9362030,
+  NEPALESE_RESTAURANT: 7315111,
+  NETBALL_STADIUM: 7374014,
+  NEWSAGENTS_TOBACCONISTS: 9361037,
+  NORWEGIAN_RESTAURANT: 7315112,
+  OASIS: 8099011,
+  OBSERVATORY: 7376005,
+  OEM: 9352021,
+  OIL_NATURAL_GAS: 9352030,
+  OPERA_HOUSE: 7318004,
+  OPTICIAN: 9361038,
+  ORGANIC_FOOD_RESTAURANT: 7315075,
+  ORIENTAL_RESTAURANT: 7315035,
+  OTHER_REPAIR_SHOPS: 7310005,
+  OTHER_WINTER_SPORT: 9362025,
+  PAGODA: 7339008,
+  PAKISTANI_RESTAURANT: 7315127,
+  PAN: 8099009,
+  PARK: 9362008,
+  PARKWAY: 9362009,
+  PASSENGER_TRANSPORT_TICKET_OFFICE: 9932002,
+  PAWN_SHOP: 9361070,
+  PEDESTRIAN_SUBWAY: 9932003,
+  PERSONAL_CARE_FACILITY: 9663003,
+  PERSONAL_SERVICE: 9663002,
+  PERUVIAN_RESTAURANT: 7315061,
+  PET_SUPPLIES: 9361064,
+  PHARMACEUTICAL_COMPANY: 9352018,
+  PHOTO_LAB_DEVELOPMENT: 9361046,
+  PHOTOCOPY_SHOP: 9361047,
+  PICNIC_AREA: 9362033,
+  PIZZERIA: 7315036,
+  PLAIN_FLAT: 8099007,
+  PLANETARIUM: 7376006,
+  PLATEAU: 8099008,
+  POLISH_RESTAURANT: 7315037,
+  POLYNESIAN_RESTAURANT: 7315129,
+  PORTUGUESE_RESTAURANT: 7315038,
+  PRE_SCHOOL: 7372004,
+  PRESERVE: 9362010,
+  PRIMARY_PRODUCER: 7335003,
+  PRIMARY_SCHOOL: 7372005,
+  PRIVATE_AIRPORT: 7383003,
+  PRIVATE_CLUB: 9379003,
+  PROVENCAL_RESTAURANT: 7315130,
+  PUB: 9376003,
+  PUB_FOOD: 7315039,
+  PUBLIC_MARKET: 7332003,
+  PUBLIC_AIRPORT: 7383002,
+  PUBLIC_CALL_BOX: 9932004,
+  PUBLIC_HEALTH_TECHNOLOGY_COMPANY: 9352017,
+  PUBLISHING_TECHNOLOGIES: 9352019,
+  QUARRY: 8099026,
+  RACE_TRACK: 7374013,
+  RAILROAD_SIDING: 7380006,
+  RAPIDS: 8099015,
+  REAL_ESTATE_COMPANY: 9352009,
+  REAL_ESTATE_AGENT: 9361015,
+  RECREATION_AREA: 9362011,
+  RECREATIONAL_CAMPING_GROUND: 7360002,
+  RECREATIONAL_VEHICLE_DEALER: 9910005,
+  RECYCLING_SHOP: 9361057,
+  REEF: 8099014,
+  RESERVOIR: 8099013,
+  RESIDENTIAL_ESTATE: 7303004,
+  RESORT: 7314005,
+  REST_CAMP: 7314008,
+  RETAIL_OUTLET: 9361063,
+  RETIREMENT_COMMUNITY: 7303002,
+  RIDGE: 8099004,
+  RIVER_CROSSING: 8099024,
+  ROAD_RESCUE: 9932006,
+  ROADSIDE_RESTAURANT: 7315041,
+  ROCK_CLIMBING_TRAIL: 7302006,
+  ROCKS: 8099012,
+  RUGBY_GROUND: 7374007,
+  ROMANIAN_RESTAURANT: 7315131,
+  RUSSIAN_RESTAURANT: 7315040,
+  SALAD_BAR: 7315143,
+  CAR_ACCESSORIES: 7310006,
+  SANDWICH_RESTAURANT: 7315042,
+  SAUNA_SOLARIUM_MASSAGE: 9378005,
+  SAVINGS_INSTITUTION: 9352010,
+  SAVOY_RESTAURANT: 7315113,
+  SCANDINAVIAN_RESTAURANT: 7315114,
+  SCOTTISH_RESTAURANT: 7315115,
+  SEAFOOD: 7315043,
+  SEASHORE: 9362013,
+  SECURED_ENTRANCE: 7389004,
+  SECURITY_PRODUCTS: 9361078,
+  SENIOR_HIGH_SCHOOL: 7372007,
+  SERVICE_COMPANY: 9352002,
+  SHANDONG_RESTAURANT: 7315053,
+  SHANGHAI_RESTAURANT: 7315055,
+  SHOPPING_SERVICE: 9361062,
+  SICHUAN_RESTAURANT: 7315056,
+  SICILIAN_RESTAURANT: 7315116,
+  SKI_RESORT: 9362026,
+  SLAVIC_RESTAURANT: 7315117,
+  SLOVAK_RESTAURANT: 7315080,
+  SNACKS_RESTAURANT: 7315139,
+  SNOOKER_POOL_BILLIARD: 9378006,
+  SOCCER_STADIUM: 7374004,
+  SOUL_FOOD: 7315064,
+  SOUP_RESTAURANT: 7315140,
+  SPANISH_RESTAURANT: 7315044,
+  SPECIAL_HOSPITAL: 7321003,
+  SPECIAL_SCHOOL: 7372013,
+  SPECIALIST: 9373003,
+  SPECIALTY_FOODS: 9361061,
+  SPORT_SCHOOL: 7372011,
+  SPORTS_EQUIPMENT_CLOTHING: 9361039,
+  STAMP_SHOP: 9361074,
+  STATION_ACCESS: 7389003,
+  STATUE: 7376013,
+  STEAK_HOUSE: 7315045,
+  STOCK_EXCHANGE: 9160002,
+  SUDANESE_RESTAURANT: 7315118,
+  SUPERMARKETS_HYPERMARKETS: 7332005,
+  SURINAMESE_RESTAURANT: 7315046,
+  SUSHI_RESTAURANT: 7315148,
+  SWEDISH_RESTAURANT: 7315119,
+  SWISS_RESTAURANT: 7315047,
+  SYNAGOG: 7339004,
+  SYRIAN_RESTAURANT: 7315120,
+  TAILOR_SHOP: 9361077,
+  TAIWANESE_RESTAURANT: 7315059,
+  TAKEOUT_FOOD: 7315145,
+  TAPAS_RESTAURANT: 7315076,
+  TAX_SERVICES: 9352022,
+  TAXI_STAND: 9942003,
+  TAXI_LIMOUSINE_SHUTTLE_SERVICE: 9352026,
+  TEA_HOUSE: 9376005,
+  TECHNICAL_SCHOOL: 7372009,
+  TELECOMMUNICATIONS: 9352020,
+  TEMPLE: 7339005,
+  TEPPANYAKI_RESTAURANT: 7315121,
+  THAI_RESTAURANT: 7315048,
+  THEMATIC_SPORT_CENTER: 7320005,
+  TIBETAN_RESTAURANT: 7315122,
+  PUBLIC_TOILET: 9932005,
+  TOWER: 7376009,
+  TOWNHOUSE_COMPLEX: 7303005,
+  TOYS_GAMES_SHOP: 9361040,
+  TRAFFIC_SERVICE_CENTER: 7301002,
+  TRAFFIC_CONTROL_DEPARTMENT: 7301002,
+  STREETCAR_STOP: 9942004,
+  TRANSPORT_COMPANY: 9352024,
+  TRAVEL_AGENT: 9361041,
+  TRUCK_DEALER: 9910006,
+  TRUCK_REPAIR_AND_SERVICE: 7310009,
+  TRUCK_WASH: 9155003,
+  TUNISIAN_RESTAURANT: 7315123,
+  TUNNEL: 7376008,
+  TURKISH_RESTAURANT: 7315049,
+  TIRE_SERVICE: 7310007,
+  URUGUAYAN_RESTAURANT: 7315124,
+  VALLEY: 8099006,
+  VAN_DEALER: 9910007,
+  VARIETY_STORE: 9361081,
+  VEGETARIAN_RESTAURANT: 7315050,
+  VENEZUELAN_RESTAURANT: 7315125,
+  VIETNAMESE_RESTAURANT: 7315051,
+  VILLA_RENTAL: 7304003,
+  VOCATIONAL_SCHOOL: 7372008,
+  WATER_HOLE: 7376014,
+  WEDDING_SERVICES: 9352046,
+  WEIGH_SCALES: 7359003,
+  WELL: 8099010,
+  WELSH_RESTAURANT: 7315126,
+  WESTERN_RESTAURANT: 7315060,
+  WHOLESALE_CLUB: 9361066,
+  WILDERNESS_AREA: 9362014,
+  WILDLIFE_PARK: 9927005,
+  WINE_BAR: 9379007,
+  YACHT_BASIN: 7347003,
+  YOGURT_JUICE_BAR: 7315149,
+  ZOO: 9927003,
+  ZOOS_ARBORETA_BOTANICAL_GARDEN: 9927,
+  ELECTRONICS_COMPANY: 9352015,
+  RIVER_SCENIC_AREA: 9362036,
+  HORSE_RIDING_TRAIL: 7302005,
+  NATURAL_TOURIST_ATTRACTION: 7376004,
+  OPEN_CAR_PARKING_AREA: 7369002,
+  MEDICINAL_MARIJUANA_DISPENSARY: 9364002,
+  RECREATIONAL_MARIJUANA_DISPENSARY: 9364003,
+  ICE_SKATING_RINK: 9360,
+  TENNIS_COURT: 9369,
+  GOLF_COURSE: 9911,
+  WATER_SPORT: 9371,
+  SWIMMING_POOL: 7338,
+  RESTAURANT_AREA: 9359,
+  DENTIST: 9374,
+  VETERINARIAN: 9375,
+  PHARMACY: 7326,
+  EMERGENCY_ROOM: 9956,
+  DEPARTMENT_STORE: 7327,
+  SHOPPING_CENTER: 7373,
+  FIRE_STATION_BRIGADE: 7392,
+  NON_GOVERNMENTAL_ORGANIZATION: 9152,
+  PRISON_CORRECTIONAL_FACILITY: 9154,
+  EMBASSY: 7365,
+  LIBRARY: 9913,
+  TRANSPORT_AUTHORITY_VEHICLE_REGISTRATION: 9151,
+  WELFARE_ORGANIZATION: 9153,
+  NATIVE_RESERVATION: 9389,
+  COURTHOUSE: 9363,
+  POLICE_STATION: 7322,
+  PRIMARY_RESOURCE_UTILITY: 9150,
+  GOVERNMENT_OFFICE: 7367,
+  MILITARY_INSTALLATION: 9388,
+  RENT_A_CAR_PARKING: 9930,
+  MUSEUM: 7317,
+  INDUSTRIAL_BUILDING: 9383,
+  PARKING_GARAGE: 7313,
+  TOURIST_INFORMATION_OFFICE: 7316,
+  MEDIA_FACILITY: 9158,
+  WINERY: 7349,
+  EMERGENCY_MEDICAL_SERVICE: 7391,
+  CASINO: 7341,
+  MANUFACTURING_FACILITY: 9156,
+  COMMERCIAL_BUILDING: 9382,
+  CULTURAL_CENTER: 7319,
+  EXHIBITION_CONVENTION_CENTER: 9377,
+  RENT_A_CAR_FACILITY: 7312,
+  TRUCK_STOP: 7358,
+  ADVENTURE_SPORTS_FACILITY: 7305,
+  ADVENTURE_SPORTS_VENUE: 7305,
+  REST_AREA: 7395,
+  RESEARCH_FACILITY: 9157,
+  COURIER_DROP_BOX: 7388,
+  GAS_STATION: 7311,
+  PETROL_STATION: 7311,
+  FUEL_FACILITIES: 7311,
+  MOTORING_ORGANIZATION_OFFICE: 7368,
+  CASH_DISPENSER: 7397,
+  ATM: 7397,
+  COMMUNITY_CENTER: 7363,
+  BEACH: 9357,
+  PORT_WAREHOUSE_FACILITY: 9159,
+  ELECTRIC_VEHICLE_STATION: 7309,
+  SCENIC_PANORAMIC_VIEW: 7337,
+  ENTERTAINMENT: 9900,
+  BUSINESS_PARK: 7378,
+  BANK: 7328,
+  HELIPAD_HELICOPTER_LANDING: 7308,
+  CHECKPOINT: 9955,
+  FRONTIER_CROSSING: 7366,
+  MOUNTAIN_PASS: 9935,
+  TOLL_GATE: 7375,
+  FERRY_TERMINAL: 7352
+};
+const appendCommonParams = (urlParams, params) => {
+  urlParams.append("apiVersion", String(params.apiVersion));
+  urlParams.append("key", params.apiKey);
+  params.language && urlParams.append("language", params.language);
+};
+const appendByRepeatingParamName = (urlParams, paramName, paramArray) => {
+  for (const param of paramArray || []) {
+    urlParams.append(paramName, param);
+  }
+};
+const appendByJoiningParamValue = (urlParams, name, values) => {
+  if (Array.isArray(values) && values.length > 0) {
+    urlParams.append(name, values.join(","));
+  }
+};
+const appendOptionalParam = (urlParams, name, value) => {
+  !isNil(value) && urlParams.append(name, String(value));
+};
+const appendLatLonParamsFromPosition = (urlParams, hasLngLat) => {
+  const position = core.getPosition(hasLngLat);
+  if (position) {
+    urlParams.append("lat", String(position[1]));
+    urlParams.append("lon", String(position[0]));
+  }
+};
+const mapPOICategoriesToIDs = (poiCategories) => {
+  return poiCategories.map((poiCategory) => {
+    if (typeof poiCategory !== "number") {
+      return poiCategoriesToID[poiCategory];
+    }
+    return poiCategory;
+  });
+};
+const PLACES_URL_PATH = "/maps/orbis/places";
+const appendCommonSearchParams = (searchUrl, params) => {
+  const urlParams = searchUrl.searchParams;
+  appendCommonParams(urlParams, params);
+  appendOptionalParam(urlParams, "limit", params.limit);
+  appendLatLonParamsFromPosition(urlParams, params.position);
+  appendByJoiningParamValue(urlParams, "fuelSet", params.fuelTypes);
+  appendByJoiningParamValue(urlParams, "idxSet", params.indexes);
+  appendByJoiningParamValue(urlParams, "brandSet", params.poiBrands);
+  params.poiCategories && appendByJoiningParamValue(urlParams, "categorySet", mapPOICategoriesToIDs(params.poiCategories));
+  appendByJoiningParamValue(urlParams, "connectorSet", params.connectors);
+  appendByJoiningParamValue(urlParams, "mapcodes", params.mapcodes);
+  appendByJoiningParamValue(urlParams, "extendedPostalCodesFor", params.extendedPostalCodesFor);
+  appendOptionalParam(urlParams, "minPowerKW", params.minPowerKW);
+  appendOptionalParam(urlParams, "maxPowerKW", params.maxPowerKW);
+  appendOptionalParam(urlParams, "view", params.view);
+  appendOptionalParam(urlParams, "openingHours", params.openingHours);
+  appendOptionalParam(urlParams, "timeZone", params.timeZone);
+  appendOptionalParam(urlParams, "relatedPois", params.relatedPois);
+  appendByJoiningParamValue(urlParams, "entityTypeSet", params.geographyTypes);
+};
+const buildUrlBasePath$9 = (mergedOptions) => mergedOptions.customServiceBaseURL || `${mergedOptions.commonBaseURL}${PLACES_URL_PATH}/autocomplete/${mergedOptions.query}.json`;
+const buildAutocompleteSearchRequest = (params) => {
+  const url = new URL(`${buildUrlBasePath$9(params)}`);
+  const urlParams = url.searchParams;
+  params.language = params.language ?? "en-GB";
+  appendCommonParams(urlParams, params);
+  appendOptionalParam(urlParams, "limit", params.limit);
+  appendLatLonParamsFromPosition(urlParams, params.position);
+  appendByJoiningParamValue(urlParams, "countrySet", params.countries);
+  appendOptionalParam(urlParams, "radius", params.radiusMeters);
+  appendByJoiningParamValue(urlParams, "resultSet", params.resultType);
+  return url;
+};
+const csvLatLngToPosition = (csv) => {
+  const splitLatLng = csv.split(",");
+  return [Number(splitLatLng[1]), Number(splitLatLng[0])];
+};
+const positionToCSVLatLon = (position) => `${position[1]},${position[0]}`;
+const hasTopLeftPoint = (bbox) => {
+  return bbox.topLeftPoint !== void 0;
+};
+const apiToGeoJSONBBox = (apiBBox) => {
+  let westSouth;
+  let eastNorth;
+  if (hasTopLeftPoint(apiBBox)) {
+    westSouth = [apiBBox.topLeftPoint.lon, apiBBox.btmRightPoint.lat];
+    eastNorth = [apiBBox.btmRightPoint.lon, apiBBox.topLeftPoint.lat];
+  } else {
+    westSouth = csvLatLngToPosition(apiBBox.southWest);
+    eastNorth = csvLatLngToPosition(apiBBox.northEast);
+  }
+  return [westSouth[0], westSouth[1], eastNorth[0], eastNorth[1]];
+};
+const latLonAPIToPosition = (point) => {
+  return [point.lon, point.lat];
+};
+const parseAutocompleteSearchResponse = (apiResponse) => {
+  const { position, ...geoBias } = apiResponse.context.geoBias || {};
+  return {
+    ...apiResponse,
+    context: {
+      ...apiResponse.context,
+      geoBias: {
+        ...position && { position: latLonAPIToPosition(position) },
+        radiusMeters: geoBias.radius
+      }
+    }
+  };
+};
+const autocompleteSearchTemplate = {
+  requestValidation: { schema: autocompleteSearchRequestSchema },
+  buildRequest: buildAutocompleteSearchRequest,
+  sendRequest: get,
+  parseResponse: parseAutocompleteSearchResponse
+};
+const autocompleteSearch = async (params, customTemplate) => callService(params, { ...autocompleteSearchTemplate, ...customTemplate }, "Autocomplete");
+const customize$8 = {
+  autocompleteSearch,
+  buildAutocompleteSearchRequest,
+  parseAutocompleteSearchResponse,
+  autocompleteSearchTemplate
+};
+const evChargingStationsAvailabilityRequestSchema = object({
+  id: string()
+});
+const parseEVChargingStationsAvailabilityResponseError = (apiError, serviceName) => {
+  const errorMessage = apiError.data?.detailedError?.message ?? apiError.message;
+  return new SDKServiceError(errorMessage, serviceName, apiError.status);
+};
+const buildUrlBasePath$8 = (params) => params.customServiceBaseURL ?? `${params.commonBaseURL}${PLACES_URL_PATH}/ev/id`;
+const buildEVChargingStationsAvailabilityRequest = (params) => {
+  const url = new URL(buildUrlBasePath$8(params));
+  const urlParams = url.searchParams;
+  appendCommonParams(urlParams, params);
+  urlParams.append("id", params.id);
+  return url;
+};
+const toChargingPointAvailability = (chargingStations) => {
+  const availability = { count: 0, statusCounts: {} };
+  for (const station of chargingStations) {
+    for (const chargingPoint of station.chargingPoints) {
+      availability.count++;
+      availability.statusCounts[chargingPoint.status] = (availability.statusCounts[chargingPoint.status] || 0) + 1;
+    }
+  }
+  return availability;
+};
+const areEqual = (connectorA, connectorB) => connectorA.type === connectorB.type && connectorA.ratedPowerKW === connectorB.ratedPowerKW;
+const addConnectorStatus = (connectors, status, availabilities) => {
+  if (!connectors) {
+    return;
+  }
+  for (const connector of connectors) {
+    const existingAvailability = availabilities.find(
+      (connectorAvailability) => areEqual(connector, connectorAvailability.connector)
+    );
+    if (existingAvailability) {
+      existingAvailability.count++;
+      if (status) {
+        const statusCounts = existingAvailability.statusCounts;
+        statusCounts[status] = (statusCounts[status] || 0) + 1;
+      }
+    } else {
+      availabilities.push({
+        connector,
+        count: 1,
+        statusCounts: status ? {
+          [status]: 1
+        } : {}
+      });
+    }
+  }
+};
+const toConnectorCounts = (connectors) => {
+  const availabilities = [];
+  addConnectorStatus(connectors, void 0, availabilities);
+  return availabilities;
+};
+const toConnectorBasedAvailabilities = (chargingStations) => {
+  const availabilities = [];
+  for (const station of chargingStations) {
+    for (const chargingPoint of station.chargingPoints) {
+      addConnectorStatus(chargingPoint.connectors, chargingPoint.status, availabilities);
+    }
+  }
+  return availabilities;
+};
+const parseYyyymmddDate = (dateYyyymmdd) => {
+  const splitDate = dateYyyymmdd.split("-");
+  return {
+    year: Number.parseInt(splitDate[0]),
+    month: Number.parseInt(splitDate[1]),
+    day: Number.parseInt(splitDate[2])
+  };
+};
+const parseMoment = (momentApi) => {
+  const { year, month, day } = parseYyyymmddDate(momentApi.date);
+  return {
+    dateYYYYMMDD: momentApi.date,
+    year,
+    month,
+    day,
+    hour: momentApi.hour,
+    minute: momentApi.minute,
+    date: new Date(year, month - 1, day, momentApi.hour, momentApi.minute)
+  };
+};
+const alwaysOpenInThisPeriod = (timeRanges) => timeRanges.length === 1 && timeRanges[0].start.hour === 0 && timeRanges[0].end.hour === 0;
+const parseOpeningHours = (openingHoursApi) => {
+  const timeRanges = openingHoursApi.timeRanges.map(
+    (timeRangeApi) => ({
+      start: parseMoment(timeRangeApi.startTime),
+      end: parseMoment(timeRangeApi.endTime)
+    })
+  );
+  return {
+    mode: openingHoursApi.mode,
+    timeRanges,
+    alwaysOpenThisPeriod: alwaysOpenInThisPeriod(timeRanges)
+  };
+};
+const parseSearchAPIResult = (result) => {
+  const { position, entryPoints, poi, id, dist, boundingBox, chargingPark, ...rest } = result;
+  const connectors = chargingPark?.connectors?.map((connector) => ({
+    ...omit(connector, "connectorType"),
+    type: connector.connectorType
+  }));
+  return {
+    ...core.toPointFeature(latLonAPIToPosition(position)),
+    ...boundingBox && { bbox: apiToGeoJSONBBox(boundingBox) },
+    id,
+    properties: {
+      ...omit(rest, "viewport"),
+      ...dist && { distance: dist },
+      ...entryPoints && {
+        entryPoints: entryPoints.map((entrypoint) => ({
+          ...entrypoint,
+          position: latLonAPIToPosition(entrypoint.position)
+        }))
+      },
+      ...connectors && {
+        chargingPark: {
+          ...chargingPark,
+          connectors,
+          connectorCounts: toConnectorCounts(connectors)
+        }
+      },
+      poi: {
+        ...omit(poi, "categorySet", "openingHours"),
+        brands: poi?.brands?.map((brand) => brand.name) ?? [],
+        categoryIds: poi?.categorySet?.map((category) => category.id) ?? [],
+        ...poi?.openingHours && { openingHours: parseOpeningHours(poi?.openingHours) }
+      }
+    }
+  };
+};
+const parseSummaryAPI = (summary) => {
+  const { geoBias, ...rest } = summary;
+  return {
+    ...geoBias && { geoBias: latLonAPIToPosition(geoBias) },
+    ...rest
+  };
+};
+const parseEVChargingStationsAvailabilityResponse = (apiResponse) => {
+  const result = apiResponse.results?.[0];
+  return result ? {
+    id: result.id,
+    accessType: result.accessType,
+    chargingStations: result.chargingStations,
+    chargingPointAvailability: toChargingPointAvailability(result.chargingStations),
+    connectorAvailabilities: toConnectorBasedAvailabilities(result.chargingStations),
+    ...result.openingHours && { openingHours: parseOpeningHours(result.openingHours) }
+  } : void 0;
+};
+const evChargingStationsAvailabilityTemplate = {
+  requestValidation: { schema: evChargingStationsAvailabilityRequestSchema },
+  buildRequest: buildEVChargingStationsAvailabilityRequest,
+  sendRequest: get,
+  parseResponse: parseEVChargingStationsAvailabilityResponse,
+  parseResponseError: parseEVChargingStationsAvailabilityResponseError
+};
+const customize$7 = {
+  buildEVChargingStationsAvailabilityRequest,
+  parseEVChargingStationsAvailabilityResponse,
+  evChargingStationsAvailabilityTemplate
+};
+const commonGeocodeAndFuzzySearchParamsSchema = partial(
+  object({
+    typeahead: boolean(),
+    offset: number().check(_lte(1900)),
+    radiusMeters: number(),
+    boundingBox: hasBBoxSchema,
+    countries: array(string())
+  })
+);
+const placesParamsMandatory = object({
+  query: string()
+});
+const placesParamsOptional = partial(
+  object({
+    position: hasLngLatSchema,
+    limit: number().check(_lte(100)),
+    extendedPostalCodesFor: array(string()),
+    mapcodes: array(string()),
+    view: _enum(core.views),
+    geographyTypes: array(string())
+  })
+);
+const commonPlacesParamsSchema = extend(placesParamsMandatory, placesParamsOptional.shape);
+const geocodingRequestSchema = extend(commonPlacesParamsSchema, commonGeocodeAndFuzzySearchParamsSchema.shape);
+const arrayToCSV = (input) => !input ? "" : Array.isArray(input) ? input.join(",") : typeof input === "string" ? input : String(input);
+const sampleWithinMaxLength = (array2, maxLength) => {
+  const length = array2.length;
+  if (length <= maxLength) {
+    return array2;
+  }
+  const sampledArray = [];
+  let i;
+  const increment = Math.ceil(length / maxLength);
+  for (i = 0; i < length; i += increment) {
+    sampledArray.push(array2[i]);
+  }
+  if (i >= length - increment) {
+    if (sampledArray.length < maxLength) {
+      sampledArray.push(array2[length - 1]);
+    } else {
+      sampledArray[sampledArray.length - 1] = array2[length - 1];
+    }
+  }
+  return sampledArray;
+};
+const buildUrlBasePath$7 = (params) => params.customServiceBaseURL || `${params.commonBaseURL}${PLACES_URL_PATH}/geocode`;
+const buildGeocodingRequest = (params) => {
+  const url = new URL(`${buildUrlBasePath$7(params)}/${params.query}.json`);
+  const urlParams = url.searchParams;
+  appendCommonParams(urlParams, params);
+  params.typeahead && urlParams.append("typeahead", String(params.typeahead));
+  !isNil(params.limit) && urlParams.append("limit", String(params.limit));
+  !isNil(params.offset) && urlParams.append("ofs", String(params.offset));
+  appendLatLonParamsFromPosition(urlParams, params.position);
+  params.countries && urlParams.append("countrySet", arrayToCSV(params.countries));
+  !isNil(params.radiusMeters) && urlParams.append("radius", String(params.radiusMeters));
+  const bbox = params.boundingBox && core.bboxFromGeoJSON(params.boundingBox);
+  if (bbox) {
+    urlParams.append("topLeft", arrayToCSV([bbox[3], bbox[0]]));
+    urlParams.append("btmRight", arrayToCSV([bbox[1], bbox[2]]));
+  }
+  params.extendedPostalCodesFor && urlParams.append("extendedPostalCodesFor", arrayToCSV(params.extendedPostalCodesFor));
+  params.mapcodes && urlParams.append("mapcodes", arrayToCSV(params.mapcodes));
+  params.view && urlParams.append("view", params.view);
+  params.geographyTypes && urlParams.append("entityTypeSet", arrayToCSV(params.geographyTypes));
+  return url;
+};
+const parseApiResult = (result) => {
+  const { position, boundingBox, dist, entryPoints, addressRanges, entityType, id, ...rest } = result;
+  return {
+    ...core.toPointFeature(latLonAPIToPosition(position)),
+    ...boundingBox && { bbox: apiToGeoJSONBBox(boundingBox) },
+    id,
+    properties: {
+      ...omit(rest, "viewport"),
+      ...dist && { distance: dist },
+      ...entityType && { geographyType: entityType.split(",") },
+      ...entryPoints && {
+        entryPoints: entryPoints.map((entrypoint) => ({
+          ...entrypoint,
+          position: latLonAPIToPosition(entrypoint.position)
+        }))
+      },
+      ...addressRanges && {
+        addressRanges: {
+          ...addressRanges,
+          from: latLonAPIToPosition(addressRanges.from),
+          to: latLonAPIToPosition(addressRanges.to)
+        }
+      }
+    }
+  };
+};
+const parseGeocodingResponse = (apiResponse) => {
+  const results = apiResponse.results;
+  const features = results.map(parseApiResult);
+  const bbox = core.bboxOnlyIfWithArea(core.bboxFromGeoJSON(features));
+  return {
+    type: "FeatureCollection",
+    features,
+    ...bbox && { bbox }
+  };
+};
+const geocodingTemplate = {
+  requestValidation: { schema: geocodingRequestSchema },
+  buildRequest: buildGeocodingRequest,
+  sendRequest: get,
+  parseResponse: parseGeocodingResponse
+};
+const customize$6 = {
+  buildGeocodingRequest,
+  parseGeocodingResponse,
+  geocodingTemplate
+};
+const geometryDataRequestMandatory = object({
+  geometries: union([
+    featureCollectionSchema,
+    array(union([string(), featureSchema])).check(_minLength(1), _maxLength(20))
+  ])
+});
+const geometryDataRequestOptional = partial(
+  object({
+    zoom: number().check(_gte(0), _lte(22))
+  })
+);
+const geometryDataRequestSchema = extend(geometryDataRequestMandatory, geometryDataRequestOptional.shape);
+const buildUrlBasePath$6 = (params) => params.customServiceBaseURL || `${params.commonBaseURL}${PLACES_URL_PATH}/additionalData.json`;
+const getGeometryIDs = (placesArray) => placesArray.map((place) => place.properties.dataSources?.geometry?.id).filter((id) => id);
+const appendGeometries = (urlParams, geometries) => {
+  let geometryIDs;
+  if (Array.isArray(geometries)) {
+    if (typeof geometries[0] === "string") {
+      geometryIDs = geometries;
+    } else {
+      geometryIDs = getGeometryIDs(geometries);
+    }
+  } else {
+    geometryIDs = getGeometryIDs(geometries.features);
+  }
+  urlParams.append("geometries", arrayToCSV(geometryIDs));
+};
+const buildGeometryDataRequest = (params) => {
+  const url = new URL(buildUrlBasePath$6(params));
+  const urlParams = url.searchParams;
+  urlParams.append("apiVersion", String(params.apiVersion));
+  urlParams.append("key", params.apiKey);
+  appendGeometries(urlParams, params.geometries);
+  appendOptionalParam(urlParams, "geometriesZoom", params.zoom);
+  return url;
+};
+const parseGeometryDataResponse = (apiResponse) => {
+  const features = apiResponse.additionalData.flatMap(
+    (data) => data.geometryData?.features.map((feature) => ({
+      ...feature,
+      bbox: core.bboxFromGeoJSON(feature.geometry)
+    }))
+  ).filter((feature) => feature);
+  return {
+    type: "FeatureCollection",
+    bbox: core.bboxFromGeoJSON(features),
+    features
+  };
+};
+const geometryDataTemplate = {
+  requestValidation: { schema: geometryDataRequestSchema },
+  buildRequest: buildGeometryDataRequest,
+  sendRequest: get,
+  parseResponse: parseGeometryDataResponse
+};
+const customize$5 = {
+  buildGeometryDataRequest,
+  parseGeometryDataResponse,
+  geometryDataTemplate
+};
+const poiCategoriesToIdZodObject = object(poiCategoriesToID);
+const searchExtraParamsOptional = partial(
+  object({
+    indexes: array(string()),
+    poiCategories: array(union([number(), keyof(poiCategoriesToIdZodObject)])),
+    poiBrands: array(string()),
+    connectors: array(string()),
+    fuelTypes: array(string()),
+    openingHours: string(),
+    timeZone: string(),
+    relatedPois: string(),
+    minPowerKW: number(),
+    maxPowerKW: number(),
+    minFuzzyLevel: number(),
+    mixFuzzyLevel: number()
+  })
+);
+const commonSearchParamsSchema = extend(commonPlacesParamsSchema, searchExtraParamsOptional.shape);
+const geometrySearchRequestMandatory = object({
+  geometries: array(union([featureCollectionSchema, geometrySchema]))
+});
+const geometrySearchRequestSchema = extend(commonSearchParamsSchema, geometrySearchRequestMandatory.shape);
+const findFiftyLargestPolygons = (searchGeometry) => {
+  let polygonSizeMap = /* @__PURE__ */ new Map();
+  searchGeometry.coordinates.forEach((polygon) => {
+    const bboxOfPolygon = core.bboxFromCoordsArray(polygon[0]);
+    if (bboxOfPolygon) {
+      const polygonSize = Math.abs((bboxOfPolygon[2] - bboxOfPolygon[0]) * (bboxOfPolygon[3] - bboxOfPolygon[1]));
+      polygonSizeMap.set(polygon, polygonSize);
+    }
+  });
+  polygonSizeMap = new Map([...polygonSizeMap.entries()].sort((a, b) => b[1] - a[1]).splice(0, 50));
+  return [...polygonSizeMap.keys()];
+};
+const sdkGeometryToApiGeometries = (searchGeometry) => {
+  switch (searchGeometry.type) {
+    case "Circle":
+      return [
+        {
+          type: "CIRCLE",
+          radius: searchGeometry.radius,
+          position: positionToCSVLatLon(searchGeometry.coordinates)
+        }
+      ];
+    case "Polygon":
+      return [
+        {
+          type: "POLYGON",
+          vertices: sampleWithinMaxLength(searchGeometry.coordinates[0], 50).map(
+            (coord) => positionToCSVLatLon(coord)
+          )
+        }
+      ];
+    case "MultiPolygon": {
+      if (searchGeometry.coordinates.length > 50) {
+        return findFiftyLargestPolygons(searchGeometry).flatMap(
+          (polygonCoords) => sdkGeometryToApiGeometries({ type: "Polygon", coordinates: polygonCoords })
+        );
+      }
+      return searchGeometry.coordinates.flatMap(
+        (polygonCoords) => sdkGeometryToApiGeometries({ type: "Polygon", coordinates: polygonCoords })
+      );
+    }
+    case "FeatureCollection":
+      return searchGeometry.features.flatMap((feature) => sdkGeometryToApiGeometries(feature.geometry));
+    default:
+      throw new Error(`Type ${searchGeometry.type} is not supported`);
+  }
+};
+const buildUrlBasePath$5 = (mergedOptions) => mergedOptions.customServiceBaseURL ?? `${mergedOptions.commonBaseURL}${PLACES_URL_PATH}/geometrySearch/${mergedOptions.query}.json`;
+const buildGeometrySearchRequest = (params) => {
+  const url = new URL(`${buildUrlBasePath$5(params)}`);
+  appendCommonSearchParams(url, params);
+  return {
+    url,
+    data: {
+      geometryList: params.geometries.flatMap(sdkGeometryToApiGeometries)
+    }
+  };
+};
+const parseGeometrySearchResponse = (apiResponse) => {
+  const features = apiResponse.results.map(parseSearchAPIResult);
+  const bbox = core.bboxOnlyIfWithArea(core.bboxFromGeoJSON(features));
+  return {
+    type: "FeatureCollection",
+    properties: {
+      ...parseSummaryAPI(apiResponse.summary)
+    },
+    features,
+    ...bbox && { bbox }
+  };
+};
+const geometrySearchTemplate = {
+  requestValidation: { schema: geometrySearchRequestSchema },
+  buildRequest: buildGeometrySearchRequest,
+  sendRequest: post,
+  parseResponse: parseGeometrySearchResponse
+};
+const geometrySearch = async (params, customTemplate) => callService(params, { ...geometrySearchTemplate, ...customTemplate }, "GeometrySearch");
+const customize$4 = {
+  geometrySearch,
+  buildGeometrySearchRequest,
+  parseGeometrySearchResponse,
+  geometrySearchTemplate
+};
+const placeByIdRequestMandatory = object({
+  entityId: string()
+});
+const placeByIdRequestOptional = partial(
+  object({
+    mapcodes: array(string()),
+    view: _enum(core.views),
+    openingHours: string(),
+    timeZone: string(),
+    relatedPois: string()
+  })
+);
+const placeByIdRequestSchema = extend(placeByIdRequestMandatory, placeByIdRequestOptional.shape);
+const buildUrlBasePath$4 = (params) => params.customServiceBaseURL || `${params.commonBaseURL}${PLACES_URL_PATH}/place.json`;
+const buildPlaceByIdRequest = (params) => {
+  const url = new URL(`${buildUrlBasePath$4(params)}`);
+  const urlParams = url.searchParams;
+  appendCommonParams(urlParams, params);
+  appendOptionalParam(urlParams, "entityId", params.entityId);
+  appendByJoiningParamValue(urlParams, "mapcodes", params.mapcodes);
+  appendOptionalParam(urlParams, "view", params.view);
+  appendOptionalParam(urlParams, "openingHours", params.openingHours);
+  appendOptionalParam(urlParams, "timeZone", params.timeZone);
+  appendOptionalParam(urlParams, "relatedPois", params.relatedPois);
+  return url;
+};
+const parsePlaceByIdResponse = (apiResponse) => apiResponse.results?.length ? parseSearchAPIResult(apiResponse.results[0]) : void 0;
+const placeByIdTemplate = {
+  requestValidation: { schema: placeByIdRequestSchema },
+  buildRequest: buildPlaceByIdRequest,
+  sendRequest: get,
+  parseResponse: parsePlaceByIdResponse
+};
+const customize$3 = {
+  buildPlaceByIdRequest,
+  parsePlaceByIdResponse,
+  placeByIdTemplate
+};
+const routeTypes = ["fast", "short", "efficient", "thrilling"];
+const loadTypes = [
+  "USHazmatClass1",
+  "USHazmatClass2",
+  "USHazmatClass3",
+  "USHazmatClass4",
+  "USHazmatClass5",
+  "USHazmatClass6",
+  "USHazmatClass7",
+  "USHazmatClass8",
+  "USHazmatClass9",
+  "otherHazmatExplosive",
+  "otherHazmatGeneral",
+  "otherHazmatHarmfulToWater"
+];
+const positiveNumber = number().check(_positive());
+const nonNegativeNumber = number().check(_gte(0));
+const percentageNumber = number().check(_gte(0), _lte(100));
+const optionalPositiveNumber = optional(positiveNumber);
+const optionalNonNegativeNumber = optional(nonNegativeNumber);
+const optionalNormalizedNumber = optional(number().check(_gte(0), _lte(1)));
+const speedToConsumptionRateSchema = object({
+  speedKMH: number(),
+  consumptionUnitsPer100KM: number()
+});
+const efficiencySchema = optional(
+  object({
+    acceleration: optionalNormalizedNumber,
+    deceleration: optionalNormalizedNumber,
+    uphill: optionalNormalizedNumber,
+    downhill: optionalNormalizedNumber
+  })
+);
+const baseConsumptionModelSchema = {
+  efficiency: efficiencySchema
+};
+const speedConsumptionArray = array(speedToConsumptionRateSchema).check(_minLength(1), _maxLength(25));
+const combustionConsumptionModelSchema = object({
+  ...baseConsumptionModelSchema,
+  speedsToConsumptionsLiters: speedConsumptionArray,
+  auxiliaryPowerInLitersPerHour: optionalNonNegativeNumber,
+  fuelEnergyDensityInMJoulesPerLiter: optional(number().check(_gte(1)))
+});
+const electricConsumptionModelSchema = object({
+  ...baseConsumptionModelSchema,
+  speedsToConsumptionsKWH: speedConsumptionArray,
+  auxiliaryPowerInkW: optionalNonNegativeNumber,
+  consumptionInKWHPerKMAltitudeGain: optional(number().check(_lte(500))),
+  recuperationInKWHPerKMAltitudeLoss: optionalNonNegativeNumber
+});
+const chargingConnectorSchema = object({
+  currentType: _enum(core.currentTypes),
+  plugTypes: array(_enum(core.plugTypes)).check(_minLength(1)),
+  efficiency: optionalNormalizedNumber,
+  baseLoadInkW: optionalNonNegativeNumber,
+  maxPowerInkW: optionalNonNegativeNumber,
+  maxVoltageInV: optionalNonNegativeNumber,
+  maxCurrentInA: optionalNonNegativeNumber,
+  voltageRange: optional(
+    object({
+      minVoltageInV: optionalNonNegativeNumber,
+      maxVoltageInV: optional(number())
+    })
+  )
+});
+const batteryCurveSchema = object({
+  stateOfChargeInkWh: nonNegativeNumber,
+  maxPowerInkW: positiveNumber
+});
+const chargingModelSchema = object({
+  maxChargeKWH: positiveNumber,
+  batteryCurve: optional(array(batteryCurveSchema).check(_maxLength(20))),
+  chargingConnectors: optional(array(chargingConnectorSchema).check(_minLength(1))),
+  chargingTimeOffsetInSec: optionalNonNegativeNumber
+});
+const combustionEngineModelSchema = object({ consumption: combustionConsumptionModelSchema });
+const electricEngineModelSchema = object({
+  consumption: electricConsumptionModelSchema,
+  charging: optional(chargingModelSchema)
+});
+const vehicleDimensionsSchema = optional(
+  object({
+    lengthMeters: optionalPositiveNumber,
+    widthMeters: optionalPositiveNumber,
+    heightMeters: optionalPositiveNumber,
+    weightKG: optionalPositiveNumber,
+    axleWeightKG: optionalPositiveNumber
+  })
+);
+const predefinedVehicleModelSchema = object({ variantId: string() });
+const explicitVehicleModelSchema = object({
+  dimensions: vehicleDimensionsSchema,
+  engine: optional(union([combustionEngineModelSchema, electricEngineModelSchema]))
+});
+const vehicleModelSchema = optional(union([predefinedVehicleModelSchema, explicitVehicleModelSchema]));
+const genericVehicleStateSchema = object({
+  heading: optional(number().check(_gte(0), _lte(360)))
+});
+const combustionVehicleStateSchema = extend(
+  genericVehicleStateSchema,
+  object({ currentFuelInLiters: nonNegativeNumber }).shape
+);
+const electricVehicleStateByPercentageSchema = extend(
+  genericVehicleStateSchema,
+  object({ currentChargePCT: percentageNumber }).shape
+);
+const electricVehicleStateByKwhSchema = extend(
+  genericVehicleStateSchema,
+  object({ currentChargeInkWh: nonNegativeNumber }).shape
+);
+const electricVehicleStateSchema = union([electricVehicleStateByPercentageSchema, electricVehicleStateByKwhSchema]);
+const chargingPreferencesPCTSchema = object({
+  minChargeAtDestinationPCT: percentageNumber,
+  minChargeAtChargingStopsPCT: number().check(_gte(0), _lte(50))
+});
+const chargingPreferencesKWHSchema = object({
+  minChargeAtDestinationInkWh: nonNegativeNumber,
+  minChargeAtChargingStopsInkWh: nonNegativeNumber
+});
+const chargingPreferencesSchema = union([chargingPreferencesPCTSchema, chargingPreferencesKWHSchema]);
+const electricVehiclePreferencesSchema = object({
+  chargingPreferences: optional(chargingPreferencesSchema)
+});
+const vehicleRestrictionsSchema = optional(
+  object({
+    loadTypes: optional(array(_enum(loadTypes))),
+    maxSpeedKMH: optional(number().check(_gte(0), _lte(250))),
+    adrCode: optional(_enum(["B", "C", "D", "E"])),
+    commercial: optional(boolean())
+  })
+);
+const baseVehicleParamsSchema = {
+  model: vehicleModelSchema,
+  restrictions: vehicleRestrictionsSchema
+};
+const genericVehicleParamsSchema = object({
+  ...baseVehicleParamsSchema,
+  engineType: _undefined(),
+  state: optional(genericVehicleStateSchema),
+  preferences: optional(object({}))
+});
+const combustionVehicleParamsSchema = object({
+  ...baseVehicleParamsSchema,
+  engineType: literal("combustion"),
+  state: optional(combustionVehicleStateSchema),
+  preferences: optional(object({}))
+});
+const electricVehicleParamsSchema = object({
+  ...baseVehicleParamsSchema,
+  engineType: literal("electric"),
+  state: optional(electricVehicleStateSchema),
+  preferences: optional(electricVehiclePreferencesSchema)
+});
+const vehicleParametersSchema = union([
+  discriminatedUnion("engineType", [combustionVehicleParamsSchema, electricVehicleParamsSchema]),
+  genericVehicleParamsSchema
+]);
+const commonRoutingRequestSchema = partial(
+  object({
+    costModel: partial(
+      object({
+        avoid: array(_enum(core.avoidableTypes)),
+        traffic: optional(_enum(["live", "historical"])),
+        routeType: optional(_enum(routeTypes)),
+        thrillingParams: optional(
+          object({
+            hilliness: optional(_enum(["low", "normal", "high"])),
+            windingness: optional(_enum(["low", "normal", "high"]))
+          })
+        )
+      })
+    ),
+    travelMode: string(),
+    vehicle: vehicleParametersSchema,
+    when: object({
+      option: _enum(["departAt", "arriveBy"]),
+      date: date()
+    })
+  })
+);
+const budgetTypes = [
+  "timeMinutes",
+  "remainingChargeCPT",
+  "spentChargePCT",
+  "spentFuelLiters",
+  "distanceKM"
+];
+const reachableRangeRequestSchemaMandatory = object({
+  origin: hasLngLatSchema,
+  budget: object({
+    type: _enum(budgetTypes),
+    value: number().check(_gte(0))
+  })
+});
+const reachableRangeRequestSchemaOptional = object({
+  maxFerryLengthMeters: optional(number().check(_gte(0)))
+});
+const reachableRangeRequestSchema = extend(
+  commonRoutingRequestSchema,
+  extend(reachableRangeRequestSchemaMandatory, reachableRangeRequestSchemaOptional.shape).shape
+);
+const reachableRangeRequestValidationConfig = {
+  schema: reachableRangeRequestSchema
+  // refinements: [evRangeRefinement, fuelRangeRefinement, departArriveRefinement]
+};
+const appendConsumptionEfficiency = (urlParams, efficiency) => {
+  if (efficiency) {
+    !isNil(efficiency.acceleration) && urlParams.append("accelerationEfficiency", String(efficiency.acceleration));
+    !isNil(efficiency.deceleration) && urlParams.append("decelerationEfficiency", String(efficiency.deceleration));
+    !isNil(efficiency.uphill) && urlParams.append("uphillEfficiency", String(efficiency.uphill));
+    !isNil(efficiency.downhill) && urlParams.append("downhillEfficiency", String(efficiency.downhill));
+  }
+};
+const buildSpeedToConsumptionString = (speedsToConsumptions) => speedsToConsumptions.map((speedToConsumption) => `${speedToConsumption.speedKMH},${speedToConsumption.consumptionUnitsPer100KM}`).join(":");
+const appendCombustionEngine = (urlParams, engine) => {
+  const consumptionModel = engine.consumption;
+  consumptionModel.speedsToConsumptionsLiters && urlParams.append(
+    "constantSpeedConsumptionInLitersPerHundredkm",
+    buildSpeedToConsumptionString(consumptionModel.speedsToConsumptionsLiters)
+  );
+  !isNil(consumptionModel.auxiliaryPowerInLitersPerHour) && urlParams.append("auxiliaryPowerInLitersPerHour", String(consumptionModel.auxiliaryPowerInLitersPerHour));
+  !isNil(consumptionModel.fuelEnergyDensityInMJoulesPerLiter) && urlParams.append(
+    "fuelEnergyDensityInMJoulesPerLiter",
+    String(consumptionModel.fuelEnergyDensityInMJoulesPerLiter)
+  );
+};
+const appendElectricConsumptionModel = (urlParams, model) => {
+  model.speedsToConsumptionsKWH && urlParams.append(
+    "constantSpeedConsumptionInkWhPerHundredkm",
+    buildSpeedToConsumptionString(model.speedsToConsumptionsKWH)
+  );
+  !isNil(model.auxiliaryPowerInkW) && urlParams.append("auxiliaryPowerInkW", String(model.auxiliaryPowerInkW));
+  !isNil(model.consumptionInKWHPerKMAltitudeGain) && urlParams.append("consumptionInkWhPerkmAltitudeGain", String(model.consumptionInKWHPerKMAltitudeGain));
+  !isNil(model.recuperationInKWHPerKMAltitudeLoss) && urlParams.append("recuperationInkWhPerkmAltitudeLoss", String(model.recuperationInKWHPerKMAltitudeLoss));
+};
+const appendChargingModel = (urlParams, engine) => {
+  const chargingModel = engine.charging;
+  if (chargingModel?.maxChargeKWH) {
+    urlParams.append("maxChargeInkWh", String(chargingModel.maxChargeKWH));
+  }
+};
+const appendVehicleState = (urlParams, vehicleParams) => {
+  if (!vehicleParams.state) {
+    return;
+  }
+  vehicleParams.state.heading && urlParams.append("vehicleHeading", String(vehicleParams.state.heading));
+  if (!("engineType" in vehicleParams)) {
+    return;
+  }
+  if (vehicleParams.engineType === "combustion") {
+    const combustionState = vehicleParams.state;
+    combustionState.currentFuelInLiters && urlParams.append("currentFuelInLiters", String(combustionState.currentFuelInLiters));
+  } else if (vehicleParams.engineType === "electric") {
+    const electricState = vehicleParams.state;
+    const kwhElectricState = electricState;
+    const pctElectricState = electricState;
+    if (kwhElectricState.currentChargeInkWh) {
+      urlParams.append("currentChargeInkWh", String(kwhElectricState.currentChargeInkWh));
+    } else if (pctElectricState.currentChargePCT && vehicleParams.model && "engine" in vehicleParams.model && vehicleParams.model.engine) {
+      const engine = vehicleParams.model.engine;
+      const maxChargeKWH = engine.charging?.maxChargeKWH;
+      if (maxChargeKWH) {
+        urlParams.append(
+          "currentChargeInkWh",
+          String(maxChargeKWH * pctElectricState.currentChargePCT / 100)
+        );
+      }
+    }
+  }
+};
+const appendVehiclePreferences = (urlParams, vehicleParams) => {
+  if (!vehicleParams.preferences) {
+    return;
+  }
+  if ("engineType" in vehicleParams && vehicleParams.engineType === "electric") {
+    const preferences = vehicleParams.preferences;
+    if (preferences.chargingPreferences) {
+      const chargingPrefs = preferences.chargingPreferences;
+      const kwhChargingPrefs = chargingPrefs;
+      const pctChargingPrefs = chargingPrefs;
+      if (kwhChargingPrefs.minChargeAtChargingStopsInkWh || kwhChargingPrefs.minChargeAtDestinationInkWh) {
+        urlParams.append("minChargeAtDestinationInkWh", String(kwhChargingPrefs.minChargeAtDestinationInkWh));
+        urlParams.append(
+          "minChargeAtChargingStopsInkWh",
+          String(kwhChargingPrefs.minChargeAtChargingStopsInkWh)
+        );
+      } else if ((pctChargingPrefs.minChargeAtChargingStopsPCT || pctChargingPrefs.minChargeAtDestinationPCT) && vehicleParams.model && "engine" in vehicleParams.model && vehicleParams.model.engine) {
+        const engine = vehicleParams.model.engine;
+        const maxChargeKWH = engine.charging?.maxChargeKWH;
+        if (maxChargeKWH) {
+          urlParams.append(
+            "minChargeAtDestinationInkWh",
+            String(maxChargeKWH * pctChargingPrefs.minChargeAtDestinationPCT / 100)
+          );
+          urlParams.append(
+            "minChargeAtChargingStopsInkWh",
+            String(maxChargeKWH * pctChargingPrefs.minChargeAtChargingStopsPCT / 100)
+          );
+        }
+      }
+    }
+  }
+};
+const appendVehicleDimensions = (urlParams, dimensions) => {
+  if (dimensions) {
+    dimensions.lengthMeters && urlParams.append("vehicleLength", String(dimensions.lengthMeters));
+    dimensions.heightMeters && urlParams.append("vehicleHeight", String(dimensions.heightMeters));
+    dimensions.widthMeters && urlParams.append("vehicleWidth", String(dimensions.widthMeters));
+    dimensions.weightKG && urlParams.append("vehicleWeight", String(dimensions.weightKG));
+    dimensions.axleWeightKG && urlParams.append("vehicleAxleWeight", String(dimensions.axleWeightKG));
+  }
+};
+const appendVehicleRestrictions = (urlParams, vehicleParams) => {
+  const restrictions = vehicleParams.restrictions;
+  if (!restrictions) {
+    return;
+  }
+  appendByRepeatingParamName(urlParams, "vehicleLoadType", restrictions.loadTypes);
+  restrictions.adrCode && urlParams.append("vehicleAdrTunnelRestrictionCode", restrictions.adrCode);
+  restrictions.commercial && urlParams.append("vehicleCommercial", String(restrictions.commercial));
+  restrictions.maxSpeedKMH && urlParams.append("vehicleMaxSpeed", String(restrictions.maxSpeedKMH));
+};
+const appendVehicleEngineModel = (urlParams, engineType, engine) => {
+  appendConsumptionEfficiency(urlParams, engine.consumption.efficiency);
+  if (engineType === "electric") {
+    appendElectricConsumptionModel(urlParams, engine.consumption);
+    appendChargingModel(urlParams, engine);
+  } else {
+    appendCombustionEngine(urlParams, engine);
+  }
+};
+const appendVehicleModel = (urlParams, vehicleParams) => {
+  if (!vehicleParams.model) {
+    return;
+  }
+  if ("variantId" in vehicleParams.model) {
+    urlParams.append("vehicleModelId", vehicleParams.model.variantId);
+  } else {
+    appendVehicleDimensions(urlParams, vehicleParams.model.dimensions);
+    if (vehicleParams.model.engine) {
+      appendVehicleEngineModel(
+        urlParams,
+        "engineType" in vehicleParams ? vehicleParams.engineType : void 0,
+        vehicleParams.model.engine
+      );
+    }
+  }
+};
+const appendVehicleParams = (urlParams, vehicleParams) => {
+  if (!vehicleParams) {
+    return;
+  }
+  if (vehicleParams.engineType === "electric") {
+    urlParams.append("vehicleEngineType", "electric");
+  }
+  appendVehicleModel(urlParams, vehicleParams);
+  appendVehicleState(urlParams, vehicleParams);
+  appendVehiclePreferences(urlParams, vehicleParams);
+  appendVehicleRestrictions(urlParams, vehicleParams);
+};
+const appendWhenParams = (urlParams, when) => {
+  if (when?.date) {
+    const formattedDate = when.date.toISOString();
+    if (when.option === "departAt") {
+      urlParams.append("departAt", formattedDate);
+    } else if (when.option === "arriveBy") {
+      urlParams.append("arriveAt", formattedDate);
+    }
+  }
+};
+const appendCommonRoutingParams = (urlParams, params) => {
+  const costModel = params.costModel;
+  appendByRepeatingParamName(urlParams, "avoid", costModel?.avoid);
+  appendOptionalParam(urlParams, "traffic", costModel?.traffic);
+  appendWhenParams(urlParams, params.when);
+  appendOptionalParam(urlParams, "routeType", costModel?.routeType);
+  appendOptionalParam(urlParams, "travelMode", params.travelMode);
+  appendVehicleParams(urlParams, params.vehicle);
+};
+const buildUrlBasePath$3 = (params) => params.customServiceBaseURL || `${params.commonBaseURL}/routing/1/calculateReachableRange/${positionToCSVLatLon(
+  core.getPositionStrict(params.origin)
+)}/json`;
+const buildReachableRangeRequest = (params) => {
+  const url = new URL(buildUrlBasePath$3(params));
+  const urlParams = url.searchParams;
+  appendCommonParams(urlParams, params);
+  appendCommonRoutingParams(urlParams, params);
+  appendOptionalParam(urlParams, "maxFerryLengthInMeters", params.maxFerryLengthMeters);
+  return url;
+};
+const parseReachableRangeResponse = (apiResponse, params) => {
+  const geometry = {
+    type: "Polygon",
+    coordinates: [apiResponse.reachableRange.boundary.map((point) => [point.longitude, point.latitude])]
+  };
+  const bbox = core.bboxFromGeoJSON(geometry);
+  return { type: "Feature", geometry, bbox, properties: params };
+};
+const reachableRangeTemplate = {
+  requestValidation: reachableRangeRequestValidationConfig,
+  buildRequest: buildReachableRangeRequest,
+  sendRequest: get,
+  parseResponse: parseReachableRangeResponse
+};
+const customize$2 = {
+  buildReachableRangeRequest,
+  parseReachableRangeResponse,
+  reachableRangeTemplate
+};
+const buildUrlBasePath$2 = (params) => params.customServiceBaseURL || `${params.commonBaseURL}${PLACES_URL_PATH}/reverseGeocode`;
+const buildRevGeoRequest = (params) => {
+  const lngLat = core.getPositionStrict(params.position);
+  const url = new URL(`${buildUrlBasePath$2(params)}/${lngLat[1]},${lngLat[0]}.json`);
+  const urlParams = url.searchParams;
+  appendCommonParams(urlParams, params);
+  params.allowFreeformNewline && urlParams.append("allowFreeformNewline", String(params.allowFreeformNewline));
+  params.geographyType && urlParams.append("entityType", arrayToCSV(params.geographyType));
+  !isNil(params.heading) && urlParams.append("heading", String(params.heading));
+  params.mapcodes && urlParams.append("mapcodes", arrayToCSV(params.mapcodes));
+  params.number && urlParams.append("number", params.number);
+  !isNil(params.radiusMeters) && urlParams.append("radius", String(params.radiusMeters));
+  params.returnSpeedLimit && urlParams.append("returnSpeedLimit", String(params.returnSpeedLimit));
+  params.returnRoadUse && urlParams.append("returnRoadUse", String(params.returnRoadUse));
+  params.roadUses && urlParams.append("roadUse", JSON.stringify(params.roadUses));
+  return url;
+};
+const parseRevGeoResponse = (apiResponse, params) => {
+  const pointFeature = core.toPointFeature(core.getPositionStrict(params.position));
+  const firstApiResult = apiResponse.addresses[0];
+  const { boundingBox, sideOfStreet, offsetPosition, ...address } = firstApiResult?.address || {};
+  return {
+    // The requested coordinates are the primary ones, and set as the GeoJSON Feature geometry:
+    ...pointFeature,
+    ...boundingBox && { bbox: apiToGeoJSONBBox(boundingBox) },
+    id: core.generateId(),
+    ...firstApiResult && {
+      properties: {
+        type: firstApiResult?.entityType ? "Geography" : !address.streetNumber ? "Street" : "Point Address",
+        address,
+        ...firstApiResult.dataSources && { dataSources: firstApiResult.dataSources },
+        ...firstApiResult.mapcodes && { mapcodes: firstApiResult.mapcodes },
+        ...sideOfStreet && { sideOfStreet },
+        ...offsetPosition && { offsetPosition: csvLatLngToPosition(offsetPosition) },
+        // The reverse geocoded coordinates are secondary and set in the GeoJSON properties:
+        originalPosition: csvLatLngToPosition(firstApiResult.position)
+      }
+    }
+  };
+};
+const revGeocodeRequestMandatory = object({
+  position: hasLngLatSchema
+});
+const revGeocodeRequestOptional = partial(
+  object({
+    allowFreeformNewline: boolean(),
+    geographyType: array(string()),
+    heading: number().check(_gte(-360), _lte(360)),
+    mapcodes: array(string()),
+    number: string(),
+    radiusMeters: number(),
+    returnMatchType: boolean(),
+    returnRoadUse: boolean(),
+    returnSpeedLimit: boolean(),
+    roadUses: array(string()),
+    view: _enum(core.views)
+  })
+);
+const revGeocodeRequestSchema = extend(revGeocodeRequestMandatory, revGeocodeRequestOptional.shape);
+const reverseGeocodingTemplate = {
+  requestValidation: { schema: revGeocodeRequestSchema },
+  buildRequest: buildRevGeoRequest,
+  sendRequest: get,
+  parseResponse: parseRevGeoResponse
+};
+const customize$1 = {
+  buildRevGeoRequest,
+  parseRevGeoResponse,
+  reverseGeocodingTemplate
+};
+const waypointLikeSchema = union([hasLngLatSchema, geometrySchema]);
+const pathLikeSchema = union([lineStringCoordsSchema, featureSchema]);
+const calculateRouteRequestSchemaMandatory = object({
+  locations: array(union([waypointLikeSchema, pathLikeSchema])).check(_minLength(1))
+});
+const calculateRouteRequestSchemaOptional = partial(
+  object({
+    computeAdditionalTravelTimeFor: _enum(["none", "all"]),
+    vehicleHeading: number().check(_gte(0), _lte(359.5)),
+    // TODO add proper instructionsInfo check
+    // instructionsType: z.enum(instructionsTypes),
+    maxAlternatives: number().check(_gte(0), _lte(5)),
+    sectionTypes: array(_enum(core.inputSectionTypesWithGuidance))
+  })
+);
+const calculateRouteRequestSchema = extend(
+  commonRoutingRequestSchema,
+  extend(calculateRouteRequestSchemaMandatory, calculateRouteRequestSchemaOptional.shape).shape
+);
+const calculateRoutelocationsRefinement = {
+  check: (data) => {
+    const routePlanningLocationTypes = data.locations.map(core.getRoutePlanningLocationType);
+    if (!routePlanningLocationTypes.includes("path")) {
+      return data.locations.length >= 2;
+    }
+    return true;
+  },
+  message: "When passing waypoints only: at least 2 must be defined. If passing also paths, at least one path must be defined"
+};
+const routeRequestValidationConfig = {
+  schema: calculateRouteRequestSchema,
+  refinements: [calculateRoutelocationsRefinement]
+};
+const getChargingPreferences = (params) => params.vehicle?.preferences?.chargingPreferences;
+const buildUrlBasePath$1 = (params) => params.customServiceBaseURL || `${params.commonBaseURL}/maps/orbis/routing/${getChargingPreferences(params) ? "calculateLongDistanceEVRoute" : "calculateRoute"}`;
+const getWaypointProps = (waypointInput) => waypointInput.properties || null;
+const defaultUseEntryPointOption = "main-when-available";
+const buildLocationsStringFromWaypoints = (waypointInputs, useEntryPoint) => waypointInputs.map((waypointInput) => {
+  const lngLatString = positionToCSVLatLon(core.getPositionStrict(waypointInput, { useEntryPoint }));
+  const radius = getWaypointProps(waypointInput)?.radiusMeters;
+  return radius ? `circle(${lngLatString},${radius})` : lngLatString;
+}).join(":");
+const getPositionsFromPath = (pathLike) => {
+  if (Array.isArray(pathLike)) {
+    return pathLike;
+  }
+  return pathLike.geometry.coordinates;
+};
+const getFirstAndLastPoints = (locations, types, useEntryPoint) => {
+  let firstPoint;
+  const firstRoutePlanningLocation = locations[0];
+  if (types[0] === "path") {
+    const positions = getPositionsFromPath(firstRoutePlanningLocation);
+    firstPoint = positions[0];
+  } else {
+    firstPoint = core.getPositionStrict(firstRoutePlanningLocation, { useEntryPoint });
+  }
+  const lastRoutePlanningLocation = locations[locations.length - 1];
+  let lastPoint;
+  if (types[types.length - 1] === "path") {
+    const positions = getPositionsFromPath(lastRoutePlanningLocation);
+    lastPoint = positions[positions.length - 1];
+  } else {
+    lastPoint = core.getPositionStrict(lastRoutePlanningLocation, { useEntryPoint });
+  }
+  return [firstPoint, lastPoint];
+};
+const buildLocationsString = (locations, routePlanningLocationTypes, useEntryPoint) => buildLocationsStringFromWaypoints(
+  routePlanningLocationTypes.includes("path") ? getFirstAndLastPoints(locations, routePlanningLocationTypes, useEntryPoint) : locations,
+  useEntryPoint
+);
+const appendSectionTypes = (urlParams, sectionTypes, instructionsInclude) => {
+  const effectiveSectionTypes = (sectionTypes ?? (instructionsInclude ? core.inputSectionTypesWithGuidance : core.inputSectionTypes)).map((sectionType) => sectionType === "vehicleRestricted" ? "travelMode" : sectionType);
+  appendByRepeatingParamName(urlParams, "sectionType", effectiveSectionTypes);
+};
+const appendGuidanceParams = (urlParams, params) => {
+  if (params?.guidance) {
+    const guidance = params.guidance;
+    urlParams.append("instructionsType", guidance.type);
+    urlParams.append("guidanceVersion", String(guidance.version ?? 2));
+    urlParams.append("instructionPhonetics", guidance.phonetics ?? "IPA");
+    urlParams.append("instructionRoadShieldReferences", guidance.roadShieldReferences ?? "all");
+    urlParams.append("language", params.language ?? "en-US");
+  }
+};
+const toLatLngPointApi = (position) => ({
+  latitude: position[1],
+  longitude: position[0]
+});
+const appendPathPostData = (pathRoutePlanningLocation, routePlanningLocationIndex, locations, supportingPoints, pointWaypoints) => {
+  const supportingPointsLengthBeforePath = supportingPoints.length;
+  for (const position of getPositionsFromPath(pathRoutePlanningLocation)) {
+    supportingPoints.push(toLatLngPointApi(position));
+  }
+  if (!Array.isArray(pathRoutePlanningLocation)) {
+    const legs = pathRoutePlanningLocation.properties.sections.leg;
+    legs.forEach((leg, legIndex) => {
+      if (routePlanningLocationIndex > 0 || legIndex > 0) {
+        pointWaypoints.push({
+          supportingPointIndex: supportingPointsLengthBeforePath + leg.startPointIndex,
+          waypointSourceType: "USER_DEFINED"
+        });
+      }
+    });
+    if (routePlanningLocationIndex < locations.length - 1) {
+      pointWaypoints.push({
+        supportingPointIndex: supportingPointsLengthBeforePath + pathRoutePlanningLocation.geometry.coordinates.length - 1,
+        waypointSourceType: "USER_DEFINED"
+      });
+    }
+  }
+};
+const appendWaypointPostData = (waypoint, routePlanningLocationIndex, locations, supportingPoints, pointWaypoints, useEntryPoint) => {
+  supportingPoints.push(toLatLngPointApi(core.getPositionStrict(waypoint, { useEntryPoint })));
+  if (routePlanningLocationIndex > 0 && routePlanningLocationIndex < locations.length - 1) {
+    pointWaypoints.push({
+      supportingPointIndex: supportingPoints.length - 1,
+      waypointSourceType: "USER_DEFINED"
+    });
+  }
+};
+const buildlocationsPostData = (locations, types, useEntryPoints) => {
+  const supportingPoints = [];
+  const pointWaypoints = [];
+  locations.forEach((routePlanningLocation, routePlanningLocationIndex) => {
+    if (types[routePlanningLocationIndex] === "path") {
+      appendPathPostData(
+        routePlanningLocation,
+        routePlanningLocationIndex,
+        locations,
+        supportingPoints,
+        pointWaypoints
+      );
+    } else {
+      appendWaypointPostData(
+        routePlanningLocation,
+        routePlanningLocationIndex,
+        locations,
+        supportingPoints,
+        pointWaypoints,
+        useEntryPoints
+      );
+    }
+  });
+  return { supportingPoints, ...pointWaypoints.length && { pointWaypoints } };
+};
+const buildPostData = (params, types, useEntryPoints) => {
+  const pathsIncluded = types.includes("path");
+  const isLdevr = !!getChargingPreferences(params);
+  if (!pathsIncluded && !isLdevr) {
+    return null;
+  }
+  const vehicleModel = params.vehicle?.model;
+  const chargingModel = vehicleModel?.engine?.charging;
+  return {
+    ...pathsIncluded && buildlocationsPostData(params.locations, types, useEntryPoints),
+    ...isLdevr && chargingModel && {
+      chargingParameters: omit(chargingModel, "maxChargeKWH")
+    }
+  };
+};
+const buildCalculateRouteRequest = (params) => {
+  const routePlanningLocationTypes = params.locations.map(core.getRoutePlanningLocationType);
+  const useEntryPoints = params.useEntryPoints ?? defaultUseEntryPointOption;
+  const url = new URL(
+    `${buildUrlBasePath$1(params)}/${buildLocationsString(params.locations, routePlanningLocationTypes, useEntryPoints)}/json`
+  );
+  const urlParams = url.searchParams;
+  appendCommonParams(urlParams, params);
+  if (!("language" in params)) {
+    urlParams.append("language", "en-GB");
+  }
+  appendCommonRoutingParams(urlParams, params);
+  appendOptionalParam(urlParams, "computeTravelTimeFor", params.computeAdditionalTravelTimeFor);
+  appendGuidanceParams(urlParams, params);
+  !isNil(params.maxAlternatives) && urlParams.append("maxAlternatives", String(params.maxAlternatives));
+  appendSectionTypes(urlParams, params.sectionTypes, !!params.guidance?.type);
+  for (const representation of params.extendedRouteRepresentations ?? ["distance", "travelTime"]) {
+    urlParams.append("extendedRouteRepresentation", representation);
+  }
+  const postData = buildPostData(params, routePlanningLocationTypes, useEntryPoints);
+  return postData ? { method: "POST", url, data: postData } : { method: "GET", url };
+};
+const toCurrentType = (apiCurrentType) => {
+  switch (apiCurrentType) {
+    case "Direct_Current":
+      return "DC";
+    case "Alternating_Current_1_Phase":
+      return "AC1";
+    case "Alternating_Current_3_Phase":
+      return "AC3";
+    default:
+      return void 0;
+  }
+};
+const toChargingSpeed = (powerInKW) => {
+  if (powerInKW < 12) {
+    return "slow";
+  } else if (powerInKW < 50) {
+    return "regular";
+  } else if (powerInKW < 150) {
+    return "fast";
+  }
+  return "ultra-fast";
+};
+const toChargingStop = (chargingInformationAtEndOfLeg, maxChargeKWH) => {
+  const chargingConnectionInfo = chargingInformationAtEndOfLeg.chargingConnectionInfo;
+  const chargingParkLocation = chargingInformationAtEndOfLeg.chargingParkLocation;
+  const coordinates = [chargingParkLocation.coordinate.longitude, chargingParkLocation.coordinate.latitude];
+  const addressParts = [chargingParkLocation.street, chargingParkLocation.houseNumber].filter(Boolean);
+  const freeformAddress = addressParts.length > 0 ? addressParts.join(", ") : "";
+  return {
+    type: "Feature",
+    id: chargingInformationAtEndOfLeg.chargingParkId,
+    geometry: { type: "Point", coordinates },
+    properties: {
+      ...omit(chargingInformationAtEndOfLeg, ["chargingConnectionInfo", "chargingParkLocation"]),
+      type: "POI",
+      address: {
+        freeformAddress,
+        ...chargingParkLocation.street && { streetName: chargingParkLocation.street },
+        ...chargingParkLocation.houseNumber && { streetNumber: chargingParkLocation.houseNumber },
+        ...chargingParkLocation.city && { municipality: chargingParkLocation.city },
+        ...chargingParkLocation.region && { countrySubdivision: chargingParkLocation.region },
+        ...chargingParkLocation.postalCode && { postalCode: chargingParkLocation.postalCode },
+        ...chargingParkLocation.country && { country: chargingParkLocation.country }
+      },
+      ...chargingConnectionInfo && {
+        chargingConnectionInfo: {
+          plugType: chargingConnectionInfo.chargingPlugType,
+          currentInA: chargingConnectionInfo.chargingCurrentInA,
+          voltageInV: chargingConnectionInfo.chargingVoltageInV,
+          chargingPowerInkW: chargingConnectionInfo.chargingPowerInkW,
+          currentType: toCurrentType(chargingConnectionInfo.chargingCurrentType),
+          chargingSpeed: toChargingSpeed(chargingConnectionInfo.chargingPowerInkW)
+        }
+      },
+      ...maxChargeKWH && {
+        targetChargeInPCT: 100 * chargingInformationAtEndOfLeg.targetChargeInkWh / maxChargeKWH
+      },
+      ...chargingInformationAtEndOfLeg.chargingParkPowerInkW && {
+        chargingParkSpeed: toChargingSpeed(chargingInformationAtEndOfLeg.chargingParkPowerInkW)
+      }
+    }
+  };
+};
+const parseSummary = (apiSummary, params) => {
+  const maxChargeKWH = params?.vehicle?.model?.engine?.charging?.maxChargeKWH;
+  return {
+    ...apiSummary,
+    departureTime: new Date(apiSummary.departureTime),
+    arrivalTime: new Date(apiSummary.arrivalTime),
+    // EV-specific fields:
+    ...maxChargeKWH && apiSummary.batteryConsumptionInkWh && {
+      batteryConsumptionInPCT: 100 * apiSummary.batteryConsumptionInkWh / maxChargeKWH
+    },
+    ...maxChargeKWH && apiSummary.remainingChargeAtArrivalInkWh && {
+      remainingChargeAtArrivalInPCT: 100 * apiSummary.remainingChargeAtArrivalInkWh / maxChargeKWH
+    },
+    ...apiSummary.chargingInformationAtEndOfLeg && {
+      chargingInformationAtEndOfLeg: toChargingStop(apiSummary.chargingInformationAtEndOfLeg, maxChargeKWH)
+    }
+  };
+};
+const parseRoutePath = (apiRouteLegs) => ({
+  type: "LineString",
+  coordinates: apiRouteLegs.flatMap(
+    (apiLeg) => apiLeg.points?.map((apiPoint) => [apiPoint.longitude, apiPoint.latitude])
+  )
+});
+const parseLegSectionProps = (apiLegs, params) => apiLegs.reduce((accumulatedParsedLegs, nextApiLeg, currentIndex) => {
+  const lastLegEndPointIndex = currentIndex === 0 ? 0 : accumulatedParsedLegs[currentIndex - 1]?.endPointIndex;
+  let endPointIndex;
+  if (!isNil(lastLegEndPointIndex)) {
+    if (lastLegEndPointIndex === 0) {
+      endPointIndex = nextApiLeg.points?.length > 0 ? nextApiLeg.points.length - 1 : 0;
+    } else {
+      endPointIndex = lastLegEndPointIndex + nextApiLeg.points?.length;
+    }
+  }
+  accumulatedParsedLegs.push({
+    ...!isNil(lastLegEndPointIndex) && { startPointIndex: lastLegEndPointIndex },
+    ...endPointIndex && { endPointIndex },
+    summary: parseSummary(nextApiLeg.summary, params),
+    id: core.generateId()
+  });
+  return accumulatedParsedLegs;
+}, []);
+const toSectionProps = (apiSection) => ({
+  id: core.generateId(),
+  startPointIndex: apiSection.startPointIndex,
+  endPointIndex: apiSection.endPointIndex
+});
+const toRoadStretchSectionProps = (apiSection) => ({
+  ...toSectionProps(apiSection),
+  index: apiSection.importantRoadStretchIndex,
+  streetName: apiSection.streetName?.text,
+  roadNumbers: apiSection.roadNumbers
+});
+const toCountrySectionProps = (apiSection) => ({
+  ...toSectionProps(apiSection),
+  countryCodeISO3: apiSection.countryCode
+});
+const toVehicleRestrictedSectionProps = (apiSection) => apiSection.travelMode === "other" ? toSectionProps(apiSection) : null;
+const toTrafficSectionProps = (apiSection) => ({
+  ...toSectionProps(apiSection),
+  delayInSeconds: apiSection.delayInSeconds,
+  effectiveSpeedInKmh: apiSection.effectiveSpeedInKmh,
+  simpleCategory: apiSection.simpleCategory.toLowerCase(),
+  magnitudeOfDelay: core.indexedMagnitudes[apiSection.magnitudeOfDelay],
+  tec: apiSection.tec
+});
+const toLaneSectionProps = (apiSection) => ({
+  ...toSectionProps(apiSection),
+  lanes: apiSection.lanes,
+  laneSeparators: apiSection.laneSeparators,
+  properties: apiSection.properties
+});
+const toSpeedLimitSectionProps = (apiSection) => ({
+  ...toSectionProps(apiSection),
+  maxSpeedLimitInKmh: apiSection.maxSpeedLimitInKmh
+});
+const toRoadShieldsSectionProps = (apiSection) => ({
+  ...toSectionProps(apiSection),
+  roadShieldReferences: apiSection.roadShieldReferences
+});
+const ensureInit = (sectionType, result) => {
+  if (!result[sectionType]) {
+    result[sectionType] = [];
+  }
+  return result[sectionType];
+};
+const getSectionMapping = (apiSection) => {
+  switch (apiSection.sectionType) {
+    case "CAR_TRAIN":
+      return { sectionType: "carTrain", mappingFunction: toSectionProps };
+    case "COUNTRY":
+      return { sectionType: "country", mappingFunction: toCountrySectionProps };
+    case "FERRY":
+      return { sectionType: "ferry", mappingFunction: toSectionProps };
+    case "MOTORWAY":
+      return { sectionType: "motorway", mappingFunction: toSectionProps };
+    case "PEDESTRIAN":
+      return { sectionType: "pedestrian", mappingFunction: toSectionProps };
+    case "TOLL_VIGNETTE":
+      return { sectionType: "tollVignette", mappingFunction: toCountrySectionProps };
+    case "TOLL":
+      return { sectionType: "toll", mappingFunction: toSectionProps };
+    case "TRAFFIC":
+      return { sectionType: "traffic", mappingFunction: toTrafficSectionProps };
+    case "TRAVEL_MODE":
+      return { sectionType: "vehicleRestricted", mappingFunction: toVehicleRestrictedSectionProps };
+    case "TUNNEL":
+      return { sectionType: "tunnel", mappingFunction: toSectionProps };
+    case "UNPAVED":
+      return { sectionType: "unpaved", mappingFunction: toSectionProps };
+    case "URBAN":
+      return { sectionType: "urban", mappingFunction: toSectionProps };
+    case "CARPOOL":
+      return { sectionType: "carpool", mappingFunction: toSectionProps };
+    case "LOW_EMISSION_ZONE":
+      return { sectionType: "lowEmissionZone", mappingFunction: toSectionProps };
+    case "LANES":
+      return { sectionType: "lanes", mappingFunction: toLaneSectionProps };
+    case "SPEED_LIMIT":
+      return { sectionType: "speedLimit", mappingFunction: toSpeedLimitSectionProps };
+    case "ROAD_SHIELDS":
+      return { sectionType: "roadShields", mappingFunction: toRoadShieldsSectionProps };
+    case "IMPORTANT_ROAD_STRETCH":
+      return { sectionType: "importantRoadStretch", mappingFunction: toRoadStretchSectionProps };
+  }
+};
+const parseSectionsAndAppendToResult = (apiSections, result) => {
+  if (!Array.isArray(apiSections)) {
+    return;
+  }
+  for (const apiSection of apiSections) {
+    const sectionMapping = getSectionMapping(apiSection);
+    const mappedSection = sectionMapping?.mappingFunction(apiSection);
+    if (mappedSection) {
+      ensureInit(sectionMapping.sectionType, result).push(mappedSection);
+    }
+  }
+};
+const parseSections = (apiRoute, params) => {
+  const result = {
+    leg: parseLegSectionProps(apiRoute.legs, params)
+    // (the rest of sections are parsed below)
+  };
+  parseSectionsAndAppendToResult(apiRoute.sections, result);
+  return result;
+};
+const DELTA = 1e-4;
+const similar = (a, b) => Math.abs(a[0] - b[0]) < DELTA && Math.abs(a[1] - b[1]) < DELTA;
+const parseGuidance = (apiGuidance, path) => {
+  const instructions = [];
+  let lastInstructionPathIndex = 0;
+  for (const apiInstruction of apiGuidance.instructions) {
+    const maneuverPoint = [apiInstruction.maneuverPoint.longitude, apiInstruction.maneuverPoint.latitude];
+    for (let pathIndex = lastInstructionPathIndex; pathIndex < path.length; pathIndex++) {
+      if (similar(path[pathIndex], maneuverPoint)) {
+        lastInstructionPathIndex = pathIndex;
+        break;
+      }
+      if (pathIndex === path.length - 1) {
+        break;
+      }
+    }
+    instructions.push({
+      ...apiInstruction,
+      maneuverPoint,
+      pathPointIndex: lastInstructionPathIndex,
+      routePath: apiInstruction.routePath.map((apiPoint) => ({
+        ...apiPoint,
+        point: [apiPoint.point.longitude, apiPoint.point.latitude]
+      }))
+    });
+  }
+  return { instructions };
+};
+const parseRoute = (apiRoute, index, params) => {
+  const geometry = parseRoutePath(apiRoute.legs);
+  const bbox = core.bboxFromGeoJSON(geometry);
+  const id = core.generateId();
+  return {
+    type: "Feature",
+    geometry,
+    id,
+    ...bbox && { bbox },
+    properties: {
+      id,
+      index,
+      summary: parseSummary(apiRoute.summary, params),
+      sections: parseSections(apiRoute, params),
+      ...apiRoute.guidance && { guidance: parseGuidance(apiRoute.guidance, geometry.coordinates) },
+      ...apiRoute.progress && { progress: apiRoute.progress }
+    }
+  };
+};
+const parseCalculateRouteResponse = (apiResponse, params) => {
+  const features = apiResponse.routes.map((apiRoute, index) => parseRoute(apiRoute, index, params));
+  const bbox = core.bboxFromGeoJSON(features);
+  return { type: "FeatureCollection", ...bbox && { bbox }, features };
+};
+const parseRoutingResponseError = (apiError, serviceName) => {
+  const { data, message, status } = apiError;
+  const errorMessage = data?.error?.description ?? data?.detailedError?.message ?? message;
+  return new SDKServiceError(errorMessage, serviceName, status);
+};
+const calculateRouteTemplate = {
+  requestValidation: routeRequestValidationConfig,
+  buildRequest: buildCalculateRouteRequest,
+  sendRequest: fetchWith,
+  parseResponse: parseCalculateRouteResponse,
+  parseResponseError: parseRoutingResponseError,
+  getAPIVersion: () => 2
+};
+const customize = {
+  buildCalculateRouteRequest,
+  parseCalculateRouteResponse,
+  calculateRouteTemplate
+};
+const customizeService = {
+  reverseGeocode: customize$1,
+  geocode: customize$6,
+  geometryData: customize$5,
+  geometrySearch: customize$4,
+  calculateRoute: customize,
+  reachableRange: customize$2,
+  evChargingStationsAvailability: customize$7,
+  placeByID: customize$3,
+  autocompleteSearch: customize$8
+};
+const evChargingStationsAvailability = async (params, customTemplate) => callService(
+  params,
+  { ...evChargingStationsAvailabilityTemplate, ...customTemplate },
+  "EVChargingStationsAvailability"
+);
+const buildPlaceWithEVAvailability = async (place) => {
+  const availabilityId = place.properties.dataSources?.chargingAvailability?.id;
+  if (!availabilityId) {
+    return place;
+  }
+  try {
+    const availability = await evChargingStationsAvailability({ id: availabilityId });
+    const poi = place.properties.poi;
+    return availability ? {
+      ...place,
+      properties: {
+        ...place.properties,
+        // We override poi opening hours with the ones from the EV call, which might be better supported:
+        ...poi && { poi: { ...poi, openingHours: availability.openingHours } },
+        chargingPark: {
+          ...place.properties.chargingPark,
+          availability
+        }
+      }
+    } : place;
+  } catch (e) {
+    console.error(e);
+    return place;
+  }
+};
+const buildPlacesWithEVAvailability = async (places, options = { includeIfAvailabilityUnknown: true }) => {
+  const placesWithAvailability = [];
+  for (const place of places.features) {
+    const placeWithAvailability = await buildPlaceWithEVAvailability(place);
+    if (placeWithAvailability.properties.chargingPark?.availability || options.includeIfAvailabilityUnknown) {
+      placesWithAvailability.push(placeWithAvailability);
+    }
+  }
+  return { ...places, features: placesWithAvailability, bbox: core.bboxFromGeoJSON(placesWithAvailability) };
+};
+const geocode = async (params, customTemplate) => callService(params, { ...geocodingTemplate, ...customTemplate }, "Geocode");
+const geocodeOne = async (query) => (await geocode({ query, limit: 1 })).features[0];
+const mergePlacesWithGeometries = (places, geometries) => {
+  const placesIdMap = places.features.reduce(
+    (acc, place) => {
+      const geometryId = place.properties.dataSources?.geometry?.id;
+      if (geometryId) {
+        acc[geometryId] = {
+          ...place.properties,
+          placeCoordinates: place.geometry.coordinates
+        };
+      }
+      return acc;
+    },
+    {}
+  );
+  const features = geometries.features.map((feature) => {
+    if (feature.id && placesIdMap[feature.id]) {
+      return { ...feature, properties: placesIdMap[feature.id] };
+    }
+    return feature;
+  });
+  return {
+    type: "FeatureCollection",
+    bbox: geometries.bbox,
+    features
+  };
+};
+async function geometryData(params, customTemplate) {
+  const geometryResult = await callService(params, { ...geometryDataTemplate, ...customTemplate }, "GeometryData");
+  if (!Array.isArray(params.geometries) && params.geometries.type === "FeatureCollection") {
+    return mergePlacesWithGeometries(params.geometries, geometryResult);
+  }
+  return geometryResult;
+}
+const placeById = async (params, customTemplate) => callService(params, { ...placeByIdTemplate, ...customTemplate }, "PlaceById");
+const reverseGeocode = async (params, customTemplate) => callService(params, { ...reverseGeocodingTemplate, ...customTemplate }, "ReverseGeocode");
+const calculateRoute = async (params, customTemplate) => callService(params, { ...calculateRouteTemplate, ...customTemplate }, "Routing");
+const fuzzySearchRequestOptional = partial(
+  object({
+    minFuzzyLevel: number().check(_gte(1), _lte(4)),
+    maxFuzzyLevel: number().check(_gte(1), _lte(4))
+  })
+);
+const fuzzySearchRequestSchema = extend(
+  commonSearchParamsSchema,
+  extend(commonGeocodeAndFuzzySearchParamsSchema, fuzzySearchRequestOptional.shape).shape
+);
+const buildUrlBasePath = (mergedOptions) => mergedOptions.customServiceBaseURL ?? `${mergedOptions.commonBaseURL}${PLACES_URL_PATH}/search/${mergedOptions.query}.json`;
+const buildFuzzySearchRequest = (params) => {
+  const url = new URL(`${buildUrlBasePath(params)}`);
+  appendCommonSearchParams(url, params);
+  const urlParams = url.searchParams;
+  appendOptionalParam(urlParams, "typeahead", params.typeahead);
+  appendOptionalParam(urlParams, "ofs", params.offset);
+  appendByJoiningParamValue(urlParams, "countrySet", params.countries);
+  appendOptionalParam(urlParams, "radius", params.radiusMeters);
+  const bbox = params.boundingBox && core.bboxFromGeoJSON(params.boundingBox);
+  if (bbox) {
+    urlParams.append("topLeft", arrayToCSV([bbox[3], bbox[0]]));
+    urlParams.append("btmRight", arrayToCSV([bbox[1], bbox[2]]));
+  }
+  appendOptionalParam(urlParams, "minFuzzyLevel", params.minFuzzyLevel);
+  appendOptionalParam(urlParams, "maxFuzzyLevel", params.maxFuzzyLevel);
+  return url;
+};
+const queryIntentApiToSdk = (intentApi) => {
+  let intent;
+  switch (intentApi.type) {
+    case "COORDINATE":
+      intent = { ...intentApi, details: { position: latLonAPIToPosition(intentApi.details) } };
+      break;
+    case "NEARBY":
+      intent = {
+        ...intentApi,
+        details: {
+          position: latLonAPIToPosition({ lon: intentApi.details.lon, lat: intentApi.details.lat }),
+          text: intentApi.details.text,
+          query: intentApi.details.query
+        }
+      };
+      break;
+    case "BOOKMARK":
+    case "W3W":
+      intent = intentApi;
+  }
+  return intent;
+};
+const parseFuzzySearchResponse = (apiResponse) => {
+  const features = apiResponse.results.map(parseSearchAPIResult);
+  const bbox = core.bboxOnlyIfWithArea(core.bboxFromGeoJSON(features));
+  return {
+    type: "FeatureCollection",
+    properties: {
+      ...parseSummaryAPI(apiResponse.summary),
+      queryIntent: apiResponse.summary.queryIntent.map(queryIntentApiToSdk)
+    },
+    features,
+    ...bbox && { bbox }
+  };
+};
+const fuzzySearchTemplate = {
+  requestValidation: { schema: fuzzySearchRequestSchema },
+  buildRequest: buildFuzzySearchRequest,
+  sendRequest: get,
+  parseResponse: parseFuzzySearchResponse
+};
+const fuzzySearch = async (params, customTemplate) => callService(params, { ...fuzzySearchTemplate, ...customTemplate }, "FuzzySearch");
+const search = async (params, customTemplate) => "geometries" in params ? geometrySearch(params, customTemplate) : fuzzySearch(params, customTemplate);
+exports.APIErrorCode = APIErrorCode;
+exports.SDKError = SDKError;
+exports.SDKServiceError = SDKServiceError;
+exports.autocompleteSearch = autocompleteSearch;
+exports.buildPlaceWithEVAvailability = buildPlaceWithEVAvailability;
+exports.buildPlacesWithEVAvailability = buildPlacesWithEVAvailability;
+exports.buildResponseError = buildResponseError;
+exports.buildValidationError = buildValidationError;
+exports.calculateRoute = calculateRoute;
+exports.customizeService = customizeService;
+exports.evChargingStationsAvailability = evChargingStationsAvailability;
+exports.geocode = geocode;
+exports.geocodeOne = geocodeOne;
+exports.geometryData = geometryData;
+exports.parseDefaultResponseError = parseDefaultResponseError;
+exports.placeById = placeById;
+exports.reverseGeocode = reverseGeocode;
+exports.search = search;
+//# sourceMappingURL=services.cjs.js.map