@aws-sdk/client-redshift-serverless 3.107.0

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetSnapshotRequest, GetSnapshotResponse } from "../models/models_0";
+import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
+export interface GetSnapshotCommandInput extends GetSnapshotRequest {
+}
+export interface GetSnapshotCommandOutput extends GetSnapshotResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns information about a specific snapshot.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftServerlessClient, GetSnapshotCommand } from "@aws-sdk/client-redshift-serverless"; // ES Modules import
+ * // const { RedshiftServerlessClient, GetSnapshotCommand } = require("@aws-sdk/client-redshift-serverless"); // CommonJS import
+ * const client = new RedshiftServerlessClient(config);
+ * const command = new GetSnapshotCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetSnapshotCommandInput} for command's `input` shape.
+ * @see {@link GetSnapshotCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
+ *
+ */
+export declare class GetSnapshotCommand extends $Command<GetSnapshotCommandInput, GetSnapshotCommandOutput, RedshiftServerlessClientResolvedConfig> {
+    readonly input: GetSnapshotCommandInput;
+    constructor(input: GetSnapshotCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSnapshotCommandInput, GetSnapshotCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetUsageLimitRequest, GetUsageLimitResponse } from "../models/models_0";
+import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
+export interface GetUsageLimitCommandInput extends GetUsageLimitRequest {
+}
+export interface GetUsageLimitCommandOutput extends GetUsageLimitResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns information about a usage limit.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftServerlessClient, GetUsageLimitCommand } from "@aws-sdk/client-redshift-serverless"; // ES Modules import
+ * // const { RedshiftServerlessClient, GetUsageLimitCommand } = require("@aws-sdk/client-redshift-serverless"); // CommonJS import
+ * const client = new RedshiftServerlessClient(config);
+ * const command = new GetUsageLimitCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetUsageLimitCommandInput} for command's `input` shape.
+ * @see {@link GetUsageLimitCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
+ *
+ */
+export declare class GetUsageLimitCommand extends $Command<GetUsageLimitCommandInput, GetUsageLimitCommandOutput, RedshiftServerlessClientResolvedConfig> {
+    readonly input: GetUsageLimitCommandInput;
+    constructor(input: GetUsageLimitCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetUsageLimitCommandInput, GetUsageLimitCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetWorkgroupRequest, GetWorkgroupResponse } from "../models/models_0";
+import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
+export interface GetWorkgroupCommandInput extends GetWorkgroupRequest {
+}
+export interface GetWorkgroupCommandOutput extends GetWorkgroupResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns information about a specific workgroup.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftServerlessClient, GetWorkgroupCommand } from "@aws-sdk/client-redshift-serverless"; // ES Modules import
+ * // const { RedshiftServerlessClient, GetWorkgroupCommand } = require("@aws-sdk/client-redshift-serverless"); // CommonJS import
+ * const client = new RedshiftServerlessClient(config);
+ * const command = new GetWorkgroupCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetWorkgroupCommandInput} for command's `input` shape.
+ * @see {@link GetWorkgroupCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
+ *
+ */
+export declare class GetWorkgroupCommand extends $Command<GetWorkgroupCommandInput, GetWorkgroupCommandOutput, RedshiftServerlessClientResolvedConfig> {
+    readonly input: GetWorkgroupCommandInput;
+    constructor(input: GetWorkgroupCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetWorkgroupCommandInput, GetWorkgroupCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListEndpointAccessRequest, ListEndpointAccessResponse } from "../models/models_0";
+import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
+export interface ListEndpointAccessCommandInput extends ListEndpointAccessRequest {
+}
+export interface ListEndpointAccessCommandOutput extends ListEndpointAccessResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns an array of <code>EndpointAccess</code> objects and relevant information.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftServerlessClient, ListEndpointAccessCommand } from "@aws-sdk/client-redshift-serverless"; // ES Modules import
+ * // const { RedshiftServerlessClient, ListEndpointAccessCommand } = require("@aws-sdk/client-redshift-serverless"); // CommonJS import
+ * const client = new RedshiftServerlessClient(config);
+ * const command = new ListEndpointAccessCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListEndpointAccessCommandInput} for command's `input` shape.
+ * @see {@link ListEndpointAccessCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
+ *
+ */
+export declare class ListEndpointAccessCommand extends $Command<ListEndpointAccessCommandInput, ListEndpointAccessCommandOutput, RedshiftServerlessClientResolvedConfig> {
+    readonly input: ListEndpointAccessCommandInput;
+    constructor(input: ListEndpointAccessCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListEndpointAccessCommandInput, ListEndpointAccessCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListNamespacesRequest, ListNamespacesResponse } from "../models/models_0";
+import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
+export interface ListNamespacesCommandInput extends ListNamespacesRequest {
+}
+export interface ListNamespacesCommandOutput extends ListNamespacesResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns information about a list of specified namespaces.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftServerlessClient, ListNamespacesCommand } from "@aws-sdk/client-redshift-serverless"; // ES Modules import
+ * // const { RedshiftServerlessClient, ListNamespacesCommand } = require("@aws-sdk/client-redshift-serverless"); // CommonJS import
+ * const client = new RedshiftServerlessClient(config);
+ * const command = new ListNamespacesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListNamespacesCommandInput} for command's `input` shape.
+ * @see {@link ListNamespacesCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
+ *
+ */
+export declare class ListNamespacesCommand extends $Command<ListNamespacesCommandInput, ListNamespacesCommandOutput, RedshiftServerlessClientResolvedConfig> {
+    readonly input: ListNamespacesCommandInput;
+    constructor(input: ListNamespacesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListNamespacesCommandInput, ListNamespacesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListRecoveryPointsRequest, ListRecoveryPointsResponse } from "../models/models_0";
+import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
+export interface ListRecoveryPointsCommandInput extends ListRecoveryPointsRequest {
+}
+export interface ListRecoveryPointsCommandOutput extends ListRecoveryPointsResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns an array of recovery points.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftServerlessClient, ListRecoveryPointsCommand } from "@aws-sdk/client-redshift-serverless"; // ES Modules import
+ * // const { RedshiftServerlessClient, ListRecoveryPointsCommand } = require("@aws-sdk/client-redshift-serverless"); // CommonJS import
+ * const client = new RedshiftServerlessClient(config);
+ * const command = new ListRecoveryPointsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListRecoveryPointsCommandInput} for command's `input` shape.
+ * @see {@link ListRecoveryPointsCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
+ *
+ */
+export declare class ListRecoveryPointsCommand extends $Command<ListRecoveryPointsCommandInput, ListRecoveryPointsCommandOutput, RedshiftServerlessClientResolvedConfig> {
+    readonly input: ListRecoveryPointsCommandInput;
+    constructor(input: ListRecoveryPointsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListRecoveryPointsCommandInput, ListRecoveryPointsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListSnapshotsRequest, ListSnapshotsResponse } from "../models/models_0";
+import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
+export interface ListSnapshotsCommandInput extends ListSnapshotsRequest {
+}
+export interface ListSnapshotsCommandOutput extends ListSnapshotsResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns a list of snapshots.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftServerlessClient, ListSnapshotsCommand } from "@aws-sdk/client-redshift-serverless"; // ES Modules import
+ * // const { RedshiftServerlessClient, ListSnapshotsCommand } = require("@aws-sdk/client-redshift-serverless"); // CommonJS import
+ * const client = new RedshiftServerlessClient(config);
+ * const command = new ListSnapshotsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListSnapshotsCommandInput} for command's `input` shape.
+ * @see {@link ListSnapshotsCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
+ *
+ */
+export declare class ListSnapshotsCommand extends $Command<ListSnapshotsCommandInput, ListSnapshotsCommandOutput, RedshiftServerlessClientResolvedConfig> {
+    readonly input: ListSnapshotsCommandInput;
+    constructor(input: ListSnapshotsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListSnapshotsCommandInput, ListSnapshotsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListTagsForResourceRequest, ListTagsForResourceResponse } from "../models/models_0";
+import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
+export interface ListTagsForResourceCommandInput extends ListTagsForResourceRequest {
+}
+export interface ListTagsForResourceCommandOutput extends ListTagsForResourceResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists the tags assigned to a resource.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftServerlessClient, ListTagsForResourceCommand } from "@aws-sdk/client-redshift-serverless"; // ES Modules import
+ * // const { RedshiftServerlessClient, ListTagsForResourceCommand } = require("@aws-sdk/client-redshift-serverless"); // CommonJS import
+ * const client = new RedshiftServerlessClient(config);
+ * const command = new ListTagsForResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListTagsForResourceCommandInput} for command's `input` shape.
+ * @see {@link ListTagsForResourceCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
+ *
+ */
+export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, RedshiftServerlessClientResolvedConfig> {
+    readonly input: ListTagsForResourceCommandInput;
+    constructor(input: ListTagsForResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListUsageLimitsRequest, ListUsageLimitsResponse } from "../models/models_0";
+import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
+export interface ListUsageLimitsCommandInput extends ListUsageLimitsRequest {
+}
+export interface ListUsageLimitsCommandOutput extends ListUsageLimitsResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists all usage limits within Amazon Redshift Serverless.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftServerlessClient, ListUsageLimitsCommand } from "@aws-sdk/client-redshift-serverless"; // ES Modules import
+ * // const { RedshiftServerlessClient, ListUsageLimitsCommand } = require("@aws-sdk/client-redshift-serverless"); // CommonJS import
+ * const client = new RedshiftServerlessClient(config);
+ * const command = new ListUsageLimitsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListUsageLimitsCommandInput} for command's `input` shape.
+ * @see {@link ListUsageLimitsCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
+ *
+ */
+export declare class ListUsageLimitsCommand extends $Command<ListUsageLimitsCommandInput, ListUsageLimitsCommandOutput, RedshiftServerlessClientResolvedConfig> {
+    readonly input: ListUsageLimitsCommandInput;
+    constructor(input: ListUsageLimitsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListUsageLimitsCommandInput, ListUsageLimitsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListWorkgroupsRequest, ListWorkgroupsResponse } from "../models/models_0";
+import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
+export interface ListWorkgroupsCommandInput extends ListWorkgroupsRequest {
+}
+export interface ListWorkgroupsCommandOutput extends ListWorkgroupsResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns information about a list of specified workgroups.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftServerlessClient, ListWorkgroupsCommand } from "@aws-sdk/client-redshift-serverless"; // ES Modules import
+ * // const { RedshiftServerlessClient, ListWorkgroupsCommand } = require("@aws-sdk/client-redshift-serverless"); // CommonJS import
+ * const client = new RedshiftServerlessClient(config);
+ * const command = new ListWorkgroupsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListWorkgroupsCommandInput} for command's `input` shape.
+ * @see {@link ListWorkgroupsCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
+ *
+ */
+export declare class ListWorkgroupsCommand extends $Command<ListWorkgroupsCommandInput, ListWorkgroupsCommandOutput, RedshiftServerlessClientResolvedConfig> {
+    readonly input: ListWorkgroupsCommandInput;
+    constructor(input: ListWorkgroupsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListWorkgroupsCommandInput, ListWorkgroupsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { PutResourcePolicyRequest, PutResourcePolicyResponse } from "../models/models_0";
+import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
+export interface PutResourcePolicyCommandInput extends PutResourcePolicyRequest {
+}
+export interface PutResourcePolicyCommandOutput extends PutResourcePolicyResponse, __MetadataBearer {
+}
+/**
+ * <p>Creates or updates a resource policy. Currently, you can use policies to share snapshots across Amazon Web Services accounts.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftServerlessClient, PutResourcePolicyCommand } from "@aws-sdk/client-redshift-serverless"; // ES Modules import
+ * // const { RedshiftServerlessClient, PutResourcePolicyCommand } = require("@aws-sdk/client-redshift-serverless"); // CommonJS import
+ * const client = new RedshiftServerlessClient(config);
+ * const command = new PutResourcePolicyCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutResourcePolicyCommandInput} for command's `input` shape.
+ * @see {@link PutResourcePolicyCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
+ *
+ */
+export declare class PutResourcePolicyCommand extends $Command<PutResourcePolicyCommandInput, PutResourcePolicyCommandOutput, RedshiftServerlessClientResolvedConfig> {
+    readonly input: PutResourcePolicyCommandInput;
+    constructor(input: PutResourcePolicyCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutResourcePolicyCommandInput, PutResourcePolicyCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { RestoreFromRecoveryPointRequest, RestoreFromRecoveryPointResponse } from "../models/models_0";
+import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
+export interface RestoreFromRecoveryPointCommandInput extends RestoreFromRecoveryPointRequest {
+}
+export interface RestoreFromRecoveryPointCommandOutput extends RestoreFromRecoveryPointResponse, __MetadataBearer {
+}
+/**
+ * <p>Restore the data from a recovery point.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftServerlessClient, RestoreFromRecoveryPointCommand } from "@aws-sdk/client-redshift-serverless"; // ES Modules import
+ * // const { RedshiftServerlessClient, RestoreFromRecoveryPointCommand } = require("@aws-sdk/client-redshift-serverless"); // CommonJS import
+ * const client = new RedshiftServerlessClient(config);
+ * const command = new RestoreFromRecoveryPointCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RestoreFromRecoveryPointCommandInput} for command's `input` shape.
+ * @see {@link RestoreFromRecoveryPointCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
+ *
+ */
+export declare class RestoreFromRecoveryPointCommand extends $Command<RestoreFromRecoveryPointCommandInput, RestoreFromRecoveryPointCommandOutput, RedshiftServerlessClientResolvedConfig> {
+    readonly input: RestoreFromRecoveryPointCommandInput;
+    constructor(input: RestoreFromRecoveryPointCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RestoreFromRecoveryPointCommandInput, RestoreFromRecoveryPointCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { RestoreFromSnapshotRequest, RestoreFromSnapshotResponse } from "../models/models_0";
+import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
+export interface RestoreFromSnapshotCommandInput extends RestoreFromSnapshotRequest {
+}
+export interface RestoreFromSnapshotCommandOutput extends RestoreFromSnapshotResponse, __MetadataBearer {
+}
+/**
+ * <p>Restores a namespace from a snapshot.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftServerlessClient, RestoreFromSnapshotCommand } from "@aws-sdk/client-redshift-serverless"; // ES Modules import
+ * // const { RedshiftServerlessClient, RestoreFromSnapshotCommand } = require("@aws-sdk/client-redshift-serverless"); // CommonJS import
+ * const client = new RedshiftServerlessClient(config);
+ * const command = new RestoreFromSnapshotCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RestoreFromSnapshotCommandInput} for command's `input` shape.
+ * @see {@link RestoreFromSnapshotCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
+ *
+ */
+export declare class RestoreFromSnapshotCommand extends $Command<RestoreFromSnapshotCommandInput, RestoreFromSnapshotCommandOutput, RedshiftServerlessClientResolvedConfig> {
+    readonly input: RestoreFromSnapshotCommandInput;
+    constructor(input: RestoreFromSnapshotCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RestoreFromSnapshotCommandInput, RestoreFromSnapshotCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { TagResourceRequest, TagResourceResponse } from "../models/models_0";
+import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
+export interface TagResourceCommandInput extends TagResourceRequest {
+}
+export interface TagResourceCommandOutput extends TagResourceResponse, __MetadataBearer {
+}
+/**
+ * <p>Assigns one or more tags to a resource.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftServerlessClient, TagResourceCommand } from "@aws-sdk/client-redshift-serverless"; // ES Modules import
+ * // const { RedshiftServerlessClient, TagResourceCommand } = require("@aws-sdk/client-redshift-serverless"); // CommonJS import
+ * const client = new RedshiftServerlessClient(config);
+ * const command = new TagResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link TagResourceCommandInput} for command's `input` shape.
+ * @see {@link TagResourceCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
+ *
+ */
+export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, RedshiftServerlessClientResolvedConfig> {
+    readonly input: TagResourceCommandInput;
+    constructor(input: TagResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { UntagResourceRequest, UntagResourceResponse } from "../models/models_0";
+import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
+export interface UntagResourceCommandInput extends UntagResourceRequest {
+}
+export interface UntagResourceCommandOutput extends UntagResourceResponse, __MetadataBearer {
+}
+/**
+ * <p>Removes a tag or set of tags from a resource.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftServerlessClient, UntagResourceCommand } from "@aws-sdk/client-redshift-serverless"; // ES Modules import
+ * // const { RedshiftServerlessClient, UntagResourceCommand } = require("@aws-sdk/client-redshift-serverless"); // CommonJS import
+ * const client = new RedshiftServerlessClient(config);
+ * const command = new UntagResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UntagResourceCommandInput} for command's `input` shape.
+ * @see {@link UntagResourceCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
+ *
+ */
+export declare class UntagResourceCommand extends $Command<UntagResourceCommandInput, UntagResourceCommandOutput, RedshiftServerlessClientResolvedConfig> {
+    readonly input: UntagResourceCommandInput;
+    constructor(input: UntagResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UntagResourceCommandInput, UntagResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { UpdateEndpointAccessRequest, UpdateEndpointAccessResponse } from "../models/models_0";
+import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
+export interface UpdateEndpointAccessCommandInput extends UpdateEndpointAccessRequest {
+}
+export interface UpdateEndpointAccessCommandOutput extends UpdateEndpointAccessResponse, __MetadataBearer {
+}
+/**
+ * <p>Updates an Amazon Redshift Serverless managed endpoint.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftServerlessClient, UpdateEndpointAccessCommand } from "@aws-sdk/client-redshift-serverless"; // ES Modules import
+ * // const { RedshiftServerlessClient, UpdateEndpointAccessCommand } = require("@aws-sdk/client-redshift-serverless"); // CommonJS import
+ * const client = new RedshiftServerlessClient(config);
+ * const command = new UpdateEndpointAccessCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateEndpointAccessCommandInput} for command's `input` shape.
+ * @see {@link UpdateEndpointAccessCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
+ *
+ */
+export declare class UpdateEndpointAccessCommand extends $Command<UpdateEndpointAccessCommandInput, UpdateEndpointAccessCommandOutput, RedshiftServerlessClientResolvedConfig> {
+    readonly input: UpdateEndpointAccessCommandInput;
+    constructor(input: UpdateEndpointAccessCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateEndpointAccessCommandInput, UpdateEndpointAccessCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { UpdateNamespaceRequest, UpdateNamespaceResponse } from "../models/models_0";
+import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
+export interface UpdateNamespaceCommandInput extends UpdateNamespaceRequest {
+}
+export interface UpdateNamespaceCommandOutput extends UpdateNamespaceResponse, __MetadataBearer {
+}
+/**
+ * <p>Updates a namespace with the specified settings.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftServerlessClient, UpdateNamespaceCommand } from "@aws-sdk/client-redshift-serverless"; // ES Modules import
+ * // const { RedshiftServerlessClient, UpdateNamespaceCommand } = require("@aws-sdk/client-redshift-serverless"); // CommonJS import
+ * const client = new RedshiftServerlessClient(config);
+ * const command = new UpdateNamespaceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateNamespaceCommandInput} for command's `input` shape.
+ * @see {@link UpdateNamespaceCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
+ *
+ */
+export declare class UpdateNamespaceCommand extends $Command<UpdateNamespaceCommandInput, UpdateNamespaceCommandOutput, RedshiftServerlessClientResolvedConfig> {
+    readonly input: UpdateNamespaceCommandInput;
+    constructor(input: UpdateNamespaceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateNamespaceCommandInput, UpdateNamespaceCommandOutput>;
+    private serialize;
+    private deserialize;
+}