@atomicmemory/core 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Public API surface of the AtomicMemory memory engine.
+ * Consumed by the standalone memory service and evaluation harness.
+ */
+export { MemoryService, type IngestResult, type RetrievalResult } from './services/memory-service.js';
+export { MemoryRepository, type MemoryRow, type SearchResult, type EpisodeRow, type MemoryMetadata } from './db/memory-repository.js';
+export { ClaimRepository } from './db/claim-repository.js';
+export { pool } from './db/pool.js';
+export { config, applyRuntimeConfigUpdates, updateRuntimeConfig, SUPPORTED_RUNTIME_CONFIG_FIELDS, INTERNAL_POLICY_CONFIG_FIELDS, type RuntimeConfig, type RuntimeConfigUpdates, type EmbeddingProviderName, type LLMProviderName, type VectorBackendName, type SupportedRuntimeConfigField, type InternalPolicyConfigField, type SupportedRuntimeConfig, type InternalPolicyConfig, } from './config.js';
+export { createMemoryRouter } from './routes/memories.js';
+export { type RetrievalCitation } from './services/retrieval-format.js';
+export { getRetrievalProfile, parseRetrievalProfile, type RetrievalProfile, type RetrievalProfileName, } from './services/retrieval-profiles.js';
+export { createCoreRuntime, type CoreRuntime, type CoreRuntimeDeps, type CoreRuntimeConfig, type CoreRuntimeRepos, type CoreRuntimeServices, type CoreRuntimeConfigRouteAdapter, } from './app/runtime-container.js';
+export { createApp } from './app/create-app.js';
+export { checkEmbeddingDimensions, type EmbeddingDimensionCheckResult, } from './app/startup-checks.js';
+export { bindEphemeral, type BootedApp } from './app/bind-ephemeral.js';
+export { initEmbedding, type EmbeddingConfig } from './services/embedding.js';
+export { initLlm, type LLMConfig } from './services/llm.js';

package/dist/index.js

@@ -0,0 +1,17 @@
+/**
+ * Public API surface of the AtomicMemory memory engine.
+ * Consumed by the standalone memory service and evaluation harness.
+ */
+export { MemoryService } from './services/memory-service.js';
+export { MemoryRepository } from './db/memory-repository.js';
+export { ClaimRepository } from './db/claim-repository.js';
+export { pool } from './db/pool.js';
+export { config, applyRuntimeConfigUpdates, updateRuntimeConfig, SUPPORTED_RUNTIME_CONFIG_FIELDS, INTERNAL_POLICY_CONFIG_FIELDS, } from './config.js';
+export { createMemoryRouter } from './routes/memories.js';
+export { getRetrievalProfile, parseRetrievalProfile, } from './services/retrieval-profiles.js';
+export { createCoreRuntime, } from './app/runtime-container.js';
+export { createApp } from './app/create-app.js';
+export { checkEmbeddingDimensions, } from './app/startup-checks.js';
+export { bindEphemeral } from './app/bind-ephemeral.js';
+export { initEmbedding } from './services/embedding.js';
+export { initLlm } from './services/llm.js';

package/dist/middleware/require-bearer.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @file `requireBearer` — Express middleware that validates the
+ * `Authorization: Bearer <token>` header against a configured shared
+ * key in constant time.
+ *
+ * Mounted in front of every SDK-facing `/v1/*` router by
+ * `src/app/create-app.ts`. Public probes (`/health`, `/openapi.json`)
+ * stay outside the protected scope.
+ *
+ * Failure response:
+ *
+ *   401 { error_code: 'unauthenticated', error: '<reason>' }
+ *
+ * The wire envelope intentionally distinguishes "missing header"
+ * from "wrong key" only by `error` text; both share the same
+ * `error_code` so caller logic does not branch on the difference
+ * (preventing oracle-style probing of valid header shape).
+ */
+import type { RequestHandler } from 'express';
+/**
+ * Build a middleware that admits a request only when its
+ * `Authorization` header carries the configured shared key. The
+ * expected key is captured at construction time so a config rotation
+ * requires a server restart (matches the rest of the runtime-config
+ * model).
+ */
+export declare function requireBearer(expectedApiKey: string): RequestHandler;

package/dist/middleware/require-bearer.js

