@aws-sdk/client-cleanrooms 3.250.0

package/dist-es/commands/BatchGetSchemaCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { BatchGetSchemaInputFilterSensitiveLog, BatchGetSchemaOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1BatchGetSchemaCommand, serializeAws_restJson1BatchGetSchemaCommand, } from "../protocols/Aws_restJson1";
+export class BatchGetSchemaCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, BatchGetSchemaCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CleanRoomsClient";
+        const commandName = "BatchGetSchemaCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: BatchGetSchemaInputFilterSensitiveLog,
+            outputFilterSensitiveLog: BatchGetSchemaOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1BatchGetSchemaCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1BatchGetSchemaCommand(output, context);
+    }
+}

package/dist-es/commands/CreateCollaborationCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateCollaborationInputFilterSensitiveLog, CreateCollaborationOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1CreateCollaborationCommand, serializeAws_restJson1CreateCollaborationCommand, } from "../protocols/Aws_restJson1";
+export class CreateCollaborationCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateCollaborationCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CleanRoomsClient";
+        const commandName = "CreateCollaborationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: CreateCollaborationInputFilterSensitiveLog,
+            outputFilterSensitiveLog: CreateCollaborationOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1CreateCollaborationCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1CreateCollaborationCommand(output, context);
+    }
+}

package/dist-es/commands/CreateConfiguredTableAnalysisRuleCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateConfiguredTableAnalysisRuleInputFilterSensitiveLog, CreateConfiguredTableAnalysisRuleOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1CreateConfiguredTableAnalysisRuleCommand, serializeAws_restJson1CreateConfiguredTableAnalysisRuleCommand, } from "../protocols/Aws_restJson1";
+export class CreateConfiguredTableAnalysisRuleCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateConfiguredTableAnalysisRuleCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CleanRoomsClient";
+        const commandName = "CreateConfiguredTableAnalysisRuleCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: CreateConfiguredTableAnalysisRuleInputFilterSensitiveLog,
+            outputFilterSensitiveLog: CreateConfiguredTableAnalysisRuleOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1CreateConfiguredTableAnalysisRuleCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1CreateConfiguredTableAnalysisRuleCommand(output, context);
+    }
+}

package/dist-es/commands/CreateConfiguredTableAssociationCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateConfiguredTableAssociationInputFilterSensitiveLog, CreateConfiguredTableAssociationOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1CreateConfiguredTableAssociationCommand, serializeAws_restJson1CreateConfiguredTableAssociationCommand, } from "../protocols/Aws_restJson1";
+export class CreateConfiguredTableAssociationCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateConfiguredTableAssociationCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CleanRoomsClient";
+        const commandName = "CreateConfiguredTableAssociationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: CreateConfiguredTableAssociationInputFilterSensitiveLog,
+            outputFilterSensitiveLog: CreateConfiguredTableAssociationOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1CreateConfiguredTableAssociationCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1CreateConfiguredTableAssociationCommand(output, context);
+    }
+}

package/dist-es/commands/CreateConfiguredTableCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateConfiguredTableInputFilterSensitiveLog, CreateConfiguredTableOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1CreateConfiguredTableCommand, serializeAws_restJson1CreateConfiguredTableCommand, } from "../protocols/Aws_restJson1";
+export class CreateConfiguredTableCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateConfiguredTableCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CleanRoomsClient";
+        const commandName = "CreateConfiguredTableCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: CreateConfiguredTableInputFilterSensitiveLog,
+            outputFilterSensitiveLog: CreateConfiguredTableOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1CreateConfiguredTableCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1CreateConfiguredTableCommand(output, context);
+    }
+}

package/dist-es/commands/CreateMembershipCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateMembershipInputFilterSensitiveLog, CreateMembershipOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1CreateMembershipCommand, serializeAws_restJson1CreateMembershipCommand, } from "../protocols/Aws_restJson1";
+export class CreateMembershipCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateMembershipCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CleanRoomsClient";
+        const commandName = "CreateMembershipCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: CreateMembershipInputFilterSensitiveLog,
+            outputFilterSensitiveLog: CreateMembershipOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1CreateMembershipCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1CreateMembershipCommand(output, context);
+    }
+}

package/dist-es/commands/DeleteCollaborationCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteCollaborationInputFilterSensitiveLog, DeleteCollaborationOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1DeleteCollaborationCommand, serializeAws_restJson1DeleteCollaborationCommand, } from "../protocols/Aws_restJson1";
+export class DeleteCollaborationCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteCollaborationCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CleanRoomsClient";
+        const commandName = "DeleteCollaborationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: DeleteCollaborationInputFilterSensitiveLog,
+            outputFilterSensitiveLog: DeleteCollaborationOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1DeleteCollaborationCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1DeleteCollaborationCommand(output, context);
+    }
+}

