@aws-sdk/client-geo-places 3.928.0 → 3.930.0

package/dist-cjs/index.js

@@ -6,6 +6,7 @@ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detect
 var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
 var configResolver = require('@smithy/config-resolver');
 var core = require('@smithy/core');
+var schema = require('@smithy/core/schema');
 var middlewareContentLength = require('@smithy/middleware-content-length');
 var middlewareEndpoint = require('@smithy/middleware-endpoint');
 var middlewareRetry = require('@smithy/middleware-retry');
@@ -14,8 +15,6 @@ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
 var runtimeConfig = require('./runtimeConfig');
 var regionConfigResolver = require('@aws-sdk/region-config-resolver');
 var protocolHttp = require('@smithy/protocol-http');
-var middlewareSerde = require('@smithy/middleware-serde');
-var core$1 = require('@aws-sdk/core');
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -91,6 +90,7 @@ class GeoPlacesClient extends smithyClient.Client {
         const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
         const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
         this.config = _config_8;
+        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
         this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
         this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
         this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
@@ -110,14 +110,14 @@ class GeoPlacesClient extends smithyClient.Client {
     }
 }
 
-class GeoPlacesServiceException extends smithyClient.ServiceException {
+let GeoPlacesServiceException$1 = class GeoPlacesServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, GeoPlacesServiceException.prototype);
     }
-}
+};
 
