@fluidframework/sequence 2.0.0-dev.5.3.2.178189 → 2.0.0-dev.6.4.0.191457

package/dist/intervals/intervalUtils.d.ts

@@ -0,0 +1,200 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { Client, PropertiesManager, PropertySet, SlidingPreference } from "@fluidframework/merge-tree";
+import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
+/**
+ * Basic interval abstraction
+ */
+export 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.
+     * @internal
+     */
+    modify(label: string, start: number | undefined, end: number | undefined, op?: ISequencedDocumentMessage, localSeq?: number): 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.
+     * @internal
+     */
+    union(b: IInterval): IInterval;
+}
+/**
+ * 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";
+};
+export declare enum IntervalType {
+    Simple = 0,
+    Nest = 1,
+    /**
+     * SlideOnRemove indicates that the ends of the interval will slide if the segment
+     * they reference is removed and acked.
+     * See `packages\dds\merge-tree\docs\REFERENCEPOSITIONS.md` for details
+     * SlideOnRemove is the default interval behavior and does not need to be specified.
+     */
+    SlideOnRemove = 2,
+    /**
+     * A temporary interval, used internally
+     * @internal
+     */
+    Transient = 4
+}
+/**
+ * Serialized object representation of an interval.
+ * This representation is used for ops that create or change intervals.
+ * @internal
+ */
+export 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;
+    /** End position of the interval */
+    end: number;
+    /** Interval type to create */
+    intervalType: IntervalType;
+    stickiness?: IntervalStickiness;
+    /** Any properties the interval has */
+    properties?: PropertySet;
+}
+export interface ISerializableInterval extends IInterval {
+    /** Serializable bag of properties associated with the interval. */
+    properties: PropertySet;
+    /** @internal */
+    propertyManager: PropertiesManager;
+    /** @internal */
+    serialize(): ISerializedInterval;
+    /** @internal */
+    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;
+}
+/**
+ * Represents a change that should be applied to an existing interval.
+ * Changes can modify any of start/end/properties, with `undefined` signifying no change should be made.
+ * @internal
+ */
+export declare type SerializedIntervalDelta = Omit<ISerializedInterval, "start" | "end" | "properties"> & Partial<Pick<ISerializedInterval, "start" | "end" | "properties">>;
+/**
+ * A size optimization to avoid redundantly storing keys when serializing intervals
+ * as JSON for summaries.
+ *
+ * Intervals are of the format:
+ *
+ * [start, end, sequenceNumber, intervalType, properties, stickiness?]
+ */
+export declare type CompressedSerializedInterval = [number, number, number, IntervalType, PropertySet, IntervalStickiness] | [number, number, number, IntervalType, PropertySet];
+/**
+ * @sealed
+ */
+export interface IIntervalHelpers<TInterval extends ISerializableInterval> {
+    /**
+     * @deprecated Use the method `IInterval.compareEnd` instead
+     */
+    compareEnds(a: TInterval, b: TInterval): number;
+    /**
+     * @deprecated Use the method `IInterval.compareStart` instead
+     */
+    compareStarts?(a: TInterval, b: TInterval): number;
+    /**
+     *
+     * @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 stickiness - {@link (IntervalStickiness:type)} to apply to the added interval.
+     */
+    create(label: string, start: number | undefined, end: number | undefined, client: Client | undefined, intervalType: IntervalType, op?: ISequencedDocumentMessage, fromSnapshot?: boolean, stickiness?: IntervalStickiness): TInterval;
+}
+/**
+ * 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
+ */
+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
+ */
+export declare type IntervalStickiness = typeof IntervalStickiness[keyof typeof IntervalStickiness];
+export declare function endReferenceSlidingPreference(stickiness: IntervalStickiness): SlidingPreference;
+export declare function startReferenceSlidingPreference(stickiness: IntervalStickiness): SlidingPreference;
+//# sourceMappingURL=intervalUtils.d.ts.map

package/dist/intervals/intervalUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intervalUtils.d.ts","sourceRoot":"","sources":["../../src/intervals/intervalUtils.ts"],"names":[],"mappings":"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"}

package/dist/intervals/intervalUtils.js

