import { E as EmailOptions } from "../packem_shared/types.d-CyiC9uRC.js";
import { E as EnqueueOptions, Q as QueueJob, a as EmailQueue } from "../packem_shared/types.d-B5iH_mgb.js";
import 'node:buffer';
type StorageValue = null | string | number | boolean | object;
type WatchEvent = "update" | "remove";
type WatchCallback = (event: WatchEvent, key: string) => any;
type MaybePromise<T> = T | Promise<T>;
type MaybeDefined<T> = T extends any ? T : any;
type Unwatch = () => MaybePromise<void>;
interface StorageMeta {
  atime?: Date;
  mtime?: Date;
  ttl?: number;
  [key: string]: StorageValue | Date | undefined;
}
type TransactionOptions = Record<string, any>;
type GetKeysOptions = TransactionOptions & {
  maxDepth?: number;
};
interface DriverFlags {
  maxDepth?: boolean;
  ttl?: boolean;
}
interface Driver<OptionsT = any, InstanceT = any> {
  name?: string;
  flags?: DriverFlags;
  options?: OptionsT;
  getInstance?: () => InstanceT;
  hasItem: (key: string, opts: TransactionOptions) => MaybePromise<boolean>;
  getItem: (key: string, opts?: TransactionOptions) => MaybePromise<StorageValue>;
  /** @experimental */
  getItems?: (items: {
    key: string;
    options?: TransactionOptions;
  }[], commonOptions?: TransactionOptions) => MaybePromise<{
    key: string;
    value: StorageValue;
  }[]>;
  /** @experimental */
  getItemRaw?: (key: string, opts: TransactionOptions) => MaybePromise<unknown>;
  setItem?: (key: string, value: string, opts: TransactionOptions) => MaybePromise<void>;
  /** @experimental */
  setItems?: (items: {
    key: string;
    value: string;
    options?: TransactionOptions;
  }[], commonOptions?: TransactionOptions) => MaybePromise<void>;
  /** @experimental */
  setItemRaw?: (key: string, value: any, opts: TransactionOptions) => MaybePromise<void>;
  removeItem?: (key: string, opts: TransactionOptions) => MaybePromise<void>;
  getMeta?: (key: string, opts: TransactionOptions) => MaybePromise<StorageMeta | null>;
  getKeys: (base: string, opts: GetKeysOptions) => MaybePromise<string[]>;
  clear?: (base: string, opts: TransactionOptions) => MaybePromise<void>;
  dispose?: () => MaybePromise<void>;
  watch?: (callback: WatchCallback) => MaybePromise<Unwatch>;
}
type StorageDefinition = {
  items: unknown;
  [key: string]: unknown;
};
type StorageItemMap<T> = T extends StorageDefinition ? T["items"] : T;
type StorageItemType<T, K> = K extends keyof StorageItemMap<T> ? StorageItemMap<T>[K] : T extends StorageDefinition ? StorageValue : T;
interface Storage<T extends StorageValue = StorageValue> {
  hasItem<U extends Extract<T, StorageDefinition>, K extends keyof StorageItemMap<U>>(key: K, opts?: TransactionOptions): Promise<boolean>;
  hasItem(key: string, opts?: TransactionOptions): Promise<boolean>;
  getItem<U extends Extract<T, StorageDefinition>, K extends string & keyof StorageItemMap<U>>(key: K, ops?: TransactionOptions): Promise<StorageItemType<T, K> | null>;
  getItem<R = StorageItemType<T, string>>(key: string, opts?: TransactionOptions): Promise<R | null>;
  /** @experimental */
  getItems: <U extends T>(items: (string | {
    key: string;
    options?: TransactionOptions;
  })[], commonOptions?: TransactionOptions) => Promise<{
    key: string;
    value: U;
  }[]>;
  /** @experimental See https://github.com/unjs/unstorage/issues/142 */
  getItemRaw: <T = any>(key: string, opts?: TransactionOptions) => Promise<MaybeDefined<T> | null>;
  setItem<U extends Extract<T, StorageDefinition>, K extends keyof StorageItemMap<U>>(key: K, value: StorageItemType<T, K>, opts?: TransactionOptions): Promise<void>;
  setItem<U extends T>(key: string, value: U, opts?: TransactionOptions): Promise<void>;
  /** @experimental */
  setItems: <U extends T>(items: {
    key: string;
    value: U;
    options?: TransactionOptions;
  }[], commonOptions?: TransactionOptions) => Promise<void>;
  /** @experimental See https://github.com/unjs/unstorage/issues/142 */
  setItemRaw: <T = any>(key: string, value: MaybeDefined<T>, opts?: TransactionOptions) => Promise<void>;
  removeItem<U extends Extract<T, StorageDefinition>, K extends keyof StorageItemMap<U>>(key: K, opts?: (TransactionOptions & {
    removeMeta?: boolean;
  }) | boolean): Promise<void>;
  removeItem(key: string, opts?: (TransactionOptions & {
    removeMeta?: boolean;
  }) | boolean): Promise<void>;
  getMeta: (key: string, opts?: (TransactionOptions & {
    nativeOnly?: boolean;
  }) | boolean) => MaybePromise<StorageMeta>;
  setMeta: (key: string, value: StorageMeta, opts?: TransactionOptions) => Promise<void>;
  removeMeta: (key: string, opts?: TransactionOptions) => Promise<void>;
  getKeys: (base?: string, opts?: GetKeysOptions) => Promise<string[]>;
  clear: (base?: string, opts?: TransactionOptions) => Promise<void>;
  dispose: () => Promise<void>;
  watch: (callback: WatchCallback) => Promise<Unwatch>;
  unwatch: () => Promise<void>;
  mount: (base: string, driver: Driver) => Storage;
  unmount: (base: string, dispose?: boolean) => Promise<void>;
  getMount: (key?: string) => {
    base: string;
    driver: Driver;
  };
  getMounts: (base?: string, options?: {
    parents?: boolean;
  }) => {
    base: string;
    driver: Driver;
  }[];
  keys: Storage["getKeys"];
  get: Storage<T>["getItem"];
  set: Storage<T>["setItem"];
  has: Storage<T>["hasItem"];
  del: Storage<T>["removeItem"];
  remove: Storage<T>["removeItem"];
}
/**
 * Options for {@link UnstorageQueue}.
 */
