@fluidframework/sequence 2.0.0-internal.7.2.2 → 2.0.0-internal.7.3.0

package/dist/sequence-untrimmed.d.ts

@@ -0,0 +1,1759 @@
+/**
+ * Supports distributed data structures which are list-like.
+ *
+ * This library's main export is {@link SharedString}, a DDS for storing and simultaneously editing a sequence of
+ * text.
+ *
+ * See the package's README for a high-level introduction to `SharedString`'s feature set.
+ * @remarks Note that SharedString is a sequence DDS but it has additional specialized features and behaviors for
+ * working with text.
+ *
+ * @packageDocumentation
+ */
+
+import { BaseSegment } from '@fluidframework/merge-tree';
+import { Client } from '@fluidframework/merge-tree';
+import { Deferred } from '@fluidframework/core-utils';
+import { IChannelAttributes } from '@fluidframework/datastore-definitions';
+import { IChannelFactory } from '@fluidframework/datastore-definitions';
+import { IChannelServices } from '@fluidframework/datastore-definitions';
+import { IChannelStorageService } from '@fluidframework/datastore-definitions';
+import { ICombiningOp } from '@fluidframework/merge-tree';
+import { IEvent } from '@fluidframework/core-interfaces';
+import { IEventThisPlaceHolder } from '@fluidframework/core-interfaces';
+import { IFluidDataStoreRuntime } from '@fluidframework/datastore-definitions';
+import { IFluidSerializer } from '@fluidframework/shared-object-base';
+import { IJSONSegment } from '@fluidframework/merge-tree';
+import { IMergeTreeDeltaCallbackArgs } from '@fluidframework/merge-tree';
+import { IMergeTreeDeltaOpArgs } from '@fluidframework/merge-tree';
+import { IMergeTreeGroupMsg } from '@fluidframework/merge-tree';
+import { IMergeTreeInsertMsg } from '@fluidframework/merge-tree';
+import { IMergeTreeMaintenanceCallbackArgs } from '@fluidframework/merge-tree';
+import { IMergeTreeOp } from '@fluidframework/merge-tree';
+import { IMergeTreeRemoveMsg } from '@fluidframework/merge-tree';
+import { IRelativePosition } from '@fluidframework/merge-tree';
+import { ISegment } from '@fluidframework/merge-tree';
+import { ISegmentAction } from '@fluidframework/merge-tree';
+import { ISequencedDocumentMessage } from '@fluidframework/protocol-definitions';
+import { ISharedObjectEvents } from '@fluidframework/shared-object-base';
+import { ISummaryTreeWithStats } from '@fluidframework/runtime-definitions';
+import { ITelemetryContext } from '@fluidframework/runtime-definitions';
+import { LocalReferencePosition } from '@fluidframework/merge-tree';
+import { Marker } from '@fluidframework/merge-tree';
+import { MergeTreeDeltaOperationType } from '@fluidframework/merge-tree';
+import { MergeTreeDeltaOperationTypes } from '@fluidframework/merge-tree';
+import { MergeTreeDeltaRevertible } from '@fluidframework/merge-tree';
+import { MergeTreeMaintenanceType } from '@fluidframework/merge-tree';
+import { MergeTreeRevertibleDriver } from '@fluidframework/merge-tree';
+import { PropertiesManager } from '@fluidframework/merge-tree';
+import { PropertySet } from '@fluidframework/merge-tree';
+import { RangeStackMap } from '@fluidframework/merge-tree';
+import { ReferencePosition } from '@fluidframework/merge-tree';
+import { ReferenceType } from '@fluidframework/merge-tree';
+import { Serializable } from '@fluidframework/datastore-definitions';
+import { SharedObject } from '@fluidframework/shared-object-base';
+import { SlidingPreference } from '@fluidframework/merge-tree';
+import { SummarySerializer } from '@fluidframework/shared-object-base';
+import { TextSegment } from '@fluidframework/merge-tree';
+import { TypedEventEmitter } from '@fluid-internal/client-utils';
+
+/**
+ * Create revertibles for adding an interval
+ * @alpha
+ */
+export declare function appendAddIntervalToRevertibles(interval: SequenceInterval, revertibles: SharedStringRevertible[]): SharedStringRevertible[];
+
+/**
+ * Create revertibles for moving endpoints of an interval
+ * @alpha
+ */
+export declare function appendChangeIntervalToRevertibles(string: SharedString, newInterval: SequenceInterval, previousInterval: SequenceInterval, revertibles: SharedStringRevertible[]): SharedStringRevertible[];
+
+/**
+ * Create revertibles for deleting an interval
+ * @alpha
+ */
+export declare function appendDeleteIntervalToRevertibles(string: SharedString, interval: SequenceInterval, revertibles: SharedStringRevertible[]): SharedStringRevertible[];
+
+/**
+ * Create revertibles for changing properties of an interval
+ * @alpha
+ */
+export declare function appendIntervalPropertyChangedToRevertibles(interval: SequenceInterval, deltas: PropertySet, revertibles: SharedStringRevertible[]): SharedStringRevertible[];
+
+/**
+ * Create revertibles for SharedStringDeltas, handling indirectly modified intervals
+ * (e.g. reverting remove of a range that contains an interval will move the interval back)
+ *
+ * @alpha
+ */
+export declare function appendSharedStringDeltaToRevertibles(string: SharedString, delta: SequenceDeltaEvent, revertibles: SharedStringRevertible[]): void;
+
+/**
+ * @public
+ */
+export declare function createEndpointIndex(sharedString: SharedString): IEndpointIndex<SequenceInterval>;
+
+/**
+ * @public
+ */
+export declare function createEndpointInRangeIndex(sharedString: SharedString): IEndpointInRangeIndex<SequenceInterval>;
+
+/**
+ * @public
+ */
+export declare function createIdIntervalIndex<TInterval extends ISerializableInterval>(): IIdIntervalIndex<TInterval>;
+
+/**
+ * @public
+ */
+export declare function createOverlappingIntervalsIndex(sharedString: SharedString): IOverlappingIntervalsIndex<SequenceInterval>;
+
+/**
+ * @public
+ */
+export declare function createOverlappingSequenceIntervalsIndex(sharedString: SharedString): SequenceIntervalIndexes.Overlapping;
+
+/**
+ * @public
+ */
+export declare function createStartpointInRangeIndex(sharedString: SharedString): IStartpointInRangeIndex<SequenceInterval>;
+
+/**
+ * @public
+ */
+export declare type DeserializeCallback = (properties: PropertySet) => void;
+
+/**
+ * Clean up resources held by revertibles that are no longer needed.
+ * @alpha
+ */
+export declare function discardSharedStringRevertibles(sharedString: SharedString, revertibles: SharedStringRevertible[]): void;
+
+/**
+ * Splits the text into regions ending with markers with the given `label`.
+ * @param sharedString - String to retrieve text and markers from
+ * @param label - label to split on
+ * @returns Two parallel lists of text and markers, split by markers with the provided `label`.
+ * For example:
+ * ```typescript
+ * // Say sharedstring has contents "hello<paragraph marker 1>world<paragraph marker 2>missing".
+ * const { parallelText, parallelMarkers } = getTextAndMarkers(sharedString, "paragraph");
+ * // parallelText === ["hello", "world"]
+ * // parallelMarkers === [<paragraph marker 1 object>, <paragraph marker 2 object>]
+ * // Note parallelText does not include "missing".
+ * ```
+ * @public
+ */
+export declare function getTextAndMarkers(sharedString: SharedString, label: string, start?: number, end?: number): {
+    parallelText: string[];
+    parallelMarkers: Marker[];
+};
+
+/**
+ * @public
+ */
+export declare interface IEndpointIndex<TInterval extends ISerializableInterval> extends IntervalIndex<TInterval> {
+    /**
+     * @returns the previous interval based on the given position number.
+     * If no such interval exists in this index, returns `undefined`
+     */
+    previousInterval(pos: number): TInterval | undefined;
+    /**
+     * @returns the next interval based on the given position number.
+     * If no such interval exists in this index, returns `undefined`
+     */
+    nextInterval(pos: number): TInterval | undefined;
+}
+
+/**
+ * Collection of intervals.
+ *
+ * Provide additional APIs to support efficiently querying a collection of intervals whose endpoints fall within a specified range.
+ * @public
+ */
+export declare interface IEndpointInRangeIndex<TInterval extends ISerializableInterval> extends IntervalIndex<TInterval> {
+    /**
+     * @returns an array of all intervals contained in this collection whose endpoints locate in the range [start, end] (includes both ends)
+     */
+    findIntervalsWithEndpointInRange(start: number, end: number): TInterval[];
+}
+
+/**
+ * @public
+ */
+export declare interface IIdIntervalIndex<TInterval extends ISerializableInterval> extends IntervalIndex<TInterval>, Iterable<TInterval> {
+    getIntervalById(id: string): TInterval | undefined;
+    [Symbol.iterator](): Iterator<TInterval>;
+}
+
+/**
+ * Basic interval abstraction
+ * @public
+ */
+export declare interface IInterval {
+    /**
+     * @returns a new interval object with identical semantics.
+     */
+    clone(): IInterval;
+    /**
+     * Compares this interval to `b` with standard comparator semantics:
+     * - returns -1 if this is less than `b`
+     * - returns 1 if this is greater than `b`
+     * - returns 0 if this is equivalent to `b`
+     * @param b - Interval to compare against
+     */
+    compare(b: IInterval): number;
+    /**
+     * Compares the start endpoint of this interval to `b`'s start endpoint.
+     * Standard comparator semantics apply.
+     * @param b - Interval to compare against
+     */
+    compareStart(b: IInterval): number;
+    /**
+     * Compares the end endpoint of this interval to `b`'s end endpoint.
+     * Standard comparator semantics apply.
+     * @param b - Interval to compare against
+     */
+    compareEnd(b: IInterval): number;
+    /**
+     * Modifies one or more of the endpoints of this interval, returning a new interval representing the result.
+     * @internal
+     */
+    modify(label: string, start: SequencePlace | undefined, end: SequencePlace | undefined, op?: ISequencedDocumentMessage, localSeq?: number, useNewSlidingBehavior?: boolean): IInterval | undefined;
+    /**
+     * @returns whether this interval overlaps with `b`.
+     * Intervals are considered to overlap if their intersection is non-empty.
+     */
+    overlaps(b: IInterval): boolean;
+    /**
+     * Unions this interval with `b`, returning a new interval.
+     * The union operates as a convex hull, i.e. if the two intervals are disjoint, the return value includes
+     * intermediate values between the two intervals.
+     * @internal
+     */
+    union(b: IInterval): IInterval;
+}
+
+/**
+ * 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).
+ * @public
+ */
+export declare interface IIntervalCollection<TInterval extends ISerializableInterval> extends TypedEventEmitter<IIntervalCollectionEvent<TInterval>> {
+    readonly attached: boolean;
+    /**
+     * Attaches an index to this collection.
+     * All intervals which are part of this collection will be added to the index, and the index will automatically
+     * be updated when this collection updates due to local or remote changes.
+     *
+     * @remarks After attaching an index to an interval collection, applications should typically store this
+     * index somewhere in their in-memory data model for future reference and querying.
+     */
+    attachIndex(index: IntervalIndex<TInterval>): void;
+    /**
+     * Detaches an index from this collection.
+     * All intervals which are part of this collection will be removed from the index, and updates to this collection
+     * due to local or remote changes will no longer incur updates to the index.
+     *
+     * @returns `false` if the target index cannot be found in the indexes, otherwise remove all intervals in the index and return `true`.
+     */
+    detachIndex(index: IntervalIndex<TInterval>): boolean;
+    /**
+     * @returns the interval in this collection that has the provided `id`.
+     * If no interval in the collection has this `id`, returns `undefined`.
+     */
+    getIntervalById(id: string): TInterval | undefined;
+    /**
+     * Creates a new interval and add it to the collection.
+     * @deprecated call IntervalCollection.add without specifying an intervalType
+     * @param start - interval start position (inclusive)
+     * @param end - interval end position (exclusive)
+     * @param intervalType - type of the interval. All intervals are SlideOnRemove. Intervals may not be Transient.
+     * @param props - properties of the interval
+     * @returns The created interval
+     * @remarks See documentation on {@link SequenceInterval} for comments on
+     * interval endpoint semantics: there are subtleties with how the current
+     * half-open behavior is represented.
+     *
+     * Note that intervals may behave unexpectedly if the entire contents
+     * of the string are deleted. In this case, it is possible for one endpoint
+     * of the interval to become detached, while the other remains on the string.
+     *
+     * By adjusting the `side` and `pos` values of the `start` and `end` parameters,
+     * it is possible to control whether the interval expands to include content
+     * inserted at its start or end.
+     *
+     *	See {@link SequencePlace} for more details on the model.
+     *
+     *	@example
+     *
+     *	Given the string "ABCD":
+     *
+     *```typescript
+     *	// Refers to "BC". If any content is inserted before B or after C, this
+     *	// interval will include that content
+     *	//
+     *	// Picture:
+     *	// \{start\} - A[- B - C -]D - \{end\}
+     *	// \{start\} - A - B - C - D - \{end\}
+     *	collection.add(\{ pos: 0, side: Side.After \}, \{ pos: 3, side: Side.Before \}, IntervalType.SlideOnRemove);
+     *	// Equivalent to specifying the same positions and Side.Before.
+     *	// Refers to "ABC". Content inserted after C will be included in the
+     *	// interval, but content inserted before A will not.
+     *	// \{start\} -[A - B - C -]D - \{end\}
+     *	// \{start\} - A - B - C - D - \{end\}
+     *	collection.add(0, 3, IntervalType.SlideOnRemove);
+     *```
+     *
+     * In the case of the first example, if text is deleted,
+     *
+     * ```typescript
+     *	// Delete the character "B"
+     *	string.removeRange(1, 2);
+     * ```
+     *
+     * The start point of the interval will slide to the position immediately
+     * before "C", and the same will be true.
+     *
+     * ```
+     * \{start\} - A[- C -]D - \{end\}
+     * ```
+     *
+     * In this case, text inserted immediately before "C" would be included in
+     * the interval.
+     *
+     * ```typescript
+     * string.insertText(1, "EFG");
+     * ```
+     *
+     * With the string now being,
+     *
+     * ```
+     * \{start\} - A[- E - F - G - C -]D - \{end\}
+     * ```
+     *
+     * @privateRemarks TODO: ADO:5205 the above comment regarding behavior in
+     * the case that the entire interval has been deleted should be resolved at
+     * the same time as this ticket
+     */
+    add(start: SequencePlace, end: SequencePlace, intervalType: IntervalType, props?: PropertySet): TInterval;
+    /**
+     * Creates a new interval and add it to the collection.
+     * @param start - interval start position (inclusive)
+     * @param end - interval end position (exclusive)
+     * @param props - properties of the interval
+     * @returns - the created interval
+     * @remarks - See documentation on {@link SequenceInterval} for comments on interval endpoint semantics: there are subtleties
+     * with how the current half-open behavior is represented.
+     */
+    add({ start, end, props, }: {
+        start: SequencePlace;
+        end: SequencePlace;
+        props?: PropertySet;
+    }): TInterval;
+    /**
+     * Removes an interval from the collection.
+     * @param id - Id of the interval to remove
+     * @returns the removed interval
+     */
+    removeIntervalById(id: string): TInterval | undefined;
+    /**
+     * Changes the properties on an existing interval.
+     * @param id - Id of the interval whose properties should be changed
+     * @param props - Property set to apply to the interval. Shallow merging is used between any existing properties
+     * and `prop`, i.e. the interval will end up with a property object equivalent to `{ ...oldProps, ...props }`.
+     */
+    changeProperties(id: string, props: PropertySet): any;
+    /**
+     * Changes the endpoints of an existing interval.
+     * @param id - Id of the interval to change
+     * @param start - New start value. To leave the endpoint unchanged, pass the current value.
+     * @param end - New end value. To leave the endpoint unchanged, pass the current value.
+     * @returns the interval that was changed, if it existed in the collection.
+     */
+    change(id: string, start: SequencePlace, end: SequencePlace): TInterval | undefined;
+    attachDeserializer(onDeserialize: DeserializeCallback): void;
+    /**
+     * @returns an iterator over all intervals in this collection.
+     */
+    [Symbol.iterator](): Iterator<TInterval>;
+    /**
+     * @returns a forward iterator over all intervals in this collection with start point equal to `startPosition`.
+     */
+    CreateForwardIteratorWithStartPosition(startPosition: number): Iterator<TInterval>;
+    /**
+     * @returns a backward iterator over all intervals in this collection with start point equal to `startPosition`.
+     */
+    CreateBackwardIteratorWithStartPosition(startPosition: number): Iterator<TInterval>;
+    /**
+     * @returns a forward iterator over all intervals in this collection with end point equal to `endPosition`.
+     */
+    CreateForwardIteratorWithEndPosition(endPosition: number): Iterator<TInterval>;
+    /**
+     * @returns a backward iterator over all intervals in this collection with end point equal to `endPosition`.
+     */
+    CreateBackwardIteratorWithEndPosition(endPosition: number): Iterator<TInterval>;
+    /**
+     * Gathers iteration results that optionally match a start/end criteria into the provided array.
+     * @param results - Array to gather the results into. In lieu of a return value, this array will be populated with
+     * intervals matching the query upon edit.
+     * @param iteratesForward - whether or not iteration should be in the forward direction
+     * @param start - If provided, only match intervals whose start point is equal to `start`.
+     * @param end - If provided, only match intervals whose end point is equal to `end`.
+     */
+    gatherIterationResults(results: TInterval[], iteratesForward: boolean, start?: number, end?: number): void;
+    /**
+     * @returns an array of all intervals in this collection that overlap with the interval
+     * `[startPosition, endPosition]`.
+     */
+    findOverlappingIntervals(startPosition: number, endPosition: number): TInterval[];
+    /**
+     * Applies a function to each interval in this collection.
+     */
+    map(fn: (interval: TInterval) => void): void;
+    previousInterval(pos: number): TInterval | undefined;
+    nextInterval(pos: number): TInterval | undefined;
+}
+
+/**
+ * Change events emitted by `IntervalCollection`s
+ * @public
+ */
+export declare interface IIntervalCollectionEvent<TInterval extends ISerializableInterval> extends IEvent {
+    /**
+     * This event is invoked whenever the endpoints of an interval may have changed.
+     * This can happen on:
+     * - local endpoint modification
+     * - ack of a remote endpoint modification
+     * - position change due to segment sliding (slides due to mergeTree segment deletion will always appear local)
+     * The `interval` argument reflects the new values.
+     * `previousInterval` contains transient `ReferencePosition`s at the same location as the interval's original
+     * endpoints. These references should be used for position information only.
+     * `local` reflects whether the change originated locally.
+     * `op` is defined if and only if the server has acked this change.
+     * `slide` is true if the change is due to sliding on removal of position
+     */
+    (event: "changeInterval", listener: (interval: TInterval, previousInterval: TInterval, local: boolean, op: ISequencedDocumentMessage | undefined, slide: boolean) => void): any;
+    /**
+     * This event is invoked whenever an interval is added or removed from the collection.
+     * `local` reflects whether the change originated locally.
+     * `op` is defined if and only if the server has acked this change.
+     */
+    (event: "addInterval" | "deleteInterval", listener: (interval: TInterval, local: boolean, op: ISequencedDocumentMessage | undefined) => void): any;
+    /**
+     * This event is invoked whenever an interval's properties have changed.
+     * `interval` reflects the state of the updated properties.
+     * `propertyDeltas` is a map-like whose keys contain all values that were changed, and whose
+     * values contain all previous values of the property set.
+     * This object can be used directly in a call to `changeProperties` to revert the property change if desired.
+     * `local` reflects whether the change originated locally.
+     * `op` is defined if and only if the server has acked this change.
+     */
+    (event: "propertyChanged", listener: (interval: TInterval, propertyDeltas: PropertySet, local: boolean, op: ISequencedDocumentMessage | undefined) => void): any;
+}
+
+/**
+ * @sealed
+ * @deprecated The methods within have substitutions
+ * @public
+ */
+export declare interface IIntervalHelpers<TInterval extends ISerializableInterval> {
+    /**
+     *
+     * @param label - label of the interval collection this interval is being added to. This parameter is
+     * irrelevant for transient intervals.
+     * @param start - numerical start position of the interval
+     * @param end - numerical end position of the interval
+     * @param client - client creating the interval
+     * @param intervalType - Type of interval to create. Default is SlideOnRemove
+     * @param op - If this create came from a remote client, op that created it. Default is undefined (i.e. local)
+     * @param fromSnapshot - If this create came from loading a snapshot. Default is false.
+     * @param startSide - The side on which the start position lays. See
+     * {@link SequencePlace} for additional context
+     * @param endSide - The side on which the end position lays. See
+     * {@link SequencePlace} for additional context
+     */
+    create(label: string, start: SequencePlace | undefined, end: SequencePlace | undefined, client: Client | undefined, intervalType: IntervalType, op?: ISequencedDocumentMessage, fromSnapshot?: boolean, useNewSlidingBehavior?: boolean): TInterval;
+}
+
+/**
+ * @deprecated IJSONRunSegment will be removed in a upcoming release. It has been moved to the fluid-experimental/sequence-deprecated package
+ * @public
+ */
+export declare interface IJSONRunSegment<T> extends IJSONSegment {
+    items: Serializable<T>[];
+}
+
+/**
+ * @internal
+ */
+export declare interface IMapMessageLocalMetadata {
+    localSeq: number;
+}
+
+/**
+ * A sequence place that does not refer to the special endpoint segments.
+ *
+ * See {@link SequencePlace} for additional context.
+ * @public
+ */
+export declare interface InteriorSequencePlace {
+    pos: number;
+    side: Side;
+}
+
+/**
+ * Serializable interval whose endpoints are plain-old numbers.
+ * @public
+ */
+export declare class Interval implements ISerializableInterval {
+    start: number;
+    end: number;
+    /**
+     * {@inheritDoc ISerializableInterval.properties}
+     */
+    properties: PropertySet;
+    /** @internal */
+    auxProps: PropertySet[] | undefined;
+    /**
+     * {@inheritDoc ISerializableInterval.propertyManager}
+     * @internal
+     */
+    propertyManager: PropertiesManager;
+    constructor(start: number, end: number, props?: PropertySet);
+    /**
+     * {@inheritDoc ISerializableInterval.getIntervalId}
+     */
+    getIntervalId(): string;
+    /**
+     * @returns an array containing any auxiliary property sets added with `addPropertySet`.
+     */
+    getAdditionalPropertySets(): PropertySet[];
+    /**
+     * Adds an auxiliary set of properties to this interval.
+     * These properties can be recovered using `getAdditionalPropertySets`
+     * @param props - set of properties to add
+     * @remarks This gets called as part of the default conflict resolver for `IIntervalCollection<Interval>`
+     * (i.e. non-sequence-based interval collections). However, the additional properties don't get serialized.
+     * This functionality seems half-baked.
+     */
+    addPropertySet(props: PropertySet): void;
+    /**
+     * {@inheritDoc ISerializableInterval.serialize}
+     * @internal
+     */
+    serialize(): ISerializedInterval;
+    /**
+     * {@inheritDoc IInterval.clone}
+     */
+    clone(): Interval;
+    /**
+     * {@inheritDoc IInterval.compare}
+     */
+    compare(b: Interval): number;
+    /**
+     * {@inheritDoc IInterval.compareStart}
+     */
+    compareStart(b: Interval): number;
+    /**
+     * {@inheritDoc IInterval.compareEnd}
+     */
+    compareEnd(b: Interval): number;
+    /**
+     * {@inheritDoc IInterval.overlaps}
+     */
+    overlaps(b: Interval): boolean;
+    /**
+     * {@inheritDoc IInterval.union}
+     * @internal
+     */
+    union(b: Interval): Interval;
+    getProperties(): PropertySet;
+    /**
+     * {@inheritDoc ISerializableInterval.addProperties}
+     * @internal
+     */
+    addProperties(newProps: PropertySet, collaborating?: boolean, seq?: number, op?: ICombiningOp): PropertySet | undefined;
+    /**
+     * {@inheritDoc IInterval.modify}
+     * @internal
+     */
+    modify(label: string, start?: SequencePlace, end?: SequencePlace, op?: ISequencedDocumentMessage): Interval | undefined;
+    private initializeProperties;
+}
+
+/**
+ * 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.
+ * @public
+ */
+export declare interface IntervalIndex<TInterval extends ISerializableInterval> {
+    /**
+     * Adds an interval to the index.
+     * @remarks Application code should never need to invoke this method on their index for production scenarios:
+     * Fluid handles adding and removing intervals from an index in response to sequence or interval changes.
+     */
+    add(interval: TInterval): void;
+    /**
+     * Removes an interval from the index.
+     * @remarks Application code should never need to invoke this method on their index for production scenarios:
+     * Fluid handles adding and removing intervals from an index in response to sequence or interval changes.
+     */
+    remove(interval: TInterval): void;
+}
+
+/**
+ * Information that identifies an interval within a `Sequence`.
+ * @public
+ */
+export declare interface IntervalLocator {
+    /**
+     * Label for the collection the interval is a part of
+     */
+    label: string;
+    /**
+     * Interval within that collection
+     */
+    interval: SequenceInterval;
+}
+
+/**
+ * Returns an object that can be used to find the interval a given LocalReferencePosition belongs to.
+ * @returns undefined if the reference position is not the endpoint of any interval (e.g. it was created
+ * on the merge tree directly by app code), otherwise an {@link IntervalLocator} for the interval this
+ * endpoint is a part of.
+ * @public
+ */
+export declare function intervalLocatorFromEndpoint(potentialEndpoint: LocalReferencePosition): IntervalLocator | undefined;
+
+/**
+ * Values are used in persisted formats (ops) and revertibles.
+ * @alpha
+ */
+export declare const IntervalOpType: {
+    readonly ADD: "add";
+    readonly DELETE: "delete";
+    readonly CHANGE: "change";
+    readonly PROPERTY_CHANGED: "propertyChanged";
+    readonly POSITION_REMOVE: "positionRemove";
+};
+
+/**
+ * Data for undoing edits affecting Intervals.
+ *
+ * @alpha
+ */
+export declare type IntervalRevertible = {
+    event: typeof IntervalOpType.CHANGE;
+    interval: SequenceInterval;
+    start: LocalReferencePosition;
+    end: LocalReferencePosition;
+} | {
+    event: typeof IntervalOpType.ADD;
+    interval: SequenceInterval;
+} | {
+    event: typeof IntervalOpType.DELETE;
+    interval: SequenceInterval;
+    start: LocalReferencePosition;
+    end: LocalReferencePosition;
+} | {
+    event: typeof IntervalOpType.PROPERTY_CHANGED;
+    interval: SequenceInterval;
+    propertyDeltas: PropertySet;
+} | {
+    event: typeof IntervalOpType.POSITION_REMOVE;
+    intervals: {
+        intervalId: string;
+        label: string;
+        startOffset?: number;
+        endOffset?: number;
+    }[];
+    revertibleRefs: {
+        revertible: IntervalRevertible;
+        offset: number;
+        isStart: boolean;
+    }[];
+    mergeTreeRevertible: MergeTreeDeltaRevertible;
+};
+
+/**
+ * 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
+ *
+ * @internal
+ */
+export declare const IntervalStickiness: {
+    /**
+     * Interval does not expand to include adjacent segments
+     */
+    readonly NONE: 0;
+    /**
+     * Interval expands to include segments inserted adjacent to the start
+     */
+    readonly START: 1;
+    /**
+     * Interval expands to include segments inserted adjacent to the end
+     *
+     * This is the default stickiness
+     */
+    readonly END: 2;
+    /**
+     * Interval expands to include all segments inserted adjacent to it
+     */
+    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
+ *
+ * @internal
+ */
+export declare type IntervalStickiness = (typeof IntervalStickiness)[keyof typeof IntervalStickiness];
+
+/**
+ * @public
+ */
+export declare enum IntervalType {
+    Simple = 0,
+    /**
+     * @deprecated this functionality is no longer supported and will be removed
+     */
+    Nest = 1,
+    /**
+     * SlideOnRemove indicates that the ends of the interval will slide if the segment
+     * they reference is removed and acked.
+     * See `packages\dds\merge-tree\docs\REFERENCEPOSITIONS.md` for details
+     * SlideOnRemove is the default interval behavior and does not need to be specified.
+     */
+    SlideOnRemove = 2,
+    /**
+     * A temporary interval, used internally
+     * @internal
+     */
+    Transient = 4
+}
+
+/**
+ * @public
+ */
+export declare interface IOverlappingIntervalsIndex<TInterval extends ISerializableInterval> extends IntervalIndex<TInterval> {
+    /**
+     * @returns an array of all intervals contained in this collection that overlap the range
+     * `[start end]`.
+     */
+    findOverlappingIntervals(start: SequencePlace, end: SequencePlace): TInterval[];
+    /**
+     * Gathers the interval results based on specified parameters.
+     */
+    gatherIterationResults(results: TInterval[], iteratesForward: boolean, start?: SequencePlace, end?: SequencePlace): void;
+}
+
+/**
+ * A range that has changed corresponding to a segment modification.
+ * @public
+ */
+export declare interface ISequenceDeltaRange<TOperation extends MergeTreeDeltaOperationTypes = MergeTreeDeltaOperationTypes> {
+    /**
+     * The type of operation that changed this range.
+     *
+     * @remarks Consuming code should typically compare this to the enum values defined in
+     * `MergeTreeDeltaOperationTypes`.
+     */
+    operation: TOperation;
+    /**
+     * The index of the start of the range.
+     */
+    position: number;
+    /**
+     * The segment that corresponds to the range.
+     */
+    segment: ISegment;
+    /**
+     * Deltas object which contains all modified properties with their previous values.
+     * Since `undefined` doesn't survive a round-trip through JSON serialization, the old value being absent
+     * is instead encoded with `null`.
+     *
+     * @remarks This object is motivated by undo/redo scenarios, and provides a convenient "inverse op" to apply to
+     * undo a property change.
+     *
+     * @example
+     *
+     * If a segment initially had properties `{ foo: "1", bar: 2 }` and it was annotated with
+     * `{ foo: 3, baz: 5 }`, the corresponding event would have a `propertyDeltas` of `{ foo: "1", baz: null }`.
+     */
+    propertyDeltas: PropertySet;
+}
+
+/**
+ * @public
+ */
+export declare interface ISerializableInterval extends IInterval {
+    /** Serializable bag of properties associated with the interval. */
+    properties: PropertySet;
+    /** @internal */
+    propertyManager: PropertiesManager;
+    /** @internal */
+    serialize(): ISerializedInterval;
+    /** @internal */
+    addProperties(props: PropertySet, collaborating?: boolean, seq?: number): PropertySet | undefined;
+    /**
+     * Gets the id associated with this interval.
+     * When the interval is used as part of an interval collection, this id can be used to modify or remove the
+     * interval.
+     * @remarks This signature includes `undefined` strictly for backwards-compatibility reasons, as older versions
+     * of Fluid didn't always write interval ids.
+     */
+    getIntervalId(): string | undefined;
+}
+
+/**
+ * Serialized object representation of an interval.
+ * This representation is used for ops that create or change intervals.
+ * @internal
+ */
+export declare interface ISerializedInterval {
+    /**
+     * Sequence number at which `start` and `end` should be interpreted
+     *
+     * @remarks It's unclear that this is necessary to store here.
+     * This should just be the refSeq on the op that modified the interval, which should be available via other means.
+     * At the time of writing, it's not plumbed through to the reconnect/rebase code, however, which does need it.
+     */
+    sequenceNumber: number;
+    /** Start position of the interval */
+    start: number | "start" | "end";
+    /** End position of the interval */
+    end: number | "start" | "end";
+    /** Interval type to create */
+    intervalType: IntervalType;
+    /**
+     * The stickiness of this interval
+     */
+    stickiness?: IntervalStickiness;
+    startSide?: Side;
+    endSide?: Side;
+    /** Any properties the interval has */
+    properties?: PropertySet;
+}
+
+/**
+ * @public
+ */
+export declare interface ISharedIntervalCollection<TInterval extends ISerializableInterval> {
+    getIntervalCollection(label: string): IIntervalCollection<TInterval>;
+}
+
+/**
+ * Events emitted in response to changes to the sequence data.
+ *
+ * @remarks
+ *
+ * The following is the list of events emitted.
+ *
+ * ### "sequenceDelta"
+ *
+ * The sequenceDelta event is emitted when segments are inserted, annotated, or removed.
+ *
+ * #### Listener signature
+ *
+ * ```typescript
+ * (event: SequenceDeltaEvent, target: IEventThisPlaceHolder) => void
+ * ```
+ * - `event` - Various information on the segments that were modified.
+ *
+ * - `target` - The sequence itself.
+ *
+ * ### "maintenance"
+ *
+ * The maintenance event is emitted when segments are modified during merge-tree maintenance.
+ *
+ * #### Listener signature
+ *
+ * ```typescript
+ * (event: SequenceMaintenanceEvent, target: IEventThisPlaceHolder) => void
+ * ```
+ * - `event` - Various information on the segments that were modified.
+ *
+ * - `target` - The sequence itself.
+ * @public
+ */
+export declare interface ISharedSegmentSequenceEvents extends ISharedObjectEvents {
+    (event: "createIntervalCollection", listener: (label: string, local: boolean, target: IEventThisPlaceHolder) => void): any;
+    (event: "sequenceDelta", listener: (event: SequenceDeltaEvent, target: IEventThisPlaceHolder) => void): any;
+    (event: "maintenance", listener: (event: SequenceMaintenanceEvent, target: IEventThisPlaceHolder) => void): any;
+}
+
+/**
+ * Fluid object interface describing access methods on a SharedString
+ * @public
+ */
+export declare interface ISharedString extends SharedSegmentSequence<SharedStringSegment> {
+    /**
+     * Inserts the text at the position.
+     * @param pos - The position to insert the text at
+     * @param text - The text to insert
+     * @param props - The properties of the text
+     */
+    insertText(pos: number, text: string, props?: PropertySet): void;
+    /**
+     * Inserts a marker at the position.
+     * @param pos - The position to insert the marker at
+     * @param refType - The reference type of the marker
+     * @param props - The properties of the marker
+     */
+    insertMarker(pos: number, refType: ReferenceType, props?: PropertySet): IMergeTreeInsertMsg | undefined;
+    /**
+     * {@inheritDoc SharedSegmentSequence.posFromRelativePos}
+     */
+    posFromRelativePos(relativePos: IRelativePosition): number;
+}
+
+/**
+ * Collection of intervals.
+ *
+ * Provide additional APIs to support efficiently querying a collection of intervals whose startpoints fall within a specified range.
+ * @public
+ */
+export declare interface IStartpointInRangeIndex<TInterval extends ISerializableInterval> extends IntervalIndex<TInterval> {
+    /**
+     * @returns an array of all intervals contained in this collection whose startpoints locate in the range [start, end] (includes both ends)
+     */
+    findIntervalsWithStartpointInRange(start: number, end: number): TInterval[];
+}
+
+/**
+ * Value types are given an IValueOpEmitter to emit their ops through the container type that holds them.
+ * @internal
+ */
+export declare interface IValueOpEmitter {
+    /**
+     * Called by the value type to emit a value type operation through the container type holding it.
+     * @param opName - Name of the emitted operation
+     * @param previousValue - JSONable previous value as defined by the value type
+     * @param params - JSONable params for the operation as defined by the value type
+     * @param localOpMetadata - JSONable local metadata which should be submitted with the op
+     * @internal
+     */
+    emit(opName: string, previousValue: any, params: any, localOpMetadata: IMapMessageLocalMetadata): void;
+}
+
+/**
+ * Invoke revertibles to reverse prior edits
+ *
+ * @alpha
+ */
+export declare function revertSharedStringRevertibles(sharedString: SharedString, revertibles: SharedStringRevertible[]): void;
+
+/**
+ * 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.
+ * @public
+ */
+export declare class SequenceDeltaEvent extends SequenceEvent<MergeTreeDeltaOperationType> {
+    readonly opArgs: IMergeTreeDeltaOpArgs;
+    /**
+     * Whether the event was caused by a locally-made change.
+     */
+    readonly isLocal: boolean;
+    constructor(opArgs: IMergeTreeDeltaOpArgs, deltaArgs: IMergeTreeDeltaCallbackArgs, mergeTreeClient: Client);
+}
+
+/**
+ * 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.
+ * @public
+ */
+export declare abstract class SequenceEvent<TOperation extends MergeTreeDeltaOperationTypes = MergeTreeDeltaOperationTypes> {
+    readonly deltaArgs: IMergeTreeDeltaCallbackArgs<TOperation>;
+    private readonly mergeTreeClient;
+    readonly deltaOperation: TOperation;
+    private readonly sortedRanges;
+    private readonly pFirst;
+    private readonly pLast;
+    constructor(deltaArgs: IMergeTreeDeltaCallbackArgs<TOperation>, mergeTreeClient: Client);
+    /**
+     * The in-order ranges affected by this delta.
+     * These may not be continuous.
+     */
+    get ranges(): readonly Readonly<ISequenceDeltaRange<TOperation>>[];
+    /**
+     * The client id of the client that made the change which caused the delta event
+     */
+    get clientId(): string | undefined;
+    /**
+     * The first of the modified ranges.
+     */
+    get first(): Readonly<ISequenceDeltaRange<TOperation>>;
+    /**
+     * The last of the modified ranges.
+     */
+    get last(): Readonly<ISequenceDeltaRange<TOperation>>;
+}
+
+/**
+ * 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.
+ *
+ * @remarks The endpoints' positions should be treated exclusively to get
+ * reasonable behavior. E.g., an interval referring to "hello" in "hello world"
+ * should have a start position of 0 and an end position of 5.
+ *
+ * To see why, consider what happens if "llo wor" is removed from the string to make "held".
+ * The interval's startpoint remains on the "h" (it isn't altered), but the interval's endpoint
+ * slides forward to the next unremoved position, which is the "l" in "held".
+ * Users would generally expect the interval to now refer to "he" (as it is the subset of content
+ * remaining after the removal), hence the "l" should be excluded.
+ * If the interval endpoint was treated inclusively, the interval would now refer to "hel", which
+ * is undesirable.
+ *
+ * Since the endpoints of an interval are treated exclusively but cannot be greater
+ * than or equal to the length of the associated sequence, there exist special
+ * endpoint segments, "start" and "end", which represent the position immediately
+ * before or immediately after the string respectively.
+ *
+ * If a `SequenceInterval` is created on a sequence with the
+ * `mergeTreeReferencesCanSlideToEndpoint` feature flag set to true, the endpoints
+ * of the interval that are exclusive will have the ability to slide to these
+ * special endpoint segments.
+ * @public
+ */
+export declare class SequenceInterval implements ISerializableInterval {
+    private readonly client;
+    /**
+     * Start endpoint of this interval.
+     * @remarks This endpoint can be resolved into a character position using the SharedString it's a part of.
+     */
+    start: LocalReferencePosition;
+    /**
+     * End endpoint of this interval.
+     * @remarks This endpoint can be resolved into a character position using the SharedString it's a part of.
+     */
+    end: LocalReferencePosition;
+    intervalType: IntervalType;
+    readonly startSide: Side;
+    readonly endSide: Side;
+    /**
+     * {@inheritDoc ISerializableInterval.properties}
+     */
+    properties: PropertySet;
+    /**
+     * {@inheritDoc ISerializableInterval.propertyManager}
+     * @internal
+     */
+    propertyManager: PropertiesManager;
+    /**
+     * @internal
+     */
+    get stickiness(): IntervalStickiness;
+    constructor(client: Client, 
+    /**
+     * Start endpoint of this interval.
+     * @remarks This endpoint can be resolved into a character position using the SharedString it's a part of.
+     */
+    start: LocalReferencePosition, 
+    /**
+     * End endpoint of this interval.
+     * @remarks This endpoint can be resolved into a character position using the SharedString it's a part of.
+     */
+    end: LocalReferencePosition, intervalType: IntervalType, props?: PropertySet, startSide?: Side, endSide?: Side);
+    private callbacks?;
+    /**
+     * Subscribes to position change events on this interval if there are no current listeners.
+     * @internal
+     */
+    addPositionChangeListeners(beforePositionChange: () => void, afterPositionChange: () => void): void;
+    /**
+     * Removes the currently subscribed position change listeners.
+     * @internal
+     */
+    removePositionChangeListeners(): void;
+    /**
+     * {@inheritDoc ISerializableInterval.serialize}
+     * @internal
+     */
+    serialize(): ISerializedInterval;
+    /**
+     * {@inheritDoc IInterval.clone}
+     */
+    clone(): SequenceInterval;
+    /**
+     * {@inheritDoc IInterval.compare}
+     */
+    compare(b: SequenceInterval): number;
+    /**
+     * {@inheritDoc IInterval.compareStart}
+     */
+    compareStart(b: SequenceInterval): number;
+    /**
+     * {@inheritDoc IInterval.compareEnd}
+     */
+    compareEnd(b: SequenceInterval): number;
+    /**
+     * {@inheritDoc IInterval.overlaps}
+     */
+    overlaps(b: SequenceInterval): boolean;
+    /**
+     * {@inheritDoc ISerializableInterval.getIntervalId}
+     */
+    getIntervalId(): string;
+    /**
+     * {@inheritDoc IInterval.union}
+     * @internal
+     */
+    union(b: SequenceInterval): SequenceInterval;
+    /**
+     * {@inheritDoc ISerializableInterval.addProperties}
+     * @internal
+     */
+    addProperties(newProps: PropertySet, collab?: boolean, seq?: number, op?: ICombiningOp): PropertySet | undefined;
+    /**
+     * @returns whether this interval overlaps two numerical positions.
+     */
+    overlapsPos(bstart: number, bend: number): boolean;
+    /**
+     * {@inheritDoc IInterval.modify}
+     * @internal
+     */
+    modify(label: string, start: SequencePlace | undefined, end: SequencePlace | undefined, op?: ISequencedDocumentMessage, localSeq?: number, useNewSlidingBehavior?: boolean): SequenceInterval;
+    private initializeProperties;
+}
+
+/**
+ * @deprecated The methods within have substitutions
+ * @public
+ */
+export declare const sequenceIntervalHelpers: IIntervalHelpers<SequenceInterval>;
+
+/**
+ * This namespace contains specialiazations of indexes which support spatial queries
+ * specifically for `SequenceInterval`s.
+ * @public
+ */
+export declare namespace SequenceIntervalIndexes {
+    /**
+     * Collection of intervals.
+     *
+     * Provides additional APIs to support efficiently querying a collection of intervals based on segments and offset.
+     */
+    export interface Overlapping extends IOverlappingIntervalsIndex<SequenceInterval> {
+        /**
+         * Finds overlapping intervals within the specified range.
+         *
+         * @returns an array of all intervals that overlap with the specified SegOff range (includes both ends)
+         */
+        findOverlappingIntervalsBySegoff(startSegoff: {
+            segment: ISegment | undefined;
+            offset: number | undefined;
+        }, endSegoff: {
+            segment: ISegment | undefined;
+            offset: number | undefined;
+        }): Iterable<SequenceInterval>;
+    }
+}
+
+/**
+ * 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.
+ * @public
+ */
+export declare class SequenceMaintenanceEvent extends SequenceEvent<MergeTreeMaintenanceType> {
+    readonly opArgs: IMergeTreeDeltaOpArgs | undefined;
+    constructor(opArgs: IMergeTreeDeltaOpArgs | undefined, deltaArgs: IMergeTreeMaintenanceCallbackArgs, mergeTreeClient: Client);
+}
+
+/**
+ * Optional flags that configure options for sequence DDSs
+ * @public
+ */
+export declare interface SequenceOptions {
+    /**
+     * Enable the ability to use interval APIs that rely on positions before and
+     * after individual characters, referred to as "sides". See {@link SequencePlace}
+     * for additional context.
+     *
+     * This flag must be enabled to pass instances of {@link SequencePlace} to
+     * any IIntervalCollection API.
+     *
+     * Also see the feature flag `mergeTreeReferencesCanSlideToEndpoint` to allow
+     * endpoints to slide to the special endpoint segments.
+     *
+     * The default value is false.
+     */
+    intervalStickinessEnabled: boolean;
+    /**
+     * Enable the ability for interval endpoints to slide to the special endpoint
+     * segments that exist before and after the bounds of the string. This is
+     * primarily useful for workflows involving interval stickiness, and it is
+     * suggested to enable both this flag and `intervalStickinessEnabled` at the
+     * same time.
+     *
+     * The default value is false.
+     */
+    mergeTreeReferencesCanSlideToEndpoint: boolean;
+    [key: string]: boolean;
+}
+
+/**
+ * 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.
+ * @public
+ */
+export declare type SequencePlace = number | "start" | "end" | InteriorSequencePlace;
+
+/**
+ * Represents a change that should be applied to an existing interval.
+ * Changes can modify any of start/end/properties, with `undefined` signifying no change should be made.
+ * @internal
+ */
+export declare type SerializedIntervalDelta = Omit<ISerializedInterval, "start" | "end" | "properties"> & Partial<Pick<ISerializedInterval, "start" | "end" | "properties">>;
+
+/**
+ * @deprecated `SharedIntervalCollection` is not maintained and is planned to be removed.
+ * @public
+ */
+export declare class SharedIntervalCollection extends SharedObject implements ISharedIntervalCollection<Interval> {
+    /**
+     * Create a SharedIntervalCollection
+     *
+     * @param runtime - data store runtime the new shared map belongs to
+     * @param id - optional name of the shared map
+     * @returns newly create shared map (but not attached yet)
+     */
+    static create(runtime: IFluidDataStoreRuntime, id?: string): SharedIntervalCollection;
+    /**
+     * Get a factory for SharedIntervalCollection to register with the data store.
+     *
+     * @returns a factory that creates and load SharedIntervalCollection
+     */
+    static getFactory(): IChannelFactory;
+    readonly [Symbol.toStringTag]: string;
+    private readonly intervalCollections;
+    /**
+     * Constructs a new shared SharedIntervalCollection. If the object is non-local an id and service interfaces will
+     * be provided
+     */
+    constructor(id: string, runtime: IFluidDataStoreRuntime, attributes: IChannelAttributes);
+    getIntervalCollection(label: string): IIntervalCollection<Interval>;
+    protected summarizeCore(serializer: IFluidSerializer): ISummaryTreeWithStats;
+    protected reSubmitCore(content: any, localOpMetadata: unknown): void;
+    protected onDisconnect(): void;
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.loadCore}
+     */
+    protected loadCore(storage: IChannelStorageService): Promise<void>;
+    protected processCore(message: ISequencedDocumentMessage, local: boolean, localOpMetadata: unknown): void;
+    /**
+     * Creates the full path of the intervalCollection label
+     * @param label - the incoming label
+     */
+    protected getIntervalCollectionPath(label: string): string;
+    protected applyStashedOp(): void;
+}
+
+/**
+ * The factory that defines the SharedIntervalCollection.
+ * @deprecated `SharedIntervalCollection` is not maintained and is planned to be removed.
+ * @public
+ */
+export declare class SharedIntervalCollectionFactory implements IChannelFactory {
+    static readonly Type = "https://graph.microsoft.com/types/sharedIntervalCollection";
+    static readonly Attributes: IChannelAttributes;
+    get type(): string;
+    get attributes(): IChannelAttributes;
+    /**
+     * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory.load}
+     */
+    load(runtime: IFluidDataStoreRuntime, id: string, services: IChannelServices, attributes: IChannelAttributes): Promise<SharedIntervalCollection>;
+    create(runtime: IFluidDataStoreRuntime, id: string): SharedIntervalCollection;
+}
+
+/**
+ * @public
+ */
+export declare abstract class SharedSegmentSequence<T extends ISegment> extends SharedObject<ISharedSegmentSequenceEvents> implements ISharedIntervalCollection<SequenceInterval>, MergeTreeRevertibleDriver {
+    private readonly dataStoreRuntime;
+    id: string;
+    readonly segmentFromSpec: (spec: IJSONSegment) => ISegment;
+    get loaded(): Promise<void>;
+    /**
+     * This is a safeguard to avoid problematic reentrancy of local ops. This type of scenario occurs if the user of SharedString subscribes
+     * to the `sequenceDelta` event and uses the callback for a local op to submit further local ops.
+     * Historically (before 2.0.0-internal.6.1.0), doing so would result in eventual consistency issues or a corrupted document.
+     * These issues were fixed in #16815 which makes such reentrancy no different from applying the ops in order but not from within the change events,
+     * but there is still little test coverage for reentrant scenarios.
+     * Additionally, applications submitting ops from inside change events need to take extreme care that their data models also support reentrancy.
+     * Since this is likely not the case, by default SharedString throws when encountering reentrant ops.
+     *
+     * An application using SharedString which explicitly wants to opt in to allowing reentrancy anyway can set `sharedStringPreventReentrancy`
+     * on the data store options to `false`.
+     * @internal
+     */
+    protected guardReentrancy: <TRet>(callback: () => TRet) => TRet;
+    private static createOpsFromDelta;
+    protected client: Client;
+    /** `Deferred` that triggers once the object is loaded */
+    protected loadedDeferred: Deferred<void>;
+    private readonly loadedDeferredOutgoingOps;
+    private deferIncomingOps;
+    private readonly loadedDeferredIncomingOps;
+    private messagesSinceMSNChange;
+    private readonly intervalCollections;
+    constructor(dataStoreRuntime: IFluidDataStoreRuntime, id: string, attributes: IChannelAttributes, segmentFromSpec: (spec: IJSONSegment) => ISegment);
+    /**
+     * @param start - The inclusive start of the range to remove
+     * @param end - The exclusive end of the range to remove
+     */
+    removeRange(start: number, end: number): IMergeTreeRemoveMsg;
+    /**
+     * @deprecated The ability to create group ops will be removed in an upcoming release, as group ops are redundant with the native batching capabilities of the runtime
+     */
+    groupOperation(groupOp: IMergeTreeGroupMsg): void;
+    /**
+     * Finds the segment information (i.e. segment + offset) corresponding to a character position in the SharedString.
+     * If the position is past the end of the string, `segment` and `offset` on the returned object may be undefined.
+     * @param pos - Character position (index) into the current local view of the SharedString.
+     */
+    getContainingSegment(pos: number): {
+        segment: T | undefined;
+        offset: number | undefined;
+    };
+    /**
+     * Returns the length of the current sequence for the client
+     */
+    getLength(): number;
+    /**
+     * Returns the current position of a segment, and -1 if the segment
+     * does not exist in this sequence
+     * @param segment - The segment to get the position of
+     */
+    getPosition(segment: ISegment): number;
+    /**
+     * Annotates the range with the provided properties
+     *
+     * @param start - The inclusive start position of the range to annotate
+     * @param end - The exclusive end position of the range to annotate
+     * @param props - The properties to annotate the range with
+     * @param combiningOp - Optional. Specifies how to combine values for the property, such as "incr" for increment.
+     *
+     */
+    annotateRange(start: number, end: number, props: PropertySet, combiningOp?: ICombiningOp): void;
+    getPropertiesAtPosition(pos: number): PropertySet | undefined;
+    getRangeExtentsOfPosition(pos: number): {
+        posStart: number | undefined;
+        posAfterEnd: number | undefined;
+    };
+    /**
+     * Creates a `LocalReferencePosition` on this SharedString. If the refType does not include
+     * ReferenceType.Transient, the returned reference will be added to the localRefs on the provided segment.
+     * @param segment - Segment to add the local reference on
+     * @param offset - Offset on the segment at which to place the local reference
+     * @param refType - ReferenceType for the created local reference
+     * @param properties - PropertySet to place on the created local reference
+     */
+    createLocalReferencePosition(segment: T, offset: number, refType: ReferenceType, properties: PropertySet | undefined, slidingPreference?: SlidingPreference, canSlideToEndpoint?: boolean): LocalReferencePosition;
+    /**
+     * Resolves a `ReferencePosition` into a character position using this client's perspective.
+     */
+    localReferencePositionToPosition(lref: ReferencePosition): number;
+    /**
+     * Removes a `LocalReferencePosition` from this SharedString.
+     */
+    removeLocalReferencePosition(lref: LocalReferencePosition): LocalReferencePosition | undefined;
+    /**
+     * Resolves a remote client's position against the local sequence
+     * and returns the remote client's position relative to the local
+     * sequence. The client ref seq must be above the minimum sequence number
+     * or the return value will be undefined.
+     * Generally this method is used in conjunction with signals which provide
+     * point in time values for the below parameters, and is useful for things
+     * like displaying user position. It should not be used with persisted values
+     * as persisted values will quickly become invalid as the remoteClientRefSeq
+     * moves below the minimum sequence number
+     * @param remoteClientPosition - The remote client's position to resolve
+     * @param remoteClientRefSeq - The reference sequence number of the remote client
+     * @param remoteClientId - The client id of the remote client
+     */
+    resolveRemoteClientPosition(remoteClientPosition: number, remoteClientRefSeq: number, remoteClientId: string): number | undefined;
+    /**
+     * @deprecated This method will no longer be public in an upcoming release as it is not safe to use outside of this class
+     */
+    submitSequenceMessage(message: IMergeTreeOp): void;
+    /**
+     * Given a position specified relative to a marker id, lookup the marker
+     * and convert the position to a character position.
+     * @param relativePos - Id of marker (may be indirect) and whether position is before or after marker.
+     */
+    posFromRelativePos(relativePos: IRelativePosition): number;
+    /**
+     * Walk the underlying segments of the sequence.
+     * The walked segments may extend beyond the range
+     * if the segments cross the ranges start or end boundaries.
+     * Set split range to true to ensure only segments within the
+     * range are walked.
+     *
+     * @param handler - The function to handle each segment
+     * @param start - Optional. The start of range walk.
+     * @param end - Optional. The end of range walk
+     * @param accum - Optional. An object that will be passed to the handler for accumulation
+     * @param splitRange - Optional. Splits boundary segments on the range boundaries
+     */
+    walkSegments<TClientData>(handler: ISegmentAction<TClientData>, start?: number, end?: number, accum?: TClientData, splitRange?: boolean): void;
+    /**
+     * @deprecated this functionality is no longer supported and will be removed
+     */
+    getStackContext(startPos: number, rangeLabels: string[]): RangeStackMap;
+    /**
+     * @returns The most recent sequence number which has been acked by the server and processed by this
+     * SharedSegmentSequence.
+     */
+    getCurrentSeq(): number;
+    /**
+     * Inserts a segment directly before a `ReferencePosition`.
+     * @param refPos - The reference position to insert the segment at
+     * @param segment - The segment to insert
+     */
+    insertAtReferencePosition(pos: ReferencePosition, segment: T): void;
+    /**
+     * Inserts a segment
+     * @param start - The position to insert the segment at
+     * @param spec - The segment to inserts spec
+     */
+    insertFromSpec(pos: number, spec: IJSONSegment): void;
+    /**
+     * Retrieves the interval collection keyed on `label`. If no such interval collection exists,
+     * creates one.
+     */
+    getIntervalCollection(label: string): IIntervalCollection<SequenceInterval>;
+    /**
+     * @returns An iterable object that enumerates the IntervalCollection labels.
+     *
+     * @example
+     *
+     * ```typescript
+     * const iter = this.getIntervalCollectionKeys();
+     * for (key of iter)
+     *     const collection = this.getIntervalCollection(key);
+     *     ...
+     * ```
+     */
+    getIntervalCollectionLabels(): IterableIterator<string>;
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.summarizeCore}
+     */
+    protected summarizeCore(serializer: IFluidSerializer, telemetryContext?: ITelemetryContext): ISummaryTreeWithStats;
+    /**
+     * Runs serializer over the GC data for this SharedMatrix.
+     * All the IFluidHandle's represent routes to other objects.
+     */
+    protected processGCDataCore(serializer: SummarySerializer): void;
+    /**
+     * Replace the range specified from start to end with the provided segment
+     * This is done by inserting the segment at the end of the range, followed
+     * by removing the contents of the range
+     * For a zero or reverse range (start \>= end), insert at end do not remove anything
+     * @param start - The start of the range to replace
+     * @param end - The end of the range to replace
+     * @param segment - The segment that will replace the range
+     */
+    protected replaceRange(start: number, end: number, segment: ISegment): void;
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.onConnect}
+     */
+    protected onConnect(): void;
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.onDisconnect}
+     */
+    protected onDisconnect(): void;
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.reSubmitCore}
+     */
+    protected reSubmitCore(content: any, localOpMetadata: unknown): void;
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.loadCore}
+     */
+    protected loadCore(storage: IChannelStorageService): Promise<void>;
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.processCore}
+     */
+    protected processCore(message: ISequencedDocumentMessage, local: boolean, localOpMetadata: unknown): void;
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.didAttach}
+     */
+    protected didAttach(): void;
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.initializeLocalCore}
+     */
+    protected initializeLocalCore(): void;
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObjectCore.applyStashedOp}
+     */
+    protected applyStashedOp(content: any): unknown;
+    private summarizeMergeTree;
+    private processMergeTreeMsg;
+    private processMinSequenceNumberChanged;
+    private loadFinished;
+    private initializeIntervalCollections;
+}
+
+/**
+ * @deprecated SharedSequence will be removed in a upcoming release. It has been moved to the fluid-experimental/sequence-deprecated package
+ * @public
+ */
+export declare class SharedSequence<T> extends SharedSegmentSequence<SubSequence<T>> {
+    id: string;
+    constructor(document: IFluidDataStoreRuntime, id: string, attributes: IChannelAttributes, specToSegment: (spec: IJSONSegment) => ISegment);
+    /**
+     * @param pos - The position to insert the items at.
+     * @param items - The items to insert.
+     * @param props - Optional. Properties to set on the inserted items.
+     */
+    insert(pos: number, items: Serializable<T>[], props?: PropertySet): void;
+    /**
+     * @param start - The inclusive start of the range to remove
+     * @param end - The exclusive end of the range to remove
+     */
+    remove(start: number, end: number): void;
+    /**
+     * Returns the total count of items in the sequence
+     */
+    getItemCount(): number;
+    /**
+     * Gets the items in the specified range
+     *
+     * @param start - The inclusive start of the range
+     * @param end - The exclusive end of the range
+     */
+    getItems(start: number, end?: number): Serializable<T>[];
+}
+
+/**
+ * The Shared String is a specialized data structure for handling collaborative
+ * text. It is based on a more general Sequence data structure but has
+ * additional features that make working with text easier.
+ *
+ * In addition to text, a Shared String can also contain markers. Markers can be
+ * used to store metadata at positions within the text, like the details of an
+ * image or Fluid object that should be rendered with the text.
+ *
+ * @public
+ */
+export declare class SharedString extends SharedSegmentSequence<SharedStringSegment> implements ISharedString {
+    id: string;
+    /**
+     * Create a new shared string.
+     * @param runtime - data store runtime the new shared string belongs to
+     * @param id - optional name of the shared string
+     * @returns newly create shared string (but not attached yet)
+     */
+    static create(runtime: IFluidDataStoreRuntime, id?: string): SharedString;
+    /**
+     * Get a factory for SharedString to register with the data store.
+     * @returns a factory that creates and load SharedString
+     */
+    static getFactory(): SharedStringFactory;
+    get ISharedString(): ISharedString;
+    private readonly mergeTreeTextHelper;
+    constructor(document: IFluidDataStoreRuntime, id: string, attributes: IChannelAttributes);
+    /**
+     * Inserts a marker at a relative position.
+     * @param relativePos1 - The relative position to insert the marker at
+     * @param refType - The reference type of the marker
+     * @param props - The properties of the marker
+     */
+    insertMarkerRelative(relativePos1: IRelativePosition, refType: ReferenceType, props?: PropertySet): void;
+    /**
+     * {@inheritDoc ISharedString.insertMarker}
+     */
+    insertMarker(pos: number, refType: ReferenceType, props?: PropertySet): IMergeTreeInsertMsg | undefined;
+    /**
+     * Inserts the text at the position.
+     * @param relativePos1 - The relative position to insert the text at
+     * @param text - The text to insert
+     * @param props - The properties of text
+     */
+    insertTextRelative(relativePos1: IRelativePosition, text: string, props?: PropertySet): void;
+    /**
+     * {@inheritDoc ISharedString.insertText}
+     */
+    insertText(pos: number, text: string, props?: PropertySet): void;
+    /**
+     * Replaces a range with the provided text.
+     * @param start - The inclusive start of the range to replace
+     * @param end - The exclusive end of the range to replace
+     * @param text - The text to replace the range with
+     * @param props - Optional. The properties of the replacement text
+     */
+    replaceText(start: number, end: number, text: string, props?: PropertySet): void;
+    /**
+     * Removes the text in the given range.
+     * @param start - The inclusive start of the range to remove
+     * @param end - The exclusive end of the range to replace
+     * @returns the message sent.
+     */
+    removeText(start: number, end: number): IMergeTreeRemoveMsg;
+    /**
+     * Annotates the marker with the provided properties and calls the callback on consensus.
+     * @param marker - The marker to annotate
+     * @param props - The properties to annotate the marker with
+     * @param consensusCallback - The callback called when consensus is reached
+     */
+    annotateMarkerNotifyConsensus(marker: Marker, props: PropertySet, callback: (m: Marker) => void): void;
+    /**
+     * Annotates the marker with the provided properties.
+     * @param marker - The marker to annotate
+     * @param props - The properties to annotate the marker with
+     * @param combiningOp - Optional. Specifies how to combine values for the property, such as "incr" for increment.
+     */
+    annotateMarker(marker: Marker, props: PropertySet, combiningOp?: ICombiningOp): void;
+    /**
+     * Finds the nearest reference with ReferenceType.Tile to `startPos` in the direction dictated by `tilePrecedesPos`.
+     * Note that Markers receive `ReferenceType.Tile` by default.
+     * @deprecated Use `searchForMarker` instead.
+     * @param startPos - Position at which to start the search
+     * @param clientId - clientId dictating the perspective to search from
+     * @param tileLabel - Label of the tile to search for
+     * @param preceding - Whether the desired tile comes before (true) or after (false) `startPos`
+     */
+    findTile(startPos: number | undefined, tileLabel: string, preceding?: boolean): {
+        tile: ReferencePosition;
+        pos: number;
+    } | undefined;
+    /**
+     * Searches a string for the nearest marker in either direction to a given start position.
+     * The search will include the start position, so markers at the start position are valid
+     * results of the search.
+     * @param startPos - Position at which to start the search
+     * @param markerLabel - Label of the marker to search for
+     * @param forwards - Whether the desired marker comes before (false) or after (true) `startPos`
+     */
+    searchForMarker(startPos: number, markerLabel: string, forwards?: boolean): Marker | undefined;
+    /**
+     * Retrieve text from the SharedString in string format.
+     * @param start - The starting index of the text to retrieve, or 0 if omitted.
+     * @param end - The ending index of the text to retrieve, or the end of the string if omitted
+     * @returns The requested text content as a string.
+     */
+    getText(start?: number, end?: number): string;
+    /**
+     * Adds spaces for markers and handles, so that position calculations account for them.
+     */
+    getTextWithPlaceholders(start?: number, end?: number): string;
+    getTextRangeWithMarkers(start: number, end: number): string;
+    /**
+     * Looks up and returns a `Marker` using its id. Returns `undefined` if there is no marker with the provided
+     * id in this `SharedString`.
+     */
+    getMarkerFromId(id: string): ISegment | undefined;
+    /**
+     * Revert an op
+     */
+    protected rollback(content: any, localOpMetadata: unknown): void;
+}
+
+/**
+ * @public
+ */
+export declare class SharedStringFactory implements IChannelFactory {
+    static Type: string;
+    static readonly Attributes: IChannelAttributes;
+    static segmentFromSpec(spec: any): SharedStringSegment;
+    get type(): string;
+    get attributes(): IChannelAttributes;
+    /**
+     * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory.load}
+     */
+    load(runtime: IFluidDataStoreRuntime, id: string, services: IChannelServices, attributes: IChannelAttributes): Promise<SharedString>;
+    create(document: IFluidDataStoreRuntime, id: string): SharedString;
+}
+
+/**
+ * Data for undoing edits on SharedStrings and Intervals.
+ *
+ * @alpha
+ */
+export declare type SharedStringRevertible = MergeTreeDeltaRevertible | IntervalRevertible;
+
+/**
+ * @public
+ */
+export declare type SharedStringSegment = TextSegment | Marker;
+
+/**
+ * Defines a side relative to a character in a sequence.
+ *
+ * @remarks See {@link SequencePlace} for additional context on usage.
+ * @public
+ */
+export declare enum Side {
+    Before = 0,
+    After = 1
+}
+
+/**
+ * @deprecated SubSequence will be removed in a upcoming release. It has been moved to the fluid-experimental/sequence-deprecated package
+ * @public
+ */
+export declare class SubSequence<T> extends BaseSegment {
+    items: Serializable<T>[];
+    static readonly typeString: string;
+    static is(segment: ISegment): segment is SubSequence<any>;
+    static fromJSONObject<U>(spec: Serializable): SubSequence<U> | undefined;
+    readonly type: string;
+    constructor(items: Serializable<T>[]);
+    toJSONObject(): IJSONRunSegment<T>;
+    clone(start?: number, end?: number): SubSequence<T>;
+    canAppend(segment: ISegment): boolean;
+    toString(): string;
+    append(segment: ISegment): void;
+    removeRange(start: number, end: number): boolean;
+    protected createSplitSegmentAt(pos: number): SubSequence<T> | undefined;
+}
+
+export { }