import { F as File, u as MetaStorageOptions, M as MetaStorage, i as BaseStorageOptions, d as FileInit, O as OperationOptions, e as FilePart, f as FileQuery, g as FileReturn, B as BaseStorage } from "../../packem_shared/storage.d-C9EdfTf1.js";
import { Readable } from 'node:stream';
import 'node:timers';
import 'node:crypto';
import 'node:http';
import 'lru-cache';
/**
 * Map-backed metadata storage used by {@link MemoryStorage}. Holds a deep-copied
 * snapshot of each `File` so callers can mutate the returned object without leaking
 * back into the backing store.
 */
declare class MemoryMetaStorage<T extends File = File> extends MetaStorage<T> {
  private readonly store;
  constructor(config?: MetaStorageOptions & {
    store?: Map<string, T>;
  });
  override save(id: string, file: T): Promise<T>;
  override get(id: string): Promise<T>;
  override delete(id: string): Promise<void>;
  override touch(id: string, file: T): Promise<T>;
  /** Reset the in-memory metadata. Test/reset helper. */
  clear(): void;
}
/**
 * Public options for {@link MemoryStorage}. The `initial` record lets tests seed the
 * store with a few key→bytes pairs; pass `metaStorage` to share metadata with another
 * `Files` instance (rarely needed — the memory adapter is meant to be ephemeral).
 */
interface MemoryStorageOptions<T extends File = File> extends BaseStorageOptions<T> {
  /** Pre-populate the store with these key → bytes entries. */
  initial?: Record<string, Buffer | Uint8Array | string>;
  metaStorageConfig?: MetaStorageOptions;
}
/**
 * Stored entry in the backing {@link Map}. `bytes` is the raw payload; `meta` is a
 * lightweight per-key metadata snapshot so {@link MemoryStorage.list} and
 * `head` can answer without dragging the file class around.
 */
interface MemoryEntry {
  bytes: Buffer;
  contentType: string;
  createdAt: string;
  eTag: string;
  metadata: Record<string, unknown>;
  modifiedAt: string;
}
/**
 * In-memory storage adapter backed by a {@link Map}.
 *
 * Implements the full {@link BaseStorage} surface without touching disk or any
 * external service — useful for tests, ephemeral environments, and as a
 * reference implementation. `raw` returns the backing map so tests can inspect
 * or reset state directly:
 *
 * ```ts
 * const storage = new MemoryStorage({ initial: { "users/1.json": '{"id":1}' } });
 * storage.raw.clear();
 * ```
 *
 * Metadata is shallow-cloned on both write and read so callers never share a
 * mutable object with the store.
 */
declare class MemoryStorage<TFile extends File = File> extends BaseStorage<TFile> {
  static override readonly name: string;
  override checksumTypes: string[];
  override readonly supportsRange: boolean;
  meta: MemoryMetaStorage<TFile>;
  private readonly store;
  constructor(config?: MemoryStorageOptions<TFile>);
  override get raw(): Map<string, MemoryEntry>;
  create(fileInit: FileInit, _options?: OperationOptions): Promise<TFile>;
  write(part: FilePart | FileQuery, _options?: OperationOptions): Promise<TFile>;
  get({ id }: FileQuery, _options?: OperationOptions & {
    range?: {
      end?: number;
      start: number;
    };
  }): Promise<FileReturn>;
  override getStream({ id }: FileQuery, _options?: OperationOptions & {
    range?: {
      end?: number;
      start: number;
    };
  }): Promise<{
    headers?: Record<string, string>;
    size?: number;
    stream: Readable;
  }>;
  override exists({ id }: FileQuery): Promise<boolean>;
  delete({ id }: FileQuery): Promise<TFile>;
  copy(source: string, destination: string): Promise<TFile>;
  move(source: string, destination: string): Promise<TFile>;
  override list(): Promise<TFile[]>;
  override getReadUrl(key: string): Promise<string>;
  override getUploadUrl(key: string): Promise<string>;
}
export { MemoryMetaStorage, MemoryStorage, type MemoryStorageOptions, MemoryStorage as default };