@chaosity/location-client 0.8.0 → 0.10.0

package/dist/server/LocationServiceConnector.js

@@ -1,9 +1,9 @@
 import debug from 'debug';
+import { VerifyAddressCommand } from '../client/commands.js';
 import { LocationServiceException } from '../errors/LocationServiceException.js';
 import { resolveEndpoint } from '../transport/endpoints.js';
 import { isTokenRejected, noTokenAvailable } from '../transport/errors.js';
 import { requestJson } from '../transport/http.js';
-import { roundPositionFields } from '../utils/roundPosition.js';
 import { readAppConfigClaims } from '../utils/tokenClaims.js';
 import { resolveApiUrl, serverTokenSource } from './getClientConfig.js';
 const log = debug('location-client:connector');
@@ -89,7 +89,13 @@ function explainMissingOrigin(err, sentOrigin) {
  * ```typescript
  * // Credentials and apiUrl from the environment, Origin supplied here
  * const connector = new LocationServiceConnector({ origin: 'https://app.example.com' })
- * const result = await connector.send(new SearchTextCommand({ QueryText: 'Space Needle' }))
+ * const result = await connector.send(
+ *   new SearchTextCommand({
+ *     QueryText: 'Space Needle',
+ *     // SearchText takes exactly one of BiasPosition, Filter.BoundingBox or Filter.Circle.
+ *     BiasPosition: [-122.3493, 47.6205],
+ *   }),
+ * )
  * ```
  */
 export class LocationServiceConnector {
@@ -152,17 +158,19 @@ export class LocationServiceConnector {
     }
     /**
      * This application's own configuration, as carried on the access token
-     * (api#65) — bias precision, and the countries it is scoped to.
+     * (api#65): the routes it may call, the domain its requests must come from,
+     * and the countries it is scoped to (#40).
      *
      * Provided so an application can SHOW its own settings: populate a country
      * selector with the markets it actually serves, label a settings screen, and
      * so on. Being a few minutes stale is cosmetic for that.
      *
      * It is not an entitlement check. See AppConfigClaims for why acting on
-     * `countries` client-side makes requests fail that would otherwise succeed.
+     * any of it client-side makes requests fail that would otherwise succeed.
      *
-     * Returns `{}` when the token carries no application config, which is the
-     * case until one is configured in the portal.
+     * Every token the API issues carries `allowedResources` and `allowedDomain`;
+     * `countries` only once a scope is configured in the portal. Returns `{}`
+     * for a token carrying none of them.
      */
     async getAppConfig() {
         return readAppConfigClaims(await this.source().get());
@@ -190,6 +198,17 @@ export class LocationServiceConnector {
             throw explainMissingOrigin(err, this.effectiveOrigin(options));
         }
     }
+    /**
+     * Verify a PlaceId: `send(new VerifyAddressCommand({ PlaceId }))`, typed
+     * (#54). Resolves the full place record plus `verified`, and resolves a
+     * `verified: false` too — see VerifyAddressResponse for what may be stored.
+     *
+     * Billed per call, whether or not the address verifies: call it once per
+     * chosen PlaceId, never per keystroke.
+     */
+    verifyAddress(placeId, options) {
+        return this.send(new VerifyAddressCommand({ PlaceId: placeId }), options);
+    }
     async dispatchWithRetry(source, url, cmd, options) {
         const token = await source.get();
         if (!token)
@@ -214,13 +233,12 @@ export class LocationServiceConnector {
         }
     }
     dispatch(url, token, cmd, options) {
-        // The token is resolved before the request is shaped, so the precision this
-        // application is entitled to is available (api#65). Absent claim -> the
-        // 3 dp floor, which is what every application gets until one is configured
-        // otherwise. Recomputed per attempt because a refreshed token may carry
-        // different claims.
-        const { biasDecimals } = readAppConfigClaims(token);
-        const input = roundPositionFields(cmd.input, biasDecimals);
+        // The caller's input goes out as the caller wrote it — nothing in the body
+        // is derived from the token any more. `BiasPosition` used to be rounded
+        // here to a grid sized by a token claim, so nearby callers shared a server
+        // cache entry; with no cache the rounding only lowered the precision the
+        // upstream geocoder had to work with, which moves the results rather than
+        // coarsening them (#51).
         // Every system header is set exactly ONCE, and the caller's own spelling of
         // each is dropped first.
         //
@@ -245,7 +263,7 @@ export class LocationServiceConnector {
             Authorization: `Bearer ${token}`,
         };
         log('Sending %s request to %s', cmd.constructor?.name, url);
-        return requestJson(url, { method: 'POST', headers, body: JSON.stringify(input) }, options);
+        return requestJson(url, { method: 'POST', headers, body: JSON.stringify(cmd.input) }, options);
     }
 }
 function requireApiUrl(explicit) {

package/dist/transport/endpoints.js

@@ -1,4 +1,5 @@
 import { AutocompleteCommand, GeocodeCommand, GetPlaceCommand, ReverseGeocodeCommand, SearchNearbyCommand, SearchTextCommand, SuggestCommand, } from '@aws-sdk/client-geo-places';
+import { VerifyAddressCommand } from '../client/commands.js';
 import { LocationServiceException } from '../errors/LocationServiceException.js';
 /**
  * Command class -> API path.
@@ -17,6 +18,8 @@ const ENDPOINTS = new Map([
     [SearchNearbyCommand, '/address/search/nearby'],
     [SearchTextCommand, '/address/search/text'],
     [SuggestCommand, '/address/suggestion'],
+    // This package's own: the route has no AWS command (#54).
+    [VerifyAddressCommand, '/address/verify'],
 ]);
 export function resolveEndpoint(command) {
     for (const [CommandClass, endpoint] of ENDPOINTS) {

package/dist/transport/http.d.ts

@@ -4,8 +4,8 @@ export declare const DEFAULT_TIMEOUT_MS = 10000;
  * Ceiling for the WHOLE call — every attempt plus every wait between them.
  *
  * `timeoutMs` bounds an attempt, not a call, and the gap between those two is
- * where the caller's own deadline disappears. The API answers a spent quota
- * with `Retry-After: 60`, which the retry loop honoured literally: two waits of
+ * where the caller's own deadline disappears. Nothing bounds the `Retry-After`
+ * a 429 carries, and the retry loop honoured one of 60 s literally: two waits of
  * a minute each, so one call could sit for ~120 s — past any Lambda budget,
  * past any HTTP gateway, and until now uncancellable (#37).
  *

package/dist/transport/http.js

@@ -8,8 +8,8 @@ export const DEFAULT_TIMEOUT_MS = 10000;
  * Ceiling for the WHOLE call — every attempt plus every wait between them.
  *
  * `timeoutMs` bounds an attempt, not a call, and the gap between those two is
- * where the caller's own deadline disappears. The API answers a spent quota
- * with `Retry-After: 60`, which the retry loop honoured literally: two waits of
+ * where the caller's own deadline disappears. Nothing bounds the `Retry-After`
+ * a 429 carries, and the retry loop honoured one of 60 s literally: two waits of
  * a minute each, so one call could sit for ~120 s — past any Lambda budget,
  * past any HTTP gateway, and until now uncancellable (#37).
  *

package/dist/types/index.d.ts

@@ -42,11 +42,12 @@ export interface ClientConfig {
     refreshToken?: () => Promise<string | undefined>;
 }
 /**
- * Minimal interface for AWS SDK command objects.
- * All AWS SDK commands (AutocompleteCommand, SearchTextCommand, etc.) extend
- * Smithy's Command base class which has an `input` property containing the
- * request parameters. This interface captures what we actually need from
- * commands without coupling to Smithy internals.
+ * Minimal interface for a command object: the AWS SDK's, and this package's
+ * own `VerifyAddressCommand` (#54). The SDK's commands (AutocompleteCommand,
+ * SearchTextCommand, etc.) extend Smithy's Command base class, which has an
+ * `input` property containing the request parameters; `VerifyAddressCommand`
+ * has the same `input` and nothing else. This interface captures what we
+ * actually need from commands without coupling to Smithy internals.
  */
 export interface GeoPlacesCommand {
     readonly input: object;

package/dist/utils/tokenClaims.d.ts

@@ -1,29 +1,29 @@
 /**
  * Read advisory application config out of the access token (api#65).
  *
- * The API puts an application's own settings — `biasDecimals`, `countries` —
- * into the JWT alongside `allowedDomain` and `allowedResources`, so this
- * library can stop hard-coding values it has no other way of knowing.
+ * The API puts an application's own settings into the JWT — `countries`,
+ * `allowedResources` and `allowedDomain` — so this library can stop
+ * hard-coding values it has no other way of knowing. The last two were in the
+ * token all along and were not surfaced until #40, so an application could
+ * only learn it lacked a route from the 403.
+ *
+ * `biasDecimals` used to be here too. It sized the grid this library rounded
+ * `BiasPosition` onto, so that nearby callers shared a server cache entry; the
+ * cache is gone, the API issues no such claim, and rounding a coordinate with
+ * nothing to share it with only lowered the precision the upstream geocoder
+ * received (#51).
  *
  * DELIBERATELY UNVERIFIED, and that is safe. This library has no signing key
  * and does not need one: every claim here is re-read from the application row
  * by the API on each request, and the API's answer is the one that counts. A
  * forged token would fail at the authorizer long before any of this mattered.
- * What is read here only decides how the request is SHAPED — a hint, never a
- * permission.
+ * Nothing read here reaches a request at all now — it is displayed, never
+ * acted on, so a forged value misinforms only the caller who forged it.
  *
  * A JWT is signed, not encrypted, so the payload is plain base64url. Nothing
  * secret is in it; these are the caller's own settings.
  */
 export interface AppConfigClaims {
-    /**
-     * Bias precision this application is entitled to.
-     *
-     * Safe to act on: it only changes how a coordinate is rounded before
-     * sending, and the server re-rounds to its own configured value anyway. A
-     * stale value here costs precision, never correctness.
-     */
-    biasDecimals?: number;
     /**
      * Countries this application may search, ISO 3166-1 alpha-2.
      *
@@ -44,6 +44,30 @@ export interface AppConfigClaims {
      * Sending nothing and letting the API scope the request is always correct.
      */
     countries?: string[];
+    /**
+     * The routes this application may call, as the API names them — method and
+     * route template, such as `POST /address/autocomplete` or
+     * `GET /maps/static/{fileName}` (#40).
+     *
+     * So an application can ask "may I call the static-map route?" before it
+     * offers one, rather than only learning from the 403. It answers for the
+     * route, not for the options sent on it: a plan feature (`@planFeature`) is
+     * answered only by its own 403, and a static map's default Satellite render
+     * is one (#55). The same rule as `countries`
+     * applies, for the same reason: show it, never refuse with it. A route
+     * granted since the token was minted is answered by the API, which reads the
+     * entitlement fresh on every request.
+     *
+     * The API issues this claim JSON-encoded — a string holding the list —
+     * because it copies the application's stored setting. Both forms are read.
+     */
+    allowedResources?: string[];
+    /**
+     * The domain this application's requests must come from (#40). A request
+     * whose `Origin` is neither this host nor one of its subdomains is refused
+     * 403, so this is what to show next to "Origin not allowed".
+     */
+    allowedDomain?: string;
 }
 /**
  * Decode a JWT payload without verifying it.

package/dist/utils/tokenClaims.js

@@ -1,20 +1,43 @@
 /**
  * Read advisory application config out of the access token (api#65).
  *
- * The API puts an application's own settings — `biasDecimals`, `countries` —
- * into the JWT alongside `allowedDomain` and `allowedResources`, so this
- * library can stop hard-coding values it has no other way of knowing.
+ * The API puts an application's own settings into the JWT — `countries`,
+ * `allowedResources` and `allowedDomain` — so this library can stop
+ * hard-coding values it has no other way of knowing. The last two were in the
+ * token all along and were not surfaced until #40, so an application could
+ * only learn it lacked a route from the 403.
+ *
+ * `biasDecimals` used to be here too. It sized the grid this library rounded
+ * `BiasPosition` onto, so that nearby callers shared a server cache entry; the
+ * cache is gone, the API issues no such claim, and rounding a coordinate with
+ * nothing to share it with only lowered the precision the upstream geocoder
+ * received (#51).
  *
  * DELIBERATELY UNVERIFIED, and that is safe. This library has no signing key
  * and does not need one: every claim here is re-read from the application row
  * by the API on each request, and the API's answer is the one that counts. A
  * forged token would fail at the authorizer long before any of this mattered.
- * What is read here only decides how the request is SHAPED — a hint, never a
- * permission.
+ * Nothing read here reaches a request at all now — it is displayed, never
+ * acted on, so a forged value misinforms only the caller who forged it.
  *
  * A JWT is signed, not encrypted, so the payload is plain base64url. Nothing
  * secret is in it; these are the caller's own settings.
  */
+/** A list of strings, whether the claim carries it as a list or JSON-encoded. */
+function readStringList(value) {
+    let list = value;
+    if (typeof list === 'string') {
+        try {
+            list = JSON.parse(list);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (!Array.isArray(list))
+        return undefined;
+    return list.filter((v) => typeof v === 'string');
+}
 /**
  * Decode a JWT payload without verifying it.
  *
@@ -36,20 +59,19 @@ export function readAppConfigClaims(token) {
         const json = decodeURIComponent(Array.from(atob(padded), (c) => `%${c.charCodeAt(0).toString(16).padStart(2, '0')}`).join(''));
         const payload = JSON.parse(json);
         const claims = {};
-        if (typeof payload.biasDecimals === 'number') {
-            claims.biasDecimals = payload.biasDecimals;
-        }
-        else if (typeof payload.biasDecimals === 'string' &&
-            payload.biasDecimals.trim() !== '') {
-            const n = Number(payload.biasDecimals);
-            if (Number.isFinite(n))
-                claims.biasDecimals = n;
-        }
         if (Array.isArray(payload.countries)) {
             const list = payload.countries.filter((c) => typeof c === 'string');
             if (list.length)
                 claims.countries = list;
         }
+        // Kept when empty, unlike countries: no countries means "search the
+        // world", but no resources means an application entitled to nothing.
+        const resources = readStringList(payload.allowedResources);
+        if (resources)
+            claims.allowedResources = resources;
+        if (typeof payload.allowedDomain === 'string' && payload.allowedDomain) {
+            claims.allowedDomain = payload.allowedDomain;
+        }
         return claims;
     }
     catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chaosity/location-client",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "Client library for Chaosity Location Service with AWS Location Service compatibility",
   "type": "module",
   "main": "dist/cjs/index.js",

package/dist/cjs/utils/roundPosition.d.ts

@@ -1,66 +0,0 @@
-/**
- * Round coordinate arrays in command inputs so nearby callers share a server
- * cache entry.
- *
- * `BiasPosition` is a hint about where to look, so collapsing it onto a grid
- * lets two users in the same area reuse one upstream answer. `QueryPosition`
- * is not a hint — reverse-geocode resolves an exact point a user clicked or a
- * device reported, and rounding it returns a neighbour's address. It is left
- * alone (RFC-0001 §2).
- *
- * WHY THE DEFAULT MOVED FROM 2 dp TO 3 dp
- *
- * 2 dp is a ~1.1 km grid, and that is not a coarser answer — it is a wrong
- * one. Measured against Amazon Location directly, `QueryText: "cafe"` from
- * Sydney CBD returns a completely different set of places when the bias moves
- * 111 m:
- *
- *   base      -> Crepe de Paris | Deli Ziosa | CBD Patisserie
- *   +111 m    -> Cafe Chocolat  | Paradiso Cafe | Incanto Coffee
- *
- * So two users a kilometre apart both received whichever places were nearest
- * the FIRST of them, with nothing in the response saying so. The server moved
- * to 3 dp in api#21 — but this library rounds BEFORE sending, on both the
- * browser and server paths, so the precision was already gone by the time the
- * request arrived and that fix never reached anyone using the SDK. This is
- * what makes it reach them.
- *
- * The cost is hit rate: cells shrink 100x in area. RFC-0001 §5 expected only
- * "single-digit to low-double-digit percent" in mixed traffic, so there was
- * little to protect, and a miss costs one upstream call while a wrong answer
- * costs trust.
- */
-/** The server's floor (api#65). A request for less is clamped up to it. */
-export declare const DEFAULT_BIAS_DECIMALS = 3;
-/**
- * The band the server enforces (api#65). Mirrored here so the value this
- * library rounds to is the value the server will actually key its cache by —
- * rounding to something outside the band just means being wrong about what
- * was sent.
- *
- * The floor is correctness: below 3 dp the nearest places are not the ones
- * returned. The ceiling is cost: cells shrink 100x in area per decimal, so
- * finer precision collapses the cache hit rate and every miss is a billable
- * upstream call.
- */
-export declare const MIN_BIAS_DECIMALS = 3;
-export declare const MAX_BIAS_DECIMALS = 5;
-/**
- * Clamp a requested precision into the allowed band.
- *
- * Anything absent or malformed becomes the default rather than throwing: this
- * runs on every request, and a surprising token claim must not break geocoding
- * for an application that is otherwise working.
- */
-export declare function clampBiasDecimals(requested?: unknown): number;
-/**
- * Shallow-clone the input and round position arrays that benefit from caching.
- * Returns the original object if no position fields are present.
- *
- * @param input      the command input
- * @param decimals   precision for this application; defaults to the floor.
- *                   Comes from the `biasDecimals` JWT claim where the token
- *                   carries one (api#65) — an application entitled to finer
- *                   bias gets it without the caller configuring anything.
- */
-export declare function roundPositionFields<T extends object>(input: T, decimals?: number): T;

package/dist/cjs/utils/roundPosition.js

@@ -1,109 +0,0 @@
-"use strict";
-/**
- * Round coordinate arrays in command inputs so nearby callers share a server
- * cache entry.
- *
- * `BiasPosition` is a hint about where to look, so collapsing it onto a grid
- * lets two users in the same area reuse one upstream answer. `QueryPosition`
- * is not a hint — reverse-geocode resolves an exact point a user clicked or a
- * device reported, and rounding it returns a neighbour's address. It is left
- * alone (RFC-0001 §2).
- *
- * WHY THE DEFAULT MOVED FROM 2 dp TO 3 dp
- *
- * 2 dp is a ~1.1 km grid, and that is not a coarser answer — it is a wrong
- * one. Measured against Amazon Location directly, `QueryText: "cafe"` from
- * Sydney CBD returns a completely different set of places when the bias moves
- * 111 m:
- *
- *   base      -> Crepe de Paris | Deli Ziosa | CBD Patisserie
- *   +111 m    -> Cafe Chocolat  | Paradiso Cafe | Incanto Coffee
- *
- * So two users a kilometre apart both received whichever places were nearest
- * the FIRST of them, with nothing in the response saying so. The server moved
- * to 3 dp in api#21 — but this library rounds BEFORE sending, on both the
- * browser and server paths, so the precision was already gone by the time the
- * request arrived and that fix never reached anyone using the SDK. This is
- * what makes it reach them.
- *
- * The cost is hit rate: cells shrink 100x in area. RFC-0001 §5 expected only
- * "single-digit to low-double-digit percent" in mixed traffic, so there was
- * little to protect, and a miss costs one upstream call while a wrong answer
- * costs trust.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MAX_BIAS_DECIMALS = exports.MIN_BIAS_DECIMALS = exports.DEFAULT_BIAS_DECIMALS = void 0;
-exports.clampBiasDecimals = clampBiasDecimals;
-exports.roundPositionFields = roundPositionFields;
-/** The server's floor (api#65). A request for less is clamped up to it. */
-exports.DEFAULT_BIAS_DECIMALS = 3;
-/**
- * The band the server enforces (api#65). Mirrored here so the value this
- * library rounds to is the value the server will actually key its cache by —
- * rounding to something outside the band just means being wrong about what
- * was sent.
- *
- * The floor is correctness: below 3 dp the nearest places are not the ones
- * returned. The ceiling is cost: cells shrink 100x in area per decimal, so
- * finer precision collapses the cache hit rate and every miss is a billable
- * upstream call.
- */
-exports.MIN_BIAS_DECIMALS = 3;
-exports.MAX_BIAS_DECIMALS = 5;
-/**
- * Clamp a requested precision into the allowed band.
- *
- * Anything absent or malformed becomes the default rather than throwing: this
- * runs on every request, and a surprising token claim must not break geocoding
- * for an application that is otherwise working.
- */
-function clampBiasDecimals(requested) {
-    const n = Number(requested);
-    if ((typeof requested !== 'number' &&
-        !(typeof requested === 'string' && requested.trim() !== '')) ||
-        !Number.isFinite(n)) {
-        return exports.DEFAULT_BIAS_DECIMALS;
-    }
-    const floored = Math.floor(n);
-    if (floored < exports.MIN_BIAS_DECIMALS)
-        return exports.MIN_BIAS_DECIMALS;
-    if (floored > exports.MAX_BIAS_DECIMALS)
-        return exports.MAX_BIAS_DECIMALS;
-    return floored;
-}
-/** Known position field names and whether they should be rounded */
-const POSITION_FIELDS = {
-    BiasPosition: true, // geocode, autocomplete, search — round for cache
-    QueryPosition: false, // reverse geocode — keep full precision
-};
-function roundCoord(value, decimals) {
-    const factor = 10 ** decimals;
-    return Math.round(value * factor) / factor;
-}
-/**
- * Shallow-clone the input and round position arrays that benefit from caching.
- * Returns the original object if no position fields are present.
- *
- * @param input      the command input
- * @param decimals   precision for this application; defaults to the floor.
- *                   Comes from the `biasDecimals` JWT claim where the token
- *                   carries one (api#65) — an application entitled to finer
- *                   bias gets it without the caller configuring anything.
- */
-function roundPositionFields(input, decimals = exports.DEFAULT_BIAS_DECIMALS) {
-    if (!input || typeof input !== 'object')
-        return input;
-    const dp = clampBiasDecimals(decimals);
-    let cloned = null;
-    for (const [field, shouldRound] of Object.entries(POSITION_FIELDS)) {
-        if (!shouldRound)
-            continue;
-        const value = input[field];
-        if (!Array.isArray(value))
-            continue;
-        if (!cloned)
-            cloned = { ...input };
-        cloned[field] = value.map((v) => typeof v === 'number' && Number.isFinite(v) ? roundCoord(v, dp) : v);
-    }
-    return cloned ?? input;
-}

package/dist/utils/roundPosition.d.ts

@@ -1,66 +0,0 @@
-/**
- * Round coordinate arrays in command inputs so nearby callers share a server
- * cache entry.
- *
- * `BiasPosition` is a hint about where to look, so collapsing it onto a grid
- * lets two users in the same area reuse one upstream answer. `QueryPosition`
- * is not a hint — reverse-geocode resolves an exact point a user clicked or a
- * device reported, and rounding it returns a neighbour's address. It is left
- * alone (RFC-0001 §2).
- *
- * WHY THE DEFAULT MOVED FROM 2 dp TO 3 dp
- *
- * 2 dp is a ~1.1 km grid, and that is not a coarser answer — it is a wrong
- * one. Measured against Amazon Location directly, `QueryText: "cafe"` from
- * Sydney CBD returns a completely different set of places when the bias moves
- * 111 m:
- *
- *   base      -> Crepe de Paris | Deli Ziosa | CBD Patisserie
- *   +111 m    -> Cafe Chocolat  | Paradiso Cafe | Incanto Coffee
- *
- * So two users a kilometre apart both received whichever places were nearest
- * the FIRST of them, with nothing in the response saying so. The server moved
- * to 3 dp in api#21 — but this library rounds BEFORE sending, on both the
- * browser and server paths, so the precision was already gone by the time the
- * request arrived and that fix never reached anyone using the SDK. This is
- * what makes it reach them.
- *
- * The cost is hit rate: cells shrink 100x in area. RFC-0001 §5 expected only
- * "single-digit to low-double-digit percent" in mixed traffic, so there was
- * little to protect, and a miss costs one upstream call while a wrong answer
- * costs trust.
- */
-/** The server's floor (api#65). A request for less is clamped up to it. */
-export declare const DEFAULT_BIAS_DECIMALS = 3;
-/**
- * The band the server enforces (api#65). Mirrored here so the value this
- * library rounds to is the value the server will actually key its cache by —
- * rounding to something outside the band just means being wrong about what
- * was sent.
- *
- * The floor is correctness: below 3 dp the nearest places are not the ones
- * returned. The ceiling is cost: cells shrink 100x in area per decimal, so
- * finer precision collapses the cache hit rate and every miss is a billable
- * upstream call.
- */
-export declare const MIN_BIAS_DECIMALS = 3;
-export declare const MAX_BIAS_DECIMALS = 5;
-/**
- * Clamp a requested precision into the allowed band.
- *
- * Anything absent or malformed becomes the default rather than throwing: this
- * runs on every request, and a surprising token claim must not break geocoding
- * for an application that is otherwise working.
- */
-export declare function clampBiasDecimals(requested?: unknown): number;
-/**
- * Shallow-clone the input and round position arrays that benefit from caching.
- * Returns the original object if no position fields are present.
- *
- * @param input      the command input
- * @param decimals   precision for this application; defaults to the floor.
- *                   Comes from the `biasDecimals` JWT claim where the token
- *                   carries one (api#65) — an application entitled to finer
- *                   bias gets it without the caller configuring anything.
- */
-export declare function roundPositionFields<T extends object>(input: T, decimals?: number): T;