import * as HttpClient from "effect/unstable/http/HttpClient";
import * as redacted from "effect/Redacted";
import * as S from "effect/Schema";
import * as stream from "effect/Stream";
import * as API from "../client/api.js";
import * as T from "../traits.js";
import * as C from "../category.js";
import { SensitiveString } from "../sensitive.js";
const svc = T.AwsApiService({
    sdkId: "ivschat",
    serviceShapeName: "AmazonInteractiveVideoServiceChat",
});
const auth = T.AwsAuthSigv4({ name: "ivschat" });
const ver = T.ServiceVersion("2020-07-14");
const proto = T.AwsProtocolsRestJson1();
const rules = T.EndpointResolver((p, _) => {
    const { Region, UseDualStack = false, UseFIPS = false, Endpoint } = p;
    const e = (u, p = {}, h = {}) => ({
        type: "endpoint",
        endpoint: { url: u, properties: p, headers: h },
    });
    const err = (m) => ({
        type: "error",
        message: m,
    });
    if (Endpoint != null) {
        if (UseFIPS === true) {
            return err("Invalid Configuration: FIPS and custom endpoint are not supported");
        }
        if (UseDualStack === true) {
            return err("Invalid Configuration: Dualstack and custom endpoint are not supported");
        }
        return e(Endpoint);
    }
    if (Region != null) {
        {
            const PartitionResult = _.partition(Region);
            if (PartitionResult != null && PartitionResult !== false) {
                if (UseFIPS === true && UseDualStack === true) {
                    if (true === _.getAttr(PartitionResult, "supportsFIPS") &&
                        true === _.getAttr(PartitionResult, "supportsDualStack")) {
                        return e(`https://ivschat-fips.${Region}.${_.getAttr(PartitionResult, "dualStackDnsSuffix")}`);
                    }
                    return err("FIPS and DualStack are enabled, but this partition does not support one or both");
                }
                if (UseFIPS === true) {
                    if (_.getAttr(PartitionResult, "supportsFIPS") === true) {
                        return e(`https://ivschat-fips.${Region}.${_.getAttr(PartitionResult, "dnsSuffix")}`);
                    }
                    return err("FIPS is enabled but this partition does not support FIPS");
                }
                if (UseDualStack === true) {
                    if (true === _.getAttr(PartitionResult, "supportsDualStack")) {
                        return e(`https://ivschat.${Region}.${_.getAttr(PartitionResult, "dualStackDnsSuffix")}`);
                    }
                    return err("DualStack is enabled but this partition does not support DualStack");
                }
                return e(`https://ivschat.${Region}.${_.getAttr(PartitionResult, "dnsSuffix")}`);
            }
        }
    }
    return err("Invalid Configuration: Missing Region");
});
export const ChatTokenCapabilities = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const ChatTokenAttributes = /*@__PURE__*/ /*#__PURE__*/ S.Record(S.String, S.String.pipe(S.optional));
export const CreateChatTokenRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    roomIdentifier: S.String,
    userId: SensitiveString,
    capabilities: S.optional(ChatTokenCapabilities),
    sessionDurationInMinutes: S.optional(S.Number),
    attributes: S.optional(ChatTokenAttributes),
}).pipe(T.all(T.Http({ method: "POST", uri: "/CreateChatToken" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreateChatTokenRequest",
});
export const CreateChatTokenResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    token: S.optional(SensitiveString),
    tokenExpirationTime: S.optional(T.DateFromString.pipe(T.TimestampFormat("date-time"))),
    sessionExpirationTime: S.optional(T.DateFromString.pipe(T.TimestampFormat("date-time"))),
})).annotate({
    identifier: "CreateChatTokenResponse",
});
export const ValidationExceptionField = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ name: S.String, message: S.String })).annotate({
    identifier: "ValidationExceptionField",
});
export const ValidationExceptionFieldList = /*@__PURE__*/ /*#__PURE__*/ S.Array(ValidationExceptionField);
export const S3DestinationConfiguration = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ bucketName: S.String })).annotate({
    identifier: "S3DestinationConfiguration",
});
export const CloudWatchLogsDestinationConfiguration = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ logGroupName: S.String })).annotate({
    identifier: "CloudWatchLogsDestinationConfiguration",
});
export const FirehoseDestinationConfiguration = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ deliveryStreamName: S.String })).annotate({
    identifier: "FirehoseDestinationConfiguration",
});
export const DestinationConfiguration = /*@__PURE__*/ /*#__PURE__*/ S.Union([
    S.Struct({ s3: S3DestinationConfiguration }),
    S.Struct({ cloudWatchLogs: CloudWatchLogsDestinationConfiguration }),
    S.Struct({ firehose: FirehoseDestinationConfiguration }),
]);
export const Tags = /*@__PURE__*/ /*#__PURE__*/ S.Record(S.String, S.String.pipe(S.optional));
export const CreateLoggingConfigurationRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    name: S.optional(S.String),
    destinationConfiguration: DestinationConfiguration,
    tags: S.optional(Tags),
}).pipe(T.all(T.Http({ method: "POST", uri: "/CreateLoggingConfiguration" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreateLoggingConfigurationRequest",
});
export const CreateLoggingConfigurationResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    arn: S.optional(S.String),
    id: S.optional(S.String),
    createTime: S.optional(T.DateFromString.pipe(T.TimestampFormat("date-time"))),
    updateTime: S.optional(T.DateFromString.pipe(T.TimestampFormat("date-time"))),
    name: S.optional(S.String),
    destinationConfiguration: S.optional(DestinationConfiguration),
    state: S.optional(S.String),
    tags: S.optional(Tags),
})).annotate({
    identifier: "CreateLoggingConfigurationResponse",
});
export const MessageReviewHandler = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ uri: S.optional(S.String), fallbackResult: S.optional(S.String) })).annotate({
    identifier: "MessageReviewHandler",
});
export const LoggingConfigurationIdentifierList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const CreateRoomRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    name: S.optional(S.String),
    maximumMessageRatePerSecond: S.optional(S.Number),
    maximumMessageLength: S.optional(S.Number),
    messageReviewHandler: S.optional(MessageReviewHandler),
    tags: S.optional(Tags),
    loggingConfigurationIdentifiers: S.optional(LoggingConfigurationIdentifierList),
}).pipe(T.all(T.Http({ method: "POST", uri: "/CreateRoom" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreateRoomRequest",
});
export const CreateRoomResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    arn: S.optional(S.String),
    id: S.optional(S.String),
    name: S.optional(S.String),
    createTime: S.optional(T.DateFromString.pipe(T.TimestampFormat("date-time"))),
    updateTime: S.optional(T.DateFromString.pipe(T.TimestampFormat("date-time"))),
    maximumMessageRatePerSecond: S.optional(S.Number),
    maximumMessageLength: S.optional(S.Number),
    messageReviewHandler: S.optional(MessageReviewHandler),
    tags: S.optional(Tags),
    loggingConfigurationIdentifiers: S.optional(LoggingConfigurationIdentifierList),
})).annotate({
    identifier: "CreateRoomResponse",
});
export const DeleteLoggingConfigurationRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ identifier: S.String }).pipe(T.all(T.Http({ method: "POST", uri: "/DeleteLoggingConfiguration" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteLoggingConfigurationRequest",
});
export const DeleteLoggingConfigurationResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "DeleteLoggingConfigurationResponse",
});
export const DeleteMessageRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    roomIdentifier: S.String,
    id: S.String,
    reason: S.optional(S.String),
}).pipe(T.all(T.Http({ method: "POST", uri: "/DeleteMessage" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteMessageRequest",
});
export const DeleteMessageResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ id: S.optional(S.String) })).annotate({
    identifier: "DeleteMessageResponse",
});
export const DeleteRoomRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ identifier: S.String }).pipe(T.all(T.Http({ method: "POST", uri: "/DeleteRoom" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteRoomRequest",
});
export const DeleteRoomResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "DeleteRoomResponse",
});
export const DisconnectUserRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    roomIdentifier: S.String,
    userId: SensitiveString,
    reason: S.optional(S.String),
}).pipe(T.all(T.Http({ method: "POST", uri: "/DisconnectUser" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DisconnectUserRequest",
});
export const DisconnectUserResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "DisconnectUserResponse",
});
export const GetLoggingConfigurationRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ identifier: S.String }).pipe(T.all(T.Http({ method: "POST", uri: "/GetLoggingConfiguration" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetLoggingConfigurationRequest",
});
export const GetLoggingConfigurationResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    arn: S.optional(S.String),
    id: S.optional(S.String),
    createTime: S.optional(T.DateFromString.pipe(T.TimestampFormat("date-time"))),
    updateTime: S.optional(T.DateFromString.pipe(T.TimestampFormat("date-time"))),
    name: S.optional(S.String),
    destinationConfiguration: S.optional(DestinationConfiguration),
    state: S.optional(S.String),
    tags: S.optional(Tags),
})).annotate({
    identifier: "GetLoggingConfigurationResponse",
});
export const GetRoomRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ identifier: S.String }).pipe(T.all(T.Http({ method: "POST", uri: "/GetRoom" }), svc, auth, proto, ver, rules))).annotate({ identifier: "GetRoomRequest" });
export const GetRoomResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    arn: S.optional(S.String),
    id: S.optional(S.String),
    name: S.optional(S.String),
    createTime: S.optional(T.DateFromString.pipe(T.TimestampFormat("date-time"))),
    updateTime: S.optional(T.DateFromString.pipe(T.TimestampFormat("date-time"))),
    maximumMessageRatePerSecond: S.optional(S.Number),
    maximumMessageLength: S.optional(S.Number),
    messageReviewHandler: S.optional(MessageReviewHandler),
    tags: S.optional(Tags),
    loggingConfigurationIdentifiers: S.optional(LoggingConfigurationIdentifierList),
})).annotate({
    identifier: "GetRoomResponse",
});
export const ListLoggingConfigurationsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    nextToken: S.optional(S.String),
    maxResults: S.optional(S.Number),
}).pipe(T.all(T.Http({ method: "POST", uri: "/ListLoggingConfigurations" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListLoggingConfigurationsRequest",
});
export const LoggingConfigurationSummary = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    arn: S.optional(S.String),
    id: S.optional(S.String),
    createTime: S.optional(T.DateFromString.pipe(T.TimestampFormat("date-time"))),
    updateTime: S.optional(T.DateFromString.pipe(T.TimestampFormat("date-time"))),
    name: S.optional(S.String),
    destinationConfiguration: S.optional(DestinationConfiguration),
    state: S.optional(S.String),
    tags: S.optional(Tags),
})).annotate({
    identifier: "LoggingConfigurationSummary",
});
export const LoggingConfigurationList = /*@__PURE__*/ /*#__PURE__*/ S.Array(LoggingConfigurationSummary);
export const ListLoggingConfigurationsResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    loggingConfigurations: LoggingConfigurationList,
    nextToken: S.optional(S.String),
})).annotate({
    identifier: "ListLoggingConfigurationsResponse",
});
export const ListRoomsRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    name: S.optional(S.String),
    nextToken: S.optional(S.String),
    maxResults: S.optional(S.Number),
    messageReviewHandlerUri: S.optional(S.String),
    loggingConfigurationIdentifier: S.optional(S.String),
}).pipe(T.all(T.Http({ method: "POST", uri: "/ListRooms" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListRoomsRequest",
});
export const RoomSummary = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    arn: S.optional(S.String),
    id: S.optional(S.String),
    name: S.optional(S.String),
    messageReviewHandler: S.optional(MessageReviewHandler),
    createTime: S.optional(T.DateFromString.pipe(T.TimestampFormat("date-time"))),
    updateTime: S.optional(T.DateFromString.pipe(T.TimestampFormat("date-time"))),
    tags: S.optional(Tags),
    loggingConfigurationIdentifiers: S.optional(LoggingConfigurationIdentifierList),
})).annotate({ identifier: "RoomSummary" });
export const RoomList = /*@__PURE__*/ /*#__PURE__*/ S.Array(RoomSummary);
export const ListRoomsResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ rooms: RoomList, nextToken: S.optional(S.String) })).annotate({
    identifier: "ListRoomsResponse",
});
export const ListTagsForResourceRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ resourceArn: S.String.pipe(T.HttpLabel("resourceArn")) }).pipe(T.all(T.Http({ method: "GET", uri: "/tags/{resourceArn}" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListTagsForResourceRequest",
});
export const ListTagsForResourceResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ tags: Tags })).annotate({
    identifier: "ListTagsForResourceResponse",
});
export const EventAttributes = /*@__PURE__*/ /*#__PURE__*/ S.Record(S.String, S.String.pipe(S.optional));
export const SendEventRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    roomIdentifier: S.String,
    eventName: S.String,
    attributes: S.optional(EventAttributes),
}).pipe(T.all(T.Http({ method: "POST", uri: "/SendEvent" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "SendEventRequest",
});
export const SendEventResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ id: S.optional(S.String) })).annotate({
    identifier: "SendEventResponse",
});
export const TagResourceRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    resourceArn: S.String.pipe(T.HttpLabel("resourceArn")),
    tags: Tags,
}).pipe(T.all(T.Http({ method: "POST", uri: "/tags/{resourceArn}" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "TagResourceRequest",
});
export const TagResourceResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "TagResourceResponse",
});
export const TagKeyList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const UntagResourceRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    resourceArn: S.String.pipe(T.HttpLabel("resourceArn")),
    tagKeys: TagKeyList.pipe(T.HttpQuery("tagKeys")),
}).pipe(T.all(T.Http({ method: "DELETE", uri: "/tags/{resourceArn}" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UntagResourceRequest",
});
export const UntagResourceResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "UntagResourceResponse",
});
export const UpdateLoggingConfigurationRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    identifier: S.String,
    name: S.optional(S.String),
    destinationConfiguration: S.optional(DestinationConfiguration),
}).pipe(T.all(T.Http({ method: "POST", uri: "/UpdateLoggingConfiguration" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UpdateLoggingConfigurationRequest",
});
export const UpdateLoggingConfigurationResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    arn: S.optional(S.String),
    id: S.optional(S.String),
    createTime: S.optional(T.DateFromString.pipe(T.TimestampFormat("date-time"))),
    updateTime: S.optional(T.DateFromString.pipe(T.TimestampFormat("date-time"))),
    name: S.optional(S.String),
    destinationConfiguration: S.optional(DestinationConfiguration),
    state: S.optional(S.String),
    tags: S.optional(Tags),
})).annotate({
    identifier: "UpdateLoggingConfigurationResponse",
});
export const UpdateRoomRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    identifier: S.String,
    name: S.optional(S.String),
    maximumMessageRatePerSecond: S.optional(S.Number),
    maximumMessageLength: S.optional(S.Number),
    messageReviewHandler: S.optional(MessageReviewHandler),
    loggingConfigurationIdentifiers: S.optional(LoggingConfigurationIdentifierList),
}).pipe(T.all(T.Http({ method: "POST", uri: "/UpdateRoom" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UpdateRoomRequest",
});
export const UpdateRoomResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    arn: S.optional(S.String),
    id: S.optional(S.String),
    name: S.optional(S.String),
    createTime: S.optional(T.DateFromString.pipe(T.TimestampFormat("date-time"))),
    updateTime: S.optional(T.DateFromString.pipe(T.TimestampFormat("date-time"))),
    maximumMessageRatePerSecond: S.optional(S.Number),
    maximumMessageLength: S.optional(S.Number),
    messageReviewHandler: S.optional(MessageReviewHandler),
    tags: S.optional(Tags),
    loggingConfigurationIdentifiers: S.optional(LoggingConfigurationIdentifierList),
})).annotate({
    identifier: "UpdateRoomResponse",
});
//# Errors
export class AccessDeniedException extends S.TaggedErrorClass()("AccessDeniedException", { message: S.String }).pipe(C.withAuthError) {
}
export class PendingVerification extends S.TaggedErrorClass()("PendingVerification", { message: S.String }).pipe(C.withAuthError) {
}
export class ResourceNotFoundException extends S.TaggedErrorClass()("ResourceNotFoundException", { message: S.String, resourceId: S.String, resourceType: S.String }).pipe(C.withBadRequestError) {
}
export class ValidationException extends S.TaggedErrorClass()("ValidationException", {
    message: S.String,
    reason: S.String,
    fieldList: S.optional(ValidationExceptionFieldList),
}).pipe(C.withBadRequestError) {
}
export class ConflictException extends S.TaggedErrorClass()("ConflictException", { message: S.String, resourceId: S.String, resourceType: S.String }).pipe(C.withConflictError) {
}
export class ServiceQuotaExceededException extends S.TaggedErrorClass()("ServiceQuotaExceededException", {
    message: S.String,
    resourceId: S.String,
    resourceType: S.String,
    limit: S.Number,
}).pipe(C.withQuotaError) {
}
export class ThrottlingException extends S.TaggedErrorClass()("ThrottlingException", {
    message: S.String,
    resourceId: S.String,
    resourceType: S.String,
    limit: S.Number,
}).pipe(C.withThrottlingError) {
}
export class InternalServerException extends S.TaggedErrorClass()("InternalServerException", { message: S.String }).pipe(C.withServerError) {
}
/**
 * Creates an encrypted token that is used by a chat participant to establish an individual
 * WebSocket chat connection to a room. When the token is used to connect to chat, the
 * connection is valid for the session duration specified in the request. The token becomes
 * invalid at the token-expiration timestamp included in the response.
 *
 * Use the `capabilities` field to permit an end user to send messages or
 * moderate a room.
 *
 * The `attributes` field securely attaches structured data to the chat session; the data is
 * included within each message sent by the end user and received by other participants in the
 * room. Common use cases for attributes include passing end-user profile data like an icon,
 * display name, colors, badges, and other display features.
 *
 * Encryption keys are owned by Amazon IVS Chat and never used directly by your
 * application.
 */
