Packages > fluid-framework

fluid-framework Package

Bundles a collection of Fluid Framework client libraries for easy use when paired with a corresponding service client package (e.g. @fluidframework/azure-client, @fluidframework/tinylicious-client, or @fluid-experimental/osdp-client (BETA)).

Interfaces

Interface Alerts Modifiers Description
CommitMetadata sealed Information about a commit that has been applied.
ContainerSchema Declares the Fluid objects that will be available in the Container.
FieldProps Additional information to provide to a FieldSchema.
FieldSchemaUnsafe Unenforced version of FieldSchema.
IBranchOrigin Legacy Branch origin information.
IConnection Base interface for information for each connection made to the Fluid session.
IDirectory Legacy Interface describing actions on a directory.
IDirectoryEvents Legacy Events emitted in response to changes to the directory data.
IDirectoryValueChanged Legacy Type of "valueChanged" event parameter for ISharedDirectory.
IDisposable sealed Base interface for objects that require lifetime management via explicit disposal.
IErrorBase Base interface for all errors and warnings emitted the container.
IErrorEvent Base interface for error event emitters.
IEvent Base interface for event emitters.
IEventProvider sealed Base interface for event providers.
IFluidContainer sealed Provides an entrypoint into the client side of collaborative Fluid data. Provides access to the data as well as status on the collaboration session.
IFluidContainerEvents sealed Events emitted from IFluidContainer.
IFluidHandle sealed Handle to a shared FluidObject.
IFluidHandleErased sealed A type erased Fluid Handle. These can only be produced by the Fluid Framework and provide the implementation details needed to power IFluidHandle.
IFluidLoadable sealed A shared FluidObject has a URL from which it can be referenced
IInterval Legacy Basic interval abstraction
IIntervalCollection Legacy Collection of intervals that supports addition, modification, removal, and efficient spatial querying. Changes to this collection will be incur updates on collaborating clients (i.e. they are not local-only).
IIntervalCollectionEvent Legacy Change events emitted by IntervalCollections
IMember Base interface to be implemented to fetch each service's member.
InteriorSequencePlace Legacy

A sequence place that does not refer to the special endpoint segments.

See SequencePlace for additional context.

InternalTreeNode sealed A node type internal to @fluidframework/tree.
IntervalIndex Legacy

Collection of intervals.

Implementers of this interface will typically implement additional APIs to support efficiently querying a collection of intervals in some manner, for example: - "find all intervals with start endpoint between these two points" - "find all intervals which overlap this range" etc.

IProvideFluidLoadable
ISequencedDocumentMessage Legacy Sequenced message for a distributed document.
ISequenceDeltaRange Legacy A range that has changed corresponding to a segment modification.
ISerializableInterval Legacy
ISerializedInterval Legacy Serialized object representation of an interval. This representation is used for ops that create or change intervals.
IServiceAudience Base interface to be implemented to fetch each service's audience.
IServiceAudienceEvents Events that trigger when the roster of members in the Fluid session change.
ISharedDirectory Legacy Provides a hierarchical organization of map-like data structures as SubDirectories. The values stored within can be accessed like a map, and the hierarchy can be navigated using path syntax. SubDirectories can be retrieved for use as working directories.
ISharedDirectoryEvents Legacy Events emitted in response to changes to the directory data.
ISharedIntervalCollection Legacy
ISharedMap Legacy sealed The SharedMap distributed data structure can be used to store key-value pairs.
ISharedMapEvents Legacy sealed Events emitted in response to changes to the map data.
ISharedObject Legacy Base interface for shared objects from which other interfaces derive. Implemented by SharedObject
ISharedObjectEvents Legacy Events emitted by ISharedObject.
ISharedSegmentSequence Legacy
ISharedSegmentSequenceEvents Legacy Events emitted in response to changes to the sequence data.
ISharedString Legacy Fluid object interface describing access methods on a SharedString
ITelemetryBaseProperties JSON-serializable properties, which will be logged with telemetry.
ITrace Legacy Messages to track latency trace.
ITree sealed Channel for a Fluid Tree DDS.
ITreeConfigurationOptions Options when constructing a tree view.
ITreeViewConfiguration Property-bag configuration for TreeViewConfiguration construction.
IValueChanged Legacy sealed Type of "valueChanged" event parameter.
Listenable sealed An object which allows the registration of listeners so that subscribers can be notified when an event happens.
MakeNominal sealed Use this as the type of a protected field to cause a type to use nominal typing instead of structural.
NodeInDocumentConstraint A transaction constraint which requires that the given node exists in the tree.
Revertible sealed Allows reversion of a change made to SharedTree.
RunTransaction sealed A function which runs a transaction in a SharedTree.
SchemaCompatibilityStatus sealed

