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

package/lib/test/subSequence.spec.js

@@ -0,0 +1,92 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { assert } from "@fluidframework/core-utils";
+import { createInsertSegmentOp, createRemoveRangeOp, } from "@fluidframework/merge-tree";
+// eslint-disable-next-line import/no-internal-modules
+import { TestClient } from "@fluidframework/merge-tree/test";
+import { SubSequence } from "../sharedSequence.js";
+const clientNames = ["Ed", "Ted", "Ned", "Harv", "Marv", "Glenda", "Susan"];
+const verbose = true;
+class SubSequenceTestClient extends TestClient {
+    constructor() {
+        super(undefined, (spec) => {
+            const subSequence = SubSequence.fromJSONObject(spec);
+            assert(subSequence !== undefined, "expected `spec` to be a valid `SubSequence`");
+            return subSequence;
+        });
+    }
+    insertItemsRemote(pos, items, props, seq, refSeq, longClientId) {
+        const segment = new SubSequence(items);
+        if (props) {
+            segment.addProperties(props);
+        }
+        this.applyMsg(this.makeOpMessage(createInsertSegmentOp(pos, segment), seq, refSeq, longClientId));
+    }
+    relItems(clientId, refSeq) {
+        let items = "";
+        this.walkSegments((s) => {
+            if (SubSequence.is(s)) {
+                items += s.items.toString();
+            }
+            return true;
+        }, 0, this.getLength());
+        return `cli: ${this.getLongClientId(clientId)} refSeq: ${refSeq}: ${items}`;
+    }
+}
+describe("SubSequence", () => {
+    it("firstItemTest", () => {
+        const cli = new SubSequenceTestClient();
+        cli.startOrUpdateCollaboration("Fred1");
+        for (const cname of clientNames) {
+            cli.addLongClientId(cname);
+        }
+        cli.insertItemsRemote(0, [2, 11], undefined, 1, 0, "1");
+        if (verbose) {
+            // eslint-disable-next-line @typescript-eslint/no-base-to-string
+            console.log(cli.mergeTree.toString());
+        }
+        cli.insertItemsRemote(0, [4, 5, 6], undefined, 2, 0, "2");
+        if (verbose) {
+            // eslint-disable-next-line @typescript-eslint/no-base-to-string
+            console.log(cli.mergeTree.toString());
+        }
+        const segment = new SubSequence([3, 4, 1, 1]);
+        const insert = cli.insertSegmentLocal(4, segment);
+        if (verbose) {
+            // eslint-disable-next-line @typescript-eslint/no-base-to-string
+            console.log(cli.mergeTree.toString());
+        }
+        if (verbose) {
+            for (let i = 0; i < 4; i++) {
+                for (let j = 0; j < 3; j++) {
+                    console.log(cli.relItems(i, j));
+                }
+            }
+        }
+        cli.applyMsg(cli.makeOpMessage(insert, 3));
+        cli.insertItemsRemote(5, [1, 5, 6, 2, 3], undefined, 4, 2, "2");
+        cli.insertItemsRemote(0, [9], undefined, 5, 0, "2");
+        if (verbose) {
+            // eslint-disable-next-line @typescript-eslint/no-base-to-string
+            console.log(cli.mergeTree.toString());
+            for (let clientId = 0; clientId < 4; clientId++) {
+                for (let refSeq = 0; refSeq < 6; refSeq++) {
+                    console.log(cli.relItems(clientId, refSeq));
+                }
+            }
+        }
+        cli.applyMsg(cli.makeOpMessage(createRemoveRangeOp(3, 6), 6, 5, "3"));
+        if (verbose) {
+            // eslint-disable-next-line @typescript-eslint/no-base-to-string
+            console.log(cli.mergeTree.toString());
+            for (let clientId = 0; clientId < 4; clientId++) {
+                for (let refSeq = 0; refSeq < 7; refSeq++) {
+                    console.log(cli.relItems(clientId, refSeq));
+                }
+            }
+        }
+    });
+});
+//# sourceMappingURL=subSequence.spec.js.map

package/lib/test/subSequence.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subSequence.spec.js","sourceRoot":"","sources":["../../src/test/subSequence.spec.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { assert } from \"@fluidframework/core-utils\";\nimport { Serializable } from \"@fluidframework/datastore-definitions\";\nimport {\n\tcreateInsertSegmentOp,\n\tcreateRemoveRangeOp,\n\tPropertySet,\n} from \"@fluidframework/merge-tree\";\n// eslint-disable-next-line import/no-internal-modules\nimport { TestClient } from \"@fluidframework/merge-tree/test\";\nimport { SubSequence } from \"../sharedSequence.js\";\n\nconst clientNames = [\"Ed\", \"Ted\", \"Ned\", \"Harv\", \"Marv\", \"Glenda\", \"Susan\"];\nconst verbose = true;\n\nclass SubSequenceTestClient extends TestClient {\n\tconstructor() {\n\t\tsuper(undefined, (spec) => {\n\t\t\tconst subSequence = SubSequence.fromJSONObject(spec);\n\t\t\tassert(subSequence !== undefined, \"expected `spec` to be a valid `SubSequence`\");\n\t\t\treturn subSequence;\n\t\t});\n\t}\n\n\tpublic insertItemsRemote<T>(\n\t\tpos: number,\n\t\titems: Serializable<T>[],\n\t\tprops: PropertySet | undefined,\n\t\tseq: number,\n\t\trefSeq: number,\n\t\tlongClientId: string,\n\t) {\n\t\tconst segment = new SubSequence(items);\n\t\tif (props) {\n\t\t\tsegment.addProperties(props);\n\t\t}\n\t\tthis.applyMsg(\n\t\t\tthis.makeOpMessage(createInsertSegmentOp(pos, segment), seq, refSeq, longClientId),\n\t\t);\n\t}\n\n\tpublic relItems(clientId: number, refSeq: number) {\n\t\tlet items: string = \"\";\n\n\t\tthis.walkSegments(\n\t\t\t(s) => {\n\t\t\t\tif (SubSequence.is(s)) {\n\t\t\t\t\titems += s.items.toString();\n\t\t\t\t}\n\t\t\t\treturn true;\n\t\t\t},\n\t\t\t0,\n\t\t\tthis.getLength(),\n\t\t);\n\n\t\treturn `cli: ${this.getLongClientId(clientId)} refSeq: ${refSeq}: ${items}`;\n\t}\n}\n\ndescribe(\"SubSequence\", () => {\n\tit(\"firstItemTest\", () => {\n\t\tconst cli = new SubSequenceTestClient();\n\t\tcli.startOrUpdateCollaboration(\"Fred1\");\n\t\tfor (const cname of clientNames) {\n\t\t\tcli.addLongClientId(cname);\n\t\t}\n\t\tcli.insertItemsRemote(0, [2, 11], undefined, 1, 0, \"1\");\n\n\t\tif (verbose) {\n\t\t\t// eslint-disable-next-line @typescript-eslint/no-base-to-string\n\t\t\tconsole.log(cli.mergeTree.toString());\n\t\t}\n\t\tcli.insertItemsRemote(0, [4, 5, 6], undefined, 2, 0, \"2\");\n\t\tif (verbose) {\n\t\t\t// eslint-disable-next-line @typescript-eslint/no-base-to-string\n\t\t\tconsole.log(cli.mergeTree.toString());\n\t\t}\n\t\tconst segment = new SubSequence<number>([3, 4, 1, 1]);\n\t\tconst insert = cli.insertSegmentLocal(4, segment);\n\t\tif (verbose) {\n\t\t\t// eslint-disable-next-line @typescript-eslint/no-base-to-string\n\t\t\tconsole.log(cli.mergeTree.toString());\n\t\t}\n\t\tif (verbose) {\n\t\t\tfor (let i = 0; i < 4; i++) {\n\t\t\t\tfor (let j = 0; j < 3; j++) {\n\t\t\t\t\tconsole.log(cli.relItems(i, j));\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tcli.applyMsg(cli.makeOpMessage(insert, 3));\n\t\tcli.insertItemsRemote(5, [1, 5, 6, 2, 3], undefined, 4, 2, \"2\");\n\t\tcli.insertItemsRemote(0, [9], undefined, 5, 0, \"2\");\n\t\tif (verbose) {\n\t\t\t// eslint-disable-next-line @typescript-eslint/no-base-to-string\n\t\t\tconsole.log(cli.mergeTree.toString());\n\t\t\tfor (let clientId = 0; clientId < 4; clientId++) {\n\t\t\t\tfor (let refSeq = 0; refSeq < 6; refSeq++) {\n\t\t\t\t\tconsole.log(cli.relItems(clientId, refSeq));\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tcli.applyMsg(cli.makeOpMessage(createRemoveRangeOp(3, 6), 6, 5, \"3\"));\n\t\tif (verbose) {\n\t\t\t// eslint-disable-next-line @typescript-eslint/no-base-to-string\n\t\t\tconsole.log(cli.mergeTree.toString());\n\t\t\tfor (let clientId = 0; clientId < 4; clientId++) {\n\t\t\t\tfor (let refSeq = 0; refSeq < 7; refSeq++) {\n\t\t\t\t\tconsole.log(cli.relItems(clientId, refSeq));\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t});\n});\n"]}

package/lib/test/types/validateSequencePrevious.generated.js

