@fluidframework/merge-tree 2.0.0-rc.1.0.3 → 2.0.0-rc.2.0.0

package/dist/merge-tree-untrimmed.d.ts

@@ -1,5 +1,4 @@
 import { AttributionKey } from '@fluidframework/runtime-definitions';
-import { Heap } from '@fluidframework/core-utils';
 import { IChannelStorageService } from '@fluidframework/datastore-definitions';
 import { IEventThisPlaceHolder } from '@fluidframework/core-interfaces';
 import { IFluidDataStoreRuntime } from '@fluidframework/datastore-definitions';
@@ -48,61 +47,6 @@ export declare interface AttributionPolicy {
     serializer: IAttributionCollectionSerializer;
 }
 
-/**
- * This is a special segment that is not bound or known by the merge tree itself,
- * but the segment itself pretends to be a removed segment at an endpoint of the
- * tree. It is removed so it appears as a undefined/0 length segment. This segment
- * adds the capability to hold local references that have been detached from the
- * real merge tree, and give the appearance that they exist at an endpoint of the
- * tree.
- *
- * This is useful today in 2 cases: detached references and interval stickiness.
- *
- * In general, local references only become detached when the tree becomes empty
- * and the EndOfTreeSegment allows us to gracefully handle that case by giving
- * those references a place to live.
- *
- * In the case of interval stickiness, it is desirable to be able to refer to
- * the position immediately after or before a segment, in order for the endpoint
- * of an interval to be exclusive. This means that in order to support intervals
- * that are exclusive and also include the first or last segment of the tree, it
- * must be possible in some way to refer to a position before or after the tree
- * respectively. The endpoint segments allow us to support such behavior.
- */
-declare abstract class BaseEndpointSegment {
-    protected readonly mergeTree: MergeTree;
-    constructor(mergeTree: MergeTree);
-    removedSeq: number;
-    removedClientIds: number[];
-    attribution: undefined;
-    propertyManager: undefined;
-    localSeq: undefined;
-    localRemovedSeq: undefined;
-    properties: undefined;
-    seq: number;
-    clientId: number;
-    cachedLength: number;
-    isLeaf(): this is ISegment;
-    protected abstract endpointSegmentProps(): {
-        parent: IMergeBlock;
-        index: number;
-        depth: number;
-    };
-    get parent(): IMergeBlock;
-    get index(): number;
-    abstract get ordinal(): string;
-    localRefs?: LocalReferenceCollection;
-    get segmentGroups(): never;
-    get trackingCollection(): never;
-    addProperties: () => never;
-    clone: () => never;
-    canAppend: () => never;
-    append: () => never;
-    splitAt: () => never;
-    toJSONObject: () => never;
-    ack: () => never;
-}
-
 /**
  * @alpha
  */
