import * as HttpClient from "effect/unstable/http/HttpClient";
import * as S from "effect/Schema";
import * as stream from "effect/Stream";
import * as API from "../client/api.ts";
import type { Credentials } from "../credentials.ts";
import type { CommonErrors } from "../errors.ts";
import type { Region } from "../region.ts";
export type ExceptionMessage = string;
export type TagKey = string;
export type TagValue = string;
export type Token = string;
export type BoxedInteger = number;
export type MessageAttributeName = string;
export type Binary = Uint8Array;
export type AWSAccountIdList = string[];
export declare const AWSAccountIdList: S.$Array<S.String>;
export type ActionNameList = string[];
export declare const ActionNameList: S.$Array<S.String>;
export interface AddPermissionRequest {
    QueueUrl: string;
    Label: string;
    AWSAccountIds: string[];
    Actions: string[];
}
export declare const AddPermissionRequest: S.Schema<AddPermissionRequest>;
export interface AddPermissionResponse {
}
export declare const AddPermissionResponse: S.Schema<AddPermissionResponse>;
export interface CancelMessageMoveTaskRequest {
    TaskHandle: string;
}
export declare const CancelMessageMoveTaskRequest: S.Schema<CancelMessageMoveTaskRequest>;
export interface CancelMessageMoveTaskResult {
    ApproximateNumberOfMessagesMoved?: number;
}
export declare const CancelMessageMoveTaskResult: S.Schema<CancelMessageMoveTaskResult>;
export interface ChangeMessageVisibilityRequest {
    QueueUrl: string;
    ReceiptHandle: string;
    VisibilityTimeout: number;
}
export declare const ChangeMessageVisibilityRequest: S.Schema<ChangeMessageVisibilityRequest>;
export interface ChangeMessageVisibilityResponse {
}
export declare const ChangeMessageVisibilityResponse: S.Schema<ChangeMessageVisibilityResponse>;
export interface ChangeMessageVisibilityBatchRequestEntry {
    Id: string;
    ReceiptHandle: string;
    VisibilityTimeout?: number;
}
export declare const ChangeMessageVisibilityBatchRequestEntry: S.Schema<ChangeMessageVisibilityBatchRequestEntry>;
export type ChangeMessageVisibilityBatchRequestEntryList = ChangeMessageVisibilityBatchRequestEntry[];
export declare const ChangeMessageVisibilityBatchRequestEntryList: S.$Array<S.Schema<ChangeMessageVisibilityBatchRequestEntry>>;
export interface ChangeMessageVisibilityBatchRequest {
    QueueUrl: string;
    Entries: ChangeMessageVisibilityBatchRequestEntry[];
}
export declare const ChangeMessageVisibilityBatchRequest: S.Schema<ChangeMessageVisibilityBatchRequest>;
export interface ChangeMessageVisibilityBatchResultEntry {
    Id: string;
}
export declare const ChangeMessageVisibilityBatchResultEntry: S.Schema<ChangeMessageVisibilityBatchResultEntry>;
export type ChangeMessageVisibilityBatchResultEntryList = ChangeMessageVisibilityBatchResultEntry[];
export declare const ChangeMessageVisibilityBatchResultEntryList: S.$Array<S.Schema<ChangeMessageVisibilityBatchResultEntry>>;
export interface BatchResultErrorEntry {
    Id: string;
    SenderFault: boolean;
    Code: string;
    Message?: string;
}
export declare const BatchResultErrorEntry: S.Schema<BatchResultErrorEntry>;
export type BatchResultErrorEntryList = BatchResultErrorEntry[];
export declare const BatchResultErrorEntryList: S.$Array<S.Schema<BatchResultErrorEntry>>;
export interface ChangeMessageVisibilityBatchResult {
    Successful: ChangeMessageVisibilityBatchResultEntry[];
    Failed: BatchResultErrorEntry[];
}
export declare const ChangeMessageVisibilityBatchResult: S.Schema<ChangeMessageVisibilityBatchResult>;
export type QueueAttributeName = "All" | "Policy" | "VisibilityTimeout" | "MaximumMessageSize" | "MessageRetentionPeriod" | "ApproximateNumberOfMessages" | "ApproximateNumberOfMessagesNotVisible" | "CreatedTimestamp" | "LastModifiedTimestamp" | "QueueArn" | "ApproximateNumberOfMessagesDelayed" | "DelaySeconds" | "ReceiveMessageWaitTimeSeconds" | "RedrivePolicy" | "FifoQueue" | "ContentBasedDeduplication" | "KmsMasterKeyId" | "KmsDataKeyReusePeriodSeconds" | "DeduplicationScope" | "FifoThroughputLimit" | "RedriveAllowPolicy" | "SqsManagedSseEnabled" | (string & {});
export declare const QueueAttributeName: S.String;
export type QueueAttributeMap = {
    [key in QueueAttributeName]?: string;
};
export declare const QueueAttributeMap: S.$Record<S.String, S.optional<S.String>>;
export type TagMap = {
    [key: string]: string | undefined;
};
export declare const TagMap: S.$Record<S.String, S.optional<S.String>>;
export interface CreateQueueRequest {
    QueueName: string;
    Attributes?: {
        [key: string]: string | undefined;
    };
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const CreateQueueRequest: S.Schema<CreateQueueRequest>;
export interface CreateQueueResult {
    QueueUrl?: string;
}
export declare const CreateQueueResult: S.Schema<CreateQueueResult>;
export interface DeleteMessageRequest {
    QueueUrl: string;
    ReceiptHandle: string;
}
export declare const DeleteMessageRequest: S.Schema<DeleteMessageRequest>;
export interface DeleteMessageResponse {
}
export declare const DeleteMessageResponse: S.Schema<DeleteMessageResponse>;
export interface DeleteMessageBatchRequestEntry {
    Id: string;
    ReceiptHandle: string;
}
export declare const DeleteMessageBatchRequestEntry: S.Schema<DeleteMessageBatchRequestEntry>;
export type DeleteMessageBatchRequestEntryList = DeleteMessageBatchRequestEntry[];
export declare const DeleteMessageBatchRequestEntryList: S.$Array<S.Schema<DeleteMessageBatchRequestEntry>>;
export interface DeleteMessageBatchRequest {
    QueueUrl: string;
    Entries: DeleteMessageBatchRequestEntry[];
}
export declare const DeleteMessageBatchRequest: S.Schema<DeleteMessageBatchRequest>;
export interface DeleteMessageBatchResultEntry {
    Id: string;
}
export declare const DeleteMessageBatchResultEntry: S.Schema<DeleteMessageBatchResultEntry>;
export type DeleteMessageBatchResultEntryList = DeleteMessageBatchResultEntry[];
export declare const DeleteMessageBatchResultEntryList: S.$Array<S.Schema<DeleteMessageBatchResultEntry>>;
export interface DeleteMessageBatchResult {
    Successful: DeleteMessageBatchResultEntry[];
    Failed: BatchResultErrorEntry[];
}
export declare const DeleteMessageBatchResult: S.Schema<DeleteMessageBatchResult>;
export interface DeleteQueueRequest {
    QueueUrl: string;
}
export declare const DeleteQueueRequest: S.Schema<DeleteQueueRequest>;
export interface DeleteQueueResponse {
}
export declare const DeleteQueueResponse: S.Schema<DeleteQueueResponse>;
export type AttributeNameList = QueueAttributeName[];
export declare const AttributeNameList: S.$Array<S.String>;
export interface GetQueueAttributesRequest {
    QueueUrl: string;
    AttributeNames?: QueueAttributeName[];
}
export declare const GetQueueAttributesRequest: S.Schema<GetQueueAttributesRequest>;
export interface GetQueueAttributesResult {
    Attributes?: {
        [key: string]: string | undefined;
    };
}
export declare const GetQueueAttributesResult: S.Schema<GetQueueAttributesResult>;
export interface GetQueueUrlRequest {
    QueueName: string;
    QueueOwnerAWSAccountId?: string;
}
export declare const GetQueueUrlRequest: S.Schema<GetQueueUrlRequest>;
export interface GetQueueUrlResult {
    QueueUrl?: string;
}
export declare const GetQueueUrlResult: S.Schema<GetQueueUrlResult>;
export interface ListDeadLetterSourceQueuesRequest {
    QueueUrl: string;
    NextToken?: string;
    MaxResults?: number;
}
export declare const ListDeadLetterSourceQueuesRequest: S.Schema<ListDeadLetterSourceQueuesRequest>;
export type QueueUrlList = string[];
export declare const QueueUrlList: S.$Array<S.String>;
export interface ListDeadLetterSourceQueuesResult {
    queueUrls: string[];
    NextToken?: string;
}
export declare const ListDeadLetterSourceQueuesResult: S.Schema<ListDeadLetterSourceQueuesResult>;
export interface ListMessageMoveTasksRequest {
    SourceArn: string;
    MaxResults?: number;
}
export declare const ListMessageMoveTasksRequest: S.Schema<ListMessageMoveTasksRequest>;
export interface ListMessageMoveTasksResultEntry {
    TaskHandle?: string;
    Status?: string;
    SourceArn?: string;
    DestinationArn?: string;
    MaxNumberOfMessagesPerSecond?: number;
    ApproximateNumberOfMessagesMoved?: number;
    ApproximateNumberOfMessagesToMove?: number;
    FailureReason?: string;
    StartedTimestamp?: number;
}
export declare const ListMessageMoveTasksResultEntry: S.Schema<ListMessageMoveTasksResultEntry>;
export type ListMessageMoveTasksResultEntryList = ListMessageMoveTasksResultEntry[];
export declare const ListMessageMoveTasksResultEntryList: S.$Array<S.Schema<ListMessageMoveTasksResultEntry>>;
export interface ListMessageMoveTasksResult {
    Results?: ListMessageMoveTasksResultEntry[];
}
export declare const ListMessageMoveTasksResult: S.Schema<ListMessageMoveTasksResult>;
export interface ListQueuesRequest {
    QueueNamePrefix?: string;
    NextToken?: string;
    MaxResults?: number;
}
export declare const ListQueuesRequest: S.Schema<ListQueuesRequest>;
export interface ListQueuesResult {
    QueueUrls?: string[];
    NextToken?: string;
}
export declare const ListQueuesResult: S.Schema<ListQueuesResult>;
export interface ListQueueTagsRequest {
    QueueUrl: string;
}
export declare const ListQueueTagsRequest: S.Schema<ListQueueTagsRequest>;
export interface ListQueueTagsResult {
    Tags?: {
        [key: string]: string | undefined;
    };
}
export declare const ListQueueTagsResult: S.Schema<ListQueueTagsResult>;
export interface PurgeQueueRequest {
    QueueUrl: string;
}
export declare const PurgeQueueRequest: S.Schema<PurgeQueueRequest>;
export interface PurgeQueueResponse {
}
export declare const PurgeQueueResponse: S.Schema<PurgeQueueResponse>;
export type MessageSystemAttributeName = "All" | "SenderId" | "SentTimestamp" | "ApproximateReceiveCount" | "ApproximateFirstReceiveTimestamp" | "SequenceNumber" | "MessageDeduplicationId" | "MessageGroupId" | "AWSTraceHeader" | "DeadLetterQueueSourceArn" | (string & {});
export declare const MessageSystemAttributeName: S.String;
export type MessageSystemAttributeList = MessageSystemAttributeName[];
export declare const MessageSystemAttributeList: S.$Array<S.String>;
export type MessageAttributeNameList = string[];
export declare const MessageAttributeNameList: S.$Array<S.String>;
export interface ReceiveMessageRequest {
    QueueUrl: string;
    AttributeNames?: QueueAttributeName[];
    MessageSystemAttributeNames?: MessageSystemAttributeName[];
    MessageAttributeNames?: string[];
    MaxNumberOfMessages?: number;
    VisibilityTimeout?: number;
    WaitTimeSeconds?: number;
    ReceiveRequestAttemptId?: string;
}
export declare const ReceiveMessageRequest: S.Schema<ReceiveMessageRequest>;
export type MessageSystemAttributeMap = {
    [key in MessageSystemAttributeName]?: string;
};
export declare const MessageSystemAttributeMap: S.$Record<S.String, S.optional<S.String>>;
export type StringList = string[];
export declare const StringList: S.$Array<S.String>;
export type BinaryList = Uint8Array[];
export declare const BinaryList: S.$Array<S.decodeTo<S.instanceOf<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>, S.String, never, never>>;
export interface MessageAttributeValue {
    StringValue?: string;
    BinaryValue?: Uint8Array;
    StringListValues?: string[];
    BinaryListValues?: Uint8Array[];
    DataType: string;
}
export declare const MessageAttributeValue: S.Schema<MessageAttributeValue>;
export type MessageBodyAttributeMap = {
    [key: string]: MessageAttributeValue | undefined;
};
export declare const MessageBodyAttributeMap: S.$Record<S.String, S.optional<S.Schema<MessageAttributeValue>>>;
export interface Message {
    MessageId?: string;
    ReceiptHandle?: string;
    MD5OfBody?: string;
    Body?: string;
    Attributes?: {
        [key: string]: string | undefined;
    };
    MD5OfMessageAttributes?: string;
    MessageAttributes?: {
        [key: string]: MessageAttributeValue | undefined;
    };
}
export declare const Message: S.Schema<Message>;
export type MessageList = Message[];
export declare const MessageList: S.$Array<S.Schema<Message>>;
export interface ReceiveMessageResult {
    Messages?: Message[];
}
export declare const ReceiveMessageResult: S.Schema<ReceiveMessageResult>;
export interface RemovePermissionRequest {
    QueueUrl: string;
    Label: string;
}
export declare const RemovePermissionRequest: S.Schema<RemovePermissionRequest>;
export interface RemovePermissionResponse {
}
export declare const RemovePermissionResponse: S.Schema<RemovePermissionResponse>;
export type MessageSystemAttributeNameForSends = "AWSTraceHeader" | (string & {});
export declare const MessageSystemAttributeNameForSends: S.String;
export interface MessageSystemAttributeValue {
    StringValue?: string;
    BinaryValue?: Uint8Array;
    StringListValues?: string[];
    BinaryListValues?: Uint8Array[];
    DataType: string;
}
export declare const MessageSystemAttributeValue: S.Schema<MessageSystemAttributeValue>;
export type MessageBodySystemAttributeMap = {
    [key in MessageSystemAttributeNameForSends]?: MessageSystemAttributeValue;
};
export declare const MessageBodySystemAttributeMap: S.$Record<S.String, S.optional<S.Schema<MessageSystemAttributeValue>>>;
export interface SendMessageRequest {
    QueueUrl: string;
    MessageBody: string;
    DelaySeconds?: number;
    MessageAttributes?: {
        [key: string]: MessageAttributeValue | undefined;
    };
    MessageSystemAttributes?: {
        [key: string]: MessageSystemAttributeValue | undefined;
    };
    MessageDeduplicationId?: string;
    MessageGroupId?: string;
}
export declare const SendMessageRequest: S.Schema<SendMessageRequest>;
export interface SendMessageResult {
    MD5OfMessageBody?: string;
    MD5OfMessageAttributes?: string;
    MD5OfMessageSystemAttributes?: string;
    MessageId?: string;
    SequenceNumber?: string;
}
export declare const SendMessageResult: S.Schema<SendMessageResult>;
export interface SendMessageBatchRequestEntry {
    Id: string;
    MessageBody: string;
    DelaySeconds?: number;
    MessageAttributes?: {
        [key: string]: MessageAttributeValue | undefined;
    };
    MessageSystemAttributes?: {
        [key: string]: MessageSystemAttributeValue | undefined;
    };
    MessageDeduplicationId?: string;
    MessageGroupId?: string;
}
export declare const SendMessageBatchRequestEntry: S.Schema<SendMessageBatchRequestEntry>;
export type SendMessageBatchRequestEntryList = SendMessageBatchRequestEntry[];
export declare const SendMessageBatchRequestEntryList: S.$Array<S.Schema<SendMessageBatchRequestEntry>>;
export interface SendMessageBatchRequest {
    QueueUrl: string;
    Entries: SendMessageBatchRequestEntry[];
}
export declare const SendMessageBatchRequest: S.Schema<SendMessageBatchRequest>;
export interface SendMessageBatchResultEntry {
    Id: string;
    MessageId: string;
    MD5OfMessageBody: string;
    MD5OfMessageAttributes?: string;
    MD5OfMessageSystemAttributes?: string;
    SequenceNumber?: string;
}
export declare const SendMessageBatchResultEntry: S.Schema<SendMessageBatchResultEntry>;
export type SendMessageBatchResultEntryList = SendMessageBatchResultEntry[];
export declare const SendMessageBatchResultEntryList: S.$Array<S.Schema<SendMessageBatchResultEntry>>;
export interface SendMessageBatchResult {
    Successful: SendMessageBatchResultEntry[];
    Failed?: BatchResultErrorEntry[];
}
export declare const SendMessageBatchResult: S.Schema<SendMessageBatchResult>;
export interface SetQueueAttributesRequest {
    QueueUrl: string;
    Attributes: {
        [key: string]: string | undefined;
    };
}
export declare const SetQueueAttributesRequest: S.Schema<SetQueueAttributesRequest>;
export interface SetQueueAttributesResponse {
}
export declare const SetQueueAttributesResponse: S.Schema<SetQueueAttributesResponse>;
export interface StartMessageMoveTaskRequest {
    SourceArn: string;
    DestinationArn?: string;
    MaxNumberOfMessagesPerSecond?: number;
}
export declare const StartMessageMoveTaskRequest: S.Schema<StartMessageMoveTaskRequest>;
export interface StartMessageMoveTaskResult {
    TaskHandle?: string;
}
export declare const StartMessageMoveTaskResult: S.Schema<StartMessageMoveTaskResult>;
export interface TagQueueRequest {
    QueueUrl: string;
    Tags: {
        [key: string]: string | undefined;
    };
}
export declare const TagQueueRequest: S.Schema<TagQueueRequest>;
export interface TagQueueResponse {
}
export declare const TagQueueResponse: S.Schema<TagQueueResponse>;
export type TagKeyList = string[];
export declare const TagKeyList: S.$Array<S.String>;
export interface UntagQueueRequest {
    QueueUrl: string;
    TagKeys: string[];
}
export declare const UntagQueueRequest: S.Schema<UntagQueueRequest>;
export interface UntagQueueResponse {
}
export declare const UntagQueueResponse: S.Schema<UntagQueueResponse>;
declare const InvalidAddress_base: S.Class<InvalidAddress, S.TaggedStruct<"InvalidAddress", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class InvalidAddress extends InvalidAddress_base {
}
declare const InvalidSecurity_base: S.Class<InvalidSecurity, S.TaggedStruct<"InvalidSecurity", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AuthError: true;
    };
});
export declare class InvalidSecurity extends InvalidSecurity_base {
}
declare const OverLimit_base: S.Class<OverLimit, S.TaggedStruct<"OverLimit", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AuthError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        QuotaError: true;
    };
});
export declare class OverLimit extends OverLimit_base {
}
declare const QueueDoesNotExist_base: S.Class<QueueDoesNotExist, S.TaggedStruct<"QueueDoesNotExist", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class QueueDoesNotExist extends QueueDoesNotExist_base {
}
declare const RequestThrottled_base: S.Class<RequestThrottled, S.TaggedStruct<"RequestThrottled", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AuthError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ThrottlingError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        RetryableError: true;
    };
});
export declare class RequestThrottled extends RequestThrottled_base {
}
declare const UnsupportedOperation_base: S.Class<UnsupportedOperation, S.TaggedStruct<"UnsupportedOperation", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class UnsupportedOperation extends UnsupportedOperation_base {
}
declare const ResourceNotFoundException_base: S.Class<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
}
declare const RequestLimitExceeded_base: S.Class<RequestLimitExceeded, S.TaggedStruct<"RequestLimitExceeded", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ThrottlingError: true;
    };
});
export declare class RequestLimitExceeded extends RequestLimitExceeded_base {
}
declare const InvalidParameterValueException_base: S.Class<InvalidParameterValueException, S.TaggedStruct<"InvalidParameterValueException", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class InvalidParameterValueException extends InvalidParameterValueException_base {
}
declare const MessageNotInflight_base: S.Class<MessageNotInflight, S.TaggedStruct<"MessageNotInflight", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class MessageNotInflight extends MessageNotInflight_base {
}
declare const ReceiptHandleIsInvalid_base: S.Class<ReceiptHandleIsInvalid, S.TaggedStruct<"ReceiptHandleIsInvalid", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ReceiptHandleIsInvalid extends ReceiptHandleIsInvalid_base {
}
declare const BatchEntryIdsNotDistinct_base: S.Class<BatchEntryIdsNotDistinct, S.TaggedStruct<"BatchEntryIdsNotDistinct", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class BatchEntryIdsNotDistinct extends BatchEntryIdsNotDistinct_base {
}
declare const EmptyBatchRequest_base: S.Class<EmptyBatchRequest, S.TaggedStruct<"EmptyBatchRequest", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class EmptyBatchRequest extends EmptyBatchRequest_base {
}
declare const InvalidBatchEntryId_base: S.Class<InvalidBatchEntryId, S.TaggedStruct<"InvalidBatchEntryId", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class InvalidBatchEntryId extends InvalidBatchEntryId_base {
}
declare const TooManyEntriesInBatchRequest_base: S.Class<TooManyEntriesInBatchRequest, S.TaggedStruct<"TooManyEntriesInBatchRequest", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class TooManyEntriesInBatchRequest extends TooManyEntriesInBatchRequest_base {
}
declare const InvalidAttributeName_base: S.Class<InvalidAttributeName, S.TaggedStruct<"InvalidAttributeName", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class InvalidAttributeName extends InvalidAttributeName_base {
}
declare const InvalidAttributeValue_base: S.Class<InvalidAttributeValue, S.TaggedStruct<"InvalidAttributeValue", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class InvalidAttributeValue extends InvalidAttributeValue_base {
}
declare const QueueDeletedRecently_base: S.Class<QueueDeletedRecently, S.TaggedStruct<"QueueDeletedRecently", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class QueueDeletedRecently extends QueueDeletedRecently_base {
}
declare const QueueNameExists_base: S.Class<QueueNameExists, S.TaggedStruct<"QueueNameExists", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class QueueNameExists extends QueueNameExists_base {
}
declare const InvalidIdFormat_base: S.Class<InvalidIdFormat, S.TaggedStruct<"InvalidIdFormat", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class InvalidIdFormat extends InvalidIdFormat_base {
}
declare const PurgeQueueInProgress_base: S.Class<PurgeQueueInProgress, S.TaggedStruct<"PurgeQueueInProgress", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AuthError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ConflictError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        RetryableError: true;
    };
});
export declare class PurgeQueueInProgress extends PurgeQueueInProgress_base {
}
declare const KmsAccessDenied_base: S.Class<KmsAccessDenied, S.TaggedStruct<"KmsAccessDenied", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AuthError: true;
    };
});
export declare class KmsAccessDenied extends KmsAccessDenied_base {
}
declare const KmsDisabled_base: S.Class<KmsDisabled, S.TaggedStruct<"KmsDisabled", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class KmsDisabled extends KmsDisabled_base {
}
declare const KmsInvalidKeyUsage_base: S.Class<KmsInvalidKeyUsage, S.TaggedStruct<"KmsInvalidKeyUsage", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class KmsInvalidKeyUsage extends KmsInvalidKeyUsage_base {
}
declare const KmsInvalidState_base: S.Class<KmsInvalidState, S.TaggedStruct<"KmsInvalidState", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class KmsInvalidState extends KmsInvalidState_base {
}
declare const KmsNotFound_base: S.Class<KmsNotFound, S.TaggedStruct<"KmsNotFound", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class KmsNotFound extends KmsNotFound_base {
}
declare const KmsOptInRequired_base: S.Class<KmsOptInRequired, S.TaggedStruct<"KmsOptInRequired", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AuthError: true;
    };
});
export declare class KmsOptInRequired extends KmsOptInRequired_base {
}
declare const KmsThrottled_base: S.Class<KmsThrottled, S.TaggedStruct<"KmsThrottled", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ThrottlingError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        RetryableError: true;
    };
});
export declare class KmsThrottled extends KmsThrottled_base {
}
declare const InvalidMessageContents_base: S.Class<InvalidMessageContents, S.TaggedStruct<"InvalidMessageContents", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class InvalidMessageContents extends InvalidMessageContents_base {
}
declare const MissingRequiredParameterException_base: S.Class<MissingRequiredParameterException, S.TaggedStruct<"MissingRequiredParameterException", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class MissingRequiredParameterException extends MissingRequiredParameterException_base {
}
declare const BatchRequestTooLong_base: S.Class<BatchRequestTooLong, S.TaggedStruct<"BatchRequestTooLong", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class BatchRequestTooLong extends BatchRequestTooLong_base {
}
declare const ParseError_base: S.Class<ParseError, S.TaggedStruct<"ParseError", {}>, import("effect/Cause").YieldableError>;
export declare class ParseError extends ParseError_base {
}
declare const CommonServiceException_base: S.Class<CommonServiceException, S.TaggedStruct<"CommonServiceException", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ServerError: true;
    };
});
export declare class CommonServiceException extends CommonServiceException_base {
}
export type AddPermissionError = InvalidAddress | InvalidSecurity | OverLimit | QueueDoesNotExist | RequestThrottled | UnsupportedOperation | CommonErrors;
/**
 * Adds a permission to a queue for a specific principal. This allows sharing
 * access to the queue.
 *
 * When you create a queue, you have full control access rights for the queue. Only you,
 * the owner of the queue, can grant or deny permissions to the queue. For more information
 * about these permissions, see Allow Developers to Write Messages to a Shared Queue in the Amazon SQS
 * Developer Guide.
 *
 * - `AddPermission` generates a policy for you. You can use
 *
 * SetQueueAttributes
 * to upload your
 * policy. For more information, see Using Custom Policies with the Amazon SQS Access Policy Language in
 * the *Amazon SQS Developer Guide*.
 *
 * - An Amazon SQS policy can have a maximum of seven actions per statement.
 *
 * - To remove the ability to change queue permissions, you must deny permission to the `AddPermission`, `RemovePermission`, and `SetQueueAttributes` actions in your IAM policy.
 *
 * - Amazon SQS `AddPermission` does not support adding a non-account
 * principal.
 *
 * Cross-account permissions don't apply to this action. For more information,
 * see Grant
 * cross-account permissions to a role and a username in the *Amazon SQS Developer Guide*.
 */