@@ -0,0 +1,162 @@
+use_current_ClassDeclaration_BaseSegment(get_old_ClassDeclaration_BaseSegment());
+use_old_ClassDeclaration_BaseSegment(get_current_ClassDeclaration_BaseSegment());
+use_current_TypeAliasDeclaration_DeserializeCallback(get_old_TypeAliasDeclaration_DeserializeCallback());
+use_old_TypeAliasDeclaration_DeserializeCallback(get_current_TypeAliasDeclaration_DeserializeCallback());
+use_current_InterfaceDeclaration_IEndpointInRangeIndex(get_old_InterfaceDeclaration_IEndpointInRangeIndex());
+use_old_InterfaceDeclaration_IEndpointInRangeIndex(get_current_InterfaceDeclaration_IEndpointInRangeIndex());
+use_current_InterfaceDeclaration_IEndpointIndex(get_old_InterfaceDeclaration_IEndpointIndex());
+use_old_InterfaceDeclaration_IEndpointIndex(get_current_InterfaceDeclaration_IEndpointIndex());
+use_current_InterfaceDeclaration_IIdIntervalIndex(get_old_InterfaceDeclaration_IIdIntervalIndex());
+use_old_InterfaceDeclaration_IIdIntervalIndex(get_current_InterfaceDeclaration_IIdIntervalIndex());
+use_current_InterfaceDeclaration_IInterval(get_old_InterfaceDeclaration_IInterval());
+use_old_InterfaceDeclaration_IInterval(get_current_InterfaceDeclaration_IInterval());
+use_current_InterfaceDeclaration_IIntervalCollection(get_old_InterfaceDeclaration_IIntervalCollection());
+use_old_InterfaceDeclaration_IIntervalCollection(
+// @ts-expect-error compatibility expected to be broken
+get_current_InterfaceDeclaration_IIntervalCollection());
+use_current_InterfaceDeclaration_IIntervalCollectionEvent(get_old_InterfaceDeclaration_IIntervalCollectionEvent());
+use_old_InterfaceDeclaration_IIntervalCollectionEvent(get_current_InterfaceDeclaration_IIntervalCollectionEvent());
+use_current_InterfaceDeclaration_IIntervalHelpers(get_old_InterfaceDeclaration_IIntervalHelpers());
+use_old_InterfaceDeclaration_IIntervalHelpers(get_current_InterfaceDeclaration_IIntervalHelpers());
+use_current_InterfaceDeclaration_IJSONRunSegment(get_old_InterfaceDeclaration_IJSONRunSegment());
+use_old_InterfaceDeclaration_IJSONRunSegment(get_current_InterfaceDeclaration_IJSONRunSegment());
+use_current_InterfaceDeclaration_IMapMessageLocalMetadata(get_old_InterfaceDeclaration_IMapMessageLocalMetadata());
+use_old_InterfaceDeclaration_IMapMessageLocalMetadata(get_current_InterfaceDeclaration_IMapMessageLocalMetadata());
+use_current_InterfaceDeclaration_IOverlappingIntervalsIndex(get_old_InterfaceDeclaration_IOverlappingIntervalsIndex());
+use_old_InterfaceDeclaration_IOverlappingIntervalsIndex(get_current_InterfaceDeclaration_IOverlappingIntervalsIndex());
+use_current_InterfaceDeclaration_ISegment(get_old_InterfaceDeclaration_ISegment());
+use_old_InterfaceDeclaration_ISegment(get_current_InterfaceDeclaration_ISegment());
+use_current_InterfaceDeclaration_ISequenceDeltaRange(get_old_InterfaceDeclaration_ISequenceDeltaRange());
+use_old_InterfaceDeclaration_ISequenceDeltaRange(get_current_InterfaceDeclaration_ISequenceDeltaRange());
+use_current_InterfaceDeclaration_ISerializableInterval(get_old_InterfaceDeclaration_ISerializableInterval());
+use_old_InterfaceDeclaration_ISerializableInterval(get_current_InterfaceDeclaration_ISerializableInterval());
+use_current_InterfaceDeclaration_ISerializedInterval(get_old_InterfaceDeclaration_ISerializedInterval());
+use_old_InterfaceDeclaration_ISerializedInterval(get_current_InterfaceDeclaration_ISerializedInterval());
+use_current_InterfaceDeclaration_ISharedIntervalCollection(get_old_InterfaceDeclaration_ISharedIntervalCollection());
+use_old_InterfaceDeclaration_ISharedIntervalCollection(get_current_InterfaceDeclaration_ISharedIntervalCollection());
+use_current_InterfaceDeclaration_ISharedSegmentSequenceEvents(get_old_InterfaceDeclaration_ISharedSegmentSequenceEvents());
+use_old_InterfaceDeclaration_ISharedSegmentSequenceEvents(get_current_InterfaceDeclaration_ISharedSegmentSequenceEvents());
+use_current_InterfaceDeclaration_ISharedString(get_old_InterfaceDeclaration_ISharedString());
+use_old_InterfaceDeclaration_ISharedString(get_current_InterfaceDeclaration_ISharedString());
+use_current_InterfaceDeclaration_IStartpointInRangeIndex(get_old_InterfaceDeclaration_IStartpointInRangeIndex());
+use_old_InterfaceDeclaration_IStartpointInRangeIndex(get_current_InterfaceDeclaration_IStartpointInRangeIndex());
+use_current_InterfaceDeclaration_IValueOpEmitter(get_old_InterfaceDeclaration_IValueOpEmitter());
+use_old_InterfaceDeclaration_IValueOpEmitter(get_current_InterfaceDeclaration_IValueOpEmitter());
+use_current_InterfaceDeclaration_InteriorSequencePlace(get_old_InterfaceDeclaration_InteriorSequencePlace());
+use_old_InterfaceDeclaration_InteriorSequencePlace(get_current_InterfaceDeclaration_InteriorSequencePlace());
+use_current_ClassDeclaration_Interval(get_old_ClassDeclaration_Interval());
+use_old_ClassDeclaration_Interval(get_current_ClassDeclaration_Interval());
+use_current_InterfaceDeclaration_IntervalIndex(get_old_InterfaceDeclaration_IntervalIndex());
+use_old_InterfaceDeclaration_IntervalIndex(get_current_InterfaceDeclaration_IntervalIndex());
+use_current_InterfaceDeclaration_IntervalLocator(get_old_InterfaceDeclaration_IntervalLocator());
+use_old_InterfaceDeclaration_IntervalLocator(get_current_InterfaceDeclaration_IntervalLocator());
+use_current_VariableDeclaration_IntervalOpType(get_old_VariableDeclaration_IntervalOpType());
+use_old_VariableDeclaration_IntervalOpType(get_current_VariableDeclaration_IntervalOpType());
+use_current_TypeAliasDeclaration_IntervalOpType(get_old_TypeAliasDeclaration_IntervalOpType());
+use_old_TypeAliasDeclaration_IntervalOpType(get_current_TypeAliasDeclaration_IntervalOpType());
+use_current_TypeAliasDeclaration_IntervalRevertible(get_old_TypeAliasDeclaration_IntervalRevertible());
+use_old_TypeAliasDeclaration_IntervalRevertible(get_current_TypeAliasDeclaration_IntervalRevertible());
+use_current_VariableDeclaration_IntervalStickiness(get_old_VariableDeclaration_IntervalStickiness());
+use_old_VariableDeclaration_IntervalStickiness(get_current_VariableDeclaration_IntervalStickiness());
+use_current_TypeAliasDeclaration_IntervalStickiness(get_old_TypeAliasDeclaration_IntervalStickiness());
+use_old_TypeAliasDeclaration_IntervalStickiness(get_current_TypeAliasDeclaration_IntervalStickiness());
+use_current_EnumDeclaration_IntervalType(get_old_EnumDeclaration_IntervalType());
+use_old_EnumDeclaration_IntervalType(get_current_EnumDeclaration_IntervalType());
+use_current_InterfaceDeclaration_LocalReferencePosition(get_old_InterfaceDeclaration_LocalReferencePosition());
+use_old_InterfaceDeclaration_LocalReferencePosition(get_current_InterfaceDeclaration_LocalReferencePosition());
+use_current_InterfaceDeclaration_MapLike(get_old_InterfaceDeclaration_MapLike());
+use_old_InterfaceDeclaration_MapLike(get_current_InterfaceDeclaration_MapLike());
+use_current_ClassDeclaration_Marker(get_old_ClassDeclaration_Marker());
+use_old_ClassDeclaration_Marker(get_current_ClassDeclaration_Marker());
+use_current_VariableDeclaration_MergeTreeDeltaType(get_old_VariableDeclaration_MergeTreeDeltaType());
+use_old_VariableDeclaration_MergeTreeDeltaType(get_current_VariableDeclaration_MergeTreeDeltaType());
+use_current_TypeAliasDeclaration_MergeTreeDeltaType(get_old_TypeAliasDeclaration_MergeTreeDeltaType());
+use_old_TypeAliasDeclaration_MergeTreeDeltaType(get_current_TypeAliasDeclaration_MergeTreeDeltaType());
+use_current_TypeAliasDeclaration_PropertySet(get_old_TypeAliasDeclaration_PropertySet());
+use_old_TypeAliasDeclaration_PropertySet(get_current_TypeAliasDeclaration_PropertySet());
+use_current_InterfaceDeclaration_ReferencePosition(get_old_InterfaceDeclaration_ReferencePosition());
+use_old_InterfaceDeclaration_ReferencePosition(get_current_InterfaceDeclaration_ReferencePosition());
+use_current_EnumDeclaration_ReferenceType(get_old_EnumDeclaration_ReferenceType());
+use_old_EnumDeclaration_ReferenceType(get_current_EnumDeclaration_ReferenceType());
+use_current_ClassDeclaration_SequenceDeltaEvent(get_old_ClassDeclaration_SequenceDeltaEvent());
+use_old_ClassDeclaration_SequenceDeltaEvent(get_current_ClassDeclaration_SequenceDeltaEvent());
+use_current_ClassDeclaration_SequenceEvent(get_old_ClassDeclaration_SequenceEvent());
+use_old_ClassDeclaration_SequenceEvent(get_current_ClassDeclaration_SequenceEvent());
+use_current_ClassDeclaration_SequenceInterval(get_old_ClassDeclaration_SequenceInterval());
+use_old_ClassDeclaration_SequenceInterval(get_current_ClassDeclaration_SequenceInterval());
+use_current_InterfaceDeclaration_SequenceIntervalIndexes_Overlapping(get_old_InterfaceDeclaration_SequenceIntervalIndexes_Overlapping());
+use_old_InterfaceDeclaration_SequenceIntervalIndexes_Overlapping(get_current_InterfaceDeclaration_SequenceIntervalIndexes_Overlapping());
+use_current_ClassDeclaration_SequenceMaintenanceEvent(get_old_ClassDeclaration_SequenceMaintenanceEvent());
+use_old_ClassDeclaration_SequenceMaintenanceEvent(get_current_ClassDeclaration_SequenceMaintenanceEvent());
+use_current_InterfaceDeclaration_SequenceOptions(get_old_InterfaceDeclaration_SequenceOptions());
+use_old_InterfaceDeclaration_SequenceOptions(get_current_InterfaceDeclaration_SequenceOptions());
+use_current_TypeAliasDeclaration_SequencePlace(get_old_TypeAliasDeclaration_SequencePlace());
+use_old_TypeAliasDeclaration_SequencePlace(get_current_TypeAliasDeclaration_SequencePlace());
+use_current_TypeAliasDeclaration_SerializedIntervalDelta(get_old_TypeAliasDeclaration_SerializedIntervalDelta());
+use_old_TypeAliasDeclaration_SerializedIntervalDelta(get_current_TypeAliasDeclaration_SerializedIntervalDelta());
+use_current_ClassDeclaration_SharedIntervalCollection(get_old_ClassDeclaration_SharedIntervalCollection());
+use_old_ClassDeclaration_SharedIntervalCollection(get_current_ClassDeclaration_SharedIntervalCollection());
+use_current_ClassDeclaration_SharedIntervalCollectionFactory(get_old_ClassDeclaration_SharedIntervalCollectionFactory());
+use_old_ClassDeclaration_SharedIntervalCollectionFactory(get_current_ClassDeclaration_SharedIntervalCollectionFactory());
+use_current_ClassDeclaration_SharedSegmentSequence(get_old_ClassDeclaration_SharedSegmentSequence());
+use_old_ClassDeclaration_SharedSegmentSequence(get_current_ClassDeclaration_SharedSegmentSequence());
+use_current_ClassDeclaration_SharedSequence(get_old_ClassDeclaration_SharedSequence());
+use_old_ClassDeclaration_SharedSequence(get_current_ClassDeclaration_SharedSequence());
+use_current_ClassDeclaration_SharedString(get_old_ClassDeclaration_SharedString());
+use_old_ClassDeclaration_SharedString(
+// @ts-expect-error compatibility expected to be broken
+get_current_ClassDeclaration_SharedString());
+use_current_ClassDeclaration_SharedStringFactory(get_old_ClassDeclaration_SharedStringFactory());
+use_old_ClassDeclaration_SharedStringFactory(get_current_ClassDeclaration_SharedStringFactory());
+use_current_TypeAliasDeclaration_SharedStringRevertible(get_old_TypeAliasDeclaration_SharedStringRevertible());
+use_old_TypeAliasDeclaration_SharedStringRevertible(get_current_TypeAliasDeclaration_SharedStringRevertible());
+use_current_TypeAliasDeclaration_SharedStringSegment(get_old_TypeAliasDeclaration_SharedStringSegment());
+use_old_TypeAliasDeclaration_SharedStringSegment(get_current_TypeAliasDeclaration_SharedStringSegment());
+use_current_EnumDeclaration_Side(get_old_EnumDeclaration_Side());
+use_old_EnumDeclaration_Side(get_current_EnumDeclaration_Side());
+use_current_ClassDeclaration_SubSequence(get_old_ClassDeclaration_SubSequence());
+use_old_ClassDeclaration_SubSequence(get_current_ClassDeclaration_SubSequence());
+use_current_ClassDeclaration_TextSegment(get_old_ClassDeclaration_TextSegment());
+use_old_ClassDeclaration_TextSegment(get_current_ClassDeclaration_TextSegment());
+use_current_ClassDeclaration_TrackingGroup(get_old_ClassDeclaration_TrackingGroup());
+use_old_ClassDeclaration_TrackingGroup(get_current_ClassDeclaration_TrackingGroup());
+use_current_FunctionDeclaration_appendAddIntervalToRevertibles(get_old_FunctionDeclaration_appendAddIntervalToRevertibles());
+use_old_FunctionDeclaration_appendAddIntervalToRevertibles(get_current_FunctionDeclaration_appendAddIntervalToRevertibles());
+use_current_FunctionDeclaration_appendChangeIntervalToRevertibles(get_old_FunctionDeclaration_appendChangeIntervalToRevertibles());
+use_old_FunctionDeclaration_appendChangeIntervalToRevertibles(get_current_FunctionDeclaration_appendChangeIntervalToRevertibles());
+use_current_FunctionDeclaration_appendDeleteIntervalToRevertibles(get_old_FunctionDeclaration_appendDeleteIntervalToRevertibles());
+use_old_FunctionDeclaration_appendDeleteIntervalToRevertibles(get_current_FunctionDeclaration_appendDeleteIntervalToRevertibles());
+use_current_FunctionDeclaration_appendIntervalPropertyChangedToRevertibles(get_old_FunctionDeclaration_appendIntervalPropertyChangedToRevertibles());
+use_old_FunctionDeclaration_appendIntervalPropertyChangedToRevertibles(get_current_FunctionDeclaration_appendIntervalPropertyChangedToRevertibles());
+use_current_FunctionDeclaration_appendSharedStringDeltaToRevertibles(get_old_FunctionDeclaration_appendSharedStringDeltaToRevertibles());
+use_old_FunctionDeclaration_appendSharedStringDeltaToRevertibles(get_current_FunctionDeclaration_appendSharedStringDeltaToRevertibles());
+use_current_FunctionDeclaration_createEndpointInRangeIndex(get_old_FunctionDeclaration_createEndpointInRangeIndex());
+use_old_FunctionDeclaration_createEndpointInRangeIndex(get_current_FunctionDeclaration_createEndpointInRangeIndex());
+use_current_FunctionDeclaration_createEndpointIndex(get_old_FunctionDeclaration_createEndpointIndex());
+use_old_FunctionDeclaration_createEndpointIndex(get_current_FunctionDeclaration_createEndpointIndex());
+use_current_FunctionDeclaration_createIdIntervalIndex(get_old_FunctionDeclaration_createIdIntervalIndex());
+use_old_FunctionDeclaration_createIdIntervalIndex(get_current_FunctionDeclaration_createIdIntervalIndex());
+use_current_FunctionDeclaration_createOverlappingIntervalsIndex(get_old_FunctionDeclaration_createOverlappingIntervalsIndex());
+use_old_FunctionDeclaration_createOverlappingIntervalsIndex(get_current_FunctionDeclaration_createOverlappingIntervalsIndex());
+use_current_FunctionDeclaration_createOverlappingSequenceIntervalsIndex(get_old_FunctionDeclaration_createOverlappingSequenceIntervalsIndex());
+use_old_FunctionDeclaration_createOverlappingSequenceIntervalsIndex(get_current_FunctionDeclaration_createOverlappingSequenceIntervalsIndex());
+use_current_FunctionDeclaration_createStartpointInRangeIndex(get_old_FunctionDeclaration_createStartpointInRangeIndex());
+use_old_FunctionDeclaration_createStartpointInRangeIndex(get_current_FunctionDeclaration_createStartpointInRangeIndex());
+use_current_FunctionDeclaration_discardSharedStringRevertibles(get_old_FunctionDeclaration_discardSharedStringRevertibles());
+use_old_FunctionDeclaration_discardSharedStringRevertibles(get_current_FunctionDeclaration_discardSharedStringRevertibles());
+use_current_FunctionDeclaration_getTextAndMarkers(get_old_FunctionDeclaration_getTextAndMarkers());
+use_old_FunctionDeclaration_getTextAndMarkers(get_current_FunctionDeclaration_getTextAndMarkers());
+use_current_FunctionDeclaration_intervalLocatorFromEndpoint(get_old_FunctionDeclaration_intervalLocatorFromEndpoint());
+use_old_FunctionDeclaration_intervalLocatorFromEndpoint(get_current_FunctionDeclaration_intervalLocatorFromEndpoint());
+use_current_VariableDeclaration_reservedMarkerIdKey(get_old_VariableDeclaration_reservedMarkerIdKey());
+use_old_VariableDeclaration_reservedMarkerIdKey(get_current_VariableDeclaration_reservedMarkerIdKey());
+use_current_VariableDeclaration_reservedRangeLabelsKey(get_old_VariableDeclaration_reservedRangeLabelsKey());
+use_old_VariableDeclaration_reservedRangeLabelsKey(get_current_VariableDeclaration_reservedRangeLabelsKey());
+use_current_VariableDeclaration_reservedTileLabelsKey(get_old_VariableDeclaration_reservedTileLabelsKey());
+use_old_VariableDeclaration_reservedTileLabelsKey(get_current_VariableDeclaration_reservedTileLabelsKey());
+use_current_FunctionDeclaration_revertSharedStringRevertibles(get_old_FunctionDeclaration_revertSharedStringRevertibles());
+use_old_FunctionDeclaration_revertSharedStringRevertibles(get_current_FunctionDeclaration_revertSharedStringRevertibles());
+use_current_VariableDeclaration_sequenceIntervalHelpers(get_old_VariableDeclaration_sequenceIntervalHelpers());
+use_old_VariableDeclaration_sequenceIntervalHelpers(get_current_VariableDeclaration_sequenceIntervalHelpers());
+export {};
+//# sourceMappingURL=validateSequencePrevious.generated.js.map

