@fluidframework/sequence 2.0.0-rc.2.0.1 → 2.0.0-rc.3.0.0

package/dist/sequence-alpha.d.ts

@@ -1,1432 +0,0 @@
-/**
- * Supports distributed data structures which are list-like.
- *
- * This library's main export is {@link SharedString}, a DDS for storing and simultaneously editing a sequence of
- * text.
- *
- * See the package's README for a high-level introduction to `SharedString`'s feature set.
- * @remarks Note that SharedString is a sequence DDS but it has additional specialized features and behaviors for
- * working with text.
- *
- * @packageDocumentation
- */
-
-import { BaseSegment } from '@fluidframework/merge-tree';
-import { Client } from '@fluidframework/merge-tree';
-import { Deferred } from '@fluidframework/core-utils';
-import { IChannelAttributes } from '@fluidframework/datastore-definitions';
-import { IChannelFactory } from '@fluidframework/datastore-definitions';
-import { IChannelServices } from '@fluidframework/datastore-definitions';
-import { IChannelStorageService } from '@fluidframework/datastore-definitions';
-import { IEvent } from '@fluidframework/core-interfaces';
-import { IEventThisPlaceHolder } from '@fluidframework/core-interfaces';
-import { IFluidDataStoreRuntime } from '@fluidframework/datastore-definitions';
-import { IFluidSerializer } from '@fluidframework/shared-object-base';
-import { IJSONSegment } from '@fluidframework/merge-tree';
-import { IMergeTreeDeltaCallbackArgs } from '@fluidframework/merge-tree';
-import { IMergeTreeDeltaOpArgs } from '@fluidframework/merge-tree';
-import { IMergeTreeGroupMsg } from '@fluidframework/merge-tree';
-import { IMergeTreeMaintenanceCallbackArgs } from '@fluidframework/merge-tree';
-import { IRelativePosition } from '@fluidframework/merge-tree';
-import { ISegment } from '@fluidframework/merge-tree';
-import { ISegmentAction } from '@fluidframework/merge-tree';
-import { ISequencedDocumentMessage } from '@fluidframework/protocol-definitions';
-import { ISharedObjectEvents } from '@fluidframework/shared-object-base';
-import { ISummaryTreeWithStats } from '@fluidframework/runtime-definitions';
-import { ITelemetryContext } from '@fluidframework/runtime-definitions';
-import { LocalReferencePosition } from '@fluidframework/merge-tree';
-import { MapLike } from '@fluidframework/merge-tree';
-import { Marker } from '@fluidframework/merge-tree';
-import { MergeTreeDeltaOperationType } from '@fluidframework/merge-tree';
-import { MergeTreeDeltaOperationTypes } from '@fluidframework/merge-tree';
-import { MergeTreeDeltaRevertible } from '@fluidframework/merge-tree';
-import { MergeTreeDeltaType } from '@fluidframework/merge-tree';
-import { MergeTreeMaintenanceType } from '@fluidframework/merge-tree';
-import { MergeTreeRevertibleDriver } from '@fluidframework/merge-tree';
-import { PropertiesManager } from '@fluidframework/merge-tree';
-import { PropertySet } from '@fluidframework/merge-tree';
-import { ReferencePosition } from '@fluidframework/merge-tree';
-import { ReferenceType } from '@fluidframework/merge-tree';
-import { reservedMarkerIdKey } from '@fluidframework/merge-tree';
-import { reservedRangeLabelsKey } from '@fluidframework/merge-tree';
-import { reservedTileLabelsKey } from '@fluidframework/merge-tree';
-import { Serializable } from '@fluidframework/datastore-definitions';
-import { SharedObject } from '@fluidframework/shared-object-base';
-import { SlidingPreference } from '@fluidframework/merge-tree';
-import { TextSegment } from '@fluidframework/merge-tree';
-import { TrackingGroup } 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[];
-
-/**
- * Create revertibles for moving endpoints of an interval
- * @alpha
- */
-export declare function appendChangeIntervalToRevertibles(string: SharedString, newInterval: SequenceInterval, previousInterval: SequenceInterval, revertibles: SharedStringRevertible[]): SharedStringRevertible[];
-
-/**
- * Create revertibles for deleting an interval
- * @alpha
- */
-export declare function appendDeleteIntervalToRevertibles(string: SharedString, interval: SequenceInterval, revertibles: SharedStringRevertible[]): SharedStringRevertible[];
-
-/**
- * Create revertibles for changing properties of an interval
- * @alpha
- */
-export declare function appendIntervalPropertyChangedToRevertibles(interval: SequenceInterval, deltas: PropertySet, revertibles: SharedStringRevertible[]): SharedStringRevertible[];
-
-/**
- * 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;
-
-export { BaseSegment }
-
-/* Excluded from this release type: createEndpointIndex */
-
-/* Excluded from this release type: createEndpointInRangeIndex */
-
-/* Excluded from this release type: createIdIntervalIndex */
-
-/**
- * @alpha
- */
-export declare function createOverlappingIntervalsIndex(sharedString: SharedString): IOverlappingIntervalsIndex<SequenceInterval>;
-
-/* Excluded from this release type: createOverlappingSequenceIntervalsIndex */
-
-/* Excluded from this release type: createStartpointInRangeIndex */
-
-/**
- * @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: getTextAndMarkers */
-
-/* Excluded from this release type: IEndpointIndex */
-
-/* Excluded from this release type: IEndpointInRangeIndex */
-
-/* Excluded from this release type: IIdIntervalIndex */
-
-/**
- * Basic interval abstraction
- * @alpha
- */
-export declare interface IInterval {
-    /**
-     * @returns a new interval object with identical semantics.
-     */
-    clone(): IInterval;
-    /**
-     * Compares this interval to `b` with standard comparator semantics:
-     * - returns -1 if this is less than `b`
-     * - returns 1 if this is greater than `b`
-     * - returns 0 if this is equivalent to `b`
-     * @param b - Interval to compare against
-     */
-    compare(b: IInterval): number;
-    /**
-     * Compares the start endpoint of this interval to `b`'s start endpoint.
-     * Standard comparator semantics apply.
-     * @param b - Interval to compare against
-     */
-    compareStart(b: IInterval): number;
-    /**
-     * Compares the end endpoint of this interval to `b`'s end endpoint.
-     * Standard comparator semantics apply.
-     * @param b - Interval to compare against
-     */
-    compareEnd(b: IInterval): number;
-    /**
-     * 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;
-    /**
-     * 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).
- * @alpha
- */
-export declare interface IIntervalCollection<TInterval extends ISerializableInterval> extends TypedEventEmitter<IIntervalCollectionEvent<TInterval>> {
-    readonly attached: boolean;
-    /**
-     * Attaches an index to this collection.
-     * All intervals which are part of this collection will be added to the index, and the index will automatically
-     * be updated when this collection updates due to local or remote changes.
-     *
-     * @remarks After attaching an index to an interval collection, applications should typically store this
-     * index somewhere in their in-memory data model for future reference and querying.
-     */
-    attachIndex(index: IntervalIndex<TInterval>): void;
-    /**
-     * Detaches an index from this collection.
-     * All intervals which are part of this collection will be removed from the index, and updates to this collection
-     * due to local or remote changes will no longer incur updates to the index.
-     *
-     * @returns `false` if the target index cannot be found in the indexes, otherwise remove all intervals in the index and return `true`.
-     */
-    detachIndex(index: IntervalIndex<TInterval>): boolean;
-    /**
-     * @returns the interval in this collection that has the provided `id`.
-     * If no interval in the collection has this `id`, returns `undefined`.
-     */
-    getIntervalById(id: string): TInterval | undefined;
-    /**
-     * Creates a new interval and add it to the collection.
-     * @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 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;
-    }): TInterval;
-    /**
-     * Removes an interval from the collection.
-     * @param id - Id of the interval to remove
-     * @returns the removed interval
-     */
-    removeIntervalById(id: string): TInterval | undefined;
-    /**
-     * Changes the endpoints, properties, or both of an existing interval.
-     * @param id - Id of the Interval to change
-     * @returns the interval that was changed, if it existed in the collection.
-     * Pass the desired new start position, end position, and/or properties in an object. Start and end positions must be changed
-     * simultaneously - they must either both be specified or both undefined. To only change the properties, leave both endpoints
-     * undefined. To only change the endpoints, leave the properties undefined.
-     */
-    change(id: string, { start, end, props }: {
-        start?: SequencePlace;
-        end?: SequencePlace;
-        props?: PropertySet;
-    }): TInterval | undefined;
-    attachDeserializer(onDeserialize: DeserializeCallback): void;
-    /**
-     * @returns an iterator over all intervals in this collection.
-     */
-    [Symbol.iterator](): Iterator<TInterval>;
-    /**
-     * @returns a forward iterator over all intervals in this collection with start point equal to `startPosition`.
-     */
-    CreateForwardIteratorWithStartPosition(startPosition: number): Iterator<TInterval>;
-    /**
-     * @returns a backward iterator over all intervals in this collection with start point equal to `startPosition`.
-     */
-    CreateBackwardIteratorWithStartPosition(startPosition: number): Iterator<TInterval>;
-    /**
-     * @returns a forward iterator over all intervals in this collection with end point equal to `endPosition`.
-     */
-    CreateForwardIteratorWithEndPosition(endPosition: number): Iterator<TInterval>;
-    /**
-     * @returns a backward iterator over all intervals in this collection with end point equal to `endPosition`.
-     */
-    CreateBackwardIteratorWithEndPosition(endPosition: number): Iterator<TInterval>;
-    /**
-     * Gathers iteration results that optionally match a start/end criteria into the provided array.
-     * @param results - Array to gather the results into. In lieu of a return value, this array will be populated with
-     * intervals matching the query upon edit.
-     * @param iteratesForward - whether or not iteration should be in the forward direction
-     * @param start - If provided, only match intervals whose start point is equal to `start`.
-     * @param end - If provided, only match intervals whose end point is equal to `end`.
-     */
-    gatherIterationResults(results: TInterval[], iteratesForward: boolean, start?: number, end?: number): void;
-    /**
-     * @deprecated - Users must manually attach the corresponding interval index to utilize this functionality, for instance:
-     *
-     * ```typescript
-     * const overlappingIntervalsIndex = createOverlappingIntervalsIndex(sharedString);
-     * collection.attachIndex(overlappingIntervalsIndex)
-     * const result = overlappingIntervalsIndex.findOverlappingIntervals(start, end);
-     * ```
-     *
-     * @returns an array of all intervals in this collection that overlap with the interval
-     * `[startPosition, endPosition]`.
-     */
-    findOverlappingIntervals(startPosition: number, endPosition: number): TInterval[];
-    /**
-     * Applies a function to each interval in this collection.
-     */
-    map(fn: (interval: TInterval) => void): void;
-    /**
-     * @deprecated - due to the forthcoming change where the endpointIndex will no longer be
-     * automatically added to the collection. Users are advised to independently attach the
-     * index to the collection and utilize the API accordingly, for instance:
-     * ```typescript
-     * const endpointIndex = createEndpointIndex(sharedString);
-     * collection.attachIndex(endpointIndex);
-     * const result1 = endpointIndex.previousInterval(pos);
-     * ```
-     * If an index is used repeatedly, applications should generally attach it once and store it in memory.
-     */
-    previousInterval(pos: number): TInterval | undefined;
-    /**
-     * @deprecated - due to the forthcoming change where the endpointIndex will no longer be
-     * automatically added to the collection. Users are advised to independently attach the
-     * index to the collection and utilize the API accordingly, for instance:
-     * ```typescript
-     * const endpointIndex = createEndpointIndex(sharedString);
-     * collection.attachIndex(endpointIndex);
-     * const result2 = endpointIndex.nextInterval(pos);
-     * ```
-     */
-    nextInterval(pos: number): TInterval | undefined;
-}
-
-/**
- * Change events emitted by `IntervalCollection`s
- * @alpha
- */
-export declare interface IIntervalCollectionEvent<TInterval extends ISerializableInterval> 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: TInterval, previousInterval: TInterval, local: boolean, op: ISequencedDocumentMessage | undefined, slide: boolean) => void): void;
-    /**
-     * This event is invoked whenever an interval is added or removed from the collection.
-     * `local` reflects whether the change originated locally.
-     * `op` is defined if and only if the server has acked this change.
-     */
-    (event: "addInterval" | "deleteInterval", listener: (interval: TInterval, local: boolean, op: ISequencedDocumentMessage | undefined) => void): void;
-    /**
-     * This event is invoked whenever an interval's properties have changed.
-     * `interval` reflects the state of the updated properties.
-     * `propertyDeltas` is a map-like whose keys contain all values that were changed, and whose
-     * values contain all previous values of the property set.
-     * This object can be used directly in a call to `changeProperties` to revert the property change if desired.
-     * `local` reflects whether the change originated locally.
-     * `op` is defined if and only if the server has acked this change.
-     */
-    (event: "propertyChanged", listener: (interval: TInterval, propertyDeltas: PropertySet, local: boolean, op: ISequencedDocumentMessage | undefined) => void): void;
-    /**
-     * 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: TInterval, propertyDeltas: PropertySet, previousInterval: TInterval | undefined, local: boolean, slide: boolean) => void): void;
-}
-
-/* Excluded from this release type: IIntervalHelpers */
-
-/* Excluded from this release type: IJSONRunSegment */
-
-/* Excluded from this release type: IMapMessageLocalMetadata */
-
-/**
- * A sequence place that does not refer to the special endpoint segments.
- *
- * See {@link SequencePlace} for additional context.
- * @alpha
- */
-export declare interface InteriorSequencePlace {
-    pos: number;
-    side: Side;
-}
-
-/* Excluded from this release type: Interval */
-
-/**
- * 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.
- * @alpha
- */
-export declare interface IntervalIndex<TInterval extends ISerializableInterval> {
-    /**
-     * 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: TInterval): 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: TInterval): void;
-}
-
-/* Excluded from this release type: IntervalLocator */
-
-/* Excluded from this release type: intervalLocatorFromEndpoint */
-
-/**
- * Values are used in revertibles.
- * @alpha
- */
-export declare const IntervalOpType: {
-    readonly PROPERTY_CHANGED: "propertyChanged";
-    readonly POSITION_REMOVE: "positionRemove";
-    readonly ADD: "add";
-    readonly DELETE: "delete";
-    readonly CHANGE: "change";
-};
-
-/**
- * @alpha
- */
-export declare type IntervalOpType = (typeof IntervalOpType)[keyof typeof IntervalOpType];
-
-/**
- * Data for undoing edits affecting Intervals.
- * @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;
-};
-
-/**
- * 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 const IntervalStickiness: {
-    /**
-     * Interval does not expand to include adjacent segments
-     */
-    readonly NONE: 0;
-    /**
-     * Interval expands to include segments inserted adjacent to the start
-     */
-    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;
-};
-
-/**
- * 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 IntervalStickiness = (typeof IntervalStickiness)[keyof typeof IntervalStickiness];
-
-/**
- * @alpha
- */
-export declare enum IntervalType {
-    Simple = 0,
-    /**
-     * SlideOnRemove indicates that the ends of the interval will slide if the segment
-     * they reference is removed and acked.
-     * See `packages\dds\merge-tree\docs\REFERENCEPOSITIONS.md` for details
-     * SlideOnRemove is the default interval behavior and does not need to be specified.
-     */
-    SlideOnRemove = 2,
-    /* Excluded from this release type: Transient */
-}
-
-/**
- * @alpha
- */
-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;
-}
-
-export { ISegment }
-
-/**
- * A range that has changed corresponding to a segment modification.
- * @alpha
- */
-export declare interface ISequenceDeltaRange<TOperation extends MergeTreeDeltaOperationTypes = MergeTreeDeltaOperationTypes> {
-    /**
-     * The type of operation that changed this range.
-     *
-     * @remarks Consuming code should typically compare this to the enum values defined in
-     * `MergeTreeDeltaOperationTypes`.
-     */
-    operation: TOperation;
-    /**
-     * The index of the start of the range.
-     */
-    position: number;
-    /**
-     * The segment that corresponds to the range.
-     */
-    segment: ISegment;
-    /**
-     * Deltas object which contains all modified properties with their previous values.
-     * Since `undefined` doesn't survive a round-trip through JSON serialization, the old value being absent
-     * is instead encoded with `null`.
-     *
-     * @remarks This object is motivated by undo/redo scenarios, and provides a convenient "inverse op" to apply to
-     * undo a property change.
-     *
-     * @example
-     *
-     * If a segment initially had properties `{ foo: "1", bar: 2 }` and it was annotated with
-     * `{ foo: 3, baz: 5 }`, the corresponding event would have a `propertyDeltas` of `{ foo: "1", baz: null }`.
-     */
-    propertyDeltas: PropertySet;
-}
-
-/**
- * @alpha
- */
-export declare interface ISerializableInterval extends IInterval {
-    /** Serializable bag of properties associated with the interval. */
-    properties: PropertySet;
-    /***/
-    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
-     * interval.
-     * @remarks This signature includes `undefined` strictly for backwards-compatibility reasons, as older versions
-     * of Fluid didn't always write interval ids.
-     */
-    getIntervalId(): string | undefined;
-}
-
-/**
- * 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;
-}
-
-/**
- * @alpha
- */
-export declare interface ISharedIntervalCollection<TInterval extends ISerializableInterval> {
-    getIntervalCollection(label: string): IIntervalCollection<TInterval>;
-}
-
-/**
- * Events emitted in response to changes to the sequence data.
- *
- * @remarks
- *
- * The following is the list of events emitted.
- *
- * ### "sequenceDelta"
- *
- * The sequenceDelta event is emitted when segments are inserted, annotated, or removed.
- *
- * #### Listener signature
- *
- * ```typescript
- * (event: SequenceDeltaEvent, target: IEventThisPlaceHolder) => void
- * ```
- * - `event` - Various information on the segments that were modified.
- *
- * - `target` - The sequence itself.
- *
- * ### "maintenance"
- *
- * The maintenance event is emitted when segments are modified during merge-tree maintenance.
- *
- * #### Listener signature
- *
- * ```typescript
- * (event: SequenceMaintenanceEvent, target: IEventThisPlaceHolder) => void
- * ```
- * - `event` - Various information on the segments that were modified.
- *
- * - `target` - The sequence itself.
- * @alpha
- */
-export declare interface ISharedSegmentSequenceEvents extends ISharedObjectEvents {
-    (event: "createIntervalCollection", listener: (label: string, local: boolean, target: IEventThisPlaceHolder) => void): void;
-    (event: "sequenceDelta", listener: (event: SequenceDeltaEvent, target: IEventThisPlaceHolder) => void): void;
-    (event: "maintenance", listener: (event: SequenceMaintenanceEvent, target: IEventThisPlaceHolder) => void): void;
-}
-
-/**
- * Fluid object interface describing access methods on a SharedString
- * @alpha
- */
-export declare interface ISharedString extends SharedSegmentSequence<SharedStringSegment> {
-    /**
-     * Inserts the text at the position.
-     * @param pos - The position to insert the text at
-     * @param text - The text to insert
-     * @param props - The properties of the text
-     */
-    insertText(pos: number, text: string, props?: PropertySet): void;
-    /**
-     * Inserts a marker at the position.
-     * @param pos - The position to insert the marker at
-     * @param refType - The reference type of the marker
-     * @param props - The properties of the marker
-     */
-    insertMarker(pos: number, refType: ReferenceType, props?: PropertySet): void;
-    /**
-     * {@inheritDoc SharedSegmentSequence.posFromRelativePos}
-     */
-    posFromRelativePos(relativePos: IRelativePosition): number;
-}
-
-/* Excluded from this release type: IStartpointInRangeIndex */
-
-/* Excluded from this release type: IValueOpEmitter */
-export { LocalReferencePosition }
-
-export { MapLike }
-
-export { Marker }
-
-export { MergeTreeDeltaType }
-
-export { PropertySet }
-
-export { ReferencePosition }
-
-export { ReferenceType }
-
-/* Excluded from this release type: reservedMarkerIdKey */
-
-/* Excluded from this release type: reservedRangeLabelsKey */
-
-/* Excluded from this release type: reservedTileLabelsKey */
-
-/**
- * Invoke revertibles to reverse prior edits
- * @alpha
- */
-export declare function revertSharedStringRevertibles(sharedString: SharedString, revertibles: SharedStringRevertible[]): void;
-
-/**
- * The event object returned on sequenceDelta events.
- *
- * 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.
- *
- * 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.
- * @alpha
- */
-export declare class SequenceDeltaEvent extends SequenceEvent<MergeTreeDeltaOperationType> {
-    readonly opArgs: IMergeTreeDeltaOpArgs;
-    /**
-     * Whether the event was caused by a locally-made change.
-     */
-    readonly isLocal: boolean;
-    constructor(opArgs: IMergeTreeDeltaOpArgs, deltaArgs: IMergeTreeDeltaCallbackArgs, mergeTreeClient: Client);
-}
-
-/**
- * Base class for SequenceDeltaEvent and SequenceMaintenanceEvent.
- *
- * 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.
- * @alpha
- */
-export declare abstract class SequenceEvent<TOperation extends MergeTreeDeltaOperationTypes = MergeTreeDeltaOperationTypes> {
-    readonly deltaArgs: IMergeTreeDeltaCallbackArgs<TOperation>;
-    private readonly mergeTreeClient;
-    readonly deltaOperation: TOperation;
-    private readonly sortedRanges;
-    private readonly pFirst;
-    private readonly pLast;
-    constructor(deltaArgs: IMergeTreeDeltaCallbackArgs<TOperation>, mergeTreeClient: Client);
-    /**
-     * The in-order ranges affected by this delta.
-     * These may not be continuous.
-     */
-    get ranges(): readonly Readonly<ISequenceDeltaRange<TOperation>>[];
-    /**
-     * The client id of the client that made the change which caused the delta event
-     */
-    get clientId(): string | undefined;
-    /**
-     * The first of the modified ranges.
-     */
-    get first(): Readonly<ISequenceDeltaRange<TOperation>>;
-    /**
-     * The last of the modified ranges.
-     */
-    get last(): Readonly<ISequenceDeltaRange<TOperation>>;
-}
-
-/**
- * Interval implementation whose ends are associated with positions in a mutatable sequence.
- * As such, when content is inserted into the middle of the interval, the interval expands to
- * include that content.
- *
- * @remarks The endpoints' positions should be treated exclusively to get
- * reasonable behavior. E.g., an interval referring to "hello" in "hello world"
- * should have a start position of 0 and an end position of 5.
- *
- * To see why, consider what happens if "llo wor" is removed from the string to make "held".
- * The interval's startpoint remains on the "h" (it isn't altered), but the interval's endpoint
- * slides forward to the next unremoved position, which is the "l" in "held".
- * Users would generally expect the interval to now refer to "he" (as it is the subset of content
- * remaining after the removal), hence the "l" should be excluded.
- * If the interval endpoint was treated inclusively, the interval would now refer to "hel", which
- * is undesirable.
- *
- * Since the endpoints of an interval are treated exclusively but cannot be greater
- * than or equal to the length of the associated sequence, there exist special
- * endpoint segments, "start" and "end", which represent the position immediately
- * before or immediately after the string respectively.
- *
- * If a `SequenceInterval` is created on a sequence with the
- * `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.
- * @alpha
- */
-export declare class SequenceInterval implements ISerializableInterval {
-    private readonly client;
-    /**
-     * Start endpoint of this interval.
-     * @remarks This endpoint can be resolved into a character position using the SharedString it's a part of.
-     */
-    start: LocalReferencePosition;
-    /**
-     * End endpoint of this interval.
-     * @remarks This endpoint can be resolved into a character position using the SharedString it's a part of.
-     */
-    end: LocalReferencePosition;
-    intervalType: IntervalType;
-    readonly startSide: Side;
-    readonly endSide: Side;
-    /**
-     * {@inheritDoc ISerializableInterval.properties}
-     */
-    properties: PropertySet;
-    /**
-     * {@inheritDoc ISerializableInterval.propertyManager}
-     */
-    propertyManager: PropertiesManager;
-    /***/
-    get stickiness(): IntervalStickiness;
-    constructor(client: Client, 
-    /**
-     * Start endpoint of this interval.
-     * @remarks This endpoint can be resolved into a character position using the SharedString it's a part of.
-     */
-    start: LocalReferencePosition, 
-    /**
-     * End endpoint of this interval.
-     * @remarks This endpoint can be resolved into a character position using the SharedString it's a part of.
-     */
-    end: LocalReferencePosition, intervalType: IntervalType, props?: PropertySet, startSide?: Side, endSide?: Side);
-    private callbacks?;
-    /**
-     * 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}
-     */
-    clone(): SequenceInterval;
-    /**
-     * {@inheritDoc IInterval.compare}
-     */
-    compare(b: SequenceInterval): number;
-    /**
-     * {@inheritDoc IInterval.compareStart}
-     */
-    compareStart(b: SequenceInterval): number;
-    /**
-     * {@inheritDoc IInterval.compareEnd}
-     */
-    compareEnd(b: SequenceInterval): number;
-    /**
-     * {@inheritDoc IInterval.overlaps}
-     */
-    overlaps(b: SequenceInterval): boolean;
-    /**
-     * {@inheritDoc ISerializableInterval.getIntervalId}
-     */
-    getIntervalId(): string;
-    /**
-     * {@inheritDoc IInterval.union}
-     */
-    union(b: SequenceInterval): SequenceInterval;
-    /**
-     * {@inheritDoc ISerializableInterval.addProperties}
-     */
-    addProperties(newProps: PropertySet, collab?: boolean, seq?: number): PropertySet | undefined;
-    /**
-     * @returns whether this interval overlaps two numerical positions.
-     */
-    overlapsPos(bstart: number, bend: number): boolean;
-    /**
-     * {@inheritDoc IInterval.modify}
-     */
-    modify(label: string, start: SequencePlace | undefined, end: SequencePlace | undefined, op?: ISequencedDocumentMessage, localSeq?: number, useNewSlidingBehavior?: boolean): SequenceInterval;
-}
-
-/* Excluded from this release type: sequenceIntervalHelpers */
-
-/* Excluded from this release type: SequenceIntervalIndexes */
-
-/**
- * The event object returned on maintenance events.
- *
- * 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.
- * @alpha
- */
-export declare class SequenceMaintenanceEvent extends SequenceEvent<MergeTreeMaintenanceType> {
-    readonly opArgs: IMergeTreeDeltaOpArgs | undefined;
-    constructor(opArgs: IMergeTreeDeltaOpArgs | undefined, deltaArgs: IMergeTreeMaintenanceCallbackArgs, mergeTreeClient: Client);
-}
-
-/* Excluded from this release type: SequenceOptions */
-
-/**
- * Defines a position and side relative to a character in a sequence.
- *
- * For this purpose, sequences look like:
- *
- * `{start} - {character 0} - {character 1} - ... - {character N} - {end}`
- *
- * Each `{value}` in the diagram is a character within a sequence.
- * Each `-` in the above diagram is a position where text could be inserted.
- * Each position between a `{value}` and a `-` is a `SequencePlace`.
- *
- * The special endpoints `{start}` and `{end}` refer to positions outside the
- * contents of the string.
- *
- * This gives us 2N + 2 possible positions to refer to within a string, where N
- * is the number of characters.
- *
- * If the position is specified with a bare number, the side defaults to
- * `Side.Before`.
- *
- * If a SequencePlace is the endpoint of a range (e.g. start/end of an interval or search range),
- * the Side value means it is exclusive if it is nearer to the other position and inclusive if it is farther.
- * E.g. the start of a range with Side.After is exclusive of the character at the position.
- * @alpha
- */
-export declare type SequencePlace = number | "start" | "end" | InteriorSequencePlace;
-
-/* Excluded from this release type: SerializedIntervalDelta */
-
-/* Excluded from this release type: SharedIntervalCollection */
-
-/* Excluded from this release type: SharedIntervalCollectionFactory */
-
-/**
- * @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>;
-    /**
-     * 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;
-    /**
-     * Note: this field only provides a lower-bound on the reference sequence numbers for in-flight ops.
-     * The exact reason isn't understood, but some e2e tests suggest that the runtime may sometimes process
-     * incoming leave/join ops before putting an op that this DDS submits over the wire.
-     *
-     * E.g. SharedString submits an op while deltaManager has lastSequenceNumber = 10, but before the runtime
-     * puts this op over the wire, it processes a client join/leave op with sequence number 11, so the referenceSequenceNumber
-     * on the SharedString op is 11.
-     *
-     * The reference sequence numbers placed in this queue are also not accurate for stashed ops due to how the applyStashedOp
-     * flow works at the runtime level. This is a legitimate bug, and AB#6602 tracks one way to fix it (stop reaching all the way
-     * to deltaManager's lastSequenceNumber to obtain refSeq, instead leveraging some analogous notion on the container or datastore
-     * runtime).
-     */
-    private readonly inFlightRefSeqs;
-    private ongoingResubmitRefSeq;
-    /**
-     * Gets the reference sequence number (i.e. sequence number of the runtime's last processed op) for an op submitted
-     * in the current context.
-     *
-     * This value can be optionally overridden using `useResubmitRefSeq`.
-     * IntervalCollection's resubmit logic currently relies on preserving merge information from when the op was originally submitted,
-     * even if the op is resubmitted more than once. Thus during resubmit, `inFlightRefSeqs` gets populated with the
-     * original refSeq rather than the refSeq at the time of reconnection.
-     *
-     * @remarks - In some not fully understood cases, the runtime may process incoming ops before putting an op that this
-     * DDS submits over the wire. See `inFlightRefSeqs` for more details.
-     */
-    private get currentRefSeq();
-    protected client: Client;
-    /** `Deferred` that triggers once the object is loaded */
-    protected loadedDeferred: Deferred<void>;
-    private readonly loadedDeferredOutgoingOps;
-    private deferIncomingOps;
-    private readonly loadedDeferredIncomingOps;
-    private messagesSinceMSNChange;
-    private readonly intervalCollections;
-    constructor(dataStoreRuntime: IFluidDataStoreRuntime, id: string, attributes: IChannelAttributes, segmentFromSpec: (spec: IJSONSegment) => ISegment);
-    /**
-     * @param start - The inclusive start of the range to remove
-     * @param end - The exclusive end of the range to remove
-     */
-    removeRange(start: number, end: number): void;
-    /**
-     * Obliterate is similar to remove, but differs in that segments concurrently
-     * inserted into an obliterated range will also be removed
-     *
-     * @param start - The inclusive start of the range to obliterate
-     * @param end - The exclusive end of the range to obliterate
-     */
-    obliterateRange(start: number, end: number): void;
-    /**
-     * @deprecated The ability to create group ops will be removed in an upcoming
-     * release, as group ops are redundant with the native batching capabilities
-     * of the runtime
-     */
-    groupOperation(groupOp: IMergeTreeGroupMsg): void;
-    /**
-     * Finds the segment information (i.e. segment + offset) corresponding to a character position in the SharedString.
-     * If the position is past the end of the string, `segment` and `offset` on the returned object may be undefined.
-     * @param pos - Character position (index) into the current local view of the SharedString.
-     */
-    getContainingSegment(pos: number): {
-        segment: T | undefined;
-        offset: number | undefined;
-    };
-    /**
-     * Returns the length of the current sequence for the client
-     */
-    getLength(): number;
-    /**
-     * Returns the current position of a segment, and -1 if the segment
-     * does not exist in this sequence
-     * @param segment - The segment to get the position of
-     */
-    getPosition(segment: ISegment): number;
-    /**
-     * Annotates the range with the provided properties
-     *
-     * @param start - The inclusive start position of the range to annotate
-     * @param end - The exclusive end position of the range to annotate
-     * @param props - The properties to annotate the range with
-     *
-     */
-    annotateRange(start: number, end: number, props: PropertySet): void;
-    getPropertiesAtPosition(pos: number): PropertySet | undefined;
-    getRangeExtentsOfPosition(pos: number): {
-        posStart: number | undefined;
-        posAfterEnd: number | undefined;
-    };
-    /**
-     * Creates a `LocalReferencePosition` on this SharedString. If the refType does not include
-     * ReferenceType.Transient, the returned reference will be added to the localRefs on the provided segment.
-     * @param segment - Segment to add the local reference on
-     * @param offset - Offset on the segment at which to place the local reference
-     * @param refType - ReferenceType for the created local reference
-     * @param properties - PropertySet to place on the created local reference
-     */
-    createLocalReferencePosition(segment: T, offset: number, refType: ReferenceType, properties: PropertySet | undefined, slidingPreference?: SlidingPreference, canSlideToEndpoint?: boolean): LocalReferencePosition;
-    /**
-     * Resolves a `ReferencePosition` into a character position using this client's perspective.
-     *
-     * Reference positions that point to a character that has been removed will
-     * always return the position of the nearest non-removed character, regardless
-     * of `ReferenceType`. To handle this case specifically, one may wish
-     * to look at the segment returned by `ReferencePosition.getSegment`.
-     */
-    localReferencePositionToPosition(lref: ReferencePosition): number;
-    /**
-     * Removes a `LocalReferencePosition` from this SharedString.
-     */
-    removeLocalReferencePosition(lref: LocalReferencePosition): LocalReferencePosition | undefined;
-    /**
-     * Resolves a remote client's position against the local sequence
-     * and returns the remote client's position relative to the local
-     * sequence. The client ref seq must be above the minimum sequence number
-     * or the return value will be undefined.
-     * Generally this method is used in conjunction with signals which provide
-     * point in time values for the below parameters, and is useful for things
-     * like displaying user position. It should not be used with persisted values
-     * as persisted values will quickly become invalid as the remoteClientRefSeq
-     * moves below the minimum sequence number
-     * @param remoteClientPosition - The remote client's position to resolve
-     * @param remoteClientRefSeq - The reference sequence number of the remote client
-     * @param remoteClientId - The client id of the remote client
-     */
-    resolveRemoteClientPosition(remoteClientPosition: number, remoteClientRefSeq: number, remoteClientId: string): number | undefined;
-    private submitSequenceMessage;
-    /**
-     * Given a position specified relative to a marker id, lookup the marker
-     * and convert the position to a character position.
-     * @param relativePos - Id of marker (may be indirect) and whether position is before or after marker.
-     */
-    posFromRelativePos(relativePos: IRelativePosition): number;
-    /**
-     * Walk the underlying segments of the sequence.
-     * The walked segments may extend beyond the range if the segments cross the
-     * ranges start or end boundaries.
-     *
-     * Set split range to true to ensure only segments within the range are walked.
-     *
-     * @param handler - The function to handle each segment. Traversal ends if
-     * this function returns true.
-     * @param start - Optional. The start of range walk.
-     * @param end - Optional. The end of range walk
-     * @param accum - Optional. An object that will be passed to the handler for accumulation
-     * @param splitRange - Optional. Splits boundary segments on the range boundaries
-     */
-    walkSegments<TClientData>(handler: ISegmentAction<TClientData>, start?: number, end?: number, accum?: TClientData, splitRange?: boolean): void;
-    /**
-     * @returns The most recent sequence number which has been acked by the server and processed by this
-     * SharedSegmentSequence.
-     */
-    getCurrentSeq(): number;
-    /**
-     * Inserts a segment directly before a `ReferencePosition`.
-     * @param refPos - The reference position to insert the segment at
-     * @param segment - The segment to insert
-     */
-    insertAtReferencePosition(pos: ReferencePosition, segment: T): void;
-    /**
-     * Inserts a segment
-     * @param start - The position to insert the segment at
-     * @param spec - The segment to inserts spec
-     */
-    insertFromSpec(pos: number, spec: IJSONSegment): void;
-    /**
-     * Retrieves the interval collection keyed on `label`. If no such interval collection exists,
-     * creates one.
-     */
-    getIntervalCollection(label: string): IIntervalCollection<SequenceInterval>;
-    /**
-     * @returns An iterable object that enumerates the IntervalCollection labels.
-     *
-     * @example
-     *
-     * ```typescript
-     * const iter = this.getIntervalCollectionKeys();
-     * for (key of iter)
-     *     const collection = this.getIntervalCollection(key);
-     *     ...
-     * ```
-     */
-    getIntervalCollectionLabels(): IterableIterator<string>;
-    /**
-     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.summarizeCore}
-     */
-    protected summarizeCore(serializer: IFluidSerializer, telemetryContext?: ITelemetryContext): ISummaryTreeWithStats;
-    /**
-     * Runs serializer over the GC data for this SharedMatrix.
-     * All the IFluidHandle's represent routes to other objects.
-     */
-    protected processGCDataCore(serializer: IFluidSerializer): void;
-    /**
-     * Replace the range specified from start to end with the provided segment
-     * This is done by inserting the segment at the end of the range, followed
-     * by removing the contents of the range
-     * For a zero or reverse range (start \>= end), insert at end do not remove anything
-     * @param start - The start of the range to replace
-     * @param end - The end of the range to replace
-     * @param segment - The segment that will replace the range
-     */
-    protected replaceRange(start: number, end: number, segment: ISegment): void;
-    /**
-     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.onConnect}
-     */
-    protected onConnect(): void;
-    /**
-     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.onDisconnect}
-     */
-    protected onDisconnect(): void;
-    /**
-     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.reSubmitCore}
-     */
-    protected reSubmitCore(content: any, localOpMetadata: unknown): void;
-    /**
-     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.loadCore}
-     */
-    protected loadCore(storage: IChannelStorageService): Promise<void>;
-    /**
-     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.processCore}
-     */
-    protected processCore(message: ISequencedDocumentMessage, local: boolean, localOpMetadata: unknown): void;
-    /**
-     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.didAttach}
-     */
-    protected didAttach(): void;
-    /**
-     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.initializeLocalCore}
-     */
-    protected initializeLocalCore(): void;
-    /**
-     * {@inheritDoc @fluidframework/shared-object-base#SharedObjectCore.applyStashedOp}
-     */
-    protected applyStashedOp(content: any): void;
-    private summarizeMergeTree;
-    /**
-     *
-     * @param message - Message with decoded and hydrated handles
-     */
-    private processMergeTreeMsg;
-    private processMinSequenceNumberChanged;
-    private loadFinished;
-    private initializeIntervalCollections;
-    /**
-     * Overrides the "currently applicable reference sequence number" for the duration of the callback.
-     * See remarks on `currentRefSeq` for more context.
-     */
-    private useResubmitRefSeq;
-}
-
-/* Excluded from this release type: SharedSequence */
-
-/**
- * The Shared String is a specialized data structure for handling collaborative
- * text. It is based on a more general Sequence data structure but has
- * additional features that make working with text easier.
- *
- * 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.
- * @alpha
- */
-export declare class SharedString extends SharedSegmentSequence<SharedStringSegment> implements ISharedString {
-    id: string;
-    /**
-     * Create a new shared string.
-     * @param runtime - data store runtime the new shared string belongs to
-     * @param id - optional name of the shared string
-     * @returns newly create shared string (but not attached yet)
-     */
-    static create(runtime: IFluidDataStoreRuntime, id?: string): SharedString;
-    /**
-     * Get a factory for SharedString to register with the data store.
-     * @returns a factory that creates and load SharedString
-     */
-    static getFactory(): SharedStringFactory;
-    get ISharedString(): ISharedString;
-    private readonly mergeTreeTextHelper;
-    constructor(document: IFluidDataStoreRuntime, id: string, attributes: IChannelAttributes);
-    /**
-     * Inserts a marker at a relative position.
-     * @param relativePos1 - The relative position to insert the marker at
-     * @param refType - The reference type of the marker
-     * @param props - The properties of the marker
-     */
-    insertMarkerRelative(relativePos1: IRelativePosition, refType: ReferenceType, props?: PropertySet): void;
-    /**
-     * {@inheritDoc ISharedString.insertMarker}
-     */
-    insertMarker(pos: number, refType: ReferenceType, props?: PropertySet): void;
-    /**
-     * Inserts the text at the position.
-     * @param relativePos1 - The relative position to insert the text at
-     * @param text - The text to insert
-     * @param props - The properties of text
-     */
-    insertTextRelative(relativePos1: IRelativePosition, text: string, props?: PropertySet): void;
-    /**
-     * {@inheritDoc ISharedString.insertText}
-     */
-    insertText(pos: number, text: string, props?: PropertySet): void;
-    /**
-     * Replaces a range with the provided text.
-     * @param start - The inclusive start of the range to replace
-     * @param end - The exclusive end of the range to replace
-     * @param text - The text to replace the range with
-     * @param props - Optional. The properties of the replacement text
-     */
-    replaceText(start: number, end: number, text: string, props?: PropertySet): void;
-    /**
-     * Removes the text in the given range.
-     * @param start - The inclusive start of the range to remove
-     * @param end - The exclusive end of the range to replace
-     * @returns the message sent.
-     */
-    removeText(start: number, end: number): void;
-    /**
-     * Annotates the marker with the provided properties.
-     * @param marker - The marker to annotate
-     * @param props - The properties to annotate the marker with
-     */
-    annotateMarker(marker: Marker, props: PropertySet): void;
-    /**
-     * Searches a string for the nearest marker in either direction to a given start position.
-     * The search will include the start position, so markers at the start position are valid
-     * results of the search.
-     * @param startPos - Position at which to start the search
-     * @param markerLabel - Label of the marker to search for
-     * @param forwards - Whether the desired marker comes before (false) or after (true) `startPos`
-     */
-    searchForMarker(startPos: number, markerLabel: string, forwards?: boolean): Marker | undefined;
-    /**
-     * Retrieve text from the SharedString in string format.
-     * @param start - The starting index of the text to retrieve, or 0 if omitted.
-     * @param end - The ending index of the text to retrieve, or the end of the string if omitted
-     * @returns The requested text content as a string.
-     */
-    getText(start?: number, end?: number): string;
-    /**
-     * Adds spaces for markers and handles, so that position calculations account for them.
-     */
-    getTextWithPlaceholders(start?: number, end?: number): string;
-    getTextRangeWithMarkers(start: number, end: number): string;
-    /**
-     * Looks up and returns a `Marker` using its id. Returns `undefined` if there is no marker with the provided
-     * id in this `SharedString`.
-     */
-    getMarkerFromId(id: string): ISegment | undefined;
-    /**
-     * Revert an op
-     */
-    protected rollback(content: any, localOpMetadata: unknown): void;
-}
-
-/**
- * @alpha
- */
-export declare class SharedStringFactory implements IChannelFactory {
-    static Type: string;
-    static readonly Attributes: IChannelAttributes;
-    static segmentFromSpec(spec: any): SharedStringSegment;
-    get type(): string;
-    get attributes(): IChannelAttributes;
-    /**
-     * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory.load}
-     */
-    load(runtime: IFluidDataStoreRuntime, id: string, services: IChannelServices, attributes: IChannelAttributes): Promise<SharedString>;
-    /**
-     * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory.create}
-     */
-    create(document: IFluidDataStoreRuntime, id: string): SharedString;
-}
-
-/**
- * Data for undoing edits on SharedStrings and Intervals.
- * @alpha
- */
-export declare type SharedStringRevertible = MergeTreeDeltaRevertible | IntervalRevertible;
-
-/**
- * @alpha
- */
-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.
- * @alpha
- */
-export declare enum Side {
-    Before = 0,
-    After = 1
-}
-
-/* Excluded from this release type: SubSequence */
-export { TextSegment }
-
-export { TrackingGroup }
-
-export { }