@aws-sdk/client-cleanrooms 3.250.0

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

@@ -0,0 +1,37 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CleanRoomsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CleanRoomsClient";
+import { CreateCollaborationInput, CreateCollaborationOutput } from "../models/models_0";
+export interface CreateCollaborationCommandInput extends CreateCollaborationInput {
+}
+export interface CreateCollaborationCommandOutput extends CreateCollaborationOutput, __MetadataBearer {
+}
+/**
+ * <p>Creates a new collaboration.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CleanRoomsClient, CreateCollaborationCommand } from "@aws-sdk/client-cleanrooms"; // ES Modules import
+ * // const { CleanRoomsClient, CreateCollaborationCommand } = require("@aws-sdk/client-cleanrooms"); // CommonJS import
+ * const client = new CleanRoomsClient(config);
+ * const command = new CreateCollaborationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateCollaborationCommandInput} for command's `input` shape.
+ * @see {@link CreateCollaborationCommandOutput} for command's `response` shape.
+ * @see {@link CleanRoomsClientResolvedConfig | config} for CleanRoomsClient's `config` shape.
+ *
+ */
+export declare class CreateCollaborationCommand extends $Command<CreateCollaborationCommandInput, CreateCollaborationCommandOutput, CleanRoomsClientResolvedConfig> {
+    readonly input: CreateCollaborationCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: CreateCollaborationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CleanRoomsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateCollaborationCommandInput, CreateCollaborationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,38 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CleanRoomsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CleanRoomsClient";
+import { CreateConfiguredTableAnalysisRuleInput, CreateConfiguredTableAnalysisRuleOutput } from "../models/models_0";
+export interface CreateConfiguredTableAnalysisRuleCommandInput extends CreateConfiguredTableAnalysisRuleInput {
+}
+export interface CreateConfiguredTableAnalysisRuleCommandOutput extends CreateConfiguredTableAnalysisRuleOutput, __MetadataBearer {
+}
+/**
+ * <p>Creates a new analysis rule for a configured table. Currently, only one analysis rule
+ *          can be created for a given configured table.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CleanRoomsClient, CreateConfiguredTableAnalysisRuleCommand } from "@aws-sdk/client-cleanrooms"; // ES Modules import
+ * // const { CleanRoomsClient, CreateConfiguredTableAnalysisRuleCommand } = require("@aws-sdk/client-cleanrooms"); // CommonJS import
+ * const client = new CleanRoomsClient(config);
+ * const command = new CreateConfiguredTableAnalysisRuleCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateConfiguredTableAnalysisRuleCommandInput} for command's `input` shape.
+ * @see {@link CreateConfiguredTableAnalysisRuleCommandOutput} for command's `response` shape.
+ * @see {@link CleanRoomsClientResolvedConfig | config} for CleanRoomsClient's `config` shape.
+ *
+ */
+export declare class CreateConfiguredTableAnalysisRuleCommand extends $Command<CreateConfiguredTableAnalysisRuleCommandInput, CreateConfiguredTableAnalysisRuleCommandOutput, CleanRoomsClientResolvedConfig> {
+    readonly input: CreateConfiguredTableAnalysisRuleCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: CreateConfiguredTableAnalysisRuleCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CleanRoomsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateConfiguredTableAnalysisRuleCommandInput, CreateConfiguredTableAnalysisRuleCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,38 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CleanRoomsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CleanRoomsClient";
+import { CreateConfiguredTableAssociationInput, CreateConfiguredTableAssociationOutput } from "../models/models_0";
+export interface CreateConfiguredTableAssociationCommandInput extends CreateConfiguredTableAssociationInput {
+}
+export interface CreateConfiguredTableAssociationCommandOutput extends CreateConfiguredTableAssociationOutput, __MetadataBearer {
+}
+/**
+ * <p>Creates a configured table association. A configured table association links a
+ *          configured table with a collaboration.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CleanRoomsClient, CreateConfiguredTableAssociationCommand } from "@aws-sdk/client-cleanrooms"; // ES Modules import
+ * // const { CleanRoomsClient, CreateConfiguredTableAssociationCommand } = require("@aws-sdk/client-cleanrooms"); // CommonJS import
+ * const client = new CleanRoomsClient(config);
+ * const command = new CreateConfiguredTableAssociationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateConfiguredTableAssociationCommandInput} for command's `input` shape.
+ * @see {@link CreateConfiguredTableAssociationCommandOutput} for command's `response` shape.
+ * @see {@link CleanRoomsClientResolvedConfig | config} for CleanRoomsClient's `config` shape.
+ *
+ */
+export declare class CreateConfiguredTableAssociationCommand extends $Command<CreateConfiguredTableAssociationCommandInput, CreateConfiguredTableAssociationCommandOutput, CleanRoomsClientResolvedConfig> {
+    readonly input: CreateConfiguredTableAssociationCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: CreateConfiguredTableAssociationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CleanRoomsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateConfiguredTableAssociationCommandInput, CreateConfiguredTableAssociationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,37 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CleanRoomsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CleanRoomsClient";
+import { CreateConfiguredTableInput, CreateConfiguredTableOutput } from "../models/models_0";
+export interface CreateConfiguredTableCommandInput extends CreateConfiguredTableInput {
+}
+export interface CreateConfiguredTableCommandOutput extends CreateConfiguredTableOutput, __MetadataBearer {
+}
+/**
+ * <p>Creates a new configured table resource.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CleanRoomsClient, CreateConfiguredTableCommand } from "@aws-sdk/client-cleanrooms"; // ES Modules import
+ * // const { CleanRoomsClient, CreateConfiguredTableCommand } = require("@aws-sdk/client-cleanrooms"); // CommonJS import
+ * const client = new CleanRoomsClient(config);
+ * const command = new CreateConfiguredTableCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateConfiguredTableCommandInput} for command's `input` shape.
+ * @see {@link CreateConfiguredTableCommandOutput} for command's `response` shape.
+ * @see {@link CleanRoomsClientResolvedConfig | config} for CleanRoomsClient's `config` shape.
+ *
+ */
+export declare class CreateConfiguredTableCommand extends $Command<CreateConfiguredTableCommandInput, CreateConfiguredTableCommandOutput, CleanRoomsClientResolvedConfig> {
+    readonly input: CreateConfiguredTableCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: CreateConfiguredTableCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CleanRoomsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateConfiguredTableCommandInput, CreateConfiguredTableCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,38 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CleanRoomsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CleanRoomsClient";
+import { CreateMembershipInput, CreateMembershipOutput } from "../models/models_0";
+export interface CreateMembershipCommandInput extends CreateMembershipInput {
+}
+export interface CreateMembershipCommandOutput extends CreateMembershipOutput, __MetadataBearer {
+}
+/**
+ * <p>Creates a membership for a specific collaboration identifier and joins the
+ *          collaboration.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CleanRoomsClient, CreateMembershipCommand } from "@aws-sdk/client-cleanrooms"; // ES Modules import
+ * // const { CleanRoomsClient, CreateMembershipCommand } = require("@aws-sdk/client-cleanrooms"); // CommonJS import
+ * const client = new CleanRoomsClient(config);
+ * const command = new CreateMembershipCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateMembershipCommandInput} for command's `input` shape.
+ * @see {@link CreateMembershipCommandOutput} for command's `response` shape.
+ * @see {@link CleanRoomsClientResolvedConfig | config} for CleanRoomsClient's `config` shape.
+ *
+ */
+export declare class CreateMembershipCommand extends $Command<CreateMembershipCommandInput, CreateMembershipCommandOutput, CleanRoomsClientResolvedConfig> {
+    readonly input: CreateMembershipCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: CreateMembershipCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CleanRoomsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateMembershipCommandInput, CreateMembershipCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,37 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CleanRoomsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CleanRoomsClient";
+import { DeleteCollaborationInput, DeleteCollaborationOutput } from "../models/models_0";
+export interface DeleteCollaborationCommandInput extends DeleteCollaborationInput {
+}
+export interface DeleteCollaborationCommandOutput extends DeleteCollaborationOutput, __MetadataBearer {
+}
+/**
+ * <p>Deletes a collaboration. It can only be called by the collaboration owner.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CleanRoomsClient, DeleteCollaborationCommand } from "@aws-sdk/client-cleanrooms"; // ES Modules import
+ * // const { CleanRoomsClient, DeleteCollaborationCommand } = require("@aws-sdk/client-cleanrooms"); // CommonJS import
+ * const client = new CleanRoomsClient(config);
+ * const command = new DeleteCollaborationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteCollaborationCommandInput} for command's `input` shape.
+ * @see {@link DeleteCollaborationCommandOutput} for command's `response` shape.
+ * @see {@link CleanRoomsClientResolvedConfig | config} for CleanRoomsClient's `config` shape.
+ *
+ */
+export declare class DeleteCollaborationCommand extends $Command<DeleteCollaborationCommandInput, DeleteCollaborationCommandOutput, CleanRoomsClientResolvedConfig> {
+    readonly input: DeleteCollaborationCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: DeleteCollaborationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CleanRoomsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteCollaborationCommandInput, DeleteCollaborationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,37 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CleanRoomsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CleanRoomsClient";
+import { DeleteConfiguredTableAnalysisRuleInput, DeleteConfiguredTableAnalysisRuleOutput } from "../models/models_0";
+export interface DeleteConfiguredTableAnalysisRuleCommandInput extends DeleteConfiguredTableAnalysisRuleInput {
+}
+export interface DeleteConfiguredTableAnalysisRuleCommandOutput extends DeleteConfiguredTableAnalysisRuleOutput, __MetadataBearer {
+}
+/**
+ * <p>Deletes a configured table analysis rule.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CleanRoomsClient, DeleteConfiguredTableAnalysisRuleCommand } from "@aws-sdk/client-cleanrooms"; // ES Modules import
+ * // const { CleanRoomsClient, DeleteConfiguredTableAnalysisRuleCommand } = require("@aws-sdk/client-cleanrooms"); // CommonJS import
+ * const client = new CleanRoomsClient(config);
+ * const command = new DeleteConfiguredTableAnalysisRuleCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteConfiguredTableAnalysisRuleCommandInput} for command's `input` shape.
+ * @see {@link DeleteConfiguredTableAnalysisRuleCommandOutput} for command's `response` shape.
+ * @see {@link CleanRoomsClientResolvedConfig | config} for CleanRoomsClient's `config` shape.
+ *
+ */
+export declare class DeleteConfiguredTableAnalysisRuleCommand extends $Command<DeleteConfiguredTableAnalysisRuleCommandInput, DeleteConfiguredTableAnalysisRuleCommandOutput, CleanRoomsClientResolvedConfig> {
+    readonly input: DeleteConfiguredTableAnalysisRuleCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: DeleteConfiguredTableAnalysisRuleCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CleanRoomsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteConfiguredTableAnalysisRuleCommandInput, DeleteConfiguredTableAnalysisRuleCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,37 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CleanRoomsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CleanRoomsClient";
+import { DeleteConfiguredTableAssociationInput, DeleteConfiguredTableAssociationOutput } from "../models/models_0";
+export interface DeleteConfiguredTableAssociationCommandInput extends DeleteConfiguredTableAssociationInput {
+}
+export interface DeleteConfiguredTableAssociationCommandOutput extends DeleteConfiguredTableAssociationOutput, __MetadataBearer {
+}
+/**
+ * <p>Deletes a configured table association.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CleanRoomsClient, DeleteConfiguredTableAssociationCommand } from "@aws-sdk/client-cleanrooms"; // ES Modules import
+ * // const { CleanRoomsClient, DeleteConfiguredTableAssociationCommand } = require("@aws-sdk/client-cleanrooms"); // CommonJS import
+ * const client = new CleanRoomsClient(config);
+ * const command = new DeleteConfiguredTableAssociationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteConfiguredTableAssociationCommandInput} for command's `input` shape.
+ * @see {@link DeleteConfiguredTableAssociationCommandOutput} for command's `response` shape.
+ * @see {@link CleanRoomsClientResolvedConfig | config} for CleanRoomsClient's `config` shape.
+ *
+ */
+export declare class DeleteConfiguredTableAssociationCommand extends $Command<DeleteConfiguredTableAssociationCommandInput, DeleteConfiguredTableAssociationCommandOutput, CleanRoomsClientResolvedConfig> {
+    readonly input: DeleteConfiguredTableAssociationCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: DeleteConfiguredTableAssociationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CleanRoomsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteConfiguredTableAssociationCommandInput, DeleteConfiguredTableAssociationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,37 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CleanRoomsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CleanRoomsClient";
+import { DeleteConfiguredTableInput, DeleteConfiguredTableOutput } from "../models/models_0";
+export interface DeleteConfiguredTableCommandInput extends DeleteConfiguredTableInput {
+}
+export interface DeleteConfiguredTableCommandOutput extends DeleteConfiguredTableOutput, __MetadataBearer {
+}
+/**
+ * <p>Deletes a configured table.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CleanRoomsClient, DeleteConfiguredTableCommand } from "@aws-sdk/client-cleanrooms"; // ES Modules import
+ * // const { CleanRoomsClient, DeleteConfiguredTableCommand } = require("@aws-sdk/client-cleanrooms"); // CommonJS import
+ * const client = new CleanRoomsClient(config);
+ * const command = new DeleteConfiguredTableCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteConfiguredTableCommandInput} for command's `input` shape.
+ * @see {@link DeleteConfiguredTableCommandOutput} for command's `response` shape.
+ * @see {@link CleanRoomsClientResolvedConfig | config} for CleanRoomsClient's `config` shape.
+ *
+ */
+export declare class DeleteConfiguredTableCommand extends $Command<DeleteConfiguredTableCommandInput, DeleteConfiguredTableCommandOutput, CleanRoomsClientResolvedConfig> {
+    readonly input: DeleteConfiguredTableCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: DeleteConfiguredTableCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CleanRoomsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteConfiguredTableCommandInput, DeleteConfiguredTableCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,39 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CleanRoomsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CleanRoomsClient";
+import { DeleteMemberInput, DeleteMemberOutput } from "../models/models_0";
+export interface DeleteMemberCommandInput extends DeleteMemberInput {
+}
+export interface DeleteMemberCommandOutput extends DeleteMemberOutput, __MetadataBearer {
+}
+/**
+ * <p>Removes the specified member from a collaboration. The removed member is placed in the
+ *          Removed status and can't interact with the collaboration. The removed member's data is
+ *          inaccessible to active members of the collaboration.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CleanRoomsClient, DeleteMemberCommand } from "@aws-sdk/client-cleanrooms"; // ES Modules import
+ * // const { CleanRoomsClient, DeleteMemberCommand } = require("@aws-sdk/client-cleanrooms"); // CommonJS import
+ * const client = new CleanRoomsClient(config);
+ * const command = new DeleteMemberCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteMemberCommandInput} for command's `input` shape.
+ * @see {@link DeleteMemberCommandOutput} for command's `response` shape.
+ * @see {@link CleanRoomsClientResolvedConfig | config} for CleanRoomsClient's `config` shape.
+ *
+ */
+export declare class DeleteMemberCommand extends $Command<DeleteMemberCommandInput, DeleteMemberCommandOutput, CleanRoomsClientResolvedConfig> {
+    readonly input: DeleteMemberCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: DeleteMemberCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CleanRoomsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteMemberCommandInput, DeleteMemberCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,37 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CleanRoomsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CleanRoomsClient";
+import { DeleteMembershipInput, DeleteMembershipOutput } from "../models/models_0";
+export interface DeleteMembershipCommandInput extends DeleteMembershipInput {
+}
+export interface DeleteMembershipCommandOutput extends DeleteMembershipOutput, __MetadataBearer {
+}
+/**
+ * <p>Deletes a specified membership. All resources under a membership must be deleted.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CleanRoomsClient, DeleteMembershipCommand } from "@aws-sdk/client-cleanrooms"; // ES Modules import
+ * // const { CleanRoomsClient, DeleteMembershipCommand } = require("@aws-sdk/client-cleanrooms"); // CommonJS import
+ * const client = new CleanRoomsClient(config);
+ * const command = new DeleteMembershipCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteMembershipCommandInput} for command's `input` shape.
+ * @see {@link DeleteMembershipCommandOutput} for command's `response` shape.
+ * @see {@link CleanRoomsClientResolvedConfig | config} for CleanRoomsClient's `config` shape.
+ *
+ */
+export declare class DeleteMembershipCommand extends $Command<DeleteMembershipCommandInput, DeleteMembershipCommandOutput, CleanRoomsClientResolvedConfig> {
+    readonly input: DeleteMembershipCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: DeleteMembershipCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CleanRoomsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteMembershipCommandInput, DeleteMembershipCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,37 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CleanRoomsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CleanRoomsClient";
+import { GetCollaborationInput, GetCollaborationOutput } from "../models/models_0";
+export interface GetCollaborationCommandInput extends GetCollaborationInput {
+}
+export interface GetCollaborationCommandOutput extends GetCollaborationOutput, __MetadataBearer {
+}
+/**
+ * <p>Returns metadata about a collaboration.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CleanRoomsClient, GetCollaborationCommand } from "@aws-sdk/client-cleanrooms"; // ES Modules import
+ * // const { CleanRoomsClient, GetCollaborationCommand } = require("@aws-sdk/client-cleanrooms"); // CommonJS import
+ * const client = new CleanRoomsClient(config);
+ * const command = new GetCollaborationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetCollaborationCommandInput} for command's `input` shape.
+ * @see {@link GetCollaborationCommandOutput} for command's `response` shape.
+ * @see {@link CleanRoomsClientResolvedConfig | config} for CleanRoomsClient's `config` shape.
+ *
+ */
+export declare class GetCollaborationCommand extends $Command<GetCollaborationCommandInput, GetCollaborationCommandOutput, CleanRoomsClientResolvedConfig> {
+    readonly input: GetCollaborationCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: GetCollaborationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CleanRoomsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCollaborationCommandInput, GetCollaborationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,37 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CleanRoomsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CleanRoomsClient";
+import { GetConfiguredTableAnalysisRuleInput, GetConfiguredTableAnalysisRuleOutput } from "../models/models_0";
+export interface GetConfiguredTableAnalysisRuleCommandInput extends GetConfiguredTableAnalysisRuleInput {
+}
+export interface GetConfiguredTableAnalysisRuleCommandOutput extends GetConfiguredTableAnalysisRuleOutput, __MetadataBearer {
+}
+/**
+ * <p>Retrieves a configured table analysis rule.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CleanRoomsClient, GetConfiguredTableAnalysisRuleCommand } from "@aws-sdk/client-cleanrooms"; // ES Modules import
+ * // const { CleanRoomsClient, GetConfiguredTableAnalysisRuleCommand } = require("@aws-sdk/client-cleanrooms"); // CommonJS import
+ * const client = new CleanRoomsClient(config);
+ * const command = new GetConfiguredTableAnalysisRuleCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetConfiguredTableAnalysisRuleCommandInput} for command's `input` shape.
+ * @see {@link GetConfiguredTableAnalysisRuleCommandOutput} for command's `response` shape.
+ * @see {@link CleanRoomsClientResolvedConfig | config} for CleanRoomsClient's `config` shape.
+ *
+ */
+export declare class GetConfiguredTableAnalysisRuleCommand extends $Command<GetConfiguredTableAnalysisRuleCommandInput, GetConfiguredTableAnalysisRuleCommandOutput, CleanRoomsClientResolvedConfig> {
+    readonly input: GetConfiguredTableAnalysisRuleCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: GetConfiguredTableAnalysisRuleCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CleanRoomsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetConfiguredTableAnalysisRuleCommandInput, GetConfiguredTableAnalysisRuleCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,37 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CleanRoomsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CleanRoomsClient";
+import { GetConfiguredTableAssociationInput, GetConfiguredTableAssociationOutput } from "../models/models_0";
+export interface GetConfiguredTableAssociationCommandInput extends GetConfiguredTableAssociationInput {
+}
+export interface GetConfiguredTableAssociationCommandOutput extends GetConfiguredTableAssociationOutput, __MetadataBearer {
+}
+/**
+ * <p>Retrieves a configured table association.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CleanRoomsClient, GetConfiguredTableAssociationCommand } from "@aws-sdk/client-cleanrooms"; // ES Modules import
+ * // const { CleanRoomsClient, GetConfiguredTableAssociationCommand } = require("@aws-sdk/client-cleanrooms"); // CommonJS import
+ * const client = new CleanRoomsClient(config);
+ * const command = new GetConfiguredTableAssociationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetConfiguredTableAssociationCommandInput} for command's `input` shape.
+ * @see {@link GetConfiguredTableAssociationCommandOutput} for command's `response` shape.
+ * @see {@link CleanRoomsClientResolvedConfig | config} for CleanRoomsClient's `config` shape.
+ *
+ */
+export declare class GetConfiguredTableAssociationCommand extends $Command<GetConfiguredTableAssociationCommandInput, GetConfiguredTableAssociationCommandOutput, CleanRoomsClientResolvedConfig> {
+    readonly input: GetConfiguredTableAssociationCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: GetConfiguredTableAssociationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CleanRoomsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetConfiguredTableAssociationCommandInput, GetConfiguredTableAssociationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,37 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CleanRoomsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CleanRoomsClient";
+import { GetConfiguredTableInput, GetConfiguredTableOutput } from "../models/models_0";
+export interface GetConfiguredTableCommandInput extends GetConfiguredTableInput {
+}
+export interface GetConfiguredTableCommandOutput extends GetConfiguredTableOutput, __MetadataBearer {
+}
+/**
+ * <p>Retrieves a configured table.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CleanRoomsClient, GetConfiguredTableCommand } from "@aws-sdk/client-cleanrooms"; // ES Modules import
+ * // const { CleanRoomsClient, GetConfiguredTableCommand } = require("@aws-sdk/client-cleanrooms"); // CommonJS import
+ * const client = new CleanRoomsClient(config);
+ * const command = new GetConfiguredTableCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetConfiguredTableCommandInput} for command's `input` shape.
+ * @see {@link GetConfiguredTableCommandOutput} for command's `response` shape.
+ * @see {@link CleanRoomsClientResolvedConfig | config} for CleanRoomsClient's `config` shape.
+ *
+ */
+export declare class GetConfiguredTableCommand extends $Command<GetConfiguredTableCommandInput, GetConfiguredTableCommandOutput, CleanRoomsClientResolvedConfig> {
+    readonly input: GetConfiguredTableCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: GetConfiguredTableCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CleanRoomsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetConfiguredTableCommandInput, GetConfiguredTableCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,37 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CleanRoomsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CleanRoomsClient";
+import { GetMembershipInput, GetMembershipOutput } from "../models/models_0";
+export interface GetMembershipCommandInput extends GetMembershipInput {
+}
+export interface GetMembershipCommandOutput extends GetMembershipOutput, __MetadataBearer {
+}
+/**
+ * <p>Retrieves a specified membership for an identifier.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CleanRoomsClient, GetMembershipCommand } from "@aws-sdk/client-cleanrooms"; // ES Modules import
+ * // const { CleanRoomsClient, GetMembershipCommand } = require("@aws-sdk/client-cleanrooms"); // CommonJS import
+ * const client = new CleanRoomsClient(config);
+ * const command = new GetMembershipCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetMembershipCommandInput} for command's `input` shape.
+ * @see {@link GetMembershipCommandOutput} for command's `response` shape.
+ * @see {@link CleanRoomsClientResolvedConfig | config} for CleanRoomsClient's `config` shape.
+ *
+ */
+export declare class GetMembershipCommand extends $Command<GetMembershipCommandInput, GetMembershipCommandOutput, CleanRoomsClientResolvedConfig> {
+    readonly input: GetMembershipCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: GetMembershipCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CleanRoomsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetMembershipCommandInput, GetMembershipCommandOutput>;
+    private serialize;
+    private deserialize;
+}