-class AccessDeniedException extends GeoPlacesServiceException {
+let AccessDeniedException$1 = class AccessDeniedException extends GeoPlacesServiceException$1 {
     name = "AccessDeniedException";
     $fault = "client";
     Message;
@@ -130,7 +130,7 @@ class AccessDeniedException extends GeoPlacesServiceException {
         Object.setPrototypeOf(this, AccessDeniedException.prototype);
         this.Message = opts.Message;
     }
-}
+};
 const TypePlacement = {
     AFTER_BASE_NAME: "AfterBaseName",
     BEFORE_BASE_NAME: "BeforeBaseName",
@@ -149,7 +149,7 @@ const PostalCodeMode = {
     ENUMERATE_SPANNED_LOCALITIES: "EnumerateSpannedLocalities",
     MERGE_ALL_SPANNED_LOCALITIES: "MergeAllSpannedLocalities",
 };
-const PlaceType = {
+const PlaceType$1 = {
     BLOCK: "Block",
     COUNTRY: "Country",
     DISTRICT: "District",
@@ -166,7 +166,7 @@ const PlaceType = {
     SUB_DISTRICT: "SubDistrict",
     SUB_REGION: "SubRegion",
 };
-class InternalServerException extends GeoPlacesServiceException {
+let InternalServerException$1 = class InternalServerException extends GeoPlacesServiceException$1 {
     name = "InternalServerException";
     $fault = "server";
     $retryable = {};
@@ -180,8 +180,8 @@ class InternalServerException extends GeoPlacesServiceException {
         Object.setPrototypeOf(this, InternalServerException.prototype);
         this.Message = opts.Message;
     }
-}
-class ThrottlingException extends GeoPlacesServiceException {
+};
+let ThrottlingException$1 = class ThrottlingException extends GeoPlacesServiceException$1 {
     name = "ThrottlingException";
     $fault = "client";
     $retryable = {};
@@ -195,7 +195,7 @@ class ThrottlingException extends GeoPlacesServiceException {
         Object.setPrototypeOf(this, ThrottlingException.prototype);
         this.Message = opts.Message;
     }
-}
+};
 const ValidationExceptionReason = {
     CANNOT_PARSE: "CannotParse",
     FIELD_VALIDATION_FAILED: "FieldValidationFailed",
@@ -204,7 +204,7 @@ const ValidationExceptionReason = {
     UNKNOWN_FIELD: "UnknownField",
     UNKNOWN_OPERATION: "UnknownOperation",
 };
-class ValidationException extends GeoPlacesServiceException {
+let ValidationException$1 = class ValidationException extends GeoPlacesServiceException$1 {
     name = "ValidationException";
     $fault = "client";
     Message;
@@ -221,14 +221,14 @@ class ValidationException extends GeoPlacesServiceException {
         this.Reason = opts.Reason;
         this.FieldList = opts.FieldList;
     }
-}
+};
 const GeocodeAdditionalFeature = {
     ACCESS: "Access",
     INTERSECTIONS: "Intersections",
     SECONDARY_ADDRESSES: "SecondaryAddresses",
     TIME_ZONE: "TimeZone",
 };
-const GeocodeFilterPlaceType = {
+const GeocodeFilterPlaceType$1 = {
     INTERPOLATED_ADDRESS: "InterpolatedAddress",
     INTERSECTION: "Intersection",
     LOCALITY: "Locality",
@@ -240,19 +240,19 @@ const GeocodeIntendedUse = {
     SINGLE_USE: "SingleUse",
     STORAGE: "Storage",
 };
-const PostalAuthority = {
+const PostalAuthority$1 = {
     USPS: "Usps",
 };
-const PostalCodeType = {
+const PostalCodeType$1 = {
     USPS_ZIP: "UspsZip",
     USPS_ZIP_PLUS_4: "UspsZipPlus4",
 };
-const ZipClassificationCode = {
+const ZipClassificationCode$1 = {
     MILITARY: "Military",
     POST_OFFICE_BOXES: "PostOfficeBoxes",
     UNIQUE: "Unique",
 };
-const RecordTypeCode = {
+const RecordTypeCode$1 = {
     FIRM: "Firm",
     GENERAL: "General",
     HIGH_RISE: "HighRise",
@@ -324,1314 +324,1511 @@ const SuggestResultItemType = {
     PLACE: "Place",
     QUERY: "Query",
 };
-const AccessPointFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Position && { Position: smithyClient.SENSITIVE_STRING }),
-});
-const CategoryFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Id && { Id: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Name && { Name: smithyClient.SENSITIVE_STRING }),
-    ...(obj.LocalizedName && { LocalizedName: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Primary && { Primary: smithyClient.SENSITIVE_STRING }),
-});
-const AccessRestrictionFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Restricted && { Restricted: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Categories && { Categories: obj.Categories.map((item) => CategoryFilterSensitiveLog(item)) }),
-});
-const CountryFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Code2 && { Code2: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Code3 && { Code3: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Name && { Name: smithyClient.SENSITIVE_STRING }),
-});
-const RegionFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Code && { Code: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Name && { Name: smithyClient.SENSITIVE_STRING }),
-});
-const SecondaryAddressComponentFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Number && { Number: smithyClient.SENSITIVE_STRING }),
-});
-const StreetComponentsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.BaseName && { BaseName: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Type && { Type: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Prefix && { Prefix: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Suffix && { Suffix: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Direction && { Direction: smithyClient.SENSITIVE_STRING }),
-});
-const SubRegionFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Code && { Code: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Name && { Name: smithyClient.SENSITIVE_STRING }),
-});
-const AddressFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Label && { Label: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Country && { Country: CountryFilterSensitiveLog(obj.Country) }),
-    ...(obj.Region && { Region: RegionFilterSensitiveLog(obj.Region) }),
-    ...(obj.SubRegion && { SubRegion: SubRegionFilterSensitiveLog(obj.SubRegion) }),
-    ...(obj.Locality && { Locality: smithyClient.SENSITIVE_STRING }),
-    ...(obj.District && { District: smithyClient.SENSITIVE_STRING }),
-    ...(obj.SubDistrict && { SubDistrict: smithyClient.SENSITIVE_STRING }),
-    ...(obj.PostalCode && { PostalCode: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Block && { Block: smithyClient.SENSITIVE_STRING }),
-    ...(obj.SubBlock && { SubBlock: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Street && { Street: smithyClient.SENSITIVE_STRING }),
-    ...(obj.StreetComponents && {
-        StreetComponents: obj.StreetComponents.map((item) => StreetComponentsFilterSensitiveLog(item)),
-    }),
-    ...(obj.AddressNumber && { AddressNumber: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Building && { Building: smithyClient.SENSITIVE_STRING }),
-    ...(obj.SecondaryAddressComponents && {
-        SecondaryAddressComponents: obj.SecondaryAddressComponents.map((item) => SecondaryAddressComponentFilterSensitiveLog(item)),
-    }),
-});
-const PhonemeTranscriptionFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Value && { Value: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Preferred && { Preferred: smithyClient.SENSITIVE_STRING }),
-});
-const AddressComponentPhonemesFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Country && { Country: obj.Country.map((item) => PhonemeTranscriptionFilterSensitiveLog(item)) }),
-    ...(obj.Region && { Region: obj.Region.map((item) => PhonemeTranscriptionFilterSensitiveLog(item)) }),
-    ...(obj.SubRegion && { SubRegion: obj.SubRegion.map((item) => PhonemeTranscriptionFilterSensitiveLog(item)) }),
-    ...(obj.Locality && { Locality: obj.Locality.map((item) => PhonemeTranscriptionFilterSensitiveLog(item)) }),
-    ...(obj.District && { District: obj.District.map((item) => PhonemeTranscriptionFilterSensitiveLog(item)) }),
-    ...(obj.SubDistrict && { SubDistrict: obj.SubDistrict.map((item) => PhonemeTranscriptionFilterSensitiveLog(item)) }),
-    ...(obj.Block && { Block: obj.Block.map((item) => PhonemeTranscriptionFilterSensitiveLog(item)) }),
-    ...(obj.SubBlock && { SubBlock: obj.SubBlock.map((item) => PhonemeTranscriptionFilterSensitiveLog(item)) }),
-    ...(obj.Street && { Street: obj.Street.map((item) => PhonemeTranscriptionFilterSensitiveLog(item)) }),
-});
-const FilterCircleFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Center && { Center: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Radius && { Radius: smithyClient.SENSITIVE_STRING }),
-});
-const AutocompleteFilterFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.BoundingBox && { BoundingBox: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Circle && { Circle: smithyClient.SENSITIVE_STRING }),
-    ...(obj.IncludeCountries && { IncludeCountries: smithyClient.SENSITIVE_STRING }),
-});
-const AutocompleteRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.QueryText && { QueryText: smithyClient.SENSITIVE_STRING }),
-    ...(obj.BiasPosition && { BiasPosition: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Filter && { Filter: AutocompleteFilterFilterSensitiveLog(obj.Filter) }),
-    ...(obj.PoliticalView && { PoliticalView: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Key && { Key: smithyClient.SENSITIVE_STRING }),
-});
-const HighlightFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Value && { Value: smithyClient.SENSITIVE_STRING }),
-});
-const CountryHighlightsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Code && { Code: obj.Code.map((item) => HighlightFilterSensitiveLog(item)) }),
-    ...(obj.Name && { Name: obj.Name.map((item) => HighlightFilterSensitiveLog(item)) }),
-});
-const RegionHighlightsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Code && { Code: obj.Code.map((item) => HighlightFilterSensitiveLog(item)) }),
-    ...(obj.Name && { Name: obj.Name.map((item) => HighlightFilterSensitiveLog(item)) }),
-});
-const SubRegionHighlightsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Code && { Code: obj.Code.map((item) => HighlightFilterSensitiveLog(item)) }),
-    ...(obj.Name && { Name: obj.Name.map((item) => HighlightFilterSensitiveLog(item)) }),
-});
-const AutocompleteAddressHighlightsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Label && { Label: obj.Label.map((item) => HighlightFilterSensitiveLog(item)) }),
-    ...(obj.Country && { Country: CountryHighlightsFilterSensitiveLog(obj.Country) }),
-    ...(obj.Region && { Region: RegionHighlightsFilterSensitiveLog(obj.Region) }),
-    ...(obj.SubRegion && { SubRegion: SubRegionHighlightsFilterSensitiveLog(obj.SubRegion) }),
-    ...(obj.Locality && { Locality: obj.Locality.map((item) => HighlightFilterSensitiveLog(item)) }),
-    ...(obj.District && { District: obj.District.map((item) => HighlightFilterSensitiveLog(item)) }),
-    ...(obj.SubDistrict && { SubDistrict: obj.SubDistrict.map((item) => HighlightFilterSensitiveLog(item)) }),
-    ...(obj.Street && { Street: obj.Street.map((item) => HighlightFilterSensitiveLog(item)) }),
-    ...(obj.Block && { Block: obj.Block.map((item) => HighlightFilterSensitiveLog(item)) }),
-    ...(obj.SubBlock && { SubBlock: obj.SubBlock.map((item) => HighlightFilterSensitiveLog(item)) }),
-    ...(obj.Intersection && {
-        Intersection: obj.Intersection.map((item) => item.map((item) => HighlightFilterSensitiveLog(item))),
-    }),
-    ...(obj.PostalCode && { PostalCode: obj.PostalCode.map((item) => HighlightFilterSensitiveLog(item)) }),
-    ...(obj.AddressNumber && { AddressNumber: obj.AddressNumber.map((item) => HighlightFilterSensitiveLog(item)) }),
-    ...(obj.Building && { Building: obj.Building.map((item) => HighlightFilterSensitiveLog(item)) }),
-});
-const AutocompleteHighlightsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Title && { Title: obj.Title.map((item) => HighlightFilterSensitiveLog(item)) }),
-    ...(obj.Address && { Address: AutocompleteAddressHighlightsFilterSensitiveLog(obj.Address) }),
-});
-const AutocompleteResultItemFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.PlaceId && { PlaceId: smithyClient.SENSITIVE_STRING }),
-    ...(obj.PlaceType && { PlaceType: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Title && { Title: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Address && { Address: AddressFilterSensitiveLog(obj.Address) }),
-    ...(obj.Distance && { Distance: smithyClient.SENSITIVE_STRING }),
-    ...(obj.PoliticalView && { PoliticalView: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Highlights && { Highlights: AutocompleteHighlightsFilterSensitiveLog(obj.Highlights) }),
-});
-const AutocompleteResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.ResultItems && {
-        ResultItems: obj.ResultItems.map((item) => AutocompleteResultItemFilterSensitiveLog(item)),
-    }),
-});
-const BusinessChainFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Name && { Name: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Id && { Id: smithyClient.SENSITIVE_STRING }),
-});
-const ContactDetailsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Label && { Label: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Value && { Value: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Categories && { Categories: obj.Categories.map((item) => CategoryFilterSensitiveLog(item)) }),
-});
-const ContactsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Phones && { Phones: obj.Phones.map((item) => ContactDetailsFilterSensitiveLog(item)) }),
-    ...(obj.Faxes && { Faxes: obj.Faxes.map((item) => ContactDetailsFilterSensitiveLog(item)) }),
-    ...(obj.Websites && { Websites: obj.Websites.map((item) => ContactDetailsFilterSensitiveLog(item)) }),
-    ...(obj.Emails && { Emails: obj.Emails.map((item) => ContactDetailsFilterSensitiveLog(item)) }),
-});
-const FoodTypeFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.LocalizedName && { LocalizedName: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Id && { Id: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Primary && { Primary: smithyClient.SENSITIVE_STRING }),
-});
-const GeocodeFilterFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.IncludeCountries && { IncludeCountries: smithyClient.SENSITIVE_STRING }),
-    ...(obj.IncludePlaceTypes && { IncludePlaceTypes: smithyClient.SENSITIVE_STRING }),
-});
-const GeocodeQueryComponentsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Country && { Country: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Region && { Region: smithyClient.SENSITIVE_STRING }),
-    ...(obj.SubRegion && { SubRegion: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Locality && { Locality: smithyClient.SENSITIVE_STRING }),
-    ...(obj.District && { District: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Street && { Street: smithyClient.SENSITIVE_STRING }),
-    ...(obj.AddressNumber && { AddressNumber: smithyClient.SENSITIVE_STRING }),
-    ...(obj.PostalCode && { PostalCode: smithyClient.SENSITIVE_STRING }),
-});
-const GeocodeRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.QueryText && { QueryText: smithyClient.SENSITIVE_STRING }),
-    ...(obj.QueryComponents && { QueryComponents: GeocodeQueryComponentsFilterSensitiveLog(obj.QueryComponents) }),
-    ...(obj.BiasPosition && { BiasPosition: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Filter && { Filter: GeocodeFilterFilterSensitiveLog(obj.Filter) }),
-    ...(obj.PoliticalView && { PoliticalView: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Key && { Key: smithyClient.SENSITIVE_STRING }),
-});
-const IntersectionFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.PlaceId && { PlaceId: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Title && { Title: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Address && { Address: AddressFilterSensitiveLog(obj.Address) }),
-    ...(obj.Position && { Position: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Distance && { Distance: smithyClient.SENSITIVE_STRING }),
-    ...(obj.RouteDistance && { RouteDistance: smithyClient.SENSITIVE_STRING }),
-    ...(obj.MapView && { MapView: smithyClient.SENSITIVE_STRING }),
-    ...(obj.AccessPoints && { AccessPoints: obj.AccessPoints.map((item) => AccessPointFilterSensitiveLog(item)) }),
-});
-const RelatedPlaceFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.PlaceId && { PlaceId: smithyClient.SENSITIVE_STRING }),
-    ...(obj.PlaceType && { PlaceType: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Title && { Title: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Address && { Address: AddressFilterSensitiveLog(obj.Address) }),
-    ...(obj.Position && { Position: smithyClient.SENSITIVE_STRING }),
-    ...(obj.AccessPoints && { AccessPoints: obj.AccessPoints.map((item) => AccessPointFilterSensitiveLog(item)) }),
-});
-const ParsedQueryComponentFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Value && { Value: smithyClient.SENSITIVE_STRING }),
-    ...(obj.QueryComponent && { QueryComponent: smithyClient.SENSITIVE_STRING }),
-});
-const ParsedQuerySecondaryAddressComponentFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Value && { Value: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Number && { Number: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Designator && { Designator: smithyClient.SENSITIVE_STRING }),
-});
-const GeocodeParsedQueryAddressComponentsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Country && { Country: obj.Country.map((item) => ParsedQueryComponentFilterSensitiveLog(item)) }),
-    ...(obj.Region && { Region: obj.Region.map((item) => ParsedQueryComponentFilterSensitiveLog(item)) }),
-    ...(obj.SubRegion && { SubRegion: obj.SubRegion.map((item) => ParsedQueryComponentFilterSensitiveLog(item)) }),
-    ...(obj.Locality && { Locality: obj.Locality.map((item) => ParsedQueryComponentFilterSensitiveLog(item)) }),
-    ...(obj.District && { District: obj.District.map((item) => ParsedQueryComponentFilterSensitiveLog(item)) }),
-    ...(obj.SubDistrict && { SubDistrict: obj.SubDistrict.map((item) => ParsedQueryComponentFilterSensitiveLog(item)) }),
-    ...(obj.PostalCode && { PostalCode: obj.PostalCode.map((item) => ParsedQueryComponentFilterSensitiveLog(item)) }),
-    ...(obj.Block && { Block: obj.Block.map((item) => ParsedQueryComponentFilterSensitiveLog(item)) }),
-    ...(obj.SubBlock && { SubBlock: obj.SubBlock.map((item) => ParsedQueryComponentFilterSensitiveLog(item)) }),
-    ...(obj.Street && { Street: obj.Street.map((item) => ParsedQueryComponentFilterSensitiveLog(item)) }),
-    ...(obj.AddressNumber && {
-        AddressNumber: obj.AddressNumber.map((item) => ParsedQueryComponentFilterSensitiveLog(item)),
-    }),
-    ...(obj.Building && { Building: obj.Building.map((item) => ParsedQueryComponentFilterSensitiveLog(item)) }),
-    ...(obj.SecondaryAddressComponents && {
-        SecondaryAddressComponents: obj.SecondaryAddressComponents.map((item) => ParsedQuerySecondaryAddressComponentFilterSensitiveLog(item)),
-    }),
-});
-const GeocodeParsedQueryFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Title && { Title: obj.Title.map((item) => ParsedQueryComponentFilterSensitiveLog(item)) }),
-    ...(obj.Address && { Address: GeocodeParsedQueryAddressComponentsFilterSensitiveLog(obj.Address) }),
-});
-const UspsZipFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.ZipClassificationCode && { ZipClassificationCode: smithyClient.SENSITIVE_STRING }),
-});
-const UspsZipPlus4FilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.RecordTypeCode && { RecordTypeCode: smithyClient.SENSITIVE_STRING }),
-});
-const PostalCodeDetailsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.PostalCode && { PostalCode: smithyClient.SENSITIVE_STRING }),
-    ...(obj.PostalAuthority && { PostalAuthority: smithyClient.SENSITIVE_STRING }),
-    ...(obj.PostalCodeType && { PostalCodeType: smithyClient.SENSITIVE_STRING }),
-    ...(obj.UspsZip && { UspsZip: UspsZipFilterSensitiveLog(obj.UspsZip) }),
-    ...(obj.UspsZipPlus4 && { UspsZipPlus4: UspsZipPlus4FilterSensitiveLog(obj.UspsZipPlus4) }),
-});
-const TimeZoneFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Name && { Name: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Offset && { Offset: smithyClient.SENSITIVE_STRING }),
-    ...(obj.OffsetSeconds && { OffsetSeconds: smithyClient.SENSITIVE_STRING }),
-});
-const GeocodeResultItemFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.PlaceId && { PlaceId: smithyClient.SENSITIVE_STRING }),
-    ...(obj.PlaceType && { PlaceType: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Title && { Title: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Address && { Address: AddressFilterSensitiveLog(obj.Address) }),
-    ...(obj.AddressNumberCorrected && { AddressNumberCorrected: smithyClient.SENSITIVE_STRING }),
-    ...(obj.PostalCodeDetails && {
-        PostalCodeDetails: obj.PostalCodeDetails.map((item) => PostalCodeDetailsFilterSensitiveLog(item)),
-    }),
-    ...(obj.Position && { Position: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Distance && { Distance: smithyClient.SENSITIVE_STRING }),
-    ...(obj.MapView && { MapView: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Categories && { Categories: obj.Categories.map((item) => CategoryFilterSensitiveLog(item)) }),
-    ...(obj.FoodTypes && { FoodTypes: obj.FoodTypes.map((item) => FoodTypeFilterSensitiveLog(item)) }),
-    ...(obj.AccessPoints && { AccessPoints: obj.AccessPoints.map((item) => AccessPointFilterSensitiveLog(item)) }),
-    ...(obj.TimeZone && { TimeZone: TimeZoneFilterSensitiveLog(obj.TimeZone) }),
-    ...(obj.PoliticalView && { PoliticalView: smithyClient.SENSITIVE_STRING }),
-    ...(obj.ParsedQuery && { ParsedQuery: GeocodeParsedQueryFilterSensitiveLog(obj.ParsedQuery) }),
-    ...(obj.Intersections && { Intersections: obj.Intersections.map((item) => IntersectionFilterSensitiveLog(item)) }),
-    ...(obj.MainAddress && { MainAddress: RelatedPlaceFilterSensitiveLog(obj.MainAddress) }),
-    ...(obj.SecondaryAddresses && {
-        SecondaryAddresses: obj.SecondaryAddresses.map((item) => RelatedPlaceFilterSensitiveLog(item)),
-    }),
-});
-const GeocodeResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.ResultItems && { ResultItems: obj.ResultItems.map((item) => GeocodeResultItemFilterSensitiveLog(item)) }),
-});
-const GetPlaceRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.PlaceId && { PlaceId: smithyClient.SENSITIVE_STRING }),
-    ...(obj.PoliticalView && { PoliticalView: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Key && { Key: smithyClient.SENSITIVE_STRING }),
-});
-const OpeningHoursComponentsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.OpenTime && { OpenTime: smithyClient.SENSITIVE_STRING }),
-    ...(obj.OpenDuration && { OpenDuration: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Recurrence && { Recurrence: smithyClient.SENSITIVE_STRING }),
-});
-const OpeningHoursFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Display && { Display: smithyClient.SENSITIVE_STRING }),
-    ...(obj.OpenNow && { OpenNow: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Components && { Components: obj.Components.map((item) => OpeningHoursComponentsFilterSensitiveLog(item)) }),
-    ...(obj.Categories && { Categories: obj.Categories.map((item) => CategoryFilterSensitiveLog(item)) }),
-});
-const PhonemeDetailsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Title && { Title: obj.Title.map((item) => PhonemeTranscriptionFilterSensitiveLog(item)) }),
-    ...(obj.Address && { Address: AddressComponentPhonemesFilterSensitiveLog(obj.Address) }),
-});
-const GetPlaceResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.PlaceId && { PlaceId: smithyClient.SENSITIVE_STRING }),
-    ...(obj.PlaceType && { PlaceType: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Title && { Title: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Address && { Address: AddressFilterSensitiveLog(obj.Address) }),
-    ...(obj.AddressNumberCorrected && { AddressNumberCorrected: smithyClient.SENSITIVE_STRING }),
-    ...(obj.PostalCodeDetails && {
-        PostalCodeDetails: obj.PostalCodeDetails.map((item) => PostalCodeDetailsFilterSensitiveLog(item)),
-    }),
-    ...(obj.Position && { Position: smithyClient.SENSITIVE_STRING }),
-    ...(obj.MapView && { MapView: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Categories && { Categories: obj.Categories.map((item) => CategoryFilterSensitiveLog(item)) }),
-    ...(obj.FoodTypes && { FoodTypes: obj.FoodTypes.map((item) => FoodTypeFilterSensitiveLog(item)) }),
-    ...(obj.BusinessChains && {
-        BusinessChains: obj.BusinessChains.map((item) => BusinessChainFilterSensitiveLog(item)),
-    }),
-    ...(obj.Contacts && { Contacts: ContactsFilterSensitiveLog(obj.Contacts) }),
-    ...(obj.OpeningHours && { OpeningHours: obj.OpeningHours.map((item) => OpeningHoursFilterSensitiveLog(item)) }),
-    ...(obj.AccessPoints && { AccessPoints: obj.AccessPoints.map((item) => AccessPointFilterSensitiveLog(item)) }),
-    ...(obj.AccessRestrictions && {
-        AccessRestrictions: obj.AccessRestrictions.map((item) => AccessRestrictionFilterSensitiveLog(item)),
-    }),
-    ...(obj.TimeZone && { TimeZone: TimeZoneFilterSensitiveLog(obj.TimeZone) }),
-    ...(obj.PoliticalView && { PoliticalView: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Phonemes && { Phonemes: PhonemeDetailsFilterSensitiveLog(obj.Phonemes) }),
-    ...(obj.MainAddress && { MainAddress: RelatedPlaceFilterSensitiveLog(obj.MainAddress) }),
-    ...(obj.SecondaryAddresses && {
-        SecondaryAddresses: obj.SecondaryAddresses.map((item) => RelatedPlaceFilterSensitiveLog(item)),
-    }),
-});
-const ReverseGeocodeRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.QueryPosition && { QueryPosition: smithyClient.SENSITIVE_STRING }),
-    ...(obj.QueryRadius && { QueryRadius: smithyClient.SENSITIVE_STRING }),
-    ...(obj.PoliticalView && { PoliticalView: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Key && { Key: smithyClient.SENSITIVE_STRING }),
-});
-const ReverseGeocodeResultItemFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.PlaceId && { PlaceId: smithyClient.SENSITIVE_STRING }),
-    ...(obj.PlaceType && { PlaceType: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Title && { Title: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Address && { Address: AddressFilterSensitiveLog(obj.Address) }),
-    ...(obj.AddressNumberCorrected && { AddressNumberCorrected: smithyClient.SENSITIVE_STRING }),
-    ...(obj.PostalCodeDetails && {
-        PostalCodeDetails: obj.PostalCodeDetails.map((item) => PostalCodeDetailsFilterSensitiveLog(item)),
-    }),
-    ...(obj.Position && { Position: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Distance && { Distance: smithyClient.SENSITIVE_STRING }),
-    ...(obj.MapView && { MapView: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Categories && { Categories: obj.Categories.map((item) => CategoryFilterSensitiveLog(item)) }),
-    ...(obj.FoodTypes && { FoodTypes: obj.FoodTypes.map((item) => FoodTypeFilterSensitiveLog(item)) }),
-    ...(obj.AccessPoints && { AccessPoints: obj.AccessPoints.map((item) => AccessPointFilterSensitiveLog(item)) }),
-    ...(obj.TimeZone && { TimeZone: TimeZoneFilterSensitiveLog(obj.TimeZone) }),
-    ...(obj.PoliticalView && { PoliticalView: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Intersections && { Intersections: obj.Intersections.map((item) => IntersectionFilterSensitiveLog(item)) }),
-});
-const ReverseGeocodeResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.ResultItems && {
-        ResultItems: obj.ResultItems.map((item) => ReverseGeocodeResultItemFilterSensitiveLog(item)),
-    }),
-});
-const SearchNearbyFilterFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.BoundingBox && { BoundingBox: smithyClient.SENSITIVE_STRING }),
-    ...(obj.IncludeCountries && { IncludeCountries: smithyClient.SENSITIVE_STRING }),
-    ...(obj.IncludeCategories && { IncludeCategories: smithyClient.SENSITIVE_STRING }),
-    ...(obj.ExcludeCategories && { ExcludeCategories: smithyClient.SENSITIVE_STRING }),
-    ...(obj.IncludeBusinessChains && { IncludeBusinessChains: smithyClient.SENSITIVE_STRING }),
-    ...(obj.ExcludeBusinessChains && { ExcludeBusinessChains: smithyClient.SENSITIVE_STRING }),
-    ...(obj.IncludeFoodTypes && { IncludeFoodTypes: smithyClient.SENSITIVE_STRING }),
-    ...(obj.ExcludeFoodTypes && { ExcludeFoodTypes: smithyClient.SENSITIVE_STRING }),
-});
-const SearchNearbyRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.QueryPosition && { QueryPosition: smithyClient.SENSITIVE_STRING }),
-    ...(obj.QueryRadius && { QueryRadius: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Filter && { Filter: SearchNearbyFilterFilterSensitiveLog(obj.Filter) }),
-    ...(obj.PoliticalView && { PoliticalView: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Key && { Key: smithyClient.SENSITIVE_STRING }),
-});
-const SearchNearbyResultItemFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.PlaceId && { PlaceId: smithyClient.SENSITIVE_STRING }),
-    ...(obj.PlaceType && { PlaceType: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Title && { Title: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Address && { Address: AddressFilterSensitiveLog(obj.Address) }),
-    ...(obj.AddressNumberCorrected && { AddressNumberCorrected: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Position && { Position: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Distance && { Distance: smithyClient.SENSITIVE_STRING }),
-    ...(obj.MapView && { MapView: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Categories && { Categories: obj.Categories.map((item) => CategoryFilterSensitiveLog(item)) }),
-    ...(obj.FoodTypes && { FoodTypes: obj.FoodTypes.map((item) => FoodTypeFilterSensitiveLog(item)) }),
-    ...(obj.BusinessChains && {
-        BusinessChains: obj.BusinessChains.map((item) => BusinessChainFilterSensitiveLog(item)),
-    }),
-    ...(obj.Contacts && { Contacts: ContactsFilterSensitiveLog(obj.Contacts) }),
-    ...(obj.OpeningHours && { OpeningHours: obj.OpeningHours.map((item) => OpeningHoursFilterSensitiveLog(item)) }),
-    ...(obj.AccessPoints && { AccessPoints: obj.AccessPoints.map((item) => AccessPointFilterSensitiveLog(item)) }),
-    ...(obj.AccessRestrictions && {
-        AccessRestrictions: obj.AccessRestrictions.map((item) => AccessRestrictionFilterSensitiveLog(item)),
-    }),
-    ...(obj.TimeZone && { TimeZone: TimeZoneFilterSensitiveLog(obj.TimeZone) }),
-    ...(obj.PoliticalView && { PoliticalView: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Phonemes && { Phonemes: PhonemeDetailsFilterSensitiveLog(obj.Phonemes) }),
-});
-const SearchNearbyResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.ResultItems && {
-        ResultItems: obj.ResultItems.map((item) => SearchNearbyResultItemFilterSensitiveLog(item)),
-    }),
-});
-const SearchTextFilterFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.BoundingBox && { BoundingBox: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Circle && { Circle: smithyClient.SENSITIVE_STRING }),
-    ...(obj.IncludeCountries && { IncludeCountries: smithyClient.SENSITIVE_STRING }),
-});
-const SearchTextRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.QueryText && { QueryText: smithyClient.SENSITIVE_STRING }),
-    ...(obj.QueryId && { QueryId: smithyClient.SENSITIVE_STRING }),
-    ...(obj.BiasPosition && { BiasPosition: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Filter && { Filter: SearchTextFilterFilterSensitiveLog(obj.Filter) }),
-    ...(obj.PoliticalView && { PoliticalView: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Key && { Key: smithyClient.SENSITIVE_STRING }),
-});
-const SearchTextResultItemFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.PlaceId && { PlaceId: smithyClient.SENSITIVE_STRING }),
-    ...(obj.PlaceType && { PlaceType: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Title && { Title: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Address && { Address: AddressFilterSensitiveLog(obj.Address) }),
-    ...(obj.AddressNumberCorrected && { AddressNumberCorrected: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Position && { Position: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Distance && { Distance: smithyClient.SENSITIVE_STRING }),
-    ...(obj.MapView && { MapView: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Categories && { Categories: obj.Categories.map((item) => CategoryFilterSensitiveLog(item)) }),
-    ...(obj.FoodTypes && { FoodTypes: obj.FoodTypes.map((item) => FoodTypeFilterSensitiveLog(item)) }),
-    ...(obj.BusinessChains && {
-        BusinessChains: obj.BusinessChains.map((item) => BusinessChainFilterSensitiveLog(item)),
-    }),
-    ...(obj.Contacts && { Contacts: ContactsFilterSensitiveLog(obj.Contacts) }),
-    ...(obj.OpeningHours && { OpeningHours: obj.OpeningHours.map((item) => OpeningHoursFilterSensitiveLog(item)) }),
-    ...(obj.AccessPoints && { AccessPoints: obj.AccessPoints.map((item) => AccessPointFilterSensitiveLog(item)) }),
-    ...(obj.AccessRestrictions && {
-        AccessRestrictions: obj.AccessRestrictions.map((item) => AccessRestrictionFilterSensitiveLog(item)),
-    }),
-    ...(obj.TimeZone && { TimeZone: TimeZoneFilterSensitiveLog(obj.TimeZone) }),
-    ...(obj.PoliticalView && { PoliticalView: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Phonemes && { Phonemes: PhonemeDetailsFilterSensitiveLog(obj.Phonemes) }),
-});
-const SearchTextResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.ResultItems && { ResultItems: obj.ResultItems.map((item) => SearchTextResultItemFilterSensitiveLog(item)) }),
-});
-const SuggestFilterFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.BoundingBox && { BoundingBox: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Circle && { Circle: smithyClient.SENSITIVE_STRING }),
-    ...(obj.IncludeCountries && { IncludeCountries: smithyClient.SENSITIVE_STRING }),
-});
-const SuggestRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.QueryText && { QueryText: smithyClient.SENSITIVE_STRING }),
-    ...(obj.BiasPosition && { BiasPosition: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Filter && { Filter: SuggestFilterFilterSensitiveLog(obj.Filter) }),
-    ...(obj.PoliticalView && { PoliticalView: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Key && { Key: smithyClient.SENSITIVE_STRING }),
-});
-const QueryRefinementFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.RefinedTerm && { RefinedTerm: smithyClient.SENSITIVE_STRING }),
-    ...(obj.OriginalTerm && { OriginalTerm: smithyClient.SENSITIVE_STRING }),
-});
-const SuggestAddressHighlightsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Label && { Label: obj.Label.map((item) => HighlightFilterSensitiveLog(item)) }),
-});
-const SuggestHighlightsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Title && { Title: obj.Title.map((item) => HighlightFilterSensitiveLog(item)) }),
-    ...(obj.Address && { Address: SuggestAddressHighlightsFilterSensitiveLog(obj.Address) }),
-});
-const SuggestPlaceResultFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.PlaceId && { PlaceId: smithyClient.SENSITIVE_STRING }),
-    ...(obj.PlaceType && { PlaceType: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Address && { Address: AddressFilterSensitiveLog(obj.Address) }),
-    ...(obj.Position && { Position: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Distance && { Distance: smithyClient.SENSITIVE_STRING }),
-    ...(obj.MapView && { MapView: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Categories && { Categories: obj.Categories.map((item) => CategoryFilterSensitiveLog(item)) }),
-    ...(obj.FoodTypes && { FoodTypes: obj.FoodTypes.map((item) => FoodTypeFilterSensitiveLog(item)) }),
-    ...(obj.BusinessChains && {
-        BusinessChains: obj.BusinessChains.map((item) => BusinessChainFilterSensitiveLog(item)),
-    }),
-    ...(obj.AccessPoints && { AccessPoints: obj.AccessPoints.map((item) => AccessPointFilterSensitiveLog(item)) }),
-    ...(obj.AccessRestrictions && {
-        AccessRestrictions: obj.AccessRestrictions.map((item) => AccessRestrictionFilterSensitiveLog(item)),
-    }),
-    ...(obj.TimeZone && { TimeZone: TimeZoneFilterSensitiveLog(obj.TimeZone) }),
-    ...(obj.PoliticalView && { PoliticalView: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Phonemes && { Phonemes: PhonemeDetailsFilterSensitiveLog(obj.Phonemes) }),
-});
-const SuggestQueryResultFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.QueryId && { QueryId: smithyClient.SENSITIVE_STRING }),
-});
-const SuggestResultItemFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Title && { Title: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Place && { Place: SuggestPlaceResultFilterSensitiveLog(obj.Place) }),
-    ...(obj.Query && { Query: SuggestQueryResultFilterSensitiveLog(obj.Query) }),
-    ...(obj.Highlights && { Highlights: SuggestHighlightsFilterSensitiveLog(obj.Highlights) }),
-});
-const SuggestResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.ResultItems && { ResultItems: obj.ResultItems.map((item) => SuggestResultItemFilterSensitiveLog(item)) }),
-    ...(obj.QueryRefinements && {
-        QueryRefinements: obj.QueryRefinements.map((item) => QueryRefinementFilterSensitiveLog(item)),
-    }),
-});
 
