@aws-sdk/client-redshift-serverless 3.462.0 → 3.465.0

package/dist-es/RedshiftServerless.js

@@ -3,14 +3,18 @@ import { ConvertRecoveryPointToSnapshotCommand, } from "./commands/ConvertRecove
 import { CreateCustomDomainAssociationCommand, } from "./commands/CreateCustomDomainAssociationCommand";
 import { CreateEndpointAccessCommand, } from "./commands/CreateEndpointAccessCommand";
 import { CreateNamespaceCommand, } from "./commands/CreateNamespaceCommand";
+import { CreateScheduledActionCommand, } from "./commands/CreateScheduledActionCommand";
 import { CreateSnapshotCommand, } from "./commands/CreateSnapshotCommand";
+import { CreateSnapshotCopyConfigurationCommand, } from "./commands/CreateSnapshotCopyConfigurationCommand";
 import { CreateUsageLimitCommand, } from "./commands/CreateUsageLimitCommand";
 import { CreateWorkgroupCommand, } from "./commands/CreateWorkgroupCommand";
 import { DeleteCustomDomainAssociationCommand, } from "./commands/DeleteCustomDomainAssociationCommand";
 import { DeleteEndpointAccessCommand, } from "./commands/DeleteEndpointAccessCommand";
 import { DeleteNamespaceCommand, } from "./commands/DeleteNamespaceCommand";
 import { DeleteResourcePolicyCommand, } from "./commands/DeleteResourcePolicyCommand";
+import { DeleteScheduledActionCommand, } from "./commands/DeleteScheduledActionCommand";
 import { DeleteSnapshotCommand, } from "./commands/DeleteSnapshotCommand";
+import { DeleteSnapshotCopyConfigurationCommand, } from "./commands/DeleteSnapshotCopyConfigurationCommand";
 import { DeleteUsageLimitCommand, } from "./commands/DeleteUsageLimitCommand";
 import { DeleteWorkgroupCommand, } from "./commands/DeleteWorkgroupCommand";
 import { GetCredentialsCommand, } from "./commands/GetCredentialsCommand";
@@ -19,6 +23,7 @@ import { GetEndpointAccessCommand, } from "./commands/GetEndpointAccessCommand";
 import { GetNamespaceCommand, } from "./commands/GetNamespaceCommand";
 import { GetRecoveryPointCommand, } from "./commands/GetRecoveryPointCommand";
 import { GetResourcePolicyCommand, } from "./commands/GetResourcePolicyCommand";
+import { GetScheduledActionCommand, } from "./commands/GetScheduledActionCommand";
 import { GetSnapshotCommand } from "./commands/GetSnapshotCommand";
 import { GetTableRestoreStatusCommand, } from "./commands/GetTableRestoreStatusCommand";
 import { GetUsageLimitCommand, } from "./commands/GetUsageLimitCommand";
@@ -27,6 +32,8 @@ import { ListCustomDomainAssociationsCommand, } from "./commands/ListCustomDomai
 import { ListEndpointAccessCommand, } from "./commands/ListEndpointAccessCommand";
 import { ListNamespacesCommand, } from "./commands/ListNamespacesCommand";
 import { ListRecoveryPointsCommand, } from "./commands/ListRecoveryPointsCommand";
+import { ListScheduledActionsCommand, } from "./commands/ListScheduledActionsCommand";
+import { ListSnapshotCopyConfigurationsCommand, } from "./commands/ListSnapshotCopyConfigurationsCommand";
 import { ListSnapshotsCommand, } from "./commands/ListSnapshotsCommand";
 import { ListTableRestoreStatusCommand, } from "./commands/ListTableRestoreStatusCommand";
 import { ListTagsForResourceCommand, } from "./commands/ListTagsForResourceCommand";
@@ -35,13 +42,16 @@ import { ListWorkgroupsCommand, } from "./commands/ListWorkgroupsCommand";
 import { PutResourcePolicyCommand, } from "./commands/PutResourcePolicyCommand";
 import { RestoreFromRecoveryPointCommand, } from "./commands/RestoreFromRecoveryPointCommand";
 import { RestoreFromSnapshotCommand, } from "./commands/RestoreFromSnapshotCommand";
