@fluidframework/sequence 1.4.0-121020 → 2.0.0-dev-rc.1.0.0.224419

package/dist/intervalCollection.d.ts

@@ -2,133 +2,92 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { TypedEventEmitter } from "@fluidframework/common-utils";
-import { IEvent } from "@fluidframework/common-definitions";
-import { Client, ICombiningOp, IInterval, IntervalConflictResolver, LocalReference, PropertiesManager, PropertySet } from "@fluidframework/merge-tree";
+import { TypedEventEmitter } from "@fluid-internal/client-utils";
+import { IEvent } from "@fluidframework/core-interfaces";
+import { Client, PropertySet, LocalReferencePosition } from "@fluidframework/merge-tree";
 import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
-import { IValueFactory, IValueOpEmitter, IValueOperation, IValueType } from "./defaultMapInterfaces";
-export declare enum IntervalType {
-    Simple = 0,
-    Nest = 1,
-    /**
-     * SlideOnRemove indicates that the ends of the interval will slide if the segment
-     * they reference is removed and acked.
-     * See `packages\dds\merge-tree\REFERENCEPOSITIONS.md` for details
-     * SlideOnRemove is the default interval behavior and does not need to be specified.
-     */
-    SlideOnRemove = 2,
-    /**
-     * @internal
-     * A temporary interval, used internally
-     */
-    Transient = 4
-}
-export interface ISerializedInterval {
-    sequenceNumber: number;
-    start: number;
-    end: number;
-    intervalType: IntervalType;
-    properties?: PropertySet;
-}
+import { IMapMessageLocalMetadata, IValueFactory, IValueOpEmitter, IValueOperation, IValueType, SequenceOptions } from "./defaultMapInterfaces";
+import { CompressedSerializedInterval, IIntervalHelpers, Interval, IntervalOpType, IntervalStickiness, IntervalType, ISerializableInterval, ISerializedInterval, SequenceInterval, SerializedIntervalDelta } from "./intervals";
+import { IEndpointIndex, IIdIntervalIndex, IOverlappingIntervalsIndex, IntervalIndex } from "./intervalIndex";
 /**
- * A size optimization to avoid redundantly storing keys when serializing intervals
- * as JSON. Intervals are of the format:
+ * Defines a position and side relative to a character in a sequence.
+ *
+ * For this purpose, sequences look like:
+ *
+ * `{start} - {character 0} - {character 1} - ... - {character N} - {end}`
+ *
+ * Each `{value}` in the diagram is a character within a sequence.
+ * Each `-` in the above diagram is a position where text could be inserted.
+ * Each position between a `{value}` and a `-` is a `SequencePlace`.
+ *
+ * The special endpoints `{start}` and `{end}` refer to positions outside the
+ * contents of the string.
  *
- * [start, end, sequenceNumber, intervalType, properties]
+ * This gives us 2N + 2 possible positions to refer to within a string, where N
+ * is the number of characters.
+ *
+ * If the position is specified with a bare number, the side defaults to
+ * `Side.Before`.
+ *
+ * If a SequencePlace is the endpoint of a range (e.g. start/end of an interval or search range),
+ * the Side value means it is exclusive if it is nearer to the other position and inclusive if it is farther.
+ * E.g. the start of a range with Side.After is exclusive of the character at the position.
+ * @alpha
  */
-export declare type CompressedSerializedInterval = [number, number, number, IntervalType, PropertySet];
+export type SequencePlace = number | "start" | "end" | InteriorSequencePlace;
 /**
- * @internal
+ * A sequence place that does not refer to the special endpoint segments.
+ *
+ * See {@link SequencePlace} for additional context.
+ * @alpha
+ */
+export interface InteriorSequencePlace {
+    pos: number;
+    side: Side;
+}
+/**
+ * Defines a side relative to a character in a sequence.
+ *
+ * @remarks See {@link SequencePlace} for additional context on usage.
+ * @alpha
  */
+export declare enum Side {
+    Before = 0,
+    After = 1
+}
 export interface ISerializedIntervalCollectionV2 {
     label: string;
     version: 2;
     intervals: CompressedSerializedInterval[];
 }
