@fluidframework/sequence 2.0.0-internal.7.3.0 → 2.0.0-internal.7.4.0

package/dist/sequence-alpha.d.ts

@@ -55,140 +55,48 @@ import { SharedObject } from '@fluidframework/shared-object-base';
 import { SlidingPreference } from '@fluidframework/merge-tree';
 import { SummarySerializer } from '@fluidframework/shared-object-base';
 import { TextSegment } from '@fluidframework/merge-tree';
+import { TypedEventEmitter } from '@fluid-internal/client-utils';
 
-/**
- * Create revertibles for adding an interval
- * @alpha
- */
-export declare function appendAddIntervalToRevertibles(interval: SequenceInterval, revertibles: SharedStringRevertible[]): SharedStringRevertible[];
+/* Excluded from this release type: appendAddIntervalToRevertibles */
 
-/**
- * Create revertibles for moving endpoints of an interval
- * @alpha
- */
-export declare function appendChangeIntervalToRevertibles(string: SharedString, newInterval: SequenceInterval, previousInterval: SequenceInterval, revertibles: SharedStringRevertible[]): SharedStringRevertible[];
+/* Excluded from this release type: appendChangeIntervalToRevertibles */
 
-/**
- * Create revertibles for deleting an interval
- * @alpha
- */
-export declare function appendDeleteIntervalToRevertibles(string: SharedString, interval: SequenceInterval, revertibles: SharedStringRevertible[]): SharedStringRevertible[];
+/* Excluded from this release type: appendDeleteIntervalToRevertibles */
 
-/**
- * Create revertibles for changing properties of an interval
- * @alpha
- */
-export declare function appendIntervalPropertyChangedToRevertibles(interval: SequenceInterval, deltas: PropertySet, revertibles: SharedStringRevertible[]): SharedStringRevertible[];
+/* Excluded from this release type: appendIntervalPropertyChangedToRevertibles */
 
-/**
- * Create revertibles for SharedStringDeltas, handling indirectly modified intervals
- * (e.g. reverting remove of a range that contains an interval will move the interval back)
- *
- * @alpha
- */
-export declare function appendSharedStringDeltaToRevertibles(string: SharedString, delta: SequenceDeltaEvent, revertibles: SharedStringRevertible[]): void;
+/* Excluded from this release type: appendSharedStringDeltaToRevertibles */
 
-/**
- * @public
- */
-export declare function createEndpointIndex(sharedString: SharedString): IEndpointIndex<SequenceInterval>;
+/* Excluded from this release type: createEndpointIndex */
 
-/**
- * @public
- */
-export declare function createEndpointInRangeIndex(sharedString: SharedString): IEndpointInRangeIndex<SequenceInterval>;
+/* Excluded from this release type: createEndpointInRangeIndex */
 
-/**
- * @public
- */
-export declare function createIdIntervalIndex<TInterval extends ISerializableInterval>(): IIdIntervalIndex<TInterval>;
+/* Excluded from this release type: createIdIntervalIndex */
 
-/**
- * @public
- */
-export declare function createOverlappingIntervalsIndex(sharedString: SharedString): IOverlappingIntervalsIndex<SequenceInterval>;
+/* Excluded from this release type: createOverlappingIntervalsIndex */
 
-/**
- * @public
- */
-export declare function createOverlappingSequenceIntervalsIndex(sharedString: SharedString): SequenceIntervalIndexes.Overlapping;
+/* Excluded from this release type: createOverlappingSequenceIntervalsIndex */
 
-/**
- * @public
- */
-export declare function createStartpointInRangeIndex(sharedString: SharedString): IStartpointInRangeIndex<SequenceInterval>;
+/* Excluded from this release type: createStartpointInRangeIndex */
 
 /**
- * @public
+ * @alpha
  */
 export declare type DeserializeCallback = (properties: PropertySet) => void;
 
-/**
- * Clean up resources held by revertibles that are no longer needed.
- * @alpha
- */
-export declare function discardSharedStringRevertibles(sharedString: SharedString, revertibles: SharedStringRevertible[]): void;
+/* Excluded from this release type: discardSharedStringRevertibles */
 
-/**
- * Splits the text into regions ending with markers with the given `label`.
- * @param sharedString - String to retrieve text and markers from
- * @param label - label to split on
- * @returns Two parallel lists of text and markers, split by markers with the provided `label`.
- * For example:
- * ```typescript
- * // Say sharedstring has contents "hello<paragraph marker 1>world<paragraph marker 2>missing".
- * const { parallelText, parallelMarkers } = getTextAndMarkers(sharedString, "paragraph");
- * // parallelText === ["hello", "world"]
- * // parallelMarkers === [<paragraph marker 1 object>, <paragraph marker 2 object>]
- * // Note parallelText does not include "missing".
- * ```
- * @public
- */
-export declare function getTextAndMarkers(sharedString: SharedString, label: string, start?: number, end?: number): {
-    parallelText: string[];
-    parallelMarkers: Marker[];
-};
+/* Excluded from this release type: getTextAndMarkers */
 
