@aws-sdk/client-finspace 3.468.0 → 3.473.0

package/dist-es/Finspace.js

@@ -3,27 +3,39 @@ import { CreateEnvironmentCommand, } from "./commands/CreateEnvironmentCommand";
 import { CreateKxChangesetCommand, } from "./commands/CreateKxChangesetCommand";
 import { CreateKxClusterCommand, } from "./commands/CreateKxClusterCommand";
 import { CreateKxDatabaseCommand, } from "./commands/CreateKxDatabaseCommand";
+import { CreateKxDataviewCommand, } from "./commands/CreateKxDataviewCommand";
 import { CreateKxEnvironmentCommand, } from "./commands/CreateKxEnvironmentCommand";
+import { CreateKxScalingGroupCommand, } from "./commands/CreateKxScalingGroupCommand";
 import { CreateKxUserCommand, } from "./commands/CreateKxUserCommand";
+import { CreateKxVolumeCommand, } from "./commands/CreateKxVolumeCommand";
 import { DeleteEnvironmentCommand, } from "./commands/DeleteEnvironmentCommand";
 import { DeleteKxClusterCommand, } from "./commands/DeleteKxClusterCommand";
 import { DeleteKxDatabaseCommand, } from "./commands/DeleteKxDatabaseCommand";
+import { DeleteKxDataviewCommand, } from "./commands/DeleteKxDataviewCommand";
 import { DeleteKxEnvironmentCommand, } from "./commands/DeleteKxEnvironmentCommand";
+import { DeleteKxScalingGroupCommand, } from "./commands/DeleteKxScalingGroupCommand";
 import { DeleteKxUserCommand, } from "./commands/DeleteKxUserCommand";
+import { DeleteKxVolumeCommand, } from "./commands/DeleteKxVolumeCommand";
 import { GetEnvironmentCommand, } from "./commands/GetEnvironmentCommand";
 import { GetKxChangesetCommand, } from "./commands/GetKxChangesetCommand";
 import { GetKxClusterCommand, } from "./commands/GetKxClusterCommand";
 import { GetKxConnectionStringCommand, } from "./commands/GetKxConnectionStringCommand";
 import { GetKxDatabaseCommand, } from "./commands/GetKxDatabaseCommand";
+import { GetKxDataviewCommand, } from "./commands/GetKxDataviewCommand";
 import { GetKxEnvironmentCommand, } from "./commands/GetKxEnvironmentCommand";
+import { GetKxScalingGroupCommand, } from "./commands/GetKxScalingGroupCommand";
 import { GetKxUserCommand } from "./commands/GetKxUserCommand";
+import { GetKxVolumeCommand } from "./commands/GetKxVolumeCommand";
 import { ListEnvironmentsCommand, } from "./commands/ListEnvironmentsCommand";
 import { ListKxChangesetsCommand, } from "./commands/ListKxChangesetsCommand";
 import { ListKxClusterNodesCommand, } from "./commands/ListKxClusterNodesCommand";
 import { ListKxClustersCommand, } from "./commands/ListKxClustersCommand";
 import { ListKxDatabasesCommand, } from "./commands/ListKxDatabasesCommand";
+import { ListKxDataviewsCommand, } from "./commands/ListKxDataviewsCommand";
 import { ListKxEnvironmentsCommand, } from "./commands/ListKxEnvironmentsCommand";
+import { ListKxScalingGroupsCommand, } from "./commands/ListKxScalingGroupsCommand";
 import { ListKxUsersCommand } from "./commands/ListKxUsersCommand";
+import { ListKxVolumesCommand, } from "./commands/ListKxVolumesCommand";
 import { ListTagsForResourceCommand, } from "./commands/ListTagsForResourceCommand";
 import { TagResourceCommand } from "./commands/TagResourceCommand";
 import { UntagResourceCommand, } from "./commands/UntagResourceCommand";