package/dist-es/commands/DeleteConfiguredTableAnalysisRuleCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteConfiguredTableAnalysisRuleInputFilterSensitiveLog, DeleteConfiguredTableAnalysisRuleOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1DeleteConfiguredTableAnalysisRuleCommand, serializeAws_restJson1DeleteConfiguredTableAnalysisRuleCommand, } from "../protocols/Aws_restJson1";
+export class DeleteConfiguredTableAnalysisRuleCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteConfiguredTableAnalysisRuleCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CleanRoomsClient";
+        const commandName = "DeleteConfiguredTableAnalysisRuleCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: DeleteConfiguredTableAnalysisRuleInputFilterSensitiveLog,
+            outputFilterSensitiveLog: DeleteConfiguredTableAnalysisRuleOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1DeleteConfiguredTableAnalysisRuleCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1DeleteConfiguredTableAnalysisRuleCommand(output, context);
+    }
+}

package/dist-es/commands/DeleteConfiguredTableAssociationCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteConfiguredTableAssociationInputFilterSensitiveLog, DeleteConfiguredTableAssociationOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1DeleteConfiguredTableAssociationCommand, serializeAws_restJson1DeleteConfiguredTableAssociationCommand, } from "../protocols/Aws_restJson1";
+export class DeleteConfiguredTableAssociationCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteConfiguredTableAssociationCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CleanRoomsClient";
+        const commandName = "DeleteConfiguredTableAssociationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: DeleteConfiguredTableAssociationInputFilterSensitiveLog,
+            outputFilterSensitiveLog: DeleteConfiguredTableAssociationOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1DeleteConfiguredTableAssociationCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1DeleteConfiguredTableAssociationCommand(output, context);
+    }
+}

package/dist-es/commands/DeleteConfiguredTableCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteConfiguredTableInputFilterSensitiveLog, DeleteConfiguredTableOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1DeleteConfiguredTableCommand, serializeAws_restJson1DeleteConfiguredTableCommand, } from "../protocols/Aws_restJson1";
+export class DeleteConfiguredTableCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteConfiguredTableCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CleanRoomsClient";
+        const commandName = "DeleteConfiguredTableCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: DeleteConfiguredTableInputFilterSensitiveLog,
+            outputFilterSensitiveLog: DeleteConfiguredTableOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1DeleteConfiguredTableCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1DeleteConfiguredTableCommand(output, context);
+    }
+}

package/dist-es/commands/DeleteMemberCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteMemberInputFilterSensitiveLog, DeleteMemberOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1DeleteMemberCommand, serializeAws_restJson1DeleteMemberCommand, } from "../protocols/Aws_restJson1";
+export class DeleteMemberCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteMemberCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CleanRoomsClient";
+        const commandName = "DeleteMemberCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: DeleteMemberInputFilterSensitiveLog,
+            outputFilterSensitiveLog: DeleteMemberOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1DeleteMemberCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1DeleteMemberCommand(output, context);
+    }
+}

package/dist-es/commands/DeleteMembershipCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteMembershipInputFilterSensitiveLog, DeleteMembershipOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1DeleteMembershipCommand, serializeAws_restJson1DeleteMembershipCommand, } from "../protocols/Aws_restJson1";
+export class DeleteMembershipCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteMembershipCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CleanRoomsClient";
+        const commandName = "DeleteMembershipCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: DeleteMembershipInputFilterSensitiveLog,
+            outputFilterSensitiveLog: DeleteMembershipOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1DeleteMembershipCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1DeleteMembershipCommand(output, context);
+    }
+}

package/dist-es/commands/GetCollaborationCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetCollaborationInputFilterSensitiveLog, GetCollaborationOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1GetCollaborationCommand, serializeAws_restJson1GetCollaborationCommand, } from "../protocols/Aws_restJson1";
+export class GetCollaborationCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetCollaborationCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CleanRoomsClient";
+        const commandName = "GetCollaborationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: GetCollaborationInputFilterSensitiveLog,
+            outputFilterSensitiveLog: GetCollaborationOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1GetCollaborationCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1GetCollaborationCommand(output, context);
+    }
+}

package/dist-es/commands/GetConfiguredTableAnalysisRuleCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetConfiguredTableAnalysisRuleInputFilterSensitiveLog, GetConfiguredTableAnalysisRuleOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1GetConfiguredTableAnalysisRuleCommand, serializeAws_restJson1GetConfiguredTableAnalysisRuleCommand, } from "../protocols/Aws_restJson1";
+export class GetConfiguredTableAnalysisRuleCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetConfiguredTableAnalysisRuleCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CleanRoomsClient";
+        const commandName = "GetConfiguredTableAnalysisRuleCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: GetConfiguredTableAnalysisRuleInputFilterSensitiveLog,
+            outputFilterSensitiveLog: GetConfiguredTableAnalysisRuleOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1GetConfiguredTableAnalysisRuleCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1GetConfiguredTableAnalysisRuleCommand(output, context);
+    }
+}

package/dist-es/commands/GetConfiguredTableAssociationCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetConfiguredTableAssociationInputFilterSensitiveLog, GetConfiguredTableAssociationOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1GetConfiguredTableAssociationCommand, serializeAws_restJson1GetConfiguredTableAssociationCommand, } from "../protocols/Aws_restJson1";
+export class GetConfiguredTableAssociationCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetConfiguredTableAssociationCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CleanRoomsClient";
+        const commandName = "GetConfiguredTableAssociationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: GetConfiguredTableAssociationInputFilterSensitiveLog,
+            outputFilterSensitiveLog: GetConfiguredTableAssociationOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1GetConfiguredTableAssociationCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1GetConfiguredTableAssociationCommand(output, context);
+    }
+}