@trestleinc/replicate 0.1.0 → 1.1.0

package/dist/client/persistence/sqlite-level.d.ts

@@ -0,0 +1,63 @@
+/**
+ * SQLite-backed abstract-level implementation.
+ *
+ * Provides a LevelDB-compatible key-value store backed by SQLite,
+ * enabling y-leveldb to work with SQLite databases.
+ *
+ * Supports both browser (sql.js WASM) and React Native (op-sqlite).
+ */
+import { AbstractLevel, AbstractIterator, AbstractKeyIterator, AbstractValueIterator } from 'abstract-level';
+/**
+ * Interface for SQLite database operations.
+ * Abstracts over sql.js (browser) and op-sqlite (React Native).
+ */
+export interface SqliteAdapter {
+    execute(sql: string, params?: unknown[]): Promise<{
+        rows: Record<string, unknown>[];
+    }>;
+    close(): void;
+}
+interface SqliteLevelOptions {
+    /** Custom SQLite adapter (for testing or alternative backends) */
+    adapter?: SqliteAdapter;
+    /** Value encoding (default: 'utf8') */
+    valueEncoding?: string;
+    keyEncoding?: string;
+}
+/**
+ * SQLite-backed implementation of abstract-level.
+ *
+ * Uses a simple key-value table with lexicographic ordering:
+ * CREATE TABLE entries (key BLOB PRIMARY KEY, value BLOB)
+ */
+export declare class SqliteLevel<K = string, V = string> extends AbstractLevel<K, V> {
+    private adapter;
+    private adapterFactory;
+    constructor(_location: string, options?: SqliteLevelOptions);
+    /**
+     * Set the adapter factory for deferred initialization.
+     * Call this before open() to configure the SQLite backend.
+     */
+    setAdapterFactory(factory: () => Promise<SqliteAdapter>): void;
+    _open(): Promise<void>;
+    _close(): Promise<void>;
+    _get(key: K): Promise<V | undefined>;
+    _put(key: K, value: V): Promise<void>;
+    _del(key: K): Promise<void>;
+    _batch(operations: Array<{
+        type: 'put';
+        key: K;
+        value: V;
+    } | {
+        type: 'del';
+        key: K;
+    }>): Promise<void>;
+    _clear(): Promise<void>;
+    _iterator(options: Record<string, unknown>): AbstractIterator<typeof this, K, V>;
+    _keys(options: Record<string, unknown>): AbstractKeyIterator<typeof this, K>;
+    _values(options: Record<string, unknown>): AbstractValueIterator<typeof this, K, V>;
+    private encodeKey;
+    private encodeValue;
+    private decodeValue;
+}
+export {};

package/dist/client/persistence/sqlite-rn.d.ts

@@ -0,0 +1,36 @@
+/**
+ * React Native SQLite persistence helper using op-sqlite.
+ *
+ * @example
+ * ```typescript
+ * import { createReactNativeSqlitePersistence } from '@trestleinc/replicate/client';
+ * import { open } from '@op-engineering/op-sqlite';
+ *
+ * const db = open({ name: 'myapp.db' });
+ * const persistence = await createReactNativeSqlitePersistence(db, 'myapp');
+ * ```
+ */
+import { type OPSQLiteDatabase } from './adapters/opsqlite.js';
+import type { Persistence } from './types.js';
+/**
+ * Create React Native SQLite persistence using op-sqlite.
+ *
+ * @param db - The opened op-sqlite database instance
+ * @param dbName - Name for internal database identification
+ *
+ * @example
+ * ```typescript
+ * import { createReactNativeSqlitePersistence } from '@trestleinc/replicate/client';
+ * import { open } from '@op-engineering/op-sqlite';
+ *
+ * const db = open({ name: 'myapp.db' });
+ * const persistence = await createReactNativeSqlitePersistence(db, 'myapp');
+ *
+ * // Use in collection options
+ * convexCollectionOptions<Task>({
+ *   // ...
+ *   persistence,
+ * });
+ * ```
+ */
+export declare function createReactNativeSqlitePersistence(db: OPSQLiteDatabase, dbName: string): Promise<Persistence>;