@@ -31,36 +43,50 @@ import { UpdateEnvironmentCommand, } from "./commands/UpdateEnvironmentCommand";
 import { UpdateKxClusterCodeConfigurationCommand, } from "./commands/UpdateKxClusterCodeConfigurationCommand";
 import { UpdateKxClusterDatabasesCommand, } from "./commands/UpdateKxClusterDatabasesCommand";
 import { UpdateKxDatabaseCommand, } from "./commands/UpdateKxDatabaseCommand";
+import { UpdateKxDataviewCommand, } from "./commands/UpdateKxDataviewCommand";
 import { UpdateKxEnvironmentCommand, } from "./commands/UpdateKxEnvironmentCommand";
 import { UpdateKxEnvironmentNetworkCommand, } from "./commands/UpdateKxEnvironmentNetworkCommand";
 import { UpdateKxUserCommand, } from "./commands/UpdateKxUserCommand";
+import { UpdateKxVolumeCommand, } from "./commands/UpdateKxVolumeCommand";
 import { FinspaceClient } from "./FinspaceClient";
 const commands = {
     CreateEnvironmentCommand,
     CreateKxChangesetCommand,
     CreateKxClusterCommand,
     CreateKxDatabaseCommand,
+    CreateKxDataviewCommand,
     CreateKxEnvironmentCommand,
+    CreateKxScalingGroupCommand,
     CreateKxUserCommand,
+    CreateKxVolumeCommand,
     DeleteEnvironmentCommand,
     DeleteKxClusterCommand,
     DeleteKxDatabaseCommand,
+    DeleteKxDataviewCommand,
     DeleteKxEnvironmentCommand,
+    DeleteKxScalingGroupCommand,
     DeleteKxUserCommand,
+    DeleteKxVolumeCommand,
     GetEnvironmentCommand,
     GetKxChangesetCommand,
     GetKxClusterCommand,
     GetKxConnectionStringCommand,
     GetKxDatabaseCommand,
+    GetKxDataviewCommand,
     GetKxEnvironmentCommand,
+    GetKxScalingGroupCommand,
     GetKxUserCommand,
+    GetKxVolumeCommand,
     ListEnvironmentsCommand,
     ListKxChangesetsCommand,
     ListKxClusterNodesCommand,
     ListKxClustersCommand,
     ListKxDatabasesCommand,
+    ListKxDataviewsCommand,
     ListKxEnvironmentsCommand,
+    ListKxScalingGroupsCommand,
     ListKxUsersCommand,
+    ListKxVolumesCommand,
     ListTagsForResourceCommand,
     TagResourceCommand,
     UntagResourceCommand,
@@ -68,9 +94,11 @@ const commands = {
     UpdateKxClusterCodeConfigurationCommand,
     UpdateKxClusterDatabasesCommand,
     UpdateKxDatabaseCommand,
+    UpdateKxDataviewCommand,
     UpdateKxEnvironmentCommand,
     UpdateKxEnvironmentNetworkCommand,
     UpdateKxUserCommand,
+    UpdateKxVolumeCommand,
 };
 export class Finspace extends FinspaceClient {
 }

package/dist-es/commands/CreateKxDataviewCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_CreateKxDataviewCommand, se_CreateKxDataviewCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class CreateKxDataviewCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateKxDataviewCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "FinspaceClient";
+        const commandName = "CreateKxDataviewCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSHabaneroManagementService",
+                operation: "CreateKxDataview",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_CreateKxDataviewCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_CreateKxDataviewCommand(output, context);
+    }
+}

package/dist-es/commands/CreateKxScalingGroupCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_CreateKxScalingGroupCommand, se_CreateKxScalingGroupCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class CreateKxScalingGroupCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateKxScalingGroupCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "FinspaceClient";
+        const commandName = "CreateKxScalingGroupCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSHabaneroManagementService",
+                operation: "CreateKxScalingGroup",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_CreateKxScalingGroupCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_CreateKxScalingGroupCommand(output, context);
+    }
+}

