@pmate/chat-sdk 0.12.0-next.4 → 0.12.0-next.41

package/lib/runtime/messageClient.d.ts

@@ -15,6 +15,8 @@ export type MessageTransport<T> = {
 export type MessageSnapshot<T> = {
     messages: readonly T[];
     hasEarlier: boolean;
+    resetVersion: number;
+    complete: boolean;
 };
 export type MessageClientOptions<T extends StoredMessage> = {
     scope: MessageScope;
@@ -34,6 +36,9 @@ export declare class MessageClient<T extends StoredMessage> {
     private options;
     private storage;
     private watches;
+    private windowEdges;
+    private accessListeners;
+    private allListeners;
     private reads;
     private syncing;
     private paging;
@@ -51,12 +56,32 @@ export declare class MessageClient<T extends StoredMessage> {
     private queueBytes;
     private pendingBytes;
     private pendingRecords;
+    private legacyImports;
+    private revokingScope?;
+    private scopeReady?;
+    private scopeVersion;
+    private scopeAllowed;
+    private scopeDenied;
+    private enqueuing;
+    private ensureScope;
     constructor(options: MessageClientOptions<T>);
+    /** Shared guard for sibling caches; it never authorizes a denied old instance. */
+    subscribeAccessRevoked(listener: () => void): () => void;
+    scopeAccess(): Promise<{
+        version: number;
+        allowed: boolean;
+    }>;
     getSnapshot(thread: string): MessageSnapshot<T> | undefined;
     subscribe(thread: string, listener: () => void): () => void;
-    read(thread: string, limit?: number): Promise<MessageSnapshot<T>>;
+    subscribeAll(listener: (threadId: string) => void): () => void;
+    /** Close the connection gap for saved windows with four bounded background lanes. */
+    restore(since: number, threadId?: string): Promise<void>;
+    read(thread: string, limit?: number, refresh?: boolean): Promise<MessageSnapshot<T>>;
     /** Application connection/wake events invalidate, rather than fetching directly. */
     invalidate(thread: string): void;
+    private fallback;
+    /** Migration batches remain separate from authoritative message coverage. */
+    importLegacy(thread: string, messages: T[]): Promise<void>;
     private reload;
     /** Events are visible only after their atomic batch commits. */
     receive(thread: string, messages: T[]): Promise<void>;
@@ -66,14 +91,16 @@ export declare class MessageClient<T extends StoredMessage> {
     private flushWrites;
     private runWrites;
     synchronize(thread: string): Promise<void>;
+    /** Keep an explicitly requested history range in the shared subscribed view. */
+    expandWindow(thread: string, page: MessageSnapshot<T>): Promise<void>;
     earlier(thread: string, before: {
         timestamp: number;
         id: string;
-    }, limit?: number): Promise<{
-        messages: T[];
-        hasEarlier: boolean;
-    }>;
+    }, limit?: number, expand?: boolean): Promise<MessageSnapshot<T>>;
     private fillWindow;
+    private denyView;
+    private denyScope;
+    revokeScope(): Promise<number>;
     revoke(thread: string): Promise<void>;
-    close(): Promise<void>;
+    close(beforeDispose?: Promise<unknown>): Promise<void>;
 }