export const createChatToken = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateChatTokenRequest,
    output: CreateChatTokenResponse,
    errors: [
        AccessDeniedException,
        PendingVerification,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Creates a logging configuration that allows clients to store and record sent
 * messages.
 */
export const createLoggingConfiguration = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateLoggingConfigurationRequest,
    output: CreateLoggingConfigurationResponse,
    errors: [
        AccessDeniedException,
        ConflictException,
        PendingVerification,
        ResourceNotFoundException,
        ServiceQuotaExceededException,
        ValidationException,
    ],
}));
/**
 * Creates a room that allows clients to connect and pass messages.
 */
export const createRoom = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateRoomRequest,
    output: CreateRoomResponse,
    errors: [
        AccessDeniedException,
        ConflictException,
        PendingVerification,
        ResourceNotFoundException,
        ServiceQuotaExceededException,
        ValidationException,
    ],
}));
/**
 * Deletes the specified logging configuration.
 */
export const deleteLoggingConfiguration = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteLoggingConfigurationRequest,
    output: DeleteLoggingConfigurationResponse,
    errors: [
        AccessDeniedException,
        ConflictException,
        PendingVerification,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Sends an event to a specific room which directs clients to delete a specific message;
 * that is, unrender it from view and delete it from the client’s chat history. This event’s
 * `EventName` is `aws:DELETE_MESSAGE`. This replicates the
 * DeleteMessage WebSocket operation in the Amazon IVS Chat Messaging API.
 */
export const deleteMessage = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteMessageRequest,
    output: DeleteMessageResponse,
    errors: [
        AccessDeniedException,
        PendingVerification,
        ResourceNotFoundException,
        ThrottlingException,
        ValidationException,
    ],
}));
/**
 * Deletes the specified room.
 */
