@aws-sdk/client-cleanrooms 3.295.0 → 3.297.0

package/dist-es/protocols/Aws_restJson1.js

@@ -43,6 +43,7 @@ export const serializeAws_restJson1CreateCollaborationCommand = async (input, co
         ...(input.members != null && { members: serializeAws_restJson1MemberList(input.members, context) }),
         ...(input.name != null && { name: input.name }),
         ...(input.queryLogStatus != null && { queryLogStatus: input.queryLogStatus }),
+        ...(input.tags != null && { tags: serializeAws_restJson1TagMap(input.tags, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -71,6 +72,7 @@ export const serializeAws_restJson1CreateConfiguredTableCommand = async (input,
         ...(input.tableReference != null && {
             tableReference: serializeAws_restJson1TableReference(input.tableReference, context),
         }),
+        ...(input.tags != null && { tags: serializeAws_restJson1TagMap(input.tags, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -121,6 +123,7 @@ export const serializeAws_restJson1CreateConfiguredTableAssociationCommand = asy
         ...(input.description != null && { description: input.description }),
         ...(input.name != null && { name: input.name }),
         ...(input.roleArn != null && { roleArn: input.roleArn }),
+        ...(input.tags != null && { tags: serializeAws_restJson1TagMap(input.tags, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -142,6 +145,7 @@ export const serializeAws_restJson1CreateMembershipCommand = async (input, conte
     body = JSON.stringify({
         ...(input.collaborationIdentifier != null && { collaborationIdentifier: input.collaborationIdentifier }),
         ...(input.queryLogStatus != null && { queryLogStatus: input.queryLogStatus }),
+        ...(input.tags != null && { tags: serializeAws_restJson1TagMap(input.tags, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -548,6 +552,22 @@ export const serializeAws_restJson1ListSchemasCommand = async (input, context) =
         body,
     });
 };
+export const serializeAws_restJson1ListTagsForResourceCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const serializeAws_restJson1StartProtectedQueryCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
@@ -576,6 +596,50 @@ export const serializeAws_restJson1StartProtectedQueryCommand = async (input, co
         body,
     });
 };
+export const serializeAws_restJson1TagResourceCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
+    let body;
+    body = JSON.stringify({
+        ...(input.tags != null && { tags: serializeAws_restJson1TagMap(input.tags, context) }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1UntagResourceCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
+    const query = map({
+        tagKeys: [
+            __expectNonNull(input.tagKeys, `tagKeys`) != null,
+            () => (input.tagKeys || []).map((_entry) => _entry),
+        ],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
 export const serializeAws_restJson1UpdateCollaborationCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
@@ -1703,6 +1767,9 @@ const deserializeAws_restJson1ListConfiguredTableAssociationsCommandError = asyn
         case "InternalServerException":
         case "com.amazonaws.cleanrooms#InternalServerException":
             throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.cleanrooms#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.cleanrooms#ThrottlingException":
             throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
@@ -1886,6 +1953,9 @@ const deserializeAws_restJson1ListProtectedQueriesCommandError = async (output,
         case "InternalServerException":
         case "com.amazonaws.cleanrooms#InternalServerException":
             throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.cleanrooms#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.cleanrooms#ThrottlingException":
             throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
@@ -1950,6 +2020,42 @@ const deserializeAws_restJson1ListSchemasCommandError = async (output, context)
             });
     }
 };
+export const deserializeAws_restJson1ListTagsForResourceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ListTagsForResourceCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.tags != null) {
+        contents.tags = deserializeAws_restJson1TagMap(data.tags, context);
+    }
+    return contents;
+};
+const deserializeAws_restJson1ListTagsForResourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ResourceNotFoundException":
+        case "com.amazonaws.cleanrooms#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.cleanrooms#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
 export const deserializeAws_restJson1StartProtectedQueryCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1StartProtectedQueryCommandError(output, context);
@@ -1998,6 +2104,72 @@ const deserializeAws_restJson1StartProtectedQueryCommandError = async (output, c
             });
     }
 };
+export const deserializeAws_restJson1TagResourceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1TagResourceCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const deserializeAws_restJson1TagResourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ResourceNotFoundException":
+        case "com.amazonaws.cleanrooms#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.cleanrooms#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1UntagResourceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1UntagResourceCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const deserializeAws_restJson1UntagResourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ResourceNotFoundException":
+        case "com.amazonaws.cleanrooms#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.cleanrooms#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
 export const deserializeAws_restJson1UpdateCollaborationCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1UpdateCollaborationCommandError(output, context);
@@ -2572,6 +2744,15 @@ const serializeAws_restJson1TableReference = (input, context) => {
         _: (name, value) => ({ name: value }),
     });
 };
+const serializeAws_restJson1TagMap = (input, context) => {
+    return Object.entries(input).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        acc[key] = value;
+        return acc;
+    }, {});
+};
 const deserializeAws_restJson1AggregateColumn = (output, context) => {
     return {
         columnNames: output.columnNames != null
@@ -3187,6 +3368,15 @@ const deserializeAws_restJson1TableReference = (output, context) => {
     }
     return { $unknown: Object.entries(output)[0] };
 };
+const deserializeAws_restJson1TagMap = (output, context) => {
+    return Object.entries(output).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        acc[key] = __expectString(value);
+        return acc;
+    }, {});
+};
 const deserializeAws_restJson1ValidationExceptionField = (output, context) => {
     return {
         message: __expectString(output.message),

package/dist-types/CleanRooms.d.ts

@@ -27,7 +27,10 @@ import { ListMembersCommandInput, ListMembersCommandOutput } from "./commands/Li
 import { ListMembershipsCommandInput, ListMembershipsCommandOutput } from "./commands/ListMembershipsCommand";
 import { ListProtectedQueriesCommandInput, ListProtectedQueriesCommandOutput } from "./commands/ListProtectedQueriesCommand";
 import { ListSchemasCommandInput, ListSchemasCommandOutput } from "./commands/ListSchemasCommand";
+import { ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput } from "./commands/ListTagsForResourceCommand";
 import { StartProtectedQueryCommandInput, StartProtectedQueryCommandOutput } from "./commands/StartProtectedQueryCommand";
+import { TagResourceCommandInput, TagResourceCommandOutput } from "./commands/TagResourceCommand";
+import { UntagResourceCommandInput, UntagResourceCommandOutput } from "./commands/UntagResourceCommand";
 import { UpdateCollaborationCommandInput, UpdateCollaborationCommandOutput } from "./commands/UpdateCollaborationCommand";
 import { UpdateConfiguredTableAnalysisRuleCommandInput, UpdateConfiguredTableAnalysisRuleCommandOutput } from "./commands/UpdateConfiguredTableAnalysisRuleCommand";
 import { UpdateConfiguredTableAssociationCommandInput, UpdateConfiguredTableAssociationCommandOutput } from "./commands/UpdateConfiguredTableAssociationCommand";
@@ -35,13 +38,11 @@ import { UpdateConfiguredTableCommandInput, UpdateConfiguredTableCommandOutput }
 import { UpdateMembershipCommandInput, UpdateMembershipCommandOutput } from "./commands/UpdateMembershipCommand";
 import { UpdateProtectedQueryCommandInput, UpdateProtectedQueryCommandOutput } from "./commands/UpdateProtectedQueryCommand";
 /**
- * <note>
- *             <p>AWS Clean Rooms is in preview release and is subject to change.</p>
- *          </note>
- *          <p>Welcome to the <i>AWS Clean Rooms API Reference</i>.</p>
+ * @public
+ * <p>Welcome to the <i>AWS Clean Rooms API Reference</i>.</p>
  *          <p>AWS Clean Rooms is an AWS service that helps multiple parties to join their data
  *          together in a secure collaboration workspace. In the collaboration, members who can query
- *          and receive results can get insights into the combined data without either party getting
+ *          and receive results can get insights into the collective datasets without either party getting
  *          access to the other party's raw data.</p>
  *          <p>To learn more about AWS Clean Rooms concepts, procedures, and best practices, see the
  *             <a href="https://docs.aws.amazon.com/clean-rooms/latest/userguide/what-is.html">AWS Clean
@@ -49,24 +50,28 @@ import { UpdateProtectedQueryCommandInput, UpdateProtectedQueryCommandOutput } f
  */
 export declare class CleanRooms extends CleanRoomsClient {
     /**
+     * @public
      * <p>Retrieves multiple schemas by their identifiers.</p>
      */
     batchGetSchema(args: BatchGetSchemaCommandInput, options?: __HttpHandlerOptions): Promise<BatchGetSchemaCommandOutput>;
     batchGetSchema(args: BatchGetSchemaCommandInput, cb: (err: any, data?: BatchGetSchemaCommandOutput) => void): void;
     batchGetSchema(args: BatchGetSchemaCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: BatchGetSchemaCommandOutput) => void): void;
     /**
+     * @public
      * <p>Creates a new collaboration.</p>
      */
     createCollaboration(args: CreateCollaborationCommandInput, options?: __HttpHandlerOptions): Promise<CreateCollaborationCommandOutput>;
     createCollaboration(args: CreateCollaborationCommandInput, cb: (err: any, data?: CreateCollaborationCommandOutput) => void): void;
     createCollaboration(args: CreateCollaborationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateCollaborationCommandOutput) => void): void;
     /**
+     * @public
      * <p>Creates a new configured table resource.</p>
      */
     createConfiguredTable(args: CreateConfiguredTableCommandInput, options?: __HttpHandlerOptions): Promise<CreateConfiguredTableCommandOutput>;
     createConfiguredTable(args: CreateConfiguredTableCommandInput, cb: (err: any, data?: CreateConfiguredTableCommandOutput) => void): void;
     createConfiguredTable(args: CreateConfiguredTableCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateConfiguredTableCommandOutput) => void): void;
     /**
+     * @public
      * <p>Creates a new analysis rule for a configured table. Currently, only one analysis rule
      *          can be created for a given configured table.</p>
      */
@@ -74,6 +79,7 @@ export declare class CleanRooms extends CleanRoomsClient {
     createConfiguredTableAnalysisRule(args: CreateConfiguredTableAnalysisRuleCommandInput, cb: (err: any, data?: CreateConfiguredTableAnalysisRuleCommandOutput) => void): void;
     createConfiguredTableAnalysisRule(args: CreateConfiguredTableAnalysisRuleCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateConfiguredTableAnalysisRuleCommandOutput) => void): void;
     /**
+     * @public
      * <p>Creates a configured table association. A configured table association links a
      *          configured table with a collaboration.</p>
      */
@@ -81,6 +87,7 @@ export declare class CleanRooms extends CleanRoomsClient {
     createConfiguredTableAssociation(args: CreateConfiguredTableAssociationCommandInput, cb: (err: any, data?: CreateConfiguredTableAssociationCommandOutput) => void): void;
     createConfiguredTableAssociation(args: CreateConfiguredTableAssociationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateConfiguredTableAssociationCommandOutput) => void): void;
     /**
+     * @public
      * <p>Creates a membership for a specific collaboration identifier and joins the
      *          collaboration.</p>
      */
@@ -88,30 +95,35 @@ export declare class CleanRooms extends CleanRoomsClient {
     createMembership(args: CreateMembershipCommandInput, cb: (err: any, data?: CreateMembershipCommandOutput) => void): void;
     createMembership(args: CreateMembershipCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateMembershipCommandOutput) => void): void;
     /**
+     * @public
      * <p>Deletes a collaboration. It can only be called by the collaboration owner.</p>
      */
     deleteCollaboration(args: DeleteCollaborationCommandInput, options?: __HttpHandlerOptions): Promise<DeleteCollaborationCommandOutput>;
     deleteCollaboration(args: DeleteCollaborationCommandInput, cb: (err: any, data?: DeleteCollaborationCommandOutput) => void): void;
     deleteCollaboration(args: DeleteCollaborationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteCollaborationCommandOutput) => void): void;
     /**
+     * @public
      * <p>Deletes a configured table.</p>
      */
     deleteConfiguredTable(args: DeleteConfiguredTableCommandInput, options?: __HttpHandlerOptions): Promise<DeleteConfiguredTableCommandOutput>;
     deleteConfiguredTable(args: DeleteConfiguredTableCommandInput, cb: (err: any, data?: DeleteConfiguredTableCommandOutput) => void): void;
     deleteConfiguredTable(args: DeleteConfiguredTableCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteConfiguredTableCommandOutput) => void): void;
     /**
+     * @public
      * <p>Deletes a configured table analysis rule.</p>
      */
     deleteConfiguredTableAnalysisRule(args: DeleteConfiguredTableAnalysisRuleCommandInput, options?: __HttpHandlerOptions): Promise<DeleteConfiguredTableAnalysisRuleCommandOutput>;
     deleteConfiguredTableAnalysisRule(args: DeleteConfiguredTableAnalysisRuleCommandInput, cb: (err: any, data?: DeleteConfiguredTableAnalysisRuleCommandOutput) => void): void;
     deleteConfiguredTableAnalysisRule(args: DeleteConfiguredTableAnalysisRuleCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteConfiguredTableAnalysisRuleCommandOutput) => void): void;
     /**
+     * @public
      * <p>Deletes a configured table association.</p>
      */
     deleteConfiguredTableAssociation(args: DeleteConfiguredTableAssociationCommandInput, options?: __HttpHandlerOptions): Promise<DeleteConfiguredTableAssociationCommandOutput>;
     deleteConfiguredTableAssociation(args: DeleteConfiguredTableAssociationCommandInput, cb: (err: any, data?: DeleteConfiguredTableAssociationCommandOutput) => void): void;
     deleteConfiguredTableAssociation(args: DeleteConfiguredTableAssociationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteConfiguredTableAssociationCommandOutput) => void): void;
     /**
+     * @public
      * <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>
@@ -120,138 +132,182 @@ export declare class CleanRooms extends CleanRoomsClient {
     deleteMember(args: DeleteMemberCommandInput, cb: (err: any, data?: DeleteMemberCommandOutput) => void): void;
     deleteMember(args: DeleteMemberCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteMemberCommandOutput) => void): void;
     /**
+     * @public
      * <p>Deletes a specified membership. All resources under a membership must be deleted.</p>
      */
     deleteMembership(args: DeleteMembershipCommandInput, options?: __HttpHandlerOptions): Promise<DeleteMembershipCommandOutput>;
     deleteMembership(args: DeleteMembershipCommandInput, cb: (err: any, data?: DeleteMembershipCommandOutput) => void): void;
     deleteMembership(args: DeleteMembershipCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteMembershipCommandOutput) => void): void;
     /**
+     * @public
      * <p>Returns metadata about a collaboration.</p>
      */
     getCollaboration(args: GetCollaborationCommandInput, options?: __HttpHandlerOptions): Promise<GetCollaborationCommandOutput>;
     getCollaboration(args: GetCollaborationCommandInput, cb: (err: any, data?: GetCollaborationCommandOutput) => void): void;
     getCollaboration(args: GetCollaborationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetCollaborationCommandOutput) => void): void;
     /**
+     * @public
      * <p>Retrieves a configured table.</p>
      */
     getConfiguredTable(args: GetConfiguredTableCommandInput, options?: __HttpHandlerOptions): Promise<GetConfiguredTableCommandOutput>;
     getConfiguredTable(args: GetConfiguredTableCommandInput, cb: (err: any, data?: GetConfiguredTableCommandOutput) => void): void;
     getConfiguredTable(args: GetConfiguredTableCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetConfiguredTableCommandOutput) => void): void;
     /**
+     * @public
      * <p>Retrieves a configured table analysis rule.</p>
      */
     getConfiguredTableAnalysisRule(args: GetConfiguredTableAnalysisRuleCommandInput, options?: __HttpHandlerOptions): Promise<GetConfiguredTableAnalysisRuleCommandOutput>;
     getConfiguredTableAnalysisRule(args: GetConfiguredTableAnalysisRuleCommandInput, cb: (err: any, data?: GetConfiguredTableAnalysisRuleCommandOutput) => void): void;
     getConfiguredTableAnalysisRule(args: GetConfiguredTableAnalysisRuleCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetConfiguredTableAnalysisRuleCommandOutput) => void): void;
     /**
+     * @public
      * <p>Retrieves a configured table association.</p>
      */
     getConfiguredTableAssociation(args: GetConfiguredTableAssociationCommandInput, options?: __HttpHandlerOptions): Promise<GetConfiguredTableAssociationCommandOutput>;
     getConfiguredTableAssociation(args: GetConfiguredTableAssociationCommandInput, cb: (err: any, data?: GetConfiguredTableAssociationCommandOutput) => void): void;
     getConfiguredTableAssociation(args: GetConfiguredTableAssociationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetConfiguredTableAssociationCommandOutput) => void): void;
     /**
+     * @public
      * <p>Retrieves a specified membership for an identifier.</p>
      */
     getMembership(args: GetMembershipCommandInput, options?: __HttpHandlerOptions): Promise<GetMembershipCommandOutput>;
     getMembership(args: GetMembershipCommandInput, cb: (err: any, data?: GetMembershipCommandOutput) => void): void;
     getMembership(args: GetMembershipCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetMembershipCommandOutput) => void): void;
     /**
+     * @public
      * <p>Returns query processing metadata.</p>
      */
     getProtectedQuery(args: GetProtectedQueryCommandInput, options?: __HttpHandlerOptions): Promise<GetProtectedQueryCommandOutput>;
     getProtectedQuery(args: GetProtectedQueryCommandInput, cb: (err: any, data?: GetProtectedQueryCommandOutput) => void): void;
     getProtectedQuery(args: GetProtectedQueryCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetProtectedQueryCommandOutput) => void): void;
     /**
+     * @public
      * <p>Retrieves the schema for a relation within a collaboration.</p>
      */
     getSchema(args: GetSchemaCommandInput, options?: __HttpHandlerOptions): Promise<GetSchemaCommandOutput>;
     getSchema(args: GetSchemaCommandInput, cb: (err: any, data?: GetSchemaCommandOutput) => void): void;
     getSchema(args: GetSchemaCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetSchemaCommandOutput) => void): void;
     /**
+     * @public
      * <p>Retrieves a schema analysis rule.</p>
      */
     getSchemaAnalysisRule(args: GetSchemaAnalysisRuleCommandInput, options?: __HttpHandlerOptions): Promise<GetSchemaAnalysisRuleCommandOutput>;
     getSchemaAnalysisRule(args: GetSchemaAnalysisRuleCommandInput, cb: (err: any, data?: GetSchemaAnalysisRuleCommandOutput) => void): void;
     getSchemaAnalysisRule(args: GetSchemaAnalysisRuleCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetSchemaAnalysisRuleCommandOutput) => void): void;
     /**
+     * @public
      * <p>Lists collaborations the caller owns, is active in, or has been invited to.</p>
      */
     listCollaborations(args: ListCollaborationsCommandInput, options?: __HttpHandlerOptions): Promise<ListCollaborationsCommandOutput>;
     listCollaborations(args: ListCollaborationsCommandInput, cb: (err: any, data?: ListCollaborationsCommandOutput) => void): void;
     listCollaborations(args: ListCollaborationsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListCollaborationsCommandOutput) => void): void;
     /**
+     * @public
      * <p>Lists configured table associations for a membership.</p>
      */
     listConfiguredTableAssociations(args: ListConfiguredTableAssociationsCommandInput, options?: __HttpHandlerOptions): Promise<ListConfiguredTableAssociationsCommandOutput>;
     listConfiguredTableAssociations(args: ListConfiguredTableAssociationsCommandInput, cb: (err: any, data?: ListConfiguredTableAssociationsCommandOutput) => void): void;
     listConfiguredTableAssociations(args: ListConfiguredTableAssociationsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListConfiguredTableAssociationsCommandOutput) => void): void;
     /**
+     * @public
      * <p>Lists configured tables.</p>
      */
     listConfiguredTables(args: ListConfiguredTablesCommandInput, options?: __HttpHandlerOptions): Promise<ListConfiguredTablesCommandOutput>;
     listConfiguredTables(args: ListConfiguredTablesCommandInput, cb: (err: any, data?: ListConfiguredTablesCommandOutput) => void): void;
     listConfiguredTables(args: ListConfiguredTablesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListConfiguredTablesCommandOutput) => void): void;
     /**
+     * @public
      * <p>Lists all members within a collaboration.</p>
      */
     listMembers(args: ListMembersCommandInput, options?: __HttpHandlerOptions): Promise<ListMembersCommandOutput>;
     listMembers(args: ListMembersCommandInput, cb: (err: any, data?: ListMembersCommandOutput) => void): void;
     listMembers(args: ListMembersCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListMembersCommandOutput) => void): void;
     /**
+     * @public
      * <p>Lists all memberships resources within the caller's account.</p>
      */
     listMemberships(args: ListMembershipsCommandInput, options?: __HttpHandlerOptions): Promise<ListMembershipsCommandOutput>;
     listMemberships(args: ListMembershipsCommandInput, cb: (err: any, data?: ListMembershipsCommandOutput) => void): void;
     listMemberships(args: ListMembershipsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListMembershipsCommandOutput) => void): void;
     /**
+     * @public
      * <p>Lists protected queries, sorted by the most recent query.</p>
      */
     listProtectedQueries(args: ListProtectedQueriesCommandInput, options?: __HttpHandlerOptions): Promise<ListProtectedQueriesCommandOutput>;
     listProtectedQueries(args: ListProtectedQueriesCommandInput, cb: (err: any, data?: ListProtectedQueriesCommandOutput) => void): void;
     listProtectedQueries(args: ListProtectedQueriesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListProtectedQueriesCommandOutput) => void): void;
     /**
+     * @public
      * <p>Lists the schemas for relations within a collaboration.</p>
      */
     listSchemas(args: ListSchemasCommandInput, options?: __HttpHandlerOptions): Promise<ListSchemasCommandOutput>;
     listSchemas(args: ListSchemasCommandInput, cb: (err: any, data?: ListSchemasCommandOutput) => void): void;
     listSchemas(args: ListSchemasCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListSchemasCommandOutput) => void): void;
     /**
+     * @public
+     * <p>Lists all of the tags that have been added to a resource.</p>
+     */
+    listTagsForResource(args: ListTagsForResourceCommandInput, options?: __HttpHandlerOptions): Promise<ListTagsForResourceCommandOutput>;
+    listTagsForResource(args: ListTagsForResourceCommandInput, cb: (err: any, data?: ListTagsForResourceCommandOutput) => void): void;
+    listTagsForResource(args: ListTagsForResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListTagsForResourceCommandOutput) => void): void;
+    /**
+     * @public
      * <p>Creates a protected query that is started by AWS Clean Rooms.</p>
      */
     startProtectedQuery(args: StartProtectedQueryCommandInput, options?: __HttpHandlerOptions): Promise<StartProtectedQueryCommandOutput>;
     startProtectedQuery(args: StartProtectedQueryCommandInput, cb: (err: any, data?: StartProtectedQueryCommandOutput) => void): void;
     startProtectedQuery(args: StartProtectedQueryCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: StartProtectedQueryCommandOutput) => void): void;
     /**
+     * @public
+     * <p>Tags a resource.</p>
+     */
+    tagResource(args: TagResourceCommandInput, options?: __HttpHandlerOptions): Promise<TagResourceCommandOutput>;
+    tagResource(args: TagResourceCommandInput, cb: (err: any, data?: TagResourceCommandOutput) => void): void;
+    tagResource(args: TagResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: TagResourceCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Removes a tag or list of tags from a resource.</p>
+     */
+    untagResource(args: UntagResourceCommandInput, options?: __HttpHandlerOptions): Promise<UntagResourceCommandOutput>;
+    untagResource(args: UntagResourceCommandInput, cb: (err: any, data?: UntagResourceCommandOutput) => void): void;
+    untagResource(args: UntagResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UntagResourceCommandOutput) => void): void;
+    /**
+     * @public
      * <p>Updates collaboration metadata and can only be called by the collaboration owner.</p>
      */
     updateCollaboration(args: UpdateCollaborationCommandInput, options?: __HttpHandlerOptions): Promise<UpdateCollaborationCommandOutput>;
     updateCollaboration(args: UpdateCollaborationCommandInput, cb: (err: any, data?: UpdateCollaborationCommandOutput) => void): void;
     updateCollaboration(args: UpdateCollaborationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateCollaborationCommandOutput) => void): void;
     /**
+     * @public
      * <p>Updates a configured table.</p>
      */
     updateConfiguredTable(args: UpdateConfiguredTableCommandInput, options?: __HttpHandlerOptions): Promise<UpdateConfiguredTableCommandOutput>;
     updateConfiguredTable(args: UpdateConfiguredTableCommandInput, cb: (err: any, data?: UpdateConfiguredTableCommandOutput) => void): void;
     updateConfiguredTable(args: UpdateConfiguredTableCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateConfiguredTableCommandOutput) => void): void;
     /**
+     * @public
      * <p>Updates a configured table analysis rule.</p>
      */
     updateConfiguredTableAnalysisRule(args: UpdateConfiguredTableAnalysisRuleCommandInput, options?: __HttpHandlerOptions): Promise<UpdateConfiguredTableAnalysisRuleCommandOutput>;
     updateConfiguredTableAnalysisRule(args: UpdateConfiguredTableAnalysisRuleCommandInput, cb: (err: any, data?: UpdateConfiguredTableAnalysisRuleCommandOutput) => void): void;
     updateConfiguredTableAnalysisRule(args: UpdateConfiguredTableAnalysisRuleCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateConfiguredTableAnalysisRuleCommandOutput) => void): void;
     /**
+     * @public
      * <p>Updates a configured table association.</p>
      */
     updateConfiguredTableAssociation(args: UpdateConfiguredTableAssociationCommandInput, options?: __HttpHandlerOptions): Promise<UpdateConfiguredTableAssociationCommandOutput>;
     updateConfiguredTableAssociation(args: UpdateConfiguredTableAssociationCommandInput, cb: (err: any, data?: UpdateConfiguredTableAssociationCommandOutput) => void): void;
     updateConfiguredTableAssociation(args: UpdateConfiguredTableAssociationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateConfiguredTableAssociationCommandOutput) => void): void;
     /**
+     * @public
      * <p>Updates a membership.</p>
      */
     updateMembership(args: UpdateMembershipCommandInput, options?: __HttpHandlerOptions): Promise<UpdateMembershipCommandOutput>;
     updateMembership(args: UpdateMembershipCommandInput, cb: (err: any, data?: UpdateMembershipCommandOutput) => void): void;
     updateMembership(args: UpdateMembershipCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateMembershipCommandOutput) => void): void;
     /**
+     * @public
      * <p>Updates the processing of a currently running query.</p>
      */
     updateProtectedQuery(args: UpdateProtectedQueryCommandInput, options?: __HttpHandlerOptions): Promise<UpdateProtectedQueryCommandOutput>;