export declare const addPermission: API.OperationMethod<AddPermissionRequest, AddPermissionResponse, AddPermissionError, Credentials | Region | HttpClient.HttpClient>;
export type CancelMessageMoveTaskError = InvalidAddress | InvalidSecurity | RequestThrottled | ResourceNotFoundException | UnsupportedOperation | RequestLimitExceeded | InvalidParameterValueException | CommonErrors;
/**
 * Cancels a specified message movement task. A message movement can only be cancelled
 * when the current status is RUNNING. Cancelling a message movement task does not revert
 * the messages that have already been moved. It can only stop the messages that have not
 * been moved yet.
 *
 * - This action is currently limited to supporting message redrive from dead-letter queues (DLQs) only. In this context, the source
 * queue is the dead-letter queue (DLQ), while the destination queue can be the
 * original source queue (from which the messages were driven to the
 * dead-letter-queue), or a custom destination queue.
 *
 * - Only one active message movement task is supported per queue at any given
 * time.
 */
export declare const cancelMessageMoveTask: API.OperationMethod<CancelMessageMoveTaskRequest, CancelMessageMoveTaskResult, CancelMessageMoveTaskError, Credentials | Region | HttpClient.HttpClient>;
export type ChangeMessageVisibilityError = InvalidAddress | InvalidSecurity | MessageNotInflight | QueueDoesNotExist | ReceiptHandleIsInvalid | RequestThrottled | UnsupportedOperation | CommonErrors;
/**
 * Changes the visibility timeout of a specified message in a queue to a new value. The
 * default visibility timeout for a message is 30 seconds. The minimum is 0 seconds. The
 * maximum is 12 hours. For more information, see Visibility Timeout in the Amazon SQS Developer
 * Guide.
 *
 * For example, if the default timeout for a queue is 60 seconds, 15 seconds have elapsed
 * since you received the message, and you send a ChangeMessageVisibility call with
 * `VisibilityTimeout` set to 10 seconds, the 10 seconds begin to count from
 * the time that you make the `ChangeMessageVisibility` call. Thus, any attempt
 * to change the visibility timeout or to delete that message 10 seconds after you
 * initially change the visibility timeout (a total of 25 seconds) might result in an
 * error.
 *
 * An Amazon SQS message has three basic states:
 *
 * - Sent to a queue by a producer.
 *
 * - Received from the queue by a consumer.
 *
 * - Deleted from the queue.
 *
 * A message is considered to be *stored* after it is sent to a queue by a producer, but not yet received from the queue by a consumer (that is, between states 1 and 2). There is no limit to the number of stored messages.
 * A message is considered to be *in flight* after it is received from a queue by a consumer, but not yet deleted from the queue (that is, between states 2 and 3). There is a limit to the number of in flight messages.
 *
 * Limits that apply to in flight messages are unrelated to the *unlimited* number of stored messages.
 *
 * For most standard queues (depending on queue traffic and message backlog), there can be a maximum of approximately 120,000 in flight messages (received from a queue by a consumer, but not yet deleted from the queue).
 * If you reach this limit, Amazon SQS returns the `OverLimit` error message.
 * To avoid reaching the limit, you should delete messages from the queue after they're processed. You can also increase the number of queues you use to process your messages.
 * To request a limit increase, file a support request.
 *
 * For FIFO queues, there can be a maximum of 120,000 in flight messages (received from a queue by a consumer, but not yet deleted from the queue). If you reach this limit, Amazon SQS returns no error messages.
 *
 * If you attempt to set the `VisibilityTimeout` to a value greater than
 * the maximum time left, Amazon SQS returns an error. Amazon SQS doesn't automatically
 * recalculate and increase the timeout to the maximum remaining time.
 *
 * Unlike with a queue, when you change the visibility timeout for a specific message
 * the timeout value is applied immediately but isn't saved in memory for that message.
 * If you don't delete a message after it is received, the visibility timeout for the
 * message reverts to the original timeout value (not to the value you set using the
 * `ChangeMessageVisibility` action) the next time the message is
 * received.
 */