-const se_AutocompleteCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/autocomplete");
-    const query = smithyClient.map({
-        [_k]: [, input[_K]],
-    });
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        AdditionalFeatures: (_) => smithyClient._json(_),
-        BiasPosition: (_) => se_Position(_),
-        Filter: (_) => se_AutocompleteFilter(_),
-        IntendedUse: [],
-        Language: [],
-        MaxResults: [],
-        PoliticalView: [],
-        PostalCodeMode: [],
-        QueryText: [],
-    }));
-    b.m("POST").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_GeocodeCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/geocode");
-    const query = smithyClient.map({
-        [_k]: [, input[_K]],
-    });
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        AdditionalFeatures: (_) => smithyClient._json(_),
-        BiasPosition: (_) => se_Position(_),
-        Filter: (_) => smithyClient._json(_),
-        IntendedUse: [],
-        Language: [],
-        MaxResults: [],
-        PoliticalView: [],
-        QueryComponents: (_) => smithyClient._json(_),
-        QueryText: [],
-    }));
-    b.m("POST").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_GetPlaceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/place/{PlaceId}");
-    b.p("PlaceId", () => input.PlaceId, "{PlaceId}", false);
-    const query = smithyClient.map({
-        [_af]: [() => input.AdditionalFeatures !== void 0, () => input[_AF] || []],
-        [_l]: [, input[_L]],
-        [_pv]: [, input[_PV]],
-        [_iu]: [, input[_IU]],
-        [_k]: [, input[_K]],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_ReverseGeocodeCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/reverse-geocode");
-    const query = smithyClient.map({
-        [_k]: [, input[_K]],
-    });
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        AdditionalFeatures: (_) => smithyClient._json(_),
-        Filter: (_) => smithyClient._json(_),
-        IntendedUse: [],
-        Language: [],
-        MaxResults: [],
-        PoliticalView: [],
-        QueryPosition: (_) => se_Position(_),
-        QueryRadius: [],
-    }));
-    b.m("POST").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_SearchNearbyCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/search-nearby");
-    const query = smithyClient.map({
-        [_k]: [, input[_K]],
-    });
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        AdditionalFeatures: (_) => smithyClient._json(_),
-        Filter: (_) => se_SearchNearbyFilter(_),
-        IntendedUse: [],
-        Language: [],
-        MaxResults: [],
-        NextToken: [],
-        PoliticalView: [],
-        QueryPosition: (_) => se_Position(_),
-        QueryRadius: [],
-    }));
-    b.m("POST").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_SearchTextCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/search-text");
-    const query = smithyClient.map({
-        [_k]: [, input[_K]],
-    });
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        AdditionalFeatures: (_) => smithyClient._json(_),
-        BiasPosition: (_) => se_Position(_),
-        Filter: (_) => se_SearchTextFilter(_),
-        IntendedUse: [],
-        Language: [],
-        MaxResults: [],
-        NextToken: [],
-        PoliticalView: [],
-        QueryId: [],
-        QueryText: [],
-    }));
-    b.m("POST").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_SuggestCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/suggest");
-    const query = smithyClient.map({
-        [_k]: [, input[_K]],
-    });
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        AdditionalFeatures: (_) => smithyClient._json(_),
-        BiasPosition: (_) => se_Position(_),
-        Filter: (_) => se_SuggestFilter(_),
-        IntendedUse: [],
-        Language: [],
-        MaxQueryRefinements: [],
-        MaxResults: [],
-        PoliticalView: [],
-        QueryText: [],
-    }));
-    b.m("POST").h(headers).q(query).b(body);
-    return b.build();
-};
-const de_AutocompleteCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-        [_PB]: [, output.headers[_xagpb]],
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        ResultItems: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GeocodeCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-        [_PB]: [, output.headers[_xagpb]],
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        ResultItems: (_) => de_GeocodeResultItemList(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetPlaceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-        [_PB]: [, output.headers[_xagpb]],
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        AccessPoints: (_) => de_AccessPointList(_),
-        AccessRestrictions: smithyClient._json,
-        Address: smithyClient._json,
-        AddressNumberCorrected: smithyClient.expectBoolean,
-        BusinessChains: smithyClient._json,
-        Categories: smithyClient._json,
-        Contacts: smithyClient._json,
-        FoodTypes: smithyClient._json,
-        MainAddress: (_) => de_RelatedPlace(_),
-        MapView: (_) => de_BoundingBox(_),
-        OpeningHours: smithyClient._json,
-        Phonemes: smithyClient._json,
-        PlaceId: smithyClient.expectString,
-        PlaceType: smithyClient.expectString,
-        PoliticalView: smithyClient.expectString,
-        Position: (_) => de_Position(_),
-        PostalCodeDetails: smithyClient._json,
-        SecondaryAddresses: (_) => de_RelatedPlaceList(_),
-        TimeZone: smithyClient._json,
-        Title: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ReverseGeocodeCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-        [_PB]: [, output.headers[_xagpb]],
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        ResultItems: (_) => de_ReverseGeocodeResultItemList(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_SearchNearbyCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-        [_PB]: [, output.headers[_xagpb]],
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        NextToken: smithyClient.expectString,
-        ResultItems: (_) => de_SearchNearbyResultItemList(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_SearchTextCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-        [_PB]: [, output.headers[_xagpb]],
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        NextToken: smithyClient.expectString,
-        ResultItems: (_) => de_SearchTextResultItemList(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_SuggestCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-        [_PB]: [, output.headers[_xagpb]],
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        QueryRefinements: smithyClient._json,
-        ResultItems: (_) => de_SuggestResultItemList(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonErrorBody(output.body, context),
-    };
-    const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.geoplaces#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput);
-        case "InternalServerException":
-        case "com.amazonaws.geoplaces#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput);
-        case "ThrottlingException":
-        case "com.amazonaws.geoplaces#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput);
-        case "ValidationException":
-        case "com.amazonaws.geoplaces#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const throwDefaultError = smithyClient.withBaseException(GeoPlacesServiceException);
-const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: [, smithyClient.expectString, `message`],
-    });
-    Object.assign(contents, doc);
-    const exception = new AccessDeniedException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InternalServerExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: [, smithyClient.expectString, `message`],
-    });
-    Object.assign(contents, doc);
-    const exception = new InternalServerException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: [, smithyClient.expectString, `message`],
-    });
-    Object.assign(contents, doc);
-    const exception = new ThrottlingException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ValidationExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        FieldList: [, (_) => de_ValidationExceptionFieldList(_), `fieldList`],
-        Message: [, smithyClient.expectString, `message`],
-        Reason: [, smithyClient.expectString, `reason`],
-    });
-    Object.assign(contents, doc);
-    const exception = new ValidationException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const se_AutocompleteFilter = (input, context) => {
-    return smithyClient.take(input, {
-        BoundingBox: (_) => se_BoundingBox(_),
-        Circle: (_) => se_FilterCircle(_),
-        IncludeCountries: smithyClient._json,
-        IncludePlaceTypes: smithyClient._json,
-    });
-};
-const se_BoundingBox = (input, context) => {
-    return input
-        .filter((e) => e != null)
-        .map((entry) => {
-        return smithyClient.serializeFloat(entry);
-    });
-};
-const se_FilterCircle = (input, context) => {
-    return smithyClient.take(input, {
-        Center: (_) => se_Position(_),
-        Radius: [],
-    });
-};
-const se_Position = (input, context) => {
-    return input
-        .filter((e) => e != null)
-        .map((entry) => {
-        return smithyClient.serializeFloat(entry);
-    });
-};
-const se_SearchNearbyFilter = (input, context) => {
-    return smithyClient.take(input, {
-        BoundingBox: (_) => se_BoundingBox(_),
-        ExcludeBusinessChains: smithyClient._json,
-        ExcludeCategories: smithyClient._json,
-        ExcludeFoodTypes: smithyClient._json,
-        IncludeBusinessChains: smithyClient._json,
-        IncludeCategories: smithyClient._json,
-        IncludeCountries: smithyClient._json,
-        IncludeFoodTypes: smithyClient._json,
-    });
-};
-const se_SearchTextFilter = (input, context) => {
-    return smithyClient.take(input, {
-        BoundingBox: (_) => se_BoundingBox(_),
-        Circle: (_) => se_FilterCircle(_),
-        IncludeCountries: smithyClient._json,
-    });
-};
-const se_SuggestFilter = (input, context) => {
-    return smithyClient.take(input, {
-        BoundingBox: (_) => se_BoundingBox(_),
-        Circle: (_) => se_FilterCircle(_),
-        IncludeCountries: smithyClient._json,
-    });
-};
-const de_AccessPoint = (output, context) => {
-    return smithyClient.take(output, {
-        Position: (_) => de_Position(_),
-    });
-};
-const de_AccessPointList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_AccessPoint(entry);
-    });
-    return retVal;
-};
-const de_AddressComponentMatchScores = (output, context) => {
-    return smithyClient.take(output, {
-        AddressNumber: smithyClient.limitedParseDouble,
-        Block: smithyClient.limitedParseDouble,
-        Building: smithyClient.limitedParseDouble,
-        Country: smithyClient.limitedParseDouble,
-        District: smithyClient.limitedParseDouble,
-        Intersection: (_) => de_MatchScoreList(_),
-        Locality: smithyClient.limitedParseDouble,
-        PostalCode: smithyClient.limitedParseDouble,
-        Region: smithyClient.limitedParseDouble,
-        SecondaryAddressComponents: (_) => de_SecondaryAddressComponentMatchScoreList(_),
-        SubBlock: smithyClient.limitedParseDouble,
-        SubDistrict: smithyClient.limitedParseDouble,
-        SubRegion: smithyClient.limitedParseDouble,
-    });
-};
-const de_BoundingBox = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return smithyClient.limitedParseDouble(entry);
-    });
-    return retVal;
-};
-const de_ComponentMatchScores = (output, context) => {
-    return smithyClient.take(output, {
-        Address: (_) => de_AddressComponentMatchScores(_),
-        Title: smithyClient.limitedParseDouble,
-    });
-};
-const de_GeocodeResultItem = (output, context) => {
-    return smithyClient.take(output, {
-        AccessPoints: (_) => de_AccessPointList(_),
-        Address: smithyClient._json,
-        AddressNumberCorrected: smithyClient.expectBoolean,
-        Categories: smithyClient._json,
-        Distance: smithyClient.expectLong,
-        FoodTypes: smithyClient._json,
-        Intersections: (_) => de_IntersectionList(_),
-        MainAddress: (_) => de_RelatedPlace(_),
-        MapView: (_) => de_BoundingBox(_),
-        MatchScores: (_) => de_MatchScoreDetails(_),
-        ParsedQuery: smithyClient._json,
-        PlaceId: smithyClient.expectString,
-        PlaceType: smithyClient.expectString,
-        PoliticalView: smithyClient.expectString,
-        Position: (_) => de_Position(_),
-        PostalCodeDetails: smithyClient._json,
-        SecondaryAddresses: (_) => de_RelatedPlaceList(_),
-        TimeZone: smithyClient._json,
-        Title: smithyClient.expectString,
-    });
-};
-const de_GeocodeResultItemList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_GeocodeResultItem(entry);
-    });
-    return retVal;
-};
-const de_Intersection = (output, context) => {
-    return smithyClient.take(output, {
-        AccessPoints: (_) => de_AccessPointList(_),
-        Address: smithyClient._json,
-        Distance: smithyClient.expectLong,
-        MapView: (_) => de_BoundingBox(_),
-        PlaceId: smithyClient.expectString,
-        Position: (_) => de_Position(_),
-        RouteDistance: smithyClient.expectLong,
-        Title: smithyClient.expectString,
-    });
-};
-const de_IntersectionList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_Intersection(entry);
-    });
-    return retVal;
-};
-const de_MatchScoreDetails = (output, context) => {
-    return smithyClient.take(output, {
-        Components: (_) => de_ComponentMatchScores(_),
-        Overall: smithyClient.limitedParseDouble,
-    });
-};
-const de_MatchScoreList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return smithyClient.limitedParseDouble(entry);
-    });
-    return retVal;
-};
-const de_Position = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return smithyClient.limitedParseDouble(entry);
-    });
-    return retVal;
-};
-const de_RelatedPlace = (output, context) => {
-    return smithyClient.take(output, {
-        AccessPoints: (_) => de_AccessPointList(_),
-        Address: smithyClient._json,
-        PlaceId: smithyClient.expectString,
-        PlaceType: smithyClient.expectString,
-        Position: (_) => de_Position(_),
-        Title: smithyClient.expectString,
-    });
-};
-const de_RelatedPlaceList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_RelatedPlace(entry);
-    });
-    return retVal;
-};
-const de_ReverseGeocodeResultItem = (output, context) => {
-    return smithyClient.take(output, {
-        AccessPoints: (_) => de_AccessPointList(_),
-        Address: smithyClient._json,
-        AddressNumberCorrected: smithyClient.expectBoolean,
-        Categories: smithyClient._json,
-        Distance: smithyClient.expectLong,
-        FoodTypes: smithyClient._json,
-        Intersections: (_) => de_IntersectionList(_),
-        MapView: (_) => de_BoundingBox(_),
-        PlaceId: smithyClient.expectString,
-        PlaceType: smithyClient.expectString,
-        PoliticalView: smithyClient.expectString,
-        Position: (_) => de_Position(_),
-        PostalCodeDetails: smithyClient._json,
-        TimeZone: smithyClient._json,
-        Title: smithyClient.expectString,
-    });
-};
-const de_ReverseGeocodeResultItemList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ReverseGeocodeResultItem(entry);
-    });
-    return retVal;
-};
-const de_SearchNearbyResultItem = (output, context) => {
-    return smithyClient.take(output, {
-        AccessPoints: (_) => de_AccessPointList(_),
-        AccessRestrictions: smithyClient._json,
-        Address: smithyClient._json,
-        AddressNumberCorrected: smithyClient.expectBoolean,
-        BusinessChains: smithyClient._json,
-        Categories: smithyClient._json,
-        Contacts: smithyClient._json,
-        Distance: smithyClient.expectLong,
-        FoodTypes: smithyClient._json,
-        MapView: (_) => de_BoundingBox(_),
-        OpeningHours: smithyClient._json,
-        Phonemes: smithyClient._json,
-        PlaceId: smithyClient.expectString,
-        PlaceType: smithyClient.expectString,
-        PoliticalView: smithyClient.expectString,
-        Position: (_) => de_Position(_),
-        TimeZone: smithyClient._json,
-        Title: smithyClient.expectString,
-    });
-};
-const de_SearchNearbyResultItemList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_SearchNearbyResultItem(entry);
-    });
-    return retVal;
-};
-const de_SearchTextResultItem = (output, context) => {
-    return smithyClient.take(output, {
-        AccessPoints: (_) => de_AccessPointList(_),
-        AccessRestrictions: smithyClient._json,
-        Address: smithyClient._json,
-        AddressNumberCorrected: smithyClient.expectBoolean,
-        BusinessChains: smithyClient._json,
-        Categories: smithyClient._json,
-        Contacts: smithyClient._json,
-        Distance: smithyClient.expectLong,
-        FoodTypes: smithyClient._json,
-        MapView: (_) => de_BoundingBox(_),
-        OpeningHours: smithyClient._json,
-        Phonemes: smithyClient._json,
-        PlaceId: smithyClient.expectString,
-        PlaceType: smithyClient.expectString,
-        PoliticalView: smithyClient.expectString,
-        Position: (_) => de_Position(_),
-        TimeZone: smithyClient._json,
-        Title: smithyClient.expectString,
-    });
-};
-const de_SearchTextResultItemList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_SearchTextResultItem(entry);
-    });
-    return retVal;
-};
-const de_SecondaryAddressComponentMatchScore = (output, context) => {
-    return smithyClient.take(output, {
-        Number: smithyClient.limitedParseDouble,
-    });
-};
-const de_SecondaryAddressComponentMatchScoreList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_SecondaryAddressComponentMatchScore(entry);
-    });
-    return retVal;
-};
-const de_SuggestPlaceResult = (output, context) => {
-    return smithyClient.take(output, {
-        AccessPoints: (_) => de_AccessPointList(_),
-        AccessRestrictions: smithyClient._json,
-        Address: smithyClient._json,
-        BusinessChains: smithyClient._json,
-        Categories: smithyClient._json,
-        Distance: smithyClient.expectLong,
-        FoodTypes: smithyClient._json,
-        MapView: (_) => de_BoundingBox(_),
-        Phonemes: smithyClient._json,
-        PlaceId: smithyClient.expectString,
-        PlaceType: smithyClient.expectString,
-        PoliticalView: smithyClient.expectString,
-        Position: (_) => de_Position(_),
-        TimeZone: smithyClient._json,
-    });
-};
-const de_SuggestResultItem = (output, context) => {
-    return smithyClient.take(output, {
-        Highlights: smithyClient._json,
-        Place: (_) => de_SuggestPlaceResult(_),
-        Query: smithyClient._json,
-        SuggestResultItemType: smithyClient.expectString,
-        Title: smithyClient.expectString,
-    });
-};
-const de_SuggestResultItemList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_SuggestResultItem(entry);
-    });
-    return retVal;
-};
-const de_ValidationExceptionField = (output, context) => {
-    return smithyClient.take(output, {
-        Message: [, smithyClient.expectString, `message`],
-        Name: [, smithyClient.expectString, `name`],
-    });
-};
-const de_ValidationExceptionFieldList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ValidationExceptionField(entry);
-    });
-    return retVal;
-};
-const deserializeMetadata = (output) => ({
-    httpStatusCode: output.statusCode,
-    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
-    extendedRequestId: output.headers["x-amz-id-2"],
-    cfId: output.headers["x-amz-cf-id"],
-});
-const _AF = "AdditionalFeatures";
+const _A = "Address";
+const _AAH = "AutocompleteAddressHighlights";
+const _ACMS = "AddressComponentMatchScores";
+const _ACP = "AddressComponentPhonemes";
+const _ADE = "AccessDeniedException";
+const _AF = "AutocompleteFilter";
+const _AFd = "AdditionalFeatures";
+const _AH = "AutocompleteHighlights";
+const _AK = "ApiKey";
+const _AN = "AddressNumber";
+const _ANC = "AddressNumberCorrected";
+const _AP = "AccessPoint";
+const _APL = "AccessPointList";
+const _APc = "AccessPoints";
+const _AR = "AccessRestriction";
+const _ARI = "AutocompleteResultItem";
+const _ARIL = "AutocompleteResultItemList";
+const _ARL = "AccessRestrictionList";
+const _ARc = "AccessRestrictions";
+const _ARu = "AutocompleteRequest";
+const _ARut = "AutocompleteResponse";
+const _Au = "Autocomplete";
+const _B = "Block";
+const _BB = "BoundingBox";
+const _BC = "BusinessChain";
+const _BCL = "BusinessChainList";
+const _BCu = "BusinessChains";
+const _BN = "BaseName";
+const _BP = "BiasPosition";
+const _Bu = "Building";
+const _C = "Categories";
+const _CC = "CountryCode";
+const _CCL = "CountryCodeList";
+const _CCo = "CountryCode2";
+const _CCou = "CountryCode3";
+const _CD = "ContactDetails";
+const _CDL = "ContactDetailsList";
+const _CH = "CountryHighlights";
+const _CL = "CategoryList";
+const _CMS = "ComponentMatchScores";
+const _Ca = "Category";
+const _Ce = "Center";
+const _Ci = "Circle";
+const _Co = "Country";
+const _Cod = "Code2";
+const _Code = "Code3";
+const _Code_ = "Code";
+const _Com = "Components";
+const _Con = "Contacts";
+const _D = "District";
+const _DM = "DistanceMeters";
+const _DS = "DurationSeconds";
+const _De = "Designator";
+const _Di = "Distance";
+const _Dir = "Direction";
+const _Dis = "Display";
+const _E = "Emails";
+const _EBC = "ExcludeBusinessChains";
+const _EC = "ExcludeCategories";
+const _EFT = "ExcludeFoodTypes";
+const _EI = "EndIndex";
+const _F = "Filter";
+const _FBCL = "FilterBusinessChainList";
+const _FC = "FilterCircle";
+const _FCL = "FilterCategoryList";
+const _FFTL = "FilterFoodTypeList";
+const _FL = "FieldList";
+const _FT = "FoodType";
+const _FTL = "FoodTypeList";
+const _FTo = "FoodTypes";
+const _Fa = "Faxes";
+const _G = "Geocode";
+const _GF = "GeocodeFilter";
+const _GFPT = "GeocodeFilterPlaceType";
+const _GFPTL = "GeocodeFilterPlaceTypeList";
+const _GP = "GetPlace";
+const _GPQ = "GeocodeParsedQuery";
+const _GPQAC = "GeocodeParsedQueryAddressComponents";
+const _GPR = "GetPlaceRequest";
+const _GPRe = "GetPlaceResponse";
+const _GQC = "GeocodeQueryComponents";
+const _GR = "GeocodeRequest";
+const _GRI = "GeocodeResultItem";
+const _GRIL = "GeocodeResultItemList";
+const _GRe = "GeocodeResponse";
+const _H = "Highlights";
+const _HL = "HighlightList";
+const _Hi = "Highlight";
+const _I = "Intersection";
+const _IBC = "IncludeBusinessChains";
+const _IC = "IncludeCountries";
+const _ICn = "IncludeCategories";
+const _IFT = "IncludeFoodTypes";
+const _IHL = "IntersectionHighlightsList";
+const _IL = "IntersectionList";
+const _IPT = "IncludePlaceTypes";
+const _ISE = "InternalServerException";
 const _IU = "IntendedUse";
