@deepseek-ai/dsh-api-workspace-files 0.1.5-alpha.1

package/lib/typert.remote-client.d.ts

@@ -0,0 +1,38 @@
+/* Generated by @deepseek-ai/dsh-typert-generator from the Host FaceModel — do not edit. */
+import type {
+  RemoteResult,
+  TypertRemoteContribution,
+} from '@deepseek-ai/dsh-typert-protocol'
+import type { WorkspaceByteRange, WorkspaceDirectoryListing, WorkspaceFileBytes, WorkspaceFileRange, WorkspaceFileStat, WorkspaceFileText, WorkspaceFileWatchFrame } from '@deepseek-ai/dsh-api-workspace-files/types'
+import type { SessionId } from '@deepseek-ai/dsh-session/types'
+
+declare module '@deepseek-ai/dsh-typert-protocol' {
+  interface TypertRemoteNamespace$776f726b737061636546696c6573 {
+    changes: (agentId: SessionId, signal?: AbortSignal) => AsyncIterable<WorkspaceFileWatchFrame>
+    list: (agentId: SessionId, path: string, signal?: AbortSignal) => Promise<RemoteResult<WorkspaceDirectoryListing>>
+    read: (agentId: SessionId, path: string, range: WorkspaceFileRange, signal?: AbortSignal) => Promise<RemoteResult<WorkspaceFileText>>
+    readBytes: (agentId: SessionId, path: string, range: WorkspaceByteRange, signal?: AbortSignal) => Promise<RemoteResult<WorkspaceFileBytes>>
+    stat: (agentId: SessionId, path: string, signal?: AbortSignal) => Promise<RemoteResult<WorkspaceFileStat>>
+  }
+  interface TypertRemoteMap {
+    'workspaceFiles/changes': (agentId: SessionId, signal?: AbortSignal) => AsyncIterable<WorkspaceFileWatchFrame>
+    'workspaceFiles/list': (agentId: SessionId, path: string, signal?: AbortSignal) => Promise<RemoteResult<WorkspaceDirectoryListing>>
+    'workspaceFiles/read': (agentId: SessionId, path: string, range: WorkspaceFileRange, signal?: AbortSignal) => Promise<RemoteResult<WorkspaceFileText>>
+    'workspaceFiles/readBytes': (agentId: SessionId, path: string, range: WorkspaceByteRange, signal?: AbortSignal) => Promise<RemoteResult<WorkspaceFileBytes>>
+    'workspaceFiles/stat': (agentId: SessionId, path: string, signal?: AbortSignal) => Promise<RemoteResult<WorkspaceFileStat>>
+  }
+  interface TypertRemoteNamespaceMap {
+    'workspaceFiles': TypertRemoteNamespace$776f726b737061636546696c6573
+  }
+  interface TypertRemoteScopeMap {
+    'agent:workspaceFiles/changes': (signal?: AbortSignal) => AsyncIterable<WorkspaceFileWatchFrame>
+    'agent:workspaceFiles/list': (path: string, signal?: AbortSignal) => Promise<RemoteResult<WorkspaceDirectoryListing>>
+    'agent:workspaceFiles/read': (path: string, range: WorkspaceFileRange, signal?: AbortSignal) => Promise<RemoteResult<WorkspaceFileText>>
+    'agent:workspaceFiles/readBytes': (path: string, range: WorkspaceByteRange, signal?: AbortSignal) => Promise<RemoteResult<WorkspaceFileBytes>>
+    'agent:workspaceFiles/stat': (path: string, signal?: AbortSignal) => Promise<RemoteResult<WorkspaceFileStat>>
+  }
+}
+
+export declare const TYPERT_REMOTE: TypertRemoteContribution
+export default TYPERT_REMOTE
+//# sourceMappingURL=typert.remote-client.d.ts.map

package/lib/typert.remote-client.js