Information about a view schema's compatibility with the document's stored schema.

See SharedTree's README for more information about choosing a compatibility policy.

SharedObjectKind sealed Defines a kind of shared object.
Tagged

A property to be logged to telemetry may require a tag indicating the value may contain sensitive data. This type wraps a value of the given type V in an object along with a string tag (type can be further specified as T).

This indicates that the value should be organized or handled differently by loggers in various first or third party scenarios. For example, tags are used to mark data that should not be stored in logs for privacy reasons.

TreeArrayNode sealed A TreeNode which implements 'readonly T[]' and the array mutation APIs.
TreeArrayNodeUnsafe sealed Unenforced version of TreeArrayNode.
TreeChangeEvents sealed A collection of events that can be emitted by a TreeNode.
TreeMapNode sealed A map of string keys to tree objects.
TreeMapNodeUnsafe sealed Unenforced version of TreeMapNode.
TreeNodeApi sealed Provides various functions for analyzing TreeNodes. *
TreeNodeSchemaClass sealed Tree node schema which is implemented using a class.
TreeNodeSchemaCore sealed Data common to all tree node schema.
TreeView sealed

An editable view of a (version control style) branch of a shared tree based on some schema.

This schema--known as the view schema--may or may not align the stored schema of the document. Information about discrepancies between the two schemas is available via compatibility.

Application authors are encouraged to read [schema-evolution.md](../../docs/user-facing/schema-evolution.md) and choose a schema compatibility policy that aligns with their application's needs.

TreeViewEvents sealed Events for TreeView.
WithType sealed Adds a type symbol to a type for stronger typing.

Classes

Class Alerts Modifiers Description
ErasedType sealed Erased type which can be used to expose a opaque/erased version of a type without referencing the actual type.
FieldSchema sealed

All policy for a specific field, including functionality that does not have to be kept consistent across versions or deterministic.

This can include policy for how to use this schema for "view" purposes, and well as how to expose editing APIs. Use SchemaFactory to create the FieldSchema instances, for example optional(t, props).

IterableTreeArrayContent sealed Used to insert iterable content into a TreeArrayNode. Use (TreeArrayNode:variable).spread to create an instance of this type.
SchemaFactory sealed Creates various types of schema for TreeNodes.
SequenceDeltaEvent Legacy

The event object returned on sequenceDelta events.

The properties of this object and its sub-objects represent the state of the sequence at the point in time at which the operation was applied. They will not take into consideration any future modifications performed to the underlying sequence and merge tree.

For group ops, each op will get its own event, and the group op property will be set on the op args.

Ops may get multiple events. For instance, an insert-replace will get a remove then an insert event.

SequenceEvent Legacy

Base class for SequenceDeltaEvent and SequenceMaintenanceEvent.

The properties of this object and its sub-objects represent the state of the sequence at the point in time at which the operation was applied. They will not take into any future modifications performed to the underlying sequence and merge tree.

SequenceInterval Legacy Interval implementation whose ends are associated with positions in a mutatable sequence. As such, when content is inserted into the middle of the interval, the interval expands to include that content.
SequenceMaintenanceEvent Legacy