+import { RestoreTableFromRecoveryPointCommand, } from "./commands/RestoreTableFromRecoveryPointCommand";
 import { RestoreTableFromSnapshotCommand, } from "./commands/RestoreTableFromSnapshotCommand";
 import { TagResourceCommand } from "./commands/TagResourceCommand";
 import { UntagResourceCommand, } from "./commands/UntagResourceCommand";
 import { UpdateCustomDomainAssociationCommand, } from "./commands/UpdateCustomDomainAssociationCommand";
 import { UpdateEndpointAccessCommand, } from "./commands/UpdateEndpointAccessCommand";
 import { UpdateNamespaceCommand, } from "./commands/UpdateNamespaceCommand";
+import { UpdateScheduledActionCommand, } from "./commands/UpdateScheduledActionCommand";
 import { UpdateSnapshotCommand, } from "./commands/UpdateSnapshotCommand";
+import { UpdateSnapshotCopyConfigurationCommand, } from "./commands/UpdateSnapshotCopyConfigurationCommand";
 import { UpdateUsageLimitCommand, } from "./commands/UpdateUsageLimitCommand";
 import { UpdateWorkgroupCommand, } from "./commands/UpdateWorkgroupCommand";
 import { RedshiftServerlessClient } from "./RedshiftServerlessClient";
@@ -50,14 +60,18 @@ const commands = {
     CreateCustomDomainAssociationCommand,
     CreateEndpointAccessCommand,
     CreateNamespaceCommand,
+    CreateScheduledActionCommand,
     CreateSnapshotCommand,
+    CreateSnapshotCopyConfigurationCommand,
     CreateUsageLimitCommand,
     CreateWorkgroupCommand,
     DeleteCustomDomainAssociationCommand,
     DeleteEndpointAccessCommand,
     DeleteNamespaceCommand,
     DeleteResourcePolicyCommand,
+    DeleteScheduledActionCommand,
     DeleteSnapshotCommand,
+    DeleteSnapshotCopyConfigurationCommand,
     DeleteUsageLimitCommand,
     DeleteWorkgroupCommand,
     GetCredentialsCommand,
@@ -66,6 +80,7 @@ const commands = {
     GetNamespaceCommand,
     GetRecoveryPointCommand,
     GetResourcePolicyCommand,
+    GetScheduledActionCommand,
     GetSnapshotCommand,
     GetTableRestoreStatusCommand,
     GetUsageLimitCommand,
@@ -74,6 +89,8 @@ const commands = {
     ListEndpointAccessCommand,
     ListNamespacesCommand,
     ListRecoveryPointsCommand,
+    ListScheduledActionsCommand,
+    ListSnapshotCopyConfigurationsCommand,
     ListSnapshotsCommand,
     ListTableRestoreStatusCommand,
     ListTagsForResourceCommand,
@@ -82,13 +99,16 @@ const commands = {
     PutResourcePolicyCommand,
     RestoreFromRecoveryPointCommand,
     RestoreFromSnapshotCommand,
+    RestoreTableFromRecoveryPointCommand,
     RestoreTableFromSnapshotCommand,
     TagResourceCommand,
     UntagResourceCommand,
     UpdateCustomDomainAssociationCommand,
     UpdateEndpointAccessCommand,
     UpdateNamespaceCommand,
+    UpdateScheduledActionCommand,
     UpdateSnapshotCommand,
+    UpdateSnapshotCopyConfigurationCommand,
     UpdateUsageLimitCommand,
     UpdateWorkgroupCommand,
 };

package/dist-es/commands/CreateScheduledActionCommand.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_CreateScheduledActionCommand, se_CreateScheduledActionCommand } from "../protocols/Aws_json1_1";
+export { $Command };
+export class CreateScheduledActionCommand 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, CreateScheduledActionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RedshiftServerlessClient";
+        const commandName = "CreateScheduledActionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "RedshiftServerless",
+                operation: "CreateScheduledAction",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_CreateScheduledActionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_CreateScheduledActionCommand(output, context);
+    }
+}