-/**
- * @public
- */
-export declare interface IEndpointIndex<TInterval extends ISerializableInterval> extends IntervalIndex<TInterval> {
-    /**
-     * @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;
-    /**
-     * @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;
-}
+/* Excluded from this release type: IEndpointIndex */
 
-/**
- * Collection of intervals.
- *
- * Provide additional APIs to support efficiently querying a collection of intervals whose endpoints fall within a specified range.
- * @public
- */
-export declare interface IEndpointInRangeIndex<TInterval extends ISerializableInterval> extends IntervalIndex<TInterval> {
-    /**
-     * @returns an array of all intervals contained in this collection whose endpoints locate in the range [start, end] (includes both ends)
-     */
-    findIntervalsWithEndpointInRange(start: number, end: number): TInterval[];
-}
+/* Excluded from this release type: IEndpointInRangeIndex */
 
-/**
- * @public
- */
-export declare interface IIdIntervalIndex<TInterval extends ISerializableInterval> extends IntervalIndex<TInterval>, Iterable<TInterval> {
-    getIntervalById(id: string): TInterval | undefined;
-    [Symbol.iterator](): Iterator<TInterval>;
-}
+/* Excluded from this release type: IIdIntervalIndex */
 
 /**
  * Basic interval abstraction
- * @public
+ * @alpha
  */
 export declare interface IInterval {
     /**
@@ -215,19 +123,27 @@ export declare interface IInterval {
      * @param b - Interval to compare against
      */
     compareEnd(b: IInterval): number;
-    /* Excluded from this release type: modify */
+    /**
+     * Modifies one or more of the endpoints of this interval, returning a new interval representing the result.
+     */
+    modify(label: string, start: SequencePlace | undefined, end: SequencePlace | undefined, op?: ISequencedDocumentMessage, localSeq?: number, useNewSlidingBehavior?: boolean): IInterval | undefined;
     /**
      * @returns whether this interval overlaps with `b`.
      * Intervals are considered to overlap if their intersection is non-empty.
      */
     overlaps(b: IInterval): boolean;
-    /* Excluded from this release type: union */
+    /**
+     * Unions this interval with `b`, returning a new interval.
+     * The union operates as a convex hull, i.e. if the two intervals are disjoint, the return value includes
+     * intermediate values between the two intervals.
+     */
+    union(b: IInterval): IInterval;
 }
 
 /**
  * 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).
- * @public
+ * @alpha
  */
 export declare interface IIntervalCollection<TInterval extends ISerializableInterval> extends TypedEventEmitter<IIntervalCollectionEvent<TInterval>> {
     readonly attached: boolean;
@@ -349,6 +265,7 @@ export declare interface IIntervalCollection<TInterval extends ISerializableInte
     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 }`.
@@ -356,12 +273,26 @@ export declare interface IIntervalCollection<TInterval extends ISerializableInte
     changeProperties(id: string, props: PropertySet): any;
     /**
      * 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.
@@ -393,6 +324,14 @@ export declare interface IIntervalCollection<TInterval extends ISerializableInte
      */
     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]`.
      */
@@ -401,13 +340,34 @@ export declare interface IIntervalCollection<TInterval extends ISerializableInte
      * 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);