export const deleteRoom = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteRoomRequest,
    output: DeleteRoomResponse,
    errors: [
        AccessDeniedException,
        PendingVerification,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Disconnects all connections using a specified user ID from a room. This replicates the
 *
 * DisconnectUser WebSocket operation in the Amazon IVS Chat Messaging API.
 */
export const disconnectUser = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DisconnectUserRequest,
    output: DisconnectUserResponse,
    errors: [
        AccessDeniedException,
        PendingVerification,
        ResourceNotFoundException,
        ThrottlingException,
        ValidationException,
    ],
}));
/**
 * Gets the specified logging configuration.
 */
export const getLoggingConfiguration = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetLoggingConfigurationRequest,
    output: GetLoggingConfigurationResponse,
    errors: [
        AccessDeniedException,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Gets the specified room.
 */
export const getRoom = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetRoomRequest,
    output: GetRoomResponse,
    errors: [
        AccessDeniedException,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Gets summary information about all your logging configurations in the AWS region where
 * the API request is processed.
 */
export const listLoggingConfigurations = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListLoggingConfigurationsRequest,
    output: ListLoggingConfigurationsResponse,
    errors: [AccessDeniedException, ValidationException],
    pagination: {
        inputToken: "nextToken",
        outputToken: "nextToken",
        pageSize: "maxResults",
    },
}));
/**
 * Gets summary information about all your rooms in the AWS region where the API request is
 * processed. Results are sorted in descending order of `updateTime`.
 */