The event object returned on maintenance events.

The properties of this object and its sub-objects represent the state of the sequence at the point in time at which the operation was applied. They will not take into consideration any future modifications performed to the underlying sequence and merge tree.

TreeNode sealed A non-leaf SharedTree node. Includes objects, arrays, and maps.
TreeViewConfiguration sealed Configuration for viewWith(config).

Enumerations

Enum Alerts Description
AttachState The attachment state of some Fluid data (e.g. a container or data store), denoting whether it is uploaded to the service. The transition from detached to attached state is a one-way transition.
CommitKind The type of a commit. This is used to describe the context in which the commit was created.
ConnectionState The state of the Container's connection to the service.
FieldKind Kind of a field on a node.
IntervalType Legacy
NodeKind Kind of tree node.
RevertibleStatus The status of a Revertible.
Side Legacy Defines a side relative to a character in a sequence.
TreeStatus Status of the tree that a particular node belongs to.

Types

TypeAlias Alerts Modifiers Description
AllowedTypes Types for use in fields.
ConnectionStateType Type defining the different states of connectivity a Container can be in.
ContainerAttachProps Represents properties that can be attached to a container.
DeserializeCallback Legacy
FluidObject

This utility type take interface(s) that follow the FluidObject pattern, and produces a new type that can be used for inspection and discovery of those interfaces.

It is meant to be used with types that are known to implement the FluidObject pattern. A common way to specify a type implements the FluidObject pattern is to expose it as a FluidObject without a generic argument.

FluidObjectProviderKeys Produces a valid FluidObject key given a type and a property.
ICriticalContainerError Represents errors raised on container.
IEventThisPlaceHolder The placeholder type that should be used instead of this in events.
IEventTransformer This type is a conditional type for transforming all the overloads provided in TEvent.
ImplicitAllowedTypes Types allowed in a field.
ImplicitFieldSchema Schema for a field of a tree node.
InitialObjects Extract the type of 'initialObjects' from the given ContainerSchema type.
InsertableObjectFromSchemaRecordUnsafe Unenforced version of InsertableObjectFromSchemaRecord.
InsertableTreeFieldFromImplicitField Type of content that can be inserted into the tree for a field of the given schema.
InsertableTreeFieldFromImplicitFieldUnsafe Unenforced version of InsertableTreeFieldFromImplicitField.
InsertableTreeNodeFromImplicitAllowedTypes Type of content that can be inserted into the tree for a node of the given schema.
InsertableTreeNodeFromImplicitAllowedTypesUnsafe Unenforced version of InsertableTreeNodeFromImplicitAllowedTypes.
InsertableTypedNode Data which can be used as a node to be inserted. Either an unhydrated node, or content to build a new node.
IntervalStickiness Legacy

Determines how an interval should expand when segments are inserted adjacent to the range it spans

Note that interval stickiness is currently an experimental feature and must be explicitly enabled with the intervalStickinessEnabled flag

IsListener true iff the given type is an acceptable shape for a event listener
LazyItem An "eager" or "lazy" Item in a FlexList. Lazy items are wrapped in a function to allow referring to themselves before they are declared. This makes recursive and co-recursive items possible.
Listeners Used to specify the kinds of events emitted by a Listenable.
MemberChangedListener Signature for IMember change events.
Myself An extended member object that includes currentConnection
NodeFromSchema Takes in TreeNodeSchema[] and returns a TypedNode union.
Off A function that, when called, will deregister an event listener subscription that was previously registered.
ReplaceIEventThisPlaceHolder Does the type replacement by changing types of IEventThisPlaceHolder to TThis
RestrictiveReadonlyRecord Alternative to the built in Record type which does not permit unexpected members, and is readonly.
RevertibleFactory sealed Factory for creating a Revertible. Will error if invoked outside the scope of the commitApplied event that provides it, or if invoked multiple times.
SequencePlace Legacy

