@aws-sdk/client-geo-places 3.683.0

package/dist-types/commands/SuggestCommand.d.ts

@@ -0,0 +1,289 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import { GeoPlacesClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GeoPlacesClient";
+import { SuggestRequest, SuggestResponse } from "../models/models_0";
+/**
+ * @public
+ */
+export type { __MetadataBearer };
+export { $Command };
+/**
+ * @public
+ *
+ * The input for {@link SuggestCommand}.
+ */
+export interface SuggestCommandInput extends SuggestRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link SuggestCommand}.
+ */
+export interface SuggestCommandOutput extends SuggestResponse, __MetadataBearer {
+}
+declare const SuggestCommand_base: {
+    new (input: SuggestCommandInput): import("@smithy/smithy-client").CommandImpl<SuggestCommandInput, SuggestCommandOutput, GeoPlacesClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    new (__0_0: SuggestCommandInput): import("@smithy/smithy-client").CommandImpl<SuggestCommandInput, SuggestCommandOutput, GeoPlacesClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+/**
+ * <p>The <code>Suggest</code> operation finds addresses or place candidates based on
+ *          incomplete or misspelled queries. You then select the best query to submit based on the
+ *          returned results.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GeoPlacesClient, SuggestCommand } from "@aws-sdk/client-geo-places"; // ES Modules import
+ * // const { GeoPlacesClient, SuggestCommand } = require("@aws-sdk/client-geo-places"); // CommonJS import
+ * const client = new GeoPlacesClient(config);
+ * const input = { // SuggestRequest
+ *   QueryText: "STRING_VALUE", // required
+ *   MaxResults: Number("int"),
+ *   MaxQueryRefinements: Number("int"),
+ *   BiasPosition: [ // Position
+ *     Number("double"),
+ *   ],
+ *   Filter: { // SuggestFilter
+ *     BoundingBox: [ // BoundingBox
+ *       Number("double"),
+ *     ],
+ *     Circle: { // FilterCircle
+ *       Center: [ // required
+ *         Number("double"),
+ *       ],
+ *       Radius: Number("long"), // required
+ *     },
+ *     IncludeCountries: [ // CountryCodeList
+ *       "STRING_VALUE",
+ *     ],
+ *   },
+ *   AdditionalFeatures: [ // SuggestAdditionalFeatureList
+ *     "STRING_VALUE",
+ *   ],
+ *   Language: "STRING_VALUE",
+ *   PoliticalView: "STRING_VALUE",
+ *   IntendedUse: "STRING_VALUE",
+ *   Key: "STRING_VALUE",
+ * };
+ * const command = new SuggestCommand(input);
+ * const response = await client.send(command);
+ * // { // SuggestResponse
+ * //   PricingBucket: "STRING_VALUE", // required
+ * //   ResultItems: [ // SuggestResultItemList
+ * //     { // SuggestResultItem
+ * //       Title: "STRING_VALUE", // required
+ * //       SuggestResultItemType: "STRING_VALUE", // required
+ * //       Place: { // SuggestPlaceResult
+ * //         PlaceId: "STRING_VALUE",
+ * //         PlaceType: "STRING_VALUE",
+ * //         Address: { // Address
+ * //           Label: "STRING_VALUE",
+ * //           Country: { // Country
+ * //             Code2: "STRING_VALUE",
+ * //             Code3: "STRING_VALUE",
+ * //             Name: "STRING_VALUE",
+ * //           },
+ * //           Region: { // Region
+ * //             Code: "STRING_VALUE",
+ * //             Name: "STRING_VALUE",
+ * //           },
+ * //           SubRegion: { // SubRegion
+ * //             Code: "STRING_VALUE",
+ * //             Name: "STRING_VALUE",
+ * //           },
+ * //           Locality: "STRING_VALUE",
+ * //           District: "STRING_VALUE",
+ * //           SubDistrict: "STRING_VALUE",
+ * //           PostalCode: "STRING_VALUE",
+ * //           Block: "STRING_VALUE",
+ * //           SubBlock: "STRING_VALUE",
+ * //           Intersection: [ // IntersectionList
+ * //             "STRING_VALUE",
+ * //           ],
+ * //           Street: "STRING_VALUE",
+ * //           StreetComponents: [ // StreetComponentsList
+ * //             { // StreetComponents
+ * //               BaseName: "STRING_VALUE",
+ * //               Type: "STRING_VALUE",
+ * //               TypePlacement: "STRING_VALUE",
+ * //               TypeSeparator: "STRING_VALUE",
+ * //               Prefix: "STRING_VALUE",
+ * //               Suffix: "STRING_VALUE",
+ * //               Direction: "STRING_VALUE",
+ * //               Language: "STRING_VALUE",
+ * //             },
+ * //           ],
+ * //           AddressNumber: "STRING_VALUE",
+ * //           Building: "STRING_VALUE",
+ * //         },
+ * //         Position: [ // Position
+ * //           Number("double"),
+ * //         ],
+ * //         Distance: Number("long"),
+ * //         MapView: [ // BoundingBox
+ * //           Number("double"),
+ * //         ],
+ * //         Categories: [ // CategoryList
+ * //           { // Category
+ * //             Id: "STRING_VALUE", // required
+ * //             Name: "STRING_VALUE", // required
+ * //             LocalizedName: "STRING_VALUE",
+ * //             Primary: true || false,
+ * //           },
+ * //         ],
+ * //         FoodTypes: [ // FoodTypeList
+ * //           { // FoodType
+ * //             LocalizedName: "STRING_VALUE", // required
+ * //             Id: "STRING_VALUE",
+ * //             Primary: true || false,
+ * //           },
+ * //         ],
+ * //         BusinessChains: [ // BusinessChainList
+ * //           { // BusinessChain
+ * //             Name: "STRING_VALUE",
+ * //             Id: "STRING_VALUE",
+ * //           },
+ * //         ],
+ * //         AccessPoints: [ // AccessPointList
+ * //           { // AccessPoint
+ * //             Position: [
+ * //               Number("double"),
+ * //             ],
+ * //           },
+ * //         ],
+ * //         AccessRestrictions: [ // AccessRestrictionList
+ * //           { // AccessRestriction
+ * //             Restricted: true || false,
+ * //             Categories: [
+ * //               {
+ * //                 Id: "STRING_VALUE", // required
+ * //                 Name: "STRING_VALUE", // required
+ * //                 LocalizedName: "STRING_VALUE",
+ * //                 Primary: true || false,
+ * //               },
+ * //             ],
+ * //           },
+ * //         ],
+ * //         TimeZone: { // TimeZone
+ * //           Name: "STRING_VALUE", // required
+ * //           Offset: "STRING_VALUE",
+ * //           OffsetSeconds: Number("long"),
+ * //         },
+ * //         PoliticalView: "STRING_VALUE",
+ * //         Phonemes: { // PhonemeDetails
+ * //           Title: [ // PhonemeTranscriptionList
+ * //             { // PhonemeTranscription
+ * //               Value: "STRING_VALUE",
+ * //               Language: "STRING_VALUE",
+ * //               Preferred: true || false,
+ * //             },
+ * //           ],
+ * //           Address: { // AddressComponentPhonemes
+ * //             Country: [
+ * //               {
+ * //                 Value: "STRING_VALUE",
+ * //                 Language: "STRING_VALUE",
+ * //                 Preferred: true || false,
+ * //               },
+ * //             ],
+ * //             Region: [
+ * //               {
+ * //                 Value: "STRING_VALUE",
+ * //                 Language: "STRING_VALUE",
+ * //                 Preferred: true || false,
+ * //               },
+ * //             ],
+ * //             SubRegion: [
+ * //               {
+ * //                 Value: "STRING_VALUE",
+ * //                 Language: "STRING_VALUE",
+ * //                 Preferred: true || false,
+ * //               },
+ * //             ],
+ * //             Locality: [
+ * //               {
+ * //                 Value: "STRING_VALUE",
+ * //                 Language: "STRING_VALUE",
+ * //                 Preferred: true || false,
+ * //               },
+ * //             ],
+ * //             District: "<PhonemeTranscriptionList>",
+ * //             SubDistrict: "<PhonemeTranscriptionList>",
+ * //             Block: "<PhonemeTranscriptionList>",
+ * //             SubBlock: "<PhonemeTranscriptionList>",
+ * //             Street: "<PhonemeTranscriptionList>",
+ * //           },
+ * //         },
+ * //       },
+ * //       Query: { // SuggestQueryResult
+ * //         QueryId: "STRING_VALUE",
+ * //         QueryType: "STRING_VALUE",
+ * //       },
+ * //       Highlights: { // SuggestHighlights
+ * //         Title: [ // HighlightList
+ * //           { // Highlight
+ * //             StartIndex: Number("int"),
+ * //             EndIndex: Number("int"),
+ * //             Value: "STRING_VALUE",
+ * //           },
+ * //         ],
+ * //         Address: { // SuggestAddressHighlights
+ * //           Label: [
+ * //             {
+ * //               StartIndex: Number("int"),
+ * //               EndIndex: Number("int"),
+ * //               Value: "STRING_VALUE",
+ * //             },
+ * //           ],
+ * //         },
+ * //       },
+ * //     },
+ * //   ],
+ * //   QueryRefinements: [ // QueryRefinementList
+ * //     { // QueryRefinement
+ * //       RefinedTerm: "STRING_VALUE", // required
+ * //       OriginalTerm: "STRING_VALUE", // required
+ * //       StartIndex: Number("int"), // required
+ * //       EndIndex: Number("int"), // required
+ * //     },
+ * //   ],
+ * // };
+ *
+ * ```
+ *
+ * @param SuggestCommandInput - {@link SuggestCommandInput}
+ * @returns {@link SuggestCommandOutput}
+ * @see {@link SuggestCommandInput} for command's `input` shape.
+ * @see {@link SuggestCommandOutput} for command's `response` shape.
+ * @see {@link GeoPlacesClientResolvedConfig | config} for GeoPlacesClient's `config` shape.
+ *
+ * @throws {@link AccessDeniedException} (client fault)
+ *  <p>You don't have sufficient access to perform this action.</p>
+ *
+ * @throws {@link InternalServerException} (server fault)
+ *  <p>The request processing has failed because of an unknown error, exception or failure.</p>
+ *
+ * @throws {@link ThrottlingException} (client fault)
+ *  <p>The request was denied due to request throttling.</p>
+ *
+ * @throws {@link ValidationException} (client fault)
+ *  <p>The input fails to satisfy the constraints specified by an AWS service.</p>
+ *
+ * @throws {@link GeoPlacesServiceException}
+ * <p>Base exception class for all service exceptions from GeoPlaces service.</p>
+ *
+ * @public
+ */
+export declare class SuggestCommand extends SuggestCommand_base {
+    /** @internal type navigation helper, not in runtime. */
+    protected static __types: {
+        api: {
+            input: SuggestRequest;
+            output: SuggestResponse;
+        };
+        sdk: {
+            input: SuggestCommandInput;
+            output: SuggestCommandOutput;
+        };
+    };
+}

package/dist-types/commands/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./AutocompleteCommand";
+export * from "./GeocodeCommand";
+export * from "./GetPlaceCommand";
+export * from "./ReverseGeocodeCommand";
+export * from "./SearchNearbyCommand";
+export * from "./SearchTextCommand";
+export * from "./SuggestCommand";

package/dist-types/endpoint/EndpointParameters.d.ts

@@ -0,0 +1,40 @@
+import { Endpoint, EndpointParameters as __EndpointParameters, EndpointV2, Provider } from "@smithy/types";
+/**
+ * @public
+ */
+export interface ClientInputEndpointParameters {
+    useDualstackEndpoint?: boolean | Provider<boolean>;
+    useFipsEndpoint?: boolean | Provider<boolean>;
+    endpoint?: string | Provider<string> | Endpoint | Provider<Endpoint> | EndpointV2 | Provider<EndpointV2>;
+    region?: string | Provider<string>;
+}
+export type ClientResolvedEndpointParameters = ClientInputEndpointParameters & {
+    defaultSigningName: string;
+};
+export declare const resolveClientEndpointParameters: <T>(options: T & ClientInputEndpointParameters) => T & ClientInputEndpointParameters & {
+    defaultSigningName: string;
+};
+export declare const commonParams: {
+    readonly UseFIPS: {
+        readonly type: "builtInParams";
+        readonly name: "useFipsEndpoint";
+    };
+    readonly Endpoint: {
+        readonly type: "builtInParams";
+        readonly name: "endpoint";
+    };
+    readonly Region: {
+        readonly type: "builtInParams";
+        readonly name: "region";
+    };
+    readonly UseDualStack: {
+        readonly type: "builtInParams";
+        readonly name: "useDualstackEndpoint";
+    };
+};
+export interface EndpointParameters extends __EndpointParameters {
+    UseDualStack?: boolean;
+    UseFIPS?: boolean;
+    Endpoint?: string;
+    Region?: string;
+}

package/dist-types/endpoint/endpointResolver.d.ts

@@ -0,0 +1,5 @@
+import { EndpointV2, Logger } from "@smithy/types";
+import { EndpointParameters } from "./EndpointParameters";
+export declare const defaultEndpointResolver: (endpointParams: EndpointParameters, context?: {
+    logger?: Logger;
+}) => EndpointV2;

package/dist-types/endpoint/ruleset.d.ts

@@ -0,0 +1,2 @@
+import { RuleSetObject } from "@smithy/types";
+export declare const ruleSet: RuleSetObject;

package/dist-types/extensionConfiguration.d.ts

@@ -0,0 +1,9 @@
+import { AwsRegionExtensionConfiguration } from "@aws-sdk/types";
+import { HttpHandlerExtensionConfiguration } from "@smithy/protocol-http";
+import { DefaultExtensionConfiguration } from "@smithy/types";
+import { HttpAuthExtensionConfiguration } from "./auth/httpAuthExtensionConfiguration";
+/**
+ * @internal
+ */
+export interface GeoPlacesExtensionConfiguration extends HttpHandlerExtensionConfiguration, DefaultExtensionConfiguration, AwsRegionExtensionConfiguration, HttpAuthExtensionConfiguration {
+}

package/dist-types/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * <p>
+ *       The Places API enables powerful location search and geocoding capabilities for your applications, offering global coverage with rich, detailed information. Key features include:
+ *   </p>
+ *          <ul>
+ *             <li>
+ *                <p>Forward and reverse geocoding for addresses and coordinates</p>
+ *             </li>
+ *             <li>
+ *                <p>Comprehensive place searches with detailed information, including:</p>
+ *                <ul>
+ *                   <li>
+ *                      <p>Business names and addresses</p>
+ *                   </li>
+ *                   <li>
+ *                      <p>Contact information</p>
+ *                   </li>
+ *                   <li>
+ *                      <p>Hours of operation</p>
+ *                   </li>
+ *                   <li>
+ *                      <p>POI (Points of Interest) categories</p>
+ *                   </li>
+ *                   <li>
+ *                      <p>Food types for restaurants</p>
+ *                   </li>
+ *                   <li>
+ *                      <p>Chain affiliation for relevant businesses</p>
+ *                   </li>
+ *                </ul>
+ *             </li>
+ *             <li>
+ *                <p>Global data coverage with a wide range of POI categories</p>
+ *             </li>
+ *             <li>
+ *                <p>Regular data updates to ensure accuracy and relevance</p>
+ *             </li>
+ *          </ul>
+ *
+ * @packageDocumentation
+ */
+export * from "./GeoPlacesClient";
+export * from "./GeoPlaces";
+export { ClientInputEndpointParameters } from "./endpoint/EndpointParameters";
+export type { RuntimeExtension } from "./runtimeExtensions";
+export type { GeoPlacesExtensionConfiguration } from "./extensionConfiguration";
+export * from "./commands";
+export * from "./models";
+export { GeoPlacesServiceException } from "./models/GeoPlacesServiceException";

package/dist-types/models/GeoPlacesServiceException.d.ts

@@ -0,0 +1,14 @@
+import { ServiceException as __ServiceException, ServiceExceptionOptions as __ServiceExceptionOptions } from "@smithy/smithy-client";
+export type { __ServiceExceptionOptions };
+export { __ServiceException };
+/**
+ * @public
+ *
+ * Base exception class for all service exceptions from GeoPlaces service.
+ */
+export declare class GeoPlacesServiceException extends __ServiceException {
+    /**
+     * @internal
+     */
+    constructor(options: __ServiceExceptionOptions);
+}

package/dist-types/models/index.d.ts

@@ -0,0 +1 @@
+export * from "./models_0";