package/dist-es/commands/CreateSnapshotCopyConfigurationCommand.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_CreateSnapshotCopyConfigurationCommand, se_CreateSnapshotCopyConfigurationCommand, } from "../protocols/Aws_json1_1";
+export { $Command };
+export class CreateSnapshotCopyConfigurationCommand 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, CreateSnapshotCopyConfigurationCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RedshiftServerlessClient";
+        const commandName = "CreateSnapshotCopyConfigurationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "RedshiftServerless",
+                operation: "CreateSnapshotCopyConfiguration",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_CreateSnapshotCopyConfigurationCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_CreateSnapshotCopyConfigurationCommand(output, context);
+    }
+}

package/dist-es/commands/DeleteScheduledActionCommand.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_DeleteScheduledActionCommand, se_DeleteScheduledActionCommand } from "../protocols/Aws_json1_1";
+export { $Command };
+export class DeleteScheduledActionCommand 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, DeleteScheduledActionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RedshiftServerlessClient";
+        const commandName = "DeleteScheduledActionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "RedshiftServerless",
+                operation: "DeleteScheduledAction",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_DeleteScheduledActionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_DeleteScheduledActionCommand(output, context);
+    }
+}

package/dist-es/commands/DeleteSnapshotCopyConfigurationCommand.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_DeleteSnapshotCopyConfigurationCommand, se_DeleteSnapshotCopyConfigurationCommand, } from "../protocols/Aws_json1_1";
+export { $Command };
+export class DeleteSnapshotCopyConfigurationCommand 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, DeleteSnapshotCopyConfigurationCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RedshiftServerlessClient";
+        const commandName = "DeleteSnapshotCopyConfigurationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "RedshiftServerless",
+                operation: "DeleteSnapshotCopyConfiguration",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_DeleteSnapshotCopyConfigurationCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_DeleteSnapshotCopyConfigurationCommand(output, context);
+    }
+}

package/dist-es/commands/GetScheduledActionCommand.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_GetScheduledActionCommand, se_GetScheduledActionCommand } from "../protocols/Aws_json1_1";
+export { $Command };
+export class GetScheduledActionCommand 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, GetScheduledActionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RedshiftServerlessClient";
+        const commandName = "GetScheduledActionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "RedshiftServerless",
+                operation: "GetScheduledAction",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_GetScheduledActionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_GetScheduledActionCommand(output, context);
+    }
+}

package/dist-es/commands/ListScheduledActionsCommand.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_ListScheduledActionsCommand, se_ListScheduledActionsCommand } from "../protocols/Aws_json1_1";
+export { $Command };
+export class ListScheduledActionsCommand 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, ListScheduledActionsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RedshiftServerlessClient";
+        const commandName = "ListScheduledActionsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "RedshiftServerless",
+                operation: "ListScheduledActions",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_ListScheduledActionsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_ListScheduledActionsCommand(output, context);
+    }
+}

package/dist-es/commands/ListSnapshotCopyConfigurationsCommand.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_ListSnapshotCopyConfigurationsCommand, se_ListSnapshotCopyConfigurationsCommand, } from "../protocols/Aws_json1_1";
+export { $Command };
+export class ListSnapshotCopyConfigurationsCommand 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, ListSnapshotCopyConfigurationsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RedshiftServerlessClient";
+        const commandName = "ListSnapshotCopyConfigurationsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "RedshiftServerless",
+                operation: "ListSnapshotCopyConfigurations",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_ListSnapshotCopyConfigurationsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_ListSnapshotCopyConfigurationsCommand(output, context);
+    }
+}

package/dist-es/commands/RestoreTableFromRecoveryPointCommand.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_RestoreTableFromRecoveryPointCommand, se_RestoreTableFromRecoveryPointCommand, } from "../protocols/Aws_json1_1";
+export { $Command };
+export class RestoreTableFromRecoveryPointCommand 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, RestoreTableFromRecoveryPointCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RedshiftServerlessClient";
+        const commandName = "RestoreTableFromRecoveryPointCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "RedshiftServerless",
+                operation: "RestoreTableFromRecoveryPoint",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_RestoreTableFromRecoveryPointCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_RestoreTableFromRecoveryPointCommand(output, context);
+    }
+}