@@ -0,0 +1,60 @@
+/**
+ * @file `requireBearer` — Express middleware that validates the
+ * `Authorization: Bearer <token>` header against a configured shared
+ * key in constant time.
+ *
+ * Mounted in front of every SDK-facing `/v1/*` router by
+ * `src/app/create-app.ts`. Public probes (`/health`, `/openapi.json`)
+ * stay outside the protected scope.
+ *
+ * Failure response:
+ *
+ *   401 { error_code: 'unauthenticated', error: '<reason>' }
+ *
+ * The wire envelope intentionally distinguishes "missing header"
+ * from "wrong key" only by `error` text; both share the same
+ * `error_code` so caller logic does not branch on the difference
+ * (preventing oracle-style probing of valid header shape).
+ */
+import { timingSafeEqual } from 'node:crypto';
+const BEARER_PREFIX = 'Bearer ';
+/**
+ * Build a middleware that admits a request only when its
+ * `Authorization` header carries the configured shared key. The
+ * expected key is captured at construction time so a config rotation
+ * requires a server restart (matches the rest of the runtime-config
+ * model).
+ */
+export function requireBearer(expectedApiKey) {
+    if (typeof expectedApiKey !== 'string' || expectedApiKey.length === 0) {
+        throw new Error('requireBearer: expectedApiKey must be a non-empty string');
+    }
+    const expectedBuffer = Buffer.from(expectedApiKey, 'utf8');
+    return (req, res, next) => {
+        const headerValue = readAuthorizationHeader(req);
+        if (headerValue === null) {
+            respondUnauthenticated(res, 'missing or malformed Authorization header');
+            return;
+        }
+        const providedBuffer = Buffer.from(headerValue, 'utf8');
+        if (providedBuffer.length !== expectedBuffer.length) {
+            respondUnauthenticated(res, 'invalid api key');
+            return;
+        }
+        if (!timingSafeEqual(providedBuffer, expectedBuffer)) {
+            respondUnauthenticated(res, 'invalid api key');
+            return;
+        }
+        next();
+    };
+}
+function readAuthorizationHeader(req) {
+    const raw = req.headers['authorization'];
+    if (typeof raw !== 'string' || !raw.startsWith(BEARER_PREFIX))
+        return null;
+    const token = raw.slice(BEARER_PREFIX.length).trim();
+    return token.length > 0 ? token : null;
+}
+function respondUnauthenticated(res, reason) {
+    res.status(401).json({ error_code: 'unauthenticated', error: reason });
+}

package/dist/middleware/validate-response.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @file Dev/test-mode response validator.
+ *
+ * Wraps `res.json()` to parse the outgoing body against a route→schema
+ * map declared alongside the OpenAPI response schemas. Catches the
+ * formatter↔schema drift that `check:openapi` alone can't see: if a
+ * formatter in `routes/memory-response-formatters.ts` changes a field
+ * name or shape without the corresponding update in
+ * `schemas/responses.ts`, tests fail loudly at the point of emission.
+ *
+ * No-op in production. Enabled by default everywhere else (tests,
+ * `NODE_ENV=development`) so the check is on in the only environments
+ * that actually run tests or local dev.
+ *
+ * Route keys follow Express's router-relative `${method} ${route.path}`
+ * format (e.g. `post /ingest`, `get /:id`). `req.route.path` is set by
+ * the time `res.json()` is called inside the handler, so the lookup
+ * resolves correctly even for parameterized paths.
+ *
+ * Error-path responses (4xx/5xx) are not validated — each route emits
+ * its own error envelope that's already schema-checked by the
+ * `validateBody` middleware on the way in, and runtime error shapes
+ * are intentionally less strict than success bodies.
+ */
+import type { RequestHandler } from 'express';
+import type { z } from 'zod';
+export type ResponseSchemaMap = Record<string, z.ZodTypeAny>;
+/**
+ * Build a middleware that validates 2xx JSON response bodies against
+ * the supplied schema map. Returns a pass-through no-op when
+ * NODE_ENV is `production`, so prod has zero per-request cost.
+ */
+export declare function validateResponse(schemaMap: ResponseSchemaMap): RequestHandler;

package/dist/middleware/validate-response.js