Defines a position and side relative to a character in a sequence.

For this purpose, sequences look like:

{start} - {character 0} - {character 1} - ... - {character N} - {end}

Each {value} in the diagram is a character within a sequence. Each - in the above diagram is a position where text could be inserted. Each position between a {value} and a - is a SequencePlace.

The special endpoints {start} and {end} refer to positions outside the contents of the string.

This gives us 2N + 2 possible positions to refer to within a string, where N is the number of characters.

If the position is specified with a bare number, the side defaults to Side.Before.

If a SequencePlace is the endpoint of a range (e.g. start/end of an interval or search range), the Side value means it is exclusive if it is nearer to the other position and inclusive if it is farther. E.g. the start of a range with Side.After is exclusive of the character at the position.

SharedDirectory Legacy Entrypoint for ISharedDirectory creation.
SharedMap Legacy Entrypoint for ISharedMap creation.
SharedString Legacy Alias for ISharedString for compatibility.
SharedStringSegment Legacy
TelemetryBaseEventPropertyType Property types that can be logged.
TransactionConstraint A requirement for a SharedTree transaction to succeed.
TransformedEvent Transforms the event overload by replacing IEventThisPlaceHolder with TThis in the event listener arguments and having the overload return TTHis as well
TreeFieldFromImplicitField Converts ImplicitFieldSchema to the corresponding tree node's field type.
TreeLeafValue Value that may be stored as a leaf node.
TreeNodeFromImplicitAllowedTypes Type of tree node for a field of the given schema.
TreeNodeSchema sealed Schema for a tree node.
TreeObjectNode A TreeNode which modules a JavaScript object.
TreeObjectNodeUnsafe Unenforced version of TreeObjectNode.
Unenforced

A placeholder to use in extends constraints when using the real type breaks compilation of some recursive types due to a design limitation of TypeScript.

These extends constraints only serve as documentation: to avoid breaking compilation, this type has to not actually enforce anything, and thus is just unknown. Therefore the type safety is the responsibility of the user of the API.

Unhydrated

Type alias to document which values are un-hydrated.

Un-hydrated values are nodes produced from schema's create functions that haven't been inserted into a tree yet.

Since un-hydrated nodes become hydrated when inserted, strong typing can't be used to distinguish them. This no-op wrapper is used instead.

ValidateRecursiveSchema Compile time check for validity of a recursive schema.

Variables

Variable Alerts Modifiers Type Description
IFluidHandle readonly
IFluidLoadable readonly keyof IProvideFluidLoadable
IntervalStickiness Legacy readonly { readonly NONE: 0; readonly START: 1; readonly END: 2; readonly FULL: 3; }

Determines how an interval should expand when segments are inserted adjacent to the range it spans

Note that interval stickiness is currently an experimental feature and must be explicitly enabled with the intervalStickinessEnabled flag

rollback readonly unique symbol A special object that signifies when a SharedTree transaction should "roll back".
SharedDirectory Legacy readonly import("@fluidframework/shared-object-base/internal").ISharedObjectKind<ISharedDirectory> & import("@fluidframework/shared-object-base/internal").SharedObjectKind<ISharedDirectory> Entrypoint for ISharedDirectory creation.
SharedMap Legacy readonly import("@fluidframework/shared-object-base/internal").ISharedObjectKind<ISharedMap> & import("@fluidframework/shared-object-base/internal").SharedObjectKind<ISharedMap> Entrypoint for ISharedMap creation.
SharedString Legacy readonly import("@fluidframework/shared-object-base/internal").ISharedObjectKind<ISharedString> & import("@fluidframework/shared-object-base/internal").SharedObjectKind<ISharedString> Entrypoint for ISharedString creation.
SharedTree readonly SharedObjectKind<ITree> A hierarchical data structure for collaboratively editing strongly typed JSON-like trees of objects, arrays, and other data types.
Tree readonly TreeApi The Tree object holds various functions for interacting with TreeNodes.
TreeArrayNode readonly { readonly spread: <T>(content: Iterable<T>) => IterableTreeArrayContent<T>; } A TreeNode which implements 'readonly T[]' and the array mutation APIs.

