@offlinejs/types 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,289 @@
+type RecordId = string;
+declare const OFFLINEJS_PUBLIC_API_VERSION = "1.0.0";
+declare const STORAGE_ADAPTER_CONTRACT_VERSION = 1;
+declare const SYNC_TRANSPORT_CONTRACT_VERSION = 1;
+type EntityRecord = {
+    id: RecordId;
+    [key: string]: unknown;
+};
+type PartialEntity<TRecord extends EntityRecord> = Partial<Omit<TRecord, "id">> & {
+    id?: RecordId;
+};
+type SortDirection = "asc" | "desc";
+type QueryFilterValue = string | number | boolean | null | Array<string | number | boolean | null> | {
+    eq?: unknown;
+    ne?: unknown;
+    gt?: number | string;
+    gte?: number | string;
+    lt?: number | string;
+    lte?: number | string;
+    in?: unknown[];
+    contains?: string;
+};
+type QueryFilters<TRecord extends EntityRecord = EntityRecord> = Partial<Record<keyof TRecord, QueryFilterValue>>;
+interface QueryOptions<TRecord extends EntityRecord = EntityRecord> {
+    filters?: QueryFilters<TRecord>;
+    limit?: number;
+    offset?: number;
+    orderBy?: keyof TRecord | string;
+    search?: string;
+    searchFields?: Array<keyof TRecord | string>;
+    sort?: SortDirection;
+}
+type IndexKind = "single" | "compound" | "fullText";
+interface IndexDefinition<TRecord extends EntityRecord = EntityRecord> {
+    collection: string;
+    fields: Array<keyof TRecord | string>;
+    name: string;
+    unique?: boolean;
+    kind?: IndexKind;
+}
+interface PaginatedResult<TRecord extends EntityRecord> {
+    data: TRecord[];
+    limit: number;
+    offset: number;
+    total: number;
+}
+interface TransactionStore {
+    get<TRecord extends EntityRecord>(collection: string, id: RecordId): Promise<TRecord | null>;
+    set<TRecord extends EntityRecord>(collection: string, value: TRecord): Promise<void>;
+    delete(collection: string, id: RecordId): Promise<void>;
+    find<TRecord extends EntityRecord>(collection: string, query?: QueryOptions<TRecord>): Promise<TRecord[]>;
+    clear(collection?: string): Promise<void>;
+}
+interface StorageMigration {
+    name: string;
+    up(storage: TransactionStore): Promise<void>;
+}
+interface StorageAdapterCapabilities {
+    indexes?: boolean;
+    migrations?: boolean;
+    persistence?: "durable" | "ephemeral";
+    transactions?: "atomic" | "best-effort";
+}
+interface StorageAdapter {
+    readonly name: string;
+    readonly contractVersion?: typeof STORAGE_ADAPTER_CONTRACT_VERSION;
+    readonly capabilities?: StorageAdapterCapabilities;
+    get<TRecord extends EntityRecord>(collection: string, id: RecordId): Promise<TRecord | null>;
+    set<TRecord extends EntityRecord>(collection: string, value: TRecord): Promise<void>;
+    delete(collection: string, id: RecordId): Promise<void>;
+    find<TRecord extends EntityRecord>(collection: string, query?: QueryOptions<TRecord>): Promise<TRecord[]>;
+    clear(collection?: string): Promise<void>;
+    transaction<TValue>(scope: string[], run: (store: TransactionStore) => Promise<TValue>): Promise<TValue>;
+    migrate?(migrations: StorageMigration[]): Promise<void>;
+}
+interface IndexableStorageAdapter extends StorageAdapter {
+    createIndex?<TRecord extends EntityRecord>(definition: IndexDefinition<TRecord>): Promise<void>;
+    dropIndex?(collection: string, name: string): Promise<void>;
+    listIndexes?(collection?: string): Promise<IndexDefinition[]>;
+}
+type MutationOperation = "create" | "update" | "delete";
+interface QueuedMutation<TRecord extends EntityRecord = EntityRecord> extends EntityRecord {
+    collection: string;
+    operation: MutationOperation;
+    recordId: RecordId;
+    payload?: PartialEntity<TRecord>;
+    base?: TRecord | null;
+    createdAt: number;
+    lastAttemptAt?: number;
+    priority: number;
+    retries: number;
+    status: "pending" | "processing" | "failed";
+}
+interface RetryOptions {
+    baseDelayMs: number;
+    factor: number;
+    jitter: boolean;
+    maxAttempts: number;
+    maxDelayMs: number;
+}
+interface QueueProcessingOptions {
+    batchSize: number;
+    retry: RetryOptions;
+}
+interface NetworkState {
+    online: boolean;
+    since: number;
+}
+interface NetworkMonitor {
+    getState(): NetworkState;
+    isOnline(): boolean;
+    subscribe(listener: (state: NetworkState) => void): () => void;
+}
+interface TransportRequest<TBody = unknown> {
+    body?: TBody;
+    headers?: Record<string, string>;
+    method: "DELETE" | "GET" | "PATCH" | "POST" | "PUT";
+    path: string;
+    query?: Record<string, string | number | boolean | undefined>;
+    timeoutMs?: number;
+}
+interface TransportResponse<TData = unknown> {
+    data: TData;
+    etag?: string;
+    status: number;
+}
+interface SyncTransport {
+    readonly contractVersion?: typeof SYNC_TRANSPORT_CONTRACT_VERSION;
+    request<TData = unknown, TBody = unknown>(request: TransportRequest<TBody>): Promise<TransportResponse<TData>>;
+}
+interface TransportMiddlewareContext<TBody = unknown> {
+    request: TransportRequest<TBody>;
+}
+type TransportMiddleware = <TBody = unknown>(context: TransportMiddlewareContext<TBody>) => Promise<TransportRequest<TBody>> | TransportRequest<TBody>;
+interface TransportOptions {
+    baseURL: string;
+    fetch?: typeof fetch;
+    headers?: Record<string, string> | (() => Promise<Record<string, string>> | Record<string, string>);
+    middlewares?: TransportMiddleware[];
+    timeoutMs?: number;
+}
+/** Named built-in conflict strategies for better DX than raw strings. */
+declare enum ConflictStrategyName {
+    ClientWins = "clientWins",
+    ServerWins = "serverWins",
+    LastWriteWins = "lastWriteWins",
+    Merge = "merge"
+}
+type ConflictStrategy<TRecord extends EntityRecord = EntityRecord> = ConflictStrategyName | `${ConflictStrategyName}` | ConflictResolver<TRecord>;
+interface ConflictContext<TRecord extends EntityRecord = EntityRecord> {
+    client: TRecord | null;
+    collection: string;
+    mutation: QueuedMutation<TRecord>;
+    server: TRecord | null;
+}
+type ConflictResolver<TRecord extends EntityRecord = EntityRecord> = (context: ConflictContext<TRecord>) => Promise<TRecord | null> | TRecord | null;
+interface SyncOptions<TRecord extends EntityRecord = EntityRecord> {
+    autoStart?: boolean;
+    batchSize?: number;
+    conflictStrategy?: ConflictStrategy<TRecord>;
+    deltaField?: string;
+    enabled?: boolean;
+    pull?: boolean;
+    push?: boolean;
+    retry?: Partial<RetryOptions>;
+}
+interface OfflineEvents {
+    "sync:start": {
+        mode: "push" | "pull" | "full";
+        queued: number;
+    };
+    "sync:end": {
+        completed: number;
+        failed: number;
+    };
+    offline: NetworkState;
+    online: NetworkState;
+    "queue:add": QueuedMutation;
+    "queue:complete": QueuedMutation;
+    conflict: ConflictContext;
+    error: Error;
+    "worker:message": WorkerSyncMessage;
+    "coordination:message": CoordinationMessage;
+}
+type OfflineEventName = keyof OfflineEvents;
+interface EventBus<TEvents extends object = OfflineEvents> {
+    emit<TName extends keyof TEvents>(name: TName, payload: TEvents[TName]): void;
+    off<TName extends keyof TEvents>(name: TName, listener: (payload: TEvents[TName]) => void): void;
+    on<TName extends keyof TEvents>(name: TName, listener: (payload: TEvents[TName]) => void): () => void;
+}
+type CollectionSubscriber<TRecord extends EntityRecord> = (records: TRecord[]) => void;
+interface OfflineCollection<TRecord extends EntityRecord> {
+    create(data: PartialEntity<TRecord>): Promise<TRecord>;
+    delete(id: RecordId): Promise<void>;
+    find(query?: QueryOptions<TRecord>): Promise<TRecord[]>;
+    findOne(id: RecordId): Promise<TRecord | null>;
+    paginate(query?: QueryOptions<TRecord>): Promise<PaginatedResult<TRecord>>;
+    subscribe(callback: CollectionSubscriber<TRecord>): () => void;
+    sync(): Promise<void>;
+    update(id: RecordId, data: PartialEntity<TRecord>): Promise<TRecord>;
+}
+type CollectionMap = object;
+type CollectionRecord<TCollections extends CollectionMap, TName extends keyof TCollections> = TCollections[TName] extends EntityRecord ? TCollections[TName] : EntityRecord;
+interface OfflineDB<TCollections extends CollectionMap = CollectionMap> extends EventBus<OfflineEvents> {
+    collection<TName extends Extract<keyof TCollections, string>>(name: TName): OfflineCollection<CollectionRecord<TCollections, TName>>;
+    collection<TRecord extends EntityRecord = EntityRecord>(name: string): OfflineCollection<TRecord>;
+    destroy(): Promise<void>;
+    sync(): Promise<void>;
+    transaction<TValue>(run: (db: OfflineDB<TCollections>) => Promise<TValue>): Promise<TValue>;
+    use(plugin: OfflinePlugin<TCollections>): OfflineDB<TCollections>;
+}
+interface OfflinePluginContext<TCollections extends CollectionMap = CollectionMap> {
+    db: OfflineDB<TCollections>;
+    events: EventBus<OfflineEvents>;
+    network: NetworkMonitor;
+    storage: StorageAdapter;
+}
+interface ValidationIssue {
+    code: string;
+    message: string;
+    path: string[];
+}
+interface ValidationResult {
+    issues: ValidationIssue[];
+    valid: boolean;
+}
+type SchemaValidator<TRecord extends EntityRecord = EntityRecord> = (record: PartialEntity<TRecord>, collection: string) => Promise<ValidationResult> | ValidationResult;
+interface EncryptionCodec {
+    decrypt(value: Uint8Array): Promise<Uint8Array> | Uint8Array;
+    encrypt(value: Uint8Array): Promise<Uint8Array> | Uint8Array;
+}
+interface CoordinationMessage<TPayload = unknown> {
+    id: string;
+    payload: TPayload;
+    source: string;
+    timestamp: number;
+    type: string;
+}
+interface WorkerSyncMessage<TPayload = unknown> {
+    id: string;
+    payload?: TPayload;
+    timestamp: number;
+    type: "sync" | "pause" | "resume" | "status" | "shutdown";
+}
+interface SyncProtocolMutation<TRecord extends EntityRecord = EntityRecord> {
+    id: string;
+    collection: string;
+    operation: MutationOperation;
+    payload?: PartialEntity<TRecord>;
+    recordId: string;
+}
+interface SyncProtocolPushRequest<TRecord extends EntityRecord = EntityRecord> {
+    clientId: string;
+    mutations: Array<SyncProtocolMutation<TRecord>>;
+    since?: string | number;
+}
+interface SyncProtocolPushResponse<TRecord extends EntityRecord = EntityRecord> {
+    accepted: string[];
+    conflicts: Array<ConflictContext<TRecord>>;
+    rejected: Array<{
+        id: string;
+        reason: string;
+    }>;
+}
+interface SyncProtocolPullRequest {
+    clientId: string;
+    collection: string;
+    limit?: number;
+    since?: string | number;
+}
+interface SyncProtocolPullResponse<TRecord extends EntityRecord = EntityRecord> {
+    cursor?: string;
+    records: TRecord[];
+}
+interface OfflinePlugin<TCollections extends CollectionMap = CollectionMap> {
+    name: string;
+    setup(context: OfflinePluginContext<TCollections>): void | (() => void) | Promise<void | (() => void)>;
+}
+interface OfflineDBOptions<TCollections extends CollectionMap = CollectionMap> {
+    baseURL?: string;
+    headers?: Record<string, string> | (() => Promise<Record<string, string>> | Record<string, string>);
+    network?: NetworkMonitor;
+    plugins?: Array<OfflinePlugin<TCollections>>;
+    storage?: StorageAdapter;
+    sync?: SyncOptions;
+    transport?: SyncTransport;
+}
+
+export { type CollectionMap, type CollectionRecord, type CollectionSubscriber, type ConflictContext, type ConflictResolver, type ConflictStrategy, ConflictStrategyName, type CoordinationMessage, type EncryptionCodec, type EntityRecord, type EventBus, type IndexDefinition, type IndexKind, type IndexableStorageAdapter, type MutationOperation, type NetworkMonitor, type NetworkState, OFFLINEJS_PUBLIC_API_VERSION, type OfflineCollection, type OfflineDB, type OfflineDBOptions, type OfflineEventName, type OfflineEvents, type OfflinePlugin, type OfflinePluginContext, type PaginatedResult, type PartialEntity, type QueryFilterValue, type QueryFilters, type QueryOptions, type QueueProcessingOptions, type QueuedMutation, type RecordId, type RetryOptions, STORAGE_ADAPTER_CONTRACT_VERSION, SYNC_TRANSPORT_CONTRACT_VERSION, type SchemaValidator, type SortDirection, type StorageAdapter, type StorageAdapterCapabilities, type StorageMigration, type SyncOptions, type SyncProtocolMutation, type SyncProtocolPullRequest, type SyncProtocolPullResponse, type SyncProtocolPushRequest, type SyncProtocolPushResponse, type SyncTransport, type TransactionStore, type TransportMiddleware, type TransportMiddlewareContext, type TransportOptions, type TransportRequest, type TransportResponse, type ValidationIssue, type ValidationResult, type WorkerSyncMessage };