@@ -0,0 +1,79 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startReferenceSlidingPreference = exports.endReferenceSlidingPreference = exports.IntervalStickiness = exports.IntervalType = exports.IntervalOpType = void 0;
+/* eslint-disable no-bitwise */
+const merge_tree_1 = require("@fluidframework/merge-tree");
+/**
+ * Values are used in persisted formats (ops) and revertibles.
+ * @alpha
+ */
+exports.IntervalOpType = {
+    ADD: "add",
+    DELETE: "delete",
+    CHANGE: "change",
+    PROPERTY_CHANGED: "propertyChanged",
+    POSITION_REMOVE: "positionRemove",
+};
+var IntervalType;
+(function (IntervalType) {
+    IntervalType[IntervalType["Simple"] = 0] = "Simple";
+    IntervalType[IntervalType["Nest"] = 1] = "Nest";
+    /**
+     * 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.
+     */
+    IntervalType[IntervalType["SlideOnRemove"] = 2] = "SlideOnRemove";
+    /**
+     * A temporary interval, used internally
+     * @internal
+     */
+    IntervalType[IntervalType["Transient"] = 4] = "Transient";
+})(IntervalType = exports.IntervalType || (exports.IntervalType = {}));
+/**
+ * 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
+ */
+exports.IntervalStickiness = {
+    /**
+     * Interval does not expand to include adjacent segments
+     */
+    NONE: 0b00,
+    /**
+     * Interval expands to include segments inserted adjacent to the start
+     */
+    START: 0b01,
+    /**
+     * Interval expands to include segments inserted adjacent to the end
+     *
+     * This is the default stickiness
+     */
+    END: 0b10,
+    /**
+     * Interval expands to include all segments inserted adjacent to it
+     */
+    FULL: 0b11,
+};
+function endReferenceSlidingPreference(stickiness) {
+    // if any end stickiness, prefer sliding forwards
+    return (stickiness & exports.IntervalStickiness.END) !== 0
+        ? merge_tree_1.SlidingPreference.FORWARD
+        : merge_tree_1.SlidingPreference.BACKWARD;
+}
+exports.endReferenceSlidingPreference = endReferenceSlidingPreference;
+function startReferenceSlidingPreference(stickiness) {
+    // if any start stickiness, prefer sliding backwards
+    return (stickiness & exports.IntervalStickiness.START) !== 0
+        ? merge_tree_1.SlidingPreference.BACKWARD
+        : merge_tree_1.SlidingPreference.FORWARD;
+}
+exports.startReferenceSlidingPreference = startReferenceSlidingPreference;
+//# sourceMappingURL=intervalUtils.js.map

