@aws-sdk/client-redshift-serverless 3.107.0

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

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConvertRecoveryPointToSnapshotRequest, ConvertRecoveryPointToSnapshotResponse } from "../models/models_0";
+import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
+export interface ConvertRecoveryPointToSnapshotCommandInput extends ConvertRecoveryPointToSnapshotRequest {
+}
+export interface ConvertRecoveryPointToSnapshotCommandOutput extends ConvertRecoveryPointToSnapshotResponse, __MetadataBearer {
+}
+/**
+ * <p>Converts a recovery point to a snapshot. For more information about recovery points and snapshots,
+ *          see <a href="https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-snapshots-recovery.html">Working with snapshots and recovery points</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftServerlessClient, ConvertRecoveryPointToSnapshotCommand } from "@aws-sdk/client-redshift-serverless"; // ES Modules import
+ * // const { RedshiftServerlessClient, ConvertRecoveryPointToSnapshotCommand } = require("@aws-sdk/client-redshift-serverless"); // CommonJS import
+ * const client = new RedshiftServerlessClient(config);
+ * const command = new ConvertRecoveryPointToSnapshotCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ConvertRecoveryPointToSnapshotCommandInput} for command's `input` shape.
+ * @see {@link ConvertRecoveryPointToSnapshotCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
+ *
+ */
+export declare class ConvertRecoveryPointToSnapshotCommand extends $Command<ConvertRecoveryPointToSnapshotCommandInput, ConvertRecoveryPointToSnapshotCommandOutput, RedshiftServerlessClientResolvedConfig> {
+    readonly input: ConvertRecoveryPointToSnapshotCommandInput;
+    constructor(input: ConvertRecoveryPointToSnapshotCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ConvertRecoveryPointToSnapshotCommandInput, ConvertRecoveryPointToSnapshotCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/CreateEndpointAccessCommand.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 { CreateEndpointAccessRequest, CreateEndpointAccessResponse } from "../models/models_0";
+import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
+export interface CreateEndpointAccessCommandInput extends CreateEndpointAccessRequest {
+}
+export interface CreateEndpointAccessCommandOutput extends CreateEndpointAccessResponse, __MetadataBearer {
+}
+/**
+ * <p>Creates an Amazon Redshift Serverless managed VPC endpoint.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftServerlessClient, CreateEndpointAccessCommand } from "@aws-sdk/client-redshift-serverless"; // ES Modules import
+ * // const { RedshiftServerlessClient, CreateEndpointAccessCommand } = require("@aws-sdk/client-redshift-serverless"); // CommonJS import
+ * const client = new RedshiftServerlessClient(config);
+ * const command = new CreateEndpointAccessCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateEndpointAccessCommandInput} for command's `input` shape.
+ * @see {@link CreateEndpointAccessCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
+ *
+ */
+export declare class CreateEndpointAccessCommand extends $Command<CreateEndpointAccessCommandInput, CreateEndpointAccessCommandOutput, RedshiftServerlessClientResolvedConfig> {
+    readonly input: CreateEndpointAccessCommandInput;
+    constructor(input: CreateEndpointAccessCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateEndpointAccessCommandInput, CreateEndpointAccessCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/CreateNamespaceCommand.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 { CreateNamespaceRequest, CreateNamespaceResponse } from "../models/models_0";
+import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
+export interface CreateNamespaceCommandInput extends CreateNamespaceRequest {
+}
+export interface CreateNamespaceCommandOutput extends CreateNamespaceResponse, __MetadataBearer {
+}
+/**
+ * <p>Creates a namespace in Amazon Redshift Serverless.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftServerlessClient, CreateNamespaceCommand } from "@aws-sdk/client-redshift-serverless"; // ES Modules import
+ * // const { RedshiftServerlessClient, CreateNamespaceCommand } = require("@aws-sdk/client-redshift-serverless"); // CommonJS import
+ * const client = new RedshiftServerlessClient(config);
+ * const command = new CreateNamespaceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateNamespaceCommandInput} for command's `input` shape.
+ * @see {@link CreateNamespaceCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
+ *
+ */
+export declare class CreateNamespaceCommand extends $Command<CreateNamespaceCommandInput, CreateNamespaceCommandOutput, RedshiftServerlessClientResolvedConfig> {
+    readonly input: CreateNamespaceCommandInput;
+    constructor(input: CreateNamespaceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateNamespaceCommandInput, CreateNamespaceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CreateSnapshotRequest, CreateSnapshotResponse } from "../models/models_0";
+import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
+export interface CreateSnapshotCommandInput extends CreateSnapshotRequest {
+}
+export interface CreateSnapshotCommandOutput extends CreateSnapshotResponse, __MetadataBearer {
+}
+/**
+ * <p>Creates a snapshot of all databases in a namespace.
+ *          For more information about snapshots, see
+ *          <a href="https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-snapshots-recovery.html">
+ *          Working with snapshots and recovery points</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftServerlessClient, CreateSnapshotCommand } from "@aws-sdk/client-redshift-serverless"; // ES Modules import
+ * // const { RedshiftServerlessClient, CreateSnapshotCommand } = require("@aws-sdk/client-redshift-serverless"); // CommonJS import
+ * const client = new RedshiftServerlessClient(config);
+ * const command = new CreateSnapshotCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateSnapshotCommandInput} for command's `input` shape.
+ * @see {@link CreateSnapshotCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
+ *
+ */
+export declare class CreateSnapshotCommand extends $Command<CreateSnapshotCommandInput, CreateSnapshotCommandOutput, RedshiftServerlessClientResolvedConfig> {
+    readonly input: CreateSnapshotCommandInput;
+    constructor(input: CreateSnapshotCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSnapshotCommandInput, CreateSnapshotCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CreateUsageLimitRequest, CreateUsageLimitResponse } from "../models/models_0";
+import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
+export interface CreateUsageLimitCommandInput extends CreateUsageLimitRequest {
+}
+export interface CreateUsageLimitCommandOutput extends CreateUsageLimitResponse, __MetadataBearer {
+}
+/**
+ * <p>Creates a usage limit for a specified Amazon Redshift Serverless usage type. The usage limit is identified by the returned usage limit identifier.
+ *       </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftServerlessClient, CreateUsageLimitCommand } from "@aws-sdk/client-redshift-serverless"; // ES Modules import
+ * // const { RedshiftServerlessClient, CreateUsageLimitCommand } = require("@aws-sdk/client-redshift-serverless"); // CommonJS import
+ * const client = new RedshiftServerlessClient(config);
+ * const command = new CreateUsageLimitCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateUsageLimitCommandInput} for command's `input` shape.
+ * @see {@link CreateUsageLimitCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
+ *
+ */
+export declare class CreateUsageLimitCommand extends $Command<CreateUsageLimitCommandInput, CreateUsageLimitCommandOutput, RedshiftServerlessClientResolvedConfig> {
+    readonly input: CreateUsageLimitCommandInput;
+    constructor(input: CreateUsageLimitCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateUsageLimitCommandInput, CreateUsageLimitCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/CreateWorkgroupCommand.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 { CreateWorkgroupRequest, CreateWorkgroupResponse } from "../models/models_0";
+import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
+export interface CreateWorkgroupCommandInput extends CreateWorkgroupRequest {
+}
+export interface CreateWorkgroupCommandOutput extends CreateWorkgroupResponse, __MetadataBearer {
+}
+/**
+ * <p>Creates an workgroup in Amazon Redshift Serverless.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftServerlessClient, CreateWorkgroupCommand } from "@aws-sdk/client-redshift-serverless"; // ES Modules import
+ * // const { RedshiftServerlessClient, CreateWorkgroupCommand } = require("@aws-sdk/client-redshift-serverless"); // CommonJS import
+ * const client = new RedshiftServerlessClient(config);
+ * const command = new CreateWorkgroupCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateWorkgroupCommandInput} for command's `input` shape.
+ * @see {@link CreateWorkgroupCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
+ *
+ */
+export declare class CreateWorkgroupCommand extends $Command<CreateWorkgroupCommandInput, CreateWorkgroupCommandOutput, RedshiftServerlessClientResolvedConfig> {
+    readonly input: CreateWorkgroupCommandInput;
+    constructor(input: CreateWorkgroupCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateWorkgroupCommandInput, CreateWorkgroupCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteEndpointAccessCommand.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 { DeleteEndpointAccessRequest, DeleteEndpointAccessResponse } from "../models/models_0";
+import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
+export interface DeleteEndpointAccessCommandInput extends DeleteEndpointAccessRequest {
+}
+export interface DeleteEndpointAccessCommandOutput extends DeleteEndpointAccessResponse, __MetadataBearer {
+}
+/**
+ * <p>Deletes an Amazon Redshift Serverless managed VPC endpoint.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftServerlessClient, DeleteEndpointAccessCommand } from "@aws-sdk/client-redshift-serverless"; // ES Modules import
+ * // const { RedshiftServerlessClient, DeleteEndpointAccessCommand } = require("@aws-sdk/client-redshift-serverless"); // CommonJS import
+ * const client = new RedshiftServerlessClient(config);
+ * const command = new DeleteEndpointAccessCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteEndpointAccessCommandInput} for command's `input` shape.
+ * @see {@link DeleteEndpointAccessCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
+ *
+ */
+export declare class DeleteEndpointAccessCommand extends $Command<DeleteEndpointAccessCommandInput, DeleteEndpointAccessCommandOutput, RedshiftServerlessClientResolvedConfig> {
+    readonly input: DeleteEndpointAccessCommandInput;
+    constructor(input: DeleteEndpointAccessCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteEndpointAccessCommandInput, DeleteEndpointAccessCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeleteNamespaceRequest, DeleteNamespaceResponse } from "../models/models_0";
+import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
+export interface DeleteNamespaceCommandInput extends DeleteNamespaceRequest {
+}
+export interface DeleteNamespaceCommandOutput extends DeleteNamespaceResponse, __MetadataBearer {
+}
+/**
+ * <p>Deletes a namespace from Amazon Redshift Serverless.
+ *          Before you delete the namespace, you can create a final snapshot that has all of the data within the namespace.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftServerlessClient, DeleteNamespaceCommand } from "@aws-sdk/client-redshift-serverless"; // ES Modules import
+ * // const { RedshiftServerlessClient, DeleteNamespaceCommand } = require("@aws-sdk/client-redshift-serverless"); // CommonJS import
+ * const client = new RedshiftServerlessClient(config);
+ * const command = new DeleteNamespaceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteNamespaceCommandInput} for command's `input` shape.
+ * @see {@link DeleteNamespaceCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
+ *
+ */
+export declare class DeleteNamespaceCommand extends $Command<DeleteNamespaceCommandInput, DeleteNamespaceCommandOutput, RedshiftServerlessClientResolvedConfig> {
+    readonly input: DeleteNamespaceCommandInput;
+    constructor(input: DeleteNamespaceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteNamespaceCommandInput, DeleteNamespaceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteResourcePolicyCommand.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 { DeleteResourcePolicyRequest, DeleteResourcePolicyResponse } from "../models/models_0";
+import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
+export interface DeleteResourcePolicyCommandInput extends DeleteResourcePolicyRequest {
+}
+export interface DeleteResourcePolicyCommandOutput extends DeleteResourcePolicyResponse, __MetadataBearer {
+}
+/**
+ * <p>Deletes the specified resource policy.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftServerlessClient, DeleteResourcePolicyCommand } from "@aws-sdk/client-redshift-serverless"; // ES Modules import
+ * // const { RedshiftServerlessClient, DeleteResourcePolicyCommand } = require("@aws-sdk/client-redshift-serverless"); // CommonJS import
+ * const client = new RedshiftServerlessClient(config);
+ * const command = new DeleteResourcePolicyCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteResourcePolicyCommandInput} for command's `input` shape.
+ * @see {@link DeleteResourcePolicyCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
+ *
+ */
+export declare class DeleteResourcePolicyCommand extends $Command<DeleteResourcePolicyCommandInput, DeleteResourcePolicyCommandOutput, RedshiftServerlessClientResolvedConfig> {
+    readonly input: DeleteResourcePolicyCommandInput;
+    constructor(input: DeleteResourcePolicyCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteResourcePolicyCommandInput, DeleteResourcePolicyCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteSnapshotCommand.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 { DeleteSnapshotRequest, DeleteSnapshotResponse } from "../models/models_0";
+import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
+export interface DeleteSnapshotCommandInput extends DeleteSnapshotRequest {
+}
+export interface DeleteSnapshotCommandOutput extends DeleteSnapshotResponse, __MetadataBearer {
+}
+/**
+ * <p>Deletes a snapshot from Amazon Redshift Serverless.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftServerlessClient, DeleteSnapshotCommand } from "@aws-sdk/client-redshift-serverless"; // ES Modules import
+ * // const { RedshiftServerlessClient, DeleteSnapshotCommand } = require("@aws-sdk/client-redshift-serverless"); // CommonJS import
+ * const client = new RedshiftServerlessClient(config);
+ * const command = new DeleteSnapshotCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteSnapshotCommandInput} for command's `input` shape.
+ * @see {@link DeleteSnapshotCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
+ *
+ */
+export declare class DeleteSnapshotCommand extends $Command<DeleteSnapshotCommandInput, DeleteSnapshotCommandOutput, RedshiftServerlessClientResolvedConfig> {
+    readonly input: DeleteSnapshotCommandInput;
+    constructor(input: DeleteSnapshotCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteSnapshotCommandInput, DeleteSnapshotCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteUsageLimitCommand.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 { DeleteUsageLimitRequest, DeleteUsageLimitResponse } from "../models/models_0";
+import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
+export interface DeleteUsageLimitCommandInput extends DeleteUsageLimitRequest {
+}
+export interface DeleteUsageLimitCommandOutput extends DeleteUsageLimitResponse, __MetadataBearer {
+}
+/**
+ * <p>Deletes a usage limit from Amazon Redshift Serverless.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftServerlessClient, DeleteUsageLimitCommand } from "@aws-sdk/client-redshift-serverless"; // ES Modules import
+ * // const { RedshiftServerlessClient, DeleteUsageLimitCommand } = require("@aws-sdk/client-redshift-serverless"); // CommonJS import
+ * const client = new RedshiftServerlessClient(config);
+ * const command = new DeleteUsageLimitCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteUsageLimitCommandInput} for command's `input` shape.
+ * @see {@link DeleteUsageLimitCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
+ *
+ */
+export declare class DeleteUsageLimitCommand extends $Command<DeleteUsageLimitCommandInput, DeleteUsageLimitCommandOutput, RedshiftServerlessClientResolvedConfig> {
+    readonly input: DeleteUsageLimitCommandInput;
+    constructor(input: DeleteUsageLimitCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteUsageLimitCommandInput, DeleteUsageLimitCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteWorkgroupCommand.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 { DeleteWorkgroupRequest, DeleteWorkgroupResponse } from "../models/models_0";
+import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
+export interface DeleteWorkgroupCommandInput extends DeleteWorkgroupRequest {
+}
+export interface DeleteWorkgroupCommandOutput extends DeleteWorkgroupResponse, __MetadataBearer {
+}
+/**
+ * <p>Deletes a workgroup.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftServerlessClient, DeleteWorkgroupCommand } from "@aws-sdk/client-redshift-serverless"; // ES Modules import
+ * // const { RedshiftServerlessClient, DeleteWorkgroupCommand } = require("@aws-sdk/client-redshift-serverless"); // CommonJS import
+ * const client = new RedshiftServerlessClient(config);
+ * const command = new DeleteWorkgroupCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteWorkgroupCommandInput} for command's `input` shape.
+ * @see {@link DeleteWorkgroupCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
+ *
+ */
+export declare class DeleteWorkgroupCommand extends $Command<DeleteWorkgroupCommandInput, DeleteWorkgroupCommandOutput, RedshiftServerlessClientResolvedConfig> {
+    readonly input: DeleteWorkgroupCommandInput;
+    constructor(input: DeleteWorkgroupCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteWorkgroupCommandInput, DeleteWorkgroupCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,48 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetCredentialsRequest, GetCredentialsResponse } from "../models/models_0";
+import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
+export interface GetCredentialsCommandInput extends GetCredentialsRequest {
+}
+export interface GetCredentialsCommandOutput extends GetCredentialsResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns a database user name and temporary password with
+ *          temporary authorization to log in to Amazon Redshift Serverless.</p>
+ *          <p>By default, the temporary credentials expire in 900 seconds.
+ *          You can optionally specify a duration between 900 seconds (15 minutes) and 3600 seconds (60 minutes).</p>
+ *
+ *          <p>
+ *          The Identity and Access Management (IAM) user or role that runs
+ *          GetCredentials must have an IAM policy attached that allows access to all
+ *          necessary actions and resources.
+ *          </p>
+ *
+ *          <p>
+ *          If the <code>DbName</code> parameter is specified, the IAM policy must
+ *          allow access to the resource dbname for the specified database name.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftServerlessClient, GetCredentialsCommand } from "@aws-sdk/client-redshift-serverless"; // ES Modules import
+ * // const { RedshiftServerlessClient, GetCredentialsCommand } = require("@aws-sdk/client-redshift-serverless"); // CommonJS import
+ * const client = new RedshiftServerlessClient(config);
+ * const command = new GetCredentialsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetCredentialsCommandInput} for command's `input` shape.
+ * @see {@link GetCredentialsCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
+ *
+ */
+export declare class GetCredentialsCommand extends $Command<GetCredentialsCommandInput, GetCredentialsCommandOutput, RedshiftServerlessClientResolvedConfig> {
+    readonly input: GetCredentialsCommandInput;
+    constructor(input: GetCredentialsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCredentialsCommandInput, GetCredentialsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetEndpointAccessCommand.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 { GetEndpointAccessRequest, GetEndpointAccessResponse } from "../models/models_0";
+import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
+export interface GetEndpointAccessCommandInput extends GetEndpointAccessRequest {
+}
+export interface GetEndpointAccessCommandOutput extends GetEndpointAccessResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns information, such as the name, about a VPC endpoint.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftServerlessClient, GetEndpointAccessCommand } from "@aws-sdk/client-redshift-serverless"; // ES Modules import
+ * // const { RedshiftServerlessClient, GetEndpointAccessCommand } = require("@aws-sdk/client-redshift-serverless"); // CommonJS import
+ * const client = new RedshiftServerlessClient(config);
+ * const command = new GetEndpointAccessCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetEndpointAccessCommandInput} for command's `input` shape.
+ * @see {@link GetEndpointAccessCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
+ *
+ */
+export declare class GetEndpointAccessCommand extends $Command<GetEndpointAccessCommandInput, GetEndpointAccessCommandOutput, RedshiftServerlessClientResolvedConfig> {
+    readonly input: GetEndpointAccessCommandInput;
+    constructor(input: GetEndpointAccessCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetEndpointAccessCommandInput, GetEndpointAccessCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetNamespaceCommand.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 { GetNamespaceRequest, GetNamespaceResponse } from "../models/models_0";
+import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
+export interface GetNamespaceCommandInput extends GetNamespaceRequest {
+}
+export interface GetNamespaceCommandOutput extends GetNamespaceResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns information about a namespace in Amazon Redshift Serverless.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftServerlessClient, GetNamespaceCommand } from "@aws-sdk/client-redshift-serverless"; // ES Modules import
+ * // const { RedshiftServerlessClient, GetNamespaceCommand } = require("@aws-sdk/client-redshift-serverless"); // CommonJS import
+ * const client = new RedshiftServerlessClient(config);
+ * const command = new GetNamespaceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetNamespaceCommandInput} for command's `input` shape.
+ * @see {@link GetNamespaceCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
+ *
+ */
+export declare class GetNamespaceCommand extends $Command<GetNamespaceCommandInput, GetNamespaceCommandOutput, RedshiftServerlessClientResolvedConfig> {
+    readonly input: GetNamespaceCommandInput;
+    constructor(input: GetNamespaceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetNamespaceCommandInput, GetNamespaceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetRecoveryPointCommand.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 { GetRecoveryPointRequest, GetRecoveryPointResponse } from "../models/models_0";
+import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
+export interface GetRecoveryPointCommandInput extends GetRecoveryPointRequest {
+}
+export interface GetRecoveryPointCommandOutput extends GetRecoveryPointResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns information about a recovery point.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftServerlessClient, GetRecoveryPointCommand } from "@aws-sdk/client-redshift-serverless"; // ES Modules import
+ * // const { RedshiftServerlessClient, GetRecoveryPointCommand } = require("@aws-sdk/client-redshift-serverless"); // CommonJS import
+ * const client = new RedshiftServerlessClient(config);
+ * const command = new GetRecoveryPointCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetRecoveryPointCommandInput} for command's `input` shape.
+ * @see {@link GetRecoveryPointCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
+ *
+ */
+export declare class GetRecoveryPointCommand extends $Command<GetRecoveryPointCommandInput, GetRecoveryPointCommandOutput, RedshiftServerlessClientResolvedConfig> {
+    readonly input: GetRecoveryPointCommandInput;
+    constructor(input: GetRecoveryPointCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetRecoveryPointCommandInput, GetRecoveryPointCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetResourcePolicyCommand.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 { GetResourcePolicyRequest, GetResourcePolicyResponse } from "../models/models_0";
+import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
+export interface GetResourcePolicyCommandInput extends GetResourcePolicyRequest {
+}
+export interface GetResourcePolicyCommandOutput extends GetResourcePolicyResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns a resource policy.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftServerlessClient, GetResourcePolicyCommand } from "@aws-sdk/client-redshift-serverless"; // ES Modules import
+ * // const { RedshiftServerlessClient, GetResourcePolicyCommand } = require("@aws-sdk/client-redshift-serverless"); // CommonJS import
+ * const client = new RedshiftServerlessClient(config);
+ * const command = new GetResourcePolicyCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetResourcePolicyCommandInput} for command's `input` shape.
+ * @see {@link GetResourcePolicyCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
+ *
+ */
+export declare class GetResourcePolicyCommand extends $Command<GetResourcePolicyCommandInput, GetResourcePolicyCommandOutput, RedshiftServerlessClientResolvedConfig> {
+    readonly input: GetResourcePolicyCommandInput;
+    constructor(input: GetResourcePolicyCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetResourcePolicyCommandInput, GetResourcePolicyCommandOutput>;
+    private serialize;
+    private deserialize;
+}