@aws-sdk/client-chime-sdk-messaging 3.933.0 → 3.935.0

package/dist-types/models/enums.d.ts

@@ -0,0 +1,218 @@
+/**
+ * @public
+ * @enum
+ */
+export declare const AllowNotifications: {
+    readonly ALL: "ALL";
+    readonly FILTERED: "FILTERED";
+    readonly NONE: "NONE";
+};
+/**
+ * @public
+ */
+export type AllowNotifications = (typeof AllowNotifications)[keyof typeof AllowNotifications];
+/**
+ * @public
+ * @enum
+ */
+export declare const ChannelMembershipType: {
+    readonly DEFAULT: "DEFAULT";
+    readonly HIDDEN: "HIDDEN";
+};
+/**
+ * @public
+ */
+export type ChannelMembershipType = (typeof ChannelMembershipType)[keyof typeof ChannelMembershipType];
+/**
+ * @public
+ * @enum
+ */
+export declare const ErrorCode: {
+    readonly AccessDenied: "AccessDenied";
+    readonly BadRequest: "BadRequest";
+    readonly Conflict: "Conflict";
+    readonly Forbidden: "Forbidden";
+    readonly NotFound: "NotFound";
+    readonly PhoneNumberAssociationsExist: "PhoneNumberAssociationsExist";
+    readonly PreconditionFailed: "PreconditionFailed";
+    readonly ResourceLimitExceeded: "ResourceLimitExceeded";
+    readonly ServiceFailure: "ServiceFailure";
+    readonly ServiceUnavailable: "ServiceUnavailable";
+    readonly Throttled: "Throttled";
+    readonly Throttling: "Throttling";
+    readonly Unauthorized: "Unauthorized";
+    readonly Unprocessable: "Unprocessable";
+    readonly VoiceConnectorGroupAssociationsExist: "VoiceConnectorGroupAssociationsExist";
+};
+/**
+ * @public
+ */
+export type ErrorCode = (typeof ErrorCode)[keyof typeof ErrorCode];
+/**
+ * @public
+ * @enum
+ */
+export declare const ExpirationCriterion: {
+    readonly CREATED_TIMESTAMP: "CREATED_TIMESTAMP";
+    readonly LAST_MESSAGE_TIMESTAMP: "LAST_MESSAGE_TIMESTAMP";
+};
+/**
+ * @public
+ */
+export type ExpirationCriterion = (typeof ExpirationCriterion)[keyof typeof ExpirationCriterion];
+/**
+ * @public
+ * @enum
+ */
+export declare const ChannelMode: {
+    readonly RESTRICTED: "RESTRICTED";
+    readonly UNRESTRICTED: "UNRESTRICTED";
+};
+/**
+ * @public
+ */
+export type ChannelMode = (typeof ChannelMode)[keyof typeof ChannelMode];
+/**
+ * @public
+ * @enum
+ */
+export declare const ChannelPrivacy: {
+    readonly PRIVATE: "PRIVATE";
+    readonly PUBLIC: "PUBLIC";
+};
+/**
+ * @public
+ */
+export type ChannelPrivacy = (typeof ChannelPrivacy)[keyof typeof ChannelPrivacy];
+/**
+ * @public
+ * @enum
+ */
+export declare const InvocationType: {
+    readonly ASYNC: "ASYNC";
+};
+/**
+ * @public
+ */
+export type InvocationType = (typeof InvocationType)[keyof typeof InvocationType];
+/**
+ * @public
+ * @enum
+ */
+export declare const FallbackAction: {
+    readonly ABORT: "ABORT";
+    readonly CONTINUE: "CONTINUE";
+};
+/**
+ * @public
+ */
+export type FallbackAction = (typeof FallbackAction)[keyof typeof FallbackAction];
+/**
+ * @public
+ * @enum
+ */
+export declare const PushNotificationType: {
+    readonly DEFAULT: "DEFAULT";
+    readonly VOIP: "VOIP";
+};
+/**
+ * @public
+ */
+export type PushNotificationType = (typeof PushNotificationType)[keyof typeof PushNotificationType];
+/**
+ * @public
+ * @enum
+ */
+export declare const ChannelMessagePersistenceType: {
+    readonly NON_PERSISTENT: "NON_PERSISTENT";
+    readonly PERSISTENT: "PERSISTENT";
+};
+/**
+ * @public
+ */
+export type ChannelMessagePersistenceType = (typeof ChannelMessagePersistenceType)[keyof typeof ChannelMessagePersistenceType];
+/**
+ * @public
+ * @enum
+ */
+export declare const ChannelMessageStatus: {
+    readonly DENIED: "DENIED";
+    readonly FAILED: "FAILED";
+    readonly PENDING: "PENDING";
+    readonly SENT: "SENT";
+};
+/**
+ * @public
+ */
+export type ChannelMessageStatus = (typeof ChannelMessageStatus)[keyof typeof ChannelMessageStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const ChannelMessageType: {
+    readonly CONTROL: "CONTROL";
+    readonly STANDARD: "STANDARD";
+};
+/**
+ * @public
+ */
+export type ChannelMessageType = (typeof ChannelMessageType)[keyof typeof ChannelMessageType];
+/**
+ * @public
+ * @enum
+ */
+export declare const NetworkType: {
+    readonly DUAL_STACK: "DUAL_STACK";
+    readonly IPV4_ONLY: "IPV4_ONLY";
+};
+/**
+ * @public
+ */
+export type NetworkType = (typeof NetworkType)[keyof typeof NetworkType];
+/**
+ * @public
+ * @enum
+ */
+export declare const MessagingDataType: {
+    readonly Channel: "Channel";
+    readonly ChannelMessage: "ChannelMessage";
+};
+/**
+ * @public
+ */
+export type MessagingDataType = (typeof MessagingDataType)[keyof typeof MessagingDataType];
+/**
+ * @public
+ * @enum
+ */
+export declare const SortOrder: {
+    readonly ASCENDING: "ASCENDING";
+    readonly DESCENDING: "DESCENDING";
+};
+/**
+ * @public
+ */
+export type SortOrder = (typeof SortOrder)[keyof typeof SortOrder];
+/**
+ * @public
+ * @enum
+ */
+export declare const SearchFieldKey: {
+    readonly MEMBERS: "MEMBERS";
+};
+/**
+ * @public
+ */
+export type SearchFieldKey = (typeof SearchFieldKey)[keyof typeof SearchFieldKey];
+/**
+ * @public
+ * @enum
+ */
+export declare const SearchFieldOperator: {
+    readonly EQUALS: "EQUALS";
+    readonly INCLUDES: "INCLUDES";
+};
+/**
+ * @public
+ */
+export type SearchFieldOperator = (typeof SearchFieldOperator)[keyof typeof SearchFieldOperator];

package/dist-types/models/errors.d.ts

@@ -0,0 +1,130 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@smithy/smithy-client";
+import { ChimeSDKMessagingServiceException as __BaseException } from "./ChimeSDKMessagingServiceException";
+import { ErrorCode } from "./enums";
+/**
+ * <p>The input parameters don't match the service's restrictions.</p>
+ * @public
+ */
+export declare class BadRequestException extends __BaseException {
+    readonly name: "BadRequestException";
+    readonly $fault: "client";
+    Code?: ErrorCode | undefined;
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<BadRequestException, __BaseException>);
+}
+/**
+ * <p>The request could not be processed because of conflict in the current state of the
+ *          resource.</p>
+ * @public
+ */
+export declare class ConflictException extends __BaseException {
+    readonly name: "ConflictException";
+    readonly $fault: "client";
+    Code?: ErrorCode | undefined;
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ConflictException, __BaseException>);
+}
+/**
+ * <p>The client is permanently forbidden from making the request.</p>
+ * @public
+ */
+export declare class ForbiddenException extends __BaseException {
+    readonly name: "ForbiddenException";
+    readonly $fault: "client";
+    Code?: ErrorCode | undefined;
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ForbiddenException, __BaseException>);
+}
+/**
+ * <p>One or more of the resources in the request does not exist in the system.</p>
+ * @public
+ */
+export declare class NotFoundException extends __BaseException {
+    readonly name: "NotFoundException";
+    readonly $fault: "client";
+    Code?: ErrorCode | undefined;
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<NotFoundException, __BaseException>);
+}
+/**
+ * <p>The service encountered an unexpected error.</p>
+ * @public
+ */
+export declare class ServiceFailureException extends __BaseException {
+    readonly name: "ServiceFailureException";
+    readonly $fault: "server";
+    Code?: ErrorCode | undefined;
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ServiceFailureException, __BaseException>);
+}
+/**
+ * <p>The service is currently unavailable.</p>
+ * @public
+ */
+export declare class ServiceUnavailableException extends __BaseException {
+    readonly name: "ServiceUnavailableException";
+    readonly $fault: "server";
+    Code?: ErrorCode | undefined;
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ServiceUnavailableException, __BaseException>);
+}
+/**
+ * <p>The client exceeded its request rate limit.</p>
+ * @public
+ */
+export declare class ThrottledClientException extends __BaseException {
+    readonly name: "ThrottledClientException";
+    readonly $fault: "client";
+    Code?: ErrorCode | undefined;
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ThrottledClientException, __BaseException>);
+}
+/**
+ * <p>The client is not currently authorized to make the request.</p>
+ * @public
+ */
+export declare class UnauthorizedClientException extends __BaseException {
+    readonly name: "UnauthorizedClientException";
+    readonly $fault: "client";
+    Code?: ErrorCode | undefined;
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<UnauthorizedClientException, __BaseException>);
+}
+/**
+ * <p>The request exceeds the resource limit.</p>
+ * @public
+ */
+export declare class ResourceLimitExceededException extends __BaseException {
+    readonly name: "ResourceLimitExceededException";
+    readonly $fault: "client";
+    Code?: ErrorCode | undefined;
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ResourceLimitExceededException, __BaseException>);
+}