package/dist-es/commands/UpdateScheduledActionCommand.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_UpdateScheduledActionCommand, se_UpdateScheduledActionCommand } from "../protocols/Aws_json1_1";
+export { $Command };
+export class UpdateScheduledActionCommand 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, UpdateScheduledActionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RedshiftServerlessClient";
+        const commandName = "UpdateScheduledActionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "RedshiftServerless",
+                operation: "UpdateScheduledAction",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_UpdateScheduledActionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_UpdateScheduledActionCommand(output, context);
+    }
+}

package/dist-es/commands/UpdateSnapshotCopyConfigurationCommand.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_UpdateSnapshotCopyConfigurationCommand, se_UpdateSnapshotCopyConfigurationCommand, } from "../protocols/Aws_json1_1";
+export { $Command };
+export class UpdateSnapshotCopyConfigurationCommand 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, UpdateSnapshotCopyConfigurationCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RedshiftServerlessClient";
+        const commandName = "UpdateSnapshotCopyConfigurationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "RedshiftServerless",
+                operation: "UpdateSnapshotCopyConfiguration",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_UpdateSnapshotCopyConfigurationCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_UpdateSnapshotCopyConfigurationCommand(output, context);
+    }
+}

package/dist-es/commands/index.js

@@ -2,14 +2,18 @@ export * from "./ConvertRecoveryPointToSnapshotCommand";
 export * from "./CreateCustomDomainAssociationCommand";
 export * from "./CreateEndpointAccessCommand";
 export * from "./CreateNamespaceCommand";
+export * from "./CreateScheduledActionCommand";
 export * from "./CreateSnapshotCommand";
+export * from "./CreateSnapshotCopyConfigurationCommand";
 export * from "./CreateUsageLimitCommand";
 export * from "./CreateWorkgroupCommand";
 export * from "./DeleteCustomDomainAssociationCommand";
 export * from "./DeleteEndpointAccessCommand";
 export * from "./DeleteNamespaceCommand";
 export * from "./DeleteResourcePolicyCommand";
+export * from "./DeleteScheduledActionCommand";
 export * from "./DeleteSnapshotCommand";
+export * from "./DeleteSnapshotCopyConfigurationCommand";
 export * from "./DeleteUsageLimitCommand";
 export * from "./DeleteWorkgroupCommand";
 export * from "./GetCredentialsCommand";
@@ -18,6 +22,7 @@ export * from "./GetEndpointAccessCommand";
 export * from "./GetNamespaceCommand";
 export * from "./GetRecoveryPointCommand";
 export * from "./GetResourcePolicyCommand";
+export * from "./GetScheduledActionCommand";
 export * from "./GetSnapshotCommand";
 export * from "./GetTableRestoreStatusCommand";
 export * from "./GetUsageLimitCommand";
@@ -26,6 +31,8 @@ export * from "./ListCustomDomainAssociationsCommand";
 export * from "./ListEndpointAccessCommand";
 export * from "./ListNamespacesCommand";
 export * from "./ListRecoveryPointsCommand";
+export * from "./ListScheduledActionsCommand";
+export * from "./ListSnapshotCopyConfigurationsCommand";
 export * from "./ListSnapshotsCommand";
 export * from "./ListTableRestoreStatusCommand";
 export * from "./ListTagsForResourceCommand";
@@ -34,12 +41,15 @@ export * from "./ListWorkgroupsCommand";
 export * from "./PutResourcePolicyCommand";
 export * from "./RestoreFromRecoveryPointCommand";
 export * from "./RestoreFromSnapshotCommand";
+export * from "./RestoreTableFromRecoveryPointCommand";
 export * from "./RestoreTableFromSnapshotCommand";
 export * from "./TagResourceCommand";
 export * from "./UntagResourceCommand";
 export * from "./UpdateCustomDomainAssociationCommand";
 export * from "./UpdateEndpointAccessCommand";
 export * from "./UpdateNamespaceCommand";
+export * from "./UpdateScheduledActionCommand";
 export * from "./UpdateSnapshotCommand";
+export * from "./UpdateSnapshotCopyConfigurationCommand";
 export * from "./UpdateUsageLimitCommand";
 export * from "./UpdateWorkgroupCommand";