@@ -0,0 +1,287 @@
+/* Generated by @deepseek-ai/dsh-typert-generator from the Host FaceModel — do not edit. */
+import { z } from 'zod'
+
+const _deepseek_ai_dsh_api_workspace_files_workspaceFiles_changes_parameter_0$schema = z.intersection(z.string(), z.unknown())
+const _deepseek_ai_dsh_api_workspace_files_workspaceFiles_changes_result$schema = z.union([z.object({
+  'kind': z.literal("ready").readonly(),
+}), z.object({
+  'kind': z.literal("change").readonly(),
+  'change': z.union([z.object({
+  'absolutePath': z.string().readonly(),
+  'version': z.string().readonly(),
+}), z.object({
+  'absolutePath': z.string().readonly(),
+  'absent': z.literal(true).readonly(),
+})]).readonly(),
+})])
+const _deepseek_ai_dsh_api_workspace_files_workspaceFiles_list_parameter_0$schema = z.intersection(z.string(), z.unknown())
+const _deepseek_ai_dsh_api_workspace_files_workspaceFiles_list_parameter_1$schema = z.string()
+const _deepseek_ai_dsh_api_workspace_files_workspaceFiles_list_result$schema = z.object({
+  'path': z.string().readonly(),
+  'entries': z.array(z.object({
+  'name': z.string().readonly(),
+  'type': z.union([z.literal("file"), z.literal("directory"), z.literal("other")]).readonly(),
+  'size': z.number().readonly().optional(),
+})).readonly(),
+  'truncated': z.boolean().readonly(),
+})
+const _deepseek_ai_dsh_api_workspace_files_workspaceFiles_read_parameter_0$schema = z.intersection(z.string(), z.unknown())
+const _deepseek_ai_dsh_api_workspace_files_workspaceFiles_read_parameter_1$schema = z.string()
+const _deepseek_ai_dsh_api_workspace_files_workspaceFiles_read_parameter_2$schema = z.object({
+  'offset': z.number().readonly().optional(),
+  'limit': z.number().readonly().optional(),
+})
+const _deepseek_ai_dsh_api_workspace_files_workspaceFiles_read_result$schema = z.object({
+  'offset': z.number().readonly(),
+  'text': z.string().readonly(),
+  'lines': z.number().readonly(),
+  'eof': z.boolean().readonly(),
+  'absolutePath': z.string().readonly(),
+  'version': z.string().readonly(),
+  'bytes': z.number().readonly().optional(),
+})
+const _deepseek_ai_dsh_api_workspace_files_workspaceFiles_readBytes_parameter_0$schema = z.intersection(z.string(), z.unknown())
+const _deepseek_ai_dsh_api_workspace_files_workspaceFiles_readBytes_parameter_1$schema = z.string()
+const _deepseek_ai_dsh_api_workspace_files_workspaceFiles_readBytes_parameter_2$schema = z.object({
+  'offset': z.number().readonly().optional(),
+  'length': z.number().readonly().optional(),
+})
+const _deepseek_ai_dsh_api_workspace_files_workspaceFiles_readBytes_result$schema = z.object({
+  'offset': z.number().readonly(),
+  'data': z.string().readonly(),
+  'eof': z.boolean().readonly(),
+  'absolutePath': z.string().readonly(),
+  'version': z.string().readonly(),
+  'bytes': z.number().readonly().optional(),
+})
+const _deepseek_ai_dsh_api_workspace_files_workspaceFiles_stat_parameter_0$schema = z.intersection(z.string(), z.unknown())
+const _deepseek_ai_dsh_api_workspace_files_workspaceFiles_stat_parameter_1$schema = z.string()
+const _deepseek_ai_dsh_api_workspace_files_workspaceFiles_stat_result$schema = z.object({
+  'absolutePath': z.string().readonly(),
+  'version': z.string().readonly(),
+  'bytes': z.number().readonly().optional(),
+})
+
+export const TYPERT_REMOTE = {
+  package: '@deepseek-ai/dsh-api-workspace-files',
+  descriptors: [
+    {
+      id: '@deepseek-ai/dsh-api-workspace-files#workspaceFiles/changes',
+      service: 'workspaceFiles',
+      namespace: 'workspaceFiles',
+      method: 'changes',
+      mode: 'stream',
+      invocation: { kind: 'direct' },
+      scope: {
+        context: 'agent',
+        wire: 'agentId',
+      },
+      parameters: [
+        {
+          name: 'agent',
+          wire: 'agentId',
+          source: 'lookup',
+          lookup: 'agent',
+          codec: {
+            mode: 'strict',
+            typeSymbol: '@deepseek-ai/dsh-session/types#SessionId',
+            schema: _deepseek_ai_dsh_api_workspace_files_workspaceFiles_changes_parameter_0$schema,
+          },
+        },
+      ],
+      cancellation: { parameter: 'signal' },
+      result: {
+        mode: 'strict',
+        typeSymbol: '@deepseek-ai/dsh-api-workspace-files/types#WorkspaceFileWatchFrame',
+        schema: _deepseek_ai_dsh_api_workspace_files_workspaceFiles_changes_result$schema,
+      },
+      sourceLocation: {"file":"packages/api/workspace-files/src/index.ts","line":274,"column":3},
+    },
+    {
+      id: '@deepseek-ai/dsh-api-workspace-files#workspaceFiles/list',
+      service: 'workspaceFiles',
+      namespace: 'workspaceFiles',
+      method: 'list',
+      invocation: { kind: 'direct' },
+      scope: {
+        context: 'agent',
+        wire: 'agentId',
+      },
+      parameters: [
+        {
+          name: 'agent',
+          wire: 'agentId',
+          source: 'lookup',
+          lookup: 'agent',
+          codec: {
+            mode: 'strict',
+            typeSymbol: '@deepseek-ai/dsh-session/types#SessionId',
+            schema: _deepseek_ai_dsh_api_workspace_files_workspaceFiles_list_parameter_0$schema,
+          },
+        },
+        {
+          name: 'path',
+          wire: 'path',
+          source: 'json',
+          codec: {
+            mode: 'strict',
+            typeSymbol: '@deepseek-ai/dsh-api-workspace-files#workspaceFiles/list:path',
+            schema: _deepseek_ai_dsh_api_workspace_files_workspaceFiles_list_parameter_1$schema,
+          },
+        },
+      ],
+      cancellation: { parameter: 'signal' },
+      result: {
+        mode: 'strict',
+        typeSymbol: '@deepseek-ai/dsh-api-workspace-files/types#WorkspaceDirectoryListing',
+        schema: _deepseek_ai_dsh_api_workspace_files_workspaceFiles_list_result$schema,
+      },
+      sourceLocation: {"file":"packages/api/workspace-files/src/index.ts","line":246,"column":9},
+    },
+    {
+      id: '@deepseek-ai/dsh-api-workspace-files#workspaceFiles/read',
+      service: 'workspaceFiles',
+      namespace: 'workspaceFiles',
+      method: 'read',
+      invocation: { kind: 'direct' },
+      scope: {
+        context: 'agent',
+        wire: 'agentId',
+      },
+      parameters: [
+        {
+          name: 'agent',
+          wire: 'agentId',
+          source: 'lookup',
+          lookup: 'agent',
+          codec: {
+            mode: 'strict',
+            typeSymbol: '@deepseek-ai/dsh-session/types#SessionId',
+            schema: _deepseek_ai_dsh_api_workspace_files_workspaceFiles_read_parameter_0$schema,
+          },
+        },
+        {
+          name: 'path',
+          wire: 'path',
+          source: 'json',
+          codec: {
+            mode: 'strict',
+            typeSymbol: '@deepseek-ai/dsh-api-workspace-files#workspaceFiles/read:path',
+            schema: _deepseek_ai_dsh_api_workspace_files_workspaceFiles_read_parameter_1$schema,
+          },
+        },
+        {
+          name: 'range',
+          wire: 'range',
+          source: 'json',
+          codec: {
+            mode: 'strict',
+            typeSymbol: '@deepseek-ai/dsh-api-workspace-files/types#WorkspaceFileRange',
+            schema: _deepseek_ai_dsh_api_workspace_files_workspaceFiles_read_parameter_2$schema,
+          },
+        },
+      ],
+      cancellation: { parameter: 'signal' },
+      result: {
+        mode: 'strict',
+        typeSymbol: '@deepseek-ai/dsh-api-workspace-files/types#WorkspaceFileText',
+        schema: _deepseek_ai_dsh_api_workspace_files_workspaceFiles_read_result$schema,
+      },
+      sourceLocation: {"file":"packages/api/workspace-files/src/index.ts","line":197,"column":9},
+    },
+    {
+      id: '@deepseek-ai/dsh-api-workspace-files#workspaceFiles/readBytes',
+      service: 'workspaceFiles',
+      namespace: 'workspaceFiles',
+      method: 'readBytes',
+      invocation: { kind: 'direct' },
+      scope: {
+        context: 'agent',
+        wire: 'agentId',
+      },
+      parameters: [
+        {
+          name: 'agent',
+          wire: 'agentId',
+          source: 'lookup',
+          lookup: 'agent',
+          codec: {
+            mode: 'strict',
+            typeSymbol: '@deepseek-ai/dsh-session/types#SessionId',
+            schema: _deepseek_ai_dsh_api_workspace_files_workspaceFiles_readBytes_parameter_0$schema,
+          },
+        },
+        {
+          name: 'path',
+          wire: 'path',
+          source: 'json',
+          codec: {
+            mode: 'strict',
+            typeSymbol: '@deepseek-ai/dsh-api-workspace-files#workspaceFiles/readBytes:path',
+            schema: _deepseek_ai_dsh_api_workspace_files_workspaceFiles_readBytes_parameter_1$schema,
+          },
+        },
+        {
+          name: 'range',
+          wire: 'range',
+          source: 'json',
+          codec: {
+            mode: 'strict',
+            typeSymbol: '@deepseek-ai/dsh-api-workspace-files/types#WorkspaceByteRange',
+            schema: _deepseek_ai_dsh_api_workspace_files_workspaceFiles_readBytes_parameter_2$schema,
+          },
+        },
+      ],
+      cancellation: { parameter: 'signal' },
+      result: {
+        mode: 'strict',
+        typeSymbol: '@deepseek-ai/dsh-api-workspace-files/types#WorkspaceFileBytes',
+        schema: _deepseek_ai_dsh_api_workspace_files_workspaceFiles_readBytes_result$schema,
+      },
+      sourceLocation: {"file":"packages/api/workspace-files/src/index.ts","line":217,"column":9},
+    },
+    {
+      id: '@deepseek-ai/dsh-api-workspace-files#workspaceFiles/stat',
+      service: 'workspaceFiles',
+      namespace: 'workspaceFiles',
+      method: 'stat',
+      invocation: { kind: 'direct' },
+      scope: {
+        context: 'agent',
+        wire: 'agentId',
+      },
+      parameters: [
+        {
+          name: 'agent',
+          wire: 'agentId',
+          source: 'lookup',
+          lookup: 'agent',
+          codec: {
+            mode: 'strict',
+            typeSymbol: '@deepseek-ai/dsh-session/types#SessionId',
+            schema: _deepseek_ai_dsh_api_workspace_files_workspaceFiles_stat_parameter_0$schema,
+          },
+        },
+        {
+          name: 'path',
+          wire: 'path',
+          source: 'json',
+          codec: {
+            mode: 'strict',
+            typeSymbol: '@deepseek-ai/dsh-api-workspace-files#workspaceFiles/stat:path',
+            schema: _deepseek_ai_dsh_api_workspace_files_workspaceFiles_stat_parameter_1$schema,
+          },
+        },
+      ],
+      cancellation: { parameter: 'signal' },
+      result: {
+        mode: 'strict',
+        typeSymbol: '@deepseek-ai/dsh-api-workspace-files/types#WorkspaceFileStat',
+        schema: _deepseek_ai_dsh_api_workspace_files_workspaceFiles_stat_result$schema,
+      },
+      sourceLocation: {"file":"packages/api/workspace-files/src/index.ts","line":233,"column":9},
+    },
+  ],
+}
+
+export default TYPERT_REMOTE

