@fluidframework/sequence 2.30.0 → 2.31.1

package/src/intervalIndex/endpointIndex.ts

@@ -7,49 +7,39 @@
 
 import { Client, RedBlackTree } from "@fluidframework/merge-tree/internal";
 
-import {
-	IIntervalHelpers,
-	ISerializableInterval,
-	IntervalType,
-	SequenceInterval,
-	sequenceIntervalHelpers,
-} from "../intervals/index.js";
+import { createSequenceInterval, IntervalType, SequenceInterval } from "../intervals/index.js";
 import { ISharedString } from "../sharedString.js";
 
-import { IntervalIndex } from "./intervalIndex.js";
+import { type SequenceIntervalIndex } from "./intervalIndex.js";
 
 /**
  * @internal
  */
-export interface IEndpointIndex<TInterval extends ISerializableInterval>
-	extends IntervalIndex<TInterval> {
+export interface IEndpointIndex extends SequenceIntervalIndex {
 	/**
 	 * @returns the previous interval based on the given position number.
 	 * If no such interval exists in this index, returns `undefined`
 	 */
-	previousInterval(pos: number): TInterval | undefined;
+	previousInterval(pos: number): SequenceInterval | undefined;
 
 	/**
 	 * @returns the next interval based on the given position number.
 	 * If no such interval exists in this index, returns `undefined`
 	 */
-	nextInterval(pos: number): TInterval | undefined;
+	nextInterval(pos: number): SequenceInterval | undefined;
 }
 
-export class EndpointIndex<TInterval extends ISerializableInterval>
-	implements IEndpointIndex<TInterval>
-{
-	private readonly endIntervalTree: RedBlackTree<TInterval, TInterval>;
+export class EndpointIndex implements IEndpointIndex {
+	private readonly endIntervalTree: RedBlackTree<SequenceInterval, SequenceInterval>;
 
-	constructor(
-		private readonly client: Client,
-		private readonly helpers: IIntervalHelpers<TInterval>,
-	) {
-		this.endIntervalTree = new RedBlackTree<TInterval, TInterval>((a, b) => a.compareEnd(b));
+	constructor(private readonly client: Client) {
+		this.endIntervalTree = new RedBlackTree<SequenceInterval, SequenceInterval>((a, b) =>
+			a.compareEnd(b),
+		);
 	}
 
-	public previousInterval(pos: number): TInterval | undefined {
-		const transientInterval = this.helpers.create(
+	public previousInterval(pos: number): SequenceInterval | undefined {
+		const transientInterval = createSequenceInterval(
 			"transient",
 			pos,
 			pos,
@@ -62,8 +52,8 @@ export class EndpointIndex<TInterval extends ISerializableInterval>
 		}
 	}
 
-	public nextInterval(pos: number): TInterval | undefined {
-		const transientInterval = this.helpers.create(
+	public nextInterval(pos: number): SequenceInterval | undefined {
+		const transientInterval = createSequenceInterval(
 			"transient",
 			pos,
 			pos,
@@ -76,11 +66,11 @@ export class EndpointIndex<TInterval extends ISerializableInterval>
 		}
 	}
 
-	public add(interval: TInterval): void {
+	public add(interval: SequenceInterval): void {
 		this.endIntervalTree.put(interval, interval);
 	}
 
-	public remove(interval: TInterval): void {
+	public remove(interval: SequenceInterval): void {
 		this.endIntervalTree.remove(interval);
 	}
 }
@@ -88,9 +78,7 @@ export class EndpointIndex<TInterval extends ISerializableInterval>
 /**
  * @internal
  */
-export function createEndpointIndex(
-	sharedString: ISharedString,
-): IEndpointIndex<SequenceInterval> {
+export function createEndpointIndex(sharedString: ISharedString): IEndpointIndex {
 	const client = (sharedString as unknown as { client: Client }).client;
-	return new EndpointIndex<SequenceInterval>(client, sequenceIntervalHelpers);
+	return new EndpointIndex(client);
 }

package/src/intervalIndex/idIntervalIndex.ts

@@ -6,26 +6,21 @@
 import { assert } from "@fluidframework/core-utils/internal";
 
 import { reservedIntervalIdKey } from "../intervalCollection.js";
-import { ISerializableInterval } from "../intervals/index.js";
+import { type SequenceIntervalClass } from "../intervals/index.js";
 
-import { IntervalIndex } from "./intervalIndex.js";
+import { type SequenceIntervalIndex } from "./intervalIndex.js";
 
-/**
- * @internal
- */
-export interface IIdIntervalIndex<TInterval extends ISerializableInterval>
-	extends IntervalIndex<TInterval>,
-		Iterable<TInterval> {
-	getIntervalById(id: string): TInterval | undefined;
+export interface IIdIntervalIndex
+	extends SequenceIntervalIndex,
+		Iterable<SequenceIntervalClass> {
+	getIntervalById(id: string): SequenceIntervalClass | undefined;
 
-	[Symbol.iterator](): Iterator<TInterval>;
+	[Symbol.iterator](): Iterator<SequenceIntervalClass>;
 }
-class IdIntervalIndex<TInterval extends ISerializableInterval>
-	implements IIdIntervalIndex<TInterval>, Iterable<TInterval>
-{
-	private readonly intervalIdMap = new Map<string, TInterval>();
+class IdIntervalIndex implements IIdIntervalIndex, Iterable<SequenceIntervalClass> {
+	private readonly intervalIdMap = new Map<string, SequenceIntervalClass>();
 
-	public add(interval: TInterval) {
+	public add(interval: SequenceIntervalClass) {
 		const id = interval.getIntervalId();
 		assert(
 			id !== undefined,
@@ -40,26 +35,21 @@ class IdIntervalIndex<TInterval extends ISerializableInterval>
 		this.intervalIdMap.set(id, interval);
 	}
 
-	public remove(interval: TInterval) {
+	public remove(interval: SequenceIntervalClass) {
 		const id = interval.getIntervalId();
 		assert(id !== undefined, 0x311 /* expected id to exist on interval */);
 		this.intervalIdMap.delete(id);
 	}
 
-	public getIntervalById(id: string): TInterval | undefined {
+	public getIntervalById(id: string): SequenceIntervalClass | undefined {
 		return this.intervalIdMap.get(id);
 	}
 
-	public [Symbol.iterator](): IterableIterator<TInterval> {
+	public [Symbol.iterator](): IterableIterator<SequenceIntervalClass> {
 		return this.intervalIdMap.values();
 	}
 }
 
-/**
- * @internal
- */
-export function createIdIntervalIndex<
-	TInterval extends ISerializableInterval,
->(): IIdIntervalIndex<TInterval> {
-	return new IdIntervalIndex<TInterval>();
+export function createIdIntervalIndex(): IIdIntervalIndex {
+	return new IdIntervalIndex();
 }

package/src/intervalIndex/index.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-export { IntervalIndex } from "./intervalIndex.js";
+export { IntervalIndex, SequenceIntervalIndex } from "./intervalIndex.js";
 export { IIdIntervalIndex, createIdIntervalIndex } from "./idIntervalIndex.js";
 export { IEndpointIndex, createEndpointIndex, EndpointIndex } from "./endpointIndex.js";
 export {
@@ -21,5 +21,6 @@ export {
 	IOverlappingIntervalsIndex,
 	createOverlappingIntervalsIndex,
 	OverlappingIntervalsIndex,
+	ISequenceOverlappingIntervalsIndex,
 } from "./overlappingIntervalsIndex.js";
 export { createOverlappingSequenceIntervalsIndex } from "./overlappingSequenceIntervalsIndex.js";

package/src/intervalIndex/intervalIndex.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { ISerializableInterval } from "../intervals/index.js";
+import { ISerializableInterval, type SequenceInterval } from "../intervals/index.js";
 
 /**
  * Collection of intervals.
@@ -15,6 +15,8 @@ import { ISerializableInterval } from "../intervals/index.js";
  * etc.
  * @legacy
  * @alpha
+ *
+ * @remarks The generic version of this interface is no longer used and will be removed. Use {@link SequenceIntervalIndex} instead.
  */
 export interface IntervalIndex<TInterval extends ISerializableInterval> {
 	/**
@@ -31,3 +33,30 @@ export interface IntervalIndex<TInterval extends ISerializableInterval> {
 	 */
 	remove(interval: TInterval): void;
 }
+
+/**
+ * Collection of intervals.
+ *
+ * Implementers of this interface will typically implement additional APIs to support efficiently querying a collection
+ * of intervals in some manner, for example:
+ * - "find all intervals with start endpoint between these two points"
+ * - "find all intervals which overlap this range"
+ * etc.
+ * @legacy
+ * @alpha
+ */
+export interface SequenceIntervalIndex {
+	/**
+	 * Adds an interval to the index.
+	 * @remarks Application code should never need to invoke this method on their index for production scenarios:
+	 * Fluid handles adding and removing intervals from an index in response to sequence or interval changes.
+	 */
+	add(interval: SequenceInterval): void;
+
+	/**
+	 * Removes an interval from the index.
+	 * @remarks Application code should never need to invoke this method on their index for production scenarios:
+	 * Fluid handles adding and removing intervals from an index in response to sequence or interval changes.
+	 */
+	remove(interval: SequenceInterval): void;
+}

package/src/intervalIndex/overlappingIntervalsIndex.ts

@@ -13,19 +13,21 @@ import {
 
 import { IntervalNode, IntervalTree } from "../intervalTree.js";
 import {
-	IIntervalHelpers,
 	ISerializableInterval,
 	IntervalType,
 	SequenceInterval,
-	sequenceIntervalHelpers,
+	createSequenceInterval,
 } from "../intervals/index.js";
 import { ISharedString } from "../sharedString.js";
 
-import { IntervalIndex } from "./intervalIndex.js";
+import { IntervalIndex, type SequenceIntervalIndex } from "./intervalIndex.js";
 
 /**
+ * The generic version of this interface is deprecated and will be removed in a future release.
+ * Use {@link ISequenceOverlappingIntervalsIndex} instead.
  * @legacy
  * @alpha
+ * @remarks The generic version of this interface is no longer used and will be removed. Use {@link ISequenceOverlappingIntervalsIndex} instead.
  */
 export interface IOverlappingIntervalsIndex<TInterval extends ISerializableInterval>
 	extends IntervalIndex<TInterval> {
@@ -46,28 +48,46 @@ export interface IOverlappingIntervalsIndex<TInterval extends ISerializableInter
 	): void;
 }
 
-export class OverlappingIntervalsIndex<TInterval extends ISerializableInterval>
-	implements IOverlappingIntervalsIndex<TInterval>
-{
-	protected readonly intervalTree = new IntervalTree<TInterval>();
+/**
+ * @legacy
+ * @alpha
+ */
+export interface ISequenceOverlappingIntervalsIndex extends SequenceIntervalIndex {
+	/**
+	 * @returns an array of all intervals contained in this collection that overlap the range
+	 * `[start end]`.
+	 */
+	findOverlappingIntervals(start: SequencePlace, end: SequencePlace): SequenceInterval[];
+
+	/**
+	 * Gathers the interval results based on specified parameters.
+	 */
+	gatherIterationResults(
+		results: SequenceInterval[],
+		iteratesForward: boolean,
+		start?: SequencePlace,
+		end?: SequencePlace,
+	): void;
+}
+
+export class OverlappingIntervalsIndex implements ISequenceOverlappingIntervalsIndex {
+	protected readonly intervalTree = new IntervalTree<SequenceInterval>();
 	protected readonly client: Client;
-	protected readonly helpers: IIntervalHelpers<TInterval>;
 
-	constructor(client: Client, helpers: IIntervalHelpers<TInterval>) {
+	constructor(client: Client) {
 		this.client = client;
-		this.helpers = helpers;
 	}
 
-	public map(fn: (interval: TInterval) => void) {
+	public map(fn: (interval: SequenceInterval) => void) {
 		this.intervalTree.map(fn);
 	}
 
-	public mapUntil(fn: (interval: TInterval) => boolean) {
+	public mapUntil(fn: (interval: SequenceInterval) => boolean) {
 		this.intervalTree.mapUntil(fn);
 	}
 
 	public gatherIterationResults(
-		results: TInterval[],
+		results: SequenceInterval[],
 		iteratesForward: boolean,
 		start?: SequencePlace,
 		end?: SequencePlace,
@@ -79,16 +99,16 @@ export class OverlappingIntervalsIndex<TInterval extends ISerializableInterval>
 		if (start === undefined && end === undefined) {
 			// No start/end provided. Gather the whole tree in the specified order.
 			if (iteratesForward) {
-				this.intervalTree.map((interval: TInterval) => {
+				this.intervalTree.map((interval: SequenceInterval) => {
 					results.push(interval);
 				});
 			} else {
-				this.intervalTree.mapBackward((interval: TInterval) => {
+				this.intervalTree.mapBackward((interval: SequenceInterval) => {
 					results.push(interval);
 				});
 			}
 		} else {
-			const transientInterval: TInterval = this.helpers.create(
+			const transientInterval: SequenceInterval = createSequenceInterval(
 				"transient",
 				start ?? "start",
 				end ?? "end",
@@ -100,13 +120,13 @@ export class OverlappingIntervalsIndex<TInterval extends ISerializableInterval>
 				// Only end position provided. Since the tree is not sorted by end position,
 				// walk the whole tree in the specified order, gathering intervals that match the end.
 				if (iteratesForward) {
-					this.intervalTree.map((interval: TInterval) => {
+					this.intervalTree.map((interval: SequenceInterval) => {
 						if (transientInterval.compareEnd(interval) === 0) {
 							results.push(interval);
 						}
 					});
 				} else {
-					this.intervalTree.mapBackward((interval: TInterval) => {
+					this.intervalTree.mapBackward((interval: SequenceInterval) => {
 						if (transientInterval.compareEnd(interval) === 0) {
 							results.push(interval);
 						}
@@ -117,15 +137,15 @@ export class OverlappingIntervalsIndex<TInterval extends ISerializableInterval>
 				// this start position.
 				const compareFn =
 					end === undefined
-						? (node: IntervalNode<TInterval>) => {
+						? (node: IntervalNode<SequenceInterval>) => {
 								return transientInterval.compareStart(node.key);
 							}
-						: (node: IntervalNode<TInterval>) => {
+						: (node: IntervalNode<SequenceInterval>) => {
 								return transientInterval.compare(node.key);
 							};
 				const continueLeftFn = (cmpResult: number) => cmpResult <= 0;
 				const continueRightFn = (cmpResult: number) => cmpResult >= 0;
-				const actionFn = (node: IntervalNode<TInterval>) => {
+				const actionFn = (node: IntervalNode<SequenceInterval>) => {
 					results.push(node.key);
 				};
 
@@ -148,7 +168,10 @@ export class OverlappingIntervalsIndex<TInterval extends ISerializableInterval>
 		}
 	}
 
-	public findOverlappingIntervals(start: SequencePlace, end: SequencePlace): TInterval[] {
+	public findOverlappingIntervals(
+		start: SequencePlace,
+		end: SequencePlace,
+	): SequenceInterval[] {
 		const { startPos, endPos } = endpointPosAndSide(start, end);
 
 		if (
@@ -161,7 +184,7 @@ export class OverlappingIntervalsIndex<TInterval extends ISerializableInterval>
 		) {
 			return [];
 		}
-		const transientInterval = this.helpers.create(
+		const transientInterval = createSequenceInterval(
 			"transient",
 			start,
 			end,
@@ -173,11 +196,11 @@ export class OverlappingIntervalsIndex<TInterval extends ISerializableInterval>
 		return overlappingIntervalNodes.map((node) => node.key);
 	}
 
-	public remove(interval: TInterval) {
+	public remove(interval: SequenceInterval) {
 		this.intervalTree.removeExisting(interval);
 	}
 
-	public add(interval: TInterval) {
+	public add(interval: SequenceInterval) {
 		this.intervalTree.put(interval);
 	}
 }
@@ -188,7 +211,7 @@ export class OverlappingIntervalsIndex<TInterval extends ISerializableInterval>
  */
 export function createOverlappingIntervalsIndex(
 	sharedString: ISharedString,
-): IOverlappingIntervalsIndex<SequenceInterval> {
+): ISequenceOverlappingIntervalsIndex {
 	const client = (sharedString as unknown as { client: Client }).client;
-	return new OverlappingIntervalsIndex<SequenceInterval>(client, sequenceIntervalHelpers);
+	return new OverlappingIntervalsIndex(client);
 }

package/src/intervalIndex/overlappingSequenceIntervalsIndex.ts

@@ -18,7 +18,6 @@ import {
 	SequenceInterval,
 	SequenceIntervalClass,
 	createPositionReferenceFromSegoff,
-	sequenceIntervalHelpers,
 } from "../intervals/index.js";
 import { ISharedString } from "../sharedString.js";
 
@@ -26,11 +25,11 @@ import { OverlappingIntervalsIndex } from "./overlappingIntervalsIndex.js";
 import { SequenceIntervalIndexes } from "./sequenceIntervalIndexes.js";
 
 class OverlappingSequenceIntervalsIndex
-	extends OverlappingIntervalsIndex<SequenceInterval>
+	extends OverlappingIntervalsIndex
 	implements SequenceIntervalIndexes.Overlapping
 {
 	constructor(client: Client) {
-		super(client, sequenceIntervalHelpers);
+		super(client);
 	}
 
 	public findOverlappingIntervalsBySegoff(

package/src/intervalIndex/sequenceIntervalIndexes.ts

@@ -7,7 +7,7 @@ import { ISegment } from "@fluidframework/merge-tree/internal";
 
 import { SequenceInterval } from "../intervals/index.js";
 
-import { IOverlappingIntervalsIndex } from "./overlappingIntervalsIndex.js";
+import { type ISequenceOverlappingIntervalsIndex } from "./overlappingIntervalsIndex.js";
 
 /**
  * This namespace contains specialiazations of indexes which support spatial queries
@@ -22,7 +22,7 @@ export namespace SequenceIntervalIndexes {
 	 * Provides additional APIs to support efficiently querying a collection of intervals based on segments and offset.
 	 * @internal
 	 */
-	export interface Overlapping extends IOverlappingIntervalsIndex<SequenceInterval> {
+	export interface Overlapping extends ISequenceOverlappingIntervalsIndex {
 		/**
 		 * Finds overlapping intervals within the specified range.
 		 *

package/src/intervalIndex/startpointInRangeIndex.ts

@@ -7,16 +7,10 @@
 
 import { Client, PropertyAction, RedBlackTree } from "@fluidframework/merge-tree/internal";
 
-import {
-	IIntervalHelpers,
-	ISerializableInterval,
-	IntervalType,
-	SequenceInterval,
-	sequenceIntervalHelpers,
-} from "../intervals/index.js";
+import { IntervalType, SequenceInterval, createSequenceInterval } from "../intervals/index.js";
 import { ISharedString } from "../sharedString.js";
 
-import { IntervalIndex } from "./intervalIndex.js";
+import { type SequenceIntervalIndex } from "./intervalIndex.js";
 import {
 	HasComparisonOverride,
 	compareOverrideables,
@@ -29,25 +23,19 @@ import {
  * Provide additional APIs to support efficiently querying a collection of intervals whose startpoints fall within a specified range.
  * @internal
  */
-export interface IStartpointInRangeIndex<TInterval extends ISerializableInterval>
-	extends IntervalIndex<TInterval> {
+export interface IStartpointInRangeIndex extends SequenceIntervalIndex {
 	/**
 	 * @returns an array of all intervals contained in this collection whose startpoints locate in the range [start, end] (includes both ends)
 	 */
-	findIntervalsWithStartpointInRange(start: number, end: number): TInterval[];
+	findIntervalsWithStartpointInRange(start: number, end: number): SequenceInterval[];
 }
 
-export class StartpointInRangeIndex<TInterval extends ISerializableInterval>
-	implements IStartpointInRangeIndex<TInterval>
-{
+export class StartpointInRangeIndex implements IStartpointInRangeIndex {
 	private readonly intervalTree;
 
-	constructor(
-		private readonly client: Client,
-		private readonly helpers: IIntervalHelpers<TInterval>,
-	) {
-		this.intervalTree = new RedBlackTree<TInterval, TInterval>(
-			(a: TInterval, b: TInterval) => {
+	constructor(private readonly client: Client) {
+		this.intervalTree = new RedBlackTree<SequenceInterval, SequenceInterval>(
+			(a: SequenceInterval, b: SequenceInterval) => {
 				const compareStartsResult = a.compareStart(b);
 				if (compareStartsResult !== 0) {
 					return compareStartsResult;
@@ -70,25 +58,25 @@ export class StartpointInRangeIndex<TInterval extends ISerializableInterval>
 		);
 	}
 
-	public add(interval: TInterval): void {
+	public add(interval: SequenceInterval): void {
 		this.intervalTree.put(interval, interval);
 	}
 
-	public remove(interval: TInterval): void {
+	public remove(interval: SequenceInterval): void {
 		this.intervalTree.remove(interval);
 	}
 
-	public findIntervalsWithStartpointInRange(start: number, end: number): TInterval[] {
+	public findIntervalsWithStartpointInRange(start: number, end: number): SequenceInterval[] {
 		if (start <= 0 || start > end || this.intervalTree.isEmpty()) {
 			return [];
 		}
-		const results: TInterval[] = [];
-		const action: PropertyAction<TInterval, TInterval> = (node) => {
+		const results: SequenceInterval[] = [];
+		const action: PropertyAction<SequenceInterval, SequenceInterval> = (node) => {
 			results.push(node.data);
 			return true;
 		};
 
-		const transientStartInterval = this.helpers.create(
+		const transientStartInterval = createSequenceInterval(
 			"transient",
 			start,
 			start,
@@ -96,7 +84,7 @@ export class StartpointInRangeIndex<TInterval extends ISerializableInterval>
 			IntervalType.Transient,
 		);
 
-		const transientEndInterval = this.helpers.create(
+		const transientEndInterval = createSequenceInterval(
 			"transient",
 			end,
 			end,
@@ -117,7 +105,7 @@ export class StartpointInRangeIndex<TInterval extends ISerializableInterval>
  */
 export function createStartpointInRangeIndex(
 	sharedString: ISharedString,
-): IStartpointInRangeIndex<SequenceInterval> {
+): IStartpointInRangeIndex {
 	const client = (sharedString as unknown as { client: Client }).client;
-	return new StartpointInRangeIndex<SequenceInterval>(client, sequenceIntervalHelpers);
+	return new StartpointInRangeIndex(client);
 }

package/src/intervals/index.ts

@@ -10,7 +10,6 @@ export {
 	IntervalOpType,
 	IntervalType,
 	IntervalDeltaOpType,
-	IIntervalHelpers,
 	IntervalStickiness,
 	ISerializableIntervalPrivate,
 	SerializedIntervalDelta,
@@ -18,11 +17,9 @@ export {
 	endReferenceSlidingPreference,
 	startReferenceSlidingPreference,
 } from "./intervalUtils.js";
-export { Interval, createInterval, intervalHelpers } from "./interval.js";
 export {
 	SequenceInterval,
 	SequenceIntervalClass,
 	createSequenceInterval,
 	createPositionReferenceFromSegoff,
-	sequenceIntervalHelpers,
 } from "./sequenceInterval.js";

package/src/intervals/intervalUtils.ts

@@ -7,9 +7,6 @@
 
 import { ISequencedDocumentMessage } from "@fluidframework/driver-definitions/internal";
 import {
-	// eslint-disable-next-line import/no-deprecated
-	Client,
-	// eslint-disable-next-line import/no-deprecated
 	PropertiesManager,
 	PropertySet,
 	SlidingPreference,
@@ -17,6 +14,8 @@ import {
 	Side,
 } from "@fluidframework/merge-tree/internal";
 
+import type { SequenceIntervalClass } from "./sequenceInterval.js";
+
 /**
  * Basic interval abstraction
  * @legacy
@@ -172,7 +171,7 @@ export interface ISerializableInterval extends IInterval {
 	getIntervalId(): string;
 }
 
-export type ISerializableIntervalPrivate<T extends ISerializableInterval> = T & {
+export type ISerializableIntervalPrivate = SequenceIntervalClass & {
 	propertyManager?: PropertiesManager;
 };
 
@@ -215,40 +214,6 @@ export type CompressedSerializedInterval =
 	  ]
 	| [number | "start" | "end", number | "start" | "end", number, IntervalType, PropertySet];
 
-/**
- * @sealed
- * @deprecated The methods within have substitutions
- * @internal
- */
-export interface IIntervalHelpers<TInterval extends ISerializableInterval> {
-	/**
-	 *
-	 * @param label - label of the interval collection this interval is being added to. This parameter is
-	 * irrelevant for transient intervals.
-	 * @param start - numerical start position of the interval
-	 * @param end - numerical end position of the interval
-	 * @param client - client creating the interval
-	 * @param intervalType - Type of interval to create. Default is SlideOnRemove
-	 * @param op - If this create came from a remote client, op that created it. Default is undefined (i.e. local)
-	 * @param fromSnapshot - If this create came from loading a snapshot. Default is false.
-	 * @param startSide - The side on which the start position lays. See
-	 * {@link @fluidframework/merge-tree#SequencePlace} for additional context
-	 * @param endSide - The side on which the end position lays. See
-	 * {@link @fluidframework/merge-tree#SequencePlace} for additional context
-	 */
-	create(
-		label: string,
-		start: SequencePlace | undefined,
-		end: SequencePlace | undefined,
-		// eslint-disable-next-line import/no-deprecated
-		client: Client | undefined,
-		intervalType: IntervalType,
-		op?: ISequencedDocumentMessage,
-		fromSnapshot?: boolean,
-		useNewSlidingBehavior?: boolean,
-	): TInterval;
-}
-
 /**
  * Determines how an interval should expand when segments are inserted adjacent
  * to the range it spans