import type { QueueHandlerSpec, QueueSpec } from "./internal/service-spec.js";
import { DurationSchedule } from "./schedule.js";
import type { ServiceContext } from "./service.js";
export declare const DEFAULT_QUEUE_VISIBILITY_TIMEOUT: {
    type: "Duration";
    dur: number;
    unit: "second" | "seconds" | "minute" | "minutes" | "hour" | "hours" | "day" | "days" | "year" | "years";
};
/**
 * Context passed to the handler.
 */
export interface QueueHandlerContext {
    /**
     * Information about the queue.
     */
    queue: {
        queueName: string;
        fifo: boolean;
    };
    /**
     * Information about the containing service.
     */
    service: ServiceContext;
}
export interface FifoQueueHandlerMessageItem<Message = any> extends StandardQueueHandlerMessageItem<Message> {
    messageGroupId: string;
    sequenceNumber: string;
    messageDeduplicationId: string;
}
export interface StandardQueueHandlerMessageItem<Message = any> {
    id: string;
    receiptHandle: string;
    message: Message;
    sent: Date;
    receiveCount: number;
}
export interface QueueBatchHandlerFunctionBase<Message = any, MessageItem extends StandardQueueHandlerMessageItem<Message> = StandardQueueHandlerMessageItem<Message>> {
    /**
     * Provides the keys, new value
     */
    (items: MessageItem[], context: QueueHandlerContext): Promise<void | {
        failedMessageIds?: string[];
    }> | void | {
        failedMessageIds?: string[];
    };
}
export type QueueBatchHandlerFunction<Message, Fifo extends boolean | undefined> = Fifo extends true ? FifoQueueBatchHandlerFunction<Message> : StandardQueueBatchHandlerFunction<Message>;
export type StandardQueueBatchHandlerFunction<Message = any> = QueueBatchHandlerFunctionBase<Message, StandardQueueHandlerMessageItem<Message>>;
export type FifoQueueBatchHandlerFunction<Message = any> = QueueBatchHandlerFunctionBase<Message, FifoQueueHandlerMessageItem<Message>>;
export type QueueBatchHandler<Handler extends QueueBatchHandlerFunction<any, any>> = QueueHandlerSpec & {
    handler: Handler;
};
export interface StandardQueueSendMessageOptions {
    delay?: DurationSchedule;
}
export type QueueSendMessageOptions = FifoQueueSendMessageOptions | StandardQueueSendMessageOptions;
export interface FifoQueueSendMessageOptions extends StandardQueueSendMessageOptions {
    group?: string;
    dedupeId?: string;
}
export interface QueueSendMessageBatchEntry<Message, Options extends StandardQueueSendMessageOptions = StandardQueueSendMessageOptions> {
    /**
     * ID of the message. Will be returned if the message fails to send.
     */
    id: string;
    message: Message;
    options?: Options;
}
export interface QueueBatchResponse {
    failed?: {
        id: string;
        message?: string;
    }[];
}
export interface QueueDeleteBatchEntry {
    id: string;
    receiptHandle: string;
}
interface QueueBase<Name extends string = string> extends Omit<QueueSpec<Name>, "handler" | "message"> {
    kind: "Queue";
    fifo: boolean;
    changeMessageVisibility(receiptHandle: string, timeout: DurationSchedule): Promise<void>;
    deleteMessage(receiptHandle: string): Promise<void>;
    deleteMessageBatch(entries: QueueDeleteBatchEntry[]): Promise<QueueBatchResponse>;
}
export interface StandardQueue<Name extends string = string, Message = any> extends QueueBase<Name> {
    fifo: false;
    handler: QueueBatchHandler<StandardQueueBatchHandlerFunction<Message>>;
    sendMessage(message: Message, options?: StandardQueueSendMessageOptions): Promise<void>;
    sendMessageBatch(entries: QueueSendMessageBatchEntry<Message>[]): Promise<QueueBatchResponse>;
}
export interface FifoQueue<Name extends string = string, Message = any> extends QueueBase<Name> {
    fifo: true;
    handler: QueueBatchHandler<FifoQueueBatchHandlerFunction<Message>>;
    groupBy?: FifoQueueMessagePropertyReference<Message>;
    dedupe?: FifoQueueMessagePropertyReference<Message> | FifoContentBasedDeduplication;
    sendMessage(message: Message, options?: FifoQueueSendMessageOptions): Promise<void>;
    sendMessageBatch(entries: QueueSendMessageBatchEntry<Message, FifoQueueSendMessageOptions>[]): Promise<QueueBatchResponse>;
}
export declare function isFifoQueue(queue: Queue): queue is FifoQueue;
export type Queue<Name extends string = string, Message = any> = FifoQueue<Name, Message> | StandardQueue<Name, Message>;
export type MessageIdField<Message> = {
    [K in keyof Message]: K extends string ? Message[K] extends string ? K : never : never;
}[keyof Message];
export type FifoQueueMessagePropertyReference<Message> = MessageIdField<Message> | ((message: Message) => string);
interface QueueOptionsBase<Fifo extends boolean> {
    /**
     * Amount of time to delay the delivery of messages in the queue to consumers.
     *
     * @default 0 seconds
     */
    delay?: DurationSchedule;
    /**
     * When true, the contents of the messages are encrypted server side with a managed key.
     *
     * @default true
     */
    encryption?: boolean;
    fifo?: Fifo;
    handlerOptions?: QueueHandlerSpec;
    /**
     * The default visibility timeout for messages in the queue.
     *
     * @default Schedule.duration(30, "seconds")
     */
    visibilityTimeout?: DurationSchedule;
}
export type QueueOptions<Message> = FifoQueueOptions<Message> | QueueOptionsBase<false>;
export interface FifoQueueOptions<Message> extends QueueOptionsBase<true> {
    fifo: true;
    groupBy?: FifoQueueMessagePropertyReference<Message>;
    dedupe?: FifoQueueMessagePropertyReference<Message> | FifoContentBasedDeduplication;
}
export declare function queue<Message, Name extends string = string>(...args: [
    name: Name,
    options: FifoQueueOptions<Message>,
    handler: FifoQueueBatchHandlerFunction<Message>
]): FifoQueue<Name, Message>;
export declare function queue<Message, Name extends string = string>(...args: [
    name: Name,
    options: QueueOptions<Message>,
    handler: StandardQueueBatchHandlerFunction<Message>
]): StandardQueue<Name, Message>;
/**
 * Assertion that content based deduplication is on.
 *
 * Can be overridden when calling `sendMessage`.
 */
export interface FifoContentBasedDeduplication {
    contentBasedDeduplication: true;
}
export declare function isFifoContentBasedDeduplication(value: any): value is FifoContentBasedDeduplication;
export {};
//# sourceMappingURL=queue.d.ts.map