+     * ```
+     */
     nextInterval(pos: number): TInterval | undefined;
 }
 
 /**
  * Change events emitted by `IntervalCollection`s
- * @public
+ * @alpha
  */
 export declare interface IIntervalCollectionEvent<TInterval extends ISerializableInterval> extends IEvent {
     /**
@@ -442,37 +402,9 @@ export declare interface IIntervalCollectionEvent<TInterval extends ISerializabl
     (event: "propertyChanged", listener: (interval: TInterval, propertyDeltas: PropertySet, local: boolean, op: ISequencedDocumentMessage | undefined) => void): any;
 }
 
-/**
- * @sealed
- * @deprecated The methods within have substitutions
- * @public
- */
-export declare 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 SequencePlace} for additional context
-     * @param endSide - The side on which the end position lays. See
-     * {@link SequencePlace} for additional context
-     */
-    create(label: string, start: SequencePlace | undefined, end: SequencePlace | undefined, client: Client | undefined, intervalType: IntervalType, op?: ISequencedDocumentMessage, fromSnapshot?: boolean, useNewSlidingBehavior?: boolean): TInterval;
-}
+/* Excluded from this release type: IIntervalHelpers */
 
-/**
- * @deprecated IJSONRunSegment will be removed in a upcoming release. It has been moved to the fluid-experimental/sequence-deprecated package
- * @public
- */
-export declare interface IJSONRunSegment<T> extends IJSONSegment {
-    items: Serializable<T>[];
-}
+/* Excluded from this release type: IJSONRunSegment */
 
 /* Excluded from this release type: IMapMessageLocalMetadata */
 
@@ -480,71 +412,14 @@ export declare interface IJSONRunSegment<T> extends IJSONSegment {
  * A sequence place that does not refer to the special endpoint segments.
  *
  * See {@link SequencePlace} for additional context.
- * @public
+ * @alpha
  */
 export declare interface InteriorSequencePlace {
     pos: number;
     side: Side;
 }
 
-/**
- * Serializable interval whose endpoints are plain-old numbers.
- * @public
- */
-export declare class Interval implements ISerializableInterval {
-    start: number;
-    end: number;
-    /**
-     * {@inheritDoc ISerializableInterval.properties}
-     */
-    properties: PropertySet;
-    /* Excluded from this release type: auxProps */
-    /* Excluded from this release type: propertyManager */
-    constructor(start: number, end: number, props?: PropertySet);
-    /**
-     * {@inheritDoc ISerializableInterval.getIntervalId}
-     */
-    getIntervalId(): string;
-    /**
-     * @returns an array containing any auxiliary property sets added with `addPropertySet`.
-     */
-    getAdditionalPropertySets(): PropertySet[];
-    /**
-     * Adds an auxiliary set of properties to this interval.
-     * These properties can be recovered using `getAdditionalPropertySets`
-     * @param props - set of properties to add
-     * @remarks This gets called as part of the default conflict resolver for `IIntervalCollection<Interval>`
-     * (i.e. non-sequence-based interval collections). However, the additional properties don't get serialized.
-     * This functionality seems half-baked.
-     */
-    addPropertySet(props: PropertySet): void;
-    /* Excluded from this release type: serialize */
-    /**
-     * {@inheritDoc IInterval.clone}
-     */
-    clone(): Interval;
-    /**
-     * {@inheritDoc IInterval.compare}
-     */
-    compare(b: Interval): number;
-    /**
-     * {@inheritDoc IInterval.compareStart}
-     */
-    compareStart(b: Interval): number;
-    /**
-     * {@inheritDoc IInterval.compareEnd}
-     */
-    compareEnd(b: Interval): number;
-    /**
-     * {@inheritDoc IInterval.overlaps}
-     */
-    overlaps(b: Interval): boolean;
-    /* Excluded from this release type: union */
-    getProperties(): PropertySet;
-    /* Excluded from this release type: addProperties */
-    /* Excluded from this release type: modify */
-    private initializeProperties;
-}
+/* Excluded from this release type: Interval */
 
 /**
  * Collection of intervals.
@@ -554,7 +429,7 @@ export declare class Interval implements ISerializableInterval {
  * - "find all intervals with start endpoint between these two points"
  * - "find all intervals which overlap this range"
  * etc.
- * @public
+ * @alpha
  */
 export declare interface IntervalIndex<TInterval extends ISerializableInterval> {
     /**
@@ -571,84 +446,56 @@ export declare interface IntervalIndex<TInterval extends ISerializableInterval>
     remove(interval: TInterval): void;
 }
 
+/* Excluded from this release type: IntervalLocator */
+
+/* Excluded from this release type: intervalLocatorFromEndpoint */
+
+/* Excluded from this release type: IntervalOpType */
+
+/* Excluded from this release type: IntervalRevertible */
+
 /**
- * Information that identifies an interval within a `Sequence`.
- * @public
+ * Determines how an interval should expand when segments are inserted adjacent
+ * to the range it spans
+ *
+ * Note that interval stickiness is currently an experimental feature and must
+ * be explicitly enabled with the `intervalStickinessEnabled` flag
+ *
+ * @alpha
  */
-export declare interface IntervalLocator {
+export declare const IntervalStickiness: {
     /**
-     * Label for the collection the interval is a part of
+     * Interval does not expand to include adjacent segments
      */
-    label: string;
+    readonly NONE: 0;
     /**
-     * Interval within that collection
+     * Interval expands to include segments inserted adjacent to the start
      */
-    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.
- * @public
- */
-export declare function intervalLocatorFromEndpoint(potentialEndpoint: LocalReferencePosition): IntervalLocator | undefined;
-
-/**
- * Values are used in persisted formats (ops) and revertibles.
- * @alpha
- */
-export declare const IntervalOpType: {
-    readonly ADD: "add";
-    readonly DELETE: "delete";
-    readonly CHANGE: "change";
-    readonly PROPERTY_CHANGED: "propertyChanged";
-    readonly POSITION_REMOVE: "positionRemove";
+    readonly START: 1;
+    /**
+     * Interval expands to include segments inserted adjacent to the end
+     *
+     * This is the default stickiness
+     */
+    readonly END: 2;
+    /**
+     * Interval expands to include all segments inserted adjacent to it
+     */
+    readonly FULL: 3;
 };
 
 /**
- * Data for undoing edits affecting Intervals.
+ * Determines how an interval should expand when segments are inserted adjacent
+ * to the range it spans
  *
+ * Note that interval stickiness is currently an experimental feature and must
+ * be explicitly enabled with the `intervalStickinessEnabled` flag
  * @alpha
  */
-export declare type IntervalRevertible = {
-    event: typeof IntervalOpType.CHANGE;
-    interval: SequenceInterval;
-    start: LocalReferencePosition;
-    end: LocalReferencePosition;
-} | {
-    event: typeof IntervalOpType.ADD;
-    interval: SequenceInterval;
-} | {
-    event: typeof IntervalOpType.DELETE;
-    interval: SequenceInterval;
-    start: LocalReferencePosition;
-    end: LocalReferencePosition;
-} | {
-    event: typeof IntervalOpType.PROPERTY_CHANGED;
-    interval: SequenceInterval;
-    propertyDeltas: PropertySet;
-} | {
-    event: typeof IntervalOpType.POSITION_REMOVE;
-    intervals: {
-        intervalId: string;
-        label: string;
-        startOffset?: number;
-        endOffset?: number;
-    }[];
-    revertibleRefs: {
-        revertible: IntervalRevertible;
-        offset: number;
-        isStart: boolean;
-    }[];
-    mergeTreeRevertible: MergeTreeDeltaRevertible;
-};
-
-/* Excluded from this release type: IntervalStickiness */
+export declare type IntervalStickiness = (typeof IntervalStickiness)[keyof typeof IntervalStickiness];
 
 /**
- * @public
+ * @alpha
  */
 export declare enum IntervalType {
     Simple = 0,
@@ -666,24 +513,11 @@ export declare enum IntervalType {
     /* Excluded from this release type: Transient */
 }
 
-/**
- * @public
- */
-export declare interface IOverlappingIntervalsIndex<TInterval extends ISerializableInterval> extends IntervalIndex<TInterval> {
-    /**
-     * @returns an array of all intervals contained in this collection that overlap the range
-     * `[start end]`.
-     */
-    findOverlappingIntervals(start: SequencePlace, end: SequencePlace): TInterval[];
-    /**
-     * Gathers the interval results based on specified parameters.
-     */
-    gatherIterationResults(results: TInterval[], iteratesForward: boolean, start?: SequencePlace, end?: SequencePlace): void;
-}
+/* Excluded from this release type: IOverlappingIntervalsIndex */
 
 /**
  * A range that has changed corresponding to a segment modification.
- * @public
+ * @alpha
  */
 export declare interface ISequenceDeltaRange<TOperation extends MergeTreeDeltaOperationTypes = MergeTreeDeltaOperationTypes> {
     /**
@@ -718,14 +552,17 @@ export declare interface ISequenceDeltaRange<TOperation extends MergeTreeDeltaOp
 }
 
 /**
- * @public
+ * @alpha
  */
 export declare interface ISerializableInterval extends IInterval {
     /** Serializable bag of properties associated with the interval. */
     properties: PropertySet;
-    /* Excluded from this release type: propertyManager */
-    /* Excluded from this release type: serialize */
-    /* Excluded from this release type: addProperties */
+    /***/
+    propertyManager: PropertiesManager;
+    /***/
+    serialize(): ISerializedInterval;
+    /***/
+    addProperties(props: PropertySet, collaborating?: boolean, seq?: number): PropertySet | undefined;
     /**
      * Gets the id associated with this interval.
      * When the interval is used as part of an interval collection, this id can be used to modify or remove the
@@ -736,10 +573,38 @@ export declare interface ISerializableInterval extends IInterval {
     getIntervalId(): string | undefined;
 }
 
-/* Excluded from this release type: ISerializedInterval */
+/**
+ * Serialized object representation of an interval.
+ * This representation is used for ops that create or change intervals.
+ * @alpha
+ */
+export declare interface ISerializedInterval {
+    /**
+     * Sequence number at which `start` and `end` should be interpreted
+     *
+     * @remarks It's unclear that this is necessary to store here.
+     * This should just be the refSeq on the op that modified the interval, which should be available via other means.
+     * At the time of writing, it's not plumbed through to the reconnect/rebase code, however, which does need it.
+     */
+    sequenceNumber: number;
+    /** Start position of the interval */
+    start: number | "start" | "end";
+    /** End position of the interval */
+    end: number | "start" | "end";
+    /** Interval type to create */
+    intervalType: IntervalType;
+    /**
+     * The stickiness of this interval
+     */
+    stickiness?: IntervalStickiness;
+    startSide?: Side;
+    endSide?: Side;
+    /** Any properties the interval has */
+    properties?: PropertySet;
+}
 
 /**
- * @public
+ * @alpha
  */
 export declare interface ISharedIntervalCollection<TInterval extends ISerializableInterval> {
     getIntervalCollection(label: string): IIntervalCollection<TInterval>;
@@ -777,7 +642,7 @@ export declare interface ISharedIntervalCollection<TInterval extends ISerializab
  * - `event` - Various information on the segments that were modified.
  *
  * - `target` - The sequence itself.
- * @public
+ * @alpha
  */
 export declare interface ISharedSegmentSequenceEvents extends ISharedObjectEvents {
     (event: "createIntervalCollection", listener: (label: string, local: boolean, target: IEventThisPlaceHolder) => void): any;
@@ -787,7 +652,7 @@ export declare interface ISharedSegmentSequenceEvents extends ISharedObjectEvent
 
 /**
  * Fluid object interface describing access methods on a SharedString
- * @public
+ * @alpha
  */
 export declare interface ISharedString extends SharedSegmentSequence<SharedStringSegment> {
     /**
@@ -810,27 +675,13 @@ export declare interface ISharedString extends SharedSegmentSequence<SharedStrin
     posFromRelativePos(relativePos: IRelativePosition): number;
 }
 
-/**
- * Collection of intervals.
- *
- * Provide additional APIs to support efficiently querying a collection of intervals whose startpoints fall within a specified range.
- * @public
- */
-export declare interface IStartpointInRangeIndex<TInterval extends ISerializableInterval> extends IntervalIndex<TInterval> {
-    /**
-     * @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[];
-}
+/* Excluded from this release type: IStartpointInRangeIndex */
 
 /* Excluded from this release type: IValueOpEmitter */
 
-/**
- * Invoke revertibles to reverse prior edits
- *
- * @alpha
- */
-export declare function revertSharedStringRevertibles(sharedString: SharedString, revertibles: SharedStringRevertible[]): void;
+/* Excluded from this release type: MergeTreeDeltaRevertible */
+
+/* Excluded from this release type: revertSharedStringRevertibles */
 
 /**
  * The event object returned on sequenceDelta events.
@@ -842,7 +693,7 @@ export declare function revertSharedStringRevertibles(sharedString: SharedString
  * For group ops, each op will get its own event, and the group op property will be set on the op args.
  *
  * Ops may get multiple events. For instance, an insert-replace will get a remove then an insert event.
- * @public
+ * @alpha
  */
 export declare class SequenceDeltaEvent extends SequenceEvent<MergeTreeDeltaOperationType> {
     readonly opArgs: IMergeTreeDeltaOpArgs;
@@ -859,7 +710,7 @@ export declare class SequenceDeltaEvent extends SequenceEvent<MergeTreeDeltaOper
  * The properties of this object and its sub-objects represent the state of the sequence at the
  * point in time at which the operation was applied.
  * They will not take into any future modifications performed to the underlying sequence and merge tree.
- * @public
+ * @alpha
  */
 export declare abstract class SequenceEvent<TOperation extends MergeTreeDeltaOperationTypes = MergeTreeDeltaOperationTypes> {
     readonly deltaArgs: IMergeTreeDeltaCallbackArgs<TOperation>;
@@ -914,7 +765,7 @@ export declare abstract class SequenceEvent<TOperation extends MergeTreeDeltaOpe
  * `mergeTreeReferencesCanSlideToEndpoint` feature flag set to true, the endpoints
  * of the interval that are exclusive will have the ability to slide to these
  * special endpoint segments.
- * @public
+ * @alpha
  */
 export declare class SequenceInterval implements ISerializableInterval {
     private readonly client;
@@ -935,8 +786,12 @@ export declare class SequenceInterval implements ISerializableInterval {
      * {@inheritDoc ISerializableInterval.properties}
      */
     properties: PropertySet;
-    /* Excluded from this release type: propertyManager */
-    /* Excluded from this release type: stickiness */
+    /**
+     * {@inheritDoc ISerializableInterval.propertyManager}
+     */
+    propertyManager: PropertiesManager;
+    /***/
+    get stickiness(): IntervalStickiness;
     constructor(client: Client, 
     /**
      * Start endpoint of this interval.
@@ -949,9 +804,18 @@ export declare class SequenceInterval implements ISerializableInterval {
      */
     end: LocalReferencePosition, intervalType: IntervalType, props?: PropertySet, startSide?: Side, endSide?: Side);
     private callbacks?;
-    /* Excluded from this release type: addPositionChangeListeners */
-    /* Excluded from this release type: removePositionChangeListeners */
-    /* Excluded from this release type: serialize */
+    /**
+     * Subscribes to position change events on this interval if there are no current listeners.
+     */
+    addPositionChangeListeners(beforePositionChange: () => void, afterPositionChange: () => void): void;
+    /**
+     * Removes the currently subscribed position change listeners.
+     */
+    removePositionChangeListeners(): void;
+    /**
+     * {@inheritDoc ISerializableInterval.serialize}
+     */
+    serialize(): ISerializedInterval;
     /**
      * {@inheritDoc IInterval.clone}
      */
@@ -976,48 +840,28 @@ export declare class SequenceInterval implements ISerializableInterval {
      * {@inheritDoc ISerializableInterval.getIntervalId}
      */
     getIntervalId(): string;
-    /* Excluded from this release type: union */
-    /* Excluded from this release type: addProperties */
+    /**
+     * {@inheritDoc IInterval.union}
+     */
+    union(b: SequenceInterval): SequenceInterval;
+    /**
+     * {@inheritDoc ISerializableInterval.addProperties}
+     */
+    addProperties(newProps: PropertySet, collab?: boolean, seq?: number, op?: ICombiningOp): PropertySet | undefined;
     /**
      * @returns whether this interval overlaps two numerical positions.
      */
     overlapsPos(bstart: number, bend: number): boolean;
-    /* Excluded from this release type: modify */
+    /**
+     * {@inheritDoc IInterval.modify}
+     */
+    modify(label: string, start: SequencePlace | undefined, end: SequencePlace | undefined, op?: ISequencedDocumentMessage, localSeq?: number, useNewSlidingBehavior?: boolean): SequenceInterval;
     private initializeProperties;
 }
 
-/**
- * @deprecated The methods within have substitutions
- * @public
- */
-export declare const sequenceIntervalHelpers: IIntervalHelpers<SequenceInterval>;
+/* Excluded from this release type: sequenceIntervalHelpers */
 
-/**
- * This namespace contains specialiazations of indexes which support spatial queries
- * specifically for `SequenceInterval`s.
- * @public
- */
-export declare namespace SequenceIntervalIndexes {
-    /**
-     * Collection of intervals.
-     *
-     * Provides additional APIs to support efficiently querying a collection of intervals based on segments and offset.
-     */
-    export interface Overlapping extends IOverlappingIntervalsIndex<SequenceInterval> {
-        /**
-         * Finds overlapping intervals within the specified range.
-         *
-         * @returns an array of all intervals that overlap with the specified SegOff range (includes both ends)
-         */
-        findOverlappingIntervalsBySegoff(startSegoff: {
-            segment: ISegment | undefined;
-            offset: number | undefined;
-        }, endSegoff: {
-            segment: ISegment | undefined;
-            offset: number | undefined;
-        }): Iterable<SequenceInterval>;
-    }
-}
+/* Excluded from this release type: SequenceIntervalIndexes */
 
 /**
  * The event object returned on maintenance events.
@@ -1025,44 +869,14 @@ export declare namespace SequenceIntervalIndexes {
  * The properties of this object and its sub-objects represent the state of the sequence at the
  * point in time at which the operation was applied.
  * They will not take into consideration any future modifications performed to the underlying sequence and merge tree.
- * @public
+ * @alpha
  */
 export declare class SequenceMaintenanceEvent extends SequenceEvent<MergeTreeMaintenanceType> {
     readonly opArgs: IMergeTreeDeltaOpArgs | undefined;
     constructor(opArgs: IMergeTreeDeltaOpArgs | undefined, deltaArgs: IMergeTreeMaintenanceCallbackArgs, mergeTreeClient: Client);
 }
 
-/**
- * Optional flags that configure options for sequence DDSs
- * @public
- */
-export declare interface SequenceOptions {
-    /**
-     * Enable the ability to use interval APIs that rely on positions before and
-     * after individual characters, referred to as "sides". See {@link SequencePlace}
-     * for additional context.
-     *
-     * This flag must be enabled to pass instances of {@link SequencePlace} to
-     * any IIntervalCollection API.
-     *
-     * Also see the feature flag `mergeTreeReferencesCanSlideToEndpoint` to allow
-     * endpoints to slide to the special endpoint segments.
-     *
-     * The default value is false.
-     */
-    intervalStickinessEnabled: boolean;
-    /**
-     * Enable the ability for interval endpoints to slide to the special endpoint
-     * segments that exist before and after the bounds of the string. This is
-     * primarily useful for workflows involving interval stickiness, and it is
-     * suggested to enable both this flag and `intervalStickinessEnabled` at the
-     * same time.
-     *
-     * The default value is false.
-     */
-    mergeTreeReferencesCanSlideToEndpoint: boolean;
-    [key: string]: boolean;
-}
+/* Excluded from this release type: SequenceOptions */
 
 /**
  * Defines a position and side relative to a character in a sequence.
@@ -1087,81 +901,37 @@ export declare interface SequenceOptions {
  * 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.
- * @public
+ * @alpha
  */
 export declare type SequencePlace = number | "start" | "end" | InteriorSequencePlace;
 
 /* Excluded from this release type: SerializedIntervalDelta */
 
-/**
- * @deprecated `SharedIntervalCollection` is not maintained and is planned to be removed.
- * @public
- */
-export declare class SharedIntervalCollection extends SharedObject implements ISharedIntervalCollection<Interval> {
-    /**
-     * Create a SharedIntervalCollection
-     *
-     * @param runtime - data store runtime the new shared map belongs to
-     * @param id - optional name of the shared map
-     * @returns newly create shared map (but not attached yet)
-     */
-    static create(runtime: IFluidDataStoreRuntime, id?: string): SharedIntervalCollection;
-    /**
-     * Get a factory for SharedIntervalCollection to register with the data store.
-     *
-     * @returns a factory that creates and load SharedIntervalCollection
-     */
-    static getFactory(): IChannelFactory;
-    readonly [Symbol.toStringTag]: string;
-    private readonly intervalCollections;
-    /**
-     * Constructs a new shared SharedIntervalCollection. If the object is non-local an id and service interfaces will
-     * be provided
-     */
-    constructor(id: string, runtime: IFluidDataStoreRuntime, attributes: IChannelAttributes);
-    getIntervalCollection(label: string): IIntervalCollection<Interval>;
-    protected summarizeCore(serializer: IFluidSerializer): ISummaryTreeWithStats;
-    protected reSubmitCore(content: any, localOpMetadata: unknown): void;
-    protected onDisconnect(): void;
-    /**
-     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.loadCore}
-     */
-    protected loadCore(storage: IChannelStorageService): Promise<void>;
-    protected processCore(message: ISequencedDocumentMessage, local: boolean, localOpMetadata: unknown): void;
-    /**
-     * Creates the full path of the intervalCollection label
-     * @param label - the incoming label
-     */
-    protected getIntervalCollectionPath(label: string): string;
-    protected applyStashedOp(): void;
-}
+/* Excluded from this release type: SharedIntervalCollection */
 
-/**
- * The factory that defines the SharedIntervalCollection.
- * @deprecated `SharedIntervalCollection` is not maintained and is planned to be removed.
- * @public
- */
-export declare class SharedIntervalCollectionFactory implements IChannelFactory {
-    static readonly Type = "https://graph.microsoft.com/types/sharedIntervalCollection";
-    static readonly Attributes: IChannelAttributes;
-    get type(): string;
-    get attributes(): IChannelAttributes;
-    /**
-     * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory.load}
-     */
-    load(runtime: IFluidDataStoreRuntime, id: string, services: IChannelServices, attributes: IChannelAttributes): Promise<SharedIntervalCollection>;
-    create(runtime: IFluidDataStoreRuntime, id: string): SharedIntervalCollection;
-}
+/* Excluded from this release type: SharedIntervalCollectionFactory */
 
 /**
- * @public
+ * @alpha
  */
 export declare abstract class SharedSegmentSequence<T extends ISegment> extends SharedObject<ISharedSegmentSequenceEvents> implements ISharedIntervalCollection<SequenceInterval>, MergeTreeRevertibleDriver {
     private readonly dataStoreRuntime;
     id: string;
     readonly segmentFromSpec: (spec: IJSONSegment) => ISegment;
     get loaded(): Promise<void>;
-    /* Excluded from this release type: guardReentrancy */
+    /**
+     * This is a safeguard to avoid problematic reentrancy of local ops. This type of scenario occurs if the user of SharedString subscribes
+     * to the `sequenceDelta` event and uses the callback for a local op to submit further local ops.
+     * Historically (before 2.0.0-internal.6.1.0), doing so would result in eventual consistency issues or a corrupted document.
+     * These issues were fixed in #16815 which makes such reentrancy no different from applying the ops in order but not from within the change events,
+     * but there is still little test coverage for reentrant scenarios.
+     * Additionally, applications submitting ops from inside change events need to take extreme care that their data models also support reentrancy.
+     * Since this is likely not the case, by default SharedString throws when encountering reentrant ops.
+     *
+     * An application using SharedString which explicitly wants to opt in to allowing reentrancy anyway can set `sharedStringPreventReentrancy`
+     * on the data store options to `false`.
+     */
+    protected guardReentrancy: <TRet>(callback: () => TRet) => TRet;
     private static createOpsFromDelta;
     protected client: Client;
     /** `Deferred` that triggers once the object is loaded */
@@ -1368,36 +1138,7 @@ export declare abstract class SharedSegmentSequence<T extends ISegment> extends
     private initializeIntervalCollections;
 }
 
-/**
- * @deprecated SharedSequence will be removed in a upcoming release. It has been moved to the fluid-experimental/sequence-deprecated package
- * @public
- */
-export declare class SharedSequence<T> extends SharedSegmentSequence<SubSequence<T>> {
-    id: string;
-    constructor(document: IFluidDataStoreRuntime, id: string, attributes: IChannelAttributes, specToSegment: (spec: IJSONSegment) => ISegment);
-    /**
-     * @param pos - The position to insert the items at.
-     * @param items - The items to insert.
-     * @param props - Optional. Properties to set on the inserted items.
-     */
-    insert(pos: number, items: Serializable<T>[], props?: PropertySet): void;
-    /**
-     * @param start - The inclusive start of the range to remove
-     * @param end - The exclusive end of the range to remove
-     */
-    remove(start: number, end: number): void;
-    /**
-     * Returns the total count of items in the sequence
-     */
-    getItemCount(): number;
-    /**
-     * Gets the items in the specified range
-     *
-     * @param start - The inclusive start of the range
-     * @param end - The exclusive end of the range
-     */
-    getItems(start: number, end?: number): Serializable<T>[];
-}
+/* Excluded from this release type: SharedSequence */
 
 /**
  * The Shared String is a specialized data structure for handling collaborative
@@ -1407,8 +1148,7 @@ export declare class SharedSequence<T> extends SharedSegmentSequence<SubSequence
  * In addition to text, a Shared String can also contain markers. Markers can be
  * used to store metadata at positions within the text, like the details of an
  * image or Fluid object that should be rendered with the text.
- *
- * @public
+ * @alpha
  */
 export declare class SharedString extends SharedSegmentSequence<SharedStringSegment> implements ISharedString {
     id: string;
@@ -1469,6 +1209,10 @@ export declare class SharedString extends SharedSegmentSequence<SharedStringSegm
      * @param marker - The marker to annotate
      * @param props - The properties to annotate the marker with
      * @param consensusCallback - The callback called when consensus is reached
+     *
+     * @deprecated We no longer intend to support this functionality and it will
+     * be removed in a future release. There is no replacement for this
+     * functionality.
      */
     annotateMarkerNotifyConsensus(marker: Marker, props: PropertySet, callback: (m: Marker) => void): void;
     /**
@@ -1524,7 +1268,7 @@ export declare class SharedString extends SharedSegmentSequence<SharedStringSegm
 }
 
 /**
- * @public
+ * @alpha
  */
 export declare class SharedStringFactory implements IChannelFactory {
     static Type: string;
@@ -1539,15 +1283,10 @@ export declare class SharedStringFactory implements IChannelFactory {
     create(document: IFluidDataStoreRuntime, id: string): SharedString;
 }
 
-/**
- * Data for undoing edits on SharedStrings and Intervals.
- *
- * @alpha
- */
-export declare type SharedStringRevertible = MergeTreeDeltaRevertible | IntervalRevertible;
+/* Excluded from this release type: SharedStringRevertible */
 
 /**
- * @public
+ * @alpha
  */
 export declare type SharedStringSegment = TextSegment | Marker;
 
@@ -1555,33 +1294,13 @@ export declare type SharedStringSegment = TextSegment | Marker;
  * Defines a side relative to a character in a sequence.
  *
  * @remarks See {@link SequencePlace} for additional context on usage.
- * @public
+ * @alpha
  */
 export declare enum Side {
     Before = 0,
     After = 1
 }
 
-/**
- * @deprecated SubSequence will be removed in a upcoming release. It has been moved to the fluid-experimental/sequence-deprecated package
- * @public
- */
-export declare class SubSequence<T> extends BaseSegment {
-    items: Serializable<T>[];
-    static readonly typeString: string;
-    static is(segment: ISegment): segment is SubSequence<any>;
-    static fromJSONObject<U>(spec: Serializable): SubSequence<U> | undefined;
-    readonly type: string;
-    constructor(items: Serializable<T>[]);
-    toJSONObject(): IJSONRunSegment<T>;
-    clone(start?: number, end?: number): SubSequence<T>;
-    canAppend(segment: ISegment): boolean;
-    toString(): string;
-    append(segment: ISegment): void;
-    removeRange(start: number, end: number): boolean;
-    protected createSplitSegmentAt(pos: number): SubSequence<T> | undefined;
-}
-
-/* Excluded from this release type: TypedEventEmitter */
+/* Excluded from this release type: SubSequence */
 
 export { }