+const _Id = "Id";
+const _In = "Intersections";
 const _K = "Key";
-const _L = "Language";
+const _L = "Label";
+const _LN = "LocalizedName";
+const _La = "Language";
+const _Lo = "Locality";
+const _M = "Message";
+const _MA = "MainAddress";
+const _MQR = "MaxQueryRefinements";
+const _MR = "MaxResults";
+const _MS = "MatchScores";
+const _MSD = "MatchScoreDetails";
+const _MV = "MapView";
+const _N = "Name";
+const _NT = "NextToken";
+const _Nu = "Number";
+const _O = "Overall";
+const _OD = "OpenDuration";
+const _OH = "OpeningHours";
+const _OHC = "OpeningHoursComponents";
+const _OHCL = "OpeningHoursComponentsList";
+const _OHD = "OpeningHoursDisplay";
+const _OHDL = "OpeningHoursDisplayList";
+const _OHL = "OpeningHoursList";
+const _ON = "OpenNow";
+const _OS = "OffsetSeconds";
+const _OT = "OpenTime";
+const _OTr = "OriginalTerm";
+const _Of = "Offset";
+const _P = "Position";
+const _PA = "PostalAuthority";
 const _PB = "PricingBucket";
+const _PC = "PostalCode";
+const _PCD = "PostalCodeDetails";
+const _PCDL = "PostalCodeDetailsList";
+const _PCM = "PostalCodeMode";
+const _PCT = "PostalCodeType";
+const _PD = "PhonemeDetails";
+const _PI = "PlaceId";
+const _PQ = "ParsedQuery";
+const _PQC = "ParsedQueryComponent";
+const _PQCL = "ParsedQueryComponentList";
+const _PQSAC = "ParsedQuerySecondaryAddressComponent";
+const _PQSACL = "ParsedQuerySecondaryAddressComponentList";
+const _PT = "PlaceType";
+const _PTL = "PhonemeTranscriptionList";
+const _PTh = "PhonemeTranscription";
 const _PV = "PoliticalView";