package/dist/client/persistence/sqlite.d.ts

@@ -0,0 +1,47 @@
+import { type SqliteAdapter } from './sqlite-level.js';
+import type { Persistence } from './types.js';
+/**
+ * Options for SQLite persistence.
+ */
+export interface SqlitePersistenceOptions {
+    /**
+     * Pre-created SQLite adapter (required).
+     * Use SqlJsAdapter for browser or OPSqliteAdapter for React Native.
+     */
+    adapter: SqliteAdapter;
+    /**
+     * Database name for internal y-leveldb usage.
+     * @default 'replicate'
+     */
+    dbName?: string;
+}
+/**
+ * Create a universal SQLite persistence factory.
+ *
+ * Requires a pre-created SqliteAdapter - the replicate package does not
+ * import any SQLite packages directly, making it environment-agnostic.
+ *
+ * @param options - Configuration with required adapter
+ *
+ * @example Browser (sql.js)
+ * ```typescript
+ * import initSqlJs from 'sql.js';
+ * import { sqlitePersistence, SqlJsAdapter } from '@trestleinc/replicate/client';
+ *
+ * const SQL = await initSqlJs();
+ * const db = new SQL.Database();
+ * const adapter = new SqlJsAdapter(db);
+ * const persistence = await sqlitePersistence({ adapter });
+ * ```
+ *
+ * @example React Native (op-sqlite)
+ * ```typescript
+ * import { open } from '@op-engineering/op-sqlite';
+ * import { sqlitePersistence, OPSqliteAdapter } from '@trestleinc/replicate/client';
+ *
+ * const db = open({ name: 'myapp.db' });
+ * const adapter = new OPSqliteAdapter(db);
+ * const persistence = await sqlitePersistence({ adapter });
+ * ```
+ */
+export declare function sqlitePersistence(options: SqlitePersistenceOptions): Promise<Persistence>;

package/dist/client/persistence/types.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Persistence layer types for swappable storage backends.
+ *
+ * Supports IndexedDB (browser), SQLite (React Native), and in-memory (testing).
+ */
+import type * as Y from 'yjs';
+/**
+ * Provider that persists Y.Doc state to storage.
+ *
+ * This wraps providers like y-indexeddb or y-op-sqlite, normalizing their APIs.
+ */
+export interface PersistenceProvider {
+    /** Promise that resolves when initial sync from storage completes */
+    readonly whenSynced: Promise<void>;
+    /** Clean up resources (stop observing, close connections) */
+    destroy(): void;
+}
+/**
+ * Factory that creates persistence providers.
+ *
+ * Each persistence implementation (IndexedDB, SQLite, memory) exports a
+ * factory function that returns this interface.
+ */
+export interface Persistence {
+    /** Create a Y.Doc persistence provider for a collection */
+    createDocPersistence(collection: string, ydoc: Y.Doc): PersistenceProvider;
+    /** Key-value store for metadata (checkpoints, clientID) */
+    readonly kv: KeyValueStore;
+}
+/**
+ * Simple key-value storage interface.
+ *
+ * Used for storing metadata like checkpoints and Yjs client IDs.
+ */
+export interface KeyValueStore {
+    /** Get a value by key */
+    get<T>(key: string): Promise<T | undefined>;
+    /** Set a value by key */
+    set<T>(key: string, value: T): Promise<void>;
+    /** Delete a value by key */
+    del(key: string): Promise<void>;
+}

