@aws-sdk/client-ivschat 3.211.0 → 3.213.0

package/dist-es/Ivschat.js

@@ -1,14 +1,19 @@
 import { CreateChatTokenCommand, } from "./commands/CreateChatTokenCommand";
+import { CreateLoggingConfigurationCommand, } from "./commands/CreateLoggingConfigurationCommand";
 import { CreateRoomCommand } from "./commands/CreateRoomCommand";
+import { DeleteLoggingConfigurationCommand, } from "./commands/DeleteLoggingConfigurationCommand";
 import { DeleteMessageCommand, } from "./commands/DeleteMessageCommand";
 import { DeleteRoomCommand } from "./commands/DeleteRoomCommand";
 import { DisconnectUserCommand, } from "./commands/DisconnectUserCommand";
+import { GetLoggingConfigurationCommand, } from "./commands/GetLoggingConfigurationCommand";
 import { GetRoomCommand } from "./commands/GetRoomCommand";
+import { ListLoggingConfigurationsCommand, } from "./commands/ListLoggingConfigurationsCommand";
 import { ListRoomsCommand } from "./commands/ListRoomsCommand";
 import { ListTagsForResourceCommand, } from "./commands/ListTagsForResourceCommand";
 import { SendEventCommand } from "./commands/SendEventCommand";
 import { TagResourceCommand } from "./commands/TagResourceCommand";
 import { UntagResourceCommand, } from "./commands/UntagResourceCommand";
+import { UpdateLoggingConfigurationCommand, } from "./commands/UpdateLoggingConfigurationCommand";
 import { UpdateRoomCommand } from "./commands/UpdateRoomCommand";
 import { IvschatClient } from "./IvschatClient";
 export class Ivschat extends IvschatClient {
@@ -26,6 +31,20 @@ export class Ivschat extends IvschatClient {
             return this.send(command, optionsOrCb);
         }
     }
