import { F as File, s as MetaStorageOptions, M as MetaStorage, S as StoredObject, C as ConditionalSupport, f as BaseStorageOptions, e as FileInit, g as ConditionalOptions, O as OperationOptions, h as FilePart, i as FileQuery, c as FileReturn, j as CopyConditionalOptions, B as BaseStorage } from "../../packem_shared/storage.d-Cnjmzau5.js";
import { Readable } from 'node:stream';
import "../../packem_shared/types.d-DFh9698o.js";
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> {
  override readonly supportsConditionalSave: boolean;
  private readonly store;
  constructor(config?: MetaStorageOptions & {
    store?: Map<string, T>;
  });
  override save(id: string, file: T): Promise<T>;
  override saveIfVersion(id: string, file: T, version: string): Promise<T | undefined>;
  override get(id: string): Promise<T>;
  override list(): 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 readonly storageKind: string;
  protected override statObject(id: string): Promise<StoredObject | undefined>;
  /** No checksum is verified against the written bytes, so none is advertised. */
  override checksumTypes: string[];
  override readonly supportsRange: boolean;
  /** Every predicate is checked and applied in one synchronous step, so no other call interleaves. */
  override readonly conditionalSupport: ConditionalSupport;
  meta: MemoryMetaStorage<TFile>;
  private readonly store;
  constructor(config?: MemoryStorageOptions<TFile>);
  override get raw(): Map<string, MemoryEntry>;
  create(fileInit: FileInit, options?: ConditionalOptions & OperationOptions): Promise<TFile>;
  write(part: FilePart | FileQuery, options?: ConditionalOptions & OperationOptions): Promise<TFile>;
  get({ id }: FileQuery, options?: ConditionalOptions & 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, options?: ConditionalOptions & OperationOptions): Promise<TFile>;
  copy(source: string, destination: string, options?: CopyConditionalOptions & OperationOptions): Promise<TFile>;
  move(source: string, destination: string): Promise<TFile>;
  /**
   * Writes `incoming` at `part.start` and saves the metadata; call with the id's lock held. A
   * `conditional` upload replaces the object wholesale once its predicate holds.
   */
  private storeBytes;
  /** The stored entry is authoritative: a record may outlive its bytes. */
  protected override currentETag(file: TFile): Promise<string | undefined>;
  override list(): Promise<TFile[]>;
  override getReadUrl(key: string): Promise<string>;
  override getUploadUrl(key: string): Promise<string>;
}
export { MemoryMetaStorage, MemoryStorage, type MemoryStorageOptions, MemoryStorage as default };