package/dist/client/prose.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Prose Field Helpers - Document-level state management for rich text sync
+ *
+ * Manages Y.XmlFragment observation, debounced sync, and pending state.
+ * Uses document-level tracking to prevent race conditions.
+ */
+import * as Y from 'yjs';
+import type { Collection } from '@tanstack/db';
+/**
+ * Check if a document is currently applying server data.
+ * Used to prevent echo loops in onUpdate handlers.
+ */
+export declare function isApplyingFromServer(collection: string, documentId: string): boolean;
+/**
+ * Set whether a document is currently applying server data.
+ */
+export declare function setApplyingFromServer(collection: string, documentId: string, value: boolean): void;
+/**
+ * Get current pending state for a document.
+ */
+export declare function isPending(collection: string, documentId: string): boolean;
+/**
+ * Subscribe to pending state changes for a document.
+ */
+export declare function subscribePending(collection: string, documentId: string, callback: (pending: boolean) => void): () => void;
+/**
+ * Cancel any pending debounced sync for a document.
+ * Called when receiving remote updates to avoid conflicts.
+ */
+export declare function cancelPending(collection: string, documentId: string): void;
+/**
+ * Cancel all pending syncs for a collection.
+ * Called when receiving a snapshot that replaces all state.
+ */
+export declare function cancelAllPending(collection: string): void;
+/** Configuration for fragment observation */
+export interface ProseObserverConfig {
+    collection: string;
+    documentId: string;
+    field: string;
+    fragment: Y.XmlFragment;
+    ydoc: Y.Doc;
+    ymap: Y.Map<unknown>;
+    collectionRef: Collection<any>;
+    debounceMs?: number;
+}
+/**
+ * Set up observation for a prose field's Y.XmlFragment.
+ * Returns a cleanup function.
+ */
+export declare function observeFragment(config: ProseObserverConfig): () => void;
+/**
+ * Clean up all prose state for a collection.
+ * Called when collection is destroyed.
+ */
+export declare function cleanup(collection: string): void;

package/dist/client/replicate.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Replicate Helpers - Collection-bound functions for TanStack DB optimistic updates
+ *
+ * Each collection gets its own set of bound functions that operate on that
+ * collection's TanStack DB instance. No global state - fully concurrent-safe.
+ */
+export interface ReplicateParams {
+    readonly begin: () => void;
+    readonly write: (message: {
+        type: 'insert' | 'update' | 'delete';
+        value: unknown;
+    }) => void;
+    readonly commit: () => void;
+    readonly truncate: () => void;
+}
+/**
+ * Bound replicate operations for a specific collection.
+ * These functions are already tied to the collection's TanStack DB params.
+ */
+export interface BoundReplicateOps<T> {
+    readonly insert: (items: T[]) => void;
+    readonly delete: (items: T[]) => void;
+    readonly upsert: (items: T[]) => void;
+    readonly replace: (items: T[]) => void;
+}
+/**
+ * Create bound replicate operations for a collection.
+ * Returns functions that are already tied to the collection's params.
+ * This is the proper way to handle multiple concurrent collections.
+ *
+ * @example
+ * ```typescript
+ * const ops = createReplicateOps<Task>(params);
+ * ops.replace(items);  // Always targets THIS collection's TanStack DB
+ * ops.upsert([item]);
+ * ops.delete([item]);
+ * ```
+ */
+export declare function createReplicateOps<T>(params: ReplicateParams): BoundReplicateOps<T>;
+export declare function _resetReplicateParams(): void;

package/dist/client/services/checkpoint.d.ts

@@ -0,0 +1,18 @@
+import { Effect, Context, Layer } from 'effect';
+import { IDBError, IDBWriteError } from '$/client/errors.js';
+import type { KeyValueStore } from '$/client/persistence/types.js';
+export interface CheckpointData {
+    lastModified: number;
+}
+declare const Checkpoint_base: Context.TagClass<Checkpoint, "Checkpoint", {
+    readonly loadCheckpoint: (collection: string) => Effect.Effect<CheckpointData, IDBError>;
+    readonly saveCheckpoint: (collection: string, checkpoint: CheckpointData) => Effect.Effect<void, IDBWriteError>;
+    readonly clearCheckpoint: (collection: string) => Effect.Effect<void, IDBError>;
+}>;
+export declare class Checkpoint extends Checkpoint_base {
+}
+/**
+ * Create a Checkpoint service layer using the provided KeyValueStore.
+ */
+export declare function createCheckpointLayer(kv: KeyValueStore): Layer.Layer<Checkpoint, never, never>;
+export {};

package/dist/client/services/reconciliation.d.ts