+const _Ph = "Phones";
+const _Pho = "Phonemes";
+const _Pl = "Place";
+const _Pr = "Primary";
+const _Pre = "Preferred";
+const _Pref = "Prefix";
+const _Q = "Query";
+const _QC = "QueryComponents";
+const _QCu = "QueryComponent";
+const _QI = "QueryId";
+const _QP = "QueryPosition";
+const _QR = "QueryRefinement";
+const _QRL = "QueryRefinementList";
+const _QRu = "QueryRadius";
+const _QRue = "QueryRefinements";
+const _QT = "QueryText";
+const _QTu = "QueryType";
+const _R = "Restricted";
+const _RD = "RouteDistance";
+const _RG = "ReverseGeocode";
+const _RGF = "ReverseGeocodeFilter";
+const _RGR = "ReverseGeocodeRequest";
+const _RGRI = "ReverseGeocodeResultItem";
+const _RGRIL = "ReverseGeocodeResultItemList";
+const _RGRe = "ReverseGeocodeResponse";
+const _RH = "RegionHighlights";
+const _RI = "ResultItems";
+const _RP = "RelatedPlace";
+const _RPL = "RelatedPlaceList";
+const _RT = "RefinedTerm";
+const _RTC = "RecordTypeCode";
+const _Ra = "Radius";
+const _Re = "Region";
+const _Rea = "Reason";
+const _Rec = "Recurrence";
+const _S = "Street";
+const _SA = "SecondaryAddresses";
+const _SAC = "SecondaryAddressComponents";
+const _SACL = "SecondaryAddressComponentList";
+const _SACMS = "SecondaryAddressComponentMatchScore";
+const _SACMSL = "SecondaryAddressComponentMatchScoreList";
+const _SACe = "SecondaryAddressComponent";
+const _SAH = "SuggestAddressHighlights";
+const _SB = "SensitiveBoolean";
+const _SBu = "SubBlock";
+const _SC = "StreetComponents";
+const _SCL = "StreetComponentsList";
+const _SD = "SubDistrict";
+const _SF = "SuggestFilter";
+const _SH = "SuggestHighlights";
+const _SI = "StartIndex";
+const _SN = "SearchNearby";
+const _SNF = "SearchNearbyFilter";
+const _SNR = "SearchNearbyRequest";
+const _SNRI = "SearchNearbyResultItem";
+const _SNRIL = "SearchNearbyResultItemList";
+const _SNRe = "SearchNearbyResponse";
+const _SPR = "SuggestPlaceResult";
+const _SQR = "SuggestQueryResult";
+const _SR = "SubRegion";
+const _SRH = "SubRegionHighlights";
+const _SRI = "SuggestResultItem";
+const _SRIL = "SuggestResultItemList";
+const _SRIT = "SuggestResultItemType";
+const _SRu = "SuggestRequest";
+const _SRug = "SuggestResponse";
+const _SS = "SensitiveString";
+const _ST = "SearchText";
+const _STF = "SearchTextFilter";
+const _STR = "SearchTextRequest";
+const _STRI = "SearchTextResultItem";
+const _STRIL = "SearchTextResultItemList";
+const _STRe = "SearchTextResponse";
+const _Su = "Suffix";
+const _Sug = "Suggest";
+const _T = "Title";
+const _TE = "ThrottlingException";
+const _TP = "TypePlacement";
+const _TS = "TypeSeparator";
+const _TZ = "TimeZone";
+const _Ty = "Type";
+const _UZ = "UspsZip";
+const _UZP = "UspsZipPlus4";
+const _V = "Value";
+const _VE = "ValidationException";
+const _VEF = "ValidationExceptionField";
+const _VEFL = "ValidationExceptionFieldList";
+const _W = "Websites";
+const _ZCC = "ZipClassificationCode";
 const _af = "additional-features";
+const _c = "client";
+const _e = "error";
+const _fL = "fieldList";
+const _h = "http";
+const _hE = "httpError";
+const _hH = "httpHeader";
+const _hQ = "httpQuery";
 const _iu = "intended-use";
+const _jN = "jsonName";
 const _k = "key";
 const _l = "language";
+const _m = "message";
+const _n = "name";
 const _pv = "political-view";
+const _r = "reason";
+const _s = "server";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.geoplaces";
 const _xagpb = "x-amz-geo-pricing-bucket";
