@aws-sdk/client-cleanrooms 3.250.0

package/dist-es/commands/GetConfiguredTableCommand.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 { GetConfiguredTableInputFilterSensitiveLog, GetConfiguredTableOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1GetConfiguredTableCommand, serializeAws_restJson1GetConfiguredTableCommand, } from "../protocols/Aws_restJson1";
+export class GetConfiguredTableCommand 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, GetConfiguredTableCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CleanRoomsClient";
+        const commandName = "GetConfiguredTableCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: GetConfiguredTableInputFilterSensitiveLog,
+            outputFilterSensitiveLog: GetConfiguredTableOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1GetConfiguredTableCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1GetConfiguredTableCommand(output, context);
+    }
+}

package/dist-es/commands/GetMembershipCommand.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 { GetMembershipInputFilterSensitiveLog, GetMembershipOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1GetMembershipCommand, serializeAws_restJson1GetMembershipCommand, } from "../protocols/Aws_restJson1";
+export class GetMembershipCommand 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, GetMembershipCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CleanRoomsClient";
+        const commandName = "GetMembershipCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: GetMembershipInputFilterSensitiveLog,
+            outputFilterSensitiveLog: GetMembershipOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1GetMembershipCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1GetMembershipCommand(output, context);
+    }
+}

package/dist-es/commands/GetProtectedQueryCommand.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 { GetProtectedQueryInputFilterSensitiveLog, GetProtectedQueryOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1GetProtectedQueryCommand, serializeAws_restJson1GetProtectedQueryCommand, } from "../protocols/Aws_restJson1";
+export class GetProtectedQueryCommand 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, GetProtectedQueryCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CleanRoomsClient";
+        const commandName = "GetProtectedQueryCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: GetProtectedQueryInputFilterSensitiveLog,
+            outputFilterSensitiveLog: GetProtectedQueryOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1GetProtectedQueryCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1GetProtectedQueryCommand(output, context);
+    }
+}

package/dist-es/commands/GetSchemaAnalysisRuleCommand.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 { GetSchemaAnalysisRuleInputFilterSensitiveLog, GetSchemaAnalysisRuleOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1GetSchemaAnalysisRuleCommand, serializeAws_restJson1GetSchemaAnalysisRuleCommand, } from "../protocols/Aws_restJson1";
+export class GetSchemaAnalysisRuleCommand 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, GetSchemaAnalysisRuleCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CleanRoomsClient";
+        const commandName = "GetSchemaAnalysisRuleCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: GetSchemaAnalysisRuleInputFilterSensitiveLog,
+            outputFilterSensitiveLog: GetSchemaAnalysisRuleOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1GetSchemaAnalysisRuleCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1GetSchemaAnalysisRuleCommand(output, context);
+    }
+}

package/dist-es/commands/GetSchemaCommand.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 { GetSchemaInputFilterSensitiveLog, GetSchemaOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1GetSchemaCommand, serializeAws_restJson1GetSchemaCommand, } from "../protocols/Aws_restJson1";
+export class GetSchemaCommand 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, GetSchemaCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CleanRoomsClient";
+        const commandName = "GetSchemaCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: GetSchemaInputFilterSensitiveLog,
+            outputFilterSensitiveLog: GetSchemaOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1GetSchemaCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1GetSchemaCommand(output, context);
+    }
+}

package/dist-es/commands/ListCollaborationsCommand.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 { ListCollaborationsInputFilterSensitiveLog, ListCollaborationsOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ListCollaborationsCommand, serializeAws_restJson1ListCollaborationsCommand, } from "../protocols/Aws_restJson1";
+export class ListCollaborationsCommand 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, ListCollaborationsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CleanRoomsClient";
+        const commandName = "ListCollaborationsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListCollaborationsInputFilterSensitiveLog,
+            outputFilterSensitiveLog: ListCollaborationsOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ListCollaborationsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ListCollaborationsCommand(output, context);
+    }
+}

package/dist-es/commands/ListConfiguredTableAssociationsCommand.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 { ListConfiguredTableAssociationsInputFilterSensitiveLog, ListConfiguredTableAssociationsOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ListConfiguredTableAssociationsCommand, serializeAws_restJson1ListConfiguredTableAssociationsCommand, } from "../protocols/Aws_restJson1";
+export class ListConfiguredTableAssociationsCommand 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, ListConfiguredTableAssociationsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CleanRoomsClient";
+        const commandName = "ListConfiguredTableAssociationsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListConfiguredTableAssociationsInputFilterSensitiveLog,
+            outputFilterSensitiveLog: ListConfiguredTableAssociationsOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ListConfiguredTableAssociationsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ListConfiguredTableAssociationsCommand(output, context);
+    }
+}

