@fluidframework/sequence 2.30.0 → 2.31.0

package/src/intervalCollection.ts

@@ -4,7 +4,6 @@
  */
 
 /* eslint-disable no-bitwise */
-/* eslint-disable import/no-deprecated */
 
 import { TypedEventEmitter } from "@fluid-internal/client-utils";
 import { IEvent } from "@fluidframework/core-interfaces";
@@ -21,7 +20,6 @@ import {
 	UnassignedSequenceNumber,
 	UniversalSequenceNumber,
 	addProperties,
-	createMap,
 	getSlideToSegoff,
 	refTypeIncludesFlag,
 	reservedRangeLabelsKey,
@@ -30,49 +28,49 @@ import {
 	endpointPosAndSide,
 	PropertiesManager,
 	type ISegmentInternal,
+	createMap,
 } from "@fluidframework/merge-tree/internal";
 import { LoggingError, UsageError } from "@fluidframework/telemetry-utils/internal";
 import { v4 as uuid } from "uuid";
 
 import {
-	IIntervalCollectionFactory,
 	IIntervalCollectionOperation,
-	IIntervalCollectionType,
 	IMapMessageLocalMetadata,
-	IValueOpEmitter,
 	SequenceOptions,
+	type IIntervalCollectionTypeOperationValue,
 } from "./intervalCollectionMapInterfaces.js";
 import {
+	createIdIntervalIndex,
 	EndpointIndex,
-	IEndpointIndex,
-	IIdIntervalIndex,
-	IOverlappingIntervalsIndex,
-	IntervalIndex,
 	OverlappingIntervalsIndex,
-	createIdIntervalIndex,
+	type IEndpointIndex,
+	type IIdIntervalIndex,
+	// eslint-disable-next-line import/no-deprecated
+	type IntervalIndex,
+	type ISequenceOverlappingIntervalsIndex,
+	type SequenceIntervalIndex,
 } from "./intervalIndex/index.js";
 import {
 	CompressedSerializedInterval,
-	IIntervalHelpers,
-	ISerializableInterval,
 	ISerializedInterval,
-	Interval,
-	IntervalOpType,
+	IntervalDeltaOpType,
 	IntervalStickiness,
 	IntervalType,
 	SequenceInterval,
 	SequenceIntervalClass,
 	SerializedIntervalDelta,
-	createInterval,
 	createPositionReferenceFromSegoff,
+	createSequenceInterval,
 	endReferenceSlidingPreference,
-	sequenceIntervalHelpers,
 	startReferenceSlidingPreference,
+	type ISerializableInterval,
 	type ISerializableIntervalPrivate,
 } from "./intervals/index.js";
 
 export const reservedIntervalIdKey = "intervalId";
 
+export type ISerializedIntervalCollectionV1 = ISerializedInterval[];
+
 export interface ISerializedIntervalCollectionV2 {
 	label: string;
 	version: 2;
@@ -166,40 +164,26 @@ export function computeStickinessFromSide(
 	return stickiness as IntervalStickiness;
 }
 
-export function createIntervalIndex() {
-	const helpers: IIntervalHelpers<Interval> = {
-		create: createInterval,
-	};
-	const lc = new LocalIntervalCollection<Interval>(
-		undefined as any as Client,
-		"",
-		helpers,
-		{},
-	);
-	return lc;
-}
-
-export class LocalIntervalCollection<TInterval extends ISerializableInterval> {
+export class LocalIntervalCollection {
 	private static readonly legacyIdPrefix = "legacy";
-	public readonly overlappingIntervalsIndex: IOverlappingIntervalsIndex<TInterval>;
-	public readonly idIntervalIndex: IIdIntervalIndex<TInterval>;
-	public readonly endIntervalIndex: IEndpointIndex<TInterval>;
-	private readonly indexes: Set<IntervalIndex<TInterval>>;
+	public readonly overlappingIntervalsIndex: ISequenceOverlappingIntervalsIndex;
+	public readonly idIntervalIndex: IIdIntervalIndex;
+	public readonly endIntervalIndex: IEndpointIndex;
+	private readonly indexes: Set<SequenceIntervalIndex>;
 
 	constructor(
 		private readonly client: Client,
 		private readonly label: string,
-		private readonly helpers: IIntervalHelpers<TInterval>,
 		private readonly options: Partial<SequenceOptions>,
 		/** Callback invoked each time one of the endpoints of an interval slides. */
 		private readonly onPositionChange?: (
-			interval: TInterval,
-			previousInterval: TInterval,
+			interval: SequenceIntervalClass,
+			previousInterval: SequenceIntervalClass,
 		) => void,
 	) {
-		this.overlappingIntervalsIndex = new OverlappingIntervalsIndex(client, helpers);
-		this.idIntervalIndex = createIdIntervalIndex<TInterval>();
-		this.endIntervalIndex = new EndpointIndex(client, helpers);
+		this.overlappingIntervalsIndex = new OverlappingIntervalsIndex(client);
+		this.idIntervalIndex = createIdIntervalIndex();
+		this.endIntervalIndex = new EndpointIndex(client);
 		this.indexes = new Set([
 			this.overlappingIntervalsIndex,
 			this.idIntervalIndex,
@@ -245,21 +229,21 @@ export class LocalIntervalCollection<TInterval extends ISerializableInterval> {
 		return id;
 	}
 
-	private removeIntervalFromIndexes(interval: TInterval) {
+	private removeIntervalFromIndexes(interval: SequenceIntervalClass) {
 		for (const index of this.indexes) {
 			index.remove(interval);
 		}
 	}
 
-	public appendIndex(index: IntervalIndex<TInterval>) {
+	public appendIndex(index: SequenceIntervalIndex) {
 		this.indexes.add(index);
 	}
 
-	public removeIndex(index: IntervalIndex<TInterval>): boolean {
+	public removeIndex(index: SequenceIntervalIndex): boolean {
 		return this.indexes.delete(index);
 	}
 
-	public removeExistingInterval(interval: TInterval) {
+	public removeExistingInterval(interval: SequenceIntervalClass) {
 		this.removeIntervalFromIndexes(interval);
 		this.removeIntervalListeners(interval);
 	}
@@ -269,8 +253,8 @@ export class LocalIntervalCollection<TInterval extends ISerializableInterval> {
 		end: SequencePlace,
 		intervalType: IntervalType,
 		op?: ISequencedDocumentMessage,
-	): TInterval {
-		return this.helpers.create(
+	): SequenceIntervalClass {
+		return createSequenceInterval(
 			this.label,
 			start,
 			end,
@@ -289,7 +273,7 @@ export class LocalIntervalCollection<TInterval extends ISerializableInterval> {
 		props?: PropertySet,
 		op?: ISequencedDocumentMessage,
 	) {
-		const interval: TInterval = this.createInterval(start, end, intervalType, op);
+		const interval: SequenceIntervalClass = this.createInterval(start, end, intervalType, op);
 		if (interval) {
 			if (!interval.properties) {
 				interval.properties = createMap<any>();
@@ -315,27 +299,25 @@ export class LocalIntervalCollection<TInterval extends ISerializableInterval> {
 		return interval;
 	}
 
-	private linkEndpointsToInterval(interval: TInterval): void {
-		if (interval instanceof SequenceIntervalClass) {
-			interval.start.addProperties({ interval });
-			interval.end.addProperties({ interval });
-		}
+	private linkEndpointsToInterval(interval: SequenceIntervalClass): void {
+		interval.start.addProperties({ interval });
+		interval.end.addProperties({ interval });
 	}
 
-	private addIntervalToIndexes(interval: TInterval) {
+	private addIntervalToIndexes(interval: SequenceIntervalClass) {
 		for (const index of this.indexes) {
 			index.add(interval);
 		}
 	}
 
-	public add(interval: TInterval): void {
+	public add(interval: SequenceIntervalClass): void {
 		this.linkEndpointsToInterval(interval);
 		this.addIntervalToIndexes(interval);
 		this.addIntervalListeners(interval);
 	}
 
 	public changeInterval(
-		interval: TInterval,
+		interval: SequenceIntervalClass,
 		start: SequencePlace | undefined,
 		end: SequencePlace | undefined,
 		op?: ISequencedDocumentMessage,
@@ -348,7 +330,7 @@ export class LocalIntervalCollection<TInterval extends ISerializableInterval> {
 			op,
 			localSeq,
 			this.options.mergeTreeReferencesCanSlideToEndpoint,
-		) as TInterval | undefined;
+		);
 		if (newInterval) {
 			this.removeExistingInterval(interval);
 			this.add(newInterval);
@@ -356,7 +338,12 @@ export class LocalIntervalCollection<TInterval extends ISerializableInterval> {
 		return newInterval;
 	}
 
-	public serialize(): ISerializedIntervalCollectionV2 {
+	public serialize(
+		version: "1" | "2",
+	): ISerializedIntervalCollectionV1 | ISerializedIntervalCollectionV2 {
+		if (version === "1") {
+			return Array.from(this.idIntervalIndex, (interval) => interval.serialize());
+		}
 		return {
 			label: this.label,
 			intervals: Array.from(this.idIntervalIndex, (interval) =>
@@ -366,7 +353,7 @@ export class LocalIntervalCollection<TInterval extends ISerializableInterval> {
 		};
 	}
 
-	private addIntervalListeners(interval: TInterval) {
+	private addIntervalListeners(interval: SequenceIntervalClass) {
 		const cloneRef = (ref: LocalReferencePosition) => {
 			const segment = ref.getSegment();
 			if (segment === undefined) {
@@ -385,193 +372,87 @@ export class LocalIntervalCollection<TInterval extends ISerializableInterval> {
 				ref.canSlideToEndpoint,
 			);
 		};
-		if (interval instanceof SequenceIntervalClass) {
-			let previousInterval: (TInterval & SequenceIntervalClass) | undefined;
-			let pendingChanges = 0;
-			interval.addPositionChangeListeners(
-				() => {
-					pendingChanges++;
-					// Note: both start and end can change and invoke beforeSlide on each endpoint before afterSlide.
-					if (!previousInterval) {
-						previousInterval = interval.clone() as TInterval & SequenceIntervalClass;
-						previousInterval.start = cloneRef(previousInterval.start);
-						previousInterval.end = cloneRef(previousInterval.end);
-						this.removeIntervalFromIndexes(interval);
-					}
-				},
-				() => {
-					assert(
-						previousInterval !== undefined,
-						0x3fa /* Invalid interleaving of before/after slide */,
-					);
-					pendingChanges--;
-					if (pendingChanges === 0) {
-						this.addIntervalToIndexes(interval);
-						this.onPositionChange?.(interval, previousInterval);
-						previousInterval = undefined;
-					}
-				},
-			);
-		}
-	}
-
-	private removeIntervalListeners(interval: TInterval) {
-		if (interval instanceof SequenceIntervalClass) {
-			interval.removePositionChangeListeners();
-		}
-	}
-}
-
-class SequenceIntervalCollectionFactory
-	implements IIntervalCollectionFactory<SequenceInterval>
-{
-	public load(
-		emitter: IValueOpEmitter,
-		raw: ISerializedInterval[] | ISerializedIntervalCollectionV2 = [],
-		options?: Partial<SequenceOptions>,
-	): IntervalCollection<SequenceInterval> {
-		return new IntervalCollection<SequenceInterval>(
-			sequenceIntervalHelpers,
-			true,
-			emitter,
-			raw,
-			options,
+		let previousInterval: SequenceIntervalClass | undefined;
+		let pendingChanges = 0;
+		interval.addPositionChangeListeners(
+			() => {
+				pendingChanges++;
+				// Note: both start and end can change and invoke beforeSlide on each endpoint before afterSlide.
+				if (!previousInterval) {
+					previousInterval = interval.clone();
+					previousInterval.start = cloneRef(previousInterval.start);
+					previousInterval.end = cloneRef(previousInterval.end);
+					this.removeIntervalFromIndexes(interval);
+				}
+			},
+			() => {
+				assert(
+					previousInterval !== undefined,
+					0x3fa /* Invalid interleaving of before/after slide */,
+				);
+				pendingChanges--;
+				if (pendingChanges === 0) {
+					this.addIntervalToIndexes(interval);
+					this.onPositionChange?.(interval, previousInterval);
+					previousInterval = undefined;
+				}
+			},
 		);
 	}
 
-	public store(
-		value: IntervalCollection<SequenceInterval>,
-	): ISerializedInterval[] | ISerializedIntervalCollectionV2 {
-		return value.serializeInternal();
-	}
-}
-
-export class SequenceIntervalCollectionValueType
-	implements IIntervalCollectionType<SequenceInterval>
-{
-	public static Name = "sharedStringIntervalCollection";
-
-	public get name(): string {
-		return SequenceIntervalCollectionValueType.Name;
-	}
-
-	public get factory(): IIntervalCollectionFactory<SequenceInterval> {
-		return SequenceIntervalCollectionValueType._factory;
-	}
-
-	public get ops(): Map<IntervalOpType, IIntervalCollectionOperation<SequenceInterval>> {
-		return SequenceIntervalCollectionValueType._ops;
-	}
-
-	private static readonly _factory: IIntervalCollectionFactory<SequenceInterval> =
-		new SequenceIntervalCollectionFactory();
-
-	private static readonly _ops = makeOpsMap<SequenceInterval>();
-}
-
-class IntervalCollectionFactory implements IIntervalCollectionFactory<Interval> {
-	public load(
-		emitter: IValueOpEmitter,
-		raw: ISerializedInterval[] | ISerializedIntervalCollectionV2 = [],
-		options?: Partial<SequenceOptions>,
-	): IntervalCollection<Interval> {
-		const helpers: IIntervalHelpers<Interval> = {
-			create: createInterval,
-		};
-		const collection = new IntervalCollection<Interval>(helpers, false, emitter, raw, options);
-		collection.attachGraph(undefined as any as Client, "");
-		return collection;
-	}
-
-	public store(value: IntervalCollection<Interval>): ISerializedIntervalCollectionV2 {
-		return value.serializeInternal();
+	private removeIntervalListeners(interval: SequenceIntervalClass) {
+		interval.removePositionChangeListeners();
 	}
 }
 
-export class IntervalCollectionValueType implements IIntervalCollectionType<Interval> {
-	public static Name = "sharedIntervalCollection";
-
-	public get name(): string {
-		return IntervalCollectionValueType.Name;
-	}
-
-	public get factory(): IIntervalCollectionFactory<Interval> {
-		return IntervalCollectionValueType._factory;
-	}
-
-	public get ops(): Map<IntervalOpType, IIntervalCollectionOperation<Interval>> {
-		return IntervalCollectionValueType._ops;
+const rebase: IIntervalCollectionOperation["rebase"] = (collection, op, localOpMetadata) => {
+	const { localSeq } = localOpMetadata;
+	const rebasedValue = collection.rebaseLocalInterval(op.opName, op.value, localSeq);
+	if (rebasedValue === undefined) {
+		return undefined;
 	}
-
-	private static readonly _factory: IIntervalCollectionFactory<Interval> =
-		new IntervalCollectionFactory();
-	private static readonly _ops = makeOpsMap<Interval>();
-}
-
-export function makeOpsMap<T extends ISerializableInterval>(): Map<
-	IntervalOpType,
-	IIntervalCollectionOperation<T>
-> {
-	const rebase: IIntervalCollectionOperation<T>["rebase"] = (
-		collection,
-		op,
-		localOpMetadata,
-	) => {
-		const { localSeq } = localOpMetadata;
-		const rebasedValue = collection.rebaseLocalInterval(op.opName, op.value, localSeq);
-		if (rebasedValue === undefined) {
-			return undefined;
-		}
-		const rebasedOp = { ...op, value: rebasedValue };
-		return { rebasedOp, rebasedLocalOpMetadata: localOpMetadata };
-	};
-
-	return new Map<IntervalOpType, IIntervalCollectionOperation<T>>([
-		[
-			IntervalOpType.ADD,
-			{
-				process: (collection, params, local, op, localOpMetadata) => {
-					// if params is undefined, the interval was deleted during
-					// rebasing
-					if (!params) {
-						return;
-					}
-					assert(op !== undefined, 0x3fb /* op should exist here */);
-					collection.ackAdd(params, local, op, localOpMetadata);
-				},
-				rebase,
-			},
-		],
-		[
-			IntervalOpType.DELETE,
-			{
-				process: (collection, params, local, op) => {
-					assert(op !== undefined, 0x3fc /* op should exist here */);
-					collection.ackDelete(params, local, op);
-				},
-				rebase: (collection, op, localOpMetadata) => {
-					// Deletion of intervals is based on id, so requires no rebasing.
-					return { rebasedOp: op, rebasedLocalOpMetadata: localOpMetadata };
-				},
-			},
-		],
-		[
-			IntervalOpType.CHANGE,
-			{
-				process: (collection, params, local, op, localOpMetadata) => {
-					// if params is undefined, the interval was deleted during
-					// rebasing
-					if (!params) {
-						return;
-					}
-					assert(op !== undefined, 0x3fd /* op should exist here */);
-					collection.ackChange(params, local, op, localOpMetadata);
-				},
-				rebase,
-			},
-		],
-	]);
-}
+	const rebasedOp = { ...op, value: rebasedValue };
+	return { rebasedOp, rebasedLocalOpMetadata: localOpMetadata };
+};
+
+export const opsMap: Record<IntervalDeltaOpType, IIntervalCollectionOperation> = {
+	[IntervalDeltaOpType.ADD]: {
+		process: (collection, params, local, op, localOpMetadata) => {
+			// if params is undefined, the interval was deleted during
+			// rebasing
+			if (!params) {
+				return;
+			}
+			assert(op !== undefined, 0x3fb /* op should exist here */);
+			collection.ackAdd(params, local, op, localOpMetadata);
+		},
+		rebase,
+	},
+
+	[IntervalDeltaOpType.DELETE]: {
+		process: (collection, params, local, op) => {
+			assert(op !== undefined, 0x3fc /* op should exist here */);
+			collection.ackDelete(params, local, op);
+		},
+		rebase: (collection, op, localOpMetadata) => {
+			// Deletion of intervals is based on id, so requires no rebasing.
+			return { rebasedOp: op, rebasedLocalOpMetadata: localOpMetadata };
+		},
+	},
+
+	[IntervalDeltaOpType.CHANGE]: {
+		process: (collection, params, local, op, localOpMetadata) => {
+			// if params is undefined, the interval was deleted during
+			// rebasing
+			if (!params) {
+				return;
+			}
+			assert(op !== undefined, 0x3fd /* op should exist here */);
+			collection.ackChange(params, local, op, localOpMetadata);
+		},
+		rebase,
+	},
+};
 
 /**
  * @legacy
@@ -579,14 +460,12 @@ export function makeOpsMap<T extends ISerializableInterval>(): Map<
  */
 export type DeserializeCallback = (properties: PropertySet) => void;
 
-class IntervalCollectionIterator<TInterval extends ISerializableInterval>
-	implements Iterator<TInterval>
-{
-	private readonly results: TInterval[];
+class IntervalCollectionIterator implements Iterator<SequenceIntervalClass> {
+	private readonly results: SequenceIntervalClass[];
 	private index: number;
 
 	constructor(
-		collection: IntervalCollection<TInterval>,
+		collection: IntervalCollection,
 		iteratesForward: boolean = true,
 		start?: number,
 		end?: number,
@@ -597,7 +476,7 @@ class IntervalCollectionIterator<TInterval extends ISerializableInterval>
 		collection.gatherIterationResults(this.results, iteratesForward, start, end);
 	}
 
-	public next(): IteratorResult<TInterval> {
+	public next(): IteratorResult<SequenceIntervalClass> {
 		if (this.index < this.results.length) {
 			return {
 				value: this.results[this.index++],
@@ -616,6 +495,7 @@ class IntervalCollectionIterator<TInterval extends ISerializableInterval>
  * Change events emitted by `IntervalCollection`s
  * @legacy
  * @alpha
+ * @remarks The generic version of this interface is no longer used and will be removed. Use {@link ISequenceIntervalCollectionEvents} instead.
  */
 export interface IIntervalCollectionEvent<TInterval extends ISerializableInterval>
 	extends IEvent {
@@ -697,11 +577,96 @@ export interface IIntervalCollectionEvent<TInterval extends ISerializableInterva
 	): void;
 }
 
+/**
+ * Change events emitted by `IntervalCollection`s
+ * @legacy
+ * @alpha
+ */
+export interface ISequenceIntervalCollectionEvents extends IEvent {
+	/**
+	 * This event is invoked whenever the endpoints of an interval may have changed.
+	 * This can happen on:
+	 * - local endpoint modification
+	 * - ack of a remote endpoint modification
+	 * - position change due to segment sliding (slides due to mergeTree segment deletion will always appear local)
+	 * The `interval` argument reflects the new values.
+	 * `previousInterval` contains transient `ReferencePosition`s at the same location as the interval's original
+	 * endpoints. These references should be used for position information only.
+	 * `local` reflects whether the change originated locally.
+	 * `op` is defined if and only if the server has acked this change.
+	 * `slide` is true if the change is due to sliding on removal of position
+	 */
+	(
+		event: "changeInterval",
+		listener: (
+			interval: SequenceInterval,
+			previousInterval: SequenceInterval,
+			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: SequenceInterval,
+			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: SequenceInterval,
+			propertyDeltas: PropertySet,
+			local: boolean,
+			op: ISequencedDocumentMessage | undefined,
+		) => void,
+	): void;
+	/**
+	 * This event is invoked whenever an interval's endpoints or properties (or both) have changed.
+	 * `interval` reflects the state of the updated endpoints or 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.
+	 * 'previousInterval' contains transient `ReferencePosition`s at the same location as the interval's original
+	 * endpoints. These references should be used for position information only. In the case of a property change
+	 * only, this argument should be undefined.
+	 * `local` reflects whether the change originated locally.
+	 * `slide` is true if the change is due to sliding on removal of position.
+	 */
+	(
+		event: "changed",
+		listener: (
+			interval: SequenceInterval,
+			propertyDeltas: PropertySet,
+			previousInterval: SequenceInterval | undefined,
+			local: boolean,
+			slide: boolean,
+		) => 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).
  * @legacy
  * @alpha
+ * @deprecated The generic version of this interface is no longer used and will be removed. Use {@link ISequenceIntervalCollection} instead.
  */
 export interface IIntervalCollection<TInterval extends ISerializableInterval>
 	extends TypedEventEmitter<IIntervalCollectionEvent<TInterval>> {
@@ -714,6 +679,7 @@ export interface IIntervalCollection<TInterval extends ISerializableInterval>
 	 * @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.
 	 */
+	// eslint-disable-next-line import/no-deprecated
 	attachIndex(index: IntervalIndex<TInterval>): void;
 	/**
 	 * Detaches an index from this collection.
@@ -722,6 +688,7 @@ export interface IIntervalCollection<TInterval extends ISerializableInterval>
 	 *
 	 * @returns `false` if the target index cannot be found in the indexes, otherwise remove all intervals in the index and return `true`.
 	 */
+	// eslint-disable-next-line import/no-deprecated
 	detachIndex(index: IntervalIndex<TInterval>): boolean;
 	/**
 	 * @returns the interval in this collection that has the provided `id`.
@@ -913,15 +880,231 @@ export interface IIntervalCollection<TInterval extends ISerializableInterval>
 	nextInterval(pos: number): TInterval | undefined;
 }
 
+/**
+ * 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).
+ * @legacy
+ * @alpha
+ */
+export interface ISequenceIntervalCollection
+	extends TypedEventEmitter<ISequenceIntervalCollectionEvents> {
+	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: SequenceIntervalIndex): 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: SequenceIntervalIndex): 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): SequenceInterval | undefined;
+	/**
+	 * 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.
+	 *
+	 * 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 @fluidframework/merge-tree#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,
+		end,
+		props,
+	}: {
+		start: SequencePlace;
+		end: SequencePlace;
+		props?: PropertySet;
+	}): SequenceInterval;
+	/**
+	 * Removes an interval from the collection.
+	 * @param id - Id of the interval to remove
+	 * @returns the removed interval
+	 */
+	removeIntervalById(id: string): SequenceInterval | 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 },
+	): SequenceInterval | undefined;
+
+	attachDeserializer(onDeserialize: DeserializeCallback): void;
+	/**
+	 * @returns an iterator over all intervals in this collection.
+	 */
+	[Symbol.iterator](): Iterator<SequenceInterval>;
+
+	/**
+	 * @returns a forward iterator over all intervals in this collection with start point equal to `startPosition`.
+	 */
+	CreateForwardIteratorWithStartPosition(startPosition: number): Iterator<SequenceInterval>;
+
+	/**
+	 * @returns a backward iterator over all intervals in this collection with start point equal to `startPosition`.
+	 */
+	CreateBackwardIteratorWithStartPosition(startPosition: number): Iterator<SequenceInterval>;
+
+	/**
+	 * @returns a forward iterator over all intervals in this collection with end point equal to `endPosition`.
+	 */
+	CreateForwardIteratorWithEndPosition(endPosition: number): Iterator<SequenceInterval>;
+
+	/**
+	 * @returns a backward iterator over all intervals in this collection with end point equal to `endPosition`.
+	 */
+	CreateBackwardIteratorWithEndPosition(endPosition: number): Iterator<SequenceInterval>;
+
+	/**
+	 * 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: SequenceInterval[],
+		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): SequenceInterval[];
+
+	/**
+	 * Applies a function to each interval in this collection.
+	 */
+	map(fn: (interval: SequenceInterval) => 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): SequenceInterval | 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);
+	 * ```
+	 */
+	nextInterval(pos: number): SequenceInterval | undefined;
+}
+
 /**
  * {@inheritdoc IIntervalCollection}
  */
-export class IntervalCollection<TInterval extends ISerializableInterval>
-	extends TypedEventEmitter<IIntervalCollectionEvent<TInterval>>
-	implements IIntervalCollection<TInterval>
+export class IntervalCollection
+	extends TypedEventEmitter<ISequenceIntervalCollectionEvents>
+	implements ISequenceIntervalCollection
 {
-	private savedSerializedIntervals?: ISerializedInterval[];
-	private localCollection: LocalIntervalCollection<TInterval> | undefined;
+	private savedSerializedIntervals?: ISerializedIntervalCollectionV1;
+	private localCollection: LocalIntervalCollection | undefined;
 	private onDeserialize: DeserializeCallback | undefined;
 	private client: Client | undefined;
 	private readonly localSeqToSerializedInterval = new Map<
@@ -932,13 +1115,13 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 		number,
 		ISerializedInterval | SerializedIntervalDelta
 	>();
-	private readonly pendingChangesStart: Map<string, ISerializedInterval[]> = new Map<
+	private readonly pendingChangesStart: Map<string, ISerializedIntervalCollectionV1> = new Map<
 		string,
-		ISerializedInterval[]
+		ISerializedIntervalCollectionV1
 	>();
-	private readonly pendingChangesEnd: Map<string, ISerializedInterval[]> = new Map<
+	private readonly pendingChangesEnd: Map<string, ISerializedIntervalCollectionV1> = new Map<
 		string,
-		ISerializedInterval[]
+		ISerializedIntervalCollectionV1
 	>();
 
 	public get attached(): boolean {
@@ -946,10 +1129,11 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 	}
 
 	constructor(
-		private readonly helpers: IIntervalHelpers<TInterval>,
-		private readonly requiresClient: boolean,
-		private readonly emitter: IValueOpEmitter,
-		serializedIntervals: ISerializedInterval[] | ISerializedIntervalCollectionV2,
+		private readonly submitDelta: (
+			op: IIntervalCollectionTypeOperationValue,
+			md: IMapMessageLocalMetadata,
+		) => void,
+		serializedIntervals: ISerializedIntervalCollectionV1 | ISerializedIntervalCollectionV2,
 		private readonly options: Partial<SequenceOptions> = {},
 	) {
 		super();
@@ -964,7 +1148,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 	/**
 	 * {@inheritdoc IIntervalCollection.attachIndex}
 	 */
-	public attachIndex(index: IntervalIndex<TInterval>): void {
+	public attachIndex(index: SequenceIntervalIndex): void {
 		if (!this.attached) {
 			throw new LoggingError("The local interval collection must exist");
 		}
@@ -978,7 +1162,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 	/**
 	 * {@inheritdoc IIntervalCollection.detachIndex}
 	 */
-	public detachIndex(index: IntervalIndex<TInterval>): boolean {
+	public detachIndex(index: SequenceIntervalIndex): boolean {
 		if (!this.attached) {
 			throw new LoggingError("The local interval collection must exist");
 		}
@@ -1068,7 +1252,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 			throw new LoggingError("Only supports one Sequence attach");
 		}
 
-		if (client === undefined && this.requiresClient) {
+		if (client === undefined) {
 			throw new LoggingError("Client required for this collection");
 		}
 
@@ -1082,10 +1266,9 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 			});
 		}
 
-		this.localCollection = new LocalIntervalCollection<TInterval>(
+		this.localCollection = new LocalIntervalCollection(
 			client,
 			label,
-			this.helpers,
 			this.options,
 			(interval, previousInterval) => this.emitChange(interval, previousInterval, true, true),
 		);
@@ -1108,7 +1291,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 					typeof endPos === "number" && endSide !== undefined
 						? { pos: endPos, side: endSide }
 						: endPos;
-				const interval = this.helpers.create(
+				const interval = createSequenceInterval(
 					label,
 					start,
 					end,
@@ -1139,8 +1322,8 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 	}
 
 	private emitChange(
-		interval: TInterval,
-		previousInterval: TInterval,
+		interval: SequenceIntervalClass,
+		previousInterval: SequenceIntervalClass,
 		local: boolean,
 		slide: boolean,
 		op?: ISequencedDocumentMessage,
@@ -1148,27 +1331,21 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 		// Temporarily make references transient so that positional queries work (non-transient refs
 		// on resolve to DetachedPosition on any segments that don't contain them). The original refType
 		// is restored as single-endpoint changes re-use previous references.
-		let startRefType: ReferenceType;
-		let endRefType: ReferenceType;
-		if (previousInterval instanceof SequenceIntervalClass) {
-			startRefType = previousInterval.start.refType;
-			endRefType = previousInterval.end.refType;
-			previousInterval.start.refType = ReferenceType.Transient;
-			previousInterval.end.refType = ReferenceType.Transient;
-			this.emit("changeInterval", interval, previousInterval, local, op, slide);
-			this.emit("changed", interval, undefined, previousInterval ?? undefined, local, slide);
-			previousInterval.start.refType = startRefType;
-			previousInterval.end.refType = endRefType;
-		} else {
-			this.emit("changeInterval", interval, previousInterval, local, op, slide);
-			this.emit("changed", interval, undefined, previousInterval ?? undefined, local, slide);
-		}
+
+		const startRefType = previousInterval.start.refType;
+		const endRefType = previousInterval.end.refType;
+		previousInterval.start.refType = ReferenceType.Transient;
+		previousInterval.end.refType = ReferenceType.Transient;
+		this.emit("changeInterval", interval, previousInterval, local, op, slide);
+		this.emit("changed", interval, undefined, previousInterval ?? undefined, local, slide);
+		previousInterval.start.refType = startRefType;
+		previousInterval.end.refType = endRefType;
 	}
 
 	/**
 	 * {@inheritdoc IIntervalCollection.getIntervalById}
 	 */
-	public getIntervalById(id: string): ISerializableIntervalPrivate<TInterval> | undefined {
+	public getIntervalById(id: string): ISerializableIntervalPrivate | undefined {
 		if (!this.localCollection) {
 			throw new LoggingError("attach must be called before accessing intervals");
 		}
@@ -1197,7 +1374,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 		start: SequencePlace;
 		end: SequencePlace;
 		props?: PropertySet;
-	}): TInterval {
+	}): SequenceIntervalClass {
 		if (!this.localCollection) {
 			throw new LoggingError("attach must be called prior to adding intervals");
 		}
@@ -1216,7 +1393,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 
 		this.assertStickinessEnabled(start, end);
 
-		const interval: TInterval = this.localCollection.addInterval(
+		const interval: SequenceIntervalClass = this.localCollection.addInterval(
 			toSequencePlace(startPos, startSide),
 			toSequencePlace(endPos, endSide),
 			IntervalType.SlideOnRemove,
@@ -1224,7 +1401,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 		);
 
 		if (interval) {
-			if (!this.isCollaborating && interval instanceof SequenceIntervalClass) {
+			if (!this.isCollaborating) {
 				setSlideOnRemove(interval.start);
 				setSlideOnRemove(interval.end);
 			}
@@ -1242,8 +1419,16 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 			if (this.isCollaborating) {
 				this.localSeqToSerializedInterval.set(localSeq, serializedInterval);
 			}
-			// Local ops get submitted to the server. Remote ops have the deserializer run.
-			this.emitter.emit("add", undefined, serializedInterval, { localSeq });
+
+			this.submitDelta(
+				{
+					opName: "add",
+					value: serializedInterval,
+				},
+				{
+					localSeq,
+				},
+			);
 		}
 
 		this.emit("addInterval", interval, true, undefined);
@@ -1252,7 +1437,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 	}
 
 	private deleteExistingInterval(
-		interval: TInterval,
+		interval: SequenceIntervalClass,
 		local: boolean,
 		op?: ISequencedDocumentMessage,
 	) {
@@ -1265,9 +1450,15 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 		if (interval) {
 			// Local ops get submitted to the server. Remote ops have the deserializer run.
 			if (local) {
-				this.emitter.emit("delete", undefined, interval.serialize(), {
-					localSeq: this.getNextLocalSeq(),
-				});
+				this.submitDelta(
+					{
+						opName: "delete",
+						value: interval.serialize(),
+					},
+					{
+						localSeq: this.getNextLocalSeq(),
+					},
+				);
 			} else {
 				if (this.onDeserialize) {
 					this.onDeserialize(interval);
@@ -1281,7 +1472,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 	/**
 	 * {@inheritdoc IIntervalCollection.removeIntervalById}
 	 */
-	public removeIntervalById(id: string): TInterval | undefined {
+	public removeIntervalById(id: string): SequenceIntervalClass | undefined {
 		if (!this.localCollection) {
 			throw new LoggingError("Attach must be called before accessing intervals");
 		}
@@ -1297,7 +1488,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 	public change(
 		id: string,
 		{ start, end, props }: { start?: SequencePlace; end?: SequencePlace; props?: PropertySet },
-	): TInterval | undefined {
+	): SequenceIntervalClass | undefined {
 		if (!this.localCollection) {
 			throw new LoggingError("Attach must be called before accessing intervals");
 		}
@@ -1325,7 +1516,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 		const interval = this.getIntervalById(id);
 		if (interval) {
 			let deltaProps: PropertySet | undefined;
-			let newInterval: TInterval | undefined;
+			let newInterval: SequenceIntervalClass | undefined;
 			if (props !== undefined) {
 				interval.propertyManager ??= new PropertiesManager();
 				deltaProps = interval.propertyManager.handleProperties(
@@ -1338,7 +1529,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 			}
 			if (start !== undefined && end !== undefined) {
 				newInterval = this.localCollection.changeInterval(interval, start, end);
-				if (!this.isCollaborating && newInterval instanceof SequenceIntervalClass) {
+				if (!this.isCollaborating && newInterval !== undefined) {
 					setSlideOnRemove(newInterval.start);
 					setSlideOnRemove(newInterval.end);
 				}
@@ -1361,7 +1552,15 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 				this.localSeqToSerializedInterval.set(localSeq, serializedInterval);
 			}
 
-			this.emitter.emit("change", undefined, serializedInterval, { localSeq });
+			this.submitDelta(
+				{
+					opName: "change",
+					value: serializedInterval,
+				},
+				{
+					localSeq,
+				},
+			);
 			if (deltaProps !== undefined) {
 				this.emit("propertyChanged", interval, deltaProps, true, undefined);
 				this.emit(
@@ -1376,10 +1575,8 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 			if (newInterval) {
 				this.addPendingChange(id, serializedInterval);
 				this.emitChange(newInterval, interval, true, false);
-				if (interval instanceof SequenceIntervalClass) {
-					this.client?.removeLocalReferencePosition(interval.start);
-					this.client?.removeLocalReferencePosition(interval.end);
-				}
+				this.client?.removeLocalReferencePosition(interval.start);
+				this.client?.removeLocalReferencePosition(interval.end);
 			}
 			return newInterval;
 		}
@@ -1482,8 +1679,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 		// strip it out of the properties here.
 		const { [reservedIntervalIdKey]: id, ...newProps } = serializedInterval.properties ?? {};
 		assert(id !== undefined, 0x3fe /* id must exist on the interval */);
-		const interval: ISerializableIntervalPrivate<TInterval> | undefined =
-			this.getIntervalById(id);
+		const interval: ISerializableIntervalPrivate | undefined = this.getIntervalById(id);
 		if (!interval) {
 			// The interval has been removed locally; no-op.
 			return;
@@ -1623,11 +1819,6 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 		}
 
 		if (localInterval !== undefined) {
-			// we know we must be using `SequenceInterval` because `this.client` exists
-			assert(
-				localInterval instanceof SequenceIntervalClass,
-				0x3a0 /* localInterval must be `SequenceInterval` when used with client */,
-			);
 			// The rebased op may place this interval's endpoints on different segments. Calling `changeInterval` here
 			// updates the local client's state to be consistent with the emitted op.
 			this.localCollection?.changeInterval(
@@ -1668,12 +1859,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 		return value;
 	}
 
-	private ackInterval(interval: TInterval, op: ISequencedDocumentMessage): void {
-		// Only SequenceIntervals need potential sliding
-		if (!(interval instanceof SequenceIntervalClass)) {
-			return;
-		}
-
+	private ackInterval(interval: SequenceIntervalClass, op: ISequencedDocumentMessage): void {
 		if (
 			!refTypeIncludesFlag(interval.start, ReferenceType.StayOnRemove) &&
 			!refTypeIncludesFlag(interval.end, ReferenceType.StayOnRemove)
@@ -1711,7 +1897,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 			}
 
 			// `interval`'s endpoints will get modified in-place, so clone it prior to doing so for event emission.
-			const oldInterval = interval.clone() as TInterval & SequenceInterval;
+			const oldInterval = interval.clone();
 
 			// In this case, where we change the start or end of an interval,
 			// it is necessary to remove and re-add the interval listeners.
@@ -1764,7 +1950,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 				oldSeg?.localRefs?.addLocalRef(oldInterval.end, oldInterval.end.getOffset());
 			}
 			this.localCollection.add(interval);
-			this.emitChange(interval, oldInterval as TInterval, true, true, op);
+			this.emitChange(interval, oldInterval, true, true, op);
 		}
 	}
 
@@ -1794,7 +1980,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 
 		this.localCollection.ensureSerializedId(serializedInterval);
 
-		const interval: TInterval = this.localCollection.addInterval(
+		const interval: SequenceIntervalClass = this.localCollection.addInterval(
 			toSequencePlace(serializedInterval.start, serializedInterval.startSide ?? Side.Before),
 			toSequencePlace(serializedInterval.end, serializedInterval.endSide ?? Side.Before),
 			serializedInterval.intervalType,
@@ -1836,19 +2022,21 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 		}
 	}
 
-	public serializeInternal(): ISerializedIntervalCollectionV2 {
+	public serializeInternal(
+		version: "1" | "2",
+	): ISerializedIntervalCollectionV1 | ISerializedIntervalCollectionV2 {
 		if (!this.localCollection) {
 			throw new LoggingError("attachSequence must be called");
 		}
 
-		return this.localCollection.serialize();
+		return this.localCollection.serialize(version);
 	}
 
 	/**
 	 * @returns an iterator over all intervals in this collection.
 	 */
-	public [Symbol.iterator](): IntervalCollectionIterator<TInterval> {
-		const iterator = new IntervalCollectionIterator<TInterval>(this);
+	public [Symbol.iterator](): IntervalCollectionIterator {
+		const iterator = new IntervalCollectionIterator(this);
 		return iterator;
 	}
 
@@ -1857,8 +2045,8 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 	 */
 	public CreateForwardIteratorWithStartPosition(
 		startPosition: number,
-	): IntervalCollectionIterator<TInterval> {
-		const iterator = new IntervalCollectionIterator<TInterval>(this, true, startPosition);
+	): IntervalCollectionIterator {
+		const iterator = new IntervalCollectionIterator(this, true, startPosition);
 		return iterator;
 	}
 
@@ -1867,8 +2055,8 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 	 */
 	public CreateBackwardIteratorWithStartPosition(
 		startPosition: number,
-	): IntervalCollectionIterator<TInterval> {
-		const iterator = new IntervalCollectionIterator<TInterval>(this, false, startPosition);
+	): IntervalCollectionIterator {
+		const iterator = new IntervalCollectionIterator(this, false, startPosition);
 		return iterator;
 	}
 
@@ -1877,13 +2065,8 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 	 */
 	public CreateForwardIteratorWithEndPosition(
 		endPosition: number,
-	): IntervalCollectionIterator<TInterval> {
-		const iterator = new IntervalCollectionIterator<TInterval>(
-			this,
-			true,
-			undefined,
-			endPosition,
-		);
+	): IntervalCollectionIterator {
+		const iterator = new IntervalCollectionIterator(this, true, undefined, endPosition);
 		return iterator;
 	}
 
@@ -1892,13 +2075,8 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 	 */
 	public CreateBackwardIteratorWithEndPosition(
 		endPosition: number,
-	): IntervalCollectionIterator<TInterval> {
-		const iterator = new IntervalCollectionIterator<TInterval>(
-			this,
-			false,
-			undefined,
-			endPosition,
-		);
+	): IntervalCollectionIterator {
+		const iterator = new IntervalCollectionIterator(this, false, undefined, endPosition);
 		return iterator;
 	}
 
@@ -1906,7 +2084,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 	 * {@inheritdoc IIntervalCollection.gatherIterationResults}
 	 */
 	public gatherIterationResults(
-		results: TInterval[],
+		results: SequenceIntervalClass[],
 		iteratesForward: boolean,
 		start?: number,
 		end?: number,
@@ -1926,7 +2104,10 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 	/**
 	 * {@inheritdoc IIntervalCollection.findOverlappingIntervals}
 	 */
-	public findOverlappingIntervals(startPosition: number, endPosition: number): TInterval[] {
+	public findOverlappingIntervals(
+		startPosition: number,
+		endPosition: number,
+	): SequenceInterval[] {
 		if (!this.localCollection) {
 			throw new LoggingError("attachSequence must be called");
 		}
@@ -1940,7 +2121,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 	/**
 	 * {@inheritdoc IIntervalCollection.map}
 	 */
-	public map(fn: (interval: TInterval) => void) {
+	public map(fn: (interval: SequenceIntervalClass) => void) {
 		if (!this.localCollection) {
 			throw new LoggingError("attachSequence must be called");
 		}
@@ -1953,7 +2134,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 	/**
 	 * {@inheritdoc IIntervalCollection.previousInterval}
 	 */
-	public previousInterval(pos: number): TInterval | undefined {
+	public previousInterval(pos: number): SequenceInterval | undefined {
 		if (!this.localCollection) {
 			throw new LoggingError("attachSequence must be called");
 		}
@@ -1964,7 +2145,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 	/**
 	 * {@inheritdoc IIntervalCollection.nextInterval}
 	 */
-	public nextInterval(pos: number): TInterval | undefined {
+	public nextInterval(pos: number): SequenceInterval | undefined {
 		if (!this.localCollection) {
 			throw new LoggingError("attachSequence must be called");
 		}
@@ -1992,7 +2173,7 @@ export interface IntervalLocator {
 	/**
 	 * Interval within that collection
 	 */
-	interval: SequenceInterval;
+	interval: SequenceIntervalClass;
 }
 
 /**