+const n0 = "com.amazonaws.geoplaces";
+var ApiKey = [0, n0, _AK, 8, 0];
+var CountryCode = [0, n0, _CC, 8, 0];
+var CountryCode2 = [0, n0, _CCo, 8, 0];
+var CountryCode3 = [0, n0, _CCou, 8, 0];
+var DistanceMeters = [0, n0, _DM, 8, 1];
+var DurationSeconds = [0, n0, _DS, 8, 1];
+var GeocodeFilterPlaceType = [0, n0, _GFPT, 8, 0];
+var OpeningHoursDisplay = [0, n0, _OHD, 8, 0];
+var PlaceType = [0, n0, _PT, 8, 0];
+var PostalAuthority = [0, n0, _PA, 8, 0];
+var PostalCodeType = [0, n0, _PCT, 8, 0];
+var RecordTypeCode = [0, n0, _RTC, 8, 0];
+var SensitiveBoolean = [0, n0, _SB, 8, 2];
+var SensitiveString = [0, n0, _SS, 8, 0];
+var ZipClassificationCode = [0, n0, _ZCC, 8, 0];
+var AccessDeniedException = [
+    -3,
+    n0,
+    _ADE,
+    {
+        [_e]: _c,
+        [_hE]: 403,
+    },
+    [_M],
+    [
+        [
+            0,
+            {
+                [_jN]: _m,
+            },
+        ],
+    ],
+];
+schema.TypeRegistry.for(n0).registerError(AccessDeniedException, AccessDeniedException$1);
+var AccessPoint = [3, n0, _AP, 0, [_P], [[() => Position, 0]]];
+var AccessRestriction = [
+    3,
+    n0,
+    _AR,
+    0,
+    [_R, _C],
+    [
+        [() => SensitiveBoolean, 0],
+        [() => CategoryList, 0],
+    ],
+];
+var Address = [
+    3,
+    n0,
+    _A,
+    0,
+    [_L, _Co, _Re, _SR, _Lo, _D, _SD, _PC, _B, _SBu, _I, _S, _SC, _AN, _Bu, _SAC],
+    [
+        [() => SensitiveString, 0],
+        [() => Country, 0],
+        [() => Region, 0],
+        [() => SubRegion, 0],
+        [() => SensitiveString, 0],
+        [() => SensitiveString, 0],
+        [() => SensitiveString, 0],
+        [() => SensitiveString, 0],
+        [() => SensitiveString, 0],
+        [() => SensitiveString, 0],
+        64 | 0,
+        [() => SensitiveString, 0],
+        [() => StreetComponentsList, 0],
+        [() => SensitiveString, 0],
+        [() => SensitiveString, 0],
+        [() => SecondaryAddressComponentList, 0],
+    ],
+];
+var AddressComponentMatchScores = [
+    3,
+    n0,
+    _ACMS,
+    0,
+    [_Co, _Re, _SR, _Lo, _D, _SD, _PC, _B, _SBu, _I, _AN, _Bu, _SAC],
+    [1, 1, 1, 1, 1, 1, 1, 1, 1, 64 | 1, 1, 1, () => SecondaryAddressComponentMatchScoreList],
+];
+var AddressComponentPhonemes = [
+    3,
+    n0,
+    _ACP,
+    0,
+    [_Co, _Re, _SR, _Lo, _D, _SD, _B, _SBu, _S],
+    [
+        [() => PhonemeTranscriptionList, 0],
+        [() => PhonemeTranscriptionList, 0],
+        [() => PhonemeTranscriptionList, 0],
+        [() => PhonemeTranscriptionList, 0],
+        [() => PhonemeTranscriptionList, 0],
+        [() => PhonemeTranscriptionList, 0],
+        [() => PhonemeTranscriptionList, 0],
+        [() => PhonemeTranscriptionList, 0],
+        [() => PhonemeTranscriptionList, 0],
+    ],
+];
+var AutocompleteAddressHighlights = [
+    3,
+    n0,
+    _AAH,
+    0,
+    [_L, _Co, _Re, _SR, _Lo, _D, _SD, _S, _B, _SBu, _I, _PC, _AN, _Bu],
+    [
+        [() => HighlightList, 0],
+        [() => CountryHighlights, 0],
+        [() => RegionHighlights, 0],
+        [() => SubRegionHighlights, 0],
+        [() => HighlightList, 0],
+        [() => HighlightList, 0],
+        [() => HighlightList, 0],
+        [() => HighlightList, 0],
+        [() => HighlightList, 0],
+        [() => HighlightList, 0],
+        [() => IntersectionHighlightsList, 0],
+        [() => HighlightList, 0],
+        [() => HighlightList, 0],
+        [() => HighlightList, 0],
+    ],
+];
+var AutocompleteFilter = [
+    3,
+    n0,
+    _AF,
+    0,
+    [_BB, _Ci, _IC, _IPT],
+    [[() => BoundingBox, 0], [() => FilterCircle, 0], [() => CountryCodeList, 0], 64 | 0],
+];
+var AutocompleteHighlights = [
+    3,
+    n0,
+    _AH,
+    0,
+    [_T, _A],
+    [
+        [() => HighlightList, 0],
+        [() => AutocompleteAddressHighlights, 0],
+    ],
+];
+var AutocompleteRequest = [
+    3,
+    n0,
+    _ARu,
+    0,
+    [_QT, _MR, _BP, _F, _PCM, _AFd, _La, _PV, _IU, _K],
+    [
+        [() => SensitiveString, 0],
+        1,
+        [() => Position, 0],
+        [() => AutocompleteFilter, 0],
+        0,
+        64 | 0,
+        0,
+        [() => CountryCode, 0],
+        0,
+        [
+            () => ApiKey,
+            {
+                [_hQ]: _k,
+            },
+        ],
+    ],
+];
+var AutocompleteResponse = [
+    3,
+    n0,
+    _ARut,
+    0,
+    [_PB, _RI],
+    [
+        [
+            0,
+            {
+                [_hH]: _xagpb,
+            },
+        ],
+        [() => AutocompleteResultItemList, 0],
+    ],
+];
+var AutocompleteResultItem = [
+    3,
+    n0,
+    _ARI,
+    0,
+    [_PI, _PT, _T, _A, _Di, _La, _PV, _H],
+    [
+        [() => SensitiveString, 0],
+        [() => PlaceType, 0],
+        [() => SensitiveString, 0],
+        [() => Address, 0],
+        [() => DistanceMeters, 0],
+        0,
+        [() => CountryCode3, 0],
+        [() => AutocompleteHighlights, 0],
+    ],
+];
+var BusinessChain = [
+    3,
+    n0,
+    _BC,
+    0,
+    [_N, _Id],
+    [
+        [() => SensitiveString, 0],
+        [() => SensitiveString, 0],
+    ],
+];
+var Category = [
+    3,
+    n0,
+    _Ca,
+    0,
+    [_Id, _N, _LN, _Pr],
+    [
+        [() => SensitiveString, 0],
+        [() => SensitiveString, 0],
+        [() => SensitiveString, 0],
+        [() => SensitiveBoolean, 0],
+    ],
+];
+var ComponentMatchScores = [
+    3,
+    n0,
+    _CMS,
+    0,
+    [_T, _A],
+    [1, () => AddressComponentMatchScores],
+];
+var ContactDetails = [
+    3,
+    n0,
+    _CD,
+    0,
+    [_L, _V, _C],
+    [
+        [() => SensitiveString, 0],
+        [() => SensitiveString, 0],
+        [() => CategoryList, 0],
+    ],
+];
+var Contacts = [
+    3,
+    n0,
+    _Con,
+    0,
+    [_Ph, _Fa, _W, _E],
+    [
+        [() => ContactDetailsList, 0],
+        [() => ContactDetailsList, 0],
+        [() => ContactDetailsList, 0],
+        [() => ContactDetailsList, 0],
+    ],
+];
+var Country = [
+    3,
+    n0,
+    _Co,
+    0,
+    [_Cod, _Code, _N],
+    [
+        [() => CountryCode2, 0],
+        [() => CountryCode3, 0],
+        [() => SensitiveString, 0],
+    ],
+];
+var CountryHighlights = [
+    3,
+    n0,
+    _CH,
+    0,
+    [_Code_, _N],
+    [
+        [() => HighlightList, 0],
+        [() => HighlightList, 0],
+    ],
+];
+var FilterCircle = [
+    3,
+    n0,
+    _FC,
+    8,
+    [_Ce, _Ra],
+    [
+        [() => Position, 0],
+        [() => DistanceMeters, 0],
+    ],
+];
+var FoodType = [
+    3,
+    n0,
+    _FT,
+    0,
+    [_LN, _Id, _Pr],
+    [
+        [() => SensitiveString, 0],
+        [() => SensitiveString, 0],
+        [() => SensitiveBoolean, 0],
+    ],
+];
+var GeocodeFilter = [
+    3,
+    n0,
+    _GF,
+    0,
+    [_IC, _IPT],
+    [
+        [() => CountryCodeList, 0],
+        [() => GeocodeFilterPlaceTypeList, 0],
+    ],
+];
+var GeocodeParsedQuery = [
+    3,
+    n0,
+    _GPQ,
+    0,
+    [_T, _A],
+    [
+        [() => ParsedQueryComponentList, 0],
+        [() => GeocodeParsedQueryAddressComponents, 0],
+    ],
+];
+var GeocodeParsedQueryAddressComponents = [
+    3,
+    n0,
+    _GPQAC,
+    0,
+    [_Co, _Re, _SR, _Lo, _D, _SD, _PC, _B, _SBu, _S, _AN, _Bu, _SAC],
+    [
+        [() => ParsedQueryComponentList, 0],
+        [() => ParsedQueryComponentList, 0],
+        [() => ParsedQueryComponentList, 0],
+        [() => ParsedQueryComponentList, 0],
+        [() => ParsedQueryComponentList, 0],
+        [() => ParsedQueryComponentList, 0],
+        [() => ParsedQueryComponentList, 0],
+        [() => ParsedQueryComponentList, 0],
+        [() => ParsedQueryComponentList, 0],
+        [() => ParsedQueryComponentList, 0],
+        [() => ParsedQueryComponentList, 0],
+        [() => ParsedQueryComponentList, 0],
+        [() => ParsedQuerySecondaryAddressComponentList, 0],
+    ],
+];
+var GeocodeQueryComponents = [
+    3,
+    n0,
+    _GQC,
+    0,
+    [_Co, _Re, _SR, _Lo, _D, _S, _AN, _PC],
+    [
+        [() => SensitiveString, 0],
+        [() => SensitiveString, 0],
+        [() => SensitiveString, 0],
+        [() => SensitiveString, 0],
+        [() => SensitiveString, 0],
+        [() => SensitiveString, 0],
+        [() => SensitiveString, 0],
+        [() => SensitiveString, 0],
+    ],
+];
+var GeocodeRequest = [
+    3,
+    n0,
+    _GR,
+    0,
+    [_QT, _QC, _MR, _BP, _F, _AFd, _La, _PV, _IU, _K],
+    [
+        [() => SensitiveString, 0],
+        [() => GeocodeQueryComponents, 0],
+        1,
+        [() => Position, 0],
+        [() => GeocodeFilter, 0],
+        64 | 0,
+        0,
+        [() => CountryCode, 0],
+        0,
+        [
+            () => ApiKey,
+            {
+                [_hQ]: _k,
+            },
+        ],
+    ],
+];
+var GeocodeResponse = [
+    3,
+    n0,
+    _GRe,
+    0,
+    [_PB, _RI],
+    [
+        [
+            0,
+            {
+                [_hH]: _xagpb,
+            },
+        ],
+        [() => GeocodeResultItemList, 0],
+    ],
+];
+var GeocodeResultItem = [
+    3,
+    n0,
+    _GRI,
+    0,
+    [_PI, _PT, _T, _A, _ANC, _PCD, _P, _Di, _MV, _C, _FTo, _APc, _TZ, _PV, _MS, _PQ, _In, _MA, _SA],
+    [
+        [() => SensitiveString, 0],
+        [() => PlaceType, 0],
+        [() => SensitiveString, 0],
+        [() => Address, 0],
+        [() => SensitiveBoolean, 0],
+        [() => PostalCodeDetailsList, 0],
+        [() => Position, 0],
+        [() => DistanceMeters, 0],
+        [() => BoundingBox, 0],
+        [() => CategoryList, 0],
+        [() => FoodTypeList, 0],
+        [() => AccessPointList, 0],
+        [() => TimeZone, 0],
+        [() => CountryCode3, 0],
+        () => MatchScoreDetails,
+        [() => GeocodeParsedQuery, 0],
+        [() => IntersectionList, 0],
+        [() => RelatedPlace, 0],
+        [() => RelatedPlaceList, 0],
+    ],
+];
+var GetPlaceRequest = [
+    3,
+    n0,
+    _GPR,
+    0,
+    [_PI, _AFd, _La, _PV, _IU, _K],
+    [
+        [() => SensitiveString, 1],
+        [
+            64 | 0,
+            {
+                [_hQ]: _af,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _l,
+            },
+        ],
+        [
+            () => CountryCode,
+            {
+                [_hQ]: _pv,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _iu,
+            },
+        ],
+        [
+            () => ApiKey,
+            {
+                [_hQ]: _k,
+            },
+        ],
+    ],
+];
+var GetPlaceResponse = [
+    3,
+    n0,
+    _GPRe,
+    0,
+    [_PI, _PT, _T, _PB, _A, _ANC, _PCD, _P, _MV, _C, _FTo, _BCu, _Con, _OH, _APc, _ARc, _TZ, _PV, _Pho, _MA, _SA],
+    [
+        [() => SensitiveString, 0],
+        [() => PlaceType, 0],
+        [() => SensitiveString, 0],
+        [
+            0,
+            {
+                [_hH]: _xagpb,
+            },
+        ],
+        [() => Address, 0],
+        [() => SensitiveBoolean, 0],
+        [() => PostalCodeDetailsList, 0],
+        [() => Position, 0],
+        [() => BoundingBox, 0],
+        [() => CategoryList, 0],
+        [() => FoodTypeList, 0],
+        [() => BusinessChainList, 0],
+        [() => Contacts, 0],
+        [() => OpeningHoursList, 0],
+        [() => AccessPointList, 0],
+        [() => AccessRestrictionList, 0],
+        [() => TimeZone, 0],
+        [() => CountryCode3, 0],
+        [() => PhonemeDetails, 0],
+        [() => RelatedPlace, 0],
+        [() => RelatedPlaceList, 0],
+    ],
+];
+var Highlight = [3, n0, _Hi, 0, [_SI, _EI, _V], [1, 1, [() => SensitiveString, 0]]];
+var InternalServerException = [
+    -3,
+    n0,
+    _ISE,
+    {
+        [_e]: _s,
+        [_hE]: 500,
+    },
+    [_M],
+    [
+        [
+            0,
+            {
+                [_jN]: _m,
+            },
+        ],
+    ],
+];
+schema.TypeRegistry.for(n0).registerError(InternalServerException, InternalServerException$1);
+var Intersection = [
+    3,
+    n0,
+    _I,
+    0,
+    [_PI, _T, _A, _P, _Di, _RD, _MV, _APc],
+    [
+        [() => SensitiveString, 0],
+        [() => SensitiveString, 0],
+        [() => Address, 0],
+        [() => Position, 0],
+        [() => DistanceMeters, 0],
+        [() => DistanceMeters, 0],
+        [() => BoundingBox, 0],
+        [() => AccessPointList, 0],
+    ],
+];
+var MatchScoreDetails = [3, n0, _MSD, 0, [_O, _Com], [1, () => ComponentMatchScores]];
+var OpeningHours = [
+    3,
+    n0,
+    _OH,
+    0,
+    [_Dis, _ON, _Com, _C],
+    [
+        [() => OpeningHoursDisplayList, 0],
+        [() => SensitiveBoolean, 0],
+        [() => OpeningHoursComponentsList, 0],
+        [() => CategoryList, 0],
+    ],
+];
+var OpeningHoursComponents = [
+    3,
+    n0,
+    _OHC,
+    0,
+    [_OT, _OD, _Rec],
+    [
+        [() => SensitiveString, 0],
+        [() => SensitiveString, 0],
+        [() => SensitiveString, 0],
+    ],
+];
+var ParsedQueryComponent = [
+    3,
+    n0,
+    _PQC,
+    0,
+    [_SI, _EI, _V, _QCu],
+    [1, 1, [() => SensitiveString, 0], [() => SensitiveString, 0]],
+];
+var ParsedQuerySecondaryAddressComponent = [
+    3,
+    n0,
+    _PQSAC,
+    0,
+    [_SI, _EI, _V, _Nu, _De],
+    [1, 1, [() => SensitiveString, 0], [() => SensitiveString, 0], [() => SensitiveString, 0]],
+];
+var PhonemeDetails = [
+    3,
+    n0,
+    _PD,
+    0,
+    [_T, _A],
+    [
+        [() => PhonemeTranscriptionList, 0],
+        [() => AddressComponentPhonemes, 0],
+    ],
+];
+var PhonemeTranscription = [
+    3,
+    n0,
+    _PTh,
+    0,
+    [_V, _La, _Pre],
+    [[() => SensitiveString, 0], 0, [() => SensitiveBoolean, 0]],
+];
+var PostalCodeDetails = [
+    3,
+    n0,
+    _PCD,
+    0,
+    [_PC, _PA, _PCT, _UZ, _UZP],
+    [
+        [() => SensitiveString, 0],
+        [() => PostalAuthority, 0],
+        [() => PostalCodeType, 0],
+        [() => UspsZip, 0],
+        [() => UspsZipPlus4, 0],
+    ],
+];
+var QueryRefinement = [
+    3,
+    n0,
+    _QR,
+    0,
+    [_RT, _OTr, _SI, _EI],
+    [[() => SensitiveString, 0], [() => SensitiveString, 0], 1, 1],
+];
+var Region = [
+    3,
+    n0,
+    _Re,
+    0,
+    [_Code_, _N],
+    [
+        [() => SensitiveString, 0],
+        [() => SensitiveString, 0],
+    ],
+];
+var RegionHighlights = [
+    3,
+    n0,
+    _RH,
+    0,
+    [_Code_, _N],
+    [
+        [() => HighlightList, 0],
+        [() => HighlightList, 0],
+    ],
+];
+var RelatedPlace = [
+    3,
+    n0,
+    _RP,
+    0,
+    [_PI, _PT, _T, _A, _P, _APc],
+    [
+        [() => SensitiveString, 0],
+        [() => PlaceType, 0],
+        [() => SensitiveString, 0],
+        [() => Address, 0],
+        [() => Position, 0],
+        [() => AccessPointList, 0],
+    ],
+];
+var ReverseGeocodeFilter = [3, n0, _RGF, 0, [_IPT], [64 | 0]];
+var ReverseGeocodeRequest = [
+    3,
+    n0,
+    _RGR,
+    0,
+    [_QP, _QRu, _MR, _F, _AFd, _La, _PV, _IU, _K],
+    [
+        [() => Position, 0],
+        [() => DistanceMeters, 0],
+        1,
+        () => ReverseGeocodeFilter,
+        64 | 0,
+        0,
+        [() => CountryCode, 0],
+        0,
+        [
+            () => ApiKey,
+            {
+                [_hQ]: _k,
+            },
+        ],
+    ],
+];
+var ReverseGeocodeResponse = [
+    3,
+    n0,
+    _RGRe,
+    0,
+    [_PB, _RI],
+    [
+        [
+            0,
+            {
+                [_hH]: _xagpb,
+            },
+        ],
+        [() => ReverseGeocodeResultItemList, 0],
+    ],
+];
+var ReverseGeocodeResultItem = [
+    3,
+    n0,
+    _RGRI,
+    0,
+    [_PI, _PT, _T, _A, _ANC, _PCD, _P, _Di, _MV, _C, _FTo, _APc, _TZ, _PV, _In],
+    [
+        [() => SensitiveString, 0],
+        [() => PlaceType, 0],
+        [() => SensitiveString, 0],
+        [() => Address, 0],
+        [() => SensitiveBoolean, 0],
+        [() => PostalCodeDetailsList, 0],
+        [() => Position, 0],
+        [() => DistanceMeters, 0],
+        [() => BoundingBox, 0],
+        [() => CategoryList, 0],
+        [() => FoodTypeList, 0],
+        [() => AccessPointList, 0],
+        [() => TimeZone, 0],
+        [() => CountryCode3, 0],
+        [() => IntersectionList, 0],
+    ],
+];
+var SearchNearbyFilter = [
+    3,
+    n0,
+    _SNF,
+    0,
+    [_BB, _IC, _ICn, _EC, _IBC, _EBC, _IFT, _EFT],
+    [
+        [() => BoundingBox, 0],
+        [() => CountryCodeList, 0],
+        [() => FilterCategoryList, 0],
+        [() => FilterCategoryList, 0],
+        [() => FilterBusinessChainList, 0],
+        [() => FilterBusinessChainList, 0],
+        [() => FilterFoodTypeList, 0],
+        [() => FilterFoodTypeList, 0],
+    ],
+];
+var SearchNearbyRequest = [
+    3,
+    n0,
+    _SNR,
+    0,
+    [_QP, _QRu, _MR, _F, _AFd, _La, _PV, _IU, _NT, _K],
+    [
+        [() => Position, 0],
+        [() => DistanceMeters, 0],
+        1,
+        [() => SearchNearbyFilter, 0],
+        64 | 0,
+        0,
+        [() => CountryCode, 0],
+        0,
+        0,
+        [
+            () => ApiKey,
+            {
+                [_hQ]: _k,
+            },
+        ],
+    ],
+];
+var SearchNearbyResponse = [
+    3,
+    n0,
+    _SNRe,
+    0,
+    [_PB, _RI, _NT],
+    [
+        [
+            0,
+            {
+                [_hH]: _xagpb,
+            },
+        ],
+        [() => SearchNearbyResultItemList, 0],
+        0,
+    ],
+];
+var SearchNearbyResultItem = [
+    3,
+    n0,
+    _SNRI,
+    0,
+    [_PI, _PT, _T, _A, _ANC, _P, _Di, _MV, _C, _FTo, _BCu, _Con, _OH, _APc, _ARc, _TZ, _PV, _Pho],
+    [
+        [() => SensitiveString, 0],
+        [() => PlaceType, 0],
+        [() => SensitiveString, 0],
+        [() => Address, 0],
+        [() => SensitiveBoolean, 0],
+        [() => Position, 0],
+        [() => DistanceMeters, 0],
+        [() => BoundingBox, 0],
+        [() => CategoryList, 0],
+        [() => FoodTypeList, 0],
+        [() => BusinessChainList, 0],
+        [() => Contacts, 0],
+        [() => OpeningHoursList, 0],
+        [() => AccessPointList, 0],
+        [() => AccessRestrictionList, 0],
+        [() => TimeZone, 0],
+        [() => CountryCode3, 0],
+        [() => PhonemeDetails, 0],
+    ],
+];
+var SearchTextFilter = [
+    3,
+    n0,
+    _STF,
+    0,
+    [_BB, _Ci, _IC],
+    [
+        [() => BoundingBox, 0],
+        [() => FilterCircle, 0],
+        [() => CountryCodeList, 0],
+    ],
+];
+var SearchTextRequest = [
+    3,
+    n0,
+    _STR,
+    0,
+    [_QT, _QI, _MR, _BP, _F, _AFd, _La, _PV, _IU, _NT, _K],
+    [
+        [() => SensitiveString, 0],
+        [() => SensitiveString, 0],
+        1,
+        [() => Position, 0],
+        [() => SearchTextFilter, 0],
+        64 | 0,
+        0,
+        [() => CountryCode, 0],
+        0,
+        0,
+        [
+            () => ApiKey,
+            {
+                [_hQ]: _k,
+            },
+        ],
+    ],
+];
+var SearchTextResponse = [
+    3,
+    n0,
+    _STRe,
+    0,
+    [_PB, _RI, _NT],
+    [
+        [
+            0,
+            {
+                [_hH]: _xagpb,
+            },
+        ],
+        [() => SearchTextResultItemList, 0],
+        0,
+    ],
+];
+var SearchTextResultItem = [
+    3,
+    n0,
+    _STRI,
+    0,
+    [_PI, _PT, _T, _A, _ANC, _P, _Di, _MV, _C, _FTo, _BCu, _Con, _OH, _APc, _ARc, _TZ, _PV, _Pho],
+    [
+        [() => SensitiveString, 0],
+        [() => PlaceType, 0],
+        [() => SensitiveString, 0],
+        [() => Address, 0],
+        [() => SensitiveBoolean, 0],
+        [() => Position, 0],
+        [() => DistanceMeters, 0],
+        [() => BoundingBox, 0],
+        [() => CategoryList, 0],
+        [() => FoodTypeList, 0],
+        [() => BusinessChainList, 0],
+        [() => Contacts, 0],
+        [() => OpeningHoursList, 0],
+        [() => AccessPointList, 0],
+        [() => AccessRestrictionList, 0],
+        [() => TimeZone, 0],
+        [() => CountryCode3, 0],
+        [() => PhonemeDetails, 0],
+    ],
+];
+var SecondaryAddressComponent = [3, n0, _SACe, 0, [_Nu], [[() => SensitiveString, 0]]];
+var SecondaryAddressComponentMatchScore = [3, n0, _SACMS, 0, [_Nu], [1]];
+var StreetComponents = [
+    3,
+    n0,
+    _SC,
+    0,
+    [_BN, _Ty, _TP, _TS, _Pref, _Su, _Dir, _La],
+    [
+        [() => SensitiveString, 0],
+        [() => SensitiveString, 0],
+        0,
+        0,
+        [() => SensitiveString, 0],
+        [() => SensitiveString, 0],
+        [() => SensitiveString, 0],
+        0,
+    ],
+];
+var SubRegion = [
+    3,
+    n0,
+    _SR,
+    0,
+    [_Code_, _N],
+    [
+        [() => SensitiveString, 0],
+        [() => SensitiveString, 0],
+    ],
+];
+var SubRegionHighlights = [
+    3,
+    n0,
+    _SRH,
+    0,
+    [_Code_, _N],
+    [
+        [() => HighlightList, 0],
+        [() => HighlightList, 0],
+    ],
+];
+var SuggestAddressHighlights = [3, n0, _SAH, 0, [_L], [[() => HighlightList, 0]]];
+var SuggestFilter = [
+    3,
+    n0,
+    _SF,
+    0,
+    [_BB, _Ci, _IC],
+    [
+        [() => BoundingBox, 0],
+        [() => FilterCircle, 0],
+        [() => CountryCodeList, 0],
+    ],
+];
+var SuggestHighlights = [
+    3,
+    n0,
+    _SH,
+    0,
+    [_T, _A],
+    [
+        [() => HighlightList, 0],
+        [() => SuggestAddressHighlights, 0],
+    ],
+];
+var SuggestPlaceResult = [
+    3,
+    n0,
+    _SPR,
+    0,
+    [_PI, _PT, _A, _P, _Di, _MV, _C, _FTo, _BCu, _APc, _ARc, _TZ, _PV, _Pho],
+    [
+        [() => SensitiveString, 0],
+        [() => PlaceType, 0],
+        [() => Address, 0],
+        [() => Position, 0],
+        [() => DistanceMeters, 0],
+        [() => BoundingBox, 0],
+        [() => CategoryList, 0],
+        [() => FoodTypeList, 0],
+        [() => BusinessChainList, 0],
+        [() => AccessPointList, 0],
+        [() => AccessRestrictionList, 0],
+        [() => TimeZone, 0],
+        [() => CountryCode3, 0],
+        [() => PhonemeDetails, 0],
+    ],
+];
+var SuggestQueryResult = [3, n0, _SQR, 0, [_QI, _QTu], [[() => SensitiveString, 0], 0]];
+var SuggestRequest = [
+    3,
+    n0,
+    _SRu,
+    0,
+    [_QT, _MR, _MQR, _BP, _F, _AFd, _La, _PV, _IU, _K],
+    [
+        [() => SensitiveString, 0],
+        1,
+        1,
+        [() => Position, 0],
+        [() => SuggestFilter, 0],
+        64 | 0,
+        0,
+        [() => CountryCode, 0],
+        0,
+        [
+            () => ApiKey,
+            {
+                [_hQ]: _k,
+            },
+        ],
+    ],
+];
+var SuggestResponse = [
+    3,
+    n0,
+    _SRug,
+    0,
+    [_PB, _RI, _QRue],
+    [
+        [
+            0,
+            {
+                [_hH]: _xagpb,
+            },
+        ],
+        [() => SuggestResultItemList, 0],
+        [() => QueryRefinementList, 0],
+    ],
+];
+var SuggestResultItem = [
+    3,
+    n0,
+    _SRI,
+    0,
+    [_T, _SRIT, _Pl, _Q, _H],
+    [
+        [() => SensitiveString, 0],
+        0,
+        [() => SuggestPlaceResult, 0],
+        [() => SuggestQueryResult, 0],
+        [() => SuggestHighlights, 0],
+    ],
+];
+var ThrottlingException = [
+    -3,
+    n0,
+    _TE,
+    {
+        [_e]: _c,
+        [_hE]: 429,
+    },
+    [_M],
+    [
+        [
+            0,
+            {
+                [_jN]: _m,
+            },
+        ],
+    ],
+];
+schema.TypeRegistry.for(n0).registerError(ThrottlingException, ThrottlingException$1);
+var TimeZone = [
+    3,
+    n0,
+    _TZ,
+    0,
+    [_N, _Of, _OS],
+    [
+        [() => SensitiveString, 0],
+        [() => SensitiveString, 0],
+        [() => DurationSeconds, 0],
+    ],
+];
+var UspsZip = [3, n0, _UZ, 0, [_ZCC], [[() => ZipClassificationCode, 0]]];
+var UspsZipPlus4 = [3, n0, _UZP, 0, [_RTC], [[() => RecordTypeCode, 0]]];
+var ValidationException = [
+    -3,
+    n0,
+    _VE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M, _Rea, _FL],
+    [
+        [
+            0,
+            {
+                [_jN]: _m,
+            },
+        ],
+        [
+            0,
+            {
+                [_jN]: _r,
+            },
+        ],
+        [
+            () => ValidationExceptionFieldList,
+            {
+                [_jN]: _fL,
+            },
+        ],
+    ],
+];
+schema.TypeRegistry.for(n0).registerError(ValidationException, ValidationException$1);
+var ValidationExceptionField = [
+    3,
+    n0,
+    _VEF,
+    0,
+    [_N, _M],
+    [
+        [
+            0,
+            {
+                [_jN]: _n,
+            },
+        ],
+        [
+            0,
+            {
+                [_jN]: _m,
+            },
+        ],
+    ],
+];
+var GeoPlacesServiceException = [-3, _sm, "GeoPlacesServiceException", 0, [], []];
+schema.TypeRegistry.for(_sm).registerError(GeoPlacesServiceException, GeoPlacesServiceException$1);
+var AccessPointList = [1, n0, _APL, 0, [() => AccessPoint, 0]];
+var AccessRestrictionList = [1, n0, _ARL, 0, [() => AccessRestriction, 0]];
+var AutocompleteResultItemList = [1, n0, _ARIL, 0, [() => AutocompleteResultItem, 0]];
+var BoundingBox = [1, n0, _BB, 8, 1];
+var BusinessChainList = [1, n0, _BCL, 0, [() => BusinessChain, 0]];
+var CategoryList = [1, n0, _CL, 0, [() => Category, 0]];
+var ContactDetailsList = [1, n0, _CDL, 0, [() => ContactDetails, 0]];
+var CountryCodeList = [1, n0, _CCL, 0, [() => CountryCode, 0]];
+var FilterBusinessChainList = [1, n0, _FBCL, 0, [() => SensitiveString, 0]];
+var FilterCategoryList = [1, n0, _FCL, 0, [() => SensitiveString, 0]];
+var FilterFoodTypeList = [1, n0, _FFTL, 0, [() => SensitiveString, 0]];
+var FoodTypeList = [1, n0, _FTL, 0, [() => FoodType, 0]];
+var GeocodeFilterPlaceTypeList = [1, n0, _GFPTL, 0, [() => GeocodeFilterPlaceType, 0]];
+var GeocodeResultItemList = [1, n0, _GRIL, 0, [() => GeocodeResultItem, 0]];
+var HighlightList = [1, n0, _HL, 0, [() => Highlight, 0]];
+var IntersectionHighlightsList = [1, n0, _IHL, 0, [() => HighlightList, 0]];
+var IntersectionList = [1, n0, _IL, 0, [() => Intersection, 0]];
+var OpeningHoursComponentsList = [1, n0, _OHCL, 0, [() => OpeningHoursComponents, 0]];
+var OpeningHoursDisplayList = [1, n0, _OHDL, 0, [() => OpeningHoursDisplay, 0]];
+var OpeningHoursList = [1, n0, _OHL, 0, [() => OpeningHours, 0]];
+var ParsedQueryComponentList = [1, n0, _PQCL, 0, [() => ParsedQueryComponent, 0]];
+var ParsedQuerySecondaryAddressComponentList = [
+    1,
+    n0,
+    _PQSACL,
+    0,
+    [() => ParsedQuerySecondaryAddressComponent, 0],
+];
+var PhonemeTranscriptionList = [1, n0, _PTL, 0, [() => PhonemeTranscription, 0]];
+var Position = [1, n0, _P, 8, 1];
+var PostalCodeDetailsList = [1, n0, _PCDL, 0, [() => PostalCodeDetails, 0]];
+var QueryRefinementList = [1, n0, _QRL, 0, [() => QueryRefinement, 0]];
+var RelatedPlaceList = [1, n0, _RPL, 0, [() => RelatedPlace, 0]];
+var ReverseGeocodeResultItemList = [1, n0, _RGRIL, 0, [() => ReverseGeocodeResultItem, 0]];
+var SearchNearbyResultItemList = [1, n0, _SNRIL, 0, [() => SearchNearbyResultItem, 0]];
+var SearchTextResultItemList = [1, n0, _STRIL, 0, [() => SearchTextResultItem, 0]];
+var SecondaryAddressComponentList = [1, n0, _SACL, 0, [() => SecondaryAddressComponent, 0]];
+var SecondaryAddressComponentMatchScoreList = [
+    1,
+    n0,
+    _SACMSL,
+    0,
+    () => SecondaryAddressComponentMatchScore,
+];
+var StreetComponentsList = [1, n0, _SCL, 0, [() => StreetComponents, 0]];
+var SuggestResultItemList = [1, n0, _SRIL, 0, [() => SuggestResultItem, 0]];
+var ValidationExceptionFieldList = [1, n0, _VEFL, 0, [() => ValidationExceptionField, 0]];
+var Autocomplete = [
+    9,
+    n0,
+    _Au,
+    {
+        [_h]: ["POST", "/autocomplete", 200],
+    },
+    () => AutocompleteRequest,
+    () => AutocompleteResponse,
+];
+var Geocode = [
+    9,
+    n0,
+    _G,
+    {
+        [_h]: ["POST", "/geocode", 200],
+    },
+    () => GeocodeRequest,
+    () => GeocodeResponse,
+];
+var GetPlace = [
+    9,
+    n0,
+    _GP,
+    {
+        [_h]: ["GET", "/place/{PlaceId}", 200],
+    },
+    () => GetPlaceRequest,
+    () => GetPlaceResponse,
+];
+var ReverseGeocode = [
+    9,
+    n0,
+    _RG,
+    {
+        [_h]: ["POST", "/reverse-geocode", 200],
+    },
+    () => ReverseGeocodeRequest,
+    () => ReverseGeocodeResponse,
+];
+var SearchNearby = [
+    9,
+    n0,
+    _SN,
+    {
+        [_h]: ["POST", "/search-nearby", 200],
+    },
+    () => SearchNearbyRequest,
+    () => SearchNearbyResponse,
+];
+var SearchText = [
+    9,
+    n0,
+    _ST,
+    {
+        [_h]: ["POST", "/search-text", 200],
+    },
+    () => SearchTextRequest,
+    () => SearchTextResponse,
+];
+var Suggest = [
+    9,
+    n0,
+    _Sug,
+    {
+        [_h]: ["POST", "/suggest", 200],
+    },
+    () => SuggestRequest,
+    () => SuggestResponse,
+];
 
 class AutocompleteCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("PlacesService", "Autocomplete", {})
     .n("GeoPlacesClient", "AutocompleteCommand")