package/dist-es/commands/ListConfiguredTablesCommand.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 { ListConfiguredTablesInputFilterSensitiveLog, ListConfiguredTablesOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ListConfiguredTablesCommand, serializeAws_restJson1ListConfiguredTablesCommand, } from "../protocols/Aws_restJson1";
+export class ListConfiguredTablesCommand 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, ListConfiguredTablesCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CleanRoomsClient";
+        const commandName = "ListConfiguredTablesCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListConfiguredTablesInputFilterSensitiveLog,
+            outputFilterSensitiveLog: ListConfiguredTablesOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ListConfiguredTablesCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ListConfiguredTablesCommand(output, context);
+    }
+}

package/dist-es/commands/ListMembersCommand.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 { ListMembersInputFilterSensitiveLog, ListMembersOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ListMembersCommand, serializeAws_restJson1ListMembersCommand, } from "../protocols/Aws_restJson1";
+export class ListMembersCommand 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, ListMembersCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CleanRoomsClient";
+        const commandName = "ListMembersCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListMembersInputFilterSensitiveLog,
+            outputFilterSensitiveLog: ListMembersOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ListMembersCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ListMembersCommand(output, context);
+    }
+}

package/dist-es/commands/ListMembershipsCommand.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 { ListMembershipsInputFilterSensitiveLog, ListMembershipsOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ListMembershipsCommand, serializeAws_restJson1ListMembershipsCommand, } from "../protocols/Aws_restJson1";
+export class ListMembershipsCommand 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, ListMembershipsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CleanRoomsClient";
+        const commandName = "ListMembershipsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListMembershipsInputFilterSensitiveLog,
+            outputFilterSensitiveLog: ListMembershipsOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ListMembershipsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ListMembershipsCommand(output, context);
+    }
+}

package/dist-es/commands/ListProtectedQueriesCommand.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 { ListProtectedQueriesInputFilterSensitiveLog, ListProtectedQueriesOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ListProtectedQueriesCommand, serializeAws_restJson1ListProtectedQueriesCommand, } from "../protocols/Aws_restJson1";
+export class ListProtectedQueriesCommand 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, ListProtectedQueriesCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CleanRoomsClient";
+        const commandName = "ListProtectedQueriesCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListProtectedQueriesInputFilterSensitiveLog,
+            outputFilterSensitiveLog: ListProtectedQueriesOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ListProtectedQueriesCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ListProtectedQueriesCommand(output, context);
+    }
+}

package/dist-es/commands/ListSchemasCommand.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 { ListSchemasInputFilterSensitiveLog, ListSchemasOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ListSchemasCommand, serializeAws_restJson1ListSchemasCommand, } from "../protocols/Aws_restJson1";
+export class ListSchemasCommand 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, ListSchemasCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CleanRoomsClient";
+        const commandName = "ListSchemasCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListSchemasInputFilterSensitiveLog,
+            outputFilterSensitiveLog: ListSchemasOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ListSchemasCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ListSchemasCommand(output, context);
+    }
+}

package/dist-es/commands/StartProtectedQueryCommand.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 { StartProtectedQueryInputFilterSensitiveLog, StartProtectedQueryOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1StartProtectedQueryCommand, serializeAws_restJson1StartProtectedQueryCommand, } from "../protocols/Aws_restJson1";
+export class StartProtectedQueryCommand 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, StartProtectedQueryCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CleanRoomsClient";
+        const commandName = "StartProtectedQueryCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: StartProtectedQueryInputFilterSensitiveLog,
+            outputFilterSensitiveLog: StartProtectedQueryOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1StartProtectedQueryCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1StartProtectedQueryCommand(output, context);
+    }
+}

package/dist-es/commands/UpdateCollaborationCommand.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 { UpdateCollaborationInputFilterSensitiveLog, UpdateCollaborationOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1UpdateCollaborationCommand, serializeAws_restJson1UpdateCollaborationCommand, } from "../protocols/Aws_restJson1";
+export class UpdateCollaborationCommand 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, UpdateCollaborationCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CleanRoomsClient";
+        const commandName = "UpdateCollaborationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: UpdateCollaborationInputFilterSensitiveLog,
+            outputFilterSensitiveLog: UpdateCollaborationOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1UpdateCollaborationCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1UpdateCollaborationCommand(output, context);
+    }
+}

package/dist-es/commands/UpdateConfiguredTableAnalysisRuleCommand.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 { UpdateConfiguredTableAnalysisRuleInputFilterSensitiveLog, UpdateConfiguredTableAnalysisRuleOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1UpdateConfiguredTableAnalysisRuleCommand, serializeAws_restJson1UpdateConfiguredTableAnalysisRuleCommand, } from "../protocols/Aws_restJson1";
+export class UpdateConfiguredTableAnalysisRuleCommand 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, UpdateConfiguredTableAnalysisRuleCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CleanRoomsClient";
+        const commandName = "UpdateConfiguredTableAnalysisRuleCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: UpdateConfiguredTableAnalysisRuleInputFilterSensitiveLog,
+            outputFilterSensitiveLog: UpdateConfiguredTableAnalysisRuleOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1UpdateConfiguredTableAnalysisRuleCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1UpdateConfiguredTableAnalysisRuleCommand(output, context);
+    }
+}