+    createLoggingConfiguration(args, optionsOrCb, cb) {
+        const command = new CreateLoggingConfigurationCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     createRoom(args, optionsOrCb, cb) {
         const command = new CreateRoomCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -40,6 +59,20 @@ export class Ivschat extends IvschatClient {
             return this.send(command, optionsOrCb);
         }
     }
+    deleteLoggingConfiguration(args, optionsOrCb, cb) {
+        const command = new DeleteLoggingConfigurationCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     deleteMessage(args, optionsOrCb, cb) {
         const command = new DeleteMessageCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -82,6 +115,20 @@ export class Ivschat extends IvschatClient {
             return this.send(command, optionsOrCb);
         }
     }
+    getLoggingConfiguration(args, optionsOrCb, cb) {
+        const command = new GetLoggingConfigurationCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     getRoom(args, optionsOrCb, cb) {
         const command = new GetRoomCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -96,6 +143,20 @@ export class Ivschat extends IvschatClient {
             return this.send(command, optionsOrCb);
         }
     }
+    listLoggingConfigurations(args, optionsOrCb, cb) {
+        const command = new ListLoggingConfigurationsCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     listRooms(args, optionsOrCb, cb) {
         const command = new ListRoomsCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -166,6 +227,20 @@ export class Ivschat extends IvschatClient {
             return this.send(command, optionsOrCb);
         }
     }
+    updateLoggingConfiguration(args, optionsOrCb, cb) {
+        const command = new UpdateLoggingConfigurationCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     updateRoom(args, optionsOrCb, cb) {
         const command = new UpdateRoomCommand(args);
         if (typeof optionsOrCb === "function") {

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

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

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

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

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

package/dist-es/commands/index.js

@@ -1,12 +1,17 @@
 export * from "./CreateChatTokenCommand";
+export * from "./CreateLoggingConfigurationCommand";
 export * from "./CreateRoomCommand";
+export * from "./DeleteLoggingConfigurationCommand";
 export * from "./DeleteMessageCommand";
 export * from "./DeleteRoomCommand";
 export * from "./DisconnectUserCommand";
+export * from "./GetLoggingConfigurationCommand";
 export * from "./GetRoomCommand";
+export * from "./ListLoggingConfigurationsCommand";
 export * from "./ListRoomsCommand";
 export * from "./ListTagsForResourceCommand";
 export * from "./SendEventCommand";
 export * from "./TagResourceCommand";
 export * from "./UntagResourceCommand";
+export * from "./UpdateLoggingConfigurationCommand";
 export * from "./UpdateRoomCommand";

package/dist-es/models/models_0.js

@@ -81,11 +81,22 @@ export class ConflictException extends __BaseException {
         this.resourceType = opts.resourceType;
     }
 }
-export var FallbackResult;
-(function (FallbackResult) {
-    FallbackResult["ALLOW"] = "ALLOW";
-    FallbackResult["DENY"] = "DENY";
-})(FallbackResult || (FallbackResult = {}));
+export var DestinationConfiguration;
+(function (DestinationConfiguration) {
+    DestinationConfiguration.visit = (value, visitor) => {
+        if (value.s3 !== undefined)
+            return visitor.s3(value.s3);
+        if (value.cloudWatchLogs !== undefined)
+            return visitor.cloudWatchLogs(value.cloudWatchLogs);
+        if (value.firehose !== undefined)
+            return visitor.firehose(value.firehose);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(DestinationConfiguration || (DestinationConfiguration = {}));
+export var CreateLoggingConfigurationState;
+(function (CreateLoggingConfigurationState) {
+    CreateLoggingConfigurationState["ACTIVE"] = "ACTIVE";
+})(CreateLoggingConfigurationState || (CreateLoggingConfigurationState = {}));
 export class ServiceQuotaExceededException extends __BaseException {
     constructor(opts) {
         super({
@@ -101,6 +112,11 @@ export class ServiceQuotaExceededException extends __BaseException {
         this.limit = opts.limit;
     }
 }
+export var FallbackResult;
+(function (FallbackResult) {
+    FallbackResult["ALLOW"] = "ALLOW";
+    FallbackResult["DENY"] = "DENY";
+})(FallbackResult || (FallbackResult = {}));
 export class ThrottlingException extends __BaseException {
     constructor(opts) {
         super({
@@ -116,6 +132,16 @@ export class ThrottlingException extends __BaseException {
         this.limit = opts.limit;
     }
 }
+export var LoggingConfigurationState;
+(function (LoggingConfigurationState) {
+    LoggingConfigurationState["ACTIVE"] = "ACTIVE";
+    LoggingConfigurationState["CREATE_FAILED"] = "CREATE_FAILED";
+    LoggingConfigurationState["CREATING"] = "CREATING";
+    LoggingConfigurationState["DELETE_FAILED"] = "DELETE_FAILED";
+    LoggingConfigurationState["DELETING"] = "DELETING";
+    LoggingConfigurationState["UPDATE_FAILED"] = "UPDATE_FAILED";
+    LoggingConfigurationState["UPDATING"] = "UPDATING";
+})(LoggingConfigurationState || (LoggingConfigurationState = {}));
 export class InternalServerException extends __BaseException {
     constructor(opts) {
         super({
@@ -128,6 +154,10 @@ export class InternalServerException extends __BaseException {
         Object.setPrototypeOf(this, InternalServerException.prototype);
     }
 }
+export var UpdateLoggingConfigurationState;
+(function (UpdateLoggingConfigurationState) {
+    UpdateLoggingConfigurationState["ACTIVE"] = "ACTIVE";
+})(UpdateLoggingConfigurationState || (UpdateLoggingConfigurationState = {}));
 export const CreateChatTokenRequestFilterSensitiveLog = (obj) => ({
     ...obj,
 });
@@ -137,6 +167,37 @@ export const CreateChatTokenResponseFilterSensitiveLog = (obj) => ({
 export const ValidationExceptionFieldFilterSensitiveLog = (obj) => ({
     ...obj,
 });
+export const CloudWatchLogsDestinationConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const FirehoseDestinationConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const S3DestinationConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DestinationConfigurationFilterSensitiveLog = (obj) => {
+    if (obj.s3 !== undefined)
+        return { s3: S3DestinationConfigurationFilterSensitiveLog(obj.s3) };
+    if (obj.cloudWatchLogs !== undefined)
+        return { cloudWatchLogs: CloudWatchLogsDestinationConfigurationFilterSensitiveLog(obj.cloudWatchLogs) };
+    if (obj.firehose !== undefined)
+        return { firehose: FirehoseDestinationConfigurationFilterSensitiveLog(obj.firehose) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const CreateLoggingConfigurationRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.destinationConfiguration && {
+        destinationConfiguration: DestinationConfigurationFilterSensitiveLog(obj.destinationConfiguration),
+    }),
+});
+export const CreateLoggingConfigurationResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.destinationConfiguration && {
+        destinationConfiguration: DestinationConfigurationFilterSensitiveLog(obj.destinationConfiguration),
+    }),
+});
 export const MessageReviewHandlerFilterSensitiveLog = (obj) => ({
     ...obj,
 });
@@ -146,6 +207,9 @@ export const CreateRoomRequestFilterSensitiveLog = (obj) => ({
 export const CreateRoomResponseFilterSensitiveLog = (obj) => ({
     ...obj,
 });
+export const DeleteLoggingConfigurationRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
 export const DeleteMessageRequestFilterSensitiveLog = (obj) => ({
     ...obj,
 });
@@ -161,12 +225,36 @@ export const DisconnectUserRequestFilterSensitiveLog = (obj) => ({
 export const DisconnectUserResponseFilterSensitiveLog = (obj) => ({
     ...obj,
 });
+export const GetLoggingConfigurationRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetLoggingConfigurationResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.destinationConfiguration && {
+        destinationConfiguration: DestinationConfigurationFilterSensitiveLog(obj.destinationConfiguration),
+    }),
+});
 export const GetRoomRequestFilterSensitiveLog = (obj) => ({
     ...obj,
 });
 export const GetRoomResponseFilterSensitiveLog = (obj) => ({
     ...obj,
 });
+export const ListLoggingConfigurationsRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const LoggingConfigurationSummaryFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.destinationConfiguration && {
+        destinationConfiguration: DestinationConfigurationFilterSensitiveLog(obj.destinationConfiguration),
+    }),
+});
+export const ListLoggingConfigurationsResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.loggingConfigurations && {
+        loggingConfigurations: obj.loggingConfigurations.map((item) => LoggingConfigurationSummaryFilterSensitiveLog(item)),
+    }),
+});
 export const ListRoomsRequestFilterSensitiveLog = (obj) => ({
     ...obj,
 });
@@ -200,6 +288,18 @@ export const UntagResourceRequestFilterSensitiveLog = (obj) => ({
 export const UntagResourceResponseFilterSensitiveLog = (obj) => ({
     ...obj,
 });
+export const UpdateLoggingConfigurationRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.destinationConfiguration && {
+        destinationConfiguration: DestinationConfigurationFilterSensitiveLog(obj.destinationConfiguration),
+    }),
+});
+export const UpdateLoggingConfigurationResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.destinationConfiguration && {
+        destinationConfiguration: DestinationConfigurationFilterSensitiveLog(obj.destinationConfiguration),
+    }),
+});
 export const UpdateRoomRequestFilterSensitiveLog = (obj) => ({
     ...obj,
 });

package/dist-es/pagination/ListLoggingConfigurationsPaginator.js

@@ -0,0 +1,32 @@
+import { ListLoggingConfigurationsCommand, } from "../commands/ListLoggingConfigurationsCommand";
+import { Ivschat } from "../Ivschat";
+import { IvschatClient } from "../IvschatClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListLoggingConfigurationsCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listLoggingConfigurations(input, ...args);
+};
+export async function* paginateListLoggingConfigurations(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxResults"] = config.pageSize;
+        if (config.client instanceof Ivschat) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof IvschatClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected Ivschat | IvschatClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/index.js

@@ -1,2 +1,3 @@
 export * from "./Interfaces";
+export * from "./ListLoggingConfigurationsPaginator";
 export * from "./ListRoomsPaginator";