-    .f(AutocompleteRequestFilterSensitiveLog, AutocompleteResponseFilterSensitiveLog)
-    .ser(se_AutocompleteCommand)
-    .de(de_AutocompleteCommand)
+    .sc(Autocomplete)
     .build() {
 }
 
@@ -1639,16 +1836,11 @@ class GeocodeCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("PlacesService", "Geocode", {})
     .n("GeoPlacesClient", "GeocodeCommand")
-    .f(GeocodeRequestFilterSensitiveLog, GeocodeResponseFilterSensitiveLog)
-    .ser(se_GeocodeCommand)
-    .de(de_GeocodeCommand)
+    .sc(Geocode)
     .build() {
 }
 
@@ -1656,16 +1848,11 @@ class GetPlaceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("PlacesService", "GetPlace", {})
     .n("GeoPlacesClient", "GetPlaceCommand")
-    .f(GetPlaceRequestFilterSensitiveLog, GetPlaceResponseFilterSensitiveLog)
-    .ser(se_GetPlaceCommand)
-    .de(de_GetPlaceCommand)
+    .sc(GetPlace)
     .build() {
 }
 
@@ -1673,16 +1860,11 @@ class ReverseGeocodeCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("PlacesService", "ReverseGeocode", {})
     .n("GeoPlacesClient", "ReverseGeocodeCommand")