-export interface ISerializableInterval extends IInterval {
-    properties: PropertySet;
-    propertyManager: PropertiesManager;
-    serialize(client: Client): ISerializedInterval;
-    addProperties(props: PropertySet, collaborating?: boolean, seq?: number): PropertySet | undefined;
-    getIntervalId(): string | undefined;
-}
-export interface IIntervalHelpers<TInterval extends ISerializableInterval> {
-    compareEnds(a: TInterval, b: TInterval): number;
-    create(label: string, start: number, end: number, client: Client, intervalType?: IntervalType, op?: ISequencedDocumentMessage): TInterval;
-}
-export declare class Interval implements ISerializableInterval {
-    start: number;
-    end: number;
-    properties: PropertySet;
-    auxProps: PropertySet[];
-    propertyManager: PropertiesManager;
-    constructor(start: number, end: number, props?: PropertySet);
-    getIntervalId(): string | undefined;
-    getAdditionalPropertySets(): PropertySet[];
-    addPropertySet(props: PropertySet): void;
-    serialize(client: Client): ISerializedInterval;
-    clone(): Interval;
-    compare(b: Interval): number;
-    compareStart(b: Interval): number;
-    compareEnd(b: Interval): number;
-    overlaps(b: Interval): boolean;
-    union(b: Interval): Interval;
-    getProperties(): PropertySet;
-    addProperties(newProps: PropertySet, collaborating?: boolean, seq?: number, op?: ICombiningOp): PropertySet | undefined;
-    modify(label: string, start: number, end: number, op?: ISequencedDocumentMessage): Interval;
-    private initializeProperties;
-}
-export declare class SequenceInterval implements ISerializableInterval {
-    start: LocalReference;
-    end: LocalReference;
-    intervalType: IntervalType;
-    properties: PropertySet;
-    propertyManager: PropertiesManager;
-    constructor(start: LocalReference, end: LocalReference, intervalType: IntervalType, props?: PropertySet);
-    private callbacks?;
-    /**
-     * @internal
-     * Subscribes to position change events on this interval if there are no current listeners.
-     */
-    addPositionChangeListeners(beforePositionChange: () => void, afterPositionChange: () => void): void;
-    /**
-     * @internal
-     * Removes the currently subscribed position change listeners.
-     */
-    removePositionChangeListeners(): void;
-    serialize(client: Client): ISerializedInterval;
-    clone(): SequenceInterval;
-    compare(b: SequenceInterval): number;
-    compareStart(b: SequenceInterval): number;
-    compareEnd(b: SequenceInterval): number;
-    overlaps(b: SequenceInterval): boolean;
-    getIntervalId(): string | undefined;
-    union(b: SequenceInterval): SequenceInterval;
-    addProperties(newProps: PropertySet, collab?: boolean, seq?: number, op?: ICombiningOp): PropertySet | undefined;
-    overlapsPos(bstart: number, bend: number): boolean;
-    modify(label: string, start: number, end: number, op?: ISequencedDocumentMessage): SequenceInterval;
-    private initializeProperties;
-}
-export declare function defaultIntervalConflictResolver(a: Interval, b: Interval): Interval;
-export declare function createIntervalIndex(conflict?: IntervalConflictResolver<Interval>): LocalIntervalCollection<Interval>;
+export declare function sidesFromStickiness(stickiness: IntervalStickiness): {
+    startSide: Side;
+    endSide: Side;
+};
+export declare function endpointPosAndSide(start: SequencePlace | undefined, end: SequencePlace | undefined): {
+    startSide: Side | undefined;
+    endSide: Side | undefined;
+    startPos: number | "end" | "start" | undefined;
+    endPos: number | "end" | "start" | undefined;
+};
+export declare function computeStickinessFromSide(startPos?: number | "start" | "end" | undefined, startSide?: Side, endPos?: number | "start" | "end" | undefined, endSide?: Side): IntervalStickiness;
+export declare function createIntervalIndex(): LocalIntervalCollection<Interval>;
 export declare class LocalIntervalCollection<TInterval extends ISerializableInterval> {
     private readonly client;
     private readonly label;
     private readonly helpers;
+    private readonly options;
     /** Callback invoked each time one of the endpoints of an interval slides. */
     private readonly onPositionChange?;
-    private readonly intervalTree;
-    private readonly endIntervalTree;
-    private readonly intervalIdMap;
-    private conflictResolver;
-    private endConflictResolver;
     private static readonly legacyIdPrefix;
-    constructor(client: Client, label: string, helpers: IIntervalHelpers<TInterval>, 
+    readonly overlappingIntervalsIndex: IOverlappingIntervalsIndex<TInterval>;
+    readonly idIntervalIndex: IIdIntervalIndex<TInterval>;
+    readonly endIntervalIndex: IEndpointIndex<TInterval>;
+    private readonly indexes;
+    constructor(client: Client, label: string, helpers: IIntervalHelpers<TInterval>, options: Partial<SequenceOptions>, 
     /** Callback invoked each time one of the endpoints of an interval slides. */
-    onPositionChange?: (interval: TInterval) => void);
-    addConflictResolver(conflictResolver: IntervalConflictResolver<TInterval>): void;
-    map(fn: (interval: TInterval) => void): void;
-    createLegacyId(start: number, end: number): string;
+    onPositionChange?: ((interval: TInterval, previousInterval: TInterval) => void) | undefined);
+    createLegacyId(start: number | "start" | "end", end: number | "start" | "end"): string;
     /**
      * Validates that a serialized interval has the ID property. Creates an ID
      * if one does not already exist
@@ -137,20 +96,16 @@ export declare class LocalIntervalCollection<TInterval extends ISerializableInte
      * @returns The interval's existing or newly created id
      */
     ensureSerializedId(serializedInterval: ISerializedInterval): string;
-    mapUntil(fn: (interval: TInterval) => boolean): void;
-    gatherIterationResults(results: TInterval[], iteratesForward: boolean, start?: number, end?: number): void;
-    findOverlappingIntervals(startPosition: number, endPosition: number): TInterval[];
-    previousInterval(pos: number): TInterval;
-    nextInterval(pos: number): TInterval;
-    removeInterval(startPosition: number, endPosition: number): TInterval;
-    private removeIntervalFromIndex;
+    private removeIntervalFromIndexes;
+    appendIndex(index: IntervalIndex<TInterval>): void;
+    removeIndex(index: IntervalIndex<TInterval>): boolean;
     removeExistingInterval(interval: TInterval): void;
-    createInterval(start: number, end: number, intervalType: IntervalType, op?: ISequencedDocumentMessage): TInterval;
-    addInterval(start: number, end: number, intervalType: IntervalType, props?: PropertySet, op?: ISequencedDocumentMessage): TInterval;
-    private addIntervalToIndex;
+    createInterval(start: SequencePlace, end: SequencePlace, intervalType: IntervalType, op?: ISequencedDocumentMessage): TInterval;
+    addInterval(start: SequencePlace, end: SequencePlace, intervalType: IntervalType, props?: PropertySet, op?: ISequencedDocumentMessage): TInterval;
+    private linkEndpointsToInterval;
+    private addIntervalToIndexes;
     add(interval: TInterval): void;
-    getIntervalById(id: string): TInterval;
-    changeInterval(interval: TInterval, start: number, end: number, op?: ISequencedDocumentMessage): TInterval;
+    changeInterval(interval: TInterval, start: SequencePlace | undefined, end: SequencePlace | undefined, op?: ISequencedDocumentMessage, localSeq?: number): TInterval | undefined;
     serialize(): ISerializedIntervalCollectionV2;
     private addIntervalListeners;
     private removeIntervalListeners;
@@ -159,7 +114,7 @@ export declare class SequenceIntervalCollectionValueType implements IValueType<I
     static Name: string;
     get name(): string;
     get factory(): IValueFactory<IntervalCollection<SequenceInterval>>;
-    get ops(): Map<string, IValueOperation<IntervalCollection<SequenceInterval>>>;
+    get ops(): Map<IntervalOpType, IValueOperation<IntervalCollection<SequenceInterval>>>;
     private static readonly _factory;
     private static readonly _ops;
 }