package/dist/intervals/intervalUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"intervalUtils.js","sourceRoot":"","sources":["../../src/intervals/intervalUtils.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,+BAA+B;AAE/B,2DAKoC;AAuDpC;;;GAGG;AACU,QAAA,cAAc,GAAG;IAC7B,GAAG,EAAE,KAAK;IACV,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,gBAAgB,EAAE,iBAAiB;IACnC,eAAe,EAAE,gBAAgB;CACxB,CAAC;AAEX,IAAY,YAiBX;AAjBD,WAAY,YAAY;IACvB,mDAAY,CAAA;IACZ,+CAAU,CAAA;IAEV;;;;;OAKG;IACH,iEAAmB,CAAA;IAEnB;;;OAGG;IACH,yDAAe,CAAA;AAChB,CAAC,EAjBW,YAAY,GAAZ,oBAAY,KAAZ,oBAAY,QAiBvB;AA2GD;;;;;;GAMG;AACU,QAAA,kBAAkB,GAAG;IACjC;;OAEG;IACH,IAAI,EAAE,IAAI;IAEV;;OAEG;IACH,KAAK,EAAE,IAAI;IAEX;;;;OAIG;IACH,GAAG,EAAE,IAAI;IAET;;OAEG;IACH,IAAI,EAAE,IAAI;CACD,CAAC;AAWX,SAAgB,6BAA6B,CAAC,UAA8B;IAC3E,iDAAiD;IACjD,OAAO,CAAC,UAAU,GAAG,0BAAkB,CAAC,GAAG,CAAC,KAAK,CAAC;QACjD,CAAC,CAAC,8BAAiB,CAAC,OAAO;QAC3B,CAAC,CAAC,8BAAiB,CAAC,QAAQ,CAAC;AAC/B,CAAC;AALD,sEAKC;AAED,SAAgB,+BAA+B,CAAC,UAA8B;IAC7E,oDAAoD;IACpD,OAAO,CAAC,UAAU,GAAG,0BAAkB,CAAC,KAAK,CAAC,KAAK,CAAC;QACnD,CAAC,CAAC,8BAAiB,CAAC,QAAQ;QAC5B,CAAC,CAAC,8BAAiB,CAAC,OAAO,CAAC;AAC9B,CAAC;AALD,0EAKC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/* eslint-disable no-bitwise */\n\nimport {\n\tClient,\n\tPropertiesManager,\n\tPropertySet,\n\tSlidingPreference,\n} from \"@fluidframework/merge-tree\";\nimport { ISequencedDocumentMessage } from \"@fluidframework/protocol-definitions\";\n/**\n * Basic interval abstraction\n */\nexport interface IInterval {\n\t/**\n\t * @returns a new interval object with identical semantics.\n\t */\n\tclone(): IInterval;\n\t/**\n\t * Compares this interval to `b` with standard comparator semantics:\n\t * - returns -1 if this is less than `b`\n\t * - returns 1 if this is greater than `b`\n\t * - returns 0 if this is equivalent to `b`\n\t * @param b - Interval to compare against\n\t */\n\tcompare(b: IInterval): number;\n\t/**\n\t * Compares the start endpoint of this interval to `b`'s start endpoint.\n\t * Standard comparator semantics apply.\n\t * @param b - Interval to compare against\n\t */\n\tcompareStart(b: IInterval): number;\n\t/**\n\t * Compares the end endpoint of this interval to `b`'s end endpoint.\n\t * Standard comparator semantics apply.\n\t * @param b - Interval to compare against\n\t */\n\tcompareEnd(b: IInterval): number;\n\t/**\n\t * Modifies one or more of the endpoints of this interval, returning a new interval representing the result.\n\t * @internal\n\t */\n\tmodify(\n\t\tlabel: string,\n\t\tstart: number | undefined,\n\t\tend: number | undefined,\n\t\top?: ISequencedDocumentMessage,\n\t\tlocalSeq?: number,\n\t): IInterval | undefined;\n\t/**\n\t * @returns whether this interval overlaps with `b`.\n\t * Intervals are considered to overlap if their intersection is non-empty.\n\t */\n\toverlaps(b: IInterval): boolean;\n\t/**\n\t * Unions this interval with `b`, returning a new interval.\n\t * The union operates as a convex hull, i.e. if the two intervals are disjoint, the return value includes\n\t * intermediate values between the two intervals.\n\t * @internal\n\t */\n\tunion(b: IInterval): IInterval;\n}\n\n/**\n * Values are used in persisted formats (ops) and revertibles.\n * @alpha\n */\nexport const IntervalOpType = {\n\tADD: \"add\",\n\tDELETE: \"delete\",\n\tCHANGE: \"change\",\n\tPROPERTY_CHANGED: \"propertyChanged\",\n\tPOSITION_REMOVE: \"positionRemove\",\n} as const;\n\nexport enum IntervalType {\n\tSimple = 0x0,\n\tNest = 0x1,\n\n\t/**\n\t * SlideOnRemove indicates that the ends of the interval will slide if the segment\n\t * they reference is removed and acked.\n\t * See `packages\\dds\\merge-tree\\docs\\REFERENCEPOSITIONS.md` for details\n\t * SlideOnRemove is the default interval behavior and does not need to be specified.\n\t */\n\tSlideOnRemove = 0x2, // SlideOnRemove is default behavior - all intervals are SlideOnRemove\n\n\t/**\n\t * A temporary interval, used internally\n\t * @internal\n\t */\n\tTransient = 0x4,\n}\n\n/**\n * Serialized object representation of an interval.\n * This representation is used for ops that create or change intervals.\n * @internal\n */\nexport interface ISerializedInterval {\n\t/**\n\t * Sequence number at which `start` and `end` should be interpreted\n\t *\n\t * @remarks It's unclear that this is necessary to store here.\n\t * This should just be the refSeq on the op that modified the interval, which should be available via other means.\n\t * At the time of writing, it's not plumbed through to the reconnect/rebase code, however, which does need it.\n\t */\n\tsequenceNumber: number;\n\t/** Start position of the interval */\n\tstart: number;\n\t/** End position of the interval */\n\tend: number;\n\t/** Interval type to create */\n\tintervalType: IntervalType;\n\tstickiness?: IntervalStickiness;\n\t/** Any properties the interval has */\n\tproperties?: PropertySet;\n}\n\nexport interface ISerializableInterval extends IInterval {\n\t/** Serializable bag of properties associated with the interval. */\n\tproperties: PropertySet;\n\t/** @internal */\n\tpropertyManager: PropertiesManager;\n\t/** @internal */\n\tserialize(): ISerializedInterval;\n\t/** @internal */\n\taddProperties(\n\t\tprops: PropertySet,\n\t\tcollaborating?: boolean,\n\t\tseq?: number,\n\t): PropertySet | undefined;\n\t/**\n\t * Gets the id associated with this interval.\n\t * When the interval is used as part of an interval collection, this id can be used to modify or remove the\n\t * interval.\n\t * @remarks This signature includes `undefined` strictly for backwards-compatibility reasons, as older versions\n\t * of Fluid didn't always write interval ids.\n\t */\n\tgetIntervalId(): string | undefined;\n}\n\n/**\n * Represents a change that should be applied to an existing interval.\n * Changes can modify any of start/end/properties, with `undefined` signifying no change should be made.\n * @internal\n */\nexport type SerializedIntervalDelta = Omit<ISerializedInterval, \"start\" | \"end\" | \"properties\"> &\n\tPartial<Pick<ISerializedInterval, \"start\" | \"end\" | \"properties\">>;\n\n/**\n * A size optimization to avoid redundantly storing keys when serializing intervals\n * as JSON for summaries.\n *\n * Intervals are of the format:\n *\n * [start, end, sequenceNumber, intervalType, properties, stickiness?]\n */\nexport type CompressedSerializedInterval =\n\t| [number, number, number, IntervalType, PropertySet, IntervalStickiness]\n\t| [number, number, number, IntervalType, PropertySet];\n\n/**\n * @sealed\n */\nexport interface IIntervalHelpers<TInterval extends ISerializableInterval> {\n\t/**\n\t * @deprecated Use the method `IInterval.compareEnd` instead\n\t */\n\tcompareEnds(a: TInterval, b: TInterval): number;\n\n\t/**\n\t * @deprecated Use the method `IInterval.compareStart` instead\n\t */\n\tcompareStarts?(a: TInterval, b: TInterval): number;\n\t/**\n\t *\n\t * @param label - label of the interval collection this interval is being added to. This parameter is\n\t * irrelevant for transient intervals.\n\t * @param start - numerical start position of the interval\n\t * @param end - numerical end position of the interval\n\t * @param client - client creating the interval\n\t * @param intervalType - Type of interval to create. Default is SlideOnRemove\n\t * @param op - If this create came from a remote client, op that created it. Default is undefined (i.e. local)\n\t * @param fromSnapshot - If this create came from loading a snapshot. Default is false.\n\t * @param stickiness - {@link (IntervalStickiness:type)} to apply to the added interval.\n\t */\n\tcreate(\n\t\tlabel: string,\n\t\tstart: number | undefined,\n\t\tend: number | undefined,\n\t\tclient: Client | undefined,\n\t\tintervalType: IntervalType,\n\t\top?: ISequencedDocumentMessage,\n\t\tfromSnapshot?: boolean,\n\t\tstickiness?: IntervalStickiness,\n\t): TInterval;\n}\n\n/**\n * Determines how an interval should expand when segments are inserted adjacent\n * to the range it spans\n *\n * Note that interval stickiness is currently an experimental feature and must\n * be explicitly enabled with the `intervalStickinessEnabled` flag\n */\nexport const IntervalStickiness = {\n\t/**\n\t * Interval does not expand to include adjacent segments\n\t */\n\tNONE: 0b00,\n\n\t/**\n\t * Interval expands to include segments inserted adjacent to the start\n\t */\n\tSTART: 0b01,\n\n\t/**\n\t * Interval expands to include segments inserted adjacent to the end\n\t *\n\t * This is the default stickiness\n\t */\n\tEND: 0b10,\n\n\t/**\n\t * Interval expands to include all segments inserted adjacent to it\n\t */\n\tFULL: 0b11,\n} as const;\n\n/**\n * Determines how an interval should expand when segments are inserted adjacent\n * to the range it spans\n *\n * Note that interval stickiness is currently an experimental feature and must\n * be explicitly enabled with the `intervalStickinessEnabled` flag\n */\nexport type IntervalStickiness = typeof IntervalStickiness[keyof typeof IntervalStickiness];\n\nexport function endReferenceSlidingPreference(stickiness: IntervalStickiness): SlidingPreference {\n\t// if any end stickiness, prefer sliding forwards\n\treturn (stickiness & IntervalStickiness.END) !== 0\n\t\t? SlidingPreference.FORWARD\n\t\t: SlidingPreference.BACKWARD;\n}\n\nexport function startReferenceSlidingPreference(stickiness: IntervalStickiness): SlidingPreference {\n\t// if any start stickiness, prefer sliding backwards\n\treturn (stickiness & IntervalStickiness.START) !== 0\n\t\t? SlidingPreference.BACKWARD\n\t\t: SlidingPreference.FORWARD;\n}\n"]}