-    .f(ReverseGeocodeRequestFilterSensitiveLog, ReverseGeocodeResponseFilterSensitiveLog)
-    .ser(se_ReverseGeocodeCommand)
-    .de(de_ReverseGeocodeCommand)
+    .sc(ReverseGeocode)
     .build() {
 }
 
@@ -1690,16 +1872,11 @@ class SearchNearbyCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("PlacesService", "SearchNearby", {})
     .n("GeoPlacesClient", "SearchNearbyCommand")
-    .f(SearchNearbyRequestFilterSensitiveLog, SearchNearbyResponseFilterSensitiveLog)
-    .ser(se_SearchNearbyCommand)
-    .de(de_SearchNearbyCommand)
+    .sc(SearchNearby)
     .build() {
 }
 
@@ -1707,16 +1884,11 @@ class SearchTextCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("PlacesService", "SearchText", {})
     .n("GeoPlacesClient", "SearchTextCommand")
-    .f(SearchTextRequestFilterSensitiveLog, SearchTextResponseFilterSensitiveLog)
-    .ser(se_SearchTextCommand)
-    .de(de_SearchTextCommand)
+    .sc(SearchText)
     .build() {
 }
 
@@ -1724,16 +1896,11 @@ class SuggestCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("PlacesService", "Suggest", {})
     .n("GeoPlacesClient", "SuggestCommand")
-    .f(SuggestRequestFilterSensitiveLog, SuggestResponseFilterSensitiveLog)
-    .ser(se_SuggestCommand)
-    .de(de_SuggestCommand)
+    .sc(Suggest)
     .build() {
 }
 
@@ -1758,110 +1925,44 @@ Object.defineProperty(exports, "__Client", {
     enumerable: true,
     get: function () { return smithyClient.Client; }
 });
-exports.AccessDeniedException = AccessDeniedException;
-exports.AccessPointFilterSensitiveLog = AccessPointFilterSensitiveLog;
-exports.AccessRestrictionFilterSensitiveLog = AccessRestrictionFilterSensitiveLog;
-exports.AddressComponentPhonemesFilterSensitiveLog = AddressComponentPhonemesFilterSensitiveLog;
-exports.AddressFilterSensitiveLog = AddressFilterSensitiveLog;
+exports.AccessDeniedException = AccessDeniedException$1;
 exports.AutocompleteAdditionalFeature = AutocompleteAdditionalFeature;
-exports.AutocompleteAddressHighlightsFilterSensitiveLog = AutocompleteAddressHighlightsFilterSensitiveLog;
 exports.AutocompleteCommand = AutocompleteCommand;
-exports.AutocompleteFilterFilterSensitiveLog = AutocompleteFilterFilterSensitiveLog;
 exports.AutocompleteFilterPlaceType = AutocompleteFilterPlaceType;
-exports.AutocompleteHighlightsFilterSensitiveLog = AutocompleteHighlightsFilterSensitiveLog;
 exports.AutocompleteIntendedUse = AutocompleteIntendedUse;
-exports.AutocompleteRequestFilterSensitiveLog = AutocompleteRequestFilterSensitiveLog;
-exports.AutocompleteResponseFilterSensitiveLog = AutocompleteResponseFilterSensitiveLog;
-exports.AutocompleteResultItemFilterSensitiveLog = AutocompleteResultItemFilterSensitiveLog;
-exports.BusinessChainFilterSensitiveLog = BusinessChainFilterSensitiveLog;
-exports.CategoryFilterSensitiveLog = CategoryFilterSensitiveLog;
-exports.ContactDetailsFilterSensitiveLog = ContactDetailsFilterSensitiveLog;
-exports.ContactsFilterSensitiveLog = ContactsFilterSensitiveLog;
-exports.CountryFilterSensitiveLog = CountryFilterSensitiveLog;
-exports.CountryHighlightsFilterSensitiveLog = CountryHighlightsFilterSensitiveLog;
-exports.FilterCircleFilterSensitiveLog = FilterCircleFilterSensitiveLog;
-exports.FoodTypeFilterSensitiveLog = FoodTypeFilterSensitiveLog;
 exports.GeoPlaces = GeoPlaces;
 exports.GeoPlacesClient = GeoPlacesClient;
-exports.GeoPlacesServiceException = GeoPlacesServiceException;
+exports.GeoPlacesServiceException = GeoPlacesServiceException$1;
 exports.GeocodeAdditionalFeature = GeocodeAdditionalFeature;
 exports.GeocodeCommand = GeocodeCommand;
-exports.GeocodeFilterFilterSensitiveLog = GeocodeFilterFilterSensitiveLog;
-exports.GeocodeFilterPlaceType = GeocodeFilterPlaceType;
+exports.GeocodeFilterPlaceType = GeocodeFilterPlaceType$1;
 exports.GeocodeIntendedUse = GeocodeIntendedUse;
-exports.GeocodeParsedQueryAddressComponentsFilterSensitiveLog = GeocodeParsedQueryAddressComponentsFilterSensitiveLog;
-exports.GeocodeParsedQueryFilterSensitiveLog = GeocodeParsedQueryFilterSensitiveLog;
-exports.GeocodeQueryComponentsFilterSensitiveLog = GeocodeQueryComponentsFilterSensitiveLog;
-exports.GeocodeRequestFilterSensitiveLog = GeocodeRequestFilterSensitiveLog;
-exports.GeocodeResponseFilterSensitiveLog = GeocodeResponseFilterSensitiveLog;
-exports.GeocodeResultItemFilterSensitiveLog = GeocodeResultItemFilterSensitiveLog;
 exports.GetPlaceAdditionalFeature = GetPlaceAdditionalFeature;
 exports.GetPlaceCommand = GetPlaceCommand;
 exports.GetPlaceIntendedUse = GetPlaceIntendedUse;
-exports.GetPlaceRequestFilterSensitiveLog = GetPlaceRequestFilterSensitiveLog;
-exports.GetPlaceResponseFilterSensitiveLog = GetPlaceResponseFilterSensitiveLog;
-exports.HighlightFilterSensitiveLog = HighlightFilterSensitiveLog;
-exports.InternalServerException = InternalServerException;
-exports.IntersectionFilterSensitiveLog = IntersectionFilterSensitiveLog;
-exports.OpeningHoursComponentsFilterSensitiveLog = OpeningHoursComponentsFilterSensitiveLog;
-exports.OpeningHoursFilterSensitiveLog = OpeningHoursFilterSensitiveLog;
-exports.ParsedQueryComponentFilterSensitiveLog = ParsedQueryComponentFilterSensitiveLog;
-exports.ParsedQuerySecondaryAddressComponentFilterSensitiveLog = ParsedQuerySecondaryAddressComponentFilterSensitiveLog;
-exports.PhonemeDetailsFilterSensitiveLog = PhonemeDetailsFilterSensitiveLog;
-exports.PhonemeTranscriptionFilterSensitiveLog = PhonemeTranscriptionFilterSensitiveLog;
-exports.PlaceType = PlaceType;
-exports.PostalAuthority = PostalAuthority;
-exports.PostalCodeDetailsFilterSensitiveLog = PostalCodeDetailsFilterSensitiveLog;
+exports.InternalServerException = InternalServerException$1;
+exports.PlaceType = PlaceType$1;
+exports.PostalAuthority = PostalAuthority$1;
 exports.PostalCodeMode = PostalCodeMode;
-exports.PostalCodeType = PostalCodeType;
-exports.QueryRefinementFilterSensitiveLog = QueryRefinementFilterSensitiveLog;
+exports.PostalCodeType = PostalCodeType$1;
 exports.QueryType = QueryType;
-exports.RecordTypeCode = RecordTypeCode;
-exports.RegionFilterSensitiveLog = RegionFilterSensitiveLog;
-exports.RegionHighlightsFilterSensitiveLog = RegionHighlightsFilterSensitiveLog;
-exports.RelatedPlaceFilterSensitiveLog = RelatedPlaceFilterSensitiveLog;
+exports.RecordTypeCode = RecordTypeCode$1;
 exports.ReverseGeocodeAdditionalFeature = ReverseGeocodeAdditionalFeature;
 exports.ReverseGeocodeCommand = ReverseGeocodeCommand;
 exports.ReverseGeocodeFilterPlaceType = ReverseGeocodeFilterPlaceType;
 exports.ReverseGeocodeIntendedUse = ReverseGeocodeIntendedUse;
-exports.ReverseGeocodeRequestFilterSensitiveLog = ReverseGeocodeRequestFilterSensitiveLog;
-exports.ReverseGeocodeResponseFilterSensitiveLog = ReverseGeocodeResponseFilterSensitiveLog;
-exports.ReverseGeocodeResultItemFilterSensitiveLog = ReverseGeocodeResultItemFilterSensitiveLog;
 exports.SearchNearbyAdditionalFeature = SearchNearbyAdditionalFeature;
 exports.SearchNearbyCommand = SearchNearbyCommand;
-exports.SearchNearbyFilterFilterSensitiveLog = SearchNearbyFilterFilterSensitiveLog;
 exports.SearchNearbyIntendedUse = SearchNearbyIntendedUse;
-exports.SearchNearbyRequestFilterSensitiveLog = SearchNearbyRequestFilterSensitiveLog;
-exports.SearchNearbyResponseFilterSensitiveLog = SearchNearbyResponseFilterSensitiveLog;
-exports.SearchNearbyResultItemFilterSensitiveLog = SearchNearbyResultItemFilterSensitiveLog;
 exports.SearchTextAdditionalFeature = SearchTextAdditionalFeature;
 exports.SearchTextCommand = SearchTextCommand;
-exports.SearchTextFilterFilterSensitiveLog = SearchTextFilterFilterSensitiveLog;
 exports.SearchTextIntendedUse = SearchTextIntendedUse;
-exports.SearchTextRequestFilterSensitiveLog = SearchTextRequestFilterSensitiveLog;
-exports.SearchTextResponseFilterSensitiveLog = SearchTextResponseFilterSensitiveLog;
-exports.SearchTextResultItemFilterSensitiveLog = SearchTextResultItemFilterSensitiveLog;
-exports.SecondaryAddressComponentFilterSensitiveLog = SecondaryAddressComponentFilterSensitiveLog;
-exports.StreetComponentsFilterSensitiveLog = StreetComponentsFilterSensitiveLog;
-exports.SubRegionFilterSensitiveLog = SubRegionFilterSensitiveLog;
-exports.SubRegionHighlightsFilterSensitiveLog = SubRegionHighlightsFilterSensitiveLog;
 exports.SuggestAdditionalFeature = SuggestAdditionalFeature;
-exports.SuggestAddressHighlightsFilterSensitiveLog = SuggestAddressHighlightsFilterSensitiveLog;
 exports.SuggestCommand = SuggestCommand;
-exports.SuggestFilterFilterSensitiveLog = SuggestFilterFilterSensitiveLog;
-exports.SuggestHighlightsFilterSensitiveLog = SuggestHighlightsFilterSensitiveLog;
 exports.SuggestIntendedUse = SuggestIntendedUse;
-exports.SuggestPlaceResultFilterSensitiveLog = SuggestPlaceResultFilterSensitiveLog;
-exports.SuggestQueryResultFilterSensitiveLog = SuggestQueryResultFilterSensitiveLog;
-exports.SuggestRequestFilterSensitiveLog = SuggestRequestFilterSensitiveLog;
-exports.SuggestResponseFilterSensitiveLog = SuggestResponseFilterSensitiveLog;
-exports.SuggestResultItemFilterSensitiveLog = SuggestResultItemFilterSensitiveLog;
 exports.SuggestResultItemType = SuggestResultItemType;
-exports.ThrottlingException = ThrottlingException;
-exports.TimeZoneFilterSensitiveLog = TimeZoneFilterSensitiveLog;
+exports.ThrottlingException = ThrottlingException$1;
 exports.TypePlacement = TypePlacement;
-exports.UspsZipFilterSensitiveLog = UspsZipFilterSensitiveLog;
-exports.UspsZipPlus4FilterSensitiveLog = UspsZipPlus4FilterSensitiveLog;
-exports.ValidationException = ValidationException;
+exports.ValidationException = ValidationException$1;
 exports.ValidationExceptionReason = ValidationExceptionReason;
-exports.ZipClassificationCode = ZipClassificationCode;
+exports.ZipClassificationCode = ZipClassificationCode$1;