@fluidframework/merge-tree 2.0.0-dev-rc.3.0.0.254513 → 2.0.0-dev-rc.3.0.0.254674

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

@@ -1,1921 +0,0 @@
-import { AttributionKey } from '@fluidframework/runtime-definitions/internal';
-import { IChannelStorageService } from '@fluidframework/datastore-definitions';
-import { IEventThisPlaceHolder } from '@fluidframework/core-interfaces';
-import { IFluidDataStoreRuntime } from '@fluidframework/datastore-definitions';
-import { IFluidHandle } from '@fluidframework/core-interfaces';
-import { IFluidSerializer } from '@fluidframework/shared-object-base';
-import { ISequencedDocumentMessage } from '@fluidframework/protocol-definitions';
-import { ISummaryTreeWithStats } from '@fluidframework/runtime-definitions';
-import { ITelemetryLoggerExt } from '@fluidframework/telemetry-utils';
-import { TypedEventEmitter } from '@fluid-internal/client-utils';
-
-/**
- * @deprecated This functionality was not intended for public export and will
- * be removed in a future release.
- * @internal
- */
-export declare function addProperties(oldProps: PropertySet | undefined, newProps: PropertySet): PropertySet;
-
-/**
- * @alpha
- */
-export declare function appendToMergeTreeDeltaRevertibles(deltaArgs: IMergeTreeDeltaCallbackArgs, revertibles: MergeTreeDeltaRevertible[]): void;
-
-/**
- * Implements policy dictating which kinds of operations should be attributed and how.
- * @sealed
- * @alpha
- */
-export declare interface AttributionPolicy {
-    /**
-     * Enables tracking attribution information for operations on this merge-tree.
-     * This function is expected to subscribe to appropriate change events in order
-     * to manage any attribution data it stores on segments.
-     *
-     * This must be done in an eventually consistent fashion.
-     */
-    attach: (client: Client) => void;
-    /**
-     * Disables tracking attribution information on segments.
-     */
-    detach: () => void;
-    /***/
-    isAttached: boolean;
-    /**
-     * Serializer capable of serializing any attribution data this policy stores on segments.
-     */
-    serializer: IAttributionCollectionSerializer;
-}
-
-/**
- * @alpha
- */
-export declare abstract class BaseSegment extends MergeNode implements ISegment {
-    clientId: number;
-    seq: number;
-    removedSeq?: number;
-    removedClientIds?: number[];
-    movedSeq?: number;
-    movedSeqs?: number[];
-    movedClientIds?: number[];
-    wasMovedOnInsert?: boolean | undefined;
-    readonly segmentGroups: SegmentGroupCollection;
-    readonly trackingCollection: TrackingGroupCollection;
-    /***/
-    attribution?: IAttributionCollection<AttributionKey>;
-    propertyManager?: PropertiesManager;
-    properties?: PropertySet;
-    localRefs?: LocalReferenceCollection;
-    abstract readonly type: string;
-    localSeq?: number;
-    localRemovedSeq?: number;
-    localMovedSeq?: number;
-    addProperties(newProps: PropertySet, seq?: number, collaborating?: boolean, rollback?: PropertiesRollback): PropertySet;
-    hasProperty(key: string): boolean;
-    isLeaf(): this is ISegment;
-    protected cloneInto(b: ISegment): void;
-    canAppend(segment: ISegment): boolean;
-    protected addSerializedProps(jseg: IJSONSegment): void;
-    abstract toJSONObject(): any;
-    /***/
-    ack(segmentGroup: SegmentGroup, opArgs: IMergeTreeDeltaOpArgs): boolean;
-    splitAt(pos: number): ISegment | undefined;
-    private copyPropertiesTo;
-    abstract clone(): ISegment;
-    append(other: ISegment): void;
-    protected abstract createSplitSegmentAt(pos: number): BaseSegment | undefined;
-}
-
-/**
- * @deprecated This functionality was not meant to be exported and will be removed in a future release
- * @alpha
- */
-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;
-    /**
-     * @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.
-     * This method peeks the tail of that queue, and returns the segments groups there.
-     * It is used to get the segment group(s) for the previous operations.
-     * @param count - The number segment groups to get peek from the tail of the queue. Default 1.
-     */
-    peekPendingSegmentGroups(): SegmentGroup | undefined;
-    peekPendingSegmentGroups(count: number): SegmentGroup | SegmentGroup[] | undefined;
-    /**
-     * Annotates the markers with the provided properties
-     * @param marker - The marker to annotate
-     * @param props - The properties to annotate the marker with
-     * @returns The annotate op if valid, otherwise undefined
-     */
-    annotateMarker(marker: Marker, props: PropertySet): IMergeTreeAnnotateMsg | undefined;
-    /**
-     * 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
-     * @returns The annotate op if valid, otherwise undefined
-     */
-    annotateRangeLocal(start: number, end: number, props: PropertySet): IMergeTreeAnnotateMsg | undefined;
-    /**
-     * Removes the range
-     *
-     * @param start - The inclusive start of the range to remove
-     * @param end - The exclusive end of the range to remove
-     */
-    removeRangeLocal(start: number, end: number): IMergeTreeRemoveMsg;
-    /**
-     * Obliterates the range. This is similar to removing the range, but also
-     * includes any concurrently inserted content.
-     *
-     * @param start - The inclusive start of the range to obliterate
-     * @param end - The exclusive end of the range to obliterate
-     */
-    obliterateRangeLocal(start: number, end: number): IMergeTreeObliterateMsg;
-    /**
-     * @param pos - The position to insert the segment at
-     * @param segment - The segment to insert
-     */
-    insertSegmentLocal(pos: number, segment: ISegment): IMergeTreeInsertMsg | undefined;
-    /**
-     * @param refPos - The reference position to insert the segment at
-     * @param segment - The segment to insert
-     */
-    insertAtReferencePositionLocal(refPos: ReferencePosition, segment: ISegment): IMergeTreeInsertMsg | undefined;
-    walkSegments<TClientData>(handler: ISegmentAction<TClientData>, start: number | undefined, end: number | undefined, accum: TClientData, splitRange?: boolean): void;
-    walkSegments<undefined>(handler: ISegmentAction<undefined>, start?: number, end?: number, accum?: undefined, splitRange?: boolean): void;
-    protected walkAllSegments<TClientData>(action: (segment: ISegment, accum?: TClientData) => boolean, accum?: TClientData): boolean;
-    /**
-     * Serializes the data required for garbage collection. The IFluidHandles stored in all segments that haven't
-     * been removed represent routes to other objects. We serialize the data in these segments using the passed in
-     * serializer which keeps track of all serialized handles.
-     */
-    serializeGCData(handle: IFluidHandle, handleCollectingSerializer: IFluidSerializer): void;
-    getCollabWindow(): CollaborationWindow;
-    /**
-     * Returns the current position of a segment, and -1 if the segment
-     * does not exist in this merge tree
-     * @param segment - The segment to get the position of
-     */
-    getPosition(segment: ISegment | undefined, localSeq?: number): number;
-    /**
-     * Creates a `LocalReferencePosition` on this client. 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
-     * @param canSlideToEndpoint - Whether or not the created local reference can
-     * slide onto one of the special endpoint segments denoting the position
-     * before the start of or after the end of the tree
-     */
-    createLocalReferencePosition(segment: ISegment | "start" | "end", offset: number | undefined, refType: ReferenceType, properties: PropertySet | undefined, slidingPreference?: SlidingPreference, canSlideToEndpoint?: boolean): LocalReferencePosition;
-    /**
-     * Removes a `LocalReferencePosition` from this client.
-     */
-    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;
-    /**
-     * 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;
-    getMarkerFromId(id: string): ISegment | undefined;
-    /**
-     * Revert an op
-     */
-    rollback?(op: any, localOpMetadata: unknown): void;
-    private applyObliterateRangeOp;
-    /**
-     * Performs the remove based on the provided op
-     * @param opArgs - The ops args for the op
-     */
-    private applyRemoveRangeOp;
-    /**
-     * Performs the annotate based on the provided op
-     * @param opArgs - The ops args for the op
-     */
-    private applyAnnotateRangeOp;
-    /**
-     * Performs the insert based on the provided op
-     * @param opArgs - The ops args for the op
-     * @returns True if the insert was applied. False if it could not be.
-     */
-    private applyInsertOp;
-    /**
-     * Returns a valid range for the op, or undefined
-     * @param op - The op to generate the range for
-     * @param clientArgs - The client args for the op
-     */
-    private getValidOpRange;
-    /**
-     * Gets the client args from the op if remote, otherwise uses the local clients info
-     * @param sequencedMessage - The sequencedMessage to get the client sequence args for
-     */
-    private getClientSequenceArgsForMessage;
-    /**
-     * Gets the client args from the op if remote, otherwise uses the local clients info
-     * @param opArgs - The op arg to get the client sequence args for
-     */
-    private getClientSequenceArgs;
-    private ackPendingSegment;
-    getOrAddShortClientId(longClientId: string): number;
-    protected getShortClientId(longClientId: string): number;
-    getLongClientId(shortClientId: number): string;
-    addLongClientId(longClientId: string): void;
-    private getOrAddShortClientIdFromMessage;
-    /**
-     * During reconnect, we must find the positions to pending segments
-     * relative to other pending segments. This methods computes that
-     * position relative to a localSeq. Pending segments above the localSeq
-     * will be ignored.
-     *
-     * @param segment - The segment to find the position for
-     * @param localSeq - The localSeq to find the position of the segment at
-     */
-    findReconnectionPosition(segment: ISegment, localSeq: number): number;
-    private resetPendingDeltaToOps;
-    private applyRemoteOp;
-    applyStashedOp(op: IMergeTreeOp): void;
-    applyMsg(msg: ISequencedDocumentMessage, local?: boolean): void;
-    private updateSeqNumbers;
-    /**
-     * Resolves a remote client's position against the local sequence
-     * and returns the remote client's position relative to the local
-     * sequence
-     * @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;
-    private lastNormalizationRefSeq;
-    private pendingRebase;
-    /**
-     * Given a pending operation and segment group, regenerate the op, so it
-     * can be resubmitted
-     * @param resetOp - The op to reset
-     * @param segmentGroup - The segment group associated with the op
-     */
-    regeneratePendingOp(resetOp: IMergeTreeOp, segmentGroup: SegmentGroup | SegmentGroup[]): IMergeTreeOp;
-    createTextHelper(): IMergeTreeTextHelper;
-    summarize(runtime: IFluidDataStoreRuntime, handle: IFluidHandle, serializer: IFluidSerializer, catchUpMsgs: ISequencedDocumentMessage[]): ISummaryTreeWithStats;
-    load(runtime: IFluidDataStoreRuntime, storage: IChannelStorageService, serializer: IFluidSerializer): Promise<{
-        catchupOpsP: Promise<ISequencedDocumentMessage[]>;
-    }>;
-    private getLocalSequenceNumber;
-    localTransaction(groupOp: IMergeTreeGroupMsg): void;
-    updateMinSeq(minSeq: number): void;
-    getContainingSegment<T extends ISegment>(pos: number, sequenceArgs?: Pick<ISequencedDocumentMessage, "referenceSequenceNumber" | "clientId">, localSeq?: number): {
-        segment: T | undefined;
-        offset: number | undefined;
-    };
-    getPropertiesAtPosition(pos: number): PropertySet | undefined;
-    getRangeExtentsOfPosition(pos: number): {
-        posStart: number | undefined;
-        posAfterEnd: number | undefined;
-    };
-    getCurrentSeq(): number;
-    getClientId(): number;
-    getLength(): number;
-    startOrUpdateCollaboration(longClientId: string | undefined, minSeq?: number, currentSeq?: number): void;
-    /**
-     * Searches a string for the nearest marker in either direction to a given start position.
-     * The search will include the start position, so markers at the start position are valid
-     * results of the search. Makes use of block-accelerated search functions for log(n) complexity.
-     *
-     * @param startPos - Position at which to start the search
-     * @param markerLabel - Label of the marker to search for
-     * @param forwards - Whether the desired marker comes before (false) or after (true) `startPos`
-     */
-    searchForMarker(startPos: number, markerLabel: string, forwards?: boolean): Marker | undefined;
-}
-
-/**
- * @deprecated This functionality was not meant to be exported and will be removed in a future release
- * @alpha
- */
-export declare class CollaborationWindow {
-    clientId: number;
-    collaborating: boolean;
-    /**
-     * Lowest-numbered segment in window; no client can reference a state before this one
-     */
-    minSeq: number;
-    /**
-     * Highest-numbered segment in window and current reference sequence number for this client.
-     */
-    currentSeq: number;
-    /**
-     * Highest-numbered localSeq used for a pending segment.
-     * Semantically, `localSeq`s provide an ordering on in-flight merge-tree operations:
-     * for operations stamped with localSeqs `a` and `b`, `a < b` if and only if `a` was submitted before `b`.
-     *
-     * @remarks - This field is analogous to the `clientSequenceNumber` field on ops, but it's accessible to merge-tree
-     * at op submission time rather than only at ack time. This enables more natural state tracking for in-flight ops.
-     *
-     * It's useful to stamp ops with such an incrementing counter because it enables reasoning about which segments existed from
-     * the perspective of the local client at a given point in 'un-acked' time, which is necessary to support the reconnect flow.
-     *
-     * For example, imagine a client with initial state "123456" submits some ops to create the text "123456ABC".
-     * If they insert the "C" first, then "B", then "A", their local segment state might look like this:
-     * ```js
-     * [
-     *     { seq: 0, text: "1234" },
-     *     { seq: 5, text: "56" },
-     *     { localSeq: 3, seq: UnassignedSequenceNumber, text: "A" },
-     *     { localSeq: 2, seq: UnassignedSequenceNumber, text: "B" },
-     *     { localSeq: 1, seq: UnassignedSequenceNumber, text: "C" },
-     * ]
-     * ```
-     * (note that {@link ISegment.localSeq} tracks the localSeq at which a segment was inserted)
-     *
-     * Suppose the client then disconnects and reconnects before any of its insertions are acked. The reconnect flow will necessitate
-     * that the client regenerates and resubmits ops based on its current segment state as well as the original op that was sent.
-     *
-     * It will generate the ops
-     * 1. \{ pos: 6, text: "C" \}
-     * 2. \{ pos: 6, text: "B" \}
-     * 3. \{ pos: 6, text: "A" \}
-     *
-     * since when submitting the first op, remote clients don't know that this client is about to submit the "A" and "B".
-     *
-     * On the other hand, imagine if the client had originally submitted the ops in the order "A", "B", "C"
-     * such that the segments' local state was instead:
-     *
-     * ```js
-     * [
-     *     { seq: 0, text: "1234" },
-     *     { seq: 5, text: "56" },
-     *     { localSeq: 1, seq: UnassignedSequenceNumber, text: "A" },
-     *     { localSeq: 2, seq: UnassignedSequenceNumber, text: "B" },
-     *     { localSeq: 3, seq: UnassignedSequenceNumber, text: "C" },
-     * ]
-     * ```
-     *
-     * The resubmitted ops should instead be:
-     * 1. \{ pos: 6, text: "A" \}
-     * 2. \{ pos: 7, text: "B" \}
-     * 3. \{ pos: 8, text: "C" \}
-     *
-     * since remote clients will have seen the "A" when processing the "B" as well as both the "A" and "B" when processing the "C".
-     * As can be seen, the list of resubmitted ops is different in the two cases despite the merge-tree's segment state only differing
-     * in `localSeq`.
-     *
-     * This example is a bit simplified from the general scenario: since no remote clients modified the merge-tree while the client
-     * was disconnected, the resubmitted ops end up matching the original ops exactly.
-     * However, this is not generally true: the production reconnect code takes into account visibility of segments based on both acked
-     * and local information as appropriate.
-     * Nonetheless, this simple scenario is enough to understand why it's useful to be able to determine if a segment should be visible
-     * from a given (seq, localSeq) perspective.
-     */
-    localSeq: number;
-    loadFrom(a: CollaborationWindow): void;
-}
-
-/**
- * @internal
- */
-export declare function compareReferencePositions(a: ReferencePosition, b: ReferencePosition): number;
-
-/**
- * @internal
- */
-export declare type ConflictAction<TKey, TData> = (key: TKey, currentKey: TKey, data: TData, currentData: TData) => QProperty<TKey, TData>;
-
-/**
- * Creates the op for annotating 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
- * @returns The annotate op
- *
- * @internal
- */
-export declare function createAnnotateRangeOp(start: number, end: number, props: PropertySet): IMergeTreeAnnotateMsg;
-
-/**
- * @internal
- */
-export declare function createDetachedLocalReferencePosition(refType?: ReferenceType): LocalReferencePosition;
-
-/**
- *
- * @param ops - The ops to group
- *
- * @deprecated The ability to create group ops will be removed in an upcoming
- * release, as group ops are redundant with he native batching capabilities of
- * the runtime
- *
- * @deprecated The ability to create group ops will be removed in an upcoming release, as group ops are redundant with he native batching capabilities of the runtime
- * @internal
- */
-export declare function createGroupOp(...ops: IMergeTreeDeltaOp[]): IMergeTreeGroupMsg;
-
-/**
- * @returns An {@link AttributionPolicy} which tracks only insertion of content.
- * @internal
- */
-export declare function createInsertOnlyAttributionPolicy(): AttributionPolicy;
-
-/**
- * @internal
- */
-export declare function createInsertOp(pos: number, segSpec: any): IMergeTreeInsertMsg;
-
-/**
- *
- * @param pos - The position to insert the segment at
- * @param segment - The segment to insert
- *
- * @internal
- */
-export declare function createInsertSegmentOp(pos: number, segment: ISegment): IMergeTreeInsertMsg;
-
-/**
- * @deprecated This functionality was not intended for public export and will
- * be removed in a future release.
- * @internal
- */
-export declare function createMap<T>(): MapLike<T>;
-
-/**
- * Creates the op to obliterate a range
- *
- * @param start - The inclusive start of the range to obliterate
- * @param end - The exclusive end of the range to obliterate
- *
- * @internal
- */
-export declare function createObliterateRangeOp(start: number, end: number): IMergeTreeObliterateMsg;
-
-/**
- * Creates an attribution policy which tracks insertion as well as annotation of certain property names.
- * This combines the policies creatable using {@link createPropertyTrackingAttributionPolicyFactory} and
- * {@link createInsertOnlyAttributionPolicy}: see there for more details.
- * @internal
- */
-export declare function createPropertyTrackingAndInsertionAttributionPolicyFactory(...propNames: string[]): () => AttributionPolicy;
-
-/**
- * @param propNames - List of property names for which attribution should be tracked.
- * @returns A policy which only attributes annotation of the properties specified.
- * Keys for each property are stored under attribution channels of the same name--see example below.
- *
- * @example
- *
- * ```typescript
- * // Use this policy when creating your merge-tree:
- * const policy = createPropertyTrackingAttributionPolicyFactory("bold", "italic");
- * // ... later, you can get attribution keys for the last time the "bold" and "italic"
- * // properties were changed on a segment using `getAtOffset`:
- * const lastBoldedAttributionKey = segment.attribution?.getAtOffset(0, "bold");
- * const lastItalicizedAttributionKey = segment.attribution?.getAtOffset(0, "italic");
- * ```
- * @internal
- */
-export declare function createPropertyTrackingAttributionPolicyFactory(...propNames: string[]): () => AttributionPolicy;
-
-/**
- * Creates the op to remove a range
- *
- * @param start - The inclusive start of the range to remove
- * @param end - The exclusive end of the range to remove
- *
- * @internal
- */
-export declare function createRemoveRangeOp(start: number, end: number): IMergeTreeRemoveMsg;
-
-/**
- * Get a human-readable string for a given {@link Marker}.
- *
- * @remarks This function is intended for debugging only. The exact format of
- * this string should not be relied upon between versions.
- * @internal
- */
-export declare function debugMarkerToString(marker: Marker): string;
-
-/**
- * @internal
- */
-export declare const DetachedReferencePosition = -1;
-
-/**
- * @internal
- */
-export declare interface Dictionary<TKey, TData> {
-    get(key: TKey): Property<TKey, TData> | undefined;
-    put(key: TKey, data: TData, conflict?: ConflictAction<TKey, TData>): void;
-    remove(key: TKey): void;
-    map<TAccum>(action: PropertyAction<TKey, TData>, accum?: TAccum): void;
-}
-
-/**
- * @alpha
- */
-export declare function discardMergeTreeDeltaRevertible(revertibles: MergeTreeDeltaRevertible[]): void;
-
-/**
- * Returns the position to slide a reference to if a slide is required.
- * @param segoff - The segment and offset to slide from
- * @returns segment and offset to slide the reference to
- * @internal
- */
-export declare function getSlideToSegoff(segoff: {
-    segment: ISegment | undefined;
-    offset: number | undefined;
-}, slidingPreference?: SlidingPreference, useNewSlidingBehavior?: boolean): {
-    segment: ISegment | undefined;
-    offset: number | undefined;
-};
-
-/**
- * @alpha
- */
-export declare interface IAttributionCollection<T> {
-    /**
-     * Retrieves the attribution key associated with the provided offset.
-     * @param channel - When specified, gets an attribution key associated with a particular channel.
-     */
-    getAtOffset(offset: number, channel?: string): AttributionKey | undefined;
-    /**
-     * Total length of all attribution keys in this collection.
-     */
-    readonly length: number;
-    readonly channelNames: Iterable<string>;
-    /**
-     * Retrieve all key/offset pairs stored on this segment. Entries should be ordered by offset, such that
-     * the `i`th result's attribution key applies to offsets in the open range between the `i`th offset and the
-     * `i+1`th offset.
-     * The last entry's key applies to the open interval from the last entry's offset to this collection's length.
-     */
-    getAll(): IAttributionCollectionSpec<T>;
-    /***/
-    splitAt(pos: number): IAttributionCollection<T>;
-    /***/
-    append(other: IAttributionCollection<T>): void;
-    /***/
-    clone(): IAttributionCollection<T>;
-    /**
-     * Updates this collection with new attribution data.
-     * @param name - Name of the channel that requires an update. Undefined signifies the root channel.
-     * Updates apply only to the individual channel (i.e. if an attribution policy needs to update the root
-     * channel and 4 other channels, it should call `.update` 5 times).
-     * @param channel - Updated collection for that channel.
-     */
-    update(name: string | undefined, channel: IAttributionCollection<T>): void;
-}
-
-/**
- * @alpha
- * @sealed
- */
-export declare interface IAttributionCollectionSerializer {
-    /***/
-    serializeAttributionCollections(segments: Iterable<{
-        attribution?: IAttributionCollection<AttributionKey>;
-        cachedLength: number;
-    }>): SerializedAttributionCollection;
-    /**
-     * Populates attribution information on segments using the provided summary.
-     */
-    populateAttributionCollections(segments: Iterable<ISegment>, summary: SerializedAttributionCollection): void;
-}
-
-/**
- * @alpha
- */
-export declare interface IAttributionCollectionSpec<T> {
-    root: Iterable<{
-        offset: number;
-        key: T | null;
-    }>;
-    channels?: {
-        [name: string]: Iterable<{
-            offset: number;
-            key: T | null;
-        }>;
-    };
-    length: number;
-}
-
-/**
- * Emitted before this client's merge-tree normalizes its segments on reconnect, potentially
- * ordering them. Useful for DDS-like consumers built atop the merge-tree to compute any information
- * they need for rebasing their ops on reconnection.
- * @alpha
- */
-export declare interface IClientEvents {
-    (event: "normalize", listener: (target: IEventThisPlaceHolder) => void): void;
-    (event: "delta", listener: (opArgs: IMergeTreeDeltaOpArgs, deltaArgs: IMergeTreeDeltaCallbackArgs, target: IEventThisPlaceHolder) => void): void;
-    (event: "maintenance", listener: (args: IMergeTreeMaintenanceCallbackArgs, deltaArgs: IMergeTreeDeltaOpArgs | undefined, target: IEventThisPlaceHolder) => void): void;
-}
-
-/**
- * @alpha
- */
-export declare interface IJSONMarkerSegment extends IJSONSegment {
-    marker: IMarkerDef;
-}
-
-/**
- * @alpha
- */
-export declare interface IJSONSegment {
-    props?: Record<string, any>;
-}
-
-/**
- * @alpha
- */
-export declare interface IJSONTextSegment extends IJSONSegment {
-    text: string;
-}
-
-/**
- * @alpha
- */
-export declare interface IMarkerDef {
-    refType?: ReferenceType;
-}
-
-/**
- * Common properties for a node in a merge tree.
- * @alpha
- */
-export declare interface IMergeNodeCommon {
-    /**
-     * The index of this node in its parent's list of children.
-     */
-    index: number;
-    /**
-     * A string that can be used for comparing the location of this node to other `MergeNode`s in the same tree.
-     * `a.ordinal < b.ordinal` if and only if `a` comes before `b` in a pre-order traversal of the tree.
-     */
-    ordinal: string;
-    isLeaf(): this is ISegment;
-}
-
-/**
- * @alpha
- */
-export declare interface IMergeTreeAnnotateMsg extends IMergeTreeDelta {
-    type: typeof MergeTreeDeltaType.ANNOTATE;
-    pos1?: number;
-    relativePos1?: IRelativePosition;
-    pos2?: number;
-    relativePos2?: IRelativePosition;
-    props: Record<string, any>;
-}
-
-/**
- * @alpha
- */
-export declare interface IMergeTreeAttributionOptions {
-    /**
-     * If enabled, segments will store attribution keys which can be used with the runtime to determine
-     * attribution information (i.e. who created the content and when it was created).
-     *
-     * This flag only applied to new documents: if a snapshot is loaded, whether or not attribution keys
-     * are tracked is determined by the presence of existing attribution keys in the snapshot.
-     *
-     * default: false
-     */
-    track?: boolean;
-    /**
-     * Provides a policy for how to track attribution data on segments.
-     * This option must be provided if either:
-     * - `track` is set to true
-     * - a document containing existing attribution information is loaded
-     */
-    policyFactory?: () => AttributionPolicy;
-}
-
-/**
- * @internal
- */
-export declare interface IMergeTreeClientSequenceArgs {
-    readonly clientId: number;
-    readonly referenceSequenceNumber: number;
-    readonly sequenceNumber: number;
-}
-
-/**
- * @alpha
- */
-export declare interface IMergeTreeDelta {
-    /**
-     * Type of this change.
-     */
-    type: MergeTreeDeltaType;
-}
-
-/**
- * @alpha
- */
-export declare interface IMergeTreeDeltaCallbackArgs<TOperationType extends MergeTreeDeltaOperationTypes = MergeTreeDeltaOperationType> {
-    readonly operation: TOperationType;
-    readonly deltaSegments: IMergeTreeSegmentDelta[];
-}
-
-/**
- * @alpha
- */
-export declare type IMergeTreeDeltaOp = IMergeTreeInsertMsg | IMergeTreeRemoveMsg | IMergeTreeAnnotateMsg | IMergeTreeObliterateMsg;
-
-/**
- * @alpha
- */
-export declare interface IMergeTreeDeltaOpArgs {
-    /**
-     * The group op which contains the operation
-     * if there operation is part of a group op.
-     */
-    readonly groupOp?: IMergeTreeGroupMsg;
-    /**
-     * The merge tree operation
-     */
-    readonly op: IMergeTreeOp;
-    /**
-     * Get the sequence message, should only be null if the
-     * Delta op args are for an unacked local change
-     */
-    readonly sequencedMessage?: ISequencedDocumentMessage;
-}
-
-/**
- * @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
- *
- * @alpha
- */
-export declare interface IMergeTreeGroupMsg extends IMergeTreeDelta {
-    type: typeof MergeTreeDeltaType.GROUP;
-    ops: IMergeTreeDeltaOp[];
-}
-
-/**
- * @alpha
- */
-export declare interface IMergeTreeInsertMsg extends IMergeTreeDelta {
-    type: typeof MergeTreeDeltaType.INSERT;
-    pos1?: number;
-    relativePos1?: IRelativePosition;
-    pos2?: number;
-    relativePos2?: IRelativePosition;
-    seg?: any;
-}
-
-/**
- * @alpha
- */
-export declare interface IMergeTreeMaintenanceCallbackArgs extends IMergeTreeDeltaCallbackArgs<MergeTreeMaintenanceType> {
-}
-
-/**
- * @deprecated We no longer intend to support this functionality and it will
- * be removed in a future release. There is no replacement for this
- * functionality.
- * @alpha
- */
-export declare interface IMergeTreeObliterateMsg extends IMergeTreeDelta {
-    type: typeof MergeTreeDeltaType.OBLITERATE;
-    pos1?: number;
-    /**
-     * This field is currently unused, but we keep it around to make the union
-     * type of all merge-tree messages have the same fields
-     */
-    relativePos1?: never;
-    pos2?: number;
-    /**
-     * This field is currently unused, but we keep it around to make the union
-     * type of all merge-tree messages have the same fields
-     */
-    relativePos2?: never;
-}
-
-/**
- * @alpha
- */
-export declare type IMergeTreeOp = IMergeTreeDeltaOp | IMergeTreeGroupMsg;
-
-/**
- * @alpha
- */
-export declare interface IMergeTreeOptions {
-    catchUpBlobName?: string;
-    /**
-     * Whether or not reference positions can slide to special endpoint segments
-     * denoting the positions immediately before the start and immediately after
-     * the end of the string.
-     *
-     * This is primarily useful in the case of interval stickiness.
-     */
-    mergeTreeReferencesCanSlideToEndpoint?: boolean;
-    mergeTreeSnapshotChunkSize?: number;
-    /**
-     * Whether to use the SnapshotV1 format over SnapshotLegacy.
-     *
-     * SnapshotV1 stores a view of the merge-tree at the current sequence number, preserving merge metadata
-     * (e.g. clientId, seq, etc.) only for segment changes within the collab window.
-     *
-     * SnapshotLegacy stores a view of the merge-tree at the minimum sequence number along with the ops between
-     * the minimum sequence number and the current sequence number.
-     *
-     * Both formats merge segments where possible (see {@link ISegment.canAppend})
-     *
-     * default: false
-     *
-     * @remarks
-     * Despite the "legacy"/"V1" naming, both formats are actively used at the time of writing. SharedString
-     * uses legacy and Matrix uses V1.
-     */
-    newMergeTreeSnapshotFormat?: boolean;
-    /**
-     * Options related to attribution
-     */
-    attribution?: IMergeTreeAttributionOptions;
-    /**
-     * Enables support for the obliterate operation -- a stronger form of remove
-     * which deletes concurrently inserted segments
-     *
-     * Obliterate is currently experimental and may not work in all scenarios.
-     *
-     * Default value: false
-     */
-    mergeTreeEnableObliterate?: boolean;
-}
-
-/**
- * @alpha
- */
-export declare interface IMergeTreeRemoveMsg extends IMergeTreeDelta {
-    type: typeof MergeTreeDeltaType.REMOVE;
-    pos1?: number;
-    relativePos1?: IRelativePosition;
-    pos2?: number;
-    relativePos2?: IRelativePosition;
-}
-
-/**
- * @alpha
- */
-export declare interface IMergeTreeSegmentDelta {
-    segment: ISegment;
-    propertyDeltas?: PropertySet;
-}
-
-/**
- * @deprecated This functionality was not meant to be exported and will be removed in a future release
- * @alpha
- */
-export declare interface IMergeTreeTextHelper {
-    getText(refSeq: number, clientId: number, placeholder: string, start?: number, end?: number): string;
-}
-
-/**
- * Tracks information about when and where this segment was moved to.
- *
- * Note that merge-tree does not currently support moving and only supports
- * obliterate. The fields below include "move" in their names to avoid renaming
- * in the future, when moves _are_ supported.
- * @alpha
- */
-export declare interface IMoveInfo {
-    /**
-     * Local seq at which this segment was moved if the move is yet-to-be
-     * acked.
-     */
-    localMovedSeq?: number;
-    /**
-     * The first seq at which this segment was moved.
-     */
-    movedSeq: number;
-    /**
-     * All seqs at which this segment was moved. In the case of overlapping,
-     * concurrent moves this array will contain multiple seqs.
-     *
-     * The seq at  `movedSeqs[i]` corresponds to the client id at `movedClientIds[i]`.
-     *
-     * The first element corresponds to the seq of the first move
-     */
-    movedSeqs: number[];
-    /**
-     * A reference to the inserted destination segment corresponding to this
-     * segment's move.
-     *
-     * If undefined, the move was an obliterate.
-     *
-     * Currently this field is unused, as we only support obliterate operations
-     */
-    moveDst?: ReferencePosition;
-    /**
-     * List of client IDs that have moved this segment.
-     *
-     * The client that actually moved the segment (i.e. whose move op was sequenced
-     * first) is stored as the first client in this list. Other clients in the
-     * list have all issued concurrent ops to move the segment.
-     */
-    movedClientIds: number[];
-    /**
-     * If this segment was inserted into a concurrently moved range and
-     * the move op was sequenced before the insertion op. In this case,
-     * the segment is visible only to the inserting client
-     *
-     * `wasMovedOnInsert` only applies for acked obliterates. That is, if
-     * a segment inserted by a remote client is moved on insertion by a local
-     * and unacked obliterate, we do not consider it as having been moved
-     * on insert
-     *
-     * If a segment is moved on insertion, its length is only ever visible to
-     * the client that inserted the segment. This is relevant in partial length
-     * calculations
-     */
-    wasMovedOnInsert: boolean;
-}
-
-/**
- * @internal
- */
-export declare interface IRBAugmentation<TKey, TData> {
-    update(node: RBNode<TKey, TData>): void;
-}
-
-/**
- * @internal
- */
-export declare interface IRBMatcher<TKey, TData> {
-    continueSubtree(node: RBNode<TKey, TData> | undefined, key: TKey): boolean;
-    matchNode(node: RBNode<TKey, TData> | undefined, key: TKey): boolean;
-}
-
-/**
- * A position specified relative to a segment.
- * @alpha
- */
-export declare interface IRelativePosition {
-    /**
-     * String identifier specifying a segment.
-     */
-    id?: string;
-    /**
-     * If true, insert before the specified segment.  If false or not defined,
-     * insert after the specified segment.
-     */
-    before?: boolean;
-    /**
-     * A positive number \>= 1.  If before is false, offset is added to the position.
-     * If before is true, offset is subtracted from the position.
-     */
-    offset?: number;
-}
-
-/**
- * Contains removal information associated to an {@link ISegment}.
- * @alpha
- */
-export declare interface IRemovalInfo {
-    /**
-     * Local seq at which this segment was removed, if the removal is yet-to-be acked.
-     */
-    localRemovedSeq?: number;
-    /**
-     * Seq at which this segment was removed.
-     */
-    removedSeq: number;
-    /**
-     * List of client IDs that have removed this segment.
-     * The client that actually removed the segment (i.e. whose removal op was sequenced first) is stored as the first
-     * client in this list. Other clients in the list have all issued concurrent ops to remove the segment.
-     * @remarks When this list has length \> 1, this is referred to as the "overlapping remove" case.
-     */
-    removedClientIds: number[];
-}
-
-/**
- * A segment representing a portion of the merge tree.
- * Segments are leaf nodes of the merge tree and contain data.
- * @alpha
- */
-export declare interface ISegment extends IMergeNodeCommon, Partial<IRemovalInfo>, Partial<IMoveInfo> {
-    readonly type: string;
-    readonly segmentGroups: SegmentGroupCollection;
-    readonly trackingCollection: TrackingGroupCollection;
-    /**
-     * Whether or not this segment is a special segment denoting the start or
-     * end of the tree
-     *
-     * Endpoint segments are imaginary segments positioned immediately before or
-     * after the tree. These segments cannot be referenced by regular operations
-     * and exist primarily as a bucket for local references to slide onto during
-     * deletion of regular segments.
-     */
-    readonly endpointType?: "start" | "end";
-    /**
-     * The length of the contents of the node.
-     */
-    cachedLength: number;
-    /**
-     * Stores attribution keys associated with offsets of this segment.
-     * This data is only persisted if MergeTree's `attributions.track` flag is set to true.
-     * Pending segments (i.e. ones that only exist locally and haven't been acked by the server) also have
-     * `attribution === undefined` until ack.
-     *
-     * Keys can be used opaquely with an IAttributor or a container runtime that provides attribution.
-     * @remarks There are plans to make the shape of the data stored extensible in a couple ways:
-     *
-     * 1. Injection of custom attribution information associated with the segment (ex: copy-paste of
-     * content but keeping the old attribution information).
-     *
-     * 2. Storage of multiple "channels" of information (ex: track property changes separately from insertion,
-     * or only attribute certain property modifications, etc.)
-     */
-    attribution?: IAttributionCollection<AttributionKey>;
-    /**
-     * Manages pending local state for properties on this segment.
-     */
-    propertyManager?: PropertiesManager;
-    /**
-     * Local seq at which this segment was inserted.
-     * This is defined if and only if the insertion of the segment is pending ack, i.e. `seq` is UnassignedSequenceNumber.
-     * Once the segment is acked, this field is cleared.
-     *
-     * See {@link CollaborationWindow.localSeq} for more information on the semantics of localSeq.
-     */
-    localSeq?: number;
-    /**
-     * Local seq at which this segment was removed. If this is defined, `removedSeq` will initially be set to
-     * UnassignedSequenceNumber. However, if another client concurrently removes the same segment, `removedSeq`
-     * will be updated to the seq at which that client removed this segment.
-     *
-     * Like {@link ISegment.localSeq}, this field is cleared once the local removal of the segment is acked.
-     * See {@link CollaborationWindow.localSeq} for more information on the semantics of localSeq.
-     */
-    localRemovedSeq?: number;
-    /**
-     * Seq at which this segment was inserted.
-     * If undefined, it is assumed the segment was inserted prior to the collab window's minimum sequence number.
-     */
-    seq?: number;
-    /**
-     * Short clientId for the client that inserted this segment.
-     */
-    clientId: number;
-    /**
-     * Local references added to this segment.
-     */
-    localRefs?: LocalReferenceCollection;
-    /**
-     * Properties that have been added to this segment via annotation.
-     */
-    properties?: PropertySet;
-    /**
-     * Add properties to this segment via annotation.
-     *
-     * @remarks This function should not be called directly. Properties should
-     * be added through the `annotateRange` functions.
-     */
-    addProperties(newProps: PropertySet, seq?: number, collaborating?: boolean, rollback?: PropertiesRollback): PropertySet;
-    clone(): ISegment;
-    canAppend(segment: ISegment): boolean;
-    append(segment: ISegment): void;
-    splitAt(pos: number): ISegment | undefined;
-    toJSONObject(): any;
-    /**
-     * Acks the current segment against the segment group, op, and merge tree.
-     *
-     * @param segmentGroup - Pending segment group associated with this op.
-     * @param opArgs - Information about the op that was acked
-     * @returns `true` if the op modifies the segment, otherwise `false`.
-     * The only current false case is overlapping remove, where a segment is removed
-     * by a previously sequenced operation before the current operation is acked.
-     * @throws - error if the segment state doesn't match segment group or op.
-     * E.g. if the segment group is not first in the pending queue, or
-     * an inserted segment does not have unassigned sequence number.
-     */
-    ack(segmentGroup: SegmentGroup, opArgs: IMergeTreeDeltaOpArgs): boolean;
-}
-
-/**
- * @alpha
- */
-export declare interface ISegmentAction<TClientData> {
-    (segment: ISegment, pos: number, refSeq: number, clientId: number, start: number, end: number, accum: TClientData): boolean;
-}
-
-/**
- * Tests whether x is a MergeTreeDeltaRevertible
- * @internal
- */
-export declare function isMergeTreeDeltaRevertible(x: unknown): x is MergeTreeDeltaRevertible;
-
-/**
- * @alpha
- */
-export declare interface ITrackingGroup {
-    tracked: readonly Trackable[];
-    size: number;
-    has(trackable: Trackable): boolean;
-    link(trackable: Trackable): void;
-    unlink(trackable: Trackable): boolean;
-}
-
-/**
- * @internal
- */
-export declare interface KeyComparer<TKey> {
-    (a: TKey, b: TKey): number;
-}
-
-/**
- * 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;
-    /***/
-    private constructor();
-    /**
-     * @remarks This method should only be called by mergeTree.
-     */
-    [Symbol.iterator](): {
-        next(): IteratorResult<LocalReferencePosition>;
-        [Symbol.iterator](): any;
-    };
-    /**
-     * @remarks This method should only be called by mergeTree.
-     */
-    get empty(): boolean;
-    /**
-     * @remarks This method should only be called by mergeTree.
-     */
-    createLocalRef(offset: number, refType: ReferenceType, properties: PropertySet | undefined, slidingPreference?: SlidingPreference, canSlideToEndpoint?: boolean): LocalReferencePosition;
-    /**
-     * @remarks This method should only be called by mergeTree.
-     */
-    addLocalRef(lref: LocalReferencePosition, offset: number): void;
-    /**
-     * @remarks This method should only be called by mergeTree.
-     */
-    removeLocalRef(lref: LocalReferencePosition): LocalReferencePosition | undefined;
-    /**
-     *
-     * Called by 'append()' implementations to append local refs from the given 'other' segment to the
-     * end of 'this' segment.
-     *
-     * Note: This method should be invoked after the caller has ensured that segments can be merged,
-     * but before 'this' segment's cachedLength has changed, or the adjustment to the local refs
-     * will be incorrect.
-     *
-     * @remarks This method should only be called by mergeTree.
-     */
-    append(other: LocalReferenceCollection): void;
-    /**
-     * Returns true of the local reference is in the collection, otherwise false.
-     *
-     * @remarks This method should only be called by mergeTree.
-     */
-    has(lref: ReferencePosition): boolean;
-    /**
-     * Splits this `LocalReferenceCollection` into the intervals [0, offset) and [offset, originalLength).
-     * Local references in the former half of this split will remain associated with the segment used on construction.
-     * Local references in the latter half of this split will be transferred to `splitSeg`,
-     * and its `localRefs` field will be set.
-     * @param offset - Offset into the original segment at which the collection should be split
-     * @param splitSeg - Split segment which originally corresponded to the indices [offset, originalLength)
-     * before splitting.
-     *
-     * @remarks This method should only be called by mergeTree.
-     */
-    split(offset: number, splitSeg: ISegment): void;
-    /**
-     * @remarks This method should only be called by mergeTree.
-     */
-    addBeforeTombstones(...refs: Iterable<LocalReferencePosition>[]): void;
-    /**
-     * @remarks This method should only be called by mergeTree.
-     */
-    addAfterTombstones(...refs: Iterable<LocalReferencePosition>[]): void;
-    /**
-     * @remarks This method should only be called by mergeTree.
-     */
-    isAfterTombstone(lref: LocalReferencePosition): boolean;
-    /**
-     * @remarks This method should only be called by mergeTree.
-     */
-    walkReferences(visitor: (lref: LocalReferencePosition) => boolean | void | undefined, start?: LocalReferencePosition, forward?: boolean): boolean;
-}
-
-/**
- * @sealed
- * @alpha
- */
-export declare interface LocalReferencePosition extends ReferencePosition {
-    callbacks?: Partial<Record<"beforeSlide" | "afterSlide", (ref: LocalReferencePosition) => void>>;
-    readonly trackingCollection: TrackingGroupCollection;
-    /**
-     * Whether or not this reference position can slide onto one of the two
-     * special segments representing the position before or after the tree
-     */
-    readonly canSlideToEndpoint?: boolean;
-}
-
-/**
- * Any mapping from a string to values of type `T`
- * @alpha
- */
-export declare interface MapLike<T> {
-    [index: string]: T;
-}
-
-/**
- * Markers are a special kind of segment that do not hold any content.
- *
- * Markers with a reference type of {@link ReferenceType.Tile} support spatially
- * accelerated queries for finding the next marker to the left or right of it in
- * sub-linear time. This is useful, for example, in the case of jumping from the
- * start of a paragraph to the end, assuming a paragraph is bound by markers at
- * the start and end.
- *
- * @alpha
- */
-export declare class Marker extends BaseSegment implements ReferencePosition, ISegment {
-    refType: ReferenceType;
-    static readonly type = "Marker";
-    static is(segment: ISegment): segment is Marker;
-    readonly type = "Marker";
-    static make(refType: ReferenceType, props?: PropertySet): Marker;
-    constructor(refType: ReferenceType);
-    toJSONObject(): IJSONMarkerSegment;
-    static fromJSONObject(spec: any): Marker | undefined;
-    clone(): Marker;
-    getSegment(): this;
-    getOffset(): number;
-    getProperties(): PropertySet | undefined;
-    getId(): string | undefined;
-    toString(): string;
-    protected createSplitSegmentAt(pos: number): undefined;
-    canAppend(segment: ISegment): boolean;
-    append(): void;
-}
-
-/**
- * @internal
- */
-export declare function matchProperties(a: PropertySet | undefined, b: PropertySet | undefined): boolean;
-
-/**
- * @internal
- */
-export declare function maxReferencePosition<T extends ReferencePosition>(a: T, b: T): T;
-
-/**
- * @alpha
- */
-export declare class MergeNode implements IMergeNodeCommon {
-    index: number;
-    ordinal: string;
-    cachedLength: number;
-    isLeaf(): this is ISegment;
-}
-
-/**
- * @alpha
- */
-export declare type MergeTreeDeltaOperationType = typeof MergeTreeDeltaType.ANNOTATE | typeof MergeTreeDeltaType.INSERT | typeof MergeTreeDeltaType.REMOVE | typeof MergeTreeDeltaType.OBLITERATE;
-
-/**
- * @alpha
- */
-export declare type MergeTreeDeltaOperationTypes = MergeTreeDeltaOperationType | MergeTreeMaintenanceType;
-
-/**
- * @alpha
- */
-export declare type MergeTreeDeltaRevertible = {
-    operation: typeof MergeTreeDeltaType.INSERT;
-    trackingGroup: ITrackingGroup;
-} | {
-    operation: typeof MergeTreeDeltaType.REMOVE;
-    trackingGroup: ITrackingGroup;
-} | {
-    operation: typeof MergeTreeDeltaType.ANNOTATE;
-    trackingGroup: ITrackingGroup;
-    propertyDeltas: PropertySet;
-};
-
-/**
- * @alpha
- */
-export declare const MergeTreeDeltaType: {
-    readonly INSERT: 0;
-    readonly REMOVE: 1;
-    readonly ANNOTATE: 2;
-    /**
-     * @deprecated The ability to create group ops will be removed in an upcoming release, as group ops are redundant with he native batching capabilities of the runtime
-     */
-    readonly GROUP: 3;
-    readonly OBLITERATE: 4;
-};
-
-/**
- * @alpha
- */
-export declare type MergeTreeDeltaType = (typeof MergeTreeDeltaType)[keyof typeof MergeTreeDeltaType];
-
-/**
- * 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.
- *
- * Note: these values are assigned negative integers to avoid clashing with `MergeTreeDeltaType`.
- * @alpha
- */
-export declare const MergeTreeMaintenanceType: {
-    /**
-     * Notification that a segment "append" has occurred, i.e. two adjacent segments have been merged.
-     * BEWARE: `deltaSegments` on the corresponding event will contain both the merged segment and the latter
-     * segment, pre-merge.
-     * For example, if the merge tree originally had two adjacent segments [A][B] and called A.append(B) to get
-     * segment [AB], `deltaSegments` would contain [AB] and [B].
-     */
-    readonly APPEND: -1;
-    /**
-     * Notification that a segment has been split in two.
-     * `deltaSegments` on the corresponding event will contain the resulting two segments.
-     */
-    readonly SPLIT: -2;
-    /**
-     * Notification that a segment has been unlinked (i.e. removed) from the MergeTree.
-     * This occurs on leaf segments during Zamboni when the segment's tracking collection is empty
-     * (e.g., not being tracked for undo/redo).
-     * It also occurs on internal merge tree segments when re-packing children to maintain tree balancing invariants.
-     */
-    readonly UNLINK: -3;
-    /**
-     * Notification that a local change has been acknowledged by the server.
-     * This means that it has made the round trip to the server and has had a sequence number assigned.
-     */
-    readonly ACKNOWLEDGED: -4;
-};
-
-/**
- * @alpha
- */
-export declare type MergeTreeMaintenanceType = (typeof MergeTreeMaintenanceType)[keyof typeof MergeTreeMaintenanceType];
-
-/**
- * @alpha
- */
-export declare interface MergeTreeRevertibleDriver {
-    insertFromSpec(pos: number, spec: IJSONSegment): void;
-    removeRange(start: number, end: number): void;
-    annotateRange(start: number, end: number, props: PropertySet): void;
-}
-
-/**
- * @internal
- */
-export declare function minReferencePosition<T extends ReferencePosition>(a: T, b: T): T;
-
-/**
- * @alpha
- */
-export declare class PropertiesManager {
-    private pendingKeyUpdateCount;
-    ackPendingProperties(annotateOp: IMergeTreeAnnotateMsg): void;
-    private decrementPendingCounts;
-    addProperties(oldProps: PropertySet, newProps: PropertySet, seq?: number, collaborating?: boolean, rollback?: PropertiesRollback): PropertySet;
-    copyTo(oldProps: PropertySet, newProps: PropertySet | undefined, newManager: PropertiesManager): PropertySet | undefined;
-    hasPendingProperties(): boolean;
-    hasPendingProperty(key: string): boolean;
-}
-
-/**
- * @alpha
- */
-export declare enum PropertiesRollback {
-    /** Not in a rollback */
-    None = 0,
-    /** Rollback */
-    Rollback = 1
-}
-
-/**
- * @internal
- */
-export declare interface Property<TKey, TData> {
-    key: TKey;
-    data: TData;
-}
-
-/**
- * @internal
- */
-export declare interface PropertyAction<TKey, TData> {
-    <TAccum>(p: Property<TKey, TData>, accum?: TAccum): boolean;
-}
-
-/**
- * A loosely-typed mapping from strings to any value.
- *
- * @remarks Property sets are expected to be JSON-stringify-able.
- *
- * @privateRemarks PropertySet is typed using `any` because when you include
- * custom methods such as toJSON(), JSON.stringify accepts most types other than
- * functions
- * @alpha
- */
-export declare type PropertySet = MapLike<any>;
-
-/**
- * @internal
- */
-export declare interface QProperty<TKey, TData> {
-    key?: TKey;
-    data?: TData;
-}
-
-/**
- * @internal
- */
-export declare const RBColor: {
-    readonly RED: 0;
-    readonly BLACK: 1;
-};
-
-/**
- * @internal
- */
-export declare type RBColor = (typeof RBColor)[keyof typeof RBColor];
-
-/**
- * @internal
- */
-export declare interface RBNode<TKey, TData> {
-    key: TKey;
-    data: TData;
-    left: RBNode<TKey, TData> | undefined;
-    right: RBNode<TKey, TData> | undefined;
-    color: RBColor;
-    size: number;
-}
-
-/**
- * @internal
- */
-export declare interface RBNodeActions<TKey, TData> {
-    infix?(node: RBNode<TKey, TData>): boolean;
-    pre?(node: RBNode<TKey, TData>): boolean;
-    post?(node: RBNode<TKey, TData>): boolean;
-    showStructure?: boolean;
-}
-
-/**
- * @internal
- */
-export declare class RedBlackTree<TKey, TData> implements SortedDictionary<TKey, TData> {
-    private readonly compareKeys;
-    private readonly aug?;
-    private root;
-    constructor(compareKeys: KeyComparer<TKey>, aug?: IRBAugmentation<TKey, TData> | undefined);
-    private makeNode;
-    private isRed;
-    private nodeSize;
-    size(): number;
-    isEmpty(): boolean;
-    get(key: TKey): RBNode<TKey, TData> | undefined;
-    private nodeGet;
-    private contains;
-    gather(key: TKey, matcher: IRBMatcher<TKey, TData>): RBNode<TKey, TData>[];
-    private nodeGather;
-    walkExactMatchesForward(compareFn: (node: RBNode<TKey, TData>) => number, actionFn: (node: RBNode<TKey, TData>) => void, continueLeftFn: (number: number) => boolean, continueRightFn: (number: number) => boolean): void;
-    private nodeWalkExactMatchesForward;
-    walkExactMatchesBackward(compareFn: (node: RBNode<TKey, TData>) => number, actionFn: (node: RBNode<TKey, TData>) => void, continueLeftFn: (number: number) => boolean, continueRightFn: (number: number) => boolean): void;
-    private nodeWalkExactMatchesBackward;
-    put(key: TKey, data: TData, conflict?: ConflictAction<TKey, TData>): void;
-    private nodePut;
-    private updateLocal;
-    private nodeRemoveMin;
-    remove(key: TKey): void;
-    removeExisting(key: TKey): void;
-    private nodeRemove;
-    /**
-     * @returns The largest node in this tree which compares less than or equal to `key`
-     */
-    floor(key: TKey): RBNode<TKey, TData> | undefined;
-    private nodeFloor;
-    /**
-     * @returns The smallest node in this tree which compares greater than or equal to `key`
-     */
-    ceil(key: TKey): RBNode<TKey, TData> | undefined;
-    private nodeCeil;
-    min(): RBNode<TKey, TData> | undefined;
-    private nodeMin;
-    max(): RBNode<TKey, TData> | undefined;
-    private nodeMax;
-    private rotateRight;
-    private rotateLeft;
-    private oppositeColor;
-    private flipColors;
-    private moveRedLeft;
-    private moveRedRight;
-    private balance;
-    mapRange<TAccum>(action: PropertyAction<TKey, TData>, accum?: TAccum, start?: TKey, end?: TKey): void;
-    map<TAccum>(action: PropertyAction<TKey, TData>, accum?: TAccum): void;
-    keys(): TKey[];
-    /**
-     * Depth-first traversal with custom action; if action returns
-     * false, traversal is halted.
-     * @param action - action to apply to each node
-     */
-    walk(actions: RBNodeActions<TKey, TData>): void;
-    walkBackward(actions: RBNodeActions<TKey, TData>): void;
-    private nodeWalk;
-    private nodeWalkBackward;
-    private nodeMap;
-}
-
-/**
- * Represents a reference to a place within a merge tree. This place conceptually remains stable over time
- * by referring to a particular segment and offset within that segment.
- * Thus, this reference's character position changes as the tree is edited.
- * @alpha
- */
-export declare interface ReferencePosition {
-    /**
-     * Properties associated with this reference
-     */
-    properties?: PropertySet;
-    /**
-     * The direction for this reference position to slide when the segment it
-     * points to is removed. See {@link (SlidingPreference:type)} for additional context.
-     *
-     * Defaults to SlidingPreference.Forward
-     */
-    slidingPreference?: SlidingPreference;
-    refType: ReferenceType;
-    /**
-     * Gets the segment that this reference position is semantically associated with. Returns undefined iff the
-     * reference became detached from the string.
-     */
-    getSegment(): ISegment | undefined;
-    /**
-     * Gets the offset for this reference position within its associated segment.
-     *
-     * @example
-     *
-     * If a merge-tree has 3 leaf segments ["hello", " ", "world"] and a ReferencePosition refers to the "l"
-     * in "world", that reference's offset would be 3 as "l" is the character at index 3 within "world".
-     */
-    getOffset(): number;
-    /**
-     * @param newProps - Properties to add to this reference.
-     * @remarks Note that merge-tree does not broadcast changes to other clients. It is up to the consumer
-     * to ensure broadcast happens if that is desired.
-     */
-    addProperties(newProps: PropertySet): void;
-    isLeaf(): this is ISegment;
-}
-
-/**
- * Flags enum that dictates behavior of a {@link ReferencePosition}
- * @alpha
- */
-export declare enum ReferenceType {
-    Simple = 0,
-    /**
-     * Allows this reference to be located using the `searchForMarker` API on merge-tree.
-     */
-    Tile = 1,
-    /**
-     * Denotes that this reference begins the start of an interval. This is
-     * generally not meaningful outside the context of interval collections
-     * on SharedString.
-     */
-    RangeBegin = 16,
-    /**
-     * Denotes that this reference is the end of an interval. This is
-     * generally not meaningful outside the context of interval collections
-     * on SharedString.
-     */
-    RangeEnd = 32,
-    /**
-     * When a segment is marked removed (locally or with ack), this reference will slide to the first
-     * valid option of:
-     * 1. the start of the next furthest segment
-     * 2. the end of the next nearest segment
-     * 3. DetachedReferencePosition
-     */
-    SlideOnRemove = 64,
-    /**
-     * When a segment is marked removed (locally or with ack), this reference will remain on that segment.
-     */
-    StayOnRemove = 128,
-    /**
-     * Specifies that the reference position should never be added to the segment it refers to.
-     * This is useful for comparison/iteration purposes
-     */
-    Transient = 256
-}
-
-/**
- * @internal
- */
-export declare const refGetTileLabels: (refPos: ReferencePosition) => string[] | undefined;
-
-/**
- * @internal
- */
-export declare function refHasTileLabel(refPos: ReferencePosition, label: string): boolean;
-
-/**
- * @internal
- */
-export declare function refHasTileLabels(refPos: ReferencePosition): boolean;
-
-/**
- * @internal
- */
-export declare function refTypeIncludesFlag(refPosOrType: ReferencePosition | ReferenceType, flags: ReferenceType): boolean;
-
-/**
- * The special-cased property key that tracks the id of a {@link Marker}.
- *
- * @remarks In general, marker ids should be accessed using the inherent method
- * {@link Marker.getId}. Marker ids should not be updated after creation.
- * @internal
- */
-export declare const reservedMarkerIdKey = "markerId";
-
-/**
- * @internal
- */
-export declare const reservedMarkerSimpleTypeKey = "markerSimpleType";
-
-/**
- * @internal
- */
-export declare const reservedRangeLabelsKey = "referenceRangeLabels";
-
-/**
- * @internal
- */
-export declare const reservedTileLabelsKey = "referenceTileLabels";
-
-/**
- * @alpha
- */
-export declare function revertMergeTreeDeltaRevertibles(driver: MergeTreeRevertibleDriver, revertibles: MergeTreeDeltaRevertible[]): void;
-
-/**
- * @deprecated This functionality was not meant to be exported and will be removed in a future release
- * @alpha
- */
-export declare interface SegmentGroup {
-    segments: ISegment[];
-    previousProps?: PropertySet[];
-    localSeq?: number;
-    refSeq: number;
-}
-
-/**
- * @alpha
- */
-export declare class SegmentGroupCollection {
-    private readonly segment;
-    private readonly segmentGroups;
-    constructor(segment: ISegment);
-    get size(): number;
-    get empty(): boolean;
-    enqueue(segmentGroup: SegmentGroup): void;
-    dequeue(): SegmentGroup | undefined;
-    remove?(segmentGroup: SegmentGroup): boolean;
-    pop?(): SegmentGroup | undefined;
-    copyTo(segment: ISegment): void;
-    private enqueueOnCopy;
-}
-
-/**
- * @alpha
- */
-export declare interface SequenceOffsets {
-    /**
-     * Parallel array with posBreakpoints which tracks the seq of insertion.
-     *
-     * @example
-     *
-     * If seqs is [45, 46] and posBreakpoints is [0, 3], the section of the string
-     * between offsets 0 and 3 was inserted at seq 45 and the section of the string between
-     * 3 and the length of the string was inserted at seq 46.
-     *
-     * @remarks We use null here rather than undefined as round-tripping through JSON converts
-     * undefineds to null anyway
-     */
-    seqs: (number | AttributionKey | null)[];
-    posBreakpoints: number[];
-}
-
-/**
- * @alpha
- */
-export declare interface SerializedAttributionCollection extends SequenceOffsets {
-    channels?: {
-        [name: string]: SequenceOffsets;
-    };
-    length: number;
-}
-
-/**
- * Dictates the preferential direction for a {@link ReferencePosition} to slide
- * in a merge-tree
- * @alpha
- */
-export declare const SlidingPreference: {
-    /**
-     * Prefer sliding towards the start of the tree
-     */
-    readonly BACKWARD: 0;
-    /**
-     * Prefer sliding towards the end of the tree
-     */
-    readonly FORWARD: 1;
-};
-
-/**
- * Dictates the preferential direction for a {@link ReferencePosition} to slide
- * in a merge-tree
- * @alpha
- */
-export declare type SlidingPreference = (typeof SlidingPreference)[keyof typeof SlidingPreference];
-
-/**
- * @internal
- */
-export declare interface SortedDictionary<TKey, TData> extends Dictionary<TKey, TData> {
-    max(): Property<TKey, TData> | undefined;
-    min(): Property<TKey, TData> | undefined;
-    mapRange<TAccum>(action: PropertyAction<TKey, TData>, accum?: TAccum, start?: TKey, end?: TKey): void;
-}
-
-/**
- * Stores a unique and sorted set of segments, or objects with segments
- *
- * This differs from a normal sorted set in that the keys are not fixed.
- * The segments are sorted via their ordinals which can change as the merge tree is modified.
- * Even though the values of the ordinals can change their ordering and uniqueness cannot, so the order of a set of
- * segments ordered by their ordinals will always have the same order even if the ordinal values on
- * the segments changes. This invariant allows us to ensure the segments stay
- * ordered and unique, and that new segments can be inserted into that order.
- *
- * @deprecated This functionality was not meant to be exported and will be removed in a future release
- * @internal
- */
-export declare class SortedSegmentSet<T extends SortedSegmentSetItem = ISegment> extends SortedSet<T, string> {
-    protected getKey(item: T): string;
-    protected findItemPosition(item: T): {
-        exists: boolean;
-        index: number;
-    };
-}
-
-/**
- * @deprecated This functionality was not meant to be exported and will be removed in a future release
- * @internal
- */
-export declare type SortedSegmentSetItem = ISegment | LocalReferencePosition | {
-    readonly segment: ISegment;
-};
-
-/**
- * @deprecated This functionality was not meant to be exported and will be removed in a future release
- * @internal
- */
-export declare abstract class SortedSet<T, U extends string | number> {
-    protected abstract getKey(t: T): U;
-    protected readonly keySortedItems: T[];
-    get size(): number;
-    get items(): readonly T[];
-    addOrUpdate(newItem: T, update?: (existingItem: T, newItem: T) => void): void;
-    remove(item: T): boolean;
-    has(item: T): boolean;
-    protected findItemPosition(item: T): {
-        exists: boolean;
-        index: number;
-    };
-}
-
-/**
- * @alpha
- */
-export declare class TextSegment extends BaseSegment {
-    text: string;
-    static readonly type = "TextSegment";
-    readonly type = "TextSegment";
-    static is(segment: ISegment): segment is TextSegment;
-    static make(text: string, props?: PropertySet): TextSegment;
-    static fromJSONObject(spec: any): TextSegment | undefined;
-    constructor(text: string);
-    toJSONObject(): IJSONTextSegment | string;
-    clone(start?: number, end?: number): TextSegment;
-    canAppend(segment: ISegment): boolean;
-    toString(): string;
-    append(segment: ISegment): void;
-    protected createSplitSegmentAt(pos: number): TextSegment | undefined;
-}
-
-/**
- * @internal
- */
-export declare function toRemovalInfo(maybe: Partial<IRemovalInfo> | undefined): IRemovalInfo | undefined;
-
-/**
- * @alpha
- */
-export declare type Trackable = ISegment | LocalReferencePosition;
-
-/**
- * @alpha
- */
-export declare class TrackingGroup implements ITrackingGroup {
-    private readonly trackedSet;
-    constructor();
-    get tracked(): readonly Trackable[];
-    get size(): number;
-    has(trackable: Trackable): boolean;
-    link(trackable: Trackable): void;
-    unlink(trackable: Trackable): boolean;
-}
-
-/**
- * A collection of {@link ITrackingGroup}.
- * @alpha
- */
-export declare class TrackingGroupCollection {
-    private readonly trackable;
-    private readonly _trackingGroups;
-    get trackingGroups(): Set<TrackingGroup>;
-    constructor(trackable: Trackable);
-    link(trackingGroup: ITrackingGroup): void;
-    unlink(trackingGroup: ITrackingGroup): boolean;
-    copyTo(trackable: Trackable): void;
-    get empty(): boolean;
-    matches(trackingCollection: TrackingGroupCollection): boolean;
-}
-
-/**
- * The sequence number of an op before it is acked.
- *
- * @internal
- */
-export declare const UnassignedSequenceNumber = -1;
-
-/**
- * The sequence number which can be seen by all ops.
- *
- * This is useful in the context of snapshot loading, rollback, among other
- * scenarios.
- *
- * @internal
- */
-export declare const UniversalSequenceNumber = 0;
-
-export { }