package/lib/test/types/validateSequencePrevious.generated.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateSequencePrevious.generated.js","sourceRoot":"","sources":["../../../src/test/types/validateSequencePrevious.generated.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n/*\n * THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.\n * Generated by fluid-type-test-generator in @fluidframework/build-tools.\n */\nimport type * as old from \"@fluidframework/sequence-previous\";\nimport type * as current from \"../../index.js\";\n\n\n// See 'build-tools/src/type-test-generator/compatibility.ts' for more information.\ntype TypeOnly<T> = T extends number\n\t? number\n\t: T extends string\n\t? string\n\t: T extends boolean | bigint | symbol\n\t? T\n\t: {\n\t\t\t[P in keyof T]: TypeOnly<T[P]>;\n\t  };\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"ClassDeclaration_BaseSegment\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_ClassDeclaration_BaseSegment():\n    TypeOnly<old.BaseSegment>;\ndeclare function use_current_ClassDeclaration_BaseSegment(\n    use: TypeOnly<current.BaseSegment>): void;\nuse_current_ClassDeclaration_BaseSegment(\n    get_old_ClassDeclaration_BaseSegment());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"ClassDeclaration_BaseSegment\": {\"backCompat\": false}\n*/\ndeclare function get_current_ClassDeclaration_BaseSegment():\n    TypeOnly<current.BaseSegment>;\ndeclare function use_old_ClassDeclaration_BaseSegment(\n    use: TypeOnly<old.BaseSegment>): void;\nuse_old_ClassDeclaration_BaseSegment(\n    get_current_ClassDeclaration_BaseSegment());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"TypeAliasDeclaration_DeserializeCallback\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_TypeAliasDeclaration_DeserializeCallback():\n    TypeOnly<old.DeserializeCallback>;\ndeclare function use_current_TypeAliasDeclaration_DeserializeCallback(\n    use: TypeOnly<current.DeserializeCallback>): void;\nuse_current_TypeAliasDeclaration_DeserializeCallback(\n    get_old_TypeAliasDeclaration_DeserializeCallback());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"TypeAliasDeclaration_DeserializeCallback\": {\"backCompat\": false}\n*/\ndeclare function get_current_TypeAliasDeclaration_DeserializeCallback():\n    TypeOnly<current.DeserializeCallback>;\ndeclare function use_old_TypeAliasDeclaration_DeserializeCallback(\n    use: TypeOnly<old.DeserializeCallback>): void;\nuse_old_TypeAliasDeclaration_DeserializeCallback(\n    get_current_TypeAliasDeclaration_DeserializeCallback());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_IEndpointInRangeIndex\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_IEndpointInRangeIndex():\n    TypeOnly<old.IEndpointInRangeIndex<any>>;\ndeclare function use_current_InterfaceDeclaration_IEndpointInRangeIndex(\n    use: TypeOnly<current.IEndpointInRangeIndex<any>>): void;\nuse_current_InterfaceDeclaration_IEndpointInRangeIndex(\n    get_old_InterfaceDeclaration_IEndpointInRangeIndex());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_IEndpointInRangeIndex\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_IEndpointInRangeIndex():\n    TypeOnly<current.IEndpointInRangeIndex<any>>;\ndeclare function use_old_InterfaceDeclaration_IEndpointInRangeIndex(\n    use: TypeOnly<old.IEndpointInRangeIndex<any>>): void;\nuse_old_InterfaceDeclaration_IEndpointInRangeIndex(\n    get_current_InterfaceDeclaration_IEndpointInRangeIndex());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_IEndpointIndex\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_IEndpointIndex():\n    TypeOnly<old.IEndpointIndex<any>>;\ndeclare function use_current_InterfaceDeclaration_IEndpointIndex(\n    use: TypeOnly<current.IEndpointIndex<any>>): void;\nuse_current_InterfaceDeclaration_IEndpointIndex(\n    get_old_InterfaceDeclaration_IEndpointIndex());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_IEndpointIndex\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_IEndpointIndex():\n    TypeOnly<current.IEndpointIndex<any>>;\ndeclare function use_old_InterfaceDeclaration_IEndpointIndex(\n    use: TypeOnly<old.IEndpointIndex<any>>): void;\nuse_old_InterfaceDeclaration_IEndpointIndex(\n    get_current_InterfaceDeclaration_IEndpointIndex());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_IIdIntervalIndex\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_IIdIntervalIndex():\n    TypeOnly<old.IIdIntervalIndex<any>>;\ndeclare function use_current_InterfaceDeclaration_IIdIntervalIndex(\n    use: TypeOnly<current.IIdIntervalIndex<any>>): void;\nuse_current_InterfaceDeclaration_IIdIntervalIndex(\n    get_old_InterfaceDeclaration_IIdIntervalIndex());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_IIdIntervalIndex\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_IIdIntervalIndex():\n    TypeOnly<current.IIdIntervalIndex<any>>;\ndeclare function use_old_InterfaceDeclaration_IIdIntervalIndex(\n    use: TypeOnly<old.IIdIntervalIndex<any>>): void;\nuse_old_InterfaceDeclaration_IIdIntervalIndex(\n    get_current_InterfaceDeclaration_IIdIntervalIndex());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_IInterval\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_IInterval():\n    TypeOnly<old.IInterval>;\ndeclare function use_current_InterfaceDeclaration_IInterval(\n    use: TypeOnly<current.IInterval>): void;\nuse_current_InterfaceDeclaration_IInterval(\n    get_old_InterfaceDeclaration_IInterval());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_IInterval\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_IInterval():\n    TypeOnly<current.IInterval>;\ndeclare function use_old_InterfaceDeclaration_IInterval(\n    use: TypeOnly<old.IInterval>): void;\nuse_old_InterfaceDeclaration_IInterval(\n    get_current_InterfaceDeclaration_IInterval());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_IIntervalCollection\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_IIntervalCollection():\n    TypeOnly<old.IIntervalCollection<any>>;\ndeclare function use_current_InterfaceDeclaration_IIntervalCollection(\n    use: TypeOnly<current.IIntervalCollection<any>>): void;\nuse_current_InterfaceDeclaration_IIntervalCollection(\n    get_old_InterfaceDeclaration_IIntervalCollection());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_IIntervalCollection\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_IIntervalCollection():\n    TypeOnly<current.IIntervalCollection<any>>;\ndeclare function use_old_InterfaceDeclaration_IIntervalCollection(\n    use: TypeOnly<old.IIntervalCollection<any>>): void;\nuse_old_InterfaceDeclaration_IIntervalCollection(\n    // @ts-expect-error compatibility expected to be broken\n    get_current_InterfaceDeclaration_IIntervalCollection());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_IIntervalCollectionEvent\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_IIntervalCollectionEvent():\n    TypeOnly<old.IIntervalCollectionEvent<any>>;\ndeclare function use_current_InterfaceDeclaration_IIntervalCollectionEvent(\n    use: TypeOnly<current.IIntervalCollectionEvent<any>>): void;\nuse_current_InterfaceDeclaration_IIntervalCollectionEvent(\n    get_old_InterfaceDeclaration_IIntervalCollectionEvent());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_IIntervalCollectionEvent\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_IIntervalCollectionEvent():\n    TypeOnly<current.IIntervalCollectionEvent<any>>;\ndeclare function use_old_InterfaceDeclaration_IIntervalCollectionEvent(\n    use: TypeOnly<old.IIntervalCollectionEvent<any>>): void;\nuse_old_InterfaceDeclaration_IIntervalCollectionEvent(\n    get_current_InterfaceDeclaration_IIntervalCollectionEvent());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_IIntervalHelpers\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_IIntervalHelpers():\n    TypeOnly<old.IIntervalHelpers<any>>;\ndeclare function use_current_InterfaceDeclaration_IIntervalHelpers(\n    use: TypeOnly<current.IIntervalHelpers<any>>): void;\nuse_current_InterfaceDeclaration_IIntervalHelpers(\n    get_old_InterfaceDeclaration_IIntervalHelpers());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_IIntervalHelpers\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_IIntervalHelpers():\n    TypeOnly<current.IIntervalHelpers<any>>;\ndeclare function use_old_InterfaceDeclaration_IIntervalHelpers(\n    use: TypeOnly<old.IIntervalHelpers<any>>): void;\nuse_old_InterfaceDeclaration_IIntervalHelpers(\n    get_current_InterfaceDeclaration_IIntervalHelpers());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_IJSONRunSegment\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_IJSONRunSegment():\n    TypeOnly<old.IJSONRunSegment<any>>;\ndeclare function use_current_InterfaceDeclaration_IJSONRunSegment(\n    use: TypeOnly<current.IJSONRunSegment<any>>): void;\nuse_current_InterfaceDeclaration_IJSONRunSegment(\n    get_old_InterfaceDeclaration_IJSONRunSegment());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_IJSONRunSegment\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_IJSONRunSegment():\n    TypeOnly<current.IJSONRunSegment<any>>;\ndeclare function use_old_InterfaceDeclaration_IJSONRunSegment(\n    use: TypeOnly<old.IJSONRunSegment<any>>): void;\nuse_old_InterfaceDeclaration_IJSONRunSegment(\n    get_current_InterfaceDeclaration_IJSONRunSegment());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_IMapMessageLocalMetadata\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_IMapMessageLocalMetadata():\n    TypeOnly<old.IMapMessageLocalMetadata>;\ndeclare function use_current_InterfaceDeclaration_IMapMessageLocalMetadata(\n    use: TypeOnly<current.IMapMessageLocalMetadata>): void;\nuse_current_InterfaceDeclaration_IMapMessageLocalMetadata(\n    get_old_InterfaceDeclaration_IMapMessageLocalMetadata());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_IMapMessageLocalMetadata\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_IMapMessageLocalMetadata():\n    TypeOnly<current.IMapMessageLocalMetadata>;\ndeclare function use_old_InterfaceDeclaration_IMapMessageLocalMetadata(\n    use: TypeOnly<old.IMapMessageLocalMetadata>): void;\nuse_old_InterfaceDeclaration_IMapMessageLocalMetadata(\n    get_current_InterfaceDeclaration_IMapMessageLocalMetadata());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_IOverlappingIntervalsIndex\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_IOverlappingIntervalsIndex():\n    TypeOnly<old.IOverlappingIntervalsIndex<any>>;\ndeclare function use_current_InterfaceDeclaration_IOverlappingIntervalsIndex(\n    use: TypeOnly<current.IOverlappingIntervalsIndex<any>>): void;\nuse_current_InterfaceDeclaration_IOverlappingIntervalsIndex(\n    get_old_InterfaceDeclaration_IOverlappingIntervalsIndex());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_IOverlappingIntervalsIndex\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_IOverlappingIntervalsIndex():\n    TypeOnly<current.IOverlappingIntervalsIndex<any>>;\ndeclare function use_old_InterfaceDeclaration_IOverlappingIntervalsIndex(\n    use: TypeOnly<old.IOverlappingIntervalsIndex<any>>): void;\nuse_old_InterfaceDeclaration_IOverlappingIntervalsIndex(\n    get_current_InterfaceDeclaration_IOverlappingIntervalsIndex());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_ISegment\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_ISegment():\n    TypeOnly<old.ISegment>;\ndeclare function use_current_InterfaceDeclaration_ISegment(\n    use: TypeOnly<current.ISegment>): void;\nuse_current_InterfaceDeclaration_ISegment(\n    get_old_InterfaceDeclaration_ISegment());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_ISegment\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_ISegment():\n    TypeOnly<current.ISegment>;\ndeclare function use_old_InterfaceDeclaration_ISegment(\n    use: TypeOnly<old.ISegment>): void;\nuse_old_InterfaceDeclaration_ISegment(\n    get_current_InterfaceDeclaration_ISegment());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_ISequenceDeltaRange\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_ISequenceDeltaRange():\n    TypeOnly<old.ISequenceDeltaRange>;\ndeclare function use_current_InterfaceDeclaration_ISequenceDeltaRange(\n    use: TypeOnly<current.ISequenceDeltaRange>): void;\nuse_current_InterfaceDeclaration_ISequenceDeltaRange(\n    get_old_InterfaceDeclaration_ISequenceDeltaRange());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_ISequenceDeltaRange\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_ISequenceDeltaRange():\n    TypeOnly<current.ISequenceDeltaRange>;\ndeclare function use_old_InterfaceDeclaration_ISequenceDeltaRange(\n    use: TypeOnly<old.ISequenceDeltaRange>): void;\nuse_old_InterfaceDeclaration_ISequenceDeltaRange(\n    get_current_InterfaceDeclaration_ISequenceDeltaRange());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_ISerializableInterval\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_ISerializableInterval():\n    TypeOnly<old.ISerializableInterval>;\ndeclare function use_current_InterfaceDeclaration_ISerializableInterval(\n    use: TypeOnly<current.ISerializableInterval>): void;\nuse_current_InterfaceDeclaration_ISerializableInterval(\n    get_old_InterfaceDeclaration_ISerializableInterval());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_ISerializableInterval\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_ISerializableInterval():\n    TypeOnly<current.ISerializableInterval>;\ndeclare function use_old_InterfaceDeclaration_ISerializableInterval(\n    use: TypeOnly<old.ISerializableInterval>): void;\nuse_old_InterfaceDeclaration_ISerializableInterval(\n    get_current_InterfaceDeclaration_ISerializableInterval());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_ISerializedInterval\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_ISerializedInterval():\n    TypeOnly<old.ISerializedInterval>;\ndeclare function use_current_InterfaceDeclaration_ISerializedInterval(\n    use: TypeOnly<current.ISerializedInterval>): void;\nuse_current_InterfaceDeclaration_ISerializedInterval(\n    get_old_InterfaceDeclaration_ISerializedInterval());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_ISerializedInterval\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_ISerializedInterval():\n    TypeOnly<current.ISerializedInterval>;\ndeclare function use_old_InterfaceDeclaration_ISerializedInterval(\n    use: TypeOnly<old.ISerializedInterval>): void;\nuse_old_InterfaceDeclaration_ISerializedInterval(\n    get_current_InterfaceDeclaration_ISerializedInterval());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_ISharedIntervalCollection\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_ISharedIntervalCollection():\n    TypeOnly<old.ISharedIntervalCollection<any>>;\ndeclare function use_current_InterfaceDeclaration_ISharedIntervalCollection(\n    use: TypeOnly<current.ISharedIntervalCollection<any>>): void;\nuse_current_InterfaceDeclaration_ISharedIntervalCollection(\n    get_old_InterfaceDeclaration_ISharedIntervalCollection());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_ISharedIntervalCollection\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_ISharedIntervalCollection():\n    TypeOnly<current.ISharedIntervalCollection<any>>;\ndeclare function use_old_InterfaceDeclaration_ISharedIntervalCollection(\n    use: TypeOnly<old.ISharedIntervalCollection<any>>): void;\nuse_old_InterfaceDeclaration_ISharedIntervalCollection(\n    get_current_InterfaceDeclaration_ISharedIntervalCollection());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_ISharedSegmentSequenceEvents\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_ISharedSegmentSequenceEvents():\n    TypeOnly<old.ISharedSegmentSequenceEvents>;\ndeclare function use_current_InterfaceDeclaration_ISharedSegmentSequenceEvents(\n    use: TypeOnly<current.ISharedSegmentSequenceEvents>): void;\nuse_current_InterfaceDeclaration_ISharedSegmentSequenceEvents(\n    get_old_InterfaceDeclaration_ISharedSegmentSequenceEvents());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_ISharedSegmentSequenceEvents\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_ISharedSegmentSequenceEvents():\n    TypeOnly<current.ISharedSegmentSequenceEvents>;\ndeclare function use_old_InterfaceDeclaration_ISharedSegmentSequenceEvents(\n    use: TypeOnly<old.ISharedSegmentSequenceEvents>): void;\nuse_old_InterfaceDeclaration_ISharedSegmentSequenceEvents(\n    get_current_InterfaceDeclaration_ISharedSegmentSequenceEvents());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_ISharedString\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_ISharedString():\n    TypeOnly<old.ISharedString>;\ndeclare function use_current_InterfaceDeclaration_ISharedString(\n    use: TypeOnly<current.ISharedString>): void;\nuse_current_InterfaceDeclaration_ISharedString(\n    get_old_InterfaceDeclaration_ISharedString());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_ISharedString\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_ISharedString():\n    TypeOnly<current.ISharedString>;\ndeclare function use_old_InterfaceDeclaration_ISharedString(\n    use: TypeOnly<old.ISharedString>): void;\nuse_old_InterfaceDeclaration_ISharedString(\n    get_current_InterfaceDeclaration_ISharedString());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_IStartpointInRangeIndex\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_IStartpointInRangeIndex():\n    TypeOnly<old.IStartpointInRangeIndex<any>>;\ndeclare function use_current_InterfaceDeclaration_IStartpointInRangeIndex(\n    use: TypeOnly<current.IStartpointInRangeIndex<any>>): void;\nuse_current_InterfaceDeclaration_IStartpointInRangeIndex(\n    get_old_InterfaceDeclaration_IStartpointInRangeIndex());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_IStartpointInRangeIndex\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_IStartpointInRangeIndex():\n    TypeOnly<current.IStartpointInRangeIndex<any>>;\ndeclare function use_old_InterfaceDeclaration_IStartpointInRangeIndex(\n    use: TypeOnly<old.IStartpointInRangeIndex<any>>): void;\nuse_old_InterfaceDeclaration_IStartpointInRangeIndex(\n    get_current_InterfaceDeclaration_IStartpointInRangeIndex());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_IValueOpEmitter\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_IValueOpEmitter():\n    TypeOnly<old.IValueOpEmitter>;\ndeclare function use_current_InterfaceDeclaration_IValueOpEmitter(\n    use: TypeOnly<current.IValueOpEmitter>): void;\nuse_current_InterfaceDeclaration_IValueOpEmitter(\n    get_old_InterfaceDeclaration_IValueOpEmitter());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_IValueOpEmitter\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_IValueOpEmitter():\n    TypeOnly<current.IValueOpEmitter>;\ndeclare function use_old_InterfaceDeclaration_IValueOpEmitter(\n    use: TypeOnly<old.IValueOpEmitter>): void;\nuse_old_InterfaceDeclaration_IValueOpEmitter(\n    get_current_InterfaceDeclaration_IValueOpEmitter());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_InteriorSequencePlace\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_InteriorSequencePlace():\n    TypeOnly<old.InteriorSequencePlace>;\ndeclare function use_current_InterfaceDeclaration_InteriorSequencePlace(\n    use: TypeOnly<current.InteriorSequencePlace>): void;\nuse_current_InterfaceDeclaration_InteriorSequencePlace(\n    get_old_InterfaceDeclaration_InteriorSequencePlace());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_InteriorSequencePlace\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_InteriorSequencePlace():\n    TypeOnly<current.InteriorSequencePlace>;\ndeclare function use_old_InterfaceDeclaration_InteriorSequencePlace(\n    use: TypeOnly<old.InteriorSequencePlace>): void;\nuse_old_InterfaceDeclaration_InteriorSequencePlace(\n    get_current_InterfaceDeclaration_InteriorSequencePlace());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"ClassDeclaration_Interval\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_ClassDeclaration_Interval():\n    TypeOnly<old.Interval>;\ndeclare function use_current_ClassDeclaration_Interval(\n    use: TypeOnly<current.Interval>): void;\nuse_current_ClassDeclaration_Interval(\n    get_old_ClassDeclaration_Interval());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"ClassDeclaration_Interval\": {\"backCompat\": false}\n*/\ndeclare function get_current_ClassDeclaration_Interval():\n    TypeOnly<current.Interval>;\ndeclare function use_old_ClassDeclaration_Interval(\n    use: TypeOnly<old.Interval>): void;\nuse_old_ClassDeclaration_Interval(\n    get_current_ClassDeclaration_Interval());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_IntervalIndex\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_IntervalIndex():\n    TypeOnly<old.IntervalIndex<any>>;\ndeclare function use_current_InterfaceDeclaration_IntervalIndex(\n    use: TypeOnly<current.IntervalIndex<any>>): void;\nuse_current_InterfaceDeclaration_IntervalIndex(\n    get_old_InterfaceDeclaration_IntervalIndex());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_IntervalIndex\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_IntervalIndex():\n    TypeOnly<current.IntervalIndex<any>>;\ndeclare function use_old_InterfaceDeclaration_IntervalIndex(\n    use: TypeOnly<old.IntervalIndex<any>>): void;\nuse_old_InterfaceDeclaration_IntervalIndex(\n    get_current_InterfaceDeclaration_IntervalIndex());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_IntervalLocator\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_IntervalLocator():\n    TypeOnly<old.IntervalLocator>;\ndeclare function use_current_InterfaceDeclaration_IntervalLocator(\n    use: TypeOnly<current.IntervalLocator>): void;\nuse_current_InterfaceDeclaration_IntervalLocator(\n    get_old_InterfaceDeclaration_IntervalLocator());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_IntervalLocator\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_IntervalLocator():\n    TypeOnly<current.IntervalLocator>;\ndeclare function use_old_InterfaceDeclaration_IntervalLocator(\n    use: TypeOnly<old.IntervalLocator>): void;\nuse_old_InterfaceDeclaration_IntervalLocator(\n    get_current_InterfaceDeclaration_IntervalLocator());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"VariableDeclaration_IntervalOpType\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_VariableDeclaration_IntervalOpType():\n    TypeOnly<typeof old.IntervalOpType>;\ndeclare function use_current_VariableDeclaration_IntervalOpType(\n    use: TypeOnly<typeof current.IntervalOpType>): void;\nuse_current_VariableDeclaration_IntervalOpType(\n    get_old_VariableDeclaration_IntervalOpType());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"VariableDeclaration_IntervalOpType\": {\"backCompat\": false}\n*/\ndeclare function get_current_VariableDeclaration_IntervalOpType():\n    TypeOnly<typeof current.IntervalOpType>;\ndeclare function use_old_VariableDeclaration_IntervalOpType(\n    use: TypeOnly<typeof old.IntervalOpType>): void;\nuse_old_VariableDeclaration_IntervalOpType(\n    get_current_VariableDeclaration_IntervalOpType());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"TypeAliasDeclaration_IntervalOpType\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_TypeAliasDeclaration_IntervalOpType():\n    TypeOnly<old.IntervalOpType>;\ndeclare function use_current_TypeAliasDeclaration_IntervalOpType(\n    use: TypeOnly<current.IntervalOpType>): void;\nuse_current_TypeAliasDeclaration_IntervalOpType(\n    get_old_TypeAliasDeclaration_IntervalOpType());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"TypeAliasDeclaration_IntervalOpType\": {\"backCompat\": false}\n*/\ndeclare function get_current_TypeAliasDeclaration_IntervalOpType():\n    TypeOnly<current.IntervalOpType>;\ndeclare function use_old_TypeAliasDeclaration_IntervalOpType(\n    use: TypeOnly<old.IntervalOpType>): void;\nuse_old_TypeAliasDeclaration_IntervalOpType(\n    get_current_TypeAliasDeclaration_IntervalOpType());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"TypeAliasDeclaration_IntervalRevertible\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_TypeAliasDeclaration_IntervalRevertible():\n    TypeOnly<old.IntervalRevertible>;\ndeclare function use_current_TypeAliasDeclaration_IntervalRevertible(\n    use: TypeOnly<current.IntervalRevertible>): void;\nuse_current_TypeAliasDeclaration_IntervalRevertible(\n    get_old_TypeAliasDeclaration_IntervalRevertible());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"TypeAliasDeclaration_IntervalRevertible\": {\"backCompat\": false}\n*/\ndeclare function get_current_TypeAliasDeclaration_IntervalRevertible():\n    TypeOnly<current.IntervalRevertible>;\ndeclare function use_old_TypeAliasDeclaration_IntervalRevertible(\n    use: TypeOnly<old.IntervalRevertible>): void;\nuse_old_TypeAliasDeclaration_IntervalRevertible(\n    get_current_TypeAliasDeclaration_IntervalRevertible());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"VariableDeclaration_IntervalStickiness\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_VariableDeclaration_IntervalStickiness():\n    TypeOnly<typeof old.IntervalStickiness>;\ndeclare function use_current_VariableDeclaration_IntervalStickiness(\n    use: TypeOnly<typeof current.IntervalStickiness>): void;\nuse_current_VariableDeclaration_IntervalStickiness(\n    get_old_VariableDeclaration_IntervalStickiness());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"VariableDeclaration_IntervalStickiness\": {\"backCompat\": false}\n*/\ndeclare function get_current_VariableDeclaration_IntervalStickiness():\n    TypeOnly<typeof current.IntervalStickiness>;\ndeclare function use_old_VariableDeclaration_IntervalStickiness(\n    use: TypeOnly<typeof old.IntervalStickiness>): void;\nuse_old_VariableDeclaration_IntervalStickiness(\n    get_current_VariableDeclaration_IntervalStickiness());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"TypeAliasDeclaration_IntervalStickiness\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_TypeAliasDeclaration_IntervalStickiness():\n    TypeOnly<old.IntervalStickiness>;\ndeclare function use_current_TypeAliasDeclaration_IntervalStickiness(\n    use: TypeOnly<current.IntervalStickiness>): void;\nuse_current_TypeAliasDeclaration_IntervalStickiness(\n    get_old_TypeAliasDeclaration_IntervalStickiness());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"TypeAliasDeclaration_IntervalStickiness\": {\"backCompat\": false}\n*/\ndeclare function get_current_TypeAliasDeclaration_IntervalStickiness():\n    TypeOnly<current.IntervalStickiness>;\ndeclare function use_old_TypeAliasDeclaration_IntervalStickiness(\n    use: TypeOnly<old.IntervalStickiness>): void;\nuse_old_TypeAliasDeclaration_IntervalStickiness(\n    get_current_TypeAliasDeclaration_IntervalStickiness());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"EnumDeclaration_IntervalType\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_EnumDeclaration_IntervalType():\n    TypeOnly<old.IntervalType>;\ndeclare function use_current_EnumDeclaration_IntervalType(\n    use: TypeOnly<current.IntervalType>): void;\nuse_current_EnumDeclaration_IntervalType(\n    get_old_EnumDeclaration_IntervalType());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"EnumDeclaration_IntervalType\": {\"backCompat\": false}\n*/\ndeclare function get_current_EnumDeclaration_IntervalType():\n    TypeOnly<current.IntervalType>;\ndeclare function use_old_EnumDeclaration_IntervalType(\n    use: TypeOnly<old.IntervalType>): void;\nuse_old_EnumDeclaration_IntervalType(\n    get_current_EnumDeclaration_IntervalType());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_LocalReferencePosition\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_LocalReferencePosition():\n    TypeOnly<old.LocalReferencePosition>;\ndeclare function use_current_InterfaceDeclaration_LocalReferencePosition(\n    use: TypeOnly<current.LocalReferencePosition>): void;\nuse_current_InterfaceDeclaration_LocalReferencePosition(\n    get_old_InterfaceDeclaration_LocalReferencePosition());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_LocalReferencePosition\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_LocalReferencePosition():\n    TypeOnly<current.LocalReferencePosition>;\ndeclare function use_old_InterfaceDeclaration_LocalReferencePosition(\n    use: TypeOnly<old.LocalReferencePosition>): void;\nuse_old_InterfaceDeclaration_LocalReferencePosition(\n    get_current_InterfaceDeclaration_LocalReferencePosition());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_MapLike\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_MapLike():\n    TypeOnly<old.MapLike<any>>;\ndeclare function use_current_InterfaceDeclaration_MapLike(\n    use: TypeOnly<current.MapLike<any>>): void;\nuse_current_InterfaceDeclaration_MapLike(\n    get_old_InterfaceDeclaration_MapLike());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_MapLike\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_MapLike():\n    TypeOnly<current.MapLike<any>>;\ndeclare function use_old_InterfaceDeclaration_MapLike(\n    use: TypeOnly<old.MapLike<any>>): void;\nuse_old_InterfaceDeclaration_MapLike(\n    get_current_InterfaceDeclaration_MapLike());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"ClassDeclaration_Marker\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_ClassDeclaration_Marker():\n    TypeOnly<old.Marker>;\ndeclare function use_current_ClassDeclaration_Marker(\n    use: TypeOnly<current.Marker>): void;\nuse_current_ClassDeclaration_Marker(\n    get_old_ClassDeclaration_Marker());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"ClassDeclaration_Marker\": {\"backCompat\": false}\n*/\ndeclare function get_current_ClassDeclaration_Marker():\n    TypeOnly<current.Marker>;\ndeclare function use_old_ClassDeclaration_Marker(\n    use: TypeOnly<old.Marker>): void;\nuse_old_ClassDeclaration_Marker(\n    get_current_ClassDeclaration_Marker());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"VariableDeclaration_MergeTreeDeltaType\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_VariableDeclaration_MergeTreeDeltaType():\n    TypeOnly<typeof old.MergeTreeDeltaType>;\ndeclare function use_current_VariableDeclaration_MergeTreeDeltaType(\n    use: TypeOnly<typeof current.MergeTreeDeltaType>): void;\nuse_current_VariableDeclaration_MergeTreeDeltaType(\n    get_old_VariableDeclaration_MergeTreeDeltaType());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"VariableDeclaration_MergeTreeDeltaType\": {\"backCompat\": false}\n*/\ndeclare function get_current_VariableDeclaration_MergeTreeDeltaType():\n    TypeOnly<typeof current.MergeTreeDeltaType>;\ndeclare function use_old_VariableDeclaration_MergeTreeDeltaType(\n    use: TypeOnly<typeof old.MergeTreeDeltaType>): void;\nuse_old_VariableDeclaration_MergeTreeDeltaType(\n    get_current_VariableDeclaration_MergeTreeDeltaType());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"TypeAliasDeclaration_MergeTreeDeltaType\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_TypeAliasDeclaration_MergeTreeDeltaType():\n    TypeOnly<old.MergeTreeDeltaType>;\ndeclare function use_current_TypeAliasDeclaration_MergeTreeDeltaType(\n    use: TypeOnly<current.MergeTreeDeltaType>): void;\nuse_current_TypeAliasDeclaration_MergeTreeDeltaType(\n    get_old_TypeAliasDeclaration_MergeTreeDeltaType());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"TypeAliasDeclaration_MergeTreeDeltaType\": {\"backCompat\": false}\n*/\ndeclare function get_current_TypeAliasDeclaration_MergeTreeDeltaType():\n    TypeOnly<current.MergeTreeDeltaType>;\ndeclare function use_old_TypeAliasDeclaration_MergeTreeDeltaType(\n    use: TypeOnly<old.MergeTreeDeltaType>): void;\nuse_old_TypeAliasDeclaration_MergeTreeDeltaType(\n    get_current_TypeAliasDeclaration_MergeTreeDeltaType());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"TypeAliasDeclaration_PropertySet\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_TypeAliasDeclaration_PropertySet():\n    TypeOnly<old.PropertySet>;\ndeclare function use_current_TypeAliasDeclaration_PropertySet(\n    use: TypeOnly<current.PropertySet>): void;\nuse_current_TypeAliasDeclaration_PropertySet(\n    get_old_TypeAliasDeclaration_PropertySet());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"TypeAliasDeclaration_PropertySet\": {\"backCompat\": false}\n*/\ndeclare function get_current_TypeAliasDeclaration_PropertySet():\n    TypeOnly<current.PropertySet>;\ndeclare function use_old_TypeAliasDeclaration_PropertySet(\n    use: TypeOnly<old.PropertySet>): void;\nuse_old_TypeAliasDeclaration_PropertySet(\n    get_current_TypeAliasDeclaration_PropertySet());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_ReferencePosition\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_ReferencePosition():\n    TypeOnly<old.ReferencePosition>;\ndeclare function use_current_InterfaceDeclaration_ReferencePosition(\n    use: TypeOnly<current.ReferencePosition>): void;\nuse_current_InterfaceDeclaration_ReferencePosition(\n    get_old_InterfaceDeclaration_ReferencePosition());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_ReferencePosition\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_ReferencePosition():\n    TypeOnly<current.ReferencePosition>;\ndeclare function use_old_InterfaceDeclaration_ReferencePosition(\n    use: TypeOnly<old.ReferencePosition>): void;\nuse_old_InterfaceDeclaration_ReferencePosition(\n    get_current_InterfaceDeclaration_ReferencePosition());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"EnumDeclaration_ReferenceType\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_EnumDeclaration_ReferenceType():\n    TypeOnly<old.ReferenceType>;\ndeclare function use_current_EnumDeclaration_ReferenceType(\n    use: TypeOnly<current.ReferenceType>): void;\nuse_current_EnumDeclaration_ReferenceType(\n    get_old_EnumDeclaration_ReferenceType());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"EnumDeclaration_ReferenceType\": {\"backCompat\": false}\n*/\ndeclare function get_current_EnumDeclaration_ReferenceType():\n    TypeOnly<current.ReferenceType>;\ndeclare function use_old_EnumDeclaration_ReferenceType(\n    use: TypeOnly<old.ReferenceType>): void;\nuse_old_EnumDeclaration_ReferenceType(\n    get_current_EnumDeclaration_ReferenceType());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"ClassDeclaration_SequenceDeltaEvent\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_ClassDeclaration_SequenceDeltaEvent():\n    TypeOnly<old.SequenceDeltaEvent>;\ndeclare function use_current_ClassDeclaration_SequenceDeltaEvent(\n    use: TypeOnly<current.SequenceDeltaEvent>): void;\nuse_current_ClassDeclaration_SequenceDeltaEvent(\n    get_old_ClassDeclaration_SequenceDeltaEvent());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"ClassDeclaration_SequenceDeltaEvent\": {\"backCompat\": false}\n*/\ndeclare function get_current_ClassDeclaration_SequenceDeltaEvent():\n    TypeOnly<current.SequenceDeltaEvent>;\ndeclare function use_old_ClassDeclaration_SequenceDeltaEvent(\n    use: TypeOnly<old.SequenceDeltaEvent>): void;\nuse_old_ClassDeclaration_SequenceDeltaEvent(\n    get_current_ClassDeclaration_SequenceDeltaEvent());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"ClassDeclaration_SequenceEvent\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_ClassDeclaration_SequenceEvent():\n    TypeOnly<old.SequenceEvent>;\ndeclare function use_current_ClassDeclaration_SequenceEvent(\n    use: TypeOnly<current.SequenceEvent>): void;\nuse_current_ClassDeclaration_SequenceEvent(\n    get_old_ClassDeclaration_SequenceEvent());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"ClassDeclaration_SequenceEvent\": {\"backCompat\": false}\n*/\ndeclare function get_current_ClassDeclaration_SequenceEvent():\n    TypeOnly<current.SequenceEvent>;\ndeclare function use_old_ClassDeclaration_SequenceEvent(\n    use: TypeOnly<old.SequenceEvent>): void;\nuse_old_ClassDeclaration_SequenceEvent(\n    get_current_ClassDeclaration_SequenceEvent());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"ClassDeclaration_SequenceInterval\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_ClassDeclaration_SequenceInterval():\n    TypeOnly<old.SequenceInterval>;\ndeclare function use_current_ClassDeclaration_SequenceInterval(\n    use: TypeOnly<current.SequenceInterval>): void;\nuse_current_ClassDeclaration_SequenceInterval(\n    get_old_ClassDeclaration_SequenceInterval());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"ClassDeclaration_SequenceInterval\": {\"backCompat\": false}\n*/\ndeclare function get_current_ClassDeclaration_SequenceInterval():\n    TypeOnly<current.SequenceInterval>;\ndeclare function use_old_ClassDeclaration_SequenceInterval(\n    use: TypeOnly<old.SequenceInterval>): void;\nuse_old_ClassDeclaration_SequenceInterval(\n    get_current_ClassDeclaration_SequenceInterval());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_SequenceIntervalIndexes.Overlapping\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_SequenceIntervalIndexes_Overlapping():\n    TypeOnly<old.SequenceIntervalIndexes.Overlapping>;\ndeclare function use_current_InterfaceDeclaration_SequenceIntervalIndexes_Overlapping(\n    use: TypeOnly<current.SequenceIntervalIndexes.Overlapping>): void;\nuse_current_InterfaceDeclaration_SequenceIntervalIndexes_Overlapping(\n    get_old_InterfaceDeclaration_SequenceIntervalIndexes_Overlapping());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_SequenceIntervalIndexes.Overlapping\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_SequenceIntervalIndexes_Overlapping():\n    TypeOnly<current.SequenceIntervalIndexes.Overlapping>;\ndeclare function use_old_InterfaceDeclaration_SequenceIntervalIndexes_Overlapping(\n    use: TypeOnly<old.SequenceIntervalIndexes.Overlapping>): void;\nuse_old_InterfaceDeclaration_SequenceIntervalIndexes_Overlapping(\n    get_current_InterfaceDeclaration_SequenceIntervalIndexes_Overlapping());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"ClassDeclaration_SequenceMaintenanceEvent\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_ClassDeclaration_SequenceMaintenanceEvent():\n    TypeOnly<old.SequenceMaintenanceEvent>;\ndeclare function use_current_ClassDeclaration_SequenceMaintenanceEvent(\n    use: TypeOnly<current.SequenceMaintenanceEvent>): void;\nuse_current_ClassDeclaration_SequenceMaintenanceEvent(\n    get_old_ClassDeclaration_SequenceMaintenanceEvent());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"ClassDeclaration_SequenceMaintenanceEvent\": {\"backCompat\": false}\n*/\ndeclare function get_current_ClassDeclaration_SequenceMaintenanceEvent():\n    TypeOnly<current.SequenceMaintenanceEvent>;\ndeclare function use_old_ClassDeclaration_SequenceMaintenanceEvent(\n    use: TypeOnly<old.SequenceMaintenanceEvent>): void;\nuse_old_ClassDeclaration_SequenceMaintenanceEvent(\n    get_current_ClassDeclaration_SequenceMaintenanceEvent());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_SequenceOptions\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_SequenceOptions():\n    TypeOnly<old.SequenceOptions>;\ndeclare function use_current_InterfaceDeclaration_SequenceOptions(\n    use: TypeOnly<current.SequenceOptions>): void;\nuse_current_InterfaceDeclaration_SequenceOptions(\n    get_old_InterfaceDeclaration_SequenceOptions());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"InterfaceDeclaration_SequenceOptions\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_SequenceOptions():\n    TypeOnly<current.SequenceOptions>;\ndeclare function use_old_InterfaceDeclaration_SequenceOptions(\n    use: TypeOnly<old.SequenceOptions>): void;\nuse_old_InterfaceDeclaration_SequenceOptions(\n    get_current_InterfaceDeclaration_SequenceOptions());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"TypeAliasDeclaration_SequencePlace\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_TypeAliasDeclaration_SequencePlace():\n    TypeOnly<old.SequencePlace>;\ndeclare function use_current_TypeAliasDeclaration_SequencePlace(\n    use: TypeOnly<current.SequencePlace>): void;\nuse_current_TypeAliasDeclaration_SequencePlace(\n    get_old_TypeAliasDeclaration_SequencePlace());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"TypeAliasDeclaration_SequencePlace\": {\"backCompat\": false}\n*/\ndeclare function get_current_TypeAliasDeclaration_SequencePlace():\n    TypeOnly<current.SequencePlace>;\ndeclare function use_old_TypeAliasDeclaration_SequencePlace(\n    use: TypeOnly<old.SequencePlace>): void;\nuse_old_TypeAliasDeclaration_SequencePlace(\n    get_current_TypeAliasDeclaration_SequencePlace());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"TypeAliasDeclaration_SerializedIntervalDelta\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_TypeAliasDeclaration_SerializedIntervalDelta():\n    TypeOnly<old.SerializedIntervalDelta>;\ndeclare function use_current_TypeAliasDeclaration_SerializedIntervalDelta(\n    use: TypeOnly<current.SerializedIntervalDelta>): void;\nuse_current_TypeAliasDeclaration_SerializedIntervalDelta(\n    get_old_TypeAliasDeclaration_SerializedIntervalDelta());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"TypeAliasDeclaration_SerializedIntervalDelta\": {\"backCompat\": false}\n*/\ndeclare function get_current_TypeAliasDeclaration_SerializedIntervalDelta():\n    TypeOnly<current.SerializedIntervalDelta>;\ndeclare function use_old_TypeAliasDeclaration_SerializedIntervalDelta(\n    use: TypeOnly<old.SerializedIntervalDelta>): void;\nuse_old_TypeAliasDeclaration_SerializedIntervalDelta(\n    get_current_TypeAliasDeclaration_SerializedIntervalDelta());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"ClassDeclaration_SharedIntervalCollection\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_ClassDeclaration_SharedIntervalCollection():\n    TypeOnly<old.SharedIntervalCollection>;\ndeclare function use_current_ClassDeclaration_SharedIntervalCollection(\n    use: TypeOnly<current.SharedIntervalCollection>): void;\nuse_current_ClassDeclaration_SharedIntervalCollection(\n    get_old_ClassDeclaration_SharedIntervalCollection());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"ClassDeclaration_SharedIntervalCollection\": {\"backCompat\": false}\n*/\ndeclare function get_current_ClassDeclaration_SharedIntervalCollection():\n    TypeOnly<current.SharedIntervalCollection>;\ndeclare function use_old_ClassDeclaration_SharedIntervalCollection(\n    use: TypeOnly<old.SharedIntervalCollection>): void;\nuse_old_ClassDeclaration_SharedIntervalCollection(\n    get_current_ClassDeclaration_SharedIntervalCollection());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"ClassDeclaration_SharedIntervalCollectionFactory\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_ClassDeclaration_SharedIntervalCollectionFactory():\n    TypeOnly<old.SharedIntervalCollectionFactory>;\ndeclare function use_current_ClassDeclaration_SharedIntervalCollectionFactory(\n    use: TypeOnly<current.SharedIntervalCollectionFactory>): void;\nuse_current_ClassDeclaration_SharedIntervalCollectionFactory(\n    get_old_ClassDeclaration_SharedIntervalCollectionFactory());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"ClassDeclaration_SharedIntervalCollectionFactory\": {\"backCompat\": false}\n*/\ndeclare function get_current_ClassDeclaration_SharedIntervalCollectionFactory():\n    TypeOnly<current.SharedIntervalCollectionFactory>;\ndeclare function use_old_ClassDeclaration_SharedIntervalCollectionFactory(\n    use: TypeOnly<old.SharedIntervalCollectionFactory>): void;\nuse_old_ClassDeclaration_SharedIntervalCollectionFactory(\n    get_current_ClassDeclaration_SharedIntervalCollectionFactory());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"ClassDeclaration_SharedSegmentSequence\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_ClassDeclaration_SharedSegmentSequence():\n    TypeOnly<old.SharedSegmentSequence<any>>;\ndeclare function use_current_ClassDeclaration_SharedSegmentSequence(\n    use: TypeOnly<current.SharedSegmentSequence<any>>): void;\nuse_current_ClassDeclaration_SharedSegmentSequence(\n    get_old_ClassDeclaration_SharedSegmentSequence());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"ClassDeclaration_SharedSegmentSequence\": {\"backCompat\": false}\n*/\ndeclare function get_current_ClassDeclaration_SharedSegmentSequence():\n    TypeOnly<current.SharedSegmentSequence<any>>;\ndeclare function use_old_ClassDeclaration_SharedSegmentSequence(\n    use: TypeOnly<old.SharedSegmentSequence<any>>): void;\nuse_old_ClassDeclaration_SharedSegmentSequence(\n    get_current_ClassDeclaration_SharedSegmentSequence());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"ClassDeclaration_SharedSequence\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_ClassDeclaration_SharedSequence():\n    TypeOnly<old.SharedSequence<any>>;\ndeclare function use_current_ClassDeclaration_SharedSequence(\n    use: TypeOnly<current.SharedSequence<any>>): void;\nuse_current_ClassDeclaration_SharedSequence(\n    get_old_ClassDeclaration_SharedSequence());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"ClassDeclaration_SharedSequence\": {\"backCompat\": false}\n*/\ndeclare function get_current_ClassDeclaration_SharedSequence():\n    TypeOnly<current.SharedSequence<any>>;\ndeclare function use_old_ClassDeclaration_SharedSequence(\n    use: TypeOnly<old.SharedSequence<any>>): void;\nuse_old_ClassDeclaration_SharedSequence(\n    get_current_ClassDeclaration_SharedSequence());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"ClassDeclaration_SharedString\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_ClassDeclaration_SharedString():\n    TypeOnly<old.SharedString>;\ndeclare function use_current_ClassDeclaration_SharedString(\n    use: TypeOnly<current.SharedString>): void;\nuse_current_ClassDeclaration_SharedString(\n    get_old_ClassDeclaration_SharedString());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"ClassDeclaration_SharedString\": {\"backCompat\": false}\n*/\ndeclare function get_current_ClassDeclaration_SharedString():\n    TypeOnly<current.SharedString>;\ndeclare function use_old_ClassDeclaration_SharedString(\n    use: TypeOnly<old.SharedString>): void;\nuse_old_ClassDeclaration_SharedString(\n    // @ts-expect-error compatibility expected to be broken\n    get_current_ClassDeclaration_SharedString());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"ClassDeclaration_SharedStringFactory\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_ClassDeclaration_SharedStringFactory():\n    TypeOnly<old.SharedStringFactory>;\ndeclare function use_current_ClassDeclaration_SharedStringFactory(\n    use: TypeOnly<current.SharedStringFactory>): void;\nuse_current_ClassDeclaration_SharedStringFactory(\n    get_old_ClassDeclaration_SharedStringFactory());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"ClassDeclaration_SharedStringFactory\": {\"backCompat\": false}\n*/\ndeclare function get_current_ClassDeclaration_SharedStringFactory():\n    TypeOnly<current.SharedStringFactory>;\ndeclare function use_old_ClassDeclaration_SharedStringFactory(\n    use: TypeOnly<old.SharedStringFactory>): void;\nuse_old_ClassDeclaration_SharedStringFactory(\n    get_current_ClassDeclaration_SharedStringFactory());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"TypeAliasDeclaration_SharedStringRevertible\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_TypeAliasDeclaration_SharedStringRevertible():\n    TypeOnly<old.SharedStringRevertible>;\ndeclare function use_current_TypeAliasDeclaration_SharedStringRevertible(\n    use: TypeOnly<current.SharedStringRevertible>): void;\nuse_current_TypeAliasDeclaration_SharedStringRevertible(\n    get_old_TypeAliasDeclaration_SharedStringRevertible());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"TypeAliasDeclaration_SharedStringRevertible\": {\"backCompat\": false}\n*/\ndeclare function get_current_TypeAliasDeclaration_SharedStringRevertible():\n    TypeOnly<current.SharedStringRevertible>;\ndeclare function use_old_TypeAliasDeclaration_SharedStringRevertible(\n    use: TypeOnly<old.SharedStringRevertible>): void;\nuse_old_TypeAliasDeclaration_SharedStringRevertible(\n    get_current_TypeAliasDeclaration_SharedStringRevertible());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"TypeAliasDeclaration_SharedStringSegment\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_TypeAliasDeclaration_SharedStringSegment():\n    TypeOnly<old.SharedStringSegment>;\ndeclare function use_current_TypeAliasDeclaration_SharedStringSegment(\n    use: TypeOnly<current.SharedStringSegment>): void;\nuse_current_TypeAliasDeclaration_SharedStringSegment(\n    get_old_TypeAliasDeclaration_SharedStringSegment());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"TypeAliasDeclaration_SharedStringSegment\": {\"backCompat\": false}\n*/\ndeclare function get_current_TypeAliasDeclaration_SharedStringSegment():\n    TypeOnly<current.SharedStringSegment>;\ndeclare function use_old_TypeAliasDeclaration_SharedStringSegment(\n    use: TypeOnly<old.SharedStringSegment>): void;\nuse_old_TypeAliasDeclaration_SharedStringSegment(\n    get_current_TypeAliasDeclaration_SharedStringSegment());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"EnumDeclaration_Side\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_EnumDeclaration_Side():\n    TypeOnly<old.Side>;\ndeclare function use_current_EnumDeclaration_Side(\n    use: TypeOnly<current.Side>): void;\nuse_current_EnumDeclaration_Side(\n    get_old_EnumDeclaration_Side());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"EnumDeclaration_Side\": {\"backCompat\": false}\n*/\ndeclare function get_current_EnumDeclaration_Side():\n    TypeOnly<current.Side>;\ndeclare function use_old_EnumDeclaration_Side(\n    use: TypeOnly<old.Side>): void;\nuse_old_EnumDeclaration_Side(\n    get_current_EnumDeclaration_Side());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"ClassDeclaration_SubSequence\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_ClassDeclaration_SubSequence():\n    TypeOnly<old.SubSequence<any>>;\ndeclare function use_current_ClassDeclaration_SubSequence(\n    use: TypeOnly<current.SubSequence<any>>): void;\nuse_current_ClassDeclaration_SubSequence(\n    get_old_ClassDeclaration_SubSequence());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"ClassDeclaration_SubSequence\": {\"backCompat\": false}\n*/\ndeclare function get_current_ClassDeclaration_SubSequence():\n    TypeOnly<current.SubSequence<any>>;\ndeclare function use_old_ClassDeclaration_SubSequence(\n    use: TypeOnly<old.SubSequence<any>>): void;\nuse_old_ClassDeclaration_SubSequence(\n    get_current_ClassDeclaration_SubSequence());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"ClassDeclaration_TextSegment\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_ClassDeclaration_TextSegment():\n    TypeOnly<old.TextSegment>;\ndeclare function use_current_ClassDeclaration_TextSegment(\n    use: TypeOnly<current.TextSegment>): void;\nuse_current_ClassDeclaration_TextSegment(\n    get_old_ClassDeclaration_TextSegment());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"ClassDeclaration_TextSegment\": {\"backCompat\": false}\n*/\ndeclare function get_current_ClassDeclaration_TextSegment():\n    TypeOnly<current.TextSegment>;\ndeclare function use_old_ClassDeclaration_TextSegment(\n    use: TypeOnly<old.TextSegment>): void;\nuse_old_ClassDeclaration_TextSegment(\n    get_current_ClassDeclaration_TextSegment());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"ClassDeclaration_TrackingGroup\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_ClassDeclaration_TrackingGroup():\n    TypeOnly<old.TrackingGroup>;\ndeclare function use_current_ClassDeclaration_TrackingGroup(\n    use: TypeOnly<current.TrackingGroup>): void;\nuse_current_ClassDeclaration_TrackingGroup(\n    get_old_ClassDeclaration_TrackingGroup());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"ClassDeclaration_TrackingGroup\": {\"backCompat\": false}\n*/\ndeclare function get_current_ClassDeclaration_TrackingGroup():\n    TypeOnly<current.TrackingGroup>;\ndeclare function use_old_ClassDeclaration_TrackingGroup(\n    use: TypeOnly<old.TrackingGroup>): void;\nuse_old_ClassDeclaration_TrackingGroup(\n    get_current_ClassDeclaration_TrackingGroup());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"FunctionDeclaration_appendAddIntervalToRevertibles\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_FunctionDeclaration_appendAddIntervalToRevertibles():\n    TypeOnly<typeof old.appendAddIntervalToRevertibles>;\ndeclare function use_current_FunctionDeclaration_appendAddIntervalToRevertibles(\n    use: TypeOnly<typeof current.appendAddIntervalToRevertibles>): void;\nuse_current_FunctionDeclaration_appendAddIntervalToRevertibles(\n    get_old_FunctionDeclaration_appendAddIntervalToRevertibles());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"FunctionDeclaration_appendAddIntervalToRevertibles\": {\"backCompat\": false}\n*/\ndeclare function get_current_FunctionDeclaration_appendAddIntervalToRevertibles():\n    TypeOnly<typeof current.appendAddIntervalToRevertibles>;\ndeclare function use_old_FunctionDeclaration_appendAddIntervalToRevertibles(\n    use: TypeOnly<typeof old.appendAddIntervalToRevertibles>): void;\nuse_old_FunctionDeclaration_appendAddIntervalToRevertibles(\n    get_current_FunctionDeclaration_appendAddIntervalToRevertibles());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"FunctionDeclaration_appendChangeIntervalToRevertibles\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_FunctionDeclaration_appendChangeIntervalToRevertibles():\n    TypeOnly<typeof old.appendChangeIntervalToRevertibles>;\ndeclare function use_current_FunctionDeclaration_appendChangeIntervalToRevertibles(\n    use: TypeOnly<typeof current.appendChangeIntervalToRevertibles>): void;\nuse_current_FunctionDeclaration_appendChangeIntervalToRevertibles(\n    get_old_FunctionDeclaration_appendChangeIntervalToRevertibles());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"FunctionDeclaration_appendChangeIntervalToRevertibles\": {\"backCompat\": false}\n*/\ndeclare function get_current_FunctionDeclaration_appendChangeIntervalToRevertibles():\n    TypeOnly<typeof current.appendChangeIntervalToRevertibles>;\ndeclare function use_old_FunctionDeclaration_appendChangeIntervalToRevertibles(\n    use: TypeOnly<typeof old.appendChangeIntervalToRevertibles>): void;\nuse_old_FunctionDeclaration_appendChangeIntervalToRevertibles(\n    get_current_FunctionDeclaration_appendChangeIntervalToRevertibles());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"FunctionDeclaration_appendDeleteIntervalToRevertibles\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_FunctionDeclaration_appendDeleteIntervalToRevertibles():\n    TypeOnly<typeof old.appendDeleteIntervalToRevertibles>;\ndeclare function use_current_FunctionDeclaration_appendDeleteIntervalToRevertibles(\n    use: TypeOnly<typeof current.appendDeleteIntervalToRevertibles>): void;\nuse_current_FunctionDeclaration_appendDeleteIntervalToRevertibles(\n    get_old_FunctionDeclaration_appendDeleteIntervalToRevertibles());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"FunctionDeclaration_appendDeleteIntervalToRevertibles\": {\"backCompat\": false}\n*/\ndeclare function get_current_FunctionDeclaration_appendDeleteIntervalToRevertibles():\n    TypeOnly<typeof current.appendDeleteIntervalToRevertibles>;\ndeclare function use_old_FunctionDeclaration_appendDeleteIntervalToRevertibles(\n    use: TypeOnly<typeof old.appendDeleteIntervalToRevertibles>): void;\nuse_old_FunctionDeclaration_appendDeleteIntervalToRevertibles(\n    get_current_FunctionDeclaration_appendDeleteIntervalToRevertibles());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"FunctionDeclaration_appendIntervalPropertyChangedToRevertibles\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_FunctionDeclaration_appendIntervalPropertyChangedToRevertibles():\n    TypeOnly<typeof old.appendIntervalPropertyChangedToRevertibles>;\ndeclare function use_current_FunctionDeclaration_appendIntervalPropertyChangedToRevertibles(\n    use: TypeOnly<typeof current.appendIntervalPropertyChangedToRevertibles>): void;\nuse_current_FunctionDeclaration_appendIntervalPropertyChangedToRevertibles(\n    get_old_FunctionDeclaration_appendIntervalPropertyChangedToRevertibles());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"FunctionDeclaration_appendIntervalPropertyChangedToRevertibles\": {\"backCompat\": false}\n*/\ndeclare function get_current_FunctionDeclaration_appendIntervalPropertyChangedToRevertibles():\n    TypeOnly<typeof current.appendIntervalPropertyChangedToRevertibles>;\ndeclare function use_old_FunctionDeclaration_appendIntervalPropertyChangedToRevertibles(\n    use: TypeOnly<typeof old.appendIntervalPropertyChangedToRevertibles>): void;\nuse_old_FunctionDeclaration_appendIntervalPropertyChangedToRevertibles(\n    get_current_FunctionDeclaration_appendIntervalPropertyChangedToRevertibles());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"FunctionDeclaration_appendSharedStringDeltaToRevertibles\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_FunctionDeclaration_appendSharedStringDeltaToRevertibles():\n    TypeOnly<typeof old.appendSharedStringDeltaToRevertibles>;\ndeclare function use_current_FunctionDeclaration_appendSharedStringDeltaToRevertibles(\n    use: TypeOnly<typeof current.appendSharedStringDeltaToRevertibles>): void;\nuse_current_FunctionDeclaration_appendSharedStringDeltaToRevertibles(\n    get_old_FunctionDeclaration_appendSharedStringDeltaToRevertibles());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"FunctionDeclaration_appendSharedStringDeltaToRevertibles\": {\"backCompat\": false}\n*/\ndeclare function get_current_FunctionDeclaration_appendSharedStringDeltaToRevertibles():\n    TypeOnly<typeof current.appendSharedStringDeltaToRevertibles>;\ndeclare function use_old_FunctionDeclaration_appendSharedStringDeltaToRevertibles(\n    use: TypeOnly<typeof old.appendSharedStringDeltaToRevertibles>): void;\nuse_old_FunctionDeclaration_appendSharedStringDeltaToRevertibles(\n    get_current_FunctionDeclaration_appendSharedStringDeltaToRevertibles());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"FunctionDeclaration_createEndpointInRangeIndex\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_FunctionDeclaration_createEndpointInRangeIndex():\n    TypeOnly<typeof old.createEndpointInRangeIndex>;\ndeclare function use_current_FunctionDeclaration_createEndpointInRangeIndex(\n    use: TypeOnly<typeof current.createEndpointInRangeIndex>): void;\nuse_current_FunctionDeclaration_createEndpointInRangeIndex(\n    get_old_FunctionDeclaration_createEndpointInRangeIndex());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"FunctionDeclaration_createEndpointInRangeIndex\": {\"backCompat\": false}\n*/\ndeclare function get_current_FunctionDeclaration_createEndpointInRangeIndex():\n    TypeOnly<typeof current.createEndpointInRangeIndex>;\ndeclare function use_old_FunctionDeclaration_createEndpointInRangeIndex(\n    use: TypeOnly<typeof old.createEndpointInRangeIndex>): void;\nuse_old_FunctionDeclaration_createEndpointInRangeIndex(\n    get_current_FunctionDeclaration_createEndpointInRangeIndex());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"FunctionDeclaration_createEndpointIndex\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_FunctionDeclaration_createEndpointIndex():\n    TypeOnly<typeof old.createEndpointIndex>;\ndeclare function use_current_FunctionDeclaration_createEndpointIndex(\n    use: TypeOnly<typeof current.createEndpointIndex>): void;\nuse_current_FunctionDeclaration_createEndpointIndex(\n    get_old_FunctionDeclaration_createEndpointIndex());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"FunctionDeclaration_createEndpointIndex\": {\"backCompat\": false}\n*/\ndeclare function get_current_FunctionDeclaration_createEndpointIndex():\n    TypeOnly<typeof current.createEndpointIndex>;\ndeclare function use_old_FunctionDeclaration_createEndpointIndex(\n    use: TypeOnly<typeof old.createEndpointIndex>): void;\nuse_old_FunctionDeclaration_createEndpointIndex(\n    get_current_FunctionDeclaration_createEndpointIndex());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"FunctionDeclaration_createIdIntervalIndex\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_FunctionDeclaration_createIdIntervalIndex():\n    TypeOnly<typeof old.createIdIntervalIndex>;\ndeclare function use_current_FunctionDeclaration_createIdIntervalIndex(\n    use: TypeOnly<typeof current.createIdIntervalIndex>): void;\nuse_current_FunctionDeclaration_createIdIntervalIndex(\n    get_old_FunctionDeclaration_createIdIntervalIndex());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"FunctionDeclaration_createIdIntervalIndex\": {\"backCompat\": false}\n*/\ndeclare function get_current_FunctionDeclaration_createIdIntervalIndex():\n    TypeOnly<typeof current.createIdIntervalIndex>;\ndeclare function use_old_FunctionDeclaration_createIdIntervalIndex(\n    use: TypeOnly<typeof old.createIdIntervalIndex>): void;\nuse_old_FunctionDeclaration_createIdIntervalIndex(\n    get_current_FunctionDeclaration_createIdIntervalIndex());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"FunctionDeclaration_createOverlappingIntervalsIndex\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_FunctionDeclaration_createOverlappingIntervalsIndex():\n    TypeOnly<typeof old.createOverlappingIntervalsIndex>;\ndeclare function use_current_FunctionDeclaration_createOverlappingIntervalsIndex(\n    use: TypeOnly<typeof current.createOverlappingIntervalsIndex>): void;\nuse_current_FunctionDeclaration_createOverlappingIntervalsIndex(\n    get_old_FunctionDeclaration_createOverlappingIntervalsIndex());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"FunctionDeclaration_createOverlappingIntervalsIndex\": {\"backCompat\": false}\n*/\ndeclare function get_current_FunctionDeclaration_createOverlappingIntervalsIndex():\n    TypeOnly<typeof current.createOverlappingIntervalsIndex>;\ndeclare function use_old_FunctionDeclaration_createOverlappingIntervalsIndex(\n    use: TypeOnly<typeof old.createOverlappingIntervalsIndex>): void;\nuse_old_FunctionDeclaration_createOverlappingIntervalsIndex(\n    get_current_FunctionDeclaration_createOverlappingIntervalsIndex());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"FunctionDeclaration_createOverlappingSequenceIntervalsIndex\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_FunctionDeclaration_createOverlappingSequenceIntervalsIndex():\n    TypeOnly<typeof old.createOverlappingSequenceIntervalsIndex>;\ndeclare function use_current_FunctionDeclaration_createOverlappingSequenceIntervalsIndex(\n    use: TypeOnly<typeof current.createOverlappingSequenceIntervalsIndex>): void;\nuse_current_FunctionDeclaration_createOverlappingSequenceIntervalsIndex(\n    get_old_FunctionDeclaration_createOverlappingSequenceIntervalsIndex());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"FunctionDeclaration_createOverlappingSequenceIntervalsIndex\": {\"backCompat\": false}\n*/\ndeclare function get_current_FunctionDeclaration_createOverlappingSequenceIntervalsIndex():\n    TypeOnly<typeof current.createOverlappingSequenceIntervalsIndex>;\ndeclare function use_old_FunctionDeclaration_createOverlappingSequenceIntervalsIndex(\n    use: TypeOnly<typeof old.createOverlappingSequenceIntervalsIndex>): void;\nuse_old_FunctionDeclaration_createOverlappingSequenceIntervalsIndex(\n    get_current_FunctionDeclaration_createOverlappingSequenceIntervalsIndex());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"FunctionDeclaration_createStartpointInRangeIndex\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_FunctionDeclaration_createStartpointInRangeIndex():\n    TypeOnly<typeof old.createStartpointInRangeIndex>;\ndeclare function use_current_FunctionDeclaration_createStartpointInRangeIndex(\n    use: TypeOnly<typeof current.createStartpointInRangeIndex>): void;\nuse_current_FunctionDeclaration_createStartpointInRangeIndex(\n    get_old_FunctionDeclaration_createStartpointInRangeIndex());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"FunctionDeclaration_createStartpointInRangeIndex\": {\"backCompat\": false}\n*/\ndeclare function get_current_FunctionDeclaration_createStartpointInRangeIndex():\n    TypeOnly<typeof current.createStartpointInRangeIndex>;\ndeclare function use_old_FunctionDeclaration_createStartpointInRangeIndex(\n    use: TypeOnly<typeof old.createStartpointInRangeIndex>): void;\nuse_old_FunctionDeclaration_createStartpointInRangeIndex(\n    get_current_FunctionDeclaration_createStartpointInRangeIndex());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"FunctionDeclaration_discardSharedStringRevertibles\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_FunctionDeclaration_discardSharedStringRevertibles():\n    TypeOnly<typeof old.discardSharedStringRevertibles>;\ndeclare function use_current_FunctionDeclaration_discardSharedStringRevertibles(\n    use: TypeOnly<typeof current.discardSharedStringRevertibles>): void;\nuse_current_FunctionDeclaration_discardSharedStringRevertibles(\n    get_old_FunctionDeclaration_discardSharedStringRevertibles());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"FunctionDeclaration_discardSharedStringRevertibles\": {\"backCompat\": false}\n*/\ndeclare function get_current_FunctionDeclaration_discardSharedStringRevertibles():\n    TypeOnly<typeof current.discardSharedStringRevertibles>;\ndeclare function use_old_FunctionDeclaration_discardSharedStringRevertibles(\n    use: TypeOnly<typeof old.discardSharedStringRevertibles>): void;\nuse_old_FunctionDeclaration_discardSharedStringRevertibles(\n    get_current_FunctionDeclaration_discardSharedStringRevertibles());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"FunctionDeclaration_getTextAndMarkers\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_FunctionDeclaration_getTextAndMarkers():\n    TypeOnly<typeof old.getTextAndMarkers>;\ndeclare function use_current_FunctionDeclaration_getTextAndMarkers(\n    use: TypeOnly<typeof current.getTextAndMarkers>): void;\nuse_current_FunctionDeclaration_getTextAndMarkers(\n    get_old_FunctionDeclaration_getTextAndMarkers());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"FunctionDeclaration_getTextAndMarkers\": {\"backCompat\": false}\n*/\ndeclare function get_current_FunctionDeclaration_getTextAndMarkers():\n    TypeOnly<typeof current.getTextAndMarkers>;\ndeclare function use_old_FunctionDeclaration_getTextAndMarkers(\n    use: TypeOnly<typeof old.getTextAndMarkers>): void;\nuse_old_FunctionDeclaration_getTextAndMarkers(\n    get_current_FunctionDeclaration_getTextAndMarkers());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"FunctionDeclaration_intervalLocatorFromEndpoint\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_FunctionDeclaration_intervalLocatorFromEndpoint():\n    TypeOnly<typeof old.intervalLocatorFromEndpoint>;\ndeclare function use_current_FunctionDeclaration_intervalLocatorFromEndpoint(\n    use: TypeOnly<typeof current.intervalLocatorFromEndpoint>): void;\nuse_current_FunctionDeclaration_intervalLocatorFromEndpoint(\n    get_old_FunctionDeclaration_intervalLocatorFromEndpoint());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"FunctionDeclaration_intervalLocatorFromEndpoint\": {\"backCompat\": false}\n*/\ndeclare function get_current_FunctionDeclaration_intervalLocatorFromEndpoint():\n    TypeOnly<typeof current.intervalLocatorFromEndpoint>;\ndeclare function use_old_FunctionDeclaration_intervalLocatorFromEndpoint(\n    use: TypeOnly<typeof old.intervalLocatorFromEndpoint>): void;\nuse_old_FunctionDeclaration_intervalLocatorFromEndpoint(\n    get_current_FunctionDeclaration_intervalLocatorFromEndpoint());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"VariableDeclaration_reservedMarkerIdKey\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_VariableDeclaration_reservedMarkerIdKey():\n    TypeOnly<typeof old.reservedMarkerIdKey>;\ndeclare function use_current_VariableDeclaration_reservedMarkerIdKey(\n    use: TypeOnly<typeof current.reservedMarkerIdKey>): void;\nuse_current_VariableDeclaration_reservedMarkerIdKey(\n    get_old_VariableDeclaration_reservedMarkerIdKey());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"VariableDeclaration_reservedMarkerIdKey\": {\"backCompat\": false}\n*/\ndeclare function get_current_VariableDeclaration_reservedMarkerIdKey():\n    TypeOnly<typeof current.reservedMarkerIdKey>;\ndeclare function use_old_VariableDeclaration_reservedMarkerIdKey(\n    use: TypeOnly<typeof old.reservedMarkerIdKey>): void;\nuse_old_VariableDeclaration_reservedMarkerIdKey(\n    get_current_VariableDeclaration_reservedMarkerIdKey());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"VariableDeclaration_reservedRangeLabelsKey\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_VariableDeclaration_reservedRangeLabelsKey():\n    TypeOnly<typeof old.reservedRangeLabelsKey>;\ndeclare function use_current_VariableDeclaration_reservedRangeLabelsKey(\n    use: TypeOnly<typeof current.reservedRangeLabelsKey>): void;\nuse_current_VariableDeclaration_reservedRangeLabelsKey(\n    get_old_VariableDeclaration_reservedRangeLabelsKey());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"VariableDeclaration_reservedRangeLabelsKey\": {\"backCompat\": false}\n*/\ndeclare function get_current_VariableDeclaration_reservedRangeLabelsKey():\n    TypeOnly<typeof current.reservedRangeLabelsKey>;\ndeclare function use_old_VariableDeclaration_reservedRangeLabelsKey(\n    use: TypeOnly<typeof old.reservedRangeLabelsKey>): void;\nuse_old_VariableDeclaration_reservedRangeLabelsKey(\n    get_current_VariableDeclaration_reservedRangeLabelsKey());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"VariableDeclaration_reservedTileLabelsKey\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_VariableDeclaration_reservedTileLabelsKey():\n    TypeOnly<typeof old.reservedTileLabelsKey>;\ndeclare function use_current_VariableDeclaration_reservedTileLabelsKey(\n    use: TypeOnly<typeof current.reservedTileLabelsKey>): void;\nuse_current_VariableDeclaration_reservedTileLabelsKey(\n    get_old_VariableDeclaration_reservedTileLabelsKey());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"VariableDeclaration_reservedTileLabelsKey\": {\"backCompat\": false}\n*/\ndeclare function get_current_VariableDeclaration_reservedTileLabelsKey():\n    TypeOnly<typeof current.reservedTileLabelsKey>;\ndeclare function use_old_VariableDeclaration_reservedTileLabelsKey(\n    use: TypeOnly<typeof old.reservedTileLabelsKey>): void;\nuse_old_VariableDeclaration_reservedTileLabelsKey(\n    get_current_VariableDeclaration_reservedTileLabelsKey());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"FunctionDeclaration_revertSharedStringRevertibles\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_FunctionDeclaration_revertSharedStringRevertibles():\n    TypeOnly<typeof old.revertSharedStringRevertibles>;\ndeclare function use_current_FunctionDeclaration_revertSharedStringRevertibles(\n    use: TypeOnly<typeof current.revertSharedStringRevertibles>): void;\nuse_current_FunctionDeclaration_revertSharedStringRevertibles(\n    get_old_FunctionDeclaration_revertSharedStringRevertibles());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"FunctionDeclaration_revertSharedStringRevertibles\": {\"backCompat\": false}\n*/\ndeclare function get_current_FunctionDeclaration_revertSharedStringRevertibles():\n    TypeOnly<typeof current.revertSharedStringRevertibles>;\ndeclare function use_old_FunctionDeclaration_revertSharedStringRevertibles(\n    use: TypeOnly<typeof old.revertSharedStringRevertibles>): void;\nuse_old_FunctionDeclaration_revertSharedStringRevertibles(\n    get_current_FunctionDeclaration_revertSharedStringRevertibles());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"VariableDeclaration_sequenceIntervalHelpers\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_VariableDeclaration_sequenceIntervalHelpers():\n    TypeOnly<typeof old.sequenceIntervalHelpers>;\ndeclare function use_current_VariableDeclaration_sequenceIntervalHelpers(\n    use: TypeOnly<typeof current.sequenceIntervalHelpers>): void;\nuse_current_VariableDeclaration_sequenceIntervalHelpers(\n    get_old_VariableDeclaration_sequenceIntervalHelpers());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"VariableDeclaration_sequenceIntervalHelpers\": {\"backCompat\": false}\n*/\ndeclare function get_current_VariableDeclaration_sequenceIntervalHelpers():\n    TypeOnly<typeof current.sequenceIntervalHelpers>;\ndeclare function use_old_VariableDeclaration_sequenceIntervalHelpers(\n    use: TypeOnly<typeof old.sequenceIntervalHelpers>): void;\nuse_old_VariableDeclaration_sequenceIntervalHelpers(\n    get_current_VariableDeclaration_sequenceIntervalHelpers());\n"]}

