@fluidframework/sequence 2.0.0-internal.7.1.0 → 2.0.0-internal.7.2.0

package/dist/sequence-untrimmed.d.ts

@@ -1,1672 +0,0 @@
-/**
- * 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;
-
-export declare function createEndpointIndex(sharedString: SharedString): IEndpointIndex<SequenceInterval>;
-
-export declare function createEndpointInRangeIndex(sharedString: SharedString): IEndpointInRangeIndex<SequenceInterval>;
-
-export declare function createIdIntervalIndex<TInterval extends ISerializableInterval>(): IIdIntervalIndex<TInterval>;
-
-export declare function createOverlappingIntervalsIndex(sharedString: SharedString): IOverlappingIntervalsIndex<SequenceInterval>;
-
-export declare function createOverlappingSequenceIntervalsIndex(sharedString: SharedString): SequenceIntervalIndexes.Overlapping;
-
-export declare function createStartpointInRangeIndex(sharedString: SharedString): IStartpointInRangeIndex<SequenceInterval>;
-
-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".
- * ```
- */
-export declare function getTextAndMarkers(sharedString: SharedString, label: string, start?: number, end?: number): {
-    parallelText: string[];
-    parallelMarkers: Marker[];
-};
-
-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.
- */
-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[];
-}
-
-export declare interface IIdIntervalIndex<TInterval extends ISerializableInterval> extends IntervalIndex<TInterval>, Iterable<TInterval> {
-    getIntervalById(id: string): TInterval | undefined;
-    [Symbol.iterator](): Iterator<TInterval>;
-}
-
-/**
- * Basic interval abstraction
- */
-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).
- */
-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
- */
-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
- */
-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
- */
-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.
- */
-export declare interface InteriorSequencePlace {
-    pos: number;
-    side: Side;
-}
-
-/**
- * Serializable interval whose endpoints are plain-old numbers.
- */
-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.
- */
-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`.
- */
-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.
- */
-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];
-
-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
-}
-
-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.
- */
-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;
-}
-
-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;
-}
-
-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.
- */
-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
- */
-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.
- */
-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.
- */
-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.
- */
-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.
- */
-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
- */
-export declare const sequenceIntervalHelpers: IIntervalHelpers<SequenceInterval>;
-
-/**
- * This namespace contains specialiazations of indexes which support spatial queries
- * specifically for `SequenceInterval`s.
- */
-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.
- */
-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
- */
-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.
- */
-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.
- */
-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.
- */
-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;
-}
-
-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
- */
-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.
- *
- */
-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.
-     * @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;
-    /**
-     * 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;
-}
-
-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;
-
-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.
- */
-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
- */
-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 { }