export declare const changeMessageVisibility: API.OperationMethod<ChangeMessageVisibilityRequest, ChangeMessageVisibilityResponse, ChangeMessageVisibilityError, Credentials | Region | HttpClient.HttpClient>;
export type ChangeMessageVisibilityBatchError = BatchEntryIdsNotDistinct | EmptyBatchRequest | InvalidAddress | InvalidBatchEntryId | InvalidSecurity | QueueDoesNotExist | RequestThrottled | TooManyEntriesInBatchRequest | UnsupportedOperation | CommonErrors;
/**
 * Changes the visibility timeout of multiple messages. This is a batch version of
 *
 * ChangeMessageVisibility. The result of the action
 * on each message is reported individually in the response. You can send up to 10
 *
 * ChangeMessageVisibility
 * requests with each
 * `ChangeMessageVisibilityBatch` action.
 *
 * Because the batch request can result in a combination of successful and unsuccessful actions, you should check for batch errors even when the call returns an HTTP status code of `200`.
 */
export declare const changeMessageVisibilityBatch: API.OperationMethod<ChangeMessageVisibilityBatchRequest, ChangeMessageVisibilityBatchResult, ChangeMessageVisibilityBatchError, Credentials | Region | HttpClient.HttpClient>;
export type CreateQueueError = InvalidAddress | InvalidAttributeName | InvalidAttributeValue | InvalidSecurity | QueueDeletedRecently | QueueNameExists | RequestThrottled | UnsupportedOperation | RequestLimitExceeded | InvalidParameterValueException | CommonErrors;
/**
 * Creates a new standard or FIFO queue. You can pass one or more attributes in
 * the request. Keep the following in mind:
 *
 * - If you don't specify the `FifoQueue` attribute, Amazon SQS creates a standard queue.
 *
 * You can't change the queue type after you create it and you can't convert
 * an existing standard queue into a FIFO queue. You must either create a new
 * FIFO queue for your application or delete your existing standard queue and
 * recreate it as a FIFO queue. For more information, see Moving From a standard queue to a FIFO queue in the
 * *Amazon SQS Developer Guide*.
 *
 * - If you don't provide a value for an attribute, the queue is created with the
 * default value for the attribute.
 *
 * - If you delete a queue, you must wait at least 60 seconds before creating a
 * queue with the same name.
 *
 * To successfully create a new queue, you must provide a queue name that adheres to the
 * limits
 * related to queues and is unique within the scope of your queues.
 *
 * After you create a queue, you must wait at least one second after the queue is
 * created to be able to use the queue.
 *
 * To retrieve the URL of a queue, use the
 * `GetQueueUrl`
 * action. This action only requires the
 * `QueueName`
 * parameter.
 *
 * When creating queues, keep the following points in mind:
 *
 * - If you specify the name of an existing queue and provide the exact same names
 * and values for all its attributes, the
 * `CreateQueue`
 * action will return the URL of the
 * existing queue instead of creating a new one.
 *
 * - If you attempt to create a queue with a name that already exists but with
 * different attribute names or values, the `CreateQueue` action will
 * return an error. This ensures that existing queues are not inadvertently
 * altered.
 *
 * Cross-account permissions don't apply to this action. For more information,
 * see Grant
 * cross-account permissions to a role and a username in the *Amazon SQS Developer Guide*.
 */