package/lib/test/v1IntervalCollectionHelpers.js

@@ -0,0 +1,93 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { DefaultMap } from "../defaultMap.js";
+import { IntervalCollection, makeOpsMap, } from "../intervalCollection.js";
+import { createSequenceInterval, } from "../intervals/index.js";
+import { pkgVersion } from "../packageVersion.js";
+import { SharedString } from "../sharedString.js";
+export class V1IntervalCollection extends IntervalCollection {
+    constructor() {
+        super(...arguments);
+        this.casted = this;
+    }
+}
+class V1SequenceIntervalCollectionFactory {
+    load(emitter, raw = []) {
+        const helpers = {
+            create: createSequenceInterval,
+        };
+        return new V1IntervalCollection(helpers, true, emitter, raw, {});
+    }
+    store(value) {
+        return Array.from(value, (interval) => interval?.serialize());
+    }
+}
+export class V1SequenceIntervalCollectionValueType {
+    get name() {
+        return V1SequenceIntervalCollectionValueType.Name;
+    }
+    get factory() {
+        return V1SequenceIntervalCollectionValueType._factory;
+    }
+    get ops() {
+        return V1SequenceIntervalCollectionValueType._ops;
+    }
+}
+V1SequenceIntervalCollectionValueType.Name = "sharedStringIntervalCollection";
+V1SequenceIntervalCollectionValueType._factory = new V1SequenceIntervalCollectionFactory();
+V1SequenceIntervalCollectionValueType._ops = makeOpsMap();
+export class SharedStringWithV1IntervalCollection extends SharedString {
+    /**
+     * 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, id) {
+        return runtime.createChannel(id, V1IntervalCollectionSharedStringFactory.Type);
+    }
+    /**
+     * Get a factory for SharedString to register with the data store.
+     * @returns a factory that creates and load SharedString
+     */
+    static getFactory() {
+        return new V1IntervalCollectionSharedStringFactory();
+    }
+    constructor(document, id, attributes) {
+        super(document, id, attributes);
+        this.id = id;
+        this.intervalCollections = new DefaultMap(this.serializer, this.handle, (op, localOpMetadata) => this.submitLocalMessage(op, localOpMetadata), new V1SequenceIntervalCollectionValueType(), {});
+    }
+}
+export class V1IntervalCollectionSharedStringFactory {
+    get type() {
+        return V1IntervalCollectionSharedStringFactory.Type;
+    }
+    get attributes() {
+        return V1IntervalCollectionSharedStringFactory.Attributes;
+    }
+    /**
+     * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory.load}
+     */
+    async load(runtime, id, services, attributes) {
+        const sharedString = new SharedStringWithV1IntervalCollection(runtime, id, attributes);
+        await sharedString.load(services);
+        return sharedString;
+    }
+    create(document, id) {
+        const sharedString = new SharedStringWithV1IntervalCollection(document, id, this.attributes);
+        sharedString.initializeLocal();
+        return sharedString;
+    }
+}
+// TODO rename back to https://graph.microsoft.com/types/mergeTree/string once paparazzi is able to dynamically
+// load code (UPDATE: paparazzi is gone... anything to do here?)
+V1IntervalCollectionSharedStringFactory.Type = "https://graph.microsoft.com/types/mergeTree";
+V1IntervalCollectionSharedStringFactory.Attributes = {
+    type: V1IntervalCollectionSharedStringFactory.Type,
+    snapshotFormatVersion: "0.1",
+    packageVersion: pkgVersion,
+};
+//# sourceMappingURL=v1IntervalCollectionHelpers.js.map