export const listRooms = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListRoomsRequest,
    output: ListRoomsResponse,
    errors: [
        AccessDeniedException,
        ResourceNotFoundException,
        ValidationException,
    ],
    pagination: {
        inputToken: "nextToken",
        outputToken: "nextToken",
        pageSize: "maxResults",
    },
}));
/**
 * Gets information about AWS tags for the specified ARN.
 */
export const listTagsForResource = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListTagsForResourceRequest,
    output: ListTagsForResourceResponse,
    errors: [
        InternalServerException,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Sends an event to a room. Use this within your application’s business logic to send
 * events to clients of a room; e.g., to notify clients to change the way the chat UI is
 * rendered.
 */
export const sendEvent = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: SendEventRequest,
    output: SendEventResponse,
    errors: [
        AccessDeniedException,
        PendingVerification,
        ResourceNotFoundException,
        ThrottlingException,
        ValidationException,
    ],
}));
/**
 * Adds or updates tags for the AWS resource with the specified ARN.
 */
export const tagResource = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: TagResourceRequest,
    output: TagResourceResponse,
    errors: [
        InternalServerException,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Removes tags from the resource with the specified ARN.
 */
export const untagResource = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UntagResourceRequest,
    output: UntagResourceResponse,
    errors: [
        InternalServerException,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Updates a specified logging configuration.
 */
export const updateLoggingConfiguration = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateLoggingConfigurationRequest,
    output: UpdateLoggingConfigurationResponse,
    errors: [
        AccessDeniedException,
        ConflictException,
        PendingVerification,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Updates a room’s configuration.
 */
export const updateRoom = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateRoomRequest,
    output: UpdateRoomResponse,
    errors: [
        AccessDeniedException,
        PendingVerification,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
//# sourceMappingURL=ivschat.js.map