export declare const createQueue: API.OperationMethod<CreateQueueRequest, CreateQueueResult, CreateQueueError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteMessageError = InvalidAddress | InvalidIdFormat | InvalidSecurity | QueueDoesNotExist | ReceiptHandleIsInvalid | RequestThrottled | UnsupportedOperation | CommonErrors;
/**
 * Deletes the specified message from the specified queue. To select the message to
 * delete, use the `ReceiptHandle` of the message (*not* the
 * `MessageId` which you receive when you send the message). Amazon SQS can
 * delete a message from a queue even if a visibility timeout setting causes the message to
 * be locked by another consumer. Amazon SQS automatically deletes messages left in a queue
 * longer than the retention period configured for the queue.
 *
 * Each time you receive a message, meaning when a consumer retrieves a message from
 * the queue, it comes with a unique `ReceiptHandle`. If you receive the
 * same message more than once, you will get a different `ReceiptHandle`
 * each time. When you want to delete a message using the `DeleteMessage`
 * action, you must use the `ReceiptHandle` from the most recent time you
 * received the message. If you use an old `ReceiptHandle`, the request will
 * succeed, but the message might not be deleted.
 *
 * For standard queues, it is possible to receive a message even after you
 * delete it. This might happen on rare occasions if one of the servers which stores a
 * copy of the message is unavailable when you send the request to delete the message.
 * The copy remains on the server and might be returned to you during a subsequent
 * receive request. You should ensure that your application is idempotent, so that
 * receiving a message more than once does not cause issues.
 */