@@ -0,0 +1,24 @@
+import { Effect, Context, Layer } from 'effect';
+import * as Y from 'yjs';
+import { ReconciliationError as ReconciliationErrorImport } from '$/client/errors.js';
+declare const Reconciliation_base: Context.TagClass<Reconciliation, "Reconciliation", {
+    /**
+     * Reconciles local Yjs state with server state by removing phantom documents.
+     * Uses an existing Yjs document and map instead of creating new ones.
+     *
+     * @param ydoc - Existing Yjs document
+     * @param ymap - Existing Yjs map within the document
+     * @param collection - Collection name for logging
+     * @param serverDocs - Documents from server
+     * @param getKey - Function to extract key from document
+     */
+    readonly reconcile: <T>(ydoc: Y.Doc, ymap: Y.Map<unknown>, collection: string, serverDocs: readonly T[], getKey: (doc: T) => string) => Effect.Effect<T[], ReconciliationErrorImport>;
+}>;
+/**
+ * Reconciliation handles removal of phantom documents -
+ * documents that exist locally but have been deleted on the server.
+ */
+export declare class Reconciliation extends Reconciliation_base {
+}
+export declare const ReconciliationLive: Layer.Layer<Reconciliation, never, never>;
+export {};

package/dist/component/_generated/api.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Generated `api` utility.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+import type * as logger from "../logger.js";
+import type * as public_ from "../public.js";
+import type { ApiFromModules, FilterApi, FunctionReference } from "convex/server";
+declare const fullApi: ApiFromModules<{
+    logger: typeof logger;
+    public: typeof public_;
+}>;
+/**
+ * A utility for referencing Convex functions in your app's public API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = api.myModule.myFunction;
+ * ```
+ */
+export declare const api: FilterApi<typeof fullApi, FunctionReference<any, "public">>;
+/**
+ * A utility for referencing Convex functions in your app's internal API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = internal.myModule.myFunction;
+ * ```
+ */
+export declare const internal: FilterApi<typeof fullApi, FunctionReference<any, "internal">>;
+export declare const components: {};
+export {};

package/dist/component/_generated/api.js

@@ -1,5 +1,5 @@
-import { anyApi, componentsGeneric } from "convex/server";
-const api = anyApi;
-const internal = anyApi;
+import { anyApi as server_anyApi, componentsGeneric } from "convex/server";
+const api = server_anyApi;
+const internal = server_anyApi;
 const components = componentsGeneric();
 export { api, components, internal };

package/dist/component/_generated/component.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Generated `ComponentApi` utility.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+import type { FunctionReference } from "convex/server";
+/**
+ * A utility for referencing a Convex component's exposed API.
+ *
+ * Useful when expecting a parameter like `components.myComponent`.
+ * Usage:
+ * ```ts
+ * async function myFunction(ctx: QueryCtx, component: ComponentApi) {
+ *   return ctx.runQuery(component.someFile.someQuery, { ...args });
+ * }
+ * ```
+ */
+export type ComponentApi<Name extends string | undefined = string | undefined> = {
+    public: {
+        deleteDocument: FunctionReference<"mutation", "internal", {
+            collection: string;
+            crdtBytes: ArrayBuffer;
+            documentId: string;
+            threshold?: number;
+            version: number;
+        }, {
+            compacted?: boolean;
+            success: boolean;
+        }, Name>;
+        getInitialState: FunctionReference<"query", "internal", {
+            collection: string;
+        }, {
+            checkpoint: {
+                lastModified: number;
+            };
+            crdtBytes: ArrayBuffer;
+        } | null, Name>;
+        insertDocument: FunctionReference<"mutation", "internal", {
+            collection: string;
+            crdtBytes: ArrayBuffer;
+            documentId: string;
+            threshold?: number;
+            version: number;
+        }, {
+            compacted?: boolean;
+            success: boolean;
+        }, Name>;
+        recovery: FunctionReference<"query", "internal", {
+            clientStateVector: ArrayBuffer;
+            collection: string;
+        }, {
+            diff?: ArrayBuffer;
+            serverStateVector: ArrayBuffer;
+        }, Name>;
+        stream: FunctionReference<"query", "internal", {
+            checkpoint: {
+                lastModified: number;
+            };
+            collection: string;
+            limit?: number;
+            vector?: ArrayBuffer;
+        }, {
+            changes: Array<{
+                crdtBytes: ArrayBuffer;
+                documentId?: string;
+                operationType: string;
+                timestamp: number;
+                version: number;
+            }>;
+            checkpoint: {
+                lastModified: number;
+            };
+            hasMore: boolean;
+        }, Name>;
+        updateDocument: FunctionReference<"mutation", "internal", {
+            collection: string;
+            crdtBytes: ArrayBuffer;
+            documentId: string;
+            threshold?: number;
+            version: number;
+        }, {
+            compacted?: boolean;
+            success: boolean;
+        }, Name>;
+    };
+};