@@ -149,11 +93,27 @@ export declare abstract class BaseSegment extends MergeNode implements ISegment
 export declare class Client extends TypedEventEmitter<IClientEvents> {
     readonly specToSegment: (spec: IJSONSegment) => ISegment;
     readonly logger: ITelemetryLoggerExt;
+    private readonly getMinInFlightRefSeq;
     longClientId: string | undefined;
     private readonly _mergeTree;
     private readonly clientNameToIds;
     private readonly shortClientIdMap;
-    constructor(specToSegment: (spec: IJSONSegment) => ISegment, logger: ITelemetryLoggerExt, options?: IMergeTreeOptions & PropertySet);
+    /**
+     * @param specToSegment - Rehydrates a segment from its JSON representation
+     * @param logger - Telemetry logger for diagnostics
+     * @param options - Options for this client. See {@link IMergeTreeOptions} for details.
+     * @param getMinInFlightRefSeq - Upon applying a message (see {@link Client.applyMsg}), client purges collab-window information which
+     * is no longer necessary based on that message's minimum sequence number.
+     * However, if the user of this client has in-flight messages which refer to positions in this Client,
+     * they may wish to preserve additional merge information.
+     * The effective minimum sequence number will be the minimum of the message's minimumSequenceNumber and the result of this function.
+     * If this function returns undefined, the message's minimumSequenceNumber will be used.
+     *
+     * @privateRemarks
+     * - Passing specToSegment would be unnecessary if Client were merged with SharedSegmentSequence
+     * - AB#6866 tracks a more unified approach to collab window min seq handling.
+     */
+    constructor(specToSegment: (spec: IJSONSegment) => ISegment, logger: ITelemetryLoggerExt, options?: IMergeTreeOptions & PropertySet, getMinInFlightRefSeq?: () => number | undefined);
     /**
      * The merge tree maintains a queue of segment groups for each local operation.
      * These segment groups track segments modified by an operation.
@@ -237,6 +197,11 @@ export declare class Client extends TypedEventEmitter<IClientEvents> {
     removeLocalReferencePosition(lref: LocalReferencePosition): LocalReferencePosition | undefined;
     /**
      * Resolves a `ReferencePosition` into a character position using this client's perspective.
+     *
+     * Reference positions that point to a character that has been removed will
+     * always return the position of the nearest non-removed character, regardless
+     * of {@link ReferenceType}. To handle this case specifically, one may wish
+     * to look at the segment returned by {@link ReferencePosition.getSegment}.
      */
     localReferencePositionToPosition(lref: ReferencePosition): number;
     /**
@@ -301,9 +266,7 @@ export declare class Client extends TypedEventEmitter<IClientEvents> {
     findReconnectionPosition(segment: ISegment, localSeq: number): number;
     private resetPendingDeltaToOps;
     private applyRemoteOp;
-    applyStashedOp(op: IMergeTreeDeltaOp): SegmentGroup;
-    applyStashedOp(op: IMergeTreeGroupMsg): SegmentGroup[];
-    applyStashedOp(op: IMergeTreeOp): SegmentGroup | SegmentGroup[];
+    applyStashedOp(op: IMergeTreeOp): void;
     applyMsg(msg: ISequencedDocumentMessage, local?: boolean): void;
     private updateSeqNumbers;
     /**
@@ -554,57 +517,6 @@ export declare interface Dictionary<TKey, TData> {
  */
 export declare function discardMergeTreeDeltaRevertible(revertibles: MergeTreeDeltaRevertible[]): void;
 
-declare class DoublyLinkedList<T> implements Iterable<ListNode<T>>, Partial<ListNodeRange<T>>, Pick<ListNode<T>[], "pop" | "shift" | "length" | "includes"> {
-    find(predicate: (value: ListNode<T>, obj: DoublyLinkedList<T>) => unknown): ListNode<T> | undefined;
-    map<U>(callbackfn: (value: ListNode<T>) => U): Iterable<U>;
-    insertAfter(preceding: ListNode<T>, ...items: T[]): ListNodeRange<T>;
-    pop(): ListNode<T> | undefined;
-    push(...items: T[]): ListNodeRange<T>;
-    /**
-     * Remove and return the first element
-     */
-    shift(): ListNode<T> | undefined;
-    /**
-     * Insert `items` at start of list
-     */
-    unshift(...items: T[]): ListNodeRange<T>;
-    /**
-     * Remove nodes starting at `start` until either the `end` node is reached
-     * or until `count` nodes have been removed. Returns the removed nodes as
-     * a separate linked list
-     */
-    splice(start: ListNode<T>, countOrEnd?: ListNode<T> | number): DoublyLinkedList<T>;
-    includes(node: ListNode<T> | undefined): node is ListNode<T>;
-    private _includes;
-    private _remove;
-    remove(node: ListNode<T> | undefined): ListNode<T> | undefined;
-    [Symbol.iterator](): IterableIterator<ListNode<T>>;
-    private _len;
-    private readonly headNode;
-    get length(): number;
-    get empty(): boolean;
-    get first(): ListNode<T> | undefined;
-    get last(): ListNode<T> | undefined;
-}
-
-/**
- * The position immediately after the end of the tree
- */
-declare class EndOfTreeSegment extends BaseEndpointSegment implements ISegment, IRemovalInfo {
-    type: string;
-    readonly endpointType = "end";
-    /**
-     * this segment pretends to be a sibling of the last real segment.
-     * so compute the necessary properties to pretend to be that segment.
-     */
-    protected endpointSegmentProps(): {
-        parent: IMergeBlock;
-        index: number;
-        depth: number;
-    };
-    get ordinal(): string;
-}
-
 /**
  * Returns the position to slide a reference to if a slide is required.
  * @param segoff - The segment and offset to slide from
@@ -701,14 +613,6 @@ export declare interface IClientEvents {
     (event: "maintenance", listener: (args: IMergeTreeMaintenanceCallbackArgs, deltaArgs: IMergeTreeDeltaOpArgs | undefined, target: IEventThisPlaceHolder) => void): void;
 }
 
-/**
- * @internal
- */
-declare interface IHierBlock extends IMergeBlock {
-    rightmostTiles: MapLike<ReferencePosition>;
-    leftmostTiles: MapLike<ReferencePosition>;
-}
-
 /**
  * @alpha
  */
@@ -737,48 +641,6 @@ export declare interface IMarkerDef {
     refType?: ReferenceType;
 }
 
-/**
- * Internal (i.e. non-leaf) node in a merge tree.
- * @internal
- */
-declare interface IMergeBlock extends IMergeNodeCommon {
-    parent?: IMergeBlock;
-    needsScour?: boolean;
-    /**
-     * Number of direct children of this node
-     */
-    childCount: number;
-    /**
-     * Array of child nodes.
-     *
-     * @remarks To avoid reallocation, this is always initialized to have maximum length as deemed by
-     * the merge tree's branching factor. Use `childCount` to determine how many children this node actually has.
-     */
-    children: IMergeNode[];
-    /**
-     * Supports querying the total length of all descendants of this IMergeBlock from the perspective of any
-     * (clientId, seq) within the collab window.
-     *
-     * @remarks This is only optional for implementation reasons (internal nodes can be created/moved without
-     * immediately initializing the partial lengths). Aside from mid-update on tree operations, these lengths
-     * objects are always defined.
-     */
-    partialLengths?: PartialSequenceLengths;
-    /**
-     * The length of the contents of the node.
-     */
-    cachedLength: number | undefined;
-    hierBlock(): IHierBlock | undefined;
-    assignChild(child: IMergeNode, index: number, updateOrdinal?: boolean): void;
-    setOrdinal(child: IMergeNode, index: number): void;
-}
-
-declare type IMergeLeaf = ISegment & {
-    parent?: IMergeBlock;
-};
-
-declare type IMergeNode = IMergeBlock | IMergeLeaf;
-
 /**
  * Common properties for a node in a merge tree.
  * @alpha
@@ -881,10 +743,6 @@ export declare interface IMergeTreeDeltaOpArgs {
      * Delta op args are for an unacked local change
      */
     readonly sequencedMessage?: ISequencedDocumentMessage;
-    /**
-     * If the operation is being applied as a stashed op, which means it may have been previously submitted, and therefore should not be resubmitted
-     */
-    readonly stashed?: boolean;
 }
 
 /**
@@ -1079,11 +937,6 @@ export declare interface IMoveInfo {
     wasMovedOnInsert: boolean;
 }
 
-declare interface IOverlapClient {
-    clientId: number;
-    seglen: number;
-}
-
 /**
  * @internal
  */