@@ -0,0 +1,55 @@
+/**
+ * @file Dev/test-mode response validator.
+ *
+ * Wraps `res.json()` to parse the outgoing body against a route→schema
+ * map declared alongside the OpenAPI response schemas. Catches the
+ * formatter↔schema drift that `check:openapi` alone can't see: if a
+ * formatter in `routes/memory-response-formatters.ts` changes a field
+ * name or shape without the corresponding update in
+ * `schemas/responses.ts`, tests fail loudly at the point of emission.
+ *
+ * No-op in production. Enabled by default everywhere else (tests,
+ * `NODE_ENV=development`) so the check is on in the only environments
+ * that actually run tests or local dev.
+ *
+ * Route keys follow Express's router-relative `${method} ${route.path}`
+ * format (e.g. `post /ingest`, `get /:id`). `req.route.path` is set by
+ * the time `res.json()` is called inside the handler, so the lookup
+ * resolves correctly even for parameterized paths.
+ *
+ * Error-path responses (4xx/5xx) are not validated — each route emits
+ * its own error envelope that's already schema-checked by the
+ * `validateBody` middleware on the way in, and runtime error shapes
+ * are intentionally less strict than success bodies.
+ */
+/**
+ * Build a middleware that validates 2xx JSON response bodies against
+ * the supplied schema map. Returns a pass-through no-op when
+ * NODE_ENV is `production`, so prod has zero per-request cost.
+ */
+export function validateResponse(schemaMap) {
+    if (process.env.NODE_ENV === 'production') {
+        return (_req, _res, next) => next();
+    }
+    return (req, res, next) => {
+        const originalJson = res.json.bind(res);
+        res.json = function patchedJson(body) {
+            if (res.statusCode >= 200 && res.statusCode < 300 && req.route?.path) {
+                const key = `${req.method.toLowerCase()} ${req.route.path}`;
+                const schema = schemaMap[key];
+                if (schema) {
+                    const result = schema.safeParse(body);
+                    if (!result.success) {
+                        throw new Error(`Response body for ${key} violates declared schema.\n`
+                            + `Formatter output does not match ${key}'s OpenAPI response schema. `
+                            + `Either update the formatter, or if the change is intentional, update `
+                            + `src/schemas/responses.ts and regenerate the OpenAPI spec.\n`
+                            + `Zod issues:\n${JSON.stringify(result.error.issues, null, 2)}`);
+                    }
+                }
+            }
+            return originalJson(body);
+        };
+        next();
+    };
+}

package/dist/middleware/validate.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @file Express request validators built on Zod schemas.
+ *
+ * `validateBody` / `validateQuery` / `validateParams` replace the hand-
+ * written `parseIngestBody` / `parseSearchBody` / `requireBodyString`
+ * helpers that used to live in `src/routes/*`. On failure they emit
+ * the existing 400 response envelope verbatim — `{ error: string }`
+ * — so HTTP clients see no change. Zod's structured issues are
+ * flattened into a single descriptive string via {@link formatZodIssues}
+ * matching the style of the prior parsers' thrown messages.
+ *
+ * On success the parsed-and-transformed value replaces the original
+ * `req.body` / `req.query` / `req.params` so handlers see camelCase
+ * fields regardless of the snake_case wire format.
+ */
+import type { RequestHandler } from 'express';
+import type { z, ZodIssue, ZodTypeAny } from 'zod';
+/**
+ * Flatten Zod issues into a single human-readable string.
+ *
+ * Example output:
+ *   "user_id is required; conversation must be ≤ 100000 characters"
+ *
+ * The format mirrors the ad-hoc messages produced by the route
+ * handlers' inline validators today, so clients that regex-match error
+ * text continue to work.
+ */
+export declare function formatZodIssues(issues: ZodIssue[]): string;
+/** Validate `req.body` against a Zod schema. */
+export declare function validateBody<T extends ZodTypeAny>(schema: T): RequestHandler;
+/** Validate `req.query` against a Zod schema. */
+export declare function validateQuery<T extends ZodTypeAny>(schema: T): RequestHandler;
+/** Validate `req.params` against a Zod schema. */
+export declare function validateParams<T extends ZodTypeAny>(schema: T): RequestHandler;
+/**
+ * Assert that a response payload matches `schema`, throwing in non-
+ * production. Used as a lightweight runtime contract check on handler
+ * outputs; in production it is a no-op so there is no perf impact.
+ *
+ * Callers should invoke `assertResponse(Schema, payload)` immediately
+ * before `res.json(payload)` on non-trivial routes.
+ */
+export declare function assertResponse<T extends ZodTypeAny>(schema: T, payload: unknown): asserts payload is z.infer<T>;