interface UnstorageQueueOptions {
  /**
   * Time source in milliseconds — injectable for tests. Defaults to `Date.now`.
   */
  now?: () => number;
  /**
   * Key prefix under which jobs are stored.
   * @default "email:queue"
   */
  prefix?: string;
  /**
   * How long, in milliseconds, a reserved job stays hidden before becoming deliverable again.
   * @default 30000
   */
  visibilityTimeout?: number;
}
/**
 * A durable {@link EmailQueue} backed by an [unstorage](https://unstorage.unjs.io/) `Storage`.
 *
 * Because unstorage abstracts many backends (memory, filesystem, Redis, Cloudflare KV, Postgres, …),
 * a single adapter persists the queue across all of them. The stored `message` must be
 * JSON-serializable (avoid `Buffer` attachments — pass `path`/`href`/base64 `content` instead).
 *
 * Note: unstorage has no transactions, so {@link UnstorageQueue.reserve} is best-effort under
 * concurrent workers; the visibility timeout bounds duplicate delivery on a crash.
 */
declare class UnstorageQueue implements EmailQueue {
  private readonly storage;
  private readonly prefix;
  private readonly visibilityTimeout;
  private readonly now;
  /**
   * @param storage The unstorage instance to persist jobs in.
   * @param options Adapter options. See {@link UnstorageQueueOptions}.
   */
  constructor(storage: Storage, options?: UnstorageQueueOptions);
  /**
   * Persists a message to the store.
   * @param message The message to send later.
   * @param options Optional scheduling. See {@link EnqueueOptions}.
   * @returns The new job id.
   */
  enqueue(message: EmailOptions, options?: EnqueueOptions): Promise<string>;
  /**
   * Reserves the next ready job, hiding it for the visibility window.
   * @returns The next deliverable job, or `undefined` when none is ready.
   */
  reserve(): Promise<QueueJob | undefined>;
  /**
   * Removes a processed job from the store.
   * @param id The job id.
   */
  ack(id: string): Promise<void>;
  /**
   * Requeues a job after a delay, incrementing its attempt count.
   * @param id The job id.
   * @param delayMs Milliseconds to wait before the job becomes ready again.
   */
  retry(id: string, delayMs?: number): Promise<void>;
  /**
   * Counts the jobs currently in the store.
   * @returns The number of stored (ready plus reserved) jobs.
   */
  size(): Promise<number>;
  private keyOf;
}
/**
 * Creates an {@link UnstorageQueue}.
 * @param storage The unstorage instance to persist jobs in.
 * @param options Adapter options. See {@link UnstorageQueueOptions}.
 * @returns A new {@link UnstorageQueue}.
 */
declare const createUnstorageQueue: (storage: Storage, options?: UnstorageQueueOptions) => UnstorageQueue;
export { UnstorageQueue, UnstorageQueueOptions, createUnstorageQueue };