@powerhousedao/reactor-attachments 6.1.0-staging.0 → 6.2.0-dev.0

package/dist/null-attachment-transport-BBhQIk5A.d.ts

@@ -0,0 +1,617 @@
+import { AttachmentHash, AttachmentRef, JwtHandler } from "@powerhousedao/reactor";
+
+//#region src/errors.d.ts
+/**
+ * Thrown when an attachment ref or hash is not known to the store.
+ */
+declare class AttachmentNotFound extends Error {
+  constructor(identifier: string);
+}
+/**
+ * Thrown when a reservation ID is not found in the reservation store.
+ */
+declare class ReservationNotFound extends Error {
+  constructor(reservationId: string);
+}
+/**
+ * Thrown when an attachment ref string does not match the expected format.
+ */
+declare class InvalidAttachmentRef extends Error {
+  constructor(ref: string);
+}
+/**
+ * Thrown when an upload exceeds the configured maximum byte cap.
+ * Route handlers should map this to HTTP 413 Payload Too Large.
+ */
+declare class UploadTooLarge extends Error {
+  readonly maxBytes: number;
+  constructor(maxBytes: number);
+}
+/**
+ * Thrown by reserve() when the claimed hash is already available in the store.
+ * The caller should use err.ref directly and upload nothing -- this is the
+ * dedup fast path: duplicate content never leaves the client.
+ */
+declare class AttachmentAlreadyExists extends Error {
+  readonly hash: AttachmentHash;
+  readonly ref: AttachmentRef;
+  constructor(hash: AttachmentHash, ref: AttachmentRef);
+}
+/**
+ * Thrown by send() when the server-computed hash of the uploaded bytes
+ * does not match the hash claimed at reservation time. Nothing is committed;
+ * the reservation is retained so the client can retry with correct bytes.
+ */
+declare class HashMismatch extends Error {
+  readonly claimed: AttachmentHash;
+  readonly actual: AttachmentHash;
+  constructor(claimed: AttachmentHash, actual: AttachmentHash);
+}
+/**
+ * Thrown by send() when the uploaded byte count does not equal the
+ * sizeBytes declared at reservation time. The handle may reject
+ * mid-stream as soon as the count exceeds the declaration.
+ * Nothing is committed; the reservation is retained for retry.
+ *
+ * "actual" is the byte count received from the stream before aborting --
+ * it includes the chunk that crossed the declaration and can exceed bytes
+ * persisted. On mid-stream aborts the true total is unknown; at least
+ * "actual" bytes were sent.
+ */
+declare class SizeMismatch extends Error {
+  readonly declared: number;
+  readonly actual: number;
+  constructor(declared: number, actual: number);
+}
+/**
+ * Thrown by get() when the hash is reserved by an in-flight upload and
+ * bytes are not yet available anywhere. Deliberately NOT a subclass of
+ * AttachmentNotFound -- callers must distinguish "retry later" from "unknown".
+ * After expiresAtUtc has passed the hash reads as not found.
+ *
+ * metadata is populated when the reservation is local and its fields are
+ * known (mimeType, fileName, sizeBytes). It is undefined when the pending
+ * state is learned from a remote transport that did not supply the full
+ * Attachment-Pending header (transport-pending / degraded wire case).
+ */
+declare class AttachmentPending extends Error {
+  readonly hash: AttachmentHash;
+  readonly expiresAtUtc: string;
+  readonly metadata: {
+    readonly mimeType: string;
+    readonly fileName: string;
+    readonly sizeBytes: number;
+  } | undefined;
+  constructor(hash: AttachmentHash, expiresAtUtc: string, meta?: {
+    mimeType: string;
+    fileName: string;
+    sizeBytes: number;
+  });
+}
+//#endregion
+//#region src/types.d.ts
+/**
+ * Status of attachment data in the local store.
+ * 'pending' is a virtual status synthesized at query time from live,
+ * hash-bearing reservations -- it never appears in the attachment table.
+ */
+type AttachmentStatus = "available" | "evicted" | "pending";
+/**
+ * Metadata about an attachment. For committed attachments (available/evicted),
+ * expiresAtUtc is null. For pending attachments synthesized from a live
+ * reservation, expiresAtUtc carries the reservation expiry so callers can
+ * emit Retry-After or bound polling loops.
+ */
+type AttachmentHeader = {
+  hash: AttachmentHash;
+  mimeType: string;
+  fileName: string;
+  sizeBytes: number;
+  extension: string | null;
+  status: AttachmentStatus;
+  source: "local" | "sync";
+  createdAtUtc: string;
+  lastAccessedAtUtc: string;
+  expiresAtUtc: string | null;
+};
+/**
+ * Metadata provided alongside attachment data during sync, and returned
+ * via the switchboard's `Attachment-Metadata` header on GET/HEAD.
+ * `createdAtUtc` is the original upload time, propagated from the source
+ * so that the receiving store preserves it instead of synthesizing the
+ * fetch time. `lastAccessedAtUtc` is the source reactor's most recent
+ * access time; it is optional because not every producer (e.g. a fresh
+ * `put` from a transport) tracks access yet. Receiving stores that
+ * persist locally (LRU concerns) reset it on every read regardless.
+ *
+ * Reliability note: `lastAccessedAtUtc` arriving over the wire is
+ * best-effort. When the producer omits it, the consumer (see
+ * `RemoteAttachmentStore` / `SwitchboardAttachmentTransport`) coalesces
+ * with `createdAtUtc`, so the field can silently equal `createdAtUtc`
+ * even on a server that has never been read. Do NOT use the wire value
+ * for LRU eviction or staleness decisions on remote data; always read
+ * the field from the local store after persistence, where the receiving
+ * store is the authority.
+ */
+type AttachmentMetadata = {
+  mimeType: string;
+  fileName: string;
+  sizeBytes: number;
+  extension: string | null;
+  createdAtUtc: string;
+  lastAccessedAtUtc?: string;
+};
+/**
+ * Upload-first reservation. clientHash and sizeBytes are absent;
+ * the ref is only known after send() completes.
+ */
+type UploadFirstReserveAttachmentOptions = {
+  mimeType: string;
+  fileName: string;
+  extension?: string | null;
+  clientHash?: undefined;
+  sizeBytes?: undefined;
+};
+/**
+ * Hash-first reservation. clientHash is present and sizeBytes is required.
+ * The ref is known at reservation time; send() verifies the uploaded bytes
+ * against the claimed hash and declared size. The explicit "?: undefined"
+ * on UploadFirstReserveAttachmentOptions makes clientHash a narrowing discriminant:
+ * checking options.clientHash !== undefined narrows sizeBytes to number.
+ */
+type HashFirstReserveAttachmentOptions = {
+  mimeType: string;
+  fileName: string;
+  extension?: string | null;
+  /**
+   * Content hash claimed by the client (lowercase SHA-256 hex).
+   */
+  clientHash: AttachmentHash;
+  /**
+   * Declared size in bytes. Required when clientHash is present.
+   * Reported by stat() during the pending window and enforced on
+   * ingest: an upload whose actual byte count differs is rejected.
+   */
+  sizeBytes: number;
+};
+/**
+ * Options provided when reserving an attachment slot.
+ *
+ * Use HashFirstReserveAttachmentOptions when clientHash is known up front;
+ * the service then operates in hash-first mode: reserve() rejects if the
+ * content is already available, and send() verifies the uploaded bytes.
+ *
+ * Use UploadFirstReserveAttachmentOptions (or omit clientHash) for the
+ * upload-first flow where the ref is only known after send() completes.
+ */
+type ReserveAttachmentOptions = UploadFirstReserveAttachmentOptions | HashFirstReserveAttachmentOptions;
+/**
+ * Result of uploading attachment data through a handle.
+ */
+type AttachmentUploadResult = {
+  hash: AttachmentHash;
+  ref: AttachmentRef;
+  header: AttachmentHeader;
+};
+/**
+ * Response when retrieving attachment data from the local store.
+ */
+type AttachmentResponse = {
+  header: AttachmentHeader;
+  body: ReadableStream<Uint8Array>;
+};
+/**
+ * Response when fetching attachment data from a remote transport.
+ * Lighter than AttachmentResponse -- a remote peer cannot meaningfully
+ * populate status or source, which are local reactor concerns.
+ * The store assigns those fields when it calls put() on receipt.
+ */
+type TransportResponse = {
+  hash: AttachmentHash;
+  metadata: AttachmentMetadata;
+  body: ReadableStream<Uint8Array>;
+};
+/**
+ * Three-way result from IAttachmentTransport.fetch(). Replaces
+ * TransportResponse | null to make the pending state explicit, so
+ * peers receiving a synced operation whose attachment is in-flight can
+ * distinguish "retry later" from "permanently unknown".
+ */
+type TransportFetchResult = {
+  kind: "data";
+  response: TransportResponse;
+} | {
+  kind: "pending";
+  hash: AttachmentHash;
+  expiresAtUtc: string;
+  retryAfterMs: number;
+} | {
+  kind: "not-found";
+};
+/**
+ * Configuration for creating an attachment transport instance.
+ */
+type AttachmentTransportConfig = {
+  type: string;
+  parameters: Record<string, unknown>;
+};
+/**
+ * A reservation for an in-progress attachment upload.
+ * Created by reserve(), deleted when upload.send() completes or
+ * once expiresAtUtc has passed and a sweep runs.
+ * clientHash and sizeBytes are set in hash-first mode and null in
+ * upload-first mode.
+ */
+type Reservation = {
+  reservationId: string;
+  mimeType: string;
+  fileName: string;
+  extension: string | null;
+  createdAtUtc: string;
+  expiresAtUtc: string;
+  clientHash: string | null;
+  sizeBytes: number | null;
+};
+//#endregion
+//#region src/interfaces.d.ts
+/**
+ * Client-facing interface for uploading, querying, and retrieving attachments.
+ * This is what applications (editors, Connect, CLI tools) interact with.
+ */
+interface IAttachmentService {
+  /**
+   * Reserve a new attachment slot and return an upload handle.
+   *
+   * When options.clientHash is provided (hash-first mode):
+   * - @throws AttachmentAlreadyExists if data for that hash is currently
+   *   available. The error carries the canonical ref; the caller uses it
+   *   directly and uploads nothing (dedup fast path).
+   * - If the hash is evicted, the reservation is created: the client holds
+   *   the bytes and the upload restores them.
+   * - If the hash is pending (another in-flight reservation), the
+   *   reservation is created: concurrent reservations are deliberately
+   *   permitted (see design doc -- no uniqueness race).
+   * - The returned handle's ref field is set immediately to the computed ref.
+   *
+   * When options.clientHash is absent (upload-first mode):
+   * - No pre-check against the store.
+   * - The returned handle's ref field is null until send() completes.
+   */
+  reserve(options: ReserveAttachmentOptions): Promise<IAttachmentUpload>;
+  /**
+   * Get attachment metadata by ref.
+   *
+   * @throws AttachmentNotFound if the ref is unknown.
+   * Returns an AttachmentHeader with status='pending' and expiresAtUtc set if
+   * the hash has an active reservation but no committed bytes. Callers must
+   * check header.status to distinguish pending from available.
+   */
+  stat(ref: AttachmentRef): Promise<AttachmentHeader>;
+  /**
+   * Retrieve attachment data.
+   *
+   * Always succeeds for any known, available ref. The underlying store
+   * handles re-fetching evicted data from the transport transparently.
+   *
+   * @throws AttachmentPending if the hash is reserved but bytes not yet
+   *         available. There is no store-level wait; polling across the
+   *         pending window is the caller's loop, bounded by the error's
+   *         expiresAtUtc. A wait inside get() would hold request handlers
+   *         open across multi-second windows and hide retry policy where
+   *         callers cannot tune it.
+   */
+  get(ref: AttachmentRef, signal?: AbortSignal): Promise<AttachmentResponse>;
+}
+/**
+ * Upload handle returned by reserve(). Encapsulates all transport-specific
+ * concerns (URLs, credentials, streaming protocols) behind a single send() method.
+ */
+interface IAttachmentUpload {
+  /**
+   * Unique identifier for this reservation.
+   */
+  reservationId: string;
+  /**
+   * The ref this upload will produce. Set immediately when the
+   * reservation carries a client hash (hash-first mode); null in the
+   * upload-first flow, where the ref is only known after send() completes.
+   */
+  ref: AttachmentRef | null;
+  /**
+   * Reservation TTL contract, from the server in remote mode.
+   * ISO 8601 UTC string indicating when the reservation expires.
+   * Clients use this to bound retry windows and populate the pending-upload queue.
+   */
+  readonly expiresAtUtc: string;
+  /**
+   * Stream attachment data through this handle.
+   *
+   * The handle manages the full upload lifecycle internally:
+   * writing bytes to the backing store, computing or verifying
+   * the content hash, creating the attachment record, and
+   * cleaning up the reservation.
+   *
+   * Dedup: if an attachment with the same content hash already
+   * exists, send() returns the existing ref. Content-addressed
+   * storage means identical uploads converge on the same hash.
+   *
+   * When the reservation carries a client hash, the handle verifies
+   * the received bytes against the claims:
+   * - @throws SizeMismatch if the byte count differs from the declared
+   *   sizeBytes. The handle may reject mid-stream as soon as the count
+   *   exceeds the declaration, without consuming the rest.
+   * - @throws HashMismatch if the server-computed hash differs from the
+   *   claimed hash. Nothing is committed; the reservation is retained
+   *   so the client can retry with the correct bytes.
+   *
+   * @returns The content hash, ref, and header for the uploaded attachment.
+   */
+  send(data: ReadableStream<Uint8Array>): Promise<AttachmentUploadResult>;
+}
+/**
+ * Read-only subset of IAttachmentStore.
+ *
+ * Adapters that cannot safely support the local-only write/GC surface
+ * (remote stores, forwarding caches) implement this narrow interface
+ * instead of stub-rejecting unsupported methods. Consumers that only
+ * need to query metadata or stream attachment bytes can take this type
+ * to make their dependency requirements explicit.
+ */
+interface IAttachmentReader {
+  /**
+   * Get attachment metadata without streaming body data.
+   * Does NOT update lastAccessedAtUtc -- this is a metadata check,
+   * not a data access.
+   *
+   * @throws AttachmentNotFound if the hash is unknown.
+   * Returns an AttachmentHeader with status='pending' and expiresAtUtc set if
+   * the hash has an active reservation but no committed bytes. Callers must
+   * check header.status to distinguish pending from available.
+   */
+  stat(hash: AttachmentHash): Promise<AttachmentHeader>;
+  /**
+   * Retrieve attachment header and data stream by hash.
+   * Updates lastAccessedAtUtc on access.
+   *
+   * If the data has been evicted, re-fetches it from the transport,
+   * restores it locally via put(), and returns the data. This makes
+   * eviction transparent to callers -- get() always succeeds for
+   * any known, available hash.
+   *
+   * @throws AttachmentNotFound if the hash is unknown (no metadata
+   *         record exists and no pending reservation).
+   * @throws AttachmentPending if the hash is reserved by an in-flight
+   *         upload; bytes are not yet available. There is no store-level
+   *         wait -- polling is the caller's responsibility.
+   */
+  get(hash: AttachmentHash, signal?: AbortSignal): Promise<AttachmentResponse>;
+}
+/**
+ * Reactor-facing interface for managing local attachment data.
+ * The IAttachmentTransport calls put when it receives data from a remote.
+ * The store notifies its configured transport when new data arrives,
+ * forming a bidirectional store-transport pair.
+ */
+interface IAttachmentStore extends IAttachmentReader {
+  /**
+   * Check whether attachment data is available locally.
+   * Returns true if the bytes can be served from this reactor's store
+   * without a transport round-trip. Does not trigger a remote fetch.
+   * Returns false for pending and evicted hashes.
+   */
+  has(hash: AttachmentHash): Promise<boolean>;
+  /**
+   * Store attachment data received from a remote (during sync or re-fetch).
+   * Called by IAttachmentTransport implementations during sync, and
+   * internally by get() when restoring evicted data.
+   *
+   * Behavior depends on existing state:
+   * - No existing row: INSERT with source='sync', status='available'.
+   * - Existing row with status='evicted': restore data, set status
+   *   to 'available'.
+   * - Existing row with status='available': no-op (dedup).
+   */
+  put(hash: AttachmentHash, metadata: AttachmentMetadata, data: ReadableStream<Uint8Array>): Promise<void>;
+  /**
+   * Evict attachment data to reclaim storage.
+   *
+   * Removes the local bytes and sets status to 'evicted'. The
+   * metadata record is retained so the hash is still known. If the
+   * data is needed again, the service fetches it via the transport.
+   *
+   * Eviction must not destroy data while a get() stream is in
+   * flight. Implementations must skip hashes with active readers
+   * (e.g. via a refcount or lease) and revisit them on the next
+   * GC pass.
+   *
+   * On immutable backends, this unpins/stops serving rather
+   * than deleting.
+   */
+  evict(hash: AttachmentHash): Promise<void>;
+  /**
+   * Get the total storage used by locally available attachment data.
+   * Used by the GC policy to decide when to evict.
+   */
+  storageUsed(): Promise<number>;
+}
+/**
+ * Transport for moving attachment data between reactors.
+ *
+ * Forms a bidirectional pair with IAttachmentStore. The store calls
+ * announce/push when new data arrives locally. The transport calls
+ * store.put() when data arrives from a remote.
+ */
+interface IAttachmentTransport {
+  /**
+   * Fetch attachment data by hash from a remote source.
+   *
+   * Returns a three-way discriminated union so callers can distinguish
+   * "data available", "upload in flight -- retry after expiry", and
+   * "not found -- possibly permanently". Conflating the last two would
+   * cause callers to apply long backoff to transient pending state,
+   * or to retry indefinitely on a permanently missing hash.
+   *
+   * @param hash - Content hash of the attachment
+   * @param signal - Abort signal for cancellation
+   */
+  fetch(hash: AttachmentHash, signal?: AbortSignal): Promise<TransportFetchResult>;
+  /**
+   * Announce that this reactor has attachment data available.
+   *
+   * For server-centric transports, this may be a no-op (the server
+   * already has the data after upload).
+   */
+  announce(hash: AttachmentHash): Promise<void>;
+  /**
+   * Push attachment data to a specific remote.
+   *
+   * Used for eager replication strategies where the source reactor
+   * pushes data to known peers rather than waiting for pull requests.
+   *
+   * @param hash - Content hash of the attachment
+   * @param remote - Target remote identifier
+   * @param data - The attachment data stream
+   */
+  push(hash: AttachmentHash, remote: string, data: ReadableStream<Uint8Array>): Promise<void>;
+}
+/**
+ * Factory for creating attachment transport instances.
+ * Mirrors IChannelFactory for operation sync.
+ */
+interface IAttachmentTransportFactory {
+  instance(config: AttachmentTransportConfig): IAttachmentTransport;
+}
+/**
+ * Store for managing attachment reservations.
+ * Reservations are transient records tracking in-progress uploads.
+ */
+interface IReservationStore {
+  create(options: ReserveAttachmentOptions): Promise<Reservation>;
+  get(reservationId: string): Promise<Reservation>;
+  delete(reservationId: string): Promise<void>;
+  /**
+   * Delete reservations whose expires_at_utc is at or before `now`.
+   * Returns the number of rows deleted.
+   *
+   * Reservations are not auto-swept; consumers should call this on a
+   * cron / interval to clean up rows left behind by aborted uploads.
+   */
+  deleteExpired(now?: Date): Promise<number>;
+}
+/**
+ * Factory for creating transport-specific upload handles.
+ * The service calls this during reserve() to create a handle
+ * that knows how to stream bytes to the appropriate backend.
+ */
+interface IAttachmentUploadFactory {
+  createUpload(reservation: Reservation): IAttachmentUpload;
+}
+//#endregion
+//#region src/attachment-service.d.ts
+declare class AttachmentService implements IAttachmentService {
+  private readonly store;
+  private readonly reservations;
+  private readonly uploadFactory;
+  constructor(store: IAttachmentReader, reservations: IReservationStore, uploadFactory: IAttachmentUploadFactory);
+  reserve(options: ReserveAttachmentOptions): Promise<IAttachmentUpload>;
+  stat(ref: AttachmentRef): Promise<AttachmentHeader>;
+  get(ref: AttachmentRef, signal?: AbortSignal): Promise<AttachmentResponse>;
+  private reserveHashFirst;
+}
+//#endregion
+//#region src/ref.d.ts
+type ParsedRef = {
+  version: number;
+  hash: AttachmentHash;
+};
+declare function parseRef(ref: AttachmentRef): ParsedRef;
+declare function createRef(hash: AttachmentHash, version?: number): AttachmentRef;
+//#endregion
+//#region src/switchboard/switchboard-attachment-transport.d.ts
+type SwitchboardTransportConfig = {
+  remoteUrl: string;
+  jwtHandler?: JwtHandler;
+  fetchFn?: typeof fetch;
+};
+declare class SwitchboardAttachmentTransport implements IAttachmentTransport {
+  private readonly remoteUrl;
+  private readonly jwtHandler?;
+  private readonly fetchFn;
+  constructor(config: SwitchboardTransportConfig);
+  fetch(hash: AttachmentHash, signal?: AbortSignal): Promise<TransportFetchResult>;
+  announce(_hash: AttachmentHash): Promise<void>;
+  push(hash: AttachmentHash, remote: string, data: ReadableStream<Uint8Array>): Promise<void>;
+  private parsePendingExpiry;
+  private parseMetadataHeaders;
+}
+//#endregion
+//#region src/switchboard/remote-reservation-store.d.ts
+type SwitchboardClientConfig = {
+  remoteUrl: string;
+  jwtHandler?: JwtHandler;
+  fetchFn?: typeof fetch;
+};
+declare class RemoteReservationStore implements IReservationStore {
+  private readonly remoteUrl;
+  private readonly jwtHandler?;
+  private readonly fetchFn;
+  constructor(config: SwitchboardClientConfig);
+  create(options: ReserveAttachmentOptions): Promise<Reservation>;
+  get(reservationId: string): Promise<Reservation>;
+  delete(reservationId: string): Promise<void>;
+  deleteExpired(): Promise<number>;
+}
+//#endregion
+//#region src/switchboard/remote-attachment-upload.d.ts
+declare class RemoteAttachmentUpload implements IAttachmentUpload {
+  readonly reservationId: string;
+  readonly ref: AttachmentRef | null;
+  readonly expiresAtUtc: string;
+  private readonly remoteUrl;
+  private readonly jwtHandler?;
+  private readonly fetchFn;
+  constructor(reservation: Reservation, config: SwitchboardClientConfig);
+  send(data: ReadableStream<Uint8Array>): Promise<AttachmentUploadResult>;
+}
+//#endregion
+//#region src/switchboard/remote-attachment-upload-factory.d.ts
+declare class RemoteAttachmentUploadFactory implements IAttachmentUploadFactory {
+  private readonly config;
+  constructor(config: SwitchboardClientConfig);
+  createUpload(reservation: Reservation): IAttachmentUpload;
+}
+//#endregion
+//#region src/switchboard/remote-attachment-store.d.ts
+declare class RemoteAttachmentStore implements IAttachmentReader {
+  private readonly remoteUrl;
+  private readonly jwtHandler?;
+  private readonly fetchFn;
+  constructor(config: SwitchboardClientConfig);
+  /**
+   * Get attachment metadata. Normally returns a pending AttachmentHeader
+   * (status: 'pending') when the server responds 202 with a full
+   * Attachment-Pending header. When only expiresAtUtc is present in the
+   * header (degraded wire), throws AttachmentPending instead -- the
+   * AttachmentPending throw is the degraded-wire case.
+   */
+  stat(hash: AttachmentHash): Promise<AttachmentHeader>;
+  get(hash: AttachmentHash, signal?: AbortSignal): Promise<AttachmentResponse>;
+  private fetchAttachment;
+}
+//#endregion
+//#region src/switchboard/create-remote-attachment-service.d.ts
+declare function createRemoteAttachmentService(config: SwitchboardClientConfig): IAttachmentService;
+//#endregion
+//#region src/null-attachment-transport.d.ts
+/**
+ * No-op transport for deployments without remote sync.
+ * fetch() always returns not-found, announce() and push() are no-ops.
+ */
+declare class NullAttachmentTransport implements IAttachmentTransport {
+  fetch(): Promise<TransportFetchResult>;
+  announce(): Promise<void>;
+  push(): Promise<void>;
+}
+//#endregion
+export { ReserveAttachmentOptions as A, SizeMismatch as B, AttachmentMetadata as C, AttachmentUploadResult as D, AttachmentTransportConfig as E, AttachmentNotFound as F, AttachmentPending as I, HashMismatch as L, TransportResponse as M, UploadFirstReserveAttachmentOptions as N, HashFirstReserveAttachmentOptions as O, AttachmentAlreadyExists as P, InvalidAttachmentRef as R, AttachmentHeader as S, AttachmentStatus as T, UploadTooLarge as V, IAttachmentTransport as _, RemoteAttachmentUpload as a, IAttachmentUploadFactory as b, SwitchboardAttachmentTransport as c, createRef as d, parseRef as f, IAttachmentStore as g, IAttachmentService as h, RemoteAttachmentUploadFactory as i, TransportFetchResult as j, Reservation as k, SwitchboardTransportConfig as l, IAttachmentReader as m, createRemoteAttachmentService as n, RemoteReservationStore as o, AttachmentService as p, RemoteAttachmentStore as r, SwitchboardClientConfig as s, NullAttachmentTransport as t, ParsedRef as u, IAttachmentTransportFactory as v, AttachmentResponse as w, IReservationStore as x, IAttachmentUpload as y, ReservationNotFound as z };
+//# sourceMappingURL=null-attachment-transport-BBhQIk5A.d.ts.map

package/dist/null-attachment-transport-BBhQIk5A.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"null-attachment-transport-BBhQIk5A.d.ts","names":[],"sources":["../src/errors.ts","../src/types.ts","../src/interfaces.ts","../src/attachment-service.ts","../src/ref.ts","../src/switchboard/switchboard-attachment-transport.ts","../src/switchboard/remote-reservation-store.ts","../src/switchboard/remote-attachment-upload.ts","../src/switchboard/remote-attachment-upload-factory.ts","../src/switchboard/remote-attachment-store.ts","../src/switchboard/create-remote-attachment-service.ts","../src/null-attachment-transport.ts"],"mappings":"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"}