package/dist/index.js

@@ -0,0 +1,15 @@
+// src/index.ts
+var OFFLINEJS_PUBLIC_API_VERSION = "1.0.0";
+var STORAGE_ADAPTER_CONTRACT_VERSION = 1;
+var SYNC_TRANSPORT_CONTRACT_VERSION = 1;
+var ConflictStrategyName = /* @__PURE__ */ ((ConflictStrategyName2) => {
+  ConflictStrategyName2["ClientWins"] = "clientWins";
+  ConflictStrategyName2["ServerWins"] = "serverWins";
+  ConflictStrategyName2["LastWriteWins"] = "lastWriteWins";
+  ConflictStrategyName2["Merge"] = "merge";
+  return ConflictStrategyName2;
+})(ConflictStrategyName || {});
+
+export { ConflictStrategyName, OFFLINEJS_PUBLIC_API_VERSION, STORAGE_ADAPTER_CONTRACT_VERSION, SYNC_TRANSPORT_CONTRACT_VERSION };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"names":["ConflictStrategyName"],"mappings":";AAEO,IAAM,4BAAA,GAA+B;AACrC,IAAM,gCAAA,GAAmC;AACzC,IAAM,+BAAA,GAAkC;AA4LxC,IAAK,oBAAA,qBAAAA,qBAAAA,KAAL;AACL,EAAAA,sBAAA,YAAA,CAAA,GAAa,YAAA;AACb,EAAAA,sBAAA,YAAA,CAAA,GAAa,YAAA;AACb,EAAAA,sBAAA,eAAA,CAAA,GAAgB,eAAA;AAChB,EAAAA,sBAAA,OAAA,CAAA,GAAQ,OAAA;AAJE,EAAA,OAAAA,qBAAAA;AAAA,CAAA,EAAA,oBAAA,IAAA,EAAA","file":"index.js","sourcesContent":["export type RecordId = string;\n\nexport const OFFLINEJS_PUBLIC_API_VERSION = \"1.0.0\";\nexport const STORAGE_ADAPTER_CONTRACT_VERSION = 1;\nexport const SYNC_TRANSPORT_CONTRACT_VERSION = 1;\n\nexport type EntityRecord = {\n  id: RecordId;\n  [key: string]: unknown;\n};\n\nexport type PartialEntity<TRecord extends EntityRecord> = Partial<Omit<TRecord, \"id\">> & {\n  id?: RecordId;\n};\n\nexport type SortDirection = \"asc\" | \"desc\";\n\nexport type QueryFilterValue =\n  | string\n  | number\n  | boolean\n  | null\n  | Array<string | number | boolean | null>\n  | {\n      eq?: unknown;\n      ne?: unknown;\n      gt?: number | string;\n      gte?: number | string;\n      lt?: number | string;\n      lte?: number | string;\n      in?: unknown[];\n      contains?: string;\n    };\n\nexport type QueryFilters<TRecord extends EntityRecord = EntityRecord> = Partial<\n  Record<keyof TRecord, QueryFilterValue>\n>;\n\nexport interface QueryOptions<TRecord extends EntityRecord = EntityRecord> {\n  filters?: QueryFilters<TRecord>;\n  limit?: number;\n  offset?: number;\n  orderBy?: keyof TRecord | string;\n  search?: string;\n  searchFields?: Array<keyof TRecord | string>;\n  sort?: SortDirection;\n}\n\nexport type IndexKind = \"single\" | \"compound\" | \"fullText\";\n\nexport interface IndexDefinition<TRecord extends EntityRecord = EntityRecord> {\n  collection: string;\n  fields: Array<keyof TRecord | string>;\n  name: string;\n  unique?: boolean;\n  kind?: IndexKind;\n}\n\nexport interface PaginatedResult<TRecord extends EntityRecord> {\n  data: TRecord[];\n  limit: number;\n  offset: number;\n  total: number;\n}\n\nexport interface TransactionStore {\n  get<TRecord extends EntityRecord>(collection: string, id: RecordId): Promise<TRecord | null>;\n  set<TRecord extends EntityRecord>(collection: string, value: TRecord): Promise<void>;\n  delete(collection: string, id: RecordId): Promise<void>;\n  find<TRecord extends EntityRecord>(\n    collection: string,\n    query?: QueryOptions<TRecord>\n  ): Promise<TRecord[]>;\n  clear(collection?: string): Promise<void>;\n}\n\nexport interface StorageMigration {\n  name: string;\n  up(storage: TransactionStore): Promise<void>;\n}\n\nexport interface StorageAdapterCapabilities {\n  indexes?: boolean;\n  migrations?: boolean;\n  persistence?: \"durable\" | \"ephemeral\";\n  transactions?: \"atomic\" | \"best-effort\";\n}\n\nexport interface StorageAdapter {\n  readonly name: string;\n  readonly contractVersion?: typeof STORAGE_ADAPTER_CONTRACT_VERSION;\n  readonly capabilities?: StorageAdapterCapabilities;\n  get<TRecord extends EntityRecord>(collection: string, id: RecordId): Promise<TRecord | null>;\n  set<TRecord extends EntityRecord>(collection: string, value: TRecord): Promise<void>;\n  delete(collection: string, id: RecordId): Promise<void>;\n  find<TRecord extends EntityRecord>(\n    collection: string,\n    query?: QueryOptions<TRecord>\n  ): Promise<TRecord[]>;\n  clear(collection?: string): Promise<void>;\n  transaction<TValue>(\n    scope: string[],\n    run: (store: TransactionStore) => Promise<TValue>\n  ): Promise<TValue>;\n  migrate?(migrations: StorageMigration[]): Promise<void>;\n}\n\nexport interface IndexableStorageAdapter extends StorageAdapter {\n  createIndex?<TRecord extends EntityRecord>(definition: IndexDefinition<TRecord>): Promise<void>;\n  dropIndex?(collection: string, name: string): Promise<void>;\n  listIndexes?(collection?: string): Promise<IndexDefinition[]>;\n}\n\nexport type MutationOperation = \"create\" | \"update\" | \"delete\";\n\nexport interface QueuedMutation<TRecord extends EntityRecord = EntityRecord> extends EntityRecord {\n  collection: string;\n  operation: MutationOperation;\n  recordId: RecordId;\n  payload?: PartialEntity<TRecord>;\n  base?: TRecord | null;\n  createdAt: number;\n  lastAttemptAt?: number;\n  priority: number;\n  retries: number;\n  status: \"pending\" | \"processing\" | \"failed\";\n}\n\nexport interface RetryOptions {\n  baseDelayMs: number;\n  factor: number;\n  jitter: boolean;\n  maxAttempts: number;\n  maxDelayMs: number;\n}\n\nexport interface QueueProcessingOptions {\n  batchSize: number;\n  retry: RetryOptions;\n}\n\nexport interface NetworkState {\n  online: boolean;\n  since: number;\n}\n\nexport interface NetworkMonitor {\n  getState(): NetworkState;\n  isOnline(): boolean;\n  subscribe(listener: (state: NetworkState) => void): () => void;\n}\n\nexport interface TransportRequest<TBody = unknown> {\n  body?: TBody;\n  headers?: Record<string, string>;\n  method: \"DELETE\" | \"GET\" | \"PATCH\" | \"POST\" | \"PUT\";\n  path: string;\n  query?: Record<string, string | number | boolean | undefined>;\n  timeoutMs?: number;\n}\n\nexport interface TransportResponse<TData = unknown> {\n  data: TData;\n  etag?: string;\n  status: number;\n}\n\nexport interface SyncTransport {\n  readonly contractVersion?: typeof SYNC_TRANSPORT_CONTRACT_VERSION;\n  request<TData = unknown, TBody = unknown>(\n    request: TransportRequest<TBody>\n  ): Promise<TransportResponse<TData>>;\n}\n\nexport interface TransportMiddlewareContext<TBody = unknown> {\n  request: TransportRequest<TBody>;\n}\n\nexport type TransportMiddleware = <TBody = unknown>(\n  context: TransportMiddlewareContext<TBody>\n) => Promise<TransportRequest<TBody>> | TransportRequest<TBody>;\n\nexport interface TransportOptions {\n  baseURL: string;\n  fetch?: typeof fetch;\n  headers?:\n    Record<string, string> | (() => Promise<Record<string, string>> | Record<string, string>);\n  middlewares?: TransportMiddleware[];\n  timeoutMs?: number;\n}\n\n/** Named built-in conflict strategies for better DX than raw strings. */\nexport enum ConflictStrategyName {\n  ClientWins = \"clientWins\",\n  ServerWins = \"serverWins\",\n  LastWriteWins = \"lastWriteWins\",\n  Merge = \"merge\"\n}\n\nexport type ConflictStrategy<TRecord extends EntityRecord = EntityRecord> =\n  | ConflictStrategyName\n  | `${ConflictStrategyName}`\n  | ConflictResolver<TRecord>;\n\nexport interface ConflictContext<TRecord extends EntityRecord = EntityRecord> {\n  client: TRecord | null;\n  collection: string;\n  mutation: QueuedMutation<TRecord>;\n  server: TRecord | null;\n}\n\nexport type ConflictResolver<TRecord extends EntityRecord = EntityRecord> = (\n  context: ConflictContext<TRecord>\n) => Promise<TRecord | null> | TRecord | null;\n\nexport interface SyncOptions<TRecord extends EntityRecord = EntityRecord> {\n  autoStart?: boolean;\n  batchSize?: number;\n  conflictStrategy?: ConflictStrategy<TRecord>;\n  deltaField?: string;\n  enabled?: boolean;\n  pull?: boolean;\n  push?: boolean;\n  retry?: Partial<RetryOptions>;\n}\n\nexport interface OfflineEvents {\n  \"sync:start\": { mode: \"push\" | \"pull\" | \"full\"; queued: number };\n  \"sync:end\": { completed: number; failed: number };\n  offline: NetworkState;\n  online: NetworkState;\n  \"queue:add\": QueuedMutation;\n  \"queue:complete\": QueuedMutation;\n  conflict: ConflictContext;\n  error: Error;\n  \"worker:message\": WorkerSyncMessage;\n  \"coordination:message\": CoordinationMessage;\n}\n\nexport type OfflineEventName = keyof OfflineEvents;\n\nexport interface EventBus<TEvents extends object = OfflineEvents> {\n  emit<TName extends keyof TEvents>(name: TName, payload: TEvents[TName]): void;\n  off<TName extends keyof TEvents>(name: TName, listener: (payload: TEvents[TName]) => void): void;\n  on<TName extends keyof TEvents>(\n    name: TName,\n    listener: (payload: TEvents[TName]) => void\n  ): () => void;\n}\n\nexport type CollectionSubscriber<TRecord extends EntityRecord> = (records: TRecord[]) => void;\n\nexport interface OfflineCollection<TRecord extends EntityRecord> {\n  create(data: PartialEntity<TRecord>): Promise<TRecord>;\n  delete(id: RecordId): Promise<void>;\n  find(query?: QueryOptions<TRecord>): Promise<TRecord[]>;\n  findOne(id: RecordId): Promise<TRecord | null>;\n  paginate(query?: QueryOptions<TRecord>): Promise<PaginatedResult<TRecord>>;\n  subscribe(callback: CollectionSubscriber<TRecord>): () => void;\n  sync(): Promise<void>;\n  update(id: RecordId, data: PartialEntity<TRecord>): Promise<TRecord>;\n}\n\nexport type CollectionMap = object;\n\nexport type CollectionRecord<\n  TCollections extends CollectionMap,\n  TName extends keyof TCollections\n> = TCollections[TName] extends EntityRecord ? TCollections[TName] : EntityRecord;\n\nexport interface OfflineDB<\n  TCollections extends CollectionMap = CollectionMap\n> extends EventBus<OfflineEvents> {\n  collection<TName extends Extract<keyof TCollections, string>>(\n    name: TName\n  ): OfflineCollection<CollectionRecord<TCollections, TName>>;\n  collection<TRecord extends EntityRecord = EntityRecord>(name: string): OfflineCollection<TRecord>;\n  destroy(): Promise<void>;\n  sync(): Promise<void>;\n  transaction<TValue>(run: (db: OfflineDB<TCollections>) => Promise<TValue>): Promise<TValue>;\n  use(plugin: OfflinePlugin<TCollections>): OfflineDB<TCollections>;\n}\n\nexport interface OfflinePluginContext<TCollections extends CollectionMap = CollectionMap> {\n  db: OfflineDB<TCollections>;\n  events: EventBus<OfflineEvents>;\n  network: NetworkMonitor;\n  storage: StorageAdapter;\n}\n\nexport interface ValidationIssue {\n  code: string;\n  message: string;\n  path: string[];\n}\n\nexport interface ValidationResult {\n  issues: ValidationIssue[];\n  valid: boolean;\n}\n\nexport type SchemaValidator<TRecord extends EntityRecord = EntityRecord> = (\n  record: PartialEntity<TRecord>,\n  collection: string\n) => Promise<ValidationResult> | ValidationResult;\n\nexport interface EncryptionCodec {\n  decrypt(value: Uint8Array): Promise<Uint8Array> | Uint8Array;\n  encrypt(value: Uint8Array): Promise<Uint8Array> | Uint8Array;\n}\n\nexport interface CoordinationMessage<TPayload = unknown> {\n  id: string;\n  payload: TPayload;\n  source: string;\n  timestamp: number;\n  type: string;\n}\n\nexport interface WorkerSyncMessage<TPayload = unknown> {\n  id: string;\n  payload?: TPayload;\n  timestamp: number;\n  type: \"sync\" | \"pause\" | \"resume\" | \"status\" | \"shutdown\";\n}\n\nexport interface SyncProtocolMutation<TRecord extends EntityRecord = EntityRecord> {\n  id: string;\n  collection: string;\n  operation: MutationOperation;\n  payload?: PartialEntity<TRecord>;\n  recordId: string;\n}\n\nexport interface SyncProtocolPushRequest<TRecord extends EntityRecord = EntityRecord> {\n  clientId: string;\n  mutations: Array<SyncProtocolMutation<TRecord>>;\n  since?: string | number;\n}\n\nexport interface SyncProtocolPushResponse<TRecord extends EntityRecord = EntityRecord> {\n  accepted: string[];\n  conflicts: Array<ConflictContext<TRecord>>;\n  rejected: Array<{ id: string; reason: string }>;\n}\n\nexport interface SyncProtocolPullRequest {\n  clientId: string;\n  collection: string;\n  limit?: number;\n  since?: string | number;\n}\n\nexport interface SyncProtocolPullResponse<TRecord extends EntityRecord = EntityRecord> {\n  cursor?: string;\n  records: TRecord[];\n}\n\nexport interface OfflinePlugin<TCollections extends CollectionMap = CollectionMap> {\n  name: string;\n  setup(\n    context: OfflinePluginContext<TCollections>\n  ): void | (() => void) | Promise<void | (() => void)>;\n}\n\nexport interface OfflineDBOptions<TCollections extends CollectionMap = CollectionMap> {\n  baseURL?: string;\n  headers?:\n    Record<string, string> | (() => Promise<Record<string, string>> | Record<string, string>);\n  network?: NetworkMonitor;\n  plugins?: Array<OfflinePlugin<TCollections>>;\n  storage?: StorageAdapter;\n  sync?: SyncOptions;\n  transport?: SyncTransport;\n}\n"]}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@offlinejs/types",
+  "version": "0.1.0",
+  "description": "Shared TypeScript contracts for OfflineJS packages.",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "tsup": "latest",
+    "typescript": "latest"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}