package/dist/middleware/validate.js

@@ -0,0 +1,85 @@
+/**
+ * @file Express request validators built on Zod schemas.
+ *
+ * `validateBody` / `validateQuery` / `validateParams` replace the hand-
+ * written `parseIngestBody` / `parseSearchBody` / `requireBodyString`
+ * helpers that used to live in `src/routes/*`. On failure they emit
+ * the existing 400 response envelope verbatim — `{ error: string }`
+ * — so HTTP clients see no change. Zod's structured issues are
+ * flattened into a single descriptive string via {@link formatZodIssues}
+ * matching the style of the prior parsers' thrown messages.
+ *
+ * On success the parsed-and-transformed value replaces the original
+ * `req.body` / `req.query` / `req.params` so handlers see camelCase
+ * fields regardless of the snake_case wire format.
+ */
+/**
+ * Flatten Zod issues into a single human-readable string.
+ *
+ * Example output:
+ *   "user_id is required; conversation must be ≤ 100000 characters"
+ *
+ * The format mirrors the ad-hoc messages produced by the route
+ * handlers' inline validators today, so clients that regex-match error
+ * text continue to work.
+ */
+export function formatZodIssues(issues) {
+    return issues
+        .map(issue => {
+        const path = issue.path.join('.');
+        return path ? `${path}: ${issue.message}` : issue.message;
+    })
+        .join('; ');
+}
+function respond400(res, error) {
+    res.status(400).json({ error: formatZodIssues(error.issues) });
+}
+function makeValidator(schema, source) {
+    return (req, res, next) => {
+        const result = schema.safeParse(req[source]);
+        if (!result.success) {
+            respond400(res, result.error);
+            return;
+        }
+        // Express 5 exposes `req.query` (and `req.params`) as getter-only
+        // properties on Request.prototype — plain `req.query = ...`
+        // silently no-ops. Define an own property to shadow the prototype
+        // accessor so handlers see the parsed-and-transformed value.
+        Object.defineProperty(req, source, {
+            value: result.data,
+            writable: true,
+            configurable: true,
+            enumerable: true,
+        });
+        next();
+    };
+}
+/** Validate `req.body` against a Zod schema. */
+export function validateBody(schema) {
+    return makeValidator(schema, 'body');
+}
+/** Validate `req.query` against a Zod schema. */
+export function validateQuery(schema) {
+    return makeValidator(schema, 'query');
+}
+/** Validate `req.params` against a Zod schema. */
+export function validateParams(schema) {
+    return makeValidator(schema, 'params');
+}
+/**
+ * Assert that a response payload matches `schema`, throwing in non-
+ * production. Used as a lightweight runtime contract check on handler
+ * outputs; in production it is a no-op so there is no perf impact.
+ *
+ * Callers should invoke `assertResponse(Schema, payload)` immediately
+ * before `res.json(payload)` on non-trivial routes.
+ */
+export function assertResponse(schema, payload) {
+    if (process.env.NODE_ENV === 'production')
+        return;
+    const result = schema.safeParse(payload);
+    if (result.success)
+        return;
+    const message = formatZodIssues(result.error.issues);
+    throw new Error(`[assertResponse] payload failed schema: ${message}`);
+}

package/dist/routes/agents.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Agent trust and conflict resolution API routes.
+ * Provides endpoints for managing agent trust levels and resolving
+ * cross-agent memory conflicts.
+ *
+ * Request validation is delegated to the Zod schemas in
+ * `src/schemas/agents.ts` via the `validateBody` / `validateQuery` /
+ * `validateParams` middleware. Error messages are preserved byte-for-
+ * byte from the pre-refactor inline validators.
+ */
+import { Router } from 'express';
+import { AgentTrustRepository } from '../db/agent-trust-repository.js';
+export declare function createAgentRouter(trustRepo: AgentTrustRepository): Router;

package/dist/routes/agents.js