export declare const deleteMessage: API.OperationMethod<DeleteMessageRequest, DeleteMessageResponse, DeleteMessageError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteMessageBatchError = BatchEntryIdsNotDistinct | EmptyBatchRequest | InvalidAddress | InvalidBatchEntryId | InvalidSecurity | QueueDoesNotExist | RequestThrottled | TooManyEntriesInBatchRequest | UnsupportedOperation | CommonErrors;
/**
 * Deletes up to ten messages from the specified queue. This is a batch version of
 *
 * DeleteMessage. The result of the action on each
 * message is reported individually in the response.
 *
 * Because the batch request can result in a combination of successful and unsuccessful actions, you should check for batch errors even when the call returns an HTTP status code of `200`.
 */
export declare const deleteMessageBatch: API.OperationMethod<DeleteMessageBatchRequest, DeleteMessageBatchResult, DeleteMessageBatchError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteQueueError = InvalidAddress | InvalidSecurity | QueueDoesNotExist | RequestThrottled | UnsupportedOperation | CommonErrors;
/**
 * Deletes the queue specified by the `QueueUrl`, regardless of the queue's
 * contents.
 *
 * Be careful with the `DeleteQueue` action: When you delete a queue, any
 * messages in the queue are no longer available.
 *
 * When you delete a queue, the deletion process takes up to 60 seconds. Requests you
 * send involving that queue during the 60 seconds might succeed. For example, a
 *
 * SendMessage
 * request might succeed, but after 60
 * seconds the queue and the message you sent no longer exist.
 *
 * When you delete a queue, you must wait at least 60 seconds before creating a queue
 * with the same name.
 *
 * Cross-account permissions don't apply to this action. For more information,
 * see Grant
 * cross-account permissions to a role and a username in the *Amazon SQS Developer Guide*.
 *
 * The delete operation uses the HTTP `GET` verb.
 */