package/lib/types/changes.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Producer of the `changes` stream: every `fs/observed` emission whose target
+ * lies inside a generation's workspace root becomes one frame of that
+ * generation. Observations are emitted by tools after their own filesystem
+ * operation, so the feed covers Agent writes only; the OS is not watched.
+ * Each generation acknowledges its observation queue and resolved workspace
+ * root with `ready` before emitting any queued or live changes.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { WorkspaceFileWatchFrame } from './types.ts';
+/** Owns `fs/observed` observation and every open `changes` generation. */
+export declare class WorkspaceChangeFeed {
+    private readonly ctx;
+    private readonly followers;
+    /** @param ctx - Host context carrying the filesystem the observations come from. */
+    constructor(ctx: Context);
+    /**
+     * Open one generation reporting observations inside `workspaceRoot`.
+     * @param workspaceRoot - the session's workspace root path.
+     * @param signal - generation cancellation.
+     * @returns `ready` after observation is active and the root resolves, then
+     *   observations made after the generation was first pulled, in emission order.
+     */
+    follow(workspaceRoot: string, signal: AbortSignal): AsyncIterable<WorkspaceFileWatchFrame>;
+}
+//# sourceMappingURL=changes.d.ts.map

package/lib/types/changes.js

@@ -0,0 +1,109 @@
+/**
+ * Producer of the `changes` stream: every `fs/observed` emission whose target
+ * lies inside a generation's workspace root becomes one frame of that
+ * generation. Observations are emitted by tools after their own filesystem
+ * operation, so the feed covers Agent writes only; the OS is not watched.
+ * Each generation acknowledges its observation queue and resolved workspace
+ * root with `ready` before emitting any queued or live changes.
+ */
+import { Deque } from '@deepseek-ai/dsh-deque';
+/** Owns `fs/observed` observation and every open `changes` generation. */
+export class WorkspaceChangeFeed {
+    ctx;
+    followers = new Set();
+    /** @param ctx - Host context carrying the filesystem the observations come from. */
+    constructor(ctx) {
+        this.ctx = ctx;
+        ctx.on('fs/observed', (target, observation) => {
+            for (const follower of this.followers)
+                follower.push([target, observation]);
+        });
+        ctx.effect(() => () => {
+            for (const follower of this.followers)
+                follower.close();
+            this.followers.clear();
+        }, 'workspace-files.changes');
+    }
+    /**
+     * Open one generation reporting observations inside `workspaceRoot`.
+     * @param workspaceRoot - the session's workspace root path.
+     * @param signal - generation cancellation.
+     * @returns `ready` after observation is active and the root resolves, then
+     *   observations made after the generation was first pulled, in emission order.
+     */
+    async *follow(workspaceRoot, signal) {
+        signal.throwIfAborted();
+        // Registered before the root resolves, so nothing observed while it does is
+        // missed; the root only filters at drain time.
+        const follower = new ChangeFollower();
+        this.followers.add(follower);
+        try {
+            // Under the generation's signal, so a consumer leaving mid-resolve on a slow
+            // backend releases the follower now rather than when the resolve settles;
+            // a rejection the abort caused is the quiet end every other abort takes here.
+            const root = await this.ctx.fs.resolve(workspaceRoot, { signal }).catch((error) => {
+                if (signal.aborted)
+                    return undefined;
+                throw error;
+            });
+            if (root === undefined || signal.aborted || follower.isClosed)
+                return;
+            yield { kind: 'ready' };
+            for await (const [target, observation] of follower.read(signal)) {
+                if (!this.ctx.fs.contains(root, target))
+                    continue;
+                const absolutePath = this.ctx.fs.processPath(target);
+                yield {
+                    kind: 'change',
+                    change: observation.kind === 'present'
+                        ? { absolutePath, version: observation.version }
+                        : { absolutePath, absent: true },
+                };
+            }
+        }
+        finally {
+            this.followers.delete(follower);
+            follower.close();
+        }
+    }
+}
+/** One generation's queue: observations wait here until its consumer pulls them. */
+class ChangeFollower {
+    queue = new Deque();
+    wake;
+    closed = false;
+    /** Whether the generation was closed while its workspace root resolved. */
+    get isClosed() {
+        return this.closed;
+    }
+    push(observed) {
+        this.queue.pushBack(observed);
+        this.wake?.();
+    }
+    close() {
+        this.closed = true;
+        this.wake?.();
+    }
+    /** Drain until closed or aborted; anything still queued then is dropped with the generation. */
+    async *read(signal) {
+        const abort = () => { this.close(); };
+        signal.addEventListener('abort', abort, { once: true });
+        if (signal.aborted)
+            abort();
+        try {
+            while (!this.closed) {
+                const observed = this.queue.popFront();
+                if (observed !== undefined) {
+                    yield observed;
+                    continue;
+                }
+                await new Promise((resolve) => { this.wake = resolve; });
+                this.wake = undefined;
+            }
+        }
+        finally {
+            signal.removeEventListener('abort', abort);
+        }
+    }
+}
+//# sourceMappingURL=changes.js.map

