@fluidframework/datastore-definitions 2.0.0-internal.7.0.0 → 2.0.0-internal.7.1.0

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # @fluidframework/datastore-definitions
 
+## 2.0.0-internal.7.1.0
+
+Dependency updates only.
+
 ## 2.0.0-internal.7.0.0
 
 ### Major Changes

package/api-extractor.json

@@ -1,4 +1,12 @@
 {
 	"$schema": "https://developer.microsoft.com/json-schemas/api-extractor/v7/api-extractor.schema.json",
-	"extends": "@fluidframework/build-common/api-extractor-common-report.json"
+	"extends": "@fluidframework/build-common/api-extractor-base.json",
+	"messages": {
+		"extractorMessageReporting": {
+			"ae-missing-release-tag": {
+				// TODO: Fix violations and remove this rule override
+				"logLevel": "none"
+			}
+		}
+	}
 }

package/api-report/datastore-definitions.api.md

@@ -0,0 +1,155 @@
+## API Report File for "@fluidframework/datastore-definitions"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+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 { IFluidRouter } from '@fluidframework/core-interfaces';
+import { IGarbageCollectionData } from '@fluidframework/runtime-definitions';
+import { IIdCompressor } from '@fluidframework/runtime-definitions';
+import { IInboundSignalMessage } from '@fluidframework/runtime-definitions';
+import { ILoaderOptions } from '@fluidframework/container-definitions';
+import { IProvideFluidDataStoreRegistry } from '@fluidframework/runtime-definitions';
+import { IQuorumClients } from '@fluidframework/protocol-definitions';
+import { IRequest } from '@fluidframework/core-interfaces';
+import { IResponse } from '@fluidframework/core-interfaces';
+import { ISequencedDocumentMessage } from '@fluidframework/protocol-definitions';
+import { ISummaryTreeWithStats } from '@fluidframework/runtime-definitions';
+import { ITelemetryContext } from '@fluidframework/runtime-definitions';
+import { ITelemetryLogger } from '@fluidframework/core-interfaces';
+
+// @public (undocumented)
+export interface IChannel extends IFluidLoadable {
+    // (undocumented)
+    readonly attributes: IChannelAttributes;
+    connect(services: IChannelServices): void;
+    getAttachSummary(fullTree?: boolean, trackState?: boolean, telemetryContext?: ITelemetryContext): ISummaryTreeWithStats;
+    getGCData(fullGC?: boolean): IGarbageCollectionData;
+    readonly id: string;
+    isAttached(): boolean;
+    summarize(fullTree?: boolean, trackState?: boolean, telemetryContext?: ITelemetryContext, incrementalSummaryContext?: IExperimentalIncrementalSummaryContext): Promise<ISummaryTreeWithStats>;
+}
+
+// @public
+export interface IChannelAttributes {
+    readonly packageVersion?: string;
+    readonly snapshotFormatVersion: string;
+    readonly type: string;
+}
+
+// @public
+export interface IChannelFactory {
+    readonly attributes: IChannelAttributes;
+    create(runtime: IFluidDataStoreRuntime, id: string): IChannel;
+    load(runtime: IFluidDataStoreRuntime, id: string, services: IChannelServices, channelAttributes: Readonly<IChannelAttributes>): Promise<IChannel>;
+    readonly type: string;
+}
+
+// @public
+export interface IChannelServices {
+    // (undocumented)
+    deltaConnection: IDeltaConnection;
+    // (undocumented)
+    objectStorage: IChannelStorageService;
+}
+
+// @public
+export interface IChannelStorageService {
+    contains(path: string): Promise<boolean>;
+    list(path: string): Promise<string[]>;
+    readBlob(path: string): Promise<ArrayBufferLike>;
+}
+
+// @public
+export interface IDeltaConnection {
+    addedGCOutboundReference?(srcHandle: IFluidHandle, outboundHandle: IFluidHandle): void;
+    attach(handler: IDeltaHandler): void;
+    // (undocumented)
+    connected: boolean;
+    dirty(): void;
+    submit(messageContent: any, localOpMetadata: unknown): void;
+}
+
+// @public
+export interface IDeltaHandler {
+    applyStashedOp(message: any): unknown;
+    process: (message: ISequencedDocumentMessage, local: boolean, localOpMetadata: unknown) => void;
+    reSubmit(message: any, localOpMetadata: unknown): void;
+    rollback?(message: any, localOpMetadata: unknown): void;
+    setConnectionState(connected: boolean): void;
+}
+
+// @public
+export interface IFluidDataStoreRuntime extends IEventProvider<IFluidDataStoreRuntimeEvents>, IDisposable, Partial<IProvideFluidDataStoreRegistry> {
+    readonly attachState: AttachState;
+    bindChannel(channel: IChannel): void;
+    // (undocumented)
+    readonly channelsRoutingContext: IFluidHandleContext;
+    // (undocumented)
+    readonly clientId: string | undefined;
+    // (undocumented)
+    readonly connected: boolean;
+    createChannel(id: string | undefined, type: string): IChannel;
+    // (undocumented)
+    readonly deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>;
+    ensureNoDataModelChanges<T>(callback: () => T): T;
+    readonly entryPoint: IFluidHandle<FluidObject>;
+    getAudience(): IAudience;
+    getChannel(id: string): Promise<IChannel>;
+    getQuorum(): IQuorumClients;
+    // (undocumented)
+    readonly id: string;
+    // (undocumented)
+    readonly idCompressor?: IIdCompressor;
+    // (undocumented)
+    readonly IFluidHandleContext: IFluidHandleContext;
+    // @deprecated (undocumented)
+    readonly IFluidRouter: IFluidRouter;
+    // (undocumented)
+    readonly logger: ITelemetryLogger;
+    // (undocumented)
+    readonly objectsRoutingContext: IFluidHandleContext;
+    // (undocumented)
+    readonly options: ILoaderOptions;
+    // @deprecated (undocumented)
+    request(request: IRequest): Promise<IResponse>;
+    // (undocumented)
+    readonly rootRoutingContext: IFluidHandleContext;
+    submitSignal(type: string, content: any): void;
+    uploadBlob(blob: ArrayBufferLike, signal?: AbortSignal): Promise<IFluidHandle<ArrayBufferLike>>;
+    waitAttached(): Promise<void>;
+}
+
+// @public (undocumented)
+export interface IFluidDataStoreRuntimeEvents extends IEvent {
+    // (undocumented)
+    (event: "disconnected" | "dispose" | "attaching" | "attached", listener: () => void): any;
+    // (undocumented)
+    (event: "op", listener: (message: ISequencedDocumentMessage) => void): any;
+    // (undocumented)
+    (event: "signal", listener: (message: IInboundSignalMessage, local: boolean) => void): any;
+    // (undocumented)
+    (event: "connected", listener: (clientId: string) => void): any;
+}
+
+// @public
+export type Jsonable<T = any, TReplaced = void> = T extends undefined | null | boolean | number | string | TReplaced ? T : Extract<T, Function> extends never ? {
+    [K in keyof T]: Extract<K, symbol> extends never ? Jsonable<T[K], TReplaced> : never;
+} : never;
+
+// @public
+export type Serializable<T = any> = Jsonable<T, IFluidHandle>;
+
+```

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

@@ -0,0 +1,445 @@
+/**
+ * This library defines the interfaces required to implement and/or communicate
+ * with a data store.
+ *
+ * @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 { IFluidRouter } from '@fluidframework/core-interfaces';
+import { IGarbageCollectionData } from '@fluidframework/runtime-definitions';
+import { IIdCompressor } from '@fluidframework/runtime-definitions';
+import { IInboundSignalMessage } from '@fluidframework/runtime-definitions';
+import { ILoaderOptions } from '@fluidframework/container-definitions';
+import { IProvideFluidDataStoreRegistry } from '@fluidframework/runtime-definitions';
+import { IQuorumClients } from '@fluidframework/protocol-definitions';
+import { IRequest } from '@fluidframework/core-interfaces';
+import { IResponse } from '@fluidframework/core-interfaces';
+import { ISequencedDocumentMessage } from '@fluidframework/protocol-definitions';
+import { ISummaryTreeWithStats } from '@fluidframework/runtime-definitions';
+import { ITelemetryContext } from '@fluidframework/runtime-definitions';
+import { ITelemetryLogger } from '@fluidframework/core-interfaces';
+
+export declare 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;
+}
+
+/**
+ * Represents the attributes of a channel/DDS.
+ */
+export declare interface IChannelAttributes {
+    /**
+     * Type name of the DDS for factory look up with ISharedObjectRegistry
+     */
+    readonly type: string;
+    /**
+     * Format version of the snapshot
+     * Currently, only use to display a debug message if the version is incompatible
+     */
+    readonly snapshotFormatVersion: string;
+    /**
+     * The package version of the code of the DDS, for debug only
+     */
+    readonly packageVersion?: string;
+}
+
+/**
+ * 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.
+ */
+export declare interface IChannelFactory {
+    /**
+     * 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<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): IChannel;
+}
+
+/**
+ * Storage services to read the objects at a given path using the given delta connection.
+ */
+export declare interface IChannelServices {
+    deltaConnection: IDeltaConnection;
+    objectStorage: IChannelStorageService;
+}
+
+/**
+ * Storage services to read the objects at a given path.
+ */
+export declare 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[]>;
+}
+
+/**
+ * Interface to represent a connection to a delta notification stream.
+ */
+export declare 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;
+    /**
+     * 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;
+}
+
+/**
+ * Handler provided by shared data structure to process requests from the runtime.
+ */
+export declare 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. 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
+     */
+    applyStashedOp(message: any): unknown;
+    /**
+     * 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;
+}
+
+/**
+ * Represents the runtime for the data store. Contains helper functions/state of the data store.
+ */
+export declare interface IFluidDataStoreRuntime extends IEventProvider<IFluidDataStoreRuntimeEvents>, IDisposable, Partial<IProvideFluidDataStoreRegistry> {
+    readonly id: string;
+    readonly IFluidHandleContext: IFluidHandleContext;
+    readonly rootRoutingContext: IFluidHandleContext;
+    readonly channelsRoutingContext: IFluidHandleContext;
+    readonly objectsRoutingContext: IFluidHandleContext;
+    readonly options: ILoaderOptions;
+    readonly deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>;
+    readonly clientId: string | undefined;
+    readonly connected: boolean;
+    readonly logger: ITelemetryLogger;
+    /**
+     * Indicates the attachment state of the data store to a host service.
+     */
+    readonly attachState: AttachState;
+    readonly idCompressor?: IIdCompressor;
+    /**
+     * Returns the channel with the given id
+     */
+    getChannel(id: string): Promise<IChannel>;
+    /**
+     * Invokes the given callback and expects that no ops are submitted
+     * until execution finishes. If an op is submitted, an error will be raised.
+     *
+     * Can be disabled by feature gate `Fluid.ContainerRuntime.DisableOpReentryCheck`
+     *
+     * @param callback - the callback to be invoked
+     */
+    ensureNoDataModelChanges<T>(callback: () => T): T;
+    /**
+     * Creates a new channel of the given type.
+     * @param id - ID of the channel to be created.  A unique ID will be generated if left undefined.
+     * @param type - Type of the channel.
+     */
+    createChannel(id: string | undefined, type: string): IChannel;
+    /**
+     * Bind the channel with the data store runtime. If the runtime
+     * is attached then we attach the channel to make it live.
+     */
+    bindChannel(channel: IChannel): void;
+    /**
+     * Api to upload a blob of data.
+     * @param blob - blob to be uploaded.
+     */
+    uploadBlob(blob: ArrayBufferLike, signal?: AbortSignal): Promise<IFluidHandle<ArrayBufferLike>>;
+    /**
+     * Submits the signal to be sent to other clients.
+     * @param type - Type of the signal.
+     * @param content - Content of the signal.
+     */
+    submitSignal(type: string, content: any): void;
+    /**
+     * Returns the current quorum.
+     */
+    getQuorum(): IQuorumClients;
+    /**
+     * Returns the current audience.
+     */
+    getAudience(): IAudience;
+    /**
+     * Resolves when a local data store is attached.
+     */
+    waitAttached(): Promise<void>;
+    /**
+     * Exposes a handle to the root object / entryPoint of the data store. Use this as the primary way of interacting
+     * with it.
+     */
+    readonly entryPoint: IFluidHandle<FluidObject>;
+    /**
+     * @deprecated - Will be removed in future major release. Migrate all usage of IFluidRouter to the "entryPoint" pattern. Refer to Removing-IFluidRouter.md
+     */
+    request(request: IRequest): Promise<IResponse>;
+    /**
+     * @deprecated - Will be removed in future major release. Migrate all usage of IFluidRouter to the "entryPoint" pattern. Refer to Removing-IFluidRouter.md
+     */
+    readonly IFluidRouter: IFluidRouter;
+}
+
+export declare interface IFluidDataStoreRuntimeEvents extends IEvent {
+    (event: "disconnected" | "dispose" | "attaching" | "attached", listener: () => void): any;
+    (event: "op", listener: (message: ISequencedDocumentMessage) => void): any;
+    (event: "signal", listener: (message: IInboundSignalMessage, local: boolean) => void): any;
+    (event: "connected", listener: (clientId: string) => void): any;
+}
+
+/**
+ * Used to constrain a type `T` to types that are serializable as JSON.
+ * Produces a compile-time error if `T` contains non-Jsonable members.
+ *
+ * @remarks
+ * Note that this does NOT prevent using of values with non-json compatible data,
+ * it only prevents using values with types that include non-json compatible data.
+ * This means that one can, for example, pass an a value typed with json compatible
+ * interface into this function,
+ * that could actually be a class with lots on non-json compatible fields and methods.
+ *
+ * Important: `T extends Jsonable<T>` is incorrect (does not even compile).
+ * `T extends Jsonable` is also incorrect since `Jsonable` is just `any` and thus applies no constraint at all.
+ *
+ * The optional 'TReplaced' parameter may be used to permit additional leaf types to support
+ * situations where a `replacer` is used to handle special values (e.g., `Jsonable<{ x: IFluidHandle }, IFluidHandle>`).
+ *
+ * Note that `Jsonable<T>` does not protect against the following pitfalls when serializing with JSON.stringify():
+ *
+ * - `undefined` properties on objects are omitted (i.e., properties become undefined instead of equal to undefined).
+ *
+ * - When `undefined` appears as the root object or as an array element it is coerced to `null`.
+ *
+ * - Non-finite numbers (`NaN`, `+/-Infinity`) are also coerced to `null`.
+ *
+ * - prototypes and non-enumerable properties are lost.
+ *
+ * Also, `Jsonable<T>` does not prevent the construction of circular references.
+ *
+ * Using `Jsonable` (with no type parameters) or `Jsonable<any>` is just a type alias for `any`
+ * and should not be used if type safety is desired.
+ *
+ * @example Typical usage
+ *
+ * ```typescript
+ * function foo<T>(value: Jsonable<T>) { ... }
+ * ```
+ */
+export declare type Jsonable<T = any, TReplaced = void> = T extends undefined | null | boolean | number | string | TReplaced ? T : Extract<T, Function> extends never ? {
+    [K in keyof T]: Extract<K, symbol> extends never ? Jsonable<T[K], TReplaced> : never;
+} : never;
+
+/**
+ * Used to constrain a type 'T' to types that Fluid can intrinsically serialize.  Produces a
+ * compile-time error if `T` contains non-serializable members.
+ *
+ * @remarks
+ * See Jsonable for caveats regarding serialization of `undefined`, non-finite numbers,
+ * and circular references.
+ *
+ * Important: `T extends Serializable<T>` is generally incorrect.
+ * (Any value of `T` extends the serializable subset of itself.)
+ *
+ * @example Typical usage
+ *
+ * ```typescript
+ * function serialize<T>(value: Serializable<T>) { ... }
+ * ```
+ */
+export declare type Serializable<T = any> = Jsonable<T, IFluidHandle>;
+
+export { }