@@ -1099,12 +952,6 @@ export declare interface IRBMatcher<TKey, TData> {
     matchNode(node: RBNode<TKey, TData> | undefined, key: TKey): boolean;
 }
 
-declare interface IRefsAtOffset {
-    before?: DoublyLinkedList<LocalReference>;
-    at?: DoublyLinkedList<LocalReference>;
-    after?: DoublyLinkedList<LocalReference>;
-}
-
 /**
  * A position specified relative to a segment.
  * @alpha
@@ -1148,10 +995,6 @@ export declare interface IRemovalInfo {
     removedClientIds: number[];
 }
 
-declare interface IRootMergeBlock extends IMergeBlock {
-    mergeTree?: MergeTree;
-}
-
 /**
  * A segment representing a portion of the merge tree.
  * Segments are leaf nodes of the merge tree and contain data.
@@ -1263,12 +1106,6 @@ export declare interface ISegmentAction<TClientData> {
     (segment: ISegment, pos: number, refSeq: number, clientId: number, start: number, end: number, accum: TClientData): boolean;
 }
 
-/**
- * someday we may split tree leaves from segments, but for now they are the same
- * this is just a convenience type that makes it clear that we need something that is both a segment and a leaf node
- */
-declare type ISegmentLeaf = ISegment & IMergeLeaf;
-
 /**
  * Tests whether x is a MergeTreeDeltaRevertible
  * @internal
@@ -1293,59 +1130,23 @@ export declare interface KeyComparer<TKey> {
     (a: TKey, b: TKey): number;
 }
 
-declare interface ListNode<T> {
-    readonly list: DoublyLinkedList<T> | undefined;
-    readonly data: T;
-    readonly next: ListNode<T> | undefined;
-    readonly prev: ListNode<T> | undefined;
-}
-
-declare interface ListNodeRange<T> {
-    first: ListNode<T>;
-    last: ListNode<T>;
-}
-
-/**
- * @privateRemarks This should not be exported outside merge tree.
- * @internal
- */
-declare class LocalReference implements LocalReferencePosition {
-    refType: ReferenceType;
-    readonly slidingPreference: SlidingPreference;
-    readonly canSlideToEndpoint?: boolean | undefined;
-    properties: PropertySet | undefined;
-    private segment;
-    private offset;
-    private listNode;
-    callbacks?: Partial<Record<"beforeSlide" | "afterSlide", (ref: LocalReferencePosition) => void>> | undefined;
-    private _trackingCollection?;
-    get trackingCollection(): TrackingGroupCollection;
-    constructor(refType?: ReferenceType, properties?: PropertySet, slidingPreference?: SlidingPreference, canSlideToEndpoint?: boolean | undefined);
-    link(segment: ISegment | undefined, offset: number, listNode: ListNode<LocalReference> | undefined): void;
-    isLeaf(): boolean;
-    addProperties(newProps: PropertySet): void;
-    getSegment(): ISegment | undefined;
-    getOffset(): number;
-    getListNode(): ListNode<LocalReference> | undefined;
-    getProperties(): PropertySet | undefined;
-}
-
 /**
  * Represents a collection of {@link LocalReferencePosition}s associated with
  * one segment in a merge-tree.
  * Represents a collection of {@link LocalReferencePosition}s associated with one segment in a merge-tree.
+ * @sealed
+ *
  * @alpha
  */
 export declare class LocalReferenceCollection {
     /** Segment this `LocalReferenceCollection` is associated to. */
     private readonly segment;
     static append(seg1: ISegment, seg2: ISegment): void;
+    static setOrGet(segment: ISegment): LocalReferenceCollection;
     private readonly refsByOffset;
     private refCount;
     /***/
-    constructor(
-    /** Segment this `LocalReferenceCollection` is associated to. */
-    segment: ISegment, initialRefsByfOffset?: (IRefsAtOffset | undefined)[]);
+    private constructor();
     /**
      * @remarks This method should only be called by mergeTree.
      */
@@ -1431,14 +1232,6 @@ export declare interface LocalReferencePosition extends ReferencePosition {
     readonly canSlideToEndpoint?: boolean;
 }
 
-/**
- * @internal
- */
-declare interface LRUSegment {
-    segment?: ISegmentLeaf;
-    maxSeq: number;
-}
-
 /**
  * Any mapping from a string to values of type `T`
  * @alpha
@@ -1488,19 +1281,6 @@ export declare function matchProperties(a: PropertySet | undefined, b: PropertyS
  */
 export declare function maxReferencePosition<T extends ReferencePosition>(a: T, b: T): T;
 
-/**
- * @internal
- */
-declare class MergeBlock extends MergeNode implements IMergeBlock {
-    childCount: number;
-    parent?: IMergeBlock;
-    children: IMergeNode[];
-    constructor(childCount: number);
-    hierBlock(): IHierBlock | undefined;
-    setOrdinal(child: IMergeNode, index: number): void;
-    assignChild(child: IMergeNode, index: number, updateOrdinal?: boolean): void;
-}
-
 /**
  * @alpha
  */
@@ -1511,266 +1291,6 @@ export declare class MergeNode implements IMergeNodeCommon {
     isLeaf(): this is ISegment;
 }
 
-/**
- * @internal
- */
-declare class MergeTree {
-    options?: IMergeTreeOptions | undefined;
-    static readonly options: {
-        incrementalUpdate: boolean;
-        insertAfterRemovedSegs: boolean;
-        zamboniSegments: boolean;
-    };
-    private static readonly theUnfinishedNode;
-    readonly collabWindow: CollaborationWindow;
-    readonly pendingSegments: DoublyLinkedList<SegmentGroup>;
-    readonly segmentsToScour: Heap<LRUSegment>;
-    readonly attributionPolicy: AttributionPolicy | undefined;
-    /**
-     * Whether or not all blocks in the mergeTree currently have information about local partial lengths computed.
-     * This information is only necessary on reconnect, and otherwise costly to bookkeep.
-     * This field enables tracking whether partials need to be recomputed using localSeq information.
-     */
-    private localPartialsComputed;
-    private readonly idToMarker;
-    mergeTreeDeltaCallback?: MergeTreeDeltaCallback;
-    mergeTreeMaintenanceCallback?: MergeTreeMaintenanceCallback;
-    /**
-     * Array containing the sequence number of all move operations within the
-     * collab window
-     *
-     * When a segment is inserted, we must traverse to the left and right of it
-     * to determine whether the segment was inserted into an obliterated range.
-     * By keeping track of all move seqs, we can significantly reduce the search
-     * space we must traverse.
-     *
-     * Sequence numbers in `moveSeqs` are sorted to accelerate bookkeeping.
-     *
-     * See https://github.com/microsoft/FluidFramework/blob/main/packages/dds/merge-tree/docs/Obliterate.md#remote-perspective
-     * for additional context
-     */
-    private moveSeqs;
-    /**
-     * Similar to moveSeqs, but tracks local moves. These are not the move
-     * operations within the collab window, but rather local moves that have
-     * not been acked.
-     */
-    private readonly localMoveSeqs;
-    /**
-     * Groups of segments moved by local moves/obliterates
-     *
-     * When a local obliterate is acked, we must also ack segments that were
-     * concurrently obliterated on insert. We check this segment group to find
-     * such segments
-     */
-    private readonly locallyMovedSegments;
-    constructor(options?: IMergeTreeOptions | undefined);
-    private _root;
-    get root(): IRootMergeBlock;
-    set root(value: IRootMergeBlock);
-    makeBlock(childCount: number): MergeBlock;
-    /**
-     * Compute the net length of this segment from a local perspective.
-     * @param segment - Segment whose length to find
-     * @param localSeq - localSeq at which to find the length of this segment. If not provided,
-     * default is to consider the local client's current perspective. Only local sequence
-     * numbers corresponding to un-acked operations give valid results.
-     */
-    localNetLength(segment: ISegment, refSeq?: number, localSeq?: number): number | undefined;
-    unlinkMarker(marker: Marker): void;
-    private addNode;
-    reloadFromSegments(segments: ISegment[]): void;
-    startCollaboration(localClientId: number, minSeq: number, currentSeq: number): void;
-    private addToLRUSet;
-    getLength(refSeq: number, clientId: number): number;
-    /**
-     * Returns the current length of the MergeTree for the local client.
-     */
-    get length(): number | undefined;
-    getPosition(node: IMergeNode, refSeq: number, clientId: number, localSeq?: number): number;
-    getContainingSegment<T extends ISegment>(pos: number, refSeq: number, clientId: number, localSeq?: number): {
-        segment: T | undefined;
-        offset: number | undefined;
-    };
-    /**
-     * Slides or removes references from the provided list of segments.
-     *
-     * The order of the references is preserved for references of the same sliding
-     * preference. Relative order between references that slide backward and those
-     * that slide forward is not preserved, even in the case when they slide to
-     * the same segment.
-     *
-     * @remarks
-     *
-     * 1. Preserving the order of the references is a useful property for reference-based undo/redo
-     * (see revertibles.ts).
-     *
-     * 2. For use cases which necessitate eventual consistency across clients,
-     * this method should only be called with segments for which the current client sequence number is
-     * max(remove segment sequence number, add reference sequence number).
-     * See `packages\dds\merge-tree\REFERENCEPOSITIONS.md`
-     *
-     * @param segments - An array of (not necessarily contiguous) segments with increasing ordinals.
-     */
-    private slideAckedRemovedSegmentReferences;
-    private blockLength;
-    /**
-     * Compute local partial length information
-     *
-     * Public only for use by internal tests
-     */
-    computeLocalPartials(refSeq: number): void;
-    private nodeLength;
-    setMinSeq(minSeq: number): void;
-    referencePositionToLocalPosition(refPos: ReferencePosition, refSeq?: number, clientId?: number): number;
-    /**
-     * Finds the nearest reference with ReferenceType.Tile to `startPos` in the direction dictated by `forwards`.
-     * Uses depthFirstNodeWalk in addition to block-accelerated functionality. The search position will be included in
-     * the nodes to walk, so searching on all positions, including the endpoints, can be considered inclusive.
-     * Any out of bound search positions will return undefined, so in order to search the whole string, a forward
-     * search can begin at 0, or a backward search can begin at length-1.
-     *
-     * @param startPos - Position at which to start the search
-     * @param clientId - clientId dictating the perspective to search from
-     * @param markerLabel - Label of the marker to search for
-     * @param forwards - Whether the string should be searched in the forward or backward direction
-     */
-    searchForMarker(startPos: number, clientId: number, markerLabel: string, forwards?: boolean): Marker | undefined;
-    private updateRoot;
-    /**
-     * Assign sequence number to existing segment; update partial lengths to reflect the change
-     * @param seq - sequence number given by server to pending segment
-     */
-    ackPendingSegment(opArgs: IMergeTreeDeltaOpArgs): void;
-    private addToPendingList;
-    getMarkerFromId(id: string): Marker | undefined;
-    /**
-     * 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.
-     * @param refseq - The reference sequence number at which to compute the position.
-     * @param clientId - The client id with which to compute the position.
-     */
-    posFromRelativePos(relativePos: IRelativePosition, refseq?: number, clientId?: number): number;
-    insertSegments(pos: number, segments: ISegment[], refSeq: number, clientId: number, seq: number, opArgs: IMergeTreeDeltaOpArgs | undefined): void;
-    /**
-     * 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: number): number | undefined;
-    private blockInsert;
-    private readonly splitLeafSegment;
-    private ensureIntervalBoundary;
-    private breakTie;
-    private getSmallestSeqMoveOp;
-    private insertingWalk;
-    private split;
-    nodeUpdateOrdinals(block: IMergeBlock): void;
-    /**
-     * Annotate a range with 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 refSeq - The reference sequence number to use to apply the annotate
-     * @param clientId - The id of the client making the annotate
-     * @param seq - The sequence number of the annotate operation
-     * @param opArgs - The op args for the annotate op. this is passed to the merge tree callback if there is one
-     * @param rollback - Whether this is for a local rollback and what kind
-     */
-    annotateRange(start: number, end: number, props: PropertySet, refSeq: number, clientId: number, seq: number, opArgs: IMergeTreeDeltaOpArgs, rollback?: PropertiesRollback): void;
-    /**
-     * @alpha
-     */
-    obliterateRange(start: number, end: number, refSeq: number, clientId: number, seq: number, overwrite: boolean | undefined, opArgs: IMergeTreeDeltaOpArgs): void;
-    markRangeRemoved(start: number, end: number, refSeq: number, clientId: number, seq: number, overwrite: boolean | undefined, opArgs: IMergeTreeDeltaOpArgs): void;
-    /**
-     * Revert an unacked local op
-     */
-    rollback(op: IMergeTreeDeltaOp, localOpMetadata: SegmentGroup): void;
-    /**
-     * Walk the segments up to the current segment and calculate its position
-     */
-    private findRollbackPosition;
-    nodeUpdateLengthNewStructure(node: IMergeBlock, recur?: boolean): void;
-    removeLocalReferencePosition(lref: LocalReferencePosition): LocalReferencePosition | undefined;
-    startOfTree: StartOfTreeSegment;
-    endOfTree: EndOfTreeSegment;
-    createLocalReferencePosition(_segment: ISegmentLeaf | "start" | "end", offset: number, refType: ReferenceType, properties: PropertySet | undefined, slidingPreference?: SlidingPreference, canSlideToEndpoint?: boolean): LocalReferencePosition;
-    private normalizeAdjacentSegments;
-    /**
-     * Normalizes the segments nearby `segmentGroup` to be ordered as they would if the op submitting `segmentGroup`
-     * is rebased to the current sequence number.
-     * This primarily affects the ordering of adjacent segments that were removed between the original submission of
-     * the local ops and now.
-     * Consider the following sequence of events:
-     * Initial state: "hi my friend" (seq: 0)
-     * - Client 1 inserts "good " to make "hi my good friend" (op1, refSeq: 0)
-     * - Client 2 deletes "my " to make "hi friend" (op2, refSeq: 0)
-     * - op2 is sequenced giving seq 1
-     * - Client 1 disconnects and reconnects at seq: 1.
-     *
-     * At this point in time, client 1 will have segments ["hi ", Removed"my ", Local"good ", "friend"].
-     * However, the rebased op that it submits will cause client 2 to have segments
-     * ["hi ", Local"good ", Removed"my ", "friend"].
-     *
-     * The difference in ordering can be problematic for tie-breaking concurrently inserted segments in some scenarios.
-     * Rather than incur extra work tie-breaking these scenarios for all clients, when client 1 rebases its operation,
-     * it can fix up its local state to align with what would be expected of the op it resubmits.
-     */
-    normalizeSegmentsOnRebase(): void;
-    private addNodeReferences;
-    private blockUpdate;
-    blockUpdatePathLengths(startBlock: IMergeBlock | undefined, seq: number, clientId: number, newStructure?: boolean): void;
-    private blockUpdateLength;
-    /**
-     * Map over all visible segments in a given range
-     *
-     * A segment is visible if its length is greater than 0
-     *
-     * See `this.nodeMap` for additional documentation
-     */
-    mapRange<TClientData>(handler: ISegmentAction<TClientData>, refSeq: number, clientId: number, accum: TClientData, start?: number, end?: number, splitRange?: boolean, visibilitySeq?: number): void;
-    /**
-     * Map over all visible segments in a given range
-     *
-     * A segment is visible if its length is greater than 0
-     *
-     * @param refSeq - The sequence number used to determine the range (start
-     * and end positions) of segments to iterate over.
-     *
-     * @param visibilitySeq - An additional sequence number to further configure
-     * segment visibility during traversal. This is the same as refSeq, except
-     * in the case of obliterate.
-     *
-     * In the case where `refSeq == visibilitySeq`, mapping is done on all
-     * visible segments from `start` to `end`.
-     *
-     * If a segment is invisible at both `visibilitySeq` and `refSeq`, then it
-     * will not be traversed and mapped. Otherwise, if the segment is visible at
-     * either seq, it will be mapped.
-     *
-     * If a segment is only visible at `visibilitySeq`, it will still be mapped,
-     * but it will not count as a segment within the range. That is, it will be
-     * ignored for the purposes of tracking when traversal should end.
-     */
-    private nodeMap;
-}
-
-/**
- * @internal
- */
-declare type MergeTreeDeltaCallback = (opArgs: IMergeTreeDeltaOpArgs, deltaArgs: IMergeTreeDeltaCallbackArgs) => void;
-
 /**
  * @alpha
  */
@@ -1815,11 +1335,6 @@ export declare const MergeTreeDeltaType: {
  */
 export declare type MergeTreeDeltaType = (typeof MergeTreeDeltaType)[keyof typeof MergeTreeDeltaType];
 
-/**
- * @internal
- */
-declare type MergeTreeMaintenanceCallback = (MaintenanceArgs: IMergeTreeMaintenanceCallbackArgs, opArgs: IMergeTreeDeltaOpArgs | undefined) => void;
-
 /**
  * Enum-like constant defining the types of "maintenance" events on a merge tree.
  * Maintenance events correspond to structural segment changes or acks of pending segments.
@@ -1874,262 +1389,6 @@ export declare interface MergeTreeRevertibleDriver {
  */
 export declare function minReferencePosition<T extends ReferencePosition>(a: T, b: T): T;
 
-/**
- * Tracks length information for a part of a MergeTree (block) at a given time (seq).
- * These objects are associated with internal nodes (i.e. blocks).
- */
-declare interface PartialSequenceLength {
-    /**
-     * Sequence number
-     */
-    seq: number;
-    /**
-     * The length of the associated block.
-     */
-    len: number;
-    /**
-     * The delta between the current length of the associated block and its length at the previous seq number.
-     */
-    seglen: number;
-    /**
-     * clientId for the client that submitted the op with sequence number `seq`.
-     */
-    clientId?: number;
-    /**
-     * If this partial length obliterated remote segments, this is the length of
-     * those segments
-     */
-    remoteObliteratedLen?: number;
-    /**
-     * This field maps each client to the size of the intersection between segments deleted at this seq
-     * and segments concurrently deleted by that client.
-     *
-     * For example, this PartialSequenceLength:
-     * ```typescript
-     * {
-     *     seq: 5,
-     *     len: 100,
-     *     seglen: -10,
-     *     clientId: 0,
-     *     overlapRemoveClients: <RedBlack tree with key-values expressed by>{
-     *         1: { clientId: 1, seglen: -5 },
-     *         3: { clientId: 3, seglen: -10 }
-     *     }
-     * }
-     * ```
-     *
-     * corresponds to an op submitted by client 0 which:
-     * - reduces the length of this block by 10 (it may have deleted a single segment of length 10,
-     *     several segments totalling length 10, or even delete and add content for a total reduction of 10 length)
-     * - was concurrent to one or more ops submitted by client 1 that also removed some of the same segments,
-     *     whose length totalled 5
-     * - was concurrent to one or more ops submitted by client 3 that removed some of the same segments,
-     *     whose length totalled 10
-     */
-    overlapRemoveClients?: RedBlackTree<number, IOverlapClient>;
-    /**
-     * This field is the same as `overlapRemoveClients`, except that it tracks
-     * overlapping obliterates rather than removes.
-     */
-    overlapObliterateClients?: RedBlackTree<number, IOverlapClient>;
-}
-
-/**
- * Keeps track of partial sums of segment lengths for all sequence numbers in the current collaboration window.
- * Only used during active collaboration.
- *
- * This class is associated with an internal node (block) of a MergeTree. It efficiently answers queries of the form
- * "What is the length of `block` from the perspective of some particular seq and clientId?".
- *
- * It also supports incremental updating of state for newly-sequenced ops that don't affect the structure of the
- * MergeTree.
- *
- * To answer these queries, it pre-builds several lists which track the length of the block at a per-sequence-number
- * level. These lists are:
- *
- * 1. (`partialLengths`): Stores the total length of the block.
- * 2. (`clientSeqNumbers[clientId]`): Stores only the total lengths of segments submitted by `clientId`. [see footnote]
- *
- * The reason both lists are necessary is that resolving the length of the block from the perspective of
- * (clientId, refSeq) requires including both of the following types of segments:
- * 1. Segments sequenced before `refSeq`
- * 2. Segments submitted by `clientId`
- *
- * This is possible with the above bookkeeping, using:
- *
- * (length of the block at the minimum sequence number)
- * + (partialLengths total length at refSeq)
- * + (clientSeqNumbers total length at most recent op)
- * - (clientSeqNumbers total length at refSeq)
- *
- * where the subtraction avoids double-counting segments submitted by clientId sequenced within the collab window.
- *
- * To enable reconnect, if constructed with `computeLocalPartials === true` it also supports querying for the length of
- * the block from the perspective of the local client at a particular `refSeq` and `localSeq`. This computation is
- * similar to the above:
- *
- * (length of the block at the minimum sequence number)
- * + (partialLengths total length at refSeq)
- * + (unsequenced edits' total length submitted before localSeq)
- * - (overlapping remove of the unsequenced edits' total length at refSeq)
- *
- * This algorithm scales roughly linearly with number of editing clients and the size of the collab window.
- * (certain unlikely sequences of operations may introduce log factors on those variables)
- *
- * Note: there is some slight complication with clientSeqNumbers resulting from the possibility of different clients
- * concurrently removing the same segment. See the field's documentation for more details.
- */
-declare class PartialSequenceLengths {
-    /**
-     * The minimumSequenceNumber as defined by the collab window used in the last call to `update`,
-     * or if no such calls have been made, the one used on construction.
-     */
-    minSeq: number;
-    static options: PartialSequenceLengthsOptions;
-    /**
-     * Combine the partial lengths of block's children
-     * @param block - an interior node. If `recur` is false, it is assumed that each interior node child of this block
-     * has its partials up to date.
-     * @param collabWindow - segment window of the segment tree containing `block`.
-     * @param recur - whether to recursively compute partial lengths for internal children of `block`.
-     * This incurs more work, but gives correct bookkeeping in the case that a descendant in the merge tree has been
-     * modified without bubbling up the resulting partial length change to this block's partials.
-     * @param computeLocalPartials - whether to compute partial length information about local unsequenced ops.
-     * This enables querying for the length of the block at a given localSeq, but incurs extra work.
-     * Local partial information doesn't support `update`.
-     */
-    static combine(block: IMergeBlock, collabWindow: CollaborationWindow, recur?: boolean, computeLocalPartials?: boolean): PartialSequenceLengths;
-    /**
-     * @returns a PartialSequenceLengths structure which tracks only lengths of leaf children of the provided
-     * IMergeBlock.
-     */
-    private static fromLeaves;
-    private static getOverlapClients;
-    private static accumulateRemoveClientOverlap;
-    private static accumulateMoveClientOverlap;
-    /**
-     * Coalesce overlapping move lengths for a partial length entry that already
-     * exists
-     *
-     * @param segmentLen - Length of segment with overlapping moves
-     * @param segment - Segment with overlapping moves
-     * @param firstGte - Existing partial length entry
-     * @param clientIds - Ids of clients that concurrently obliterated this segment
-     */
-    static accumulateMoveOverlapForExisting(segmentLen: number, segment: ISegment, firstGte: PartialSequenceLength, clientIds: number[]): void;
-    /**
-     * @param obliterateOverlapLen - Length of segment with overlap
-     * @param clientIds - Ids of clients that have concurrently obliterated this
-     * segment
-     */
-    private static getMoveOverlapForExisting;
-    private static updatePartialsAfterInsertion;
-    /**
-     * Inserts length information about the insertion of `segment` into
-     * `combinedPartialLengths.partialLengths`.
-     *
-     * Does not update the clientSeqNumbers field to account for this segment.
-     *
-     * If `removalInfo` or `moveInfo` are defined, this operation updates the
-     * bookkeeping to account for the (re)moval of this segment at the (re)movedSeq
-     * instead.
-     *
-     * When the insertion or (re)moval of the segment is un-acked and
-     * `combinedPartialLengths` is meant to compute such records, this does the
-     * analogous addition to the bookkeeping for the local segment in
-     * `combinedPartialLengths.unsequencedRecords`.
-     */
-    private static insertSegment;
-    private static addSeq;
-    /**
-     * Length of the block this PartialSequenceLength corresponds to when viewed at `minSeq`.
-     */
-    private minLength;
-    /**
-     * Total number of segments in the subtree rooted at the block this PartialSequenceLength corresponds to.
-     */
-    private segmentCount;
-    /**
-     * List of PartialSequenceLength objects--ordered by increasing seq--giving length information about
-     * the block associated with this PartialSequenceLengths object.
-     *
-     * `partialLengths[i].len` contains the length of this block considering only sequenced segments with
-     * `sequenceNumber <= partialLengths[i].seq`.
-     */
-    private readonly partialLengths;
-    /**
-     * clientSeqNumbers[clientId] is a list of partial lengths for sequenced ops which either:
-     * - were submitted by `clientId`.
-     * - deleted a range containing segments that were concurrently deleted by `clientId`
-     *
-     * The second case is referred to as the "overlapping delete" case. It is necessary to avoid double-counting
-     * the removal of those segments in queries including clientId.
-     */
-    private readonly clientSeqNumbers;
-    /**
-     * Contains information required to answer queries for the length of this segment from the perspective of
-     * the local client but not including all local segments (i.e., `localSeq !== collabWindow.localSeq`).
-     * This field is only computed if requested in the constructor (i.e. `computeLocalPartials === true`).
-     */
-    private unsequencedRecords;
-    constructor(
-    /**
-     * The minimumSequenceNumber as defined by the collab window used in the last call to `update`,
-     * or if no such calls have been made, the one used on construction.
-     */
-    minSeq: number, computeLocalPartials: boolean);
-    update(node: IMergeBlock, seq: number, clientId: number, collabWindow: CollaborationWindow): void;
-    /**
-     * Returns the length of this block as viewed from the perspective of `clientId` at `refSeq`.
-     * This is the total length of all segments sequenced at or before refSeq OR submitted by `clientId`.
-     * If `clientId` is the local client, `localSeq` can also be provided. In that case, it is the total
-     * length of all segments submitted at or before `refSeq` in addition to any local, unacked segments
-     * with `segment.localSeq <= localSeq`.
-     *
-     * Note: the local case (where `localSeq !== undefined`) is only supported on a PartialSequenceLength object
-     * constructed with `computeLocalPartials` set to true and not subsequently updated with `update`.
-     */
-    getPartialLength(refSeq: number, clientId: number, localSeq?: number): number;
-    /**
-     * Computes the seglen for the double-counted removed overlap at (refSeq, localSeq). This logic is equivalent
-     * to the following:
-     *
-     * ```typescript
-     *   let total = 0;
-     *   for (const partialLength of this.unsequencedRecords!.overlappingRemoves) {
-     *       if (partialLength.seq > refSeq) {
-     *           break;
-     *       }
-     *
-     *      if (partialLength.localSeq <= localSeq) {
-     *          total += partialLength.seglen;
-     *      }
-     *   }
-     *
-     *   return total;
-     * ```
-     *
-     * Reconnect happens to only need to compute these lengths for two refSeq values: before and
-     * after the rebase. Since these lists potentially scale with O(collab window * number of local edits)
-     * and potentially need to be queried for each local op that gets rebased,
-     * we cache the results for a given refSeq in `this.unsequencedRecords.cachedOverlappingByRefSeq` so
-     * that they can be binary-searched the same way the usual partialLengths lists are.
-     */
-    private computeOverlappingLocalRemoves;
-    toString(glc?: (id: number) => string, indentCount?: number): string;
-    private zamboni;
-    private addClientSeqNumber;
-    private addClientSeqNumberFromPartial;
-    private cliLatestLEQ;
-    private cliLatest;
-}
-
-declare interface PartialSequenceLengthsOptions {
-    verifier?: (partialLengths: PartialSequenceLengths) => void;
-    verifyExpected?: (mergeTree: MergeTree, node: IMergeBlock, refSeq: number, clientId: number, localSeq?: number) => void;
-    zamboni: boolean;
-}
-
 /**
  * @alpha
  */
@@ -2425,7 +1684,7 @@ export declare function revertMergeTreeDeltaRevertibles(driver: MergeTreeReverti
  * @alpha
  */
 export declare interface SegmentGroup {
-    segments: ISegmentLeaf[];
+    segments: ISegment[];
     previousProps?: PropertySet[];
     localSeq?: number;
     refSeq: number;
@@ -2557,24 +1816,6 @@ export declare abstract class SortedSet<T, U extends string | number> {
     };
 }
 
-/**
- * The position immediately prior to the start of the tree
- */
-declare class StartOfTreeSegment extends BaseEndpointSegment implements ISegment, IRemovalInfo {
-    type: string;
-    readonly endpointType = "start";
-    /**
-     * this segment pretends to be a sibling of the first real segment.
-     * so compute the necessary properties to pretend to be that segment.
-     */
-    protected endpointSegmentProps(): {
-        parent: IMergeBlock;
-        index: number;
-        depth: number;
-    };
-    get ordinal(): string;
-}
-
 /**
  * @alpha
  */