@fluidframework/datastore-definitions 2.0.0-rc.1.0.4 → 2.0.0-rc.2.0.0

package/dist/datastore-definitions-public.d.ts

@@ -5,27 +5,26 @@
  * @packageDocumentation
  */
 
-import { AttachState } from '@fluidframework/container-definitions';
-import { FluidObject } from '@fluidframework/core-interfaces';
-import { IAudience } from '@fluidframework/container-definitions';
-import { IDeltaManager } from '@fluidframework/container-definitions';
-import { IDisposable } from '@fluidframework/core-interfaces';
-import { IDocumentMessage } from '@fluidframework/protocol-definitions';
-import { IEvent } from '@fluidframework/core-interfaces';
-import { IEventProvider } from '@fluidframework/core-interfaces';
-import { IExperimentalIncrementalSummaryContext } from '@fluidframework/runtime-definitions';
-import { IFluidHandle } from '@fluidframework/core-interfaces';
-import { IFluidHandleContext } from '@fluidframework/core-interfaces';
-import { IFluidLoadable } from '@fluidframework/core-interfaces';
-import { IGarbageCollectionData } from '@fluidframework/runtime-definitions';
-import { IIdCompressor } from '@fluidframework/id-compressor';
-import { IInboundSignalMessage } from '@fluidframework/runtime-definitions';
-import { ILoaderOptions } from '@fluidframework/container-definitions';
-import { IQuorumClients } from '@fluidframework/protocol-definitions';
-import { ISequencedDocumentMessage } from '@fluidframework/protocol-definitions';
-import { ISummaryTreeWithStats } from '@fluidframework/runtime-definitions';
-import { ITelemetryContext } from '@fluidframework/runtime-definitions';
-import { ITelemetryLogger } from '@fluidframework/core-interfaces';
+import type { AttachState } from '@fluidframework/container-definitions';
+import type { FluidObject } from '@fluidframework/core-interfaces';
+import type { IAudience } from '@fluidframework/container-definitions';
+import type { IDeltaManager } from '@fluidframework/container-definitions';
+import type { IDisposable } from '@fluidframework/core-interfaces';
+import type { IDocumentMessage } from '@fluidframework/protocol-definitions';
+import type { IEvent } from '@fluidframework/core-interfaces';
+import type { IEventProvider } from '@fluidframework/core-interfaces';
+import type { IExperimentalIncrementalSummaryContext } from '@fluidframework/runtime-definitions';
+import type { IFluidHandle } from '@fluidframework/core-interfaces';
+import type { IFluidHandleContext } from '@fluidframework/core-interfaces';
+import type { IFluidLoadable } from '@fluidframework/core-interfaces';
+import type { IGarbageCollectionData } from '@fluidframework/runtime-definitions';
+import type { IIdCompressor } from '@fluidframework/id-compressor';
+import type { IInboundSignalMessage } from '@fluidframework/runtime-definitions';
+import type { IQuorumClients } from '@fluidframework/protocol-definitions';
+import type { ISequencedDocumentMessage } from '@fluidframework/protocol-definitions';
+import type { ISummaryTreeWithStats } from '@fluidframework/runtime-definitions';
+import type { ITelemetryBaseLogger } from '@fluidframework/core-interfaces';
+import type { ITelemetryContext } from '@fluidframework/runtime-definitions';
 
 /**
  * @public
@@ -153,9 +152,16 @@ export declare interface IChannelAttributes {
  *
  * If a collaboration includes a {@link https://fluidframework.com/docs/data-structures/map/ | SharedMap},
  * the collaborating clients will need to have access to a factory that can produce the `SharedMap` object.
+ *
+ * @privateRemarks
+ * TChannel extends IFluidLoadable instead of TChannel since doing so enables LoadableObjectClass to be covariant over its input parameter.
+ * This means that code like fluid-static's `InitialObjects` can be simple and type safe and LoadableObjectClass<any> is not needed.
+ * This approach (not requiring TChannel to extend IChannel) also makes it possible for SharedObject's public interfaces to not include IChannel if desired
+ * (while still requiring the implementation to implement it).
+ *
  * @public
  */