@@ -0,0 +1,89 @@
+/**
+ * Agent trust and conflict resolution API routes.
+ * Provides endpoints for managing agent trust levels and resolving
+ * cross-agent memory conflicts.
+ *
+ * Request validation is delegated to the Zod schemas in
+ * `src/schemas/agents.ts` via the `validateBody` / `validateQuery` /
+ * `validateParams` middleware. Error messages are preserved byte-for-
+ * byte from the pre-refactor inline validators.
+ */
+import { Router } from 'express';
+import { handleRouteError } from './route-errors.js';
+import { validateBody, validateQuery, validateParams } from '../middleware/validate.js';
+import { validateResponse } from '../middleware/validate-response.js';
+import { AGENT_RESPONSE_SCHEMAS } from './response-schema-map.js';
+import { SetTrustBodySchema, GetTrustQuerySchema, UserIdFromQuerySchema, UserIdFromBodySchema, ConflictIdParamSchema, ResolveConflictBodySchema, } from '../schemas/agents.js';
+export function createAgentRouter(trustRepo) {
+    const router = Router();
+    // Dev/test-mode response validator: no-op in production, throws loudly
+    // if any 2xx body violates the schema declared in responses.ts.
+    router.use(validateResponse(AGENT_RESPONSE_SCHEMAS));
+    registerSetTrustRoute(router, trustRepo);
+    registerGetTrustRoute(router, trustRepo);
+    registerListConflictsRoute(router, trustRepo);
+    registerResolveConflictRoute(router, trustRepo);
+    registerAutoResolveRoute(router, trustRepo);
+    return router;
+}
+function registerSetTrustRoute(router, trustRepo) {
+    router.put('/trust', validateBody(SetTrustBodySchema), async (req, res) => {
+        try {
+            const { agentId, userId, trustLevel, displayName } = req.body;
+            await trustRepo.setTrustLevel(agentId, userId, trustLevel, displayName);
+            res.json({ agent_id: agentId, trust_level: trustLevel });
+        }
+        catch (err) {
+            handleRouteError(res, 'PUT /v1/agents/trust', err);
+        }
+    });
+}
+function registerGetTrustRoute(router, trustRepo) {
+    router.get('/trust', validateQuery(GetTrustQuerySchema), async (req, res) => {
+        try {
+            const { agentId, userId } = req.query;
+            const trustLevel = await trustRepo.getTrustLevel(agentId, userId);
+            res.json({ agent_id: agentId, trust_level: trustLevel });
+        }
+        catch (err) {
+            handleRouteError(res, 'GET /v1/agents/trust', err);
+        }
+    });
+}
+function registerListConflictsRoute(router, trustRepo) {
+    router.get('/conflicts', validateQuery(UserIdFromQuerySchema), async (req, res) => {
+        try {
+            const { userId } = req.query;
+            const conflicts = await trustRepo.listOpenConflicts(userId);
+            res.json({ conflicts, count: conflicts.length });
+        }
+        catch (err) {
+            handleRouteError(res, 'GET /v1/agents/conflicts', err);
+        }
+    });
+}
+function registerResolveConflictRoute(router, trustRepo) {
+    router.put('/conflicts/:id/resolve', validateParams(ConflictIdParamSchema), validateBody(ResolveConflictBodySchema), async (req, res) => {
+        try {
+            const { id: conflictId } = req.params;
+            const { resolution } = req.body;
+            await trustRepo.resolveConflict(conflictId, resolution);
+            res.json({ id: conflictId, status: resolution });
+        }
+        catch (err) {
+            handleRouteError(res, 'PUT /v1/agents/conflicts/:id/resolve', err);
+        }
+    });
+}
+function registerAutoResolveRoute(router, trustRepo) {
+    router.post('/conflicts/auto-resolve', validateBody(UserIdFromBodySchema), async (req, res) => {
+        try {
+            const { userId } = req.body;
+            const resolved = await trustRepo.autoResolveExpiredConflicts(userId);
+            res.json({ resolved });
+        }
+        catch (err) {
+            handleRouteError(res, 'POST /v1/agents/conflicts/auto-resolve', err);
+        }
+    });
+}