@@ -167,104 +122,448 @@ export declare class IntervalCollectionValueType implements IValueType<IntervalC
     static Name: string;
     get name(): string;
     get factory(): IValueFactory<IntervalCollection<Interval>>;
-    get ops(): Map<string, IValueOperation<IntervalCollection<Interval>>>;
+    get ops(): Map<IntervalOpType, IValueOperation<IntervalCollection<Interval>>>;
     private static readonly _factory;
     private static readonly _ops;
 }
-export declare type DeserializeCallback = (properties: PropertySet) => void;
-export declare class IntervalCollectionIterator<TInterval extends ISerializableInterval> {
+export declare function makeOpsMap<T extends ISerializableInterval>(): Map<IntervalOpType, IValueOperation<IntervalCollection<T>>>;
+/**
+ * @alpha
+ */
+export type DeserializeCallback = (properties: PropertySet) => void;
+declare class IntervalCollectionIterator<TInterval extends ISerializableInterval> implements Iterator<TInterval> {
     private readonly results;
     private index;
     constructor(collection: IntervalCollection<TInterval>, iteratesForward?: boolean, start?: number, end?: number);
-    next(): {
-        value: TInterval;
-        done: boolean;
-    };
+    next(): IteratorResult<TInterval>;
 }
+/**
+ * Change events emitted by `IntervalCollection`s
+ * @alpha
+ */
 export interface IIntervalCollectionEvent<TInterval extends ISerializableInterval> extends IEvent {
     /**
-     * This event is invoked whenever the properties or endpoints of an interval may have changed.
+     * This event is invoked whenever the endpoints of an interval may have changed.
      * This can happen on:
-     * - endpoint modification (local or remote)
-     * - ack of an endpoint modification
-     * - property change (local or remote)
-     * - position change due to segment sliding (will always appear as a local change)
+     * - local endpoint modification
+     * - ack of a remote endpoint modification
+     * - position change due to segment sliding (slides due to mergeTree segment deletion will always appear local)
      * The `interval` argument reflects the new values.
+     * `previousInterval` contains transient `ReferencePosition`s at the same location as the interval's original
+     * endpoints. These references should be used for position information only.
+     * `local` reflects whether the change originated locally.
+     * `op` is defined if and only if the server has acked this change.
+     * `slide` is true if the change is due to sliding on removal of position
+     */
+    (event: "changeInterval", listener: (interval: TInterval, previousInterval: TInterval, local: boolean, op: ISequencedDocumentMessage | undefined, slide: boolean) => void): void;
+    /**
+     * This event is invoked whenever an interval is added or removed from the collection.
+     * `local` reflects whether the change originated locally.
+     * `op` is defined if and only if the server has acked this change.
+     */
+    (event: "addInterval" | "deleteInterval", listener: (interval: TInterval, local: boolean, op: ISequencedDocumentMessage | undefined) => void): void;
+    /**
+     * This event is invoked whenever an interval's properties have changed.
+     * `interval` reflects the state of the updated properties.
+     * `propertyDeltas` is a map-like whose keys contain all values that were changed, and whose
+     * values contain all previous values of the property set.
+     * This object can be used directly in a call to `changeProperties` to revert the property change if desired.
+     * `local` reflects whether the change originated locally.
+     * `op` is defined if and only if the server has acked this change.
+     */
+    (event: "propertyChanged", listener: (interval: TInterval, propertyDeltas: PropertySet, local: boolean, op: ISequencedDocumentMessage | undefined) => void): void;
+}
+/**
+ * Collection of intervals that supports addition, modification, removal, and efficient spatial querying.
+ * Changes to this collection will be incur updates on collaborating clients (i.e. they are not local-only).
+ * @alpha
+ */
+export interface IIntervalCollection<TInterval extends ISerializableInterval> extends TypedEventEmitter<IIntervalCollectionEvent<TInterval>> {
+    readonly attached: boolean;
+    /**
+     * Attaches an index to this collection.
+     * All intervals which are part of this collection will be added to the index, and the index will automatically
+     * be updated when this collection updates due to local or remote changes.
+     *
+     * @remarks After attaching an index to an interval collection, applications should typically store this
+     * index somewhere in their in-memory data model for future reference and querying.
+     */
+    attachIndex(index: IntervalIndex<TInterval>): void;
+    /**
+     * Detaches an index from this collection.
+     * All intervals which are part of this collection will be removed from the index, and updates to this collection
+     * due to local or remote changes will no longer incur updates to the index.
+     *
+     * @returns `false` if the target index cannot be found in the indexes, otherwise remove all intervals in the index and return `true`.
+     */
+    detachIndex(index: IntervalIndex<TInterval>): boolean;
+    /**
+     * @returns the interval in this collection that has the provided `id`.
+     * If no interval in the collection has this `id`, returns `undefined`.
+     */
+    getIntervalById(id: string): TInterval | undefined;
+    /**
+     * Creates a new interval and add it to the collection.
+     * @deprecated call IntervalCollection.add without specifying an intervalType
+     * @param start - interval start position (inclusive)
+     * @param end - interval end position (exclusive)
+     * @param intervalType - type of the interval. All intervals are SlideOnRemove. Intervals may not be Transient.
+     * @param props - properties of the interval
+     * @returns The created interval
+     * @remarks See documentation on {@link SequenceInterval} for comments on
+     * interval endpoint semantics: there are subtleties with how the current
+     * half-open behavior is represented.
+     *
+     * Note that intervals may behave unexpectedly if the entire contents
+     * of the string are deleted. In this case, it is possible for one endpoint
+     * of the interval to become detached, while the other remains on the string.
+     *
+     * By adjusting the `side` and `pos` values of the `start` and `end` parameters,
+     * it is possible to control whether the interval expands to include content
+     * inserted at its start or end.
+     *
+     *	See {@link SequencePlace} for more details on the model.
+     *
+     *	@example
+     *
+     *	Given the string "ABCD":
+     *
+     *```typescript
+     *	// Refers to "BC". If any content is inserted before B or after C, this
+     *	// interval will include that content
+     *	//
+     *	// Picture:
+     *	// \{start\} - A[- B - C -]D - \{end\}
+     *	// \{start\} - A - B - C - D - \{end\}
+     *	collection.add(\{ pos: 0, side: Side.After \}, \{ pos: 3, side: Side.Before \}, IntervalType.SlideOnRemove);
+     *	// Equivalent to specifying the same positions and Side.Before.
+     *	// Refers to "ABC". Content inserted after C will be included in the
+     *	// interval, but content inserted before A will not.
+     *	// \{start\} -[A - B - C -]D - \{end\}
+     *	// \{start\} - A - B - C - D - \{end\}
+     *	collection.add(0, 3, IntervalType.SlideOnRemove);
+     *```
+     *
+     * In the case of the first example, if text is deleted,
+     *
+     * ```typescript
+     *	// Delete the character "B"
+     *	string.removeRange(1, 2);
+     * ```
+     *
+     * The start point of the interval will slide to the position immediately
+     * before "C", and the same will be true.
+     *
+     * ```
+     * \{start\} - A[- C -]D - \{end\}
+     * ```
+     *
+     * In this case, text inserted immediately before "C" would be included in
+     * the interval.
+     *
+     * ```typescript
+     * string.insertText(1, "EFG");
+     * ```
+     *
+     * With the string now being,
+     *
+     * ```
+     * \{start\} - A[- E - F - G - C -]D - \{end\}
+     * ```
+     *
+     * @privateRemarks TODO: ADO:5205 the above comment regarding behavior in
+     * the case that the entire interval has been deleted should be resolved at
+     * the same time as this ticket
+     */
+    add(start: SequencePlace, end: SequencePlace, intervalType: IntervalType, props?: PropertySet): TInterval;
+    /**
+     * Creates a new interval and add it to the collection.
+     * @param start - interval start position (inclusive)
+     * @param end - interval end position (exclusive)
+     * @param props - properties of the interval
+     * @returns - the created interval
+     * @remarks - See documentation on {@link SequenceInterval} for comments on interval endpoint semantics: there are subtleties
+     * with how the current half-open behavior is represented.
+     */
+    add({ start, end, props, }: {
+        start: SequencePlace;
+        end: SequencePlace;
+        props?: PropertySet;
+    }): TInterval;
+    /**
+     * Removes an interval from the collection.
+     * @param id - Id of the interval to remove
+     * @returns the removed interval
+     */
+    removeIntervalById(id: string): TInterval | undefined;
+    /**
+     * Changes the properties on an existing interval.
+     * @deprecated - call change with the id and and object containing the new properties
+     * @param id - Id of the interval whose properties should be changed
+     * @param props - Property set to apply to the interval. Shallow merging is used between any existing properties
+     * and `prop`, i.e. the interval will end up with a property object equivalent to `{ ...oldProps, ...props }`.
+     */
+    changeProperties(id: string, props: PropertySet): void;
+    /**
+     * Changes the endpoints of an existing interval.
+     * @deprecated - call change with the start and end parameters encapsulated in an object
+     * @param id - Id of the interval to change
+     * @param start - New start value. To leave the endpoint unchanged, pass the current value.
+     * @param end - New end value. To leave the endpoint unchanged, pass the current value.
+     * @returns the interval that was changed, if it existed in the collection.
+     */
+    change(id: string, start: SequencePlace, end: SequencePlace): TInterval | undefined;
+    /**
+     * Changes the endpoints, properties, or both of an existing interval.
+     * @param id - Id of the Interval to change
+     * @returns the interval that was changed, if it existed in the collection.
+     * Pass the desired new start position, end position, and/or properties in an object. Start and end positions must be changed
+     * simultaneously - they must either both be specified or both undefined. To only change the properties, leave both endpoints
+     * undefined. To only change the endpoints, leave the properties undefined.
+     */
+    change(id: string, { start, end, props }: {
+        start?: SequencePlace;
+        end?: SequencePlace;
+        props?: PropertySet;
+    }): TInterval | undefined;
+    attachDeserializer(onDeserialize: DeserializeCallback): void;
+    /**
+     * @returns an iterator over all intervals in this collection.
+     */
+    [Symbol.iterator](): Iterator<TInterval>;
+    /**
+     * @returns a forward iterator over all intervals in this collection with start point equal to `startPosition`.
+     */
+    CreateForwardIteratorWithStartPosition(startPosition: number): Iterator<TInterval>;
+    /**
+     * @returns a backward iterator over all intervals in this collection with start point equal to `startPosition`.
+     */
+    CreateBackwardIteratorWithStartPosition(startPosition: number): Iterator<TInterval>;
+    /**
+     * @returns a forward iterator over all intervals in this collection with end point equal to `endPosition`.
+     */
+    CreateForwardIteratorWithEndPosition(endPosition: number): Iterator<TInterval>;
+    /**
+     * @returns a backward iterator over all intervals in this collection with end point equal to `endPosition`.
+     */
+    CreateBackwardIteratorWithEndPosition(endPosition: number): Iterator<TInterval>;
+    /**
+     * Gathers iteration results that optionally match a start/end criteria into the provided array.
+     * @param results - Array to gather the results into. In lieu of a return value, this array will be populated with
+     * intervals matching the query upon edit.
+     * @param iteratesForward - whether or not iteration should be in the forward direction
+     * @param start - If provided, only match intervals whose start point is equal to `start`.
+     * @param end - If provided, only match intervals whose end point is equal to `end`.
+     */
+    gatherIterationResults(results: TInterval[], iteratesForward: boolean, start?: number, end?: number): void;
+    /**
+     * @deprecated - Users must manually attach the corresponding interval index to utilize this functionality, for instance:
+     *
+     * ```typescript
+     * const overlappingIntervalsIndex = createOverlappingIntervalsIndex(sharedString);
+     * collection.attachIndex(overlappingIntervalsIndex)
+     * const result = overlappingIntervalsIndex.findOverlappingIntervals(start, end);
+     * ```
+     *
+     * @returns an array of all intervals in this collection that overlap with the interval
+     * `[startPosition, endPosition]`.
+     */
+    findOverlappingIntervals(startPosition: number, endPosition: number): TInterval[];
+    /**
+     * Applies a function to each interval in this collection.
+     */
+    map(fn: (interval: TInterval) => void): void;
+    /**
+     * @deprecated - due to the forthcoming change where the endpointIndex will no longer be
+     * automatically added to the collection. Users are advised to independently attach the
+     * index to the collection and utilize the API accordingly, for instance:
+     * ```typescript
+     * const endpointIndex = createEndpointIndex(sharedString);
+     * collection.attachIndex(endpointIndex);
+     * const result1 = endpointIndex.previousInterval(pos);
+     * ```
+     * If an index is used repeatedly, applications should generally attach it once and store it in memory.
+     */
+    previousInterval(pos: number): TInterval | undefined;
+    /**
+     * @deprecated - due to the forthcoming change where the endpointIndex will no longer be
+     * automatically added to the collection. Users are advised to independently attach the
+     * index to the collection and utilize the API accordingly, for instance:
+     * ```typescript
+     * const endpointIndex = createEndpointIndex(sharedString);
+     * collection.attachIndex(endpointIndex);
+     * const result2 = endpointIndex.nextInterval(pos);
+     * ```
      */
-    (event: "changeInterval", listener: (interval: TInterval, local: boolean, op: ISequencedDocumentMessage | undefined) => void): any;
-    (event: "addInterval" | "deleteInterval", listener: (interval: TInterval, local: boolean, op: ISequencedDocumentMessage) => void): any;
-    (event: "propertyChanged", listener: (interval: TInterval, propertyArgs: PropertySet) => void): any;
+    nextInterval(pos: number): TInterval | undefined;
 }
-export declare class IntervalCollection<TInterval extends ISerializableInterval> extends TypedEventEmitter<IIntervalCollectionEvent<TInterval>> {
+/**
+ * {@inheritdoc IIntervalCollection}
+ */
+export declare class IntervalCollection<TInterval extends ISerializableInterval> extends TypedEventEmitter<IIntervalCollectionEvent<TInterval>> implements IIntervalCollection<TInterval> {
     private readonly helpers;
     private readonly requiresClient;
     private readonly emitter;
+    private readonly options;
     private savedSerializedIntervals?;
     private localCollection;
     private onDeserialize;
     private client;
+    private readonly localSeqToSerializedInterval;
+    private readonly localSeqToRebasedInterval;
     private readonly pendingChangesStart;
     private readonly pendingChangesEnd;
     get attached(): boolean;
     /** @internal */
-    constructor(helpers: IIntervalHelpers<TInterval>, requiresClient: boolean, emitter: IValueOpEmitter, serializedIntervals: ISerializedInterval[] | ISerializedIntervalCollectionV2);
+    constructor(helpers: IIntervalHelpers<TInterval>, requiresClient: boolean, emitter: IValueOpEmitter, serializedIntervals: ISerializedInterval[] | ISerializedIntervalCollectionV2, options?: Partial<SequenceOptions>);
+    /**
+     * {@inheritdoc IIntervalCollection.attachIndex}
+     */
+    attachIndex(index: IntervalIndex<TInterval>): void;
+    /**
+     * {@inheritdoc IIntervalCollection.detachIndex}
+     */
+    detachIndex(index: IntervalIndex<TInterval>): boolean;
+    private rebasePositionWithSegmentSlide;
+    private computeRebasedPositions;
+    /** @internal */
     attachGraph(client: Client, label: string): void;
     /**
      * Gets the next local sequence number, modifying this client's collab window in doing so.
      */
     private getNextLocalSeq;
-    getIntervalById(id: string): TInterval;
+    private emitChange;
     /**
-     * Create a new interval and add it to the collection
-     * @param start - interval start position
-     * @param end - interval end position
-     * @param intervalType - type of the interval. All intervals are SlideOnRemove. Intervals may not be Transient.
-     * @param props - properties of the interval
-     * @returns - the created interval
+     * {@inheritdoc IIntervalCollection.getIntervalById}
+     */
+    getIntervalById(id: string): TInterval | undefined;
+    private assertStickinessEnabled;
+    /**
+     * {@inheritdoc IIntervalCollection.add}
+     * @deprecated call IntervalCollection.add without specifying an intervalType
      */
-    add(start: number, end: number, intervalType: IntervalType, props?: PropertySet): TInterval;
+    add(start: SequencePlace, end: SequencePlace, intervalType: IntervalType, props?: PropertySet): TInterval;
+    add({ start, end, props, }: {
+        start: SequencePlace;
+        end: SequencePlace;
+        props?: PropertySet;
+    }): TInterval;
     private deleteExistingInterval;
-    removeIntervalById(id: string): TInterval;
+    /**
+     * {@inheritdoc IIntervalCollection.removeIntervalById}
+     */
+    removeIntervalById(id: string): TInterval | undefined;
+    /**
+     * {@inheritdoc IIntervalCollection.changeProperties}
+     * @deprecated - call change with the id and an object containing the new props values
+     */
     changeProperties(id: string, props: PropertySet): void;
-    change(id: string, start?: number, end?: number): TInterval | undefined;
+    /**
+     * {@inheritdoc IIntervalCollection.change}
+     * @deprecated - call change with the id and an object containing the new start, end, and/or props values
+     */
+    change(id: string, start: SequencePlace, end: SequencePlace): TInterval | undefined;
+    /**
+     * {@inheritdoc IIntervalCollection.change}
+     */
+    change(id: string, { start, end, props }: {
+        start?: SequencePlace;
+        end?: SequencePlace;
+        props?: PropertySet;
+    }): TInterval | undefined;
+    private get isCollaborating();
     private addPendingChange;
     private addPendingChangeHelper;
     private removePendingChange;
     private removePendingChangeHelper;
     private hasPendingChangeStart;
     private hasPendingChangeEnd;
-    /** @deprecated - use ackChange */
-    changeInterval(serializedInterval: ISerializedInterval, local: boolean, op: ISequencedDocumentMessage): void;
     /** @internal */
-    ackChange(serializedInterval: ISerializedInterval, local: boolean, op: ISequencedDocumentMessage): void;
-    addConflictResolver(conflictResolver: IntervalConflictResolver<TInterval>): void;
+    ackChange(serializedInterval: ISerializedInterval, local: boolean, op: ISequencedDocumentMessage, localOpMetadata: IMapMessageLocalMetadata | undefined): void;
+    /**
+     * {@inheritdoc IIntervalCollection.attachDeserializer}
+     */
     attachDeserializer(onDeserialize: DeserializeCallback): void;
-    /** @internal */
-    rebaseLocalInterval(opName: string, serializedInterval: ISerializedInterval, localSeq: number): ISerializedInterval;
+    /**
+     * Returns new interval after rebasing. If undefined, the interval was
+     * deleted as a result of rebasing. This can occur if the interval applies
+     * to a range that no longer exists, and the interval was unable to slide.
+     *
+     * @internal
+     */
+    rebaseLocalInterval(opName: string, serializedInterval: SerializedIntervalDelta, localSeq: number): SerializedIntervalDelta | undefined;
     private getSlideToSegment;
-    private setSlideOnRemove;
     private ackInterval;
-    /** @deprecated - use ackAdd */
-    addInternal(serializedInterval: ISerializedInterval, local: boolean, op: ISequencedDocumentMessage): TInterval;
     /** @internal */
-    ackAdd(serializedInterval: ISerializedInterval, local: boolean, op: ISequencedDocumentMessage): TInterval;
-    /** @deprecated - use ackDelete */
-    deleteInterval(serializedInterval: ISerializedInterval, local: boolean, op: ISequencedDocumentMessage): void;
+    ackAdd(serializedInterval: ISerializedInterval, local: boolean, op: ISequencedDocumentMessage, localOpMetadata: IMapMessageLocalMetadata | undefined): TInterval | undefined;
     /** @internal */
     ackDelete(serializedInterval: ISerializedInterval, local: boolean, op: ISequencedDocumentMessage): void;
     /**
      * @internal
      */
     serializeInternal(): ISerializedIntervalCollectionV2;
+    /**
+     * @returns an iterator over all intervals in this collection.
+     */
     [Symbol.iterator](): IntervalCollectionIterator<TInterval>;
+    /**
+     * {@inheritdoc IIntervalCollection.CreateForwardIteratorWithStartPosition}
+     */
     CreateForwardIteratorWithStartPosition(startPosition: number): IntervalCollectionIterator<TInterval>;
+    /**
+     * {@inheritdoc IIntervalCollection.CreateBackwardIteratorWithStartPosition}
+     */
     CreateBackwardIteratorWithStartPosition(startPosition: number): IntervalCollectionIterator<TInterval>;
+    /**
+     * {@inheritdoc IIntervalCollection.CreateForwardIteratorWithEndPosition}
+     */
     CreateForwardIteratorWithEndPosition(endPosition: number): IntervalCollectionIterator<TInterval>;
+    /**
+     * {@inheritdoc IIntervalCollection.CreateBackwardIteratorWithEndPosition}
+     */
     CreateBackwardIteratorWithEndPosition(endPosition: number): IntervalCollectionIterator<TInterval>;
+    /**
+     * {@inheritdoc IIntervalCollection.gatherIterationResults}
+     */
     gatherIterationResults(results: TInterval[], iteratesForward: boolean, start?: number, end?: number): void;
+    /**
+     * {@inheritdoc IIntervalCollection.findOverlappingIntervals}
+     */
     findOverlappingIntervals(startPosition: number, endPosition: number): TInterval[];
+    /**
+     * {@inheritdoc IIntervalCollection.map}
+     */
     map(fn: (interval: TInterval) => void): void;
-    previousInterval(pos: number): TInterval;
-    nextInterval(pos: number): TInterval;
+    /**
+     * {@inheritdoc IIntervalCollection.previousInterval}
+     */
+    previousInterval(pos: number): TInterval | undefined;
+    /**
+     * {@inheritdoc IIntervalCollection.nextInterval}
+     */
+    nextInterval(pos: number): TInterval | undefined;
 }
+/**
+ * Information that identifies an interval within a `Sequence`.
+ * @internal
+ */
+export interface IntervalLocator {
+    /**
+     * Label for the collection the interval is a part of
+     */
+    label: string;
+    /**
+     * Interval within that collection
+     */
+    interval: SequenceInterval;
+}
+/**
+ * Returns an object that can be used to find the interval a given LocalReferencePosition belongs to.
+ * @returns undefined if the reference position is not the endpoint of any interval (e.g. it was created
+ * on the merge tree directly by app code), otherwise an {@link IntervalLocator} for the interval this
+ * endpoint is a part of.
+ * @internal
+ */
+export declare function intervalLocatorFromEndpoint(potentialEndpoint: LocalReferencePosition): IntervalLocator | undefined;
+export {};
 //# sourceMappingURL=intervalCollection.d.ts.map