package/dist/component/_generated/dataModel.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Generated data model types.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+import type { DataModelFromSchemaDefinition, DocumentByName, TableNamesInDataModel, SystemTableNames } from "convex/server";
+import type { GenericId } from "convex/values";
+import schema from "../schema.js";
+/**
+ * The names of all of your Convex tables.
+ */
+export type TableNames = TableNamesInDataModel<DataModel>;
+/**
+ * The type of a document stored in Convex.
+ *
+ * @typeParam TableName - A string literal type of the table name (like "users").
+ */
+export type Doc<TableName extends TableNames> = DocumentByName<DataModel, TableName>;
+/**
+ * An identifier for a document in Convex.
+ *
+ * Convex documents are uniquely identified by their `Id`, which is accessible
+ * on the `_id` field. To learn more, see [Document IDs](https://docs.convex.dev/using/document-ids).
+ *
+ * Documents can be loaded using `db.get(tableName, id)` in query and mutation functions.
+ *
+ * IDs are just strings at runtime, but this type can be used to distinguish them from other
+ * strings when type checking.
+ *
+ * @typeParam TableName - A string literal type of the table name (like "users").
+ */
+export type Id<TableName extends TableNames | SystemTableNames> = GenericId<TableName>;
+/**
+ * A type describing your Convex data model.
+ *
+ * This type includes information about what tables you have, the type of
+ * documents stored in those tables, and the indexes defined on them.
+ *
+ * This type is used to parameterize methods like `queryGeneric` and
+ * `mutationGeneric` to make them type-safe.
+ */
+export type DataModel = DataModelFromSchemaDefinition<typeof schema>;

package/{src → dist}/component/_generated/server.d.ts

@@ -1,4 +1,3 @@
-/* eslint-disable */
 /**
  * Generated utilities for implementing server-side Convex query and mutation functions.
  *
@@ -7,27 +6,8 @@
  * To regenerate, run `npx convex dev`.
  * @module
  */
-
-import {
-  ActionBuilder,
-  AnyComponents,
-  HttpActionBuilder,
-  MutationBuilder,
-  QueryBuilder,
-  GenericActionCtx,
-  GenericMutationCtx,
-  GenericQueryCtx,
-  GenericDatabaseReader,
-  GenericDatabaseWriter,
-  FunctionReference,
-} from "convex/server";
+import type { ActionBuilder, HttpActionBuilder, MutationBuilder, QueryBuilder, GenericActionCtx, GenericMutationCtx, GenericQueryCtx, GenericDatabaseReader, GenericDatabaseWriter } from "convex/server";
 import type { DataModel } from "./dataModel.js";
-
-type GenericCtx =
-  | GenericActionCtx<DataModel>
-  | GenericMutationCtx<DataModel>
-  | GenericQueryCtx<DataModel>;
-
 /**
  * Define a query in this Convex app's public API.
  *
@@ -37,7 +17,6 @@ type GenericCtx =
  * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
  */
 export declare const query: QueryBuilder<DataModel, "public">;
-
 /**
  * Define a query that is only accessible from other Convex functions (but not from the client).
  *
@@ -47,7 +26,6 @@ export declare const query: QueryBuilder<DataModel, "public">;
  * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
  */
 export declare const internalQuery: QueryBuilder<DataModel, "internal">;
