@aws-sdk/client-location 3.276.0 → 3.278.0

package/dist-es/Location.js

@@ -8,16 +8,19 @@ import { BatchUpdateDevicePositionCommand, } from "./commands/BatchUpdateDeviceP
 import { CalculateRouteCommand, } from "./commands/CalculateRouteCommand";
 import { CalculateRouteMatrixCommand, } from "./commands/CalculateRouteMatrixCommand";
 import { CreateGeofenceCollectionCommand, } from "./commands/CreateGeofenceCollectionCommand";
+import { CreateKeyCommand } from "./commands/CreateKeyCommand";
 import { CreateMapCommand } from "./commands/CreateMapCommand";
 import { CreatePlaceIndexCommand, } from "./commands/CreatePlaceIndexCommand";
 import { CreateRouteCalculatorCommand, } from "./commands/CreateRouteCalculatorCommand";
 import { CreateTrackerCommand, } from "./commands/CreateTrackerCommand";
 import { DeleteGeofenceCollectionCommand, } from "./commands/DeleteGeofenceCollectionCommand";
+import { DeleteKeyCommand } from "./commands/DeleteKeyCommand";
 import { DeleteMapCommand } from "./commands/DeleteMapCommand";
 import { DeletePlaceIndexCommand, } from "./commands/DeletePlaceIndexCommand";
 import { DeleteRouteCalculatorCommand, } from "./commands/DeleteRouteCalculatorCommand";
 import { DeleteTrackerCommand, } from "./commands/DeleteTrackerCommand";
 import { DescribeGeofenceCollectionCommand, } from "./commands/DescribeGeofenceCollectionCommand";
+import { DescribeKeyCommand } from "./commands/DescribeKeyCommand";
 import { DescribeMapCommand } from "./commands/DescribeMapCommand";
 import { DescribePlaceIndexCommand, } from "./commands/DescribePlaceIndexCommand";
 import { DescribeRouteCalculatorCommand, } from "./commands/DescribeRouteCalculatorCommand";
@@ -34,6 +37,7 @@ import { GetPlaceCommand } from "./commands/GetPlaceCommand";
 import { ListDevicePositionsCommand, } from "./commands/ListDevicePositionsCommand";
 import { ListGeofenceCollectionsCommand, } from "./commands/ListGeofenceCollectionsCommand";
 import { ListGeofencesCommand, } from "./commands/ListGeofencesCommand";
+import { ListKeysCommand } from "./commands/ListKeysCommand";
 import { ListMapsCommand } from "./commands/ListMapsCommand";
 import { ListPlaceIndexesCommand, } from "./commands/ListPlaceIndexesCommand";
 import { ListRouteCalculatorsCommand, } from "./commands/ListRouteCalculatorsCommand";
@@ -47,6 +51,7 @@ import { SearchPlaceIndexForTextCommand, } from "./commands/SearchPlaceIndexForT
 import { TagResourceCommand } from "./commands/TagResourceCommand";
 import { UntagResourceCommand, } from "./commands/UntagResourceCommand";
 import { UpdateGeofenceCollectionCommand, } from "./commands/UpdateGeofenceCollectionCommand";
+import { UpdateKeyCommand } from "./commands/UpdateKeyCommand";
 import { UpdateMapCommand } from "./commands/UpdateMapCommand";
 import { UpdatePlaceIndexCommand, } from "./commands/UpdatePlaceIndexCommand";
 import { UpdateRouteCalculatorCommand, } from "./commands/UpdateRouteCalculatorCommand";
@@ -193,6 +198,20 @@ export class Location extends LocationClient {
             return this.send(command, optionsOrCb);
         }
     }