Namespaces

Namespace Description
ConnectionStateType Namespace for the different connection states a container can be in. PLEASE NOTE: The sequence of the numerical values does no correspond to the typical connection state progression.
InternalTypes

Variable Details

IFluidHandle

Signature

IFluidHandle = "IFluidHandle"

IFluidLoadable

Signature

IFluidLoadable: keyof IProvideFluidLoadable

Type: keyof IProvideFluidLoadable

IntervalStickiness

Determines how an interval should expand when segments are inserted adjacent to the range it spans

Note that interval stickiness is currently an experimental feature and must be explicitly enabled with the intervalStickinessEnabled flag

This API is provided for existing users, but is not recommended for new users.

To use, import via fluid-framework/legacy.

For more information about our API support guarantees, see here .

Signature

IntervalStickiness: {
    readonly NONE: 0;
    readonly START: 1;
    readonly END: 2;
    readonly FULL: 3;
}

Type: { readonly NONE: 0; readonly START: 1; readonly END: 2; readonly FULL: 3; }

rollback

A special object that signifies when a SharedTree transaction should “roll back”.

Signature

rollback: unique symbol

Type: unique symbol

SharedDirectory

Entrypoint for ISharedDirectory creation.

This API is provided for existing users, but is not recommended for new users.

To use, import via fluid-framework/legacy.

For more information about our API support guarantees, see here .

Signature

SharedDirectory: import("@fluidframework/shared-object-base/internal").ISharedObjectKind<ISharedDirectory> & import("@fluidframework/shared-object-base/internal").SharedObjectKind<ISharedDirectory>

Type: import("@fluidframework/shared-object-base/internal").ISharedObjectKind<ISharedDirectory > & import("@fluidframework/shared-object-base/internal").SharedObjectKind <ISharedDirectory >

SharedMap

Entrypoint for ISharedMap creation.

This API is provided for existing users, but is not recommended for new users.

To use, import via fluid-framework/legacy.

For more information about our API support guarantees, see here .

Signature

SharedMap: import("@fluidframework/shared-object-base/internal").ISharedObjectKind<ISharedMap> & import("@fluidframework/shared-object-base/internal").SharedObjectKind<ISharedMap>

Type: import("@fluidframework/shared-object-base/internal").ISharedObjectKind<ISharedMap > & import("@fluidframework/shared-object-base/internal").SharedObjectKind <ISharedMap >

SharedString

Entrypoint for ISharedString creation.

This API is provided for existing users, but is not recommended for new users.

To use, import via fluid-framework/legacy.

For more information about our API support guarantees, see here .

Signature

SharedString: import("@fluidframework/shared-object-base/internal").ISharedObjectKind<ISharedString> & import("@fluidframework/shared-object-base/internal").SharedObjectKind<ISharedString>

Type: import("@fluidframework/shared-object-base/internal").ISharedObjectKind<ISharedString > & import("@fluidframework/shared-object-base/internal").SharedObjectKind <ISharedString >

SharedTree

A hierarchical data structure for collaboratively editing strongly typed JSON-like trees of objects, arrays, and other data types.

Signature

SharedTree: SharedObjectKind<ITree>

Type: SharedObjectKind <ITree >

Tree

The Tree object holds various functions for interacting with TreeNode s.

Signature

treeApi: TreeApi

Type: TreeApi

TreeArrayNode

A TreeNode which implements ‘readonly T[]’ and the array mutation APIs.

Signature

TreeArrayNode: {
    readonly spread: <T>(content: Iterable<T>) => IterableTreeArrayContent<T>;
}

Type: { readonly spread: <T>(content: Iterable<T>) => IterableTreeArrayContent <T>; }