@tileflow/search 0.1.0-alpha.2 → 0.1.0-alpha.4

package/dist/{chunk-EDYCZVXI.js → chunk-W66J2DAS.js}

@@ -16,7 +16,10 @@ var geocodingLimits = Object.freeze({
   maximumResponseBytes: 64 * 1024,
   maximumSafeErrorBytes: 8 * 1024,
   maximumSourceCharacters: 128,
-  maximumSuggestionTokenCharacters: 2048
+  maximumSuggestionTokenCharacters: 2048,
+  maximumDetailEntries: 100,
+  maximumOpeningHoursEntries: 20,
+  maximumOpeningHoursLines: 50
 });
 var boundedText = (maximum) => z.string().trim().min(1).max(maximum).refine((value) => !controlCharacterPattern.test(value), {
   message: "Control characters are not allowed"
@@ -24,12 +27,18 @@ var boundedText = (maximum) => z.string().trim().min(1).max(maximum).refine((val
 var longitude = z.number().finite().min(-180).max(180);
 var latitude = z.number().finite().min(-90).max(90);
 var geocodingPositionSchema = z.tuple([longitude, latitude]);
-var geocodingRetentionModes = ["temporary", "persistent"];
-var geocodingBoundsSchema = z.tuple([longitude, latitude, longitude, latitude]).refine(([west, south, east]) => west < east, { message: "West must be less than east" }).refine(([, south, , north]) => south < north, {
+var geocodingRetentionModes = ["temporary"];
+var geocodingBoundsSchema = z.tuple([longitude, latitude, longitude, latitude]).refine(([west, , east]) => west < east, { message: "West must be less than east" }).refine(([, south, , north]) => south < north, {
   message: "South must be less than north"
 });
+var searchPlaceDetails = ["contacts", "openingHours", "timeZone", "accessPoints"];
+var searchPlaceDetailSchema = z.enum(searchPlaceDetails);
+var searchPlaceDetailsSchema = z.array(searchPlaceDetailSchema).min(1).max(searchPlaceDetails.length).refine((values) => new Set(values).size === values.length, {
+  message: "Place details must be unique"
+});
 var geocodingForwardRequestSchema = z.object({
   bounds: geocodingBoundsSchema.optional(),
+  include: searchPlaceDetailsSchema.optional(),
   language: z.string().max(geocodingLimits.maximumLanguageCharacters).regex(languagePattern).optional(),
   limit: z.number().int().min(1).max(geocodingLimits.maximumLimit).optional(),
   proximity: geocodingPositionSchema.optional(),
@@ -39,8 +48,10 @@ var geocodingForwardRequestSchema = z.object({
   message: "Bounds and proximity are mutually exclusive",
   path: ["proximity"]
 });
+var autocompleteIncludeSchema = z.tuple([z.literal("place")]);
 var autocompleteRequestSchema = z.object({
   bounds: geocodingBoundsSchema.optional(),
+  include: autocompleteIncludeSchema.optional(),
   language: z.string().max(geocodingLimits.maximumLanguageCharacters).regex(languagePattern).optional(),
   limit: z.number().int().min(1).max(geocodingLimits.maximumLimit).default(geocodingLimits.defaultLimit),
   proximity: geocodingPositionSchema.optional(),
@@ -51,6 +62,7 @@ var autocompleteRequestSchema = z.object({
 });
 var reverseGeocodingKindSchema = z.enum(["address", "street", "locality", "place"]);
 var geocodingReverseRequestSchema = z.object({
+  include: searchPlaceDetailsSchema.optional(),
   kinds: z.array(reverseGeocodingKindSchema).min(1).max(4).optional(),
   language: z.string().max(geocodingLimits.maximumLanguageCharacters).regex(languagePattern).optional(),
   limit: z.number().int().min(1).max(geocodingLimits.maximumLimit).default(geocodingLimits.defaultReverseLimit),
@@ -82,7 +94,51 @@ var geocodingAddressSchema = z.object({
   region: addressPart.optional(),
   street: addressPart.optional()
 }).strict();
+var searchLiteralText = (maximum) => z.string().min(1).max(maximum).refine((value) => !/[\p{Cc}\p{Cs}]/u.test(value));
+var searchCategoryIdSchema = searchLiteralText(100);
+var searchCategorySchema = z.object({
+  id: searchCategoryIdSchema,
+  name: searchLiteralText(100),
+  localizedName: searchLiteralText(100).optional(),
+  primary: z.boolean().optional()
+}).strict();
+var searchPlaceMetadata = {
+  name: searchLiteralText(200).optional(),
+  categories: z.array(searchCategorySchema).min(1).max(100).optional(),
+  foodTypes: z.array(searchCategorySchema).min(1).max(100).optional(),
+  businessChains: z.array(z.object({ id: searchLiteralText(100), name: searchLiteralText(100) }).strict()).min(1).max(100).optional()
+};
+var contactListSchema = z.array(
+  z.object({
+    value: searchLiteralText(2048),
+    label: searchLiteralText(256).optional()
+  }).strict()
+).min(1).max(geocodingLimits.maximumDetailEntries);
+var searchContactsSchema = z.object({
+  phones: contactListSchema.optional(),
+  websites: contactListSchema.optional(),
+  emails: contactListSchema.optional()
+}).strict();
+var searchOpeningHoursSchema = z.array(
+  z.object({
+    display: z.array(searchLiteralText(256)).min(1).max(geocodingLimits.maximumOpeningHoursLines).optional(),
+    openNow: z.boolean().optional()
+  }).strict()
+).min(1).max(geocodingLimits.maximumOpeningHoursEntries);
+var searchTimeZoneSchema = z.object({
+  name: searchLiteralText(64),
+  utcOffsetSeconds: z.number().int().min(-86400).max(86400).optional()
+}).strict();
+var searchPlaceDetailFields = {
+  distanceMeters: z.number().finite().nonnegative().optional(),
+  contacts: searchContactsSchema.optional(),
+  openingHours: searchOpeningHoursSchema.optional(),
+  timeZone: searchTimeZoneSchema.optional(),
+  accessPoints: z.array(z.object({ position: geocodingPositionSchema }).strict()).min(1).max(geocodingLimits.maximumDetailEntries).optional()
+};
 var geocodingResultSchema = z.object({
+  ...searchPlaceMetadata,
+  ...searchPlaceDetailFields,
   address: geocodingAddressSchema,
   bounds: geocodingBoundsSchema.optional(),
   kind: z.enum(geocodingResultKinds),
@@ -102,27 +158,32 @@ var geocodingAttributionSchema = z.object({
     message: "Expected an HTTPS URL without credentials"
   }).optional()
 }).strict();
+var placeOperationUnitsSchema = z.union([z.literal(25), z.literal(75)]);
 var geocodingForwardResponseSchema = z.object({
   attribution: z.array(geocodingAttributionSchema).min(1).max(geocodingLimits.maximumAttributionEntries),
   queryId: z.string().regex(queryIdPattern),
   results: z.array(geocodingResultSchema).max(geocodingLimits.maximumLimit),
   schemaVersion: z.literal(1),
   source: geocodingSourceSchema,
-  usage: z.object({ units: z.literal(1) }).strict()
+  usage: z.object({ units: placeOperationUnitsSchema }).strict()
 }).strict();
 var geocodingReverseResponseSchema = geocodingForwardResponseSchema;
 var geocodingSuggestionSchema = z.object({
   kind: z.enum(geocodingResultKinds),
   label: boundedText(512),
+  addressLabel: boundedText(512).optional(),
+  place: geocodingResultSchema.optional(),
   token: z.string().min(1).max(geocodingLimits.maximumSuggestionTokenCharacters).regex(/^[\x21-\x7e]+$/u)
 }).strict();
 var autocompleteResponseSchema = z.object({
   attribution: z.array(geocodingAttributionSchema).min(1).max(geocodingLimits.maximumAttributionEntries),
   schemaVersion: z.literal(1),
   source: geocodingSourceSchema,
-  suggestions: z.array(geocodingSuggestionSchema).max(geocodingLimits.maximumLimit)
+  suggestions: z.array(geocodingSuggestionSchema).max(geocodingLimits.maximumLimit),
+  usage: z.object({ units: z.union([z.literal(10), z.literal(25)]) }).strict()
 }).strict();
 var resolveSuggestionRequestSchema = z.object({
+  include: searchPlaceDetailsSchema.optional(),
   retention: z.enum(geocodingRetentionModes).default("temporary"),
   token: z.string().min(1).max(geocodingLimits.maximumSuggestionTokenCharacters).regex(/^[\x21-\x7e]+$/u)
 }).strict();
@@ -131,7 +192,7 @@ var resolveSuggestionResponseSchema = z.object({
   result: geocodingResultSchema,
   schemaVersion: z.literal(1),
   source: geocodingSourceSchema,
-  usage: z.object({ units: z.literal(1) }).strict()
+  usage: z.object({ units: placeOperationUnitsSchema }).strict()
 }).strict();
 function isCredentialFreeHttpsUrl(value) {
   try {
@@ -141,18 +202,87 @@ function isCredentialFreeHttpsUrl(value) {
     return false;
   }
 }
+var nearbyLimits = Object.freeze({
+  defaultLimit: 20,
+  maximumLimit: 100,
+  maximumRadiusMeters: 21e6,
+  maximumCategoryCharacters: 100,
+  maximumFilterCategories: 10,
+  maximumCountries: 100,
+  maximumCursorCharacters: 8192,
+  maximumRequestBytes: 32 * 1024,
+  maximumResponseBytes: 512 * 1024
+});
+var nearbyCursorSchema = z.string().min(1).max(nearbyLimits.maximumCursorCharacters).regex(/^[\x21-\x7e]+$/u);
+var categoryFilter = z.array(searchCategoryIdSchema).min(1).max(nearbyLimits.maximumFilterCategories);
+var nearbyRequestSchema = z.object({
+  position: geocodingPositionSchema,
+  radiusMeters: z.number().int().min(1).max(nearbyLimits.maximumRadiusMeters).optional(),
+  bounds: geocodingBoundsSchema.optional(),
+  includeCategories: categoryFilter.optional(),
+  excludeCategories: categoryFilter.optional(),
+  countries: z.array(z.string().regex(/^(?:[A-Z]{2}|[A-Z]{3})$/u)).min(1).max(nearbyLimits.maximumCountries).optional(),
+  language: geocodingForwardRequestSchema.shape.language,
+  include: searchPlaceDetailsSchema.optional(),
+  limit: z.number().int().min(1).max(nearbyLimits.maximumLimit).default(nearbyLimits.defaultLimit),
+  cursor: nearbyCursorSchema.optional()
+}).strict();
+var nearbyPlaceSchema = geocodingResultSchema.omit({ sourceRef: true }).extend({
+  kind: z.literal("place"),
+  token: geocodingSuggestionSchema.shape.token.optional()
+}).strict();
+var nearbyResponseSchema = z.object({
+  schemaVersion: z.literal(1),
+  provider: z.literal("aws"),
+  results: z.array(nearbyPlaceSchema).max(nearbyLimits.maximumLimit),
+  nextCursor: nearbyCursorSchema.optional(),
+  source: geocodingSourceSchema,
+  attribution: geocodingForwardResponseSchema.shape.attribution,
+  usage: z.object({ units: placeOperationUnitsSchema }).strict()
+}).strict().refine(
+  (value) => new TextEncoder().encode(JSON.stringify(value)).byteLength <= nearbyLimits.maximumResponseBytes,
+  { message: "Nearby response exceeds the encoded byte limit" }
+);
+var searchCategoriesResponseSchema = z.object({
+  schemaVersion: z.literal(1),
+  provider: z.literal("aws"),
+  categories: z.array(searchCategorySchema).min(1).max(2e3),
+  source: geocodingSourceSchema,
+  attribution: geocodingForwardResponseSchema.shape.attribution,
+  usage: z.object({ units: z.literal(0) }).strict()
+}).strict();
+var resolvePlaceRequestSchema = resolveSuggestionRequestSchema;
+var resolvePlaceResponseSchema = resolveSuggestionResponseSchema;
+var searchContactDetails = ["contacts", "openingHours"];
+function searchOperationUnits(operation, include) {
+  if (operation === "categories") return 0;
+  if (operation === "autocomplete") return include?.length ? 25 : 10;
+  return include?.length ? 75 : 25;
+}
 
 export {
   geocodingLimits,
   geocodingPositionSchema,
   geocodingRetentionModes,
   geocodingBoundsSchema,
+  searchPlaceDetails,
+  searchPlaceDetailSchema,
+  searchPlaceDetailsSchema,
   geocodingForwardRequestSchema,
+  autocompleteIncludeSchema,
   autocompleteRequestSchema,
   reverseGeocodingKindSchema,
   geocodingReverseRequestSchema,
   geocodingResultKinds,
   geocodingAddressSchema,
+  searchLiteralText,
+  searchCategoryIdSchema,
+  searchCategorySchema,
+  searchPlaceMetadata,
+  searchContactsSchema,
+  searchOpeningHoursSchema,
+  searchTimeZoneSchema,
+  searchPlaceDetailFields,
   geocodingResultSchema,
   geocodingSourceSchema,
   geocodingAttributionSchema,
@@ -161,5 +291,15 @@ export {
   geocodingSuggestionSchema,
   autocompleteResponseSchema,
   resolveSuggestionRequestSchema,
-  resolveSuggestionResponseSchema
+  resolveSuggestionResponseSchema,
+  nearbyLimits,
+  nearbyCursorSchema,
+  nearbyRequestSchema,
+  nearbyPlaceSchema,
+  nearbyResponseSchema,
+  searchCategoriesResponseSchema,
+  resolvePlaceRequestSchema,
+  resolvePlaceResponseSchema,
+  searchContactDetails,
+  searchOperationUnits
 };

package/dist/client.d.ts

@@ -1,7 +1,7 @@
-import { AutocompleteRequest, AutocompleteResponse, GeocodingForwardRequest, GeocodingForwardResponse, GeocodingReverseRequest, GeocodingReverseResponse, ResolveSuggestionRequest, ResolveSuggestionResponse } from './contract.js';
+import { AutocompleteRequest, AutocompleteResponse, GeocodingForwardRequest, GeocodingForwardResponse, GeocodingReverseRequest, GeocodingReverseResponse, SearchCategoriesResponse, ResolveSuggestionRequest, ResolveSuggestionResponse, NearbyRequest, NearbyResponse } from './contract.js';
 import 'zod';
 
-declare const GEOCODING_ERROR_CODES: readonly ["GEOCODING_ABORTED", "GEOCODING_DISABLED", "GEOCODING_INVALID_REQUEST", "GEOCODING_INVALID_SUGGESTION", "GEOCODING_PICK_LIMIT_EXCEEDED", "GEOCODING_QUOTA_EXCEEDED", "GEOCODING_REQUEST_TOO_LARGE", "GEOCODING_SUGGESTION_EXPIRED", "GEOCODING_TERRITORY_UNSUPPORTED", "GEOCODING_UNAVAILABLE", "GEOCODING_UPSTREAM_INVALID", "GEOCODING_UPSTREAM_THROTTLED", "GEOCODING_UPSTREAM_TIMEOUT", "GEOCODING_UPSTREAM_UNAVAILABLE", "GEOCODING_USAGE_UNCONFIRMED"];
+declare const GEOCODING_ERROR_CODES: readonly ["GEOCODING_FILTER_UNSUPPORTED", "GEOCODING_PLAN_UNAVAILABLE", "GEOCODING_EVALUATION_REQUIRED", "GEOCODING_EVALUATION_EXPIRED", "GEOCODING_EVALUATION_EXHAUSTED", "GEOCODING_INVALID_CURSOR", "GEOCODING_CURSOR_EXPIRED", "GEOCODING_ABORTED", "GEOCODING_DISABLED", "GEOCODING_INVALID_REQUEST", "GEOCODING_INVALID_SUGGESTION", "GEOCODING_PICK_LIMIT_EXCEEDED", "GEOCODING_QUOTA_EXCEEDED", "GEOCODING_REQUEST_TOO_LARGE", "GEOCODING_SUGGESTION_EXPIRED", "GEOCODING_UNAVAILABLE", "GEOCODING_UPSTREAM_INVALID", "GEOCODING_UPSTREAM_THROTTLED", "GEOCODING_UPSTREAM_TIMEOUT", "GEOCODING_UPSTREAM_UNAVAILABLE", "GEOCODING_USAGE_UNCONFIRMED"];
 type GeocodingErrorCode = (typeof GEOCODING_ERROR_CODES)[number];
 type GeocodeOptions = Readonly<{
     apiKey: string;
@@ -13,15 +13,20 @@ declare class GeocodingError extends Error {
     readonly code: GeocodingErrorCode | null;
     readonly requestId: string | null;
     readonly status: number;
+    readonly retryAfterSeconds: number | null;
     constructor(message: string, input: {
         code?: GeocodingErrorCode;
         requestId?: string;
         status: number;
+        retryAfterSeconds?: number | null;
     });
 }
 declare function geocode(request: GeocodingForwardRequest, options: GeocodeOptions): Promise<GeocodingForwardResponse>;
 declare function geocodeReverse(request: GeocodingReverseRequest, options: GeocodeOptions): Promise<GeocodingReverseResponse>;
 declare function autocomplete(request: AutocompleteRequest, options: GeocodeOptions): Promise<AutocompleteResponse>;
 declare function resolveSuggestion(request: ResolveSuggestionRequest, options: GeocodeOptions): Promise<ResolveSuggestionResponse>;
+declare const resolvePlace: typeof resolveSuggestion;
+declare function searchNearby(request: NearbyRequest, options: GeocodeOptions): Promise<NearbyResponse>;
+declare function listCategories(options: GeocodeOptions): Promise<SearchCategoriesResponse>;
 
-export { GEOCODING_ERROR_CODES, type GeocodeOptions, GeocodingError, type GeocodingErrorCode, autocomplete, geocode, geocodeReverse, resolveSuggestion };
+export { GEOCODING_ERROR_CODES, type GeocodeOptions, GeocodingError, type GeocodingErrorCode, autocomplete, geocode, geocodeReverse, listCategories, resolvePlace, resolveSuggestion, searchNearby };

package/dist/client.js

@@ -4,14 +4,20 @@ import {
   autocomplete,
   geocode,
   geocodeReverse,
-  resolveSuggestion
-} from "./chunk-YMLUPVQH.js";
-import "./chunk-EDYCZVXI.js";
+  listCategories,
+  resolvePlace,
+  resolveSuggestion,
+  searchNearby
+} from "./chunk-QDEMNVJD.js";
+import "./chunk-W66J2DAS.js";
 export {
   GEOCODING_ERROR_CODES,
   GeocodingError,
   autocomplete,
   geocode,
   geocodeReverse,
-  resolveSuggestion
+  listCategories,
+  resolvePlace,
+  resolveSuggestion,
+  searchNearby
 };