export declare const deleteQueue: API.OperationMethod<DeleteQueueRequest, DeleteQueueResponse, DeleteQueueError, Credentials | Region | HttpClient.HttpClient>;
export type GetQueueAttributesError = InvalidAddress | InvalidAttributeName | InvalidSecurity | QueueDoesNotExist | RequestThrottled | UnsupportedOperation | CommonErrors;
/**
 * Gets attributes for the specified queue.
 *
 * To determine whether a queue is FIFO, you can check whether `QueueName` ends with the `.fifo` suffix.
 */
export declare const getQueueAttributes: API.OperationMethod<GetQueueAttributesRequest, GetQueueAttributesResult, GetQueueAttributesError, Credentials | Region | HttpClient.HttpClient>;
export type GetQueueUrlError = InvalidAddress | InvalidSecurity | QueueDoesNotExist | RequestThrottled | UnsupportedOperation | CommonErrors;
/**
 * The `GetQueueUrl` API returns the URL of an existing Amazon SQS queue. This is
 * useful when you know the queue's name but need to retrieve its URL for further
 * operations.
 *
 * To access a queue owned by another Amazon Web Services account, use the
 * `QueueOwnerAWSAccountId` parameter to specify the account ID of the
 * queue's owner. Note that the queue owner must grant you the necessary permissions to
 * access the queue. For more information about accessing shared queues, see the
 *
 * AddPermission
 * API or Allow developers to write messages to a shared queue in the Amazon SQS
 * Developer Guide.
 */
export declare const getQueueUrl: API.OperationMethod<GetQueueUrlRequest, GetQueueUrlResult, GetQueueUrlError, Credentials | Region | HttpClient.HttpClient>;
export type ListDeadLetterSourceQueuesError = InvalidAddress | InvalidSecurity | QueueDoesNotExist | RequestThrottled | UnsupportedOperation | CommonErrors;
/**
 * Returns a list of your queues that have the `RedrivePolicy` queue attribute
 * configured with a dead-letter queue.
 *
 * The `ListDeadLetterSourceQueues` methods supports pagination. Set
 * parameter `MaxResults` in the request to specify the maximum number of
 * results to be returned in the response. If you do not set `MaxResults`, the
 * response includes a maximum of 1,000 results. If you set `MaxResults` and
 * there are additional results to display, the response includes a value for
 * `NextToken`. Use `NextToken` as a parameter in your next
 * request to `ListDeadLetterSourceQueues` to receive the next page of results.
 *
 * For more information about using dead-letter queues, see Using Amazon SQS Dead-Letter Queues in the Amazon SQS Developer
 * Guide.
 */
export declare const listDeadLetterSourceQueues: API.OperationMethod<ListDeadLetterSourceQueuesRequest, ListDeadLetterSourceQueuesResult, ListDeadLetterSourceQueuesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListDeadLetterSourceQueuesRequest) => stream.Stream<ListDeadLetterSourceQueuesResult, ListDeadLetterSourceQueuesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListDeadLetterSourceQueuesRequest) => stream.Stream<string, ListDeadLetterSourceQueuesError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListMessageMoveTasksError = InvalidAddress | InvalidSecurity | RequestThrottled | ResourceNotFoundException | UnsupportedOperation | RequestLimitExceeded | InvalidParameterValueException | CommonErrors;
/**
 * Gets the most recent message movement tasks (up to 10) under a specific source
 * queue.
 *
 * - This action is currently limited to supporting message redrive from dead-letter queues (DLQs) only. In this context, the source
 * queue is the dead-letter queue (DLQ), while the destination queue can be the
 * original source queue (from which the messages were driven to the
 * dead-letter-queue), or a custom destination queue.
 *
 * - Only one active message movement task is supported per queue at any given
 * time.
 */