-export declare interface IChannelFactory {
+export declare interface IChannelFactory<out TChannel extends IFluidLoadable = IFluidLoadable> {
     /**
      * String representing the type of the factory.
      */
@@ -179,7 +185,7 @@ export declare interface IChannelFactory {
      * for the given object? The latter seems good in general. But both are probably good things. We then just
      * need a way to allow the document to provide later storage for the object.
      */
-    load(runtime: IFluidDataStoreRuntime, id: string, services: IChannelServices, channelAttributes: Readonly<IChannelAttributes>): Promise<IChannel>;
+    load(runtime: IFluidDataStoreRuntime, id: string, services: IChannelServices, channelAttributes: Readonly<IChannelAttributes>): Promise<TChannel & IChannel>;
     /**
      * Creates a local version of the channel.
      * Calling attach on the object later will insert it into the object stream.
@@ -191,7 +197,7 @@ export declare interface IChannelFactory {
      * NOTE here - When we attach we need to submit all the pending ops prior to actually doing the attach
      * for consistency.
      */
-    create(runtime: IFluidDataStoreRuntime, id: string): IChannel;
+    create(runtime: IFluidDataStoreRuntime, id: string): TChannel & IChannel;
 }
 
 /**
@@ -285,14 +291,21 @@ export declare interface IDeltaHandler {
      */
     reSubmit(message: any, localOpMetadata: unknown): void;
     /**
-     * Apply changes from an op. Used when rehydrating an attached container
+     * Apply changes from an op just as if a local client has made the change,
+     * including submitting the op. Used when rehydrating an attached container
      * with pending changes. This prepares the SharedObject for seeing an ACK
      * for the op or resubmitting the op upon reconnection.
-     * @param message - Contents of a stashed op.
-     * @returns localMetadata of the op, to be passed to process() or resubmit()
-     * when the op is ACKed or resubmitted, respectively
+     * @param content - Contents of a stashed op.
+     * @returns Should return void.
+     *
+     * @privateRemarks
+     * This interface is undergoing changes. Right now it support both the old
+     * flow, where just local metadata is returned, and a more ergonomic flow
+     * where operations are applied just like local edits, including
+     * submission of the op if attached. Soon the old flow will be removed
+     * and only the new flow will be supported.
      */
-    applyStashedOp(message: any): unknown;
+    applyStashedOp(message: any): void;
     /**
      * Revert a local op.
      * @param message - The original message that was submitted.
@@ -311,11 +324,11 @@ export declare interface IFluidDataStoreRuntime extends IEventProvider<IFluidDat
     readonly rootRoutingContext: IFluidHandleContext;
     readonly channelsRoutingContext: IFluidHandleContext;
     readonly objectsRoutingContext: IFluidHandleContext;
-    readonly options: ILoaderOptions;
+    readonly options: Record<string | number, any>;
     readonly deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>;
     readonly clientId: string | undefined;
     readonly connected: boolean;
-    readonly logger: ITelemetryLogger;
+    readonly logger: ITelemetryBaseLogger;
     /**
      * Indicates the attachment state of the data store to a host service.
      */

package/dist/datastore-definitions-untrimmed.d.ts

@@ -5,27 +5,26 @@
  * @packageDocumentation
  */
 
-import { AttachState } from '@fluidframework/container-definitions';
-import { FluidObject } from '@fluidframework/core-interfaces';
-import { IAudience } from '@fluidframework/container-definitions';
-import { IDeltaManager } from '@fluidframework/container-definitions';
-import { IDisposable } from '@fluidframework/core-interfaces';
-import { IDocumentMessage } from '@fluidframework/protocol-definitions';
-import { IEvent } from '@fluidframework/core-interfaces';
-import { IEventProvider } from '@fluidframework/core-interfaces';
-import { IExperimentalIncrementalSummaryContext } from '@fluidframework/runtime-definitions';
-import { IFluidHandle } from '@fluidframework/core-interfaces';
-import { IFluidHandleContext } from '@fluidframework/core-interfaces';
-import { IFluidLoadable } from '@fluidframework/core-interfaces';
-import { IGarbageCollectionData } from '@fluidframework/runtime-definitions';
-import { IIdCompressor } from '@fluidframework/id-compressor';
-import { IInboundSignalMessage } from '@fluidframework/runtime-definitions';
-import { ILoaderOptions } from '@fluidframework/container-definitions';
-import { IQuorumClients } from '@fluidframework/protocol-definitions';
-import { ISequencedDocumentMessage } from '@fluidframework/protocol-definitions';
-import { ISummaryTreeWithStats } from '@fluidframework/runtime-definitions';
-import { ITelemetryContext } from '@fluidframework/runtime-definitions';
-import { ITelemetryLogger } from '@fluidframework/core-interfaces';
+import type { AttachState } from '@fluidframework/container-definitions';
+import type { FluidObject } from '@fluidframework/core-interfaces';
+import type { IAudience } from '@fluidframework/container-definitions';
+import type { IDeltaManager } from '@fluidframework/container-definitions';
+import type { IDisposable } from '@fluidframework/core-interfaces';
+import type { IDocumentMessage } from '@fluidframework/protocol-definitions';
+import type { IEvent } from '@fluidframework/core-interfaces';
+import type { IEventProvider } from '@fluidframework/core-interfaces';
+import type { IExperimentalIncrementalSummaryContext } from '@fluidframework/runtime-definitions';
+import type { IFluidHandle } from '@fluidframework/core-interfaces';
+import type { IFluidHandleContext } from '@fluidframework/core-interfaces';
+import type { IFluidLoadable } from '@fluidframework/core-interfaces';
+import type { IGarbageCollectionData } from '@fluidframework/runtime-definitions';
+import type { IIdCompressor } from '@fluidframework/id-compressor';
+import type { IInboundSignalMessage } from '@fluidframework/runtime-definitions';
+import type { IQuorumClients } from '@fluidframework/protocol-definitions';
+import type { ISequencedDocumentMessage } from '@fluidframework/protocol-definitions';
+import type { ISummaryTreeWithStats } from '@fluidframework/runtime-definitions';
+import type { ITelemetryBaseLogger } from '@fluidframework/core-interfaces';
+import type { ITelemetryContext } from '@fluidframework/runtime-definitions';
 
 /**
  * @public
@@ -153,9 +152,16 @@ export declare interface IChannelAttributes {
  *
  * If a collaboration includes a {@link https://fluidframework.com/docs/data-structures/map/ | SharedMap},
  * the collaborating clients will need to have access to a factory that can produce the `SharedMap` object.
+ *
+ * @privateRemarks
+ * TChannel extends IFluidLoadable instead of TChannel since doing so enables LoadableObjectClass to be covariant over its input parameter.
+ * This means that code like fluid-static's `InitialObjects` can be simple and type safe and LoadableObjectClass<any> is not needed.
+ * This approach (not requiring TChannel to extend IChannel) also makes it possible for SharedObject's public interfaces to not include IChannel if desired
+ * (while still requiring the implementation to implement it).
+ *
  * @public
  */
-export declare interface IChannelFactory {
+export declare interface IChannelFactory<out TChannel extends IFluidLoadable = IFluidLoadable> {
     /**
      * String representing the type of the factory.
      */
@@ -179,7 +185,7 @@ export declare interface IChannelFactory {
      * for the given object? The latter seems good in general. But both are probably good things. We then just
      * need a way to allow the document to provide later storage for the object.
      */
-    load(runtime: IFluidDataStoreRuntime, id: string, services: IChannelServices, channelAttributes: Readonly<IChannelAttributes>): Promise<IChannel>;
+    load(runtime: IFluidDataStoreRuntime, id: string, services: IChannelServices, channelAttributes: Readonly<IChannelAttributes>): Promise<TChannel & IChannel>;
     /**
      * Creates a local version of the channel.
      * Calling attach on the object later will insert it into the object stream.
@@ -191,7 +197,7 @@ export declare interface IChannelFactory {
      * NOTE here - When we attach we need to submit all the pending ops prior to actually doing the attach
      * for consistency.
      */
-    create(runtime: IFluidDataStoreRuntime, id: string): IChannel;
+    create(runtime: IFluidDataStoreRuntime, id: string): TChannel & IChannel;
 }
 
 /**
@@ -285,14 +291,21 @@ export declare interface IDeltaHandler {
      */
     reSubmit(message: any, localOpMetadata: unknown): void;
     /**
-     * Apply changes from an op. Used when rehydrating an attached container
+     * Apply changes from an op just as if a local client has made the change,
+     * including submitting the op. Used when rehydrating an attached container
      * with pending changes. This prepares the SharedObject for seeing an ACK
      * for the op or resubmitting the op upon reconnection.
-     * @param message - Contents of a stashed op.
-     * @returns localMetadata of the op, to be passed to process() or resubmit()
-     * when the op is ACKed or resubmitted, respectively
+     * @param content - Contents of a stashed op.
+     * @returns Should return void.
+     *
+     * @privateRemarks
+     * This interface is undergoing changes. Right now it support both the old
+     * flow, where just local metadata is returned, and a more ergonomic flow
+     * where operations are applied just like local edits, including
+     * submission of the op if attached. Soon the old flow will be removed
+     * and only the new flow will be supported.
      */
-    applyStashedOp(message: any): unknown;
+    applyStashedOp(message: any): void;
     /**
      * Revert a local op.
      * @param message - The original message that was submitted.
@@ -311,11 +324,11 @@ export declare interface IFluidDataStoreRuntime extends IEventProvider<IFluidDat
     readonly rootRoutingContext: IFluidHandleContext;
     readonly channelsRoutingContext: IFluidHandleContext;
     readonly objectsRoutingContext: IFluidHandleContext;
-    readonly options: ILoaderOptions;
+    readonly options: Record<string | number, any>;
     readonly deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>;
     readonly clientId: string | undefined;
     readonly connected: boolean;
-    readonly logger: ITelemetryLogger;
+    readonly logger: ITelemetryBaseLogger;
     /**
      * Indicates the attachment state of the data store to a host service.
      */

package/dist/index.d.ts

@@ -8,9 +8,9 @@
  *
  * @packageDocumentation
  */
-export { IChannel, IChannelFactory, IChannelServices, IChannelStorageService, IDeltaConnection, IDeltaHandler, } from "./channel";
-export { IFluidDataStoreRuntime, IFluidDataStoreRuntimeEvents } from "./dataStoreRuntime";
-export type { Jsonable, JsonableTypeWith, Internal_InterfaceOfJsonableTypesWith } from "./jsonable";
-export { Serializable } from "./serializable";
-export { IChannelAttributes } from "./storage";
+export type { IChannel, IChannelFactory, IChannelServices, IChannelStorageService, IDeltaConnection, IDeltaHandler, } from "./channel.js";
+export type { IFluidDataStoreRuntime, IFluidDataStoreRuntimeEvents } from "./dataStoreRuntime.js";
+export type { Jsonable, JsonableTypeWith, Internal_InterfaceOfJsonableTypesWith, } from "./jsonable.js";
+export type { Serializable } from "./serializable.js";
+export type { IChannelAttributes } from "./storage.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;GAKG;AAEH,OAAO,EACN,QAAQ,EACR,eAAe,EACf,gBAAgB,EAChB,sBAAsB,EACtB,gBAAgB,EAChB,aAAa,GACb,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,sBAAsB,EAAE,4BAA4B,EAAE,MAAM,oBAAoB,CAAC;AAC1F,YAAY,EAAE,QAAQ,EAAE,gBAAgB,EAAE,qCAAqC,EAAE,MAAM,YAAY,CAAC;AACpG,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;GAKG;AAEH,YAAY,EACX,QAAQ,EACR,eAAe,EACf,gBAAgB,EAChB,sBAAsB,EACtB,gBAAgB,EAChB,aAAa,GACb,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,sBAAsB,EAAE,4BAA4B,EAAE,MAAM,uBAAuB,CAAC;AAClG,YAAY,EACX,QAAQ,EACR,gBAAgB,EAChB,qCAAqC,GACrC,MAAM,eAAe,CAAC;AACvB,YAAY,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,YAAY,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC"}

package/dist/package.json

@@ -0,0 +1,3 @@
+{
+	"type": "commonjs"
+}

package/dist/serializable.d.ts

@@ -2,8 +2,8 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { IFluidHandle } from "@fluidframework/core-interfaces";
-import { Jsonable } from "./jsonable";
+import type { IFluidHandle } from "@fluidframework/core-interfaces";
+import type { Jsonable } from "./jsonable.js";
 /**
  * Used to constrain a type 'T' to types that Fluid can intrinsically serialize.  Produces a
  * compile-time error if `T` contains non-serializable members.

package/dist/serializable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"serializable.d.ts","sourceRoot":"","sources":["../src/serializable.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAC/D,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,QAAQ,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC"}
+{"version":3,"file":"serializable.d.ts","sourceRoot":"","sources":["../src/serializable.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AACpE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE9C;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,QAAQ,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC"}

package/dist/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.38.3"
+      "packageVersion": "7.42.3"
     }
   ]
 }

package/lib/channel.d.ts

@@ -0,0 +1,272 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import type { IFluidHandle, IFluidLoadable } from "@fluidframework/core-interfaces";
+import type { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
+import type { IGarbageCollectionData, IExperimentalIncrementalSummaryContext, ISummaryTreeWithStats, ITelemetryContext } from "@fluidframework/runtime-definitions";
+import type { IChannelAttributes } from "./storage.js";
+import type { IFluidDataStoreRuntime } from "./dataStoreRuntime.js";
+/**
+ * @public
+ */
+export interface IChannel extends IFluidLoadable {
+    /**
+     * A readonly identifier for the channel
+     */
+    readonly id: string;
+    readonly attributes: IChannelAttributes;
+    /**
+     * Generates summary of the channel synchronously. It is called when an `attach message`
+     * for a local channel is generated. In other words, when the channel is being attached
+     * to make it visible to other clients.
+     *
+     * @remarks
+     *
+     * Note: Since the Attach Summary is generated for local channels when making them visible to
+     * remote clients, they don't have any previous summaries to compare against. For this reason,
+     * the attach summary cannot contain summary handles (paths to sub-trees or blobs).
+     * It can, however, contain {@link @fluidframework/protocol-definitions#ISummaryAttachment}
+     * (handles to blobs uploaded async via the blob manager).
+     *
+     * @param fullTree - A flag indicating whether the attempt should generate a full
+     * summary tree without any handles for unchanged subtrees.
+     *
+     * Default: `false`
+     *
+     * @param trackState - An optimization for tracking state of objects across summaries. If the state
+     * of an object did not change since last successful summary, an
+     * {@link @fluidframework/protocol-definitions#ISummaryHandle} can be used
+     * instead of re-summarizing it. If this is `false`, the expectation is that you should never
+     * send an `ISummaryHandle`, since you are not expected to track state.
+     *
+     * Note: The goal is to remove the trackState and automatically decided whether the
+     * handles will be used or not: {@link https://github.com/microsoft/FluidFramework/issues/10455}
+     *
+     * Default: `false`
+     *
+     * @param telemetryContext - See {@link @fluidframework/runtime-definitions#ITelemetryContext}.
+     *
+     * @returns A summary capturing the current state of the channel.
+     */
+    getAttachSummary(fullTree?: boolean, trackState?: boolean, telemetryContext?: ITelemetryContext): ISummaryTreeWithStats;
+    /**
+     * Generates summary of the channel asynchronously.
+     * This should not be called where the channel can be modified while summarization is in progress.
+     *
+     * @param fullTree - flag indicating whether the attempt should generate a full
+     * summary tree without any handles for unchanged subtrees. It should only be set to true when generating
+     * a summary from the entire container.
+     *
+     * Default: `false`
+     *
+     * @param trackState - An optimization for tracking state of objects across summaries. If the state
+     * of an object did not change since last successful summary, an
+     * {@link @fluidframework/protocol-definitions#ISummaryHandle} can be used
+     * instead of re-summarizing it. If this is `false`, the expectation is that you should never
+     * send an `ISummaryHandle`, since you are not expected to track state.
+     *
+     * Default: `false`
+     *
+     * Note: The goal is to remove the trackState and automatically decided whether the
+     * handles will be used or not: {@link https://github.com/microsoft/FluidFramework/issues/10455}
+     *
+     * @param telemetryContext - See {@link @fluidframework/runtime-definitions#ITelemetryContext}.
+     *
+     * @returns A summary capturing the current state of the channel.
+     */
+    summarize(fullTree?: boolean, trackState?: boolean, telemetryContext?: ITelemetryContext, incrementalSummaryContext?: IExperimentalIncrementalSummaryContext): Promise<ISummaryTreeWithStats>;
+    /**
+     * Checks if the channel is attached to storage.
+     * @returns True iff the channel is attached.
+     */
+    isAttached(): boolean;
+    /**
+     * Enables the channel to send and receive ops.
+     * @param services - The services to connect to.
+     */
+    connect(services: IChannelServices): void;
+    /**
+     * Returns the GC data for this channel. It contains a list of GC nodes that contains references to
+     * other GC nodes.
+     * @param fullGC - true to bypass optimizations and force full generation of GC data.
+     */
+    getGCData(fullGC?: boolean): IGarbageCollectionData;
+}
+/**
+ * Handler provided by shared data structure to process requests from the runtime.
+ * @public
+ */
+export interface IDeltaHandler {
+    /**
+     * Processes the op.
+     * @param message - The message to process
+     * @param local - Whether the message originated from the local client
+     * @param localOpMetadata - For local client messages, this is the metadata that was submitted with the message.
+     * For messages from a remote client, this will be undefined.
+     */
+    process: (message: ISequencedDocumentMessage, local: boolean, localOpMetadata: unknown) => void;
+    /**
+     * State change events to indicate changes to the delta connection
+     * @param connected - true if connected, false otherwise
+     */
+    setConnectionState(connected: boolean): void;
+    /**
+     * Called when the runtime asks the client to resubmit an op. This may be because the Container reconnected and
+     * this op was not acked.
+     * The client can choose to resubmit the same message, submit different / multiple messages or not submit anything
+     * at all.
+     * @param message - The original message that was submitted.
+     * @param localOpMetadata - The local metadata associated with the original message.
+     */
+    reSubmit(message: any, localOpMetadata: unknown): void;
+    /**
+     * Apply changes from an op just as if a local client has made the change,
+     * including submitting the op. Used when rehydrating an attached container
+     * with pending changes. This prepares the SharedObject for seeing an ACK
+     * for the op or resubmitting the op upon reconnection.
+     * @param content - Contents of a stashed op.
+     * @returns Should return void.
+     *
+     * @privateRemarks
+     * This interface is undergoing changes. Right now it support both the old
+     * flow, where just local metadata is returned, and a more ergonomic flow
+     * where operations are applied just like local edits, including
+     * submission of the op if attached. Soon the old flow will be removed
+     * and only the new flow will be supported.
+     */
+    applyStashedOp(message: any): void;
+    /**
+     * Revert a local op.
+     * @param message - The original message that was submitted.
+     * @param localOpMetadata - The local metadata associated with the original message.
+     */
+    rollback?(message: any, localOpMetadata: unknown): void;
+}
+/**
+ * Interface to represent a connection to a delta notification stream.
+ * @public
+ */
+export interface IDeltaConnection {
+    connected: boolean;
+    /**
+     * Send new messages to the server.
+     * @param messageContent - The content of the message to be sent.
+     * @param localOpMetadata - The local metadata associated with the message. This is kept locally by the runtime
+     * and not sent to the server. It will be provided back when this message is acknowledged by the server. It will
+     * also be provided back when asked to resubmit the message.
+     */
+    submit(messageContent: any, localOpMetadata: unknown): void;
+    /**
+     * Attaches a message handler to the delta connection
+     */
+    attach(handler: IDeltaHandler): void;
+    /**
+     * Indicates that the channel is dirty and needs to be part of the summary. It is called by a SharedSummaryBlock
+     * that needs to be part of the summary but does not generate ops.
+     */
+    dirty(): void;
+    /**
+     * @deprecated There is no replacement for this, its functionality is no longer needed at this layer.
+     * It will be removed in a future release, sometime after 2.0.0-internal.8.0.0
+     *
+     * Called when a new outbound reference is added to another node. This is used by garbage collection to identify
+     * all references added in the system.
+     * @param srcHandle - The handle of the node that added the reference.
+     * @param outboundHandle - The handle of the outbound node that is referenced.
+     */
+    addedGCOutboundReference?(srcHandle: IFluidHandle, outboundHandle: IFluidHandle): void;
+}
+/**
+ * Storage services to read the objects at a given path.
+ * @public
+ */
+export interface IChannelStorageService {
+    /**
+     * Reads the object contained at the given path. Returns a buffer representation for the object.
+     */
+    readBlob(path: string): Promise<ArrayBufferLike>;
+    /**
+     * Determines if there is an object contained at the given path.
+     */
+    contains(path: string): Promise<boolean>;
+    /**
+     * Lists the blobs that exist at a specific path.
+     */
+    list(path: string): Promise<string[]>;
+}
+/**
+ * Storage services to read the objects at a given path using the given delta connection.
+ * @public
+ */
+export interface IChannelServices {
+    deltaConnection: IDeltaConnection;
+    objectStorage: IChannelStorageService;
+}
+/**
+ * Definitions of a channel factory.
+ *
+ * @remarks
+ *
+ * The runtime must be able to produce "channels" of the correct in-memory object type for the collaborative session.
+ * Here "channels" are typically distributed data structures (DDSs).
+ *
+ * The runtime will consult with a registry of such factories during
+ * {@link https://fluidframework.com/docs/build/containers/ | Container} load and when receiving "attach" operations
+ * (ops), which indicate a new instance of a channel being introduced to the collaboration session, to produce the
+ * appropriate in-memory object.
+ *
+ * Factories follow a common model but enable custom behavior.
+ *
+ * @example
+ *
+ * If a collaboration includes a {@link https://fluidframework.com/docs/data-structures/map/ | SharedMap},
+ * the collaborating clients will need to have access to a factory that can produce the `SharedMap` object.
+ *
+ * @privateRemarks
+ * TChannel extends IFluidLoadable instead of TChannel since doing so enables LoadableObjectClass to be covariant over its input parameter.
+ * This means that code like fluid-static's `InitialObjects` can be simple and type safe and LoadableObjectClass<any> is not needed.
+ * This approach (not requiring TChannel to extend IChannel) also makes it possible for SharedObject's public interfaces to not include IChannel if desired
+ * (while still requiring the implementation to implement it).
+ *
+ * @public
+ */
+export interface IChannelFactory<out TChannel extends IFluidLoadable = IFluidLoadable> {
+    /**
+     * String representing the type of the factory.
+     */
+    readonly type: string;
+    /**
+     * Attributes of the channel.
+     */
+    readonly attributes: IChannelAttributes;
+    /**
+     * Loads the given channel. This call is only ever invoked internally as the only thing
+     * that is ever directly loaded is the document itself. Load will then only be called on documents that
+     * were created and added to a channel.
+     * @param runtime - Data store runtime containing state/info/helper methods about the data store.
+     * @param id - ID of the channel.
+     * @param services - Services to read objects at a given path using the delta connection.
+     * @param channelAttributes - The attributes for the the channel to be loaded.
+     * @returns The loaded object
+     *
+     * @privateRemarks
+     * Thought: should the storage object include the version information and limit access to just files
+     * for the given object? The latter seems good in general. But both are probably good things. We then just
+     * need a way to allow the document to provide later storage for the object.
+     */
+    load(runtime: IFluidDataStoreRuntime, id: string, services: IChannelServices, channelAttributes: Readonly<IChannelAttributes>): Promise<TChannel & IChannel>;
+    /**
+     * Creates a local version of the channel.
+     * Calling attach on the object later will insert it into the object stream.
+     * @param runtime - The runtime the new object will be associated with
+     * @param id - The unique ID of the new object
+     * @returns The newly created object.
+     *
+     * @privateRemarks
+     * NOTE here - When we attach we need to submit all the pending ops prior to actually doing the attach
+     * for consistency.
+     */
+    create(runtime: IFluidDataStoreRuntime, id: string): TChannel & IChannel;
+}
+//# sourceMappingURL=channel.d.ts.map

package/lib/channel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel.d.ts","sourceRoot":"","sources":["../src/channel.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACpF,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,sCAAsC,CAAC;AACtF,OAAO,KAAK,EACX,sBAAsB,EACtB,sCAAsC,EACtC,qBAAqB,EACrB,iBAAiB,EACjB,MAAM,qCAAqC,CAAC;AAC7C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AACvD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAEpE;;GAEG;AACH,MAAM,WAAW,QAAS,SAAQ,cAAc;IAC/C;;OAEG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAEpB,QAAQ,CAAC,UAAU,EAAE,kBAAkB,CAAC;IAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACH,gBAAgB,CACf,QAAQ,CAAC,EAAE,OAAO,EAClB,UAAU,CAAC,EAAE,OAAO,EACpB,gBAAgB,CAAC,EAAE,iBAAiB,GAClC,qBAAqB,CAAC;IAEzB;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,SAAS,CACR,QAAQ,CAAC,EAAE,OAAO,EAClB,UAAU,CAAC,EAAE,OAAO,EACpB,gBAAgB,CAAC,EAAE,iBAAiB,EACpC,yBAAyB,CAAC,EAAE,sCAAsC,GAChE,OAAO,CAAC,qBAAqB,CAAC,CAAC;IAElC;;;OAGG;IACH,UAAU,IAAI,OAAO,CAAC;IAEtB;;;OAGG;IACH,OAAO,CAAC,QAAQ,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAE1C;;;;OAIG;IACH,SAAS,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,sBAAsB,CAAC;CACpD;AAED;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC7B;;;;;;OAMG;IACH,OAAO,EAAE,CAAC,OAAO,EAAE,yBAAyB,EAAE,KAAK,EAAE,OAAO,EAAE,eAAe,EAAE,OAAO,KAAK,IAAI,CAAC;IAEhG;;;OAGG;IACH,kBAAkB,CAAC,SAAS,EAAE,OAAO,GAAG,IAAI,CAAC;IAE7C;;;;;;;OAOG;IACH,QAAQ,CAAC,OAAO,EAAE,GAAG,EAAE,eAAe,EAAE,OAAO,GAAG,IAAI,CAAC;IAEvD;;;;;;;;;;;;;;OAcG;IACH,cAAc,CAAC,OAAO,EAAE,GAAG,GAAG,IAAI,CAAC;IAEnC;;;;OAIG;IACH,QAAQ,CAAC,CAAC,OAAO,EAAE,GAAG,EAAE,eAAe,EAAE,OAAO,GAAG,IAAI,CAAC;CACxD;AAED;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAChC,SAAS,EAAE,OAAO,CAAC;IAEnB;;;;;;OAMG;IACH,MAAM,CAAC,cAAc,EAAE,GAAG,EAAE,eAAe,EAAE,OAAO,GAAG,IAAI,CAAC;IAE5D;;OAEG;IACH,MAAM,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,CAAC;IAErC;;;OAGG;IACH,KAAK,IAAI,IAAI,CAAC;IAEd;;;;;;;;OAQG;IACH,wBAAwB,CAAC,CAAC,SAAS,EAAE,YAAY,EAAE,cAAc,EAAE,YAAY,GAAG,IAAI,CAAC;CACvF;AAED;;;GAGG;AACH,MAAM,WAAW,sBAAsB;IACtC;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;IAEjD;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAEzC;;OAEG;IACH,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;CACtC;AAED;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAChC,eAAe,EAAE,gBAAgB,CAAC;IAElC,aAAa,EAAE,sBAAsB,CAAC;CACtC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,WAAW,eAAe,CAAC,GAAG,CAAC,QAAQ,SAAS,cAAc,GAAG,cAAc;IACpF;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,QAAQ,CAAC,UAAU,EAAE,kBAAkB,CAAC;IAExC;;;;;;;;;;;;;;OAcG;IACH,IAAI,CACH,OAAO,EAAE,sBAAsB,EAC/B,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,gBAAgB,EAC1B,iBAAiB,EAAE,QAAQ,CAAC,kBAAkB,CAAC,GAC7C,OAAO,CAAC,QAAQ,GAAG,QAAQ,CAAC,CAAC;IAEhC;;;;;;;;;;OAUG;IACH,MAAM,CAAC,OAAO,EAAE,sBAAsB,EAAE,EAAE,EAAE,MAAM,GAAG,QAAQ,GAAG,QAAQ,CAAC;CACzE"}