package/lib/types/client/change-feed.d.ts

@@ -0,0 +1,105 @@
+/**
+ * One Host `changes` subscription per session, fanned out to the open files of
+ * that session.
+ *
+ * The Host reports every agent write in a session on one stream; each open file
+ * wants only its own. The feed opens the session stream when the first follower
+ * arrives, hands each frame to the followers of its path, and disposes the
+ * stream when the last follower leaves. A follower buffers session changes
+ * until `stat` supplies its Host absolute path, then filters queued and live
+ * frames by that path, with `\\` normalized to `/`. Resource addresses identify
+ * reload requests; they never determine a notification path.
+ */
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+import type { WorkspaceFilesRemote } from './remote.ts';
+import type { WorkspaceFileNotice } from './types.ts';
+/** Notices of one follower, delivered in order and pulled by its consumer. */
+declare class Follower implements AsyncIterable<WorkspaceFileNotice> {
+    readonly address: string;
+    private readonly leave;
+    private readonly pending;
+    private readonly started;
+    private wake;
+    private ended;
+    private hostKey;
+    /**
+     * Resolves true after the Host acknowledges its subscription, or false if
+     * this follower ends before acknowledgement.
+     */
+    readonly ready: Promise<boolean>;
+    /**
+     * @param address - resource address used for reload lookup.
+     * @param leave - unregisters this follower and its abort listener.
+     */
+    constructor(address: string, leave: () => void);
+    /** The normalized Host path, absent until a successful stat. */
+    get key(): string | undefined;
+    /**
+     * Select the Host path for queued and future changes.
+     * @param absolutePath - the successful stat's absolute path.
+     */
+    bind(absolutePath: string): void;
+    /** The Host acknowledged an active subscription and resolved workspace root. */
+    start(): void;
+    /**
+     * Queue one notice.
+     * @param notice - what the consumer receives next.
+     * @param key - normalized Host path for a change; absent for a reload.
+     */
+    push(notice: WorkspaceFileNotice, key?: string): void;
+    /** Deliver what is queued, then finish. */
+    end(): void;
+    /** Unregister even when the consumer has not started pulling notices. */
+    dispose(): void;
+    /** @inheritdoc */
+    [Symbol.asyncIterator](): AsyncIterator<WorkspaceFileNotice>;
+}
+/**
+ * Per-session fan-out of the Host's workspace file change stream.
+ *
+ * Owned by the provider; one instance serves every session of the Client.
+ */
+export declare class ChangeFeed {
+    private readonly remote;
+    /** Live feeds only: a feed removes itself when its stream closes. */
+    private readonly sessions;
+    /** Streams still closing, by session: the session's next feed opens after its predecessor has settled. */
+    private readonly closing;
+    /**
+     * @param remote - the Remote face carrying `$stream` and `workspaceFiles.changes`.
+     */
+    constructor(remote: WorkspaceFilesRemote);
+    /**
+     * Follow one resource address in one session before its Host path is known.
+     *
+     * The follower is registered on call, not on first pull. Changes delivered
+     * to this Client are queued while stat is pending. The first follower starts
+     * the session's local `changes` call. The iterable ends
+     * when `signal` aborts or when the session stream is gone; ending it early
+     * (`break`, `return`) unregisters the follower as well, and the last follower
+     * of a session disposes its stream. Await a true `ready` result before stat
+     * so the Host subscription is active, then bind each stat's absolute path. Until binding,
+     * any session write can trigger a retry; after binding, only matching queued
+     * and live changes pass.
+     * @param sessionId - the session whose workspace holds the file.
+     * @param address - the resource address, used only for reload lookup.
+     * @param signal - ends the follow.
+     * @returns a single-consumer subscription with Host-path binding and explicit disposal.
+     */
+    follow(sessionId: SessionId, address: string, signal: AbortSignal): Follower;
+    /**
+     * Ask an address and its same-session Host-path peers to `stat` again.
+     * @param sessionId - the session whose workspace holds the file.
+     * @param address - the resource address requesting a reload.
+     */
+    requestRestat(sessionId: SessionId, address: string): void;
+    /**
+     * Wait for every stream that is still closing, so an owner tearing down
+     * leaves no Host stream behind.
+     * @returns resolves once no stream of this feed is closing.
+     */
+    settle(): Promise<void>;
+    private feedOf;
+}
+export {};
+//# sourceMappingURL=change-feed.d.ts.map