+    createKey(args, optionsOrCb, cb) {
+        const command = new CreateKeyCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     createMap(args, optionsOrCb, cb) {
         const command = new CreateMapCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -263,6 +282,20 @@ export class Location extends LocationClient {
             return this.send(command, optionsOrCb);
         }
     }
+    deleteKey(args, optionsOrCb, cb) {
+        const command = new DeleteKeyCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     deleteMap(args, optionsOrCb, cb) {
         const command = new DeleteMapCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -333,6 +366,20 @@ export class Location extends LocationClient {
             return this.send(command, optionsOrCb);
         }
     }
+    describeKey(args, optionsOrCb, cb) {
+        const command = new DescribeKeyCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     describeMap(args, optionsOrCb, cb) {
         const command = new DescribeMapCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -557,6 +604,20 @@ export class Location extends LocationClient {
             return this.send(command, optionsOrCb);
         }
     }
+    listKeys(args, optionsOrCb, cb) {
+        const command = new ListKeysCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     listMaps(args, optionsOrCb, cb) {
         const command = new ListMapsCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -739,6 +800,20 @@ export class Location extends LocationClient {
             return this.send(command, optionsOrCb);
         }
     }
+    updateKey(args, optionsOrCb, cb) {
+        const command = new UpdateKeyCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     updateMap(args, optionsOrCb, cb) {
         const command = new UpdateMapCommand(args);
         if (typeof optionsOrCb === "function") {

package/dist-es/commands/CreateKeyCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateKeyRequestFilterSensitiveLog, CreateKeyResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1CreateKeyCommand, serializeAws_restJson1CreateKeyCommand, } from "../protocols/Aws_restJson1";
+export class CreateKeyCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateKeyCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LocationClient";
+        const commandName = "CreateKeyCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: CreateKeyRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: CreateKeyResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1CreateKeyCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1CreateKeyCommand(output, context);
+    }
+}

package/dist-es/commands/DeleteKeyCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteKeyRequestFilterSensitiveLog, DeleteKeyResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1DeleteKeyCommand, serializeAws_restJson1DeleteKeyCommand, } from "../protocols/Aws_restJson1";
+export class DeleteKeyCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteKeyCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LocationClient";
+        const commandName = "DeleteKeyCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: DeleteKeyRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: DeleteKeyResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1DeleteKeyCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1DeleteKeyCommand(output, context);
+    }
+}

package/dist-es/commands/DescribeKeyCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DescribeKeyRequestFilterSensitiveLog, DescribeKeyResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1DescribeKeyCommand, serializeAws_restJson1DescribeKeyCommand, } from "../protocols/Aws_restJson1";
+export class DescribeKeyCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DescribeKeyCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LocationClient";
+        const commandName = "DescribeKeyCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: DescribeKeyRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: DescribeKeyResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1DescribeKeyCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1DescribeKeyCommand(output, context);
+    }
+}

package/dist-es/commands/ListKeysCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListKeysRequestFilterSensitiveLog, ListKeysResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ListKeysCommand, serializeAws_restJson1ListKeysCommand, } from "../protocols/Aws_restJson1";
+export class ListKeysCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListKeysCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LocationClient";
+        const commandName = "ListKeysCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListKeysRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListKeysResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ListKeysCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ListKeysCommand(output, context);
+    }
+}

package/dist-es/commands/UpdateKeyCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { UpdateKeyRequestFilterSensitiveLog, UpdateKeyResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1UpdateKeyCommand, serializeAws_restJson1UpdateKeyCommand, } from "../protocols/Aws_restJson1";
+export class UpdateKeyCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, UpdateKeyCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LocationClient";
+        const commandName = "UpdateKeyCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: UpdateKeyRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: UpdateKeyResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1UpdateKeyCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1UpdateKeyCommand(output, context);
+    }
+}

package/dist-es/commands/index.js

@@ -8,16 +8,19 @@ export * from "./BatchUpdateDevicePositionCommand";
 export * from "./CalculateRouteCommand";
 export * from "./CalculateRouteMatrixCommand";
 export * from "./CreateGeofenceCollectionCommand";
+export * from "./CreateKeyCommand";
 export * from "./CreateMapCommand";
 export * from "./CreatePlaceIndexCommand";
 export * from "./CreateRouteCalculatorCommand";
 export * from "./CreateTrackerCommand";
 export * from "./DeleteGeofenceCollectionCommand";
+export * from "./DeleteKeyCommand";
 export * from "./DeleteMapCommand";
 export * from "./DeletePlaceIndexCommand";
 export * from "./DeleteRouteCalculatorCommand";
 export * from "./DeleteTrackerCommand";
 export * from "./DescribeGeofenceCollectionCommand";
+export * from "./DescribeKeyCommand";
 export * from "./DescribeMapCommand";
 export * from "./DescribePlaceIndexCommand";
 export * from "./DescribeRouteCalculatorCommand";
@@ -34,6 +37,7 @@ export * from "./GetPlaceCommand";
 export * from "./ListDevicePositionsCommand";
 export * from "./ListGeofenceCollectionsCommand";
 export * from "./ListGeofencesCommand";
+export * from "./ListKeysCommand";
 export * from "./ListMapsCommand";
 export * from "./ListPlaceIndexesCommand";
 export * from "./ListRouteCalculatorsCommand";
@@ -47,6 +51,7 @@ export * from "./SearchPlaceIndexForTextCommand";
 export * from "./TagResourceCommand";
 export * from "./UntagResourceCommand";
 export * from "./UpdateGeofenceCollectionCommand";
+export * from "./UpdateKeyCommand";
 export * from "./UpdateMapCommand";
 export * from "./UpdatePlaceIndexCommand";
 export * from "./UpdateRouteCalculatorCommand";