export declare const listMessageMoveTasks: API.OperationMethod<ListMessageMoveTasksRequest, ListMessageMoveTasksResult, ListMessageMoveTasksError, Credentials | Region | HttpClient.HttpClient>;
export type ListQueuesError = InvalidAddress | InvalidSecurity | RequestThrottled | UnsupportedOperation | CommonErrors;
/**
 * Returns a list of your queues in the current region. The response includes a maximum
 * of 1,000 results. If you specify a value for the optional `QueueNamePrefix`
 * parameter, only queues with a name that begins with the specified value are
 * returned.
 *
 * The `listQueues` methods supports pagination. Set parameter
 * `MaxResults` in the request to specify the maximum number of results to
 * be returned in the response. If you do not set `MaxResults`, the response
 * includes a maximum of 1,000 results. If you set `MaxResults` and there are
 * additional results to display, the response includes a value for `NextToken`.
 * Use `NextToken` as a parameter in your next request to
 * `listQueues` to receive the next page of results.
 *
 * Cross-account permissions don't apply to this action. For more information,
 * see Grant
 * cross-account permissions to a role and a username in the *Amazon SQS Developer Guide*.
 */
export declare const listQueues: API.OperationMethod<ListQueuesRequest, ListQueuesResult, ListQueuesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListQueuesRequest) => stream.Stream<ListQueuesResult, ListQueuesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListQueuesRequest) => stream.Stream<string, ListQueuesError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListQueueTagsError = InvalidAddress | InvalidSecurity | QueueDoesNotExist | RequestThrottled | UnsupportedOperation | CommonErrors;
/**
 * List all cost allocation tags added to the specified Amazon SQS queue.
 * For an overview, see Tagging
 * Your Amazon SQS Queues in the *Amazon SQS Developer Guide*.
 *
 * Cross-account permissions don't apply to this action. For more information,
 * see Grant
 * cross-account permissions to a role and a username in the *Amazon SQS Developer Guide*.
 */
export declare const listQueueTags: API.OperationMethod<ListQueueTagsRequest, ListQueueTagsResult, ListQueueTagsError, Credentials | Region | HttpClient.HttpClient>;
export type PurgeQueueError = InvalidAddress | InvalidSecurity | PurgeQueueInProgress | QueueDoesNotExist | RequestThrottled | UnsupportedOperation | CommonErrors;
/**
 * Deletes available messages in a queue (including in-flight messages) specified by the
 * `QueueURL` parameter.
 *
 * When you use the `PurgeQueue` action, you can't retrieve any messages
 * deleted from a queue.
 *
 * The message deletion process takes up to 60 seconds. We recommend waiting for 60
 * seconds regardless of your queue's size.
 *
 * Messages sent to the queue *before* you call
 * `PurgeQueue` might be received but are deleted within the next
 * minute.
 *
 * Messages sent to the queue *after* you call `PurgeQueue`
 * might be deleted while the queue is being purged.
 */
export declare const purgeQueue: API.OperationMethod<PurgeQueueRequest, PurgeQueueResponse, PurgeQueueError, Credentials | Region | HttpClient.HttpClient>;
export type ReceiveMessageError = InvalidAddress | InvalidSecurity | KmsAccessDenied | KmsDisabled | KmsInvalidKeyUsage | KmsInvalidState | KmsNotFound | KmsOptInRequired | KmsThrottled | OverLimit | QueueDoesNotExist | RequestThrottled | UnsupportedOperation | RequestLimitExceeded | InvalidParameterValueException | CommonErrors;
/**
 * Retrieves one or more messages (up to 10), from the specified queue. Using the
 * `WaitTimeSeconds` parameter enables long-poll support. For more
 * information, see Amazon SQS
 * Long Polling in the *Amazon SQS Developer Guide*.
 *
 * Short poll is the default behavior where a weighted random set of machines is sampled
 * on a `ReceiveMessage` call. Therefore, only the messages on the sampled
 * machines are returned. If the number of messages in the queue is small (fewer than
 * 1,000), you most likely get fewer messages than you requested per
 * `ReceiveMessage` call. If the number of messages in the queue is
 * extremely small, you might not receive any messages in a particular
 * `ReceiveMessage` response. If this happens, repeat the request.
 *
 * For each message returned, the response includes the following:
 *
 * - The message body.
 *
 * - An MD5 digest of the message body. For information about MD5, see RFC1321.
 *
 * - The `MessageId` you received when you sent the message to the
 * queue.
 *
 * - The receipt handle.
 *
 * - The message attributes.
 *
 * - An MD5 digest of the message attributes.
 *
 * The receipt handle is the identifier you must provide when deleting the message. For
 * more information, see Queue and Message Identifiers in the Amazon SQS Developer
 * Guide.
 *
 * You can provide the `VisibilityTimeout` parameter in your request. The
 * parameter is applied to the messages that Amazon SQS returns in the response. If you don't
 * include the parameter, the overall visibility timeout for the queue is used for the
 * returned messages. The default visibility timeout for a queue is 30 seconds.
 *
 * In the future, new attributes might be added. If you write code that calls this action, we recommend that you structure your code so that it can handle new attributes gracefully.
 */
export declare const receiveMessage: API.OperationMethod<ReceiveMessageRequest, ReceiveMessageResult, ReceiveMessageError, Credentials | Region | HttpClient.HttpClient>;
export type RemovePermissionError = InvalidAddress | InvalidSecurity | QueueDoesNotExist | RequestThrottled | UnsupportedOperation | CommonErrors;
/**
 * Revokes any permissions in the queue policy that matches the specified
 * `Label` parameter.
 *
 * - Only the owner of a queue can remove permissions from it.
 *
 * - Cross-account permissions don't apply to this action. For more information,
 * see Grant
 * cross-account permissions to a role and a username in the *Amazon SQS Developer Guide*.
 *
 * - To remove the ability to change queue permissions, you must deny permission to the `AddPermission`, `RemovePermission`, and `SetQueueAttributes` actions in your IAM policy.
 */
export declare const removePermission: API.OperationMethod<RemovePermissionRequest, RemovePermissionResponse, RemovePermissionError, Credentials | Region | HttpClient.HttpClient>;
export type SendMessageError = InvalidAddress | InvalidMessageContents | InvalidSecurity | KmsAccessDenied | KmsDisabled | KmsInvalidKeyUsage | KmsInvalidState | KmsNotFound | KmsOptInRequired | KmsThrottled | QueueDoesNotExist | RequestThrottled | UnsupportedOperation | RequestLimitExceeded | InvalidParameterValueException | MissingRequiredParameterException | CommonErrors;
/**
 * Delivers a message to the specified queue.
 *
 * A message can include only XML, JSON, and unformatted text. The following Unicode characters are allowed. For more information, see the W3C specification for characters.
 *
 * `#x9` | `#xA` | `#xD` | `#x20` to `#xD7FF` | `#xE000` to `#xFFFD` | `#x10000` to `#x10FFFF`
 *
 * If a message contains characters outside the allowed set, Amazon SQS rejects the message and returns an InvalidMessageContents error. Ensure that your message body includes only valid characters to avoid this exception.
 */