package/dist/intervals/sequenceInterval.d.ts

@@ -0,0 +1,132 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { Client, ICombiningOp, ISegment, LocalReferencePosition, PropertiesManager, PropertySet, ReferenceType, SlidingPreference } from "@fluidframework/merge-tree";
+import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
+import { IIntervalHelpers, ISerializableInterval, ISerializedInterval, IntervalStickiness, IntervalType } from "./intervalUtils";
+/**
+ * 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 endpoint's position should be treated exclusively to get reasonable behavior--i.e.
+ * 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 end of an interval is treated exclusively but cannot be greater than or equal to the
+ * length of the associated sequence, application models which leverage interval collections should
+ * consider inserting a marker at the end of the sequence to represent the end of the content.
+ */
+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 stickiness: IntervalStickiness;
+    /**
+     * {@inheritDoc ISerializableInterval.properties}
+     */
+    properties: PropertySet;
+    /**
+     * {@inheritDoc ISerializableInterval.propertyManager}
+     * @internal
+     */
+    propertyManager: PropertiesManager;
+    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, stickiness?: IntervalStickiness);
+    private callbacks?;
+    /**
+     * Subscribes to position change events on this interval if there are no current listeners.
+     * @internal
+     */
+    addPositionChangeListeners(beforePositionChange: () => void, afterPositionChange: () => void): void;
+    /**
+     * Removes the currently subscribed position change listeners.
+     * @internal
+     */
+    removePositionChangeListeners(): void;
+    /**
+     * {@inheritDoc ISerializableInterval.serialize}
+     * @internal
+     */
+    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}
+     * @internal
+     */
+    union(b: SequenceInterval): SequenceInterval;
+    /**
+     * {@inheritDoc ISerializableInterval.addProperties}
+     * @internal
+     */
+    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;
+    /**
+     * {@inheritDoc IInterval.modify}
+     * @internal
+     */
+    modify(label: string, start: number, end: number, op?: ISequencedDocumentMessage, localSeq?: number, stickiness?: IntervalStickiness): SequenceInterval;
+    private initializeProperties;
+}
+export declare function createPositionReferenceFromSegoff(client: Client, segoff: {
+    segment: ISegment | undefined;
+    offset: number | undefined;
+}, refType: ReferenceType, op?: ISequencedDocumentMessage, localSeq?: number, fromSnapshot?: boolean, slidingPreference?: SlidingPreference): LocalReferencePosition;
+export declare function createSequenceInterval(label: string, start: number, end: number, client: Client, intervalType: IntervalType, op?: ISequencedDocumentMessage, fromSnapshot?: boolean, stickiness?: IntervalStickiness): SequenceInterval;
+export declare const compareSequenceIntervalEnds: (a: SequenceInterval, b: SequenceInterval) => number;
+export declare const compareSequenceIntervalStarts: (a: SequenceInterval, b: SequenceInterval) => number;
+export declare const sequenceIntervalHelpers: IIntervalHelpers<SequenceInterval>;
+//# sourceMappingURL=sequenceInterval.d.ts.map

package/dist/intervals/sequenceInterval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequenceInterval.d.ts","sourceRoot":"","sources":["../../src/intervals/sequenceInterval.ts"],"names":[],"mappings":"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"}