package/dist-es/endpoint/ruleset.js

@@ -1,4 +1,4 @@
-const q = "fn", r = "argv", s = "ref";
-const a = true, b = false, c = "String", d = "PartitionResult", e = "tree", f = "error", g = "endpoint", h = { "required": true, "default": false, "type": "Boolean" }, i = { [s]: "Endpoint" }, j = { [q]: "booleanEquals", [r]: [{ [s]: "UseFIPS" }, true] }, k = { [q]: "booleanEquals", [r]: [{ [s]: "UseDualStack" }, true] }, l = {}, m = { [q]: "booleanEquals", [r]: [true, { [q]: "getAttr", [r]: [{ [s]: d }, "supportsFIPS"] }] }, n = { [q]: "booleanEquals", [r]: [true, { [q]: "getAttr", [r]: [{ [s]: d }, "supportsDualStack"] }] }, o = [j], p = [k];
-const _data = { version: "1.0", parameters: { Region: { required: a, type: c }, UseDualStack: h, UseFIPS: h, Endpoint: { required: b, type: c } }, rules: [{ conditions: [{ [q]: "aws.partition", [r]: [{ [s]: "Region" }], assign: d }], type: e, rules: [{ conditions: [{ [q]: "isSet", [r]: [i] }], type: e, rules: [{ conditions: o, error: "Invalid Configuration: FIPS and custom endpoint are not supported", type: f }, { type: e, rules: [{ conditions: p, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", type: f }, { endpoint: { url: i, properties: l, headers: l }, type: g }] }] }, { conditions: [j, k], type: e, rules: [{ conditions: [m, n], type: e, rules: [{ type: e, rules: [{ endpoint: { url: "https://geo-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: l, headers: l }, type: g }] }] }, { error: "FIPS and DualStack are enabled, but this partition does not support one or both", type: f }] }, { conditions: o, type: e, rules: [{ conditions: [m], type: e, rules: [{ type: e, rules: [{ endpoint: { url: "https://geo-fips.{Region}.{PartitionResult#dnsSuffix}", properties: l, headers: l }, type: g }] }] }, { error: "FIPS is enabled but this partition does not support FIPS", type: f }] }, { conditions: p, type: e, rules: [{ conditions: [n], type: e, rules: [{ type: e, rules: [{ endpoint: { url: "https://geo.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: l, headers: l }, type: g }] }] }, { error: "DualStack is enabled but this partition does not support DualStack", type: f }] }, { type: e, rules: [{ endpoint: { url: "https://geo.{Region}.{PartitionResult#dnsSuffix}", properties: l, headers: l }, type: g }] }] }] };
+const q = "required", r = "fn", s = "argv", t = "ref";
+const a = "isSet", b = "tree", c = "error", d = "endpoint", e = "PartitionResult", f = { [q]: false, "type": "String" }, g = { [q]: true, "default": false, "type": "Boolean" }, h = { [t]: "Endpoint" }, i = { [r]: "booleanEquals", [s]: [{ [t]: "UseFIPS" }, true] }, j = { [r]: "booleanEquals", [s]: [{ [t]: "UseDualStack" }, true] }, k = {}, l = { [r]: "booleanEquals", [s]: [true, { [r]: "getAttr", [s]: [{ [t]: e }, "supportsFIPS"] }] }, m = { [r]: "booleanEquals", [s]: [true, { [r]: "getAttr", [s]: [{ [t]: e }, "supportsDualStack"] }] }, n = [i], o = [j], p = [{ [t]: "Region" }];
+const _data = { version: "1.0", parameters: { Region: f, UseDualStack: g, UseFIPS: g, Endpoint: f }, rules: [{ conditions: [{ [r]: a, [s]: [h] }], type: b, rules: [{ conditions: n, error: "Invalid Configuration: FIPS and custom endpoint are not supported", type: c }, { type: b, rules: [{ conditions: o, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", type: c }, { endpoint: { url: h, properties: k, headers: k }, type: d }] }] }, { type: b, rules: [{ conditions: [{ [r]: a, [s]: p }], type: b, rules: [{ conditions: [{ [r]: "aws.partition", [s]: p, assign: e }], type: b, rules: [{ conditions: [i, j], type: b, rules: [{ conditions: [l, m], type: b, rules: [{ type: b, rules: [{ endpoint: { url: "https://geo-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: k, headers: k }, type: d }] }] }, { error: "FIPS and DualStack are enabled, but this partition does not support one or both", type: c }] }, { conditions: n, type: b, rules: [{ conditions: [l], type: b, rules: [{ type: b, rules: [{ endpoint: { url: "https://geo-fips.{Region}.{PartitionResult#dnsSuffix}", properties: k, headers: k }, type: d }] }] }, { error: "FIPS is enabled but this partition does not support FIPS", type: c }] }, { conditions: o, type: b, rules: [{ conditions: [m], type: b, rules: [{ type: b, rules: [{ endpoint: { url: "https://geo.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: k, headers: k }, type: d }] }] }, { error: "DualStack is enabled but this partition does not support DualStack", type: c }] }, { type: b, rules: [{ endpoint: { url: "https://geo.{Region}.{PartitionResult#dnsSuffix}", properties: k, headers: k }, type: d }] }] }] }, { error: "Invalid Configuration: Missing Region", type: c }] }] };
 export const ruleSet = _data;

package/dist-es/models/models_0.js

@@ -40,19 +40,6 @@ export class InternalServerException extends __BaseException {
         this.Message = opts.Message;
     }
 }
-export class ResourceNotFoundException extends __BaseException {
-    constructor(opts) {
-        super({
-            name: "ResourceNotFoundException",
-            $fault: "client",
-            ...opts,
-        });
-        this.name = "ResourceNotFoundException";
-        this.$fault = "client";
-        Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
-        this.Message = opts.Message;
-    }
-}
 export class ServiceQuotaExceededException extends __BaseException {
     constructor(opts) {
         super({
@@ -95,15 +82,69 @@ export class ValidationException extends __BaseException {
         this.FieldList = opts.FieldList;
     }
 }
-export const AssociateTrackerConsumerRequestFilterSensitiveLog = (obj) => ({
+export class ResourceNotFoundException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ResourceNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ResourceNotFoundException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
+        this.Message = opts.Message;
+    }
+}
+export const ApiKeyFilterFilterSensitiveLog = (obj) => ({
     ...obj,
 });
-export const AssociateTrackerConsumerResponseFilterSensitiveLog = (obj) => ({
+export const ApiKeyRestrictionsFilterSensitiveLog = (obj) => ({
     ...obj,
 });
+export const CreateKeyRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CreateKeyResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Key && { Key: SENSITIVE_STRING }),
+});
 export const ValidationExceptionFieldFilterSensitiveLog = (obj) => ({
     ...obj,
 });
+export const DeleteKeyRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteKeyResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DescribeKeyRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DescribeKeyResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Key && { Key: SENSITIVE_STRING }),
+});
+export const ListKeysRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListKeysResponseEntryFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListKeysResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UpdateKeyRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UpdateKeyResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const AssociateTrackerConsumerRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const AssociateTrackerConsumerResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
 export const BatchDeleteDevicePositionHistoryRequestFilterSensitiveLog = (obj) => ({
     ...obj,
 });
@@ -439,24 +480,28 @@ export const GetDevicePositionHistoryResponseFilterSensitiveLog = (obj) => ({
 });
 export const GetMapGlyphsRequestFilterSensitiveLog = (obj) => ({
     ...obj,
+    ...(obj.Key && { Key: SENSITIVE_STRING }),
 });
 export const GetMapGlyphsResponseFilterSensitiveLog = (obj) => ({
     ...obj,
 });
 export const GetMapSpritesRequestFilterSensitiveLog = (obj) => ({
     ...obj,
+    ...(obj.Key && { Key: SENSITIVE_STRING }),
 });
 export const GetMapSpritesResponseFilterSensitiveLog = (obj) => ({
     ...obj,
 });
 export const GetMapStyleDescriptorRequestFilterSensitiveLog = (obj) => ({
     ...obj,
+    ...(obj.Key && { Key: SENSITIVE_STRING }),
 });
 export const GetMapStyleDescriptorResponseFilterSensitiveLog = (obj) => ({
     ...obj,
 });
 export const GetMapTileRequestFilterSensitiveLog = (obj) => ({
     ...obj,
+    ...(obj.Key && { Key: SENSITIVE_STRING }),
 });
 export const GetMapTileResponseFilterSensitiveLog = (obj) => ({
     ...obj,

package/dist-es/pagination/ListKeysPaginator.js

@@ -0,0 +1,32 @@
+import { ListKeysCommand } from "../commands/ListKeysCommand";
+import { Location } from "../Location";
+import { LocationClient } from "../LocationClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListKeysCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listKeys(input, ...args);
+};
+export async function* paginateListKeys(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof Location) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof LocationClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected Location | LocationClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/index.js

@@ -3,6 +3,7 @@ export * from "./Interfaces";
 export * from "./ListDevicePositionsPaginator";
 export * from "./ListGeofenceCollectionsPaginator";
 export * from "./ListGeofencesPaginator";
+export * from "./ListKeysPaginator";
 export * from "./ListMapsPaginator";
 export * from "./ListPlaceIndexesPaginator";
 export * from "./ListRouteCalculatorsPaginator";