export declare const sendMessage: API.OperationMethod<SendMessageRequest, SendMessageResult, SendMessageError, Credentials | Region | HttpClient.HttpClient>;
export type SendMessageBatchError = BatchEntryIdsNotDistinct | BatchRequestTooLong | EmptyBatchRequest | InvalidAddress | InvalidBatchEntryId | InvalidSecurity | KmsAccessDenied | KmsDisabled | KmsInvalidKeyUsage | KmsInvalidState | KmsNotFound | KmsOptInRequired | KmsThrottled | QueueDoesNotExist | RequestThrottled | TooManyEntriesInBatchRequest | UnsupportedOperation | RequestLimitExceeded | InvalidParameterValueException | ParseError | CommonErrors;
/**
 * You can use `SendMessageBatch` to send up to 10 messages to the specified
 * queue by assigning either identical or different values to each message (or by not
 * assigning values at all). This is a batch version of
 * SendMessage. For a FIFO queue, multiple messages within a single batch are enqueued
 * in the order they are sent.
 *
 * The result of sending each message is reported individually in the response.
 * Because the batch request can result in a combination of successful and unsuccessful actions, you should check for batch errors even when the call returns an HTTP status code of `200`.
 *
 * The maximum allowed individual message size and the maximum total payload size (the
 * sum of the individual lengths of all of the batched messages) are both 1 MiB
 * 1,048,576 bytes.
 *
 * A message can include only XML, JSON, and unformatted text. The following Unicode characters are allowed. For more information, see the W3C specification for characters.
 *
 * `#x9` | `#xA` | `#xD` | `#x20` to `#xD7FF` | `#xE000` to `#xFFFD` | `#x10000` to `#x10FFFF`
 *
 * If a message contains characters outside the allowed set, Amazon SQS rejects the message and returns an InvalidMessageContents error. Ensure that your message body includes only valid characters to avoid this exception.
 *
 * If you don't specify the `DelaySeconds` parameter for an entry, Amazon SQS uses
 * the default value for the queue.
 */
export declare const sendMessageBatch: API.OperationMethod<SendMessageBatchRequest, SendMessageBatchResult, SendMessageBatchError, Credentials | Region | HttpClient.HttpClient>;
export type SetQueueAttributesError = InvalidAddress | InvalidAttributeName | InvalidAttributeValue | InvalidSecurity | OverLimit | QueueDoesNotExist | RequestThrottled | UnsupportedOperation | RequestLimitExceeded | CommonServiceException | MissingRequiredParameterException | CommonErrors;
/**
 * Sets the value of one or more queue attributes, like a policy. When you change a
 * queue's attributes, the change can take up to 60 seconds for most of the attributes to
 * propagate throughout the Amazon SQS system. Changes made to the
 * `MessageRetentionPeriod` attribute can take up to 15 minutes and will
 * impact existing messages in the queue potentially causing them to be expired and deleted
 * if the `MessageRetentionPeriod` is reduced below the age of existing
 * messages.
 *
 * - In the future, new attributes might be added. If you write code that calls this action, we recommend that you structure your code so that it can handle new attributes gracefully.
 *
 * - Cross-account permissions don't apply to this action. For more information,
 * see Grant
 * cross-account permissions to a role and a username in the *Amazon SQS Developer Guide*.
 *
 * - To remove the ability to change queue permissions, you must deny permission to the `AddPermission`, `RemovePermission`, and `SetQueueAttributes` actions in your IAM policy.
 */
export declare const setQueueAttributes: API.OperationMethod<SetQueueAttributesRequest, SetQueueAttributesResponse, SetQueueAttributesError, Credentials | Region | HttpClient.HttpClient>;
export type StartMessageMoveTaskError = InvalidAddress | InvalidSecurity | RequestThrottled | ResourceNotFoundException | UnsupportedOperation | RequestLimitExceeded | CommonServiceException | InvalidParameterValueException | CommonErrors;
/**
 * Starts an asynchronous task to move messages from a specified source queue to a
 * specified destination queue.
 *
 * - This action is currently limited to supporting message redrive from queues
 * that are configured as dead-letter queues (DLQs) of other Amazon SQS queues only. Non-SQS
 * queue sources of dead-letter queues, such as Lambda or Amazon SNS topics, are
 * currently not supported.
 *
 * - In dead-letter queues redrive context, the
 * `StartMessageMoveTask` the source queue is the DLQ, while the
 * destination queue can be the original source queue (from which the messages
 * were driven to the dead-letter-queue), or a custom destination queue.
 *
 * - Only one active message movement task is supported per queue at any given
 * time.
 */
export declare const startMessageMoveTask: API.OperationMethod<StartMessageMoveTaskRequest, StartMessageMoveTaskResult, StartMessageMoveTaskError, Credentials | Region | HttpClient.HttpClient>;
export type TagQueueError = InvalidAddress | InvalidSecurity | QueueDoesNotExist | RequestThrottled | UnsupportedOperation | CommonErrors;
/**
 * Add cost allocation tags to the specified Amazon SQS queue. For an overview, see Tagging
 * Your Amazon SQS Queues in the *Amazon SQS Developer Guide*.
 *
 * When you use queue tags, keep the following guidelines in mind:
 *
 * - Adding more than 50 tags to a queue isn't recommended.
 *
 * - Tags don't have any semantic meaning. Amazon SQS interprets tags as character strings.
 *
 * - Tags are case-sensitive.
 *
 * - A new tag with a key identical to that of an existing tag overwrites the existing tag.
 *
 * For a full list of tag restrictions, see
 * Quotas related to queues
 * in the *Amazon SQS Developer Guide*.
 *
 * Cross-account permissions don't apply to this action. For more information,
 * see Grant
 * cross-account permissions to a role and a username in the *Amazon SQS Developer Guide*.
 */
export declare const tagQueue: API.OperationMethod<TagQueueRequest, TagQueueResponse, TagQueueError, Credentials | Region | HttpClient.HttpClient>;
export type UntagQueueError = InvalidAddress | InvalidSecurity | QueueDoesNotExist | RequestThrottled | UnsupportedOperation | CommonErrors;
/**
 * Remove cost allocation tags from the specified Amazon SQS queue. For an overview, see Tagging
 * Your Amazon SQS Queues in the *Amazon SQS Developer Guide*.
 *
 * Cross-account permissions don't apply to this action. For more information,
 * see Grant
 * cross-account permissions to a role and a username in the *Amazon SQS Developer Guide*.
 */
export declare const untagQueue: API.OperationMethod<UntagQueueRequest, UntagQueueResponse, UntagQueueError, Credentials | Region | HttpClient.HttpClient>;
export {};
//# sourceMappingURL=sqs.d.ts.map