-
 /**
  * Define a mutation in this Convex app's public API.
  *
@@ -57,7 +35,6 @@ export declare const internalQuery: QueryBuilder<DataModel, "internal">;
  * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
  */
 export declare const mutation: MutationBuilder<DataModel, "public">;
-
 /**
  * Define a mutation that is only accessible from other Convex functions (but not from the client).
  *
@@ -67,7 +44,6 @@ export declare const mutation: MutationBuilder<DataModel, "public">;
  * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
  */
 export declare const internalMutation: MutationBuilder<DataModel, "internal">;
-
 /**
  * Define an action in this Convex app's public API.
  *
@@ -80,7 +56,6 @@ export declare const internalMutation: MutationBuilder<DataModel, "internal">;
  * @returns The wrapped action. Include this as an `export` to name it and make it accessible.
  */
 export declare const action: ActionBuilder<DataModel, "public">;
-
 /**
  * Define an action that is only accessible from other Convex functions (but not from the client).
  *
@@ -88,38 +63,36 @@ export declare const action: ActionBuilder<DataModel, "public">;
  * @returns The wrapped function. Include this as an `export` to name it and make it accessible.
  */
 export declare const internalAction: ActionBuilder<DataModel, "internal">;
-
 /**
  * Define an HTTP action.
  *
- * This function will be used to respond to HTTP requests received by a Convex
- * deployment if the requests matches the path and method where this action
- * is routed. Be sure to route your action in `convex/http.js`.
+ * The wrapped function will be used to respond to HTTP requests received
+ * by a Convex deployment if the requests matches the path and method where
+ * this action is routed. Be sure to route your httpAction in `convex/http.js`.
  *
- * @param func - The function. It receives an {@link ActionCtx} as its first argument.
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument
+ * and a Fetch API `Request` object as its second.
  * @returns The wrapped function. Import this function from `convex/http.js` and route it to hook it up.
  */
 export declare const httpAction: HttpActionBuilder;
-
 /**
  * A set of services for use within Convex query functions.
  *
  * The query context is passed as the first argument to any Convex query
  * function run on the server.
  *
- * This differs from the {@link MutationCtx} because all of the services are
- * read-only.
+ * If you're using code generation, use the `QueryCtx` type in `convex/_generated/server.d.ts` instead.
  */
 export type QueryCtx = GenericQueryCtx<DataModel>;
-
 /**
  * A set of services for use within Convex mutation functions.
  *
  * The mutation context is passed as the first argument to any Convex mutation
  * function run on the server.
+ *
+ * If you're using code generation, use the `MutationCtx` type in `convex/_generated/server.d.ts` instead.
  */
 export type MutationCtx = GenericMutationCtx<DataModel>;
-
 /**
  * A set of services for use within Convex action functions.
  *
@@ -127,7 +100,6 @@ export type MutationCtx = GenericMutationCtx<DataModel>;
  * function run on the server.
  */
 export type ActionCtx = GenericActionCtx<DataModel>;
-
 /**
  * An interface to read from the database within Convex query functions.
  *
@@ -136,7 +108,6 @@ export type ActionCtx = GenericActionCtx<DataModel>;
  * building a query.
  */
 export type DatabaseReader = GenericDatabaseReader<DataModel>;
-
 /**
  * An interface to read from and write to the database within Convex mutation
  * functions.

package/dist/component/convex.config.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("convex/server").ComponentDefinition<any>;
-export default _default;
+declare const component: import("convex/server").ComponentDefinition<any>;
+export default component;

package/dist/component/convex.config.js

@@ -1,3 +1,4 @@
 import { defineComponent } from "convex/server";
-const convex_config = defineComponent('replicate');
+const component = defineComponent('replicate');
+const convex_config = component;
 export { convex_config as default };

package/dist/component/logger.d.ts

@@ -0,0 +1,8 @@
+interface Logger {
+    debug(message: string, context?: Record<string, any>): void;
+    info(message: string, context?: Record<string, any>): void;
+    warn(message: string, context?: Record<string, any>): void;
+    error(message: string, context?: Record<string, any>): void;
+}
+export declare function getLogger(category: string[]): Logger;
+export {};