package/dist/routes/document-response-formatters.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Wire-format formatters for /v1/documents/* responses.
+ *
+ * Mirrors the snake_case envelope the rest of the API uses: handlers
+ * emit camelCase shapes from the service layer, this module flattens
+ * them to the on-the-wire JSON.
+ */
+import type { RawDocumentRow } from '../db/raw-document-types.js';
+import type { ListPassportFeedResult } from '../db/passport-feed-repository.js';
+import { type RawContentStoreRegistry } from '../storage/store-registry.js';
+export declare function formatRawDocument(row: RawDocumentRow, registry: RawContentStoreRegistry): Record<string, unknown>;
+export declare function formatRegisterDocumentResponse(result: {
+    document: RawDocumentRow;
+    created: boolean;
+}, registry: RawContentStoreRegistry): Record<string, unknown>;
+export declare function formatListDocumentsResponse(documents: RawDocumentRow[], registry: RawContentStoreRegistry): Record<string, unknown>;
+/**
+ * Cursor-paginated document list. Mirrors
+ * `DocumentListRootResponseSchema` in `schemas/responses.ts`.
+ */
+export declare function formatDocumentListRootResponse(result: {
+    documents: RawDocumentRow[];
+    nextCursor: string | null;
+}, registry: RawContentStoreRegistry): Record<string, unknown>;
+/**
+ * Passport-feed envelope formatter. Maps the discriminated
+ * repository result to the public snake_case wire shape.
+ */
+export declare function formatPassportFeedResponse(result: ListPassportFeedResult, registry: RawContentStoreRegistry): Record<string, unknown>;
+export declare function formatDeleteDocumentResponse(result: {
+    success: true;
+    alreadyDeleted: boolean;
+}): Record<string, unknown>;
+export declare function formatUploadRawDocumentResponse(result: {
+    documentId: string;
+    storageProvider: string;
+    storageUri: string;
+    contentHash: string;
+    sizeBytes: number;
+    rawStorageStatus: 'blob_stored' | 'blob_pending' | 'blob_available';
+    storageMode: 'managed_blob';
+    /**
+     * INTERNAL metadata shape `{ codec, filecoin?, upload_result }`
+     * — the wire response strips `upload_result` and AES-GCM
+     * internals via `formatPublicRawStorageMetadata`. The Filecoin
+     * sidecar is projected through the shared
+     * `projectFilecoinPublicMetadata` helper into the Synapse-backed
+     * public shape (`copy_count` / `provider_ids` / `copy_statuses`).
+     */
+    rawStorageMetadata: Record<string, unknown>;
+    idempotentSkip: boolean;
+}, registry: RawContentStoreRegistry): Record<string, unknown>;
+export declare function formatIndexDocumentResponse(result: {
+    documentId: string;
+    indexedContentHash: string;
+    chunksCreated: number;
+    memoriesCreated: number;
+    idempotentSkip: boolean;
+    chunkerVersion: string;
+    parserVersion: string;
+}): Record<string, unknown>;
+export declare function formatDocumentFailureMarkerResponse(result: {
+    document: RawDocumentRow;
+    idempotent: boolean;
+}, registry: RawContentStoreRegistry): Record<string, unknown>;
+/**
+ * Filecoin lifecycle refactor (Slice 4): `capabilities` is the
+ * internal camelCase shape `RawContentStore.capabilities`
+ * advertises. The snapshot composition root (`create-app.ts`)
+ * sources it from the active store; this formatter is the ONLY
+ * place that flips the four capability keys
+ * (`addressing`, `retrievalConsistency`, `deleteSemantics`,
+ * `supportsHead`, `supportsGet`) to their snake_case wire form.
+ * Internal code MUST NOT receive the snake_case names; wire code
+ * MUST NOT see the camelCase names.
+ *
+ * `provider` echoes `RawContentStore.provider` (`local_fs`, `s3`,
+ * `filecoin`, ...). Omitted alongside `capabilities` when
+ * `mode = 'pointer_only'` (no store).
+ */
+export interface DocumentLimitsSnapshot {
+    rawUploadMaxBytes: number;
+    indexMaxTextBytes: number;
+    rawStorage: {
+        enabled: boolean;
+        mode: 'pointer_only' | 'managed_blob';
+        reason?: string;
+        provider?: string;
+        capabilities?: {
+            addressing: 'location' | 'content';
+            retrievalConsistency: 'immediate' | 'eventual';
+            deleteSemantics: 'delete' | 'unpin' | 'tombstone';
+            supportsHead: boolean;
+            supportsGet: boolean;
+        };
+    };
+}
+export declare function formatDocumentLimitsResponse(snapshot: DocumentLimitsSnapshot): Record<string, unknown>;