package/dist-es/commands/CreateKxVolumeCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_CreateKxVolumeCommand, se_CreateKxVolumeCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class CreateKxVolumeCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateKxVolumeCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "FinspaceClient";
+        const commandName = "CreateKxVolumeCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSHabaneroManagementService",
+                operation: "CreateKxVolume",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_CreateKxVolumeCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_CreateKxVolumeCommand(output, context);
+    }
+}

package/dist-es/commands/DeleteKxDataviewCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_DeleteKxDataviewCommand, se_DeleteKxDataviewCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class DeleteKxDataviewCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteKxDataviewCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "FinspaceClient";
+        const commandName = "DeleteKxDataviewCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSHabaneroManagementService",
+                operation: "DeleteKxDataview",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_DeleteKxDataviewCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_DeleteKxDataviewCommand(output, context);
+    }
+}

package/dist-es/commands/DeleteKxScalingGroupCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_DeleteKxScalingGroupCommand, se_DeleteKxScalingGroupCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class DeleteKxScalingGroupCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteKxScalingGroupCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "FinspaceClient";
+        const commandName = "DeleteKxScalingGroupCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSHabaneroManagementService",
+                operation: "DeleteKxScalingGroup",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_DeleteKxScalingGroupCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_DeleteKxScalingGroupCommand(output, context);
+    }
+}

package/dist-es/commands/DeleteKxVolumeCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_DeleteKxVolumeCommand, se_DeleteKxVolumeCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class DeleteKxVolumeCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteKxVolumeCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "FinspaceClient";
+        const commandName = "DeleteKxVolumeCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSHabaneroManagementService",
+                operation: "DeleteKxVolume",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_DeleteKxVolumeCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_DeleteKxVolumeCommand(output, context);
+    }
+}

package/dist-es/commands/GetKxDataviewCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_GetKxDataviewCommand, se_GetKxDataviewCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class GetKxDataviewCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetKxDataviewCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "FinspaceClient";
+        const commandName = "GetKxDataviewCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSHabaneroManagementService",
+                operation: "GetKxDataview",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_GetKxDataviewCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_GetKxDataviewCommand(output, context);
+    }
+}

package/dist-es/commands/GetKxScalingGroupCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_GetKxScalingGroupCommand, se_GetKxScalingGroupCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class GetKxScalingGroupCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetKxScalingGroupCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "FinspaceClient";
+        const commandName = "GetKxScalingGroupCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSHabaneroManagementService",
+                operation: "GetKxScalingGroup",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_GetKxScalingGroupCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_GetKxScalingGroupCommand(output, context);
+    }
+}

package/dist-es/commands/GetKxVolumeCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_GetKxVolumeCommand, se_GetKxVolumeCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class GetKxVolumeCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetKxVolumeCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "FinspaceClient";
+        const commandName = "GetKxVolumeCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSHabaneroManagementService",
+                operation: "GetKxVolume",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_GetKxVolumeCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_GetKxVolumeCommand(output, context);
+    }
+}

package/dist-es/commands/ListKxDataviewsCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_ListKxDataviewsCommand, se_ListKxDataviewsCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class ListKxDataviewsCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListKxDataviewsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "FinspaceClient";
+        const commandName = "ListKxDataviewsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSHabaneroManagementService",
+                operation: "ListKxDataviews",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_ListKxDataviewsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_ListKxDataviewsCommand(output, context);
+    }
+}

package/dist-es/commands/ListKxScalingGroupsCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_ListKxScalingGroupsCommand, se_ListKxScalingGroupsCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class ListKxScalingGroupsCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListKxScalingGroupsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "FinspaceClient";
+        const commandName = "ListKxScalingGroupsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSHabaneroManagementService",
+                operation: "ListKxScalingGroups",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_ListKxScalingGroupsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_ListKxScalingGroupsCommand(output, context);
+    }
+}