fluid-framework 2.0.0-dev-rc.3.0.0.254513 → 2.0.0-dev-rc.3.0.0.254674

package/dist/fluid-framework-alpha.d.ts

@@ -1,2326 +0,0 @@
-/**
- * Bundles a collection of Fluid Framework client libraries for easy use when paired with a corresponding service client
- * package (e.g. `@fluidframework/azure-client`, `@fluidframework/tinylicious-client`, or `@fluid-experimental/osdp-client (BETA)`).
- *
- * @packageDocumentation
- */
-
-import { FluidObject } from '@fluidframework/core-interfaces';
-import { IChannel } from '@fluidframework/datastore-definitions';
-import type { IErrorBase } from '@fluidframework/core-interfaces';
-import { IEvent } from '@fluidframework/core-interfaces';
-import { IEventProvider } from '@fluidframework/core-interfaces';
-import { IEventThisPlaceHolder } from '@fluidframework/core-interfaces';
-import { IFluidHandle } from '@fluidframework/core-interfaces';
-import { IFluidLoadable } from '@fluidframework/core-interfaces';
-import { ISharedObject } from '@fluidframework/shared-object-base';
-import { ISharedObjectEvents } from '@fluidframework/shared-object-base';
-import { ISharedObjectKind } from '@fluidframework/shared-object-base';
-
-/**
- * Types for use in fields.
- * @public
- */
-export declare type AllowedTypes = readonly LazyItem<TreeNodeSchema>[];
-
-/**
- * Suitable for output.
- * For input must error on side of excluding undefined instead.
- * @public
- */
-export declare type ApplyKind<T, Kind extends FieldKind> = Kind extends FieldKind.Required ? T : undefined | T;
-
-/**
- * The attachment state of some Fluid data (e.g. a container or data store), denoting whether it is uploaded to the
- * service.  The transition from detached to attached state is a one-way transition.
- * @public
- */
-export declare enum AttachState {
-    /**
-     * In detached state, the data is only present on the local client's machine.  It has not yet been uploaded
-     * to the service.
-     */
-    Detached = "Detached",
-    /**
-     * In attaching state, the data has started the upload to the service, but has not yet completed.
-     */
-    Attaching = "Attaching",
-    /**
-     * In attached state, the data has completed upload to the service.  It can be accessed by other clients after
-     * reaching attached state.
-     */
-    Attached = "Attached"
-}
-
-/**
- * The type of a commit. This is used to describe the context in which the commit was created.
- *
- * @public
- */
-export declare enum CommitKind {
-    /** A commit corresponding to a change that is not the result of an undo/redo. */
-    Default = 0,
-    /** A commit that is the result of an undo. */
-    Undo = 1,
-    /** A commit that is the result of a redo. */
-    Redo = 2
-}
-
-/**
- * Information about a commit that has been applied.
- *
- * @public
- */
-export declare interface CommitMetadata {
-    /**
-     * A {@link CommitKind} enum value describing whether the commit represents an Edit, an Undo, or a Redo.
-     */
-    readonly kind: CommitKind;
-    /**
-     * Indicates whether the commit is a local edit
-     */
-    readonly isLocal: boolean;
-}
-
-/**
- * The state of the Container's connection to the service.
- * @public
- */
-export declare enum ConnectionState {
-    /**
-     * The container is not connected to the ordering service
-     * Note - When in this state the container may be about to reconnect,
-     * or may remain disconnected until explicitly told to connect.
-     */
-    Disconnected = 0,
-    /**
-     * The container is disconnected but actively trying to establish a new connection
-     * PLEASE NOTE that this numerical value falls out of the order you may expect for this state
-     */
-    EstablishingConnection = 3,
-    /**
-     * The container has an inbound connection only, and is catching up to the latest known state from the service.
-     */
-    CatchingUp = 1,
-    /**
-     * The container is fully connected and syncing
-     */
-    Connected = 2
-}
-
-/**
- * Namespace for the different connection states a container can be in.
- * PLEASE NOTE: The sequence of the numerical values does no correspond to the typical connection state progression.
- * @public
- */
-export declare namespace ConnectionStateType {
-    /**
-     * The container is not connected to the delta server.
-     * Note - When in this state the container may be about to reconnect,
-     * or may remain disconnected until explicitly told to connect.
-     * @public
-     */
-    export type Disconnected = 0;
-    /**
-     * The container is disconnected but actively trying to establish a new connection.
-     * PLEASE NOTE that this numerical value falls out of the order you may expect for this state.
-     * @public
-     */
-    export type EstablishingConnection = 3;
-    /**
-     * The container has an inbound connection only, and is catching up to the latest known state from the service.
-     * @public
-     */
-    export type CatchingUp = 1;
-    /**
-     * The container is fully connected and syncing.
-     * @public
-     */
-    export type Connected = 2;
-}
-
-/**
- * Type defining the different states of connectivity a Container can be in.
- * @public
- */
-export declare type ConnectionStateType = ConnectionStateType.Disconnected | ConnectionStateType.EstablishingConnection | ConnectionStateType.CatchingUp | ConnectionStateType.Connected;
-
-/**
- * Represents properties that can be attached to a container.
- * @public
- */
-export declare type ContainerAttachProps<T = unknown> = T;
-
-/**
- * Different error types the ClientSession may report out to the Host.
- * @alpha
- */
-export declare const ContainerErrorTypes: {
-    /**
-     * Error indicating an client session has expired. Currently this only happens when GC is allowed on a document and
-     * aids in safely deleting unused objects.
-     */
-    readonly clientSessionExpiredError: "clientSessionExpiredError";
-    readonly genericError: "genericError";
-    readonly throttlingError: "throttlingError";
-    readonly dataCorruptionError: "dataCorruptionError";
-    readonly dataProcessingError: "dataProcessingError";
-    readonly usageError: "usageError";
-};
-
-/**
- * {@inheritDoc (ContainerErrorTypes:variable)}
- * @alpha
- */
-export declare type ContainerErrorTypes = (typeof ContainerErrorTypes)[keyof typeof ContainerErrorTypes];
-
-/**
- * Declares the Fluid objects that will be available in the {@link IFluidContainer | Container}.
- *
- * @remarks
- *
- * It includes both the instances of objects that are initially available upon `Container` creation, as well
- * as the types of objects that may be dynamically created throughout the lifetime of the `Container`.
- * @public
- */
-export declare interface ContainerSchema {
-    /**
-     * Defines loadable objects that will be created when the {@link IFluidContainer | Container} is first created.
-     *
-     * @remarks It uses the key as the id and the value as the loadable object to create.
-     *
-     * @example
-     *
-     * In the example below two objects will be created when the `Container` is first
-     * created. One with id "map1" that will return a `SharedMap` and the other with
-     * id "pair1" that will return a `KeyValueDataObject`.
-     *
-     * ```typescript
-     * {
-     *   map1: SharedMap,
-     *   pair1: KeyValueDataObject,
-     * }
-     * ```
-     */
-    readonly initialObjects: LoadableObjectClassRecord;
-    /**
-     * Loadable objects that can be created after the initial {@link IFluidContainer | Container} creation.
-     *
-     * @remarks
-     *
-     * Types defined in `initialObjects` will always be available and are not required to be provided here.
-     *
-     * For best practice it's recommended to define all the dynamic types you create even if they are
-     * included via initialObjects.
-     */
-    readonly dynamicObjectTypes?: readonly LoadableObjectClass[];
-}
-
-/**
- * A class that has a factory that can create a `DataObject` and a
- * constructor that will return the type of the `DataObject`.
- *
- * @typeParam T - The class of the `DataObject`.
- * @privateRemarks
- * Having both `factory` and `LoadableObjectCtor` is redundant, and having `factory` not actually work as a factory is also strange.
- * This may need some refinement.
- * @public
- */
-export declare type DataObjectClass<T extends IFluidLoadable = IFluidLoadable> = {
-    readonly factory: {
-        readonly IFluidDataStoreFactory: DataObjectClass<T>["factory"];
-    };
-} & (new (...args: any[]) => T);
-
-/**
- * Placeholder for `Symbol.dispose`.
- *
- * Replace this with `Symbol.dispose` when it is available.
- * @public
- */
-export declare const disposeSymbol: unique symbol;
-
-/**
- * Different error types the Driver may report out to the Host.
- * @public
- */
-export declare const DriverErrorTypes: {
-    /**
-     * Some non-categorized (below) networking error
-     * Include errors like  fatal server error (usually 500).
-     */
-    readonly genericNetworkError: "genericNetworkError";
-    /**
-     * Access denied - user does not have enough privileges to open a file, or continue to operate on a file
-     */
-    readonly authorizationError: "authorizationError";
-    /**
-     * File not found, or file deleted during session
-     */
-    readonly fileNotFoundOrAccessDeniedError: "fileNotFoundOrAccessDeniedError";
-    /**
-     * We can not reach server due to computer being offline.
-     */
-    readonly offlineError: "offlineError";
-    readonly unsupportedClientProtocolVersion: "unsupportedClientProtocolVersion";
-    /**
-     * User does not have write permissions to a file, but is changing content of a file.
-     * That might be indication of some data store error - data stores should not generate ops in readonly mode.
-     */
-    readonly writeError: "writeError";
-    /**
-     * A generic fetch failure that indicates we were not able to get a response from the server.
-     * This may be due to the client being offline (though, if we are able to detect offline state it will be
-     * logged as an offlineError instead).  Other possibilities could be DNS errors, malformed fetch request,
-     * CSP violation, etc.
-     */
-    readonly fetchFailure: "fetchFailure";
-    /**
-     * This error occurs when token provider fails to fetch orderer token
-     */
-    readonly fetchTokenError: "fetchTokenError";
-    /**
-     * Unexpected response from server. Either JSON is malformed, or some required properties are missing
-     */
-    readonly incorrectServerResponse: "incorrectServerResponse";
-    /**
-     * This error occurs when the file is modified externally (not through Fluid protocol) in storage.
-     * It will occur in cases where client has some state or cache that is based on old content (identity) of a file,
-     * and storage / driver / loader detects such mismatch.
-     * When it's hit, client needs to forget all the knowledge about this file and start over.
-     */
-    readonly fileOverwrittenInStorage: "fileOverwrittenInStorage";
-    /**
-     * The document is read-only and delta stream connection is forbidden.
-     */
-    readonly deltaStreamConnectionForbidden: "deltaStreamConnectionForbidden";
-    /**
-     * The location of file/container can change on server. So if the file location moves and we try to access the old
-     * location, then this error is thrown to let the client know about the new location info.
-     */
-    readonly locationRedirection: "locationRedirection";
-    /**
-     * When a file is not a Fluid file, but has Fluid extension such as ".note",
-     * server won't be able to open it and will return this error. The innerMostErrorCode will be
-     * "fluidInvalidSchema"
-     */
-    readonly fluidInvalidSchema: "fluidInvalidSchema";
-    /**
-     * File is locked for read/write by storage, e.g. whole collection is locked and access denied.
-     */
-    readonly fileIsLocked: "fileIsLocked";
-    /**
-     * Storage is out of space
-     */
-    readonly outOfStorageError: "outOfStorageError";
-    readonly genericError: "genericError";
-    readonly throttlingError: "throttlingError";
-    readonly usageError: "usageError";
-};
-
-/**
- * {@inheritDoc (DriverErrorTypes:variable)}
- * @public
- */
-export declare type DriverErrorTypes = (typeof DriverErrorTypes)[keyof typeof DriverErrorTypes];
-
-/**
- * Used to specify the kinds of events emitted by an {@link ISubscribable}.
- *
- * @remarks
- *
- * Any object type is a valid {@link Events}, but only the event-like properties of that
- * type will be included.
- *
- * @example
- *
- * ```typescript
- * interface MyEvents {
- *   load: (user: string, data: IUserData) => void;
- *   error: (errorCode: number) => void;
- * }
- * ```
- *
- * @public
- */
-export declare type Events<E> = {
-    [P in (string | symbol) & keyof E as IsEvent<E[P]> extends true ? P : never]: E[P];
-};
-
-/**
- * Get the `Item` type from a `LazyItem<Item>`.
- * @public
- */
-export declare type ExtractItemType<Item extends LazyItem> = Item extends () => infer Result ? Result : Item;
-
-/**
- * Kind of a field on a node.
- * @public
- */
-export declare enum FieldKind {
-    /**
-     * A field which can be empty or filled.
-     * @remarks
-     * Allows 0 or one child.
-     */
-    Optional = 0,
-    /**
-     * A field which must always be filled.
-     * @remarks
-     * Only allows exactly one child.
-     */
-    Required = 1,
-    /**
-     * A special field used for node identifiers.
-     * @remarks
-     * Only allows exactly one child.
-     */
-    Identifier = 2
-}
-
-/**
- * Additional information to provide to a {@link FieldSchema}.
- *
- * @public
- */
-export declare interface FieldProps {
-    /**
-     * The unique identifier of a field, used in the persisted form of the tree.
-     *
-     * @remarks
-     * If not explicitly set via the schema, this is the same as the schema's property key.
-     *
-     * Specifying a stored key that differs from the property key is particularly useful in refactoring scenarios.
-     * To update the developer-facing API, while maintaining backwards compatibility with existing SharedTree data,
-     * you can change the property key and specify the previous property key as the stored key.
-     *
-     * Notes:
-     *
-     * - Stored keys have no impact on standard JavaScript behavior, on tree nodes. For example, `Object.keys`
-     * will always return the property keys specified in the schema, ignoring any stored keys that differ from
-     * the property keys.
-     *
-     * - When specifying stored keys in an object schema, you must ensure that the final set of stored keys
-     * (accounting for those implicitly derived from property keys) contains no duplicates.
-     * This is validated at runtime.
-     *
-     * @example Refactoring code without breaking compatibility with existing data
-     *
-     * Consider some existing object schema:
-     *
-     * ```TypeScript
-     * class Point extends schemaFactory.object("Point", {
-     * 	xPosition: schemaFactory.number,
-     * 	yPosition: schemaFactory.number,
-     * 	zPosition: schemaFactory.optional(schemaFactory.number),
-     * });
-     * ```
-     *
-     * Developers using nodes of this type would access the the `xPosition` property as `point.xPosition`.
-     *
-     * We would like to refactor the schema to omit "Position" from the property keys, but application data has
-     * already been persisted using the original property keys. To maintain compatibility with existing data,
-     * we can refactor the schema as follows:
-     *
-     * ```TypeScript
-     * class Point extends schemaFactory.object("Point", {
-     * 	x: schemaFactory.required(schemaFactory.number, { key: "xPosition" }),
-     * 	y: schemaFactory.required(schemaFactory.number, { key: "yPosition" }),
-     * 	z: schemaFactory.optional(schemaFactory.number, { key: "zPosition" }),
-     * });
-     * ```
-     *
-     * Now, developers can access the `x` property as `point.x`, while existing data can still be collaborated on.
-     *
-     * @defaultValue If not specified, the key that is persisted is the property key that was specified in the schema.
-     */
-    readonly key?: string;
-}
-
-/**
- * All policy for a specific field,
- * including functionality that does not have to be kept consistent across versions or deterministic.
- *
- * This can include policy for how to use this schema for "view" purposes, and well as how to expose editing APIs.
- * @sealed @public
- */
-export declare class FieldSchema<out Kind extends FieldKind = FieldKind, out Types extends ImplicitAllowedTypes = ImplicitAllowedTypes> {
-    /**
-     * The {@link https://en.wikipedia.org/wiki/Kind_(type_theory) | kind } of this field.
-     * Determines the multiplicity, viewing and editing APIs as well as the merge resolution policy.
-     */
-    readonly kind: Kind;
-    /**
-     * What types of tree nodes are allowed in this field.
-     */
-    readonly allowedTypes: Types;
-    /**
-     * Optional properties associated with the field.
-     */
-    readonly props?: FieldProps | undefined;
-    /**
-     * This class is used with instanceof, and therefore should have nominal typing.
-     * This field enforces that.
-     */
-    protected _typeCheck?: MakeNominal;
-    private readonly lazyTypes;
-    /**
-     * What types of tree nodes are allowed in this field.
-     * @remarks Counterpart to {@link FieldSchema.allowedTypes}, with any lazy definitions evaluated.
-     */
-    get allowedTypeSet(): ReadonlySet<TreeNodeSchema>;
-    constructor(
-    /**
-     * The {@link https://en.wikipedia.org/wiki/Kind_(type_theory) | kind } of this field.
-     * Determines the multiplicity, viewing and editing APIs as well as the merge resolution policy.
-     */
-    kind: Kind, 
-    /**
-     * What types of tree nodes are allowed in this field.
-     */
-    allowedTypes: Types, 
-    /**
-     * Optional properties associated with the field.
-     */
-    props?: FieldProps | undefined);
-}
-
-/**
- * A flexible way to list values.
- * Each item in the list can either be an "eager" **value** or a "lazy" **function that returns a value** (the latter allows cyclic references to work).
- * @privateRemarks
- * By default, items that are of type `"function"` will be considered lazy and all other items will be considered eager.
- * To force a `"function"` item to be treated as an eager item, call `markEager` before putting it in the list.
- * This is necessary e.g. when the eager list items are function types and the lazy items are functions that _return_ function types.
- * `FlexList`s are processed by `normalizeFlexList` and `normalizeFlexListEager`.
- * @public
- */
-export declare type FlexList<Item = unknown> = readonly LazyItem<Item>[];
-
-/**
- * Normalize FlexList type to a union.
- * @public
- */
-export declare type FlexListToUnion<TList extends FlexList> = ExtractItemType<TList[number]>;
-
-/**
- * Base interface for information for each connection made to the Fluid session.
- *
- * @remarks This interface can be extended to provide additional information specific to each service.
- * @public
- */
-export declare interface IConnection {
-    /**
-     * A unique ID for the connection.  A single user may have multiple connections, each with a different ID.
-     */
-    readonly id: string;
-    /**
-     * Whether the connection is in read or read/write mode.
-     */
-    readonly mode: "write" | "read";
-}
-
-/**
- * Represents errors raised on container.
- *
- * @see
- *
- * The following are commonly thrown error types, but `errorType` could be any string.
- *
- * - {@link @fluidframework/core-interfaces#ContainerErrorTypes}
- *
- * - {@link @fluidframework/driver-definitions#DriverErrorTypes}
- *
- * - {@link @fluidframework/odsp-driver-definitions#OdspErrorTypes}
- *
- * - {@link @fluidframework/routerlicious-driver#RouterliciousErrorType}
- * @public
- */
-export declare type ICriticalContainerError = IErrorBase;
-
-/**
- * An object with an explicit lifetime that can be ended.
- * @privateRemarks
- * TODO: align this with core-utils/IDisposable and {@link https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-2.html#using-declarations-and-explicit-resource-management| TypeScript's Disposable}.
- * @public
- */
-export declare interface IDisposable {
-    /**
-     * Call to end the lifetime of this object.
-     *
-     * It is invalid to use this object after this,
-     * except for operations which explicitly document they are valid after disposal.
-     *
-     * @remarks
-     * May cleanup resources retained by this object.
-     * Often includes un-registering from events and thus preventing other objects from retaining a reference to this indefinably.
-     *
-     * Usually the only operations allowed after disposal are querying if an object is already disposed,
-     * but this can vary between implementations.
-     */
-    [disposeSymbol](): void;
-}
-
-/**
- * Provides an entrypoint into the client side of collaborative Fluid data.
- * Provides access to the data as well as status on the collaboration session.
- *
- * @typeparam TContainerSchema - Used to determine the type of 'initialObjects'.
- *
- * @remarks Note: external implementations of this interface are not supported.
- *
- * @sealed
- * @public
- */
-export declare interface IFluidContainer<TContainerSchema extends ContainerSchema = ContainerSchema> extends IEventProvider<IFluidContainerEvents> {
-    /**
-     * Provides the current connected state of the container
-     */
-    readonly connectionState: ConnectionStateType;
-    /**
-     * A container is considered **dirty** if it has local changes that have not yet been acknowledged by the service.
-     *
-     * @remarks
-     *
-     * You should always check the `isDirty` flag before closing the container or navigating away from the page.
-     * Closing the container while `isDirty === true` may result in the loss of operations that have not yet been
-     * acknowledged by the service.
-     *
-     * A container is considered dirty in the following cases:
-     *
-     * 1. The container has been created in the detached state, and either it has not been attached yet or it is
-     * in the process of being attached (container is in `attaching` state). If container is closed prior to being
-     * attached, host may never know if the file was created or not.
-     *
-     * 2. The container was attached, but it has local changes that have not yet been saved to service endpoint.
-     * This occurs as part of normal op flow where pending operation (changes) are awaiting acknowledgement from the
-     * service. In some cases this can be due to lack of network connection. If the network connection is down,
-     * it needs to be restored for the pending changes to be acknowledged.
-     */
-    readonly isDirty: boolean;
-    /**
-     * Whether or not the container is disposed, which permanently disables it.
-     */
-    readonly disposed: boolean;
-    /**
-     * The collection of data objects and Distributed Data Stores (DDSes) that were specified by the schema.
-     *
-     * @remarks These data objects and DDSes exist for the lifetime of the container.
-     */
-    readonly initialObjects: InitialObjects<TContainerSchema>;
-    /**
-     * The current attachment state of the container.
-     *
-     * @remarks
-     *
-     * Once a container has been attached, it remains attached.
-     * When loading an existing container, it will already be attached.
-     */
-    readonly attachState: AttachState;
-    /**
-     * A newly created container starts detached from the collaborative service.
-     * Calling `attach()` uploads the new container to the service and connects to the collaborative service.
-     *
-     * @remarks
-     *
-     * This should only be called when the container is in the
-     * {@link @fluidframework/container-definitions#AttachState.Detatched} state.
-     *
-     * This can be determined by observing {@link IFluidContainer.attachState}.
-     *
-     * @returns A promise which resolves when the attach is complete, with the string identifier of the container.
-     */
-    attach(props?: ContainerAttachProps): Promise<string>;
-    /**
-     * Attempts to connect the container to the delta stream and process operations.
-     *
-     * @throws Will throw an error if connection is unsuccessful.
-     *
-     * @remarks
-     *
-     * This should only be called when the container is in the
-     * {@link @fluidframework/container-definitions#(ConnectionState:namespace).Disconnected} state.
-     *
-     * This can be determined by observing {@link IFluidContainer.connectionState}.
-     */
-    connect(): void;
-    /**
-     * Disconnects the container from the delta stream and stops processing operations.
-     *
-     * @remarks
-     *
-     * This should only be called when the container is in the
-     * {@link @fluidframework/container-definitions#(ConnectionState:namespace).Connected} state.
-     *
-     * This can be determined by observing {@link IFluidContainer.connectionState}.
-     */
-    disconnect(): void;
-    /**
-     * Create a new data object or Distributed Data Store (DDS) of the specified type.
-     *
-     * @remarks
-     *
-     * In order to share the data object or DDS with other
-     * collaborators and retrieve it later, store its handle in a collection like a SharedDirectory from your
-     * initialObjects.
-     *
-     * @param objectClass - The class of the `DataObject` or `SharedObject` to create.
-     *
-     * @typeParam T - The class of the `DataObject` or `SharedObject`.
-     */
-    create<T extends IFluidLoadable>(objectClass: LoadableObjectClass<T>): Promise<T>;
-    /**
-     * Dispose of the container instance, permanently disabling it.
-     */
-    dispose(): void;
-}
-
-/**
- * Events emitted from {@link IFluidContainer}.
- *
- * @remarks Note: external implementations of this interface are not supported.
- * @sealed
- * @public
- */
-export declare interface IFluidContainerEvents extends IEvent {
-    /**
-     * Emitted when the {@link IFluidContainer} completes connecting to the Fluid service.
-     *
-     * @remarks Reflects connection state changes against the (delta) service acknowledging ops/edits.
-     *
-     * @see
-     *
-     * - {@link IFluidContainer.connectionState}
-     *
-     * - {@link IFluidContainer.connect}
-     */
-    (event: "connected", listener: () => void): void;
-    /**
-     * Emitted when the {@link IFluidContainer} becomes disconnected from the Fluid service.
-     *
-     * @remarks Reflects connection state changes against the (delta) service acknowledging ops/edits.
-     *
-     * @see
-     *
-     * - {@link IFluidContainer.connectionState}
-     *
-     * - {@link IFluidContainer.disconnect}
-     */
-    (event: "disconnected", listener: () => void): void;
-    /**
-     * Emitted when all local changes/edits have been acknowledged by the service.
-     *
-     * @remarks "dirty" event will be emitted when the next local change has been made.
-     *
-     * @see {@link IFluidContainer.isDirty}
-     */
-    (event: "saved", listener: () => void): void;
-    /**
-     * Emitted when the first local change has been made, following a "saved" event.
-     *
-     * @remarks "saved" event will be emitted once all local changes have been acknowledged by the service.
-     *
-     * @see {@link IFluidContainer.isDirty}
-     */
-    (event: "dirty", listener: () => void): void;
-    /**
-     * Emitted when the {@link IFluidContainer} is closed, which permanently disables it.
-     *
-     * @remarks Listener parameters:
-     *
-     * - `error`: If the container was closed due to error (as opposed to an explicit call to
-     * {@link IFluidContainer.dispose}), this will contain details about the error that caused it.
-     */
-    (event: "disposed", listener: (error?: ICriticalContainerError) => void): any;
-}
-
-/**
- * Base interface to be implemented to fetch each service's member.
- *
- * @remarks This interface can be extended by each service to provide additional service-specific user metadata.
- * @public
- */
-export declare interface IMember {
-    /**
-     * An ID for the user, unique among each individual user connecting to the session.
-     */
-    readonly userId: string;
-    /**
-     * The set of connections the user has made, e.g. from multiple tabs or devices.
-     */
-    readonly connections: IConnection[];
-}
-
-/**
- * Types allowed in a field.
- * @remarks
- * Implicitly treats a single type as an array of one type.
- * @public
- */
-export declare type ImplicitAllowedTypes = AllowedTypes | TreeNodeSchema;
-
-/**
- * Schema for a field of a tree node.
- * @remarks
- * Implicitly treats {@link ImplicitAllowedTypes} as a Required field of that type.
- * @public
- */
-export declare type ImplicitFieldSchema = FieldSchema | ImplicitAllowedTypes;
-
-/**
- * Extract the type of 'initialObjects' from the given {@link ContainerSchema} type.
- * @public
- */
-export declare type InitialObjects<T extends ContainerSchema> = {
-    [K in keyof T["initialObjects"]]: T["initialObjects"][K] extends LoadableObjectClass<infer TChannel> ? TChannel : never;
-};
-
-/**
- * Helper used to produce types for:
- *
- * 1. Insertable content which can be used to construct an object node.
- *
- * 2. Insertable content which is an unhydrated object node.
- *
- * 3. Union of 1 and 2.
- *
- * @privateRemarks TODO: consider separating these cases into different types.
- *
- * @public
- */
-export declare type InsertableObjectFromSchemaRecord<T extends RestrictiveReadonlyRecord<string, ImplicitFieldSchema>> = {
-    readonly [Property in keyof T]: InsertableTreeFieldFromImplicitField<T[Property]>;
-};
-
-/**
- * Type of content that can be inserted into the tree for a field of the given schema.
- * @public
- */
-export declare type InsertableTreeFieldFromImplicitField<TSchema extends ImplicitFieldSchema = FieldSchema> = TSchema extends FieldSchema<infer Kind, infer Types> ? ApplyKind<InsertableTreeNodeFromImplicitAllowedTypes<Types>, Kind> : TSchema extends ImplicitAllowedTypes ? InsertableTreeNodeFromImplicitAllowedTypes<TSchema> : unknown;
-
-/**
- * Type of content that can be inserted into the tree for a node of the given schema.
- * @public
- */
-export declare type InsertableTreeNodeFromImplicitAllowedTypes<TSchema extends ImplicitAllowedTypes = TreeNodeSchema> = TSchema extends TreeNodeSchema ? InsertableTypedNode<TSchema> : TSchema extends AllowedTypes ? InsertableTypedNode<FlexListToUnion<TSchema>> : never;
-
-/**
- * Data which can be used as a node to be inserted.
- * Either an unhydrated node, or content to build a new node.
- * @public
- */
-export declare type InsertableTypedNode<T extends TreeNodeSchema> = (T extends {
-    implicitlyConstructable: true;
-} ? NodeBuilderData<T> : never) | Unhydrated<NodeFromSchema<T>>;
-
-/**
- * Base interface to be implemented to fetch each service's audience.
- *
- * @remarks
- *
- * The type parameter `M` allows consumers to further extend the client object with service-specific
- * details about the connecting client, such as device information, environment, or a username.
- *
- * @typeParam M - A service-specific {@link IMember} type.
- * @public
- */
-export declare interface IServiceAudience<M extends IMember> extends IEventProvider<IServiceAudienceEvents<M>> {
-    /**
-     * Returns an map of all users currently in the Fluid session where key is the userId and the value is the
-     * member object.  The implementation may choose to exclude certain connections from the returned map.
-     * E.g. ServiceAudience excludes non-interactive connections to represent only the roster of live users.
-     */
-    getMembers(): ReadonlyMap<string, M>;
-    /**
-     * Returns the current active user on this client once they are connected. Otherwise, returns undefined.
-     */
-    getMyself(): Myself<M> | undefined;
-}
-
-/**
- * Events that trigger when the roster of members in the Fluid session change.
- *
- * @remarks
- *
- * Only changes that would be reflected in the returned map of {@link IServiceAudience}'s
- * {@link IServiceAudience.getMembers} method will emit events.
- *
- * @typeParam M - A service-specific {@link IMember} implementation.
- * @public
- */
-export declare interface IServiceAudienceEvents<M extends IMember> extends IEvent {
-    /**
-     * Emitted when a {@link IMember | member}(s) are either added or removed.
-     *
-     * @eventProperty
-     */
-    (event: "membersChanged", listener: () => void): void;
-    /**
-     * Emitted when a {@link IMember | member} joins the audience.
-     *
-     * @eventProperty
-     */
-    (event: "memberAdded", listener: MemberChangedListener<M>): void;
-    /**
-     * Emitted when a {@link IMember | member} leaves the audience.
-     *
-     * @eventProperty
-     */
-    (event: "memberRemoved", listener: MemberChangedListener<M>): void;
-}
-
-/**
- * `true` iff the given type is an acceptable shape for an event
- * @public
- */
-export declare type IsEvent<Event> = Event extends (...args: any[]) => any ? true : false;
-
-/**
- * The SharedMap distributed data structure can be used to store key-value pairs. It provides the same API for setting
- * and retrieving values that JavaScript developers are accustomed to with the
- * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map | Map} built-in object.
- * However, the keys of a SharedMap must be strings, and the values must either be a JSON-serializable object or a
- * {@link @fluidframework/datastore#FluidObjectHandle}.
- *
- * For more information, including example usages, see {@link https://fluidframework.com/docs/data-structures/map/}.
- * @sealed
- * @public
- */
-export declare interface ISharedMap extends ISharedObject<ISharedMapEvents>, Map<string, any> {
-    /**
-     * Retrieves the given key from the map if it exists.
-     * @param key - Key to retrieve from
-     * @returns The stored value, or undefined if the key is not set
-     */
-    get<T = any>(key: string): T | undefined;
-    /**
-     * Sets the value stored at key to the provided value.
-     * @param key - Key to set
-     * @param value - Value to set
-     * @returns The {@link ISharedMap} itself
-     */
-    set<T = unknown>(key: string, value: T): this;
-}
-
-/**
- * Events emitted in response to changes to the {@link ISharedMap | map} data.
- * @sealed
- * @public
- */
-export declare interface ISharedMapEvents extends ISharedObjectEvents {
-    /**
-     * Emitted when a key is set or deleted.
-     *
-     * @remarks Listener parameters:
-     *
-     * - `changed` - Information on the key that changed and its value prior to the change.
-     *
-     * - `local` - Whether the change originated from this client.
-     *
-     * - `target` - The {@link ISharedMap} itself.
-     */
-    (event: "valueChanged", listener: (changed: IValueChanged, local: boolean, target: IEventThisPlaceHolder) => void): any;
-    /**
-     * Emitted when the map is cleared.
-     *
-     * @remarks Listener parameters:
-     *
-     * - `local` - Whether the clear originated from this client.
-     *
-     * - `target` - The {@link ISharedMap} itself.
-     */
-    (event: "clear", listener: (local: boolean, target: IEventThisPlaceHolder) => void): any;
-}
-
-/**
- * An object which allows the registration of listeners so that subscribers can be notified when an event happens.
- *
- * `EventEmitter` can be used as a base class to implement this via extension.
- * @param E - All the events that this emitter supports
- * @example
- * ```ts
- * type MyEventEmitter = IEventEmitter<{
- *   load: (user: string, data: IUserData) => void;
- *   error: (errorCode: number) => void;
- * }>
- * ```
- * @privateRemarks
- * {@link createEmitter} can help implement this interface via delegation.
- *
- * @public
- */
-export declare interface ISubscribable<E extends Events<E>> {
-    /**
-     * Register an event listener.
-     * @param eventName - the name of the event
-     * @param listener - the handler to run when the event is fired by the emitter
-     * @returns a function which will deregister the listener when run. This function has undefined behavior
-     * if called more than once.
-     */
-    on<K extends keyof Events<E>>(eventName: K, listener: E[K]): () => void;
-}
-
-/**
- * Used to insert iterable content into a {@link (TreeArrayNode:interface)}.
- * Use {@link (TreeArrayNode:variable).spread} to create an instance of this type.
- * @public
- */
-export declare class IterableTreeArrayContent<T> implements Iterable<T> {
-    private readonly content;
-    private constructor();
-    /**
-     * Iterates over content for nodes to insert.
-     */
-    [Symbol.iterator](): Iterator<T>;
-}
-
-/**
- * Channel for a Fluid Tree DDS.
- * @remarks
- * Allows storing and collaboratively editing schema-aware hierarchial data.
- * @public
- */
-export declare interface ITree extends IChannel {
-    /**
-     * Returns a {@link TreeView} using the provided schema.
-     * If the tree's stored schema is compatible, this will provide a schema-aware API for accessing the tree's content.
-     * If the provided schema is incompatible with the stored data, the view will instead expose an error indicating the incompatibility.
-     *
-     * @remarks
-     * If the tree is uninitialized (has no schema and no content), the tree is initialized with the `initialTree` and
-     * view `schema` in the provided `config`.
-     *
-     * The tree (now known to have been initialized) has its stored schema checked against the provided view schema.
-     *
-     * If the schemas are compatible, the returned {@link TreeView} will expose the root with a schema-aware API based on the provided view schema.
-     *
-     * If the schemas are not compatible, the view will indicate the error.
-     *
-     * Note that other clients can modify the document at any time, causing the view to enter or leave this error state: see {@link TreeView.events} for how to handle invalidation in these cases.
-     *
-     * Only one schematized view may exist for a given ITree at a time.
-     * If creating a second, the first must be disposed before calling `schematize` again.
-     *
-     * @privateRemarks
-     * TODO: Provide a way to make a generic view schema for any document.
-     * TODO: Support adapters for handling out-of-schema data.
-     *
-     * Doing initialization here allows a small API that is hard to use incorrectly.
-     * Other approaches tend to have easy-to-make mistakes.
-     * For example, having a separate initialization function means apps can forget to call it, making an app that can only open existing documents,
-     * or call it unconditionally leaving an app that can only create new documents.
-     * It also would require the schema to be passed into separate places and could cause issues if they didn't match.
-     * Since the initialization function couldn't return a typed tree, the type checking wouldn't help catch that.
-     * Also, if an app manages to create a document, but the initialization fails to get persisted, an app that only calls the initialization function
-     * on the create code-path (for example how a schematized factory might do it),
-     * would leave the document in an unusable state which could not be repaired when it is reopened (by the same or other clients).
-     * Additionally, once out of schema content adapters are properly supported (with lazy document updates),
-     * this initialization could become just another out of schema content adapter and this initialization is no longer a special case.
-     */
-    schematize<TRoot extends ImplicitFieldSchema>(config: TreeConfiguration<TRoot>): TreeView<TRoot>;
-}
-
-/**
- * Type of "valueChanged" event parameter.
- * @sealed
- * @public
- */
-export declare interface IValueChanged {
-    /**
-     * The key storing the value that changed.
-     */
-    readonly key: string;
-    /**
-     * The value that was stored at the key prior to the change.
-     */
-    readonly previousValue: any;
-}
-
-/**
- * An "eager" or "lazy" Item in a `FlexList`.
- * Lazy items are wrapped in a function to allow referring to themselves before they are declared.
- * This makes recursive and co-recursive items possible.
- * @public
- */
-export declare type LazyItem<Item = unknown> = Item | (() => Item);
-
-/**
- * A class object of `DataObject` or `SharedObject`.
- *
- * @typeParam T - The class of the `DataObject` or `SharedObject`.
- * @public
- *
- * @privateRemarks
- * There are some edge cases in TypeScript where the order of the members in a union matter.
- * Once such edge case is when multiple members of a generic union partially match, and the type parameter is being inferred.
- * In this case, its better to have the desired match and/or the simpler type first.
- * In this case placing ISharedObjectKind fixed one usage and didn't break anything, and generally seems more likely to work than the reverse, so this is the order being used.
- * This is likely (a bug in TypeScript)[https://github.com/microsoft/TypeScript/issues/45809].
- */
-export declare type LoadableObjectClass<T extends IFluidLoadable = IFluidLoadable> = ISharedObjectKind<T> | DataObjectClass<T>;
-
-/**
- * A mapping of string identifiers to classes that will later be used to instantiate a corresponding `DataObject`
- * or `SharedObject`.
- * @public
- */
-export declare type LoadableObjectClassRecord = Record<string, LoadableObjectClass>;
-
-/**
- * Utilities for manipulating the typescript typechecker.
- *
- * @remarks
- * While it appears the the variance parts of this library are made obsolete by TypeScript 4.7's explicit variance annotations,
- * many cases still type check with incorrect variance even when using the explicit annotations,
- * and are fixed by using the patterns in this library.
- *
- * TypeScript uses structural typing if there are no private or protected members,
- * and variance of generic type parameters depends on their usages.
- * Thus when trying to constrain code by adding extra type information,
- * it often fails to actually constrain as desired, and these utilities can help with those cases.
- *
- * This library is designed so that the desired variance can be documented in a way that is easy to read, concise,
- * and allows easy navigation to documentation explaining what is being done
- * for readers who are not familiar with this library.
- * Additionally it constrains the types so the undesired usage patterns will not compile,
- * and will give somewhat intelligible errors.
- *
- * Additionally this library provides the tools needed to test that the type constraints are working as expected,
- * or test any other similar typing constraints in an application.
- *
- * This library assumes you are compiling with --strictFunctionTypes:
- * (Covariance and Contravariance is explained along with how these helpers cause it in typescript at this link)
- * {@link https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-6.html#strict-function-types}.
- * If compiled with a TypeScript configuration that is not strict enough for these features to work,
- * the test suite should fail to build.
- *
- * Classes in TypeScript by default allow all assignments:
- * its only though adding members that any type constraints actually get applied.
- * This library provides types that can be used on a protected member of a class to add the desired constraints.
- *
- * Typical usages (use one field like this at the top of a class):
- * ```typescript
- * protected _typeCheck?: MakeNominal;
- * protected _typeCheck?: Contravariant<T>;
- * protected _typeCheck?: Covariant<T>;
- * protected _typeCheck?: Invariant<T>;
- * protected _typeCheck?: Contravariant<T> & Invariant<K>;
- * ```
- *
- * See tests for examples.
- *
- * Note that all of these cause nominal typing.
- * If constraints on generic type parameter variance are desired, but nominal typing is not,
- * these types can be used on a public field. This case also works with interfaces.
- *
- * Be aware that other members of your type might apply further constraints
- * (ex: you might try and write a Contravariant<T> class, but it ends up being Invariant<T> due to a field of type T).
- *
- * Be aware of TypeScript Bug:
- * {@link https://github.com/microsoft/TypeScript/issues/36906}.
- * This bug is why the fields here are protected not private.
- * Note that this bug is closed as a duplicate of {@link https://github.com/microsoft/TypeScript/issues/20979}
- * which was closed because fixing it would be too large of a breaking change.
- * Thus we expect this bug to be part of TypeScript for the forseeable future.
- */
-/**
- * Use this as the type of a protected field to cause a type to use nominal typing instead of structural.
- *
- * @remarks
- * Using nominal typing in this way prevents assignment of objects which are not instances of this class to values of this class's type.
- * Classes which are used with "instanceof", or are supposed to be instantiated in particular ways (not just made with object literals)
- * can use this to prevent undesired assignments.
- * @example
- * ```typescript
- * protected _typeCheck?: MakeNominal;
- * ```
- * @privateRemarks
- * See: {@link https://dev.azure.com/intentional/intent/_wiki/wikis/NP%20Platform/7146/Nominal-vs-Structural-Types}
- * @public
- */
-export declare interface MakeNominal {
-}
-
-/**
- * Signature for {@link IMember} change events.
- *
- * @param clientId - A unique identifier for the client.
- * @param member - The service-specific member object for the client.
- *
- * @see See {@link IServiceAudienceEvents} for usage details.
- * @public
- */
-export declare type MemberChangedListener<M extends IMember> = (clientId: string, member: M) => void;
-
-/**
- * An extended member object that includes currentConnection
- * @public
- */
-export declare type Myself<M extends IMember = IMember> = M & {
-    readonly currentConnection: string;
-};
-
-/**
- * Given a node's schema, return the corresponding object from which the node could be built.
- * @privateRemarks
- * Currently this assumes factory functions take exactly one argument.
- * This could be changed if needed.
- *
- * These factory functions can also take a FlexTreeNode, but this is not exposed in the public facing types.
- * @public
- */
-export declare type NodeBuilderData<T extends TreeNodeSchema> = T extends TreeNodeSchema<string, NodeKind, unknown, infer TBuild> ? TBuild : never;
-
-/**
- * Takes in `TreeNodeSchema[]` and returns a TypedNode union.
- * @public
- */
-export declare type NodeFromSchema<T extends TreeNodeSchema> = T extends TreeNodeSchema<string, NodeKind, infer TNode> ? TNode : never;
-
-/**
- * Kind of tree node.
- * @public
- */
-export declare enum NodeKind {
-    /**
-     * A node which serves as a map, storing children under string keys.
-     */
-    Map = 0,
-    /**
-     * A node which serves as an array, storing children in an ordered sequence.
-     */
-    Array = 1,
-    /**
-     * A node which stores a heterogenous collection of children in named fields.
-     * @remarks
-     * Each field gets its own schema.
-     */
-    Object = 2,
-    /**
-     * A node which stores a single leaf value.
-     */
-    Leaf = 3
-}
-
-/**
- * Helper used to produce types for object nodes.
- * @public
- */
-export declare type ObjectFromSchemaRecord<T extends RestrictiveReadonlyRecord<string, ImplicitFieldSchema>> = {
-    -readonly [Property in keyof T]: TreeFieldFromImplicitField<T[Property]>;
-};
-
-/**
- * Alternative to the built in Record type which does not permit unexpected members,
- * and is readonly.
- *
- * @privateRemarks
- * `number` is not allowed as a key here since doing so causes the compiler to reject recursive schema.
- * The cause for this is unclear, but empirically it was the case when this comment was written.
- * @public
- */
-export declare type RestrictiveReadonlyRecord<K extends symbol | string, T> = {
-    readonly [P in symbol | string]: P extends K ? T : never;
-};
-
-/**
- * Allows reversion of a change made to SharedTree.
- *
- * @remarks
- * Applications wanting to implement undo/redo support might typically maintain two stacks of Revertibles, with optional eviction policy to free up memory.
- *
- * @public
- */
-export declare interface Revertible {
-    /**
-     * The current status of the revertible.
-     */
-    readonly status: RevertibleStatus;
-    /**
-     * Reverts the associated change and disposes it.
-     */
-    revert(): void;
-    /**
-     * Reverts the associated change and optionally disposes it.
-     *
-     * @param dispose - If true, the revertible will be disposed after being reverted.
-     * If false, the revertible will remain valid. This can be useful for scenarios where the revert may be dropped
-     * due to merge conflicts, and one wants to attempt reverting again.
-     */
-    revert(dispose: boolean): void;
-    /**
-     * Disposes this revertible, allowing associated resources to be released.
-     */
-    [disposeSymbol](): void;
-}
-
-/**
- * Factory for creating a {@link Revertible}.
- * Will error if invoked outside the scope of the `commitApplied` event that provides it, or if invoked multiple times.
- *
- * @param onRevertibleDisposed - A callback that will be invoked when the `Revertible` generated by this factory is disposed.
- * This happens when the `Revertible` is disposed manually, or when the `TreeView` that the `Revertible` belongs to is disposed,
- * whichever happens first.
- * This is typically used to clean up any resources associated with the `Revertible` in the host application.
- *
- * @public
- */
-export declare type RevertibleFactory = (onRevertibleDisposed?: (revertible: Revertible) => void) => Revertible;
-
-/**
- * The status of a {@link Revertible}.
- *
- * @public
- */
-export declare enum RevertibleStatus {
-    /** The revertible can be reverted. */
-    Valid = 0,
-    /** The revertible has been disposed. Reverting it will have no effect. */
-    Disposed = 1
-}
-
-/**
- * Creates various types of {@link TreeNodeSchema|schema} for {@link TreeNode}s.
- *
- * @typeParam TScope - Scope added as a prefix to the name of every schema produced by this factory.
- * @typeParam TName - Type of names used to identify each schema produced in this factory.
- * Typically this is just `string` but it is also possible to use `string` or `number` based enums if you prefer to identify your types that way.
- *
- * @remarks
- * All schema produced by this factory get a {@link TreeNodeSchemaCore.identifier|unique identifier} by {@link ScopedSchemaName|combining} the {@link SchemaFactory.scope} with the schema's `Name`.
- * The `Name` part may be explicitly provided as a parameter, or inferred as a structural combination of the provided types.
- * The APIs which use this second approach, structural naming, also deduplicate all equivalent calls.
- * Therefor two calls to `array(allowedTypes)` with the same allowedTypes will return the same {@link TreeNodeSchema} instance.
- * On the other hand, two calls to `array(name, allowedTypes)` will always return different {@link TreeNodeSchema} instances
- * and it is an error to use both in the same tree (since their identifiers are not unique).
- *
- * Note:
- * POJO stands for Plain Old JavaScript Object.
- * This means an object that works like a `{}` style object literal.
- * In this case it means the prototype is `Object.prototype` and acts like a set of key value pairs (data, not methods).
- * The usage below generalizes this to include array and map like objects as well.
- *
- * There are two ways to use these APIs:
- * |                     | Customizable | POJO Emulation |
- * | ------------------- | ------------ |--------------- |
- * | Declaration         | `class X extends schemaFactory.object("x", {}) {}` | `const X = schemaFactory.object("x", {}); type X = NodeFromSchema<typeof X>; `
- * | Allows adding "local" (non-persisted) members | Yes. Members (including methods) can be added to class.        | No. Attempting to set non-field members will error. |
- * | Prototype | The user defined class | `Object.prototype`, `Map.prototype` or `Array.prototype` depending on node kind |
- * | Structurally named Schema | Not Supported | Supported |
- * | Explicitly named Objects | Supported | Supported |
- * | Explicitly named Maps and Arrays | Supported: Both declaration approaches can be used | Not Supported |
- * | node.js assert.deepEqual | Compares like class instances: equal to other nodes of the same type with the same content, including custom local fields. | Compares like plain objects: equal to plain JavaScript objects with the same fields, and other nodes with the same fields, even if the types are different. |
- * | IntelliSense | Shows and links to user defined class by name: `X` | Shows internal type generation logic: `object & TreeNode & ObjectFromSchemaRecord<{}> & WithType<"test.x">` |
- * | Recursion | Supported with special declaration patterns. | Unsupported: Generated d.ts files replace recursive references with `any`, breaking use of recursive schema across compilation boundaries |
- *
- * Note that while "POJO Emulation" nodes act a lot like POJO objects, they are not true POJO objects:
- *
- * - Adding new arbitrary fields will error, as well some cases of invalid edits.
- *
- * - They are implemented using proxies.
- *
- * - They have state that is not exposed via enumerable own properties, including a {@link TreeNodeSchema}.
- * This makes libraries like node.js `assert.deepEqual` fail to detect differences in type.
- *
- * - Assigning members has side effects (in this case editing the persisted/shared tree).
- *
- * - Not all operations implied by the prototype will work correctly: stick to the APIs explicitly declared in the TypeScript types.
- *
- * @privateRemarks
- * It's perfectly possible to make `POJO Emulation` mode (or even just hiding the prototype) selectable even when using the custom user class declaration syntax.
- * When doing this, it's still possible to make `instanceof` perform correctly.
- * Allowing (or banning) custom/out-of-schema properties on the class is also possible in both modes: it could be orthogonal.
- * Also for consistency, if keeping the current approach to detecting `POJO Emulation` mode it might make sense to make explicitly named Maps and Arrays do the detection the same as how object does it.
- *
- * @sealed @public
- */
-export declare class SchemaFactory<out TScope extends string | undefined = string | undefined, TName extends number | string = string> {
-    readonly scope: TScope;
-    private readonly structuralTypes;
-    /**
-     * @param scope - Prefix appended to the identifiers of all {@link TreeNodeSchema} produced by this builder.
-     * Use of [Reverse domain name notation](https://en.wikipedia.org/wiki/Reverse_domain_name_notation) or a UUIDv4 is recommended to avoid collisions.
-     * You may opt out of using a scope by passing `undefined`, but note that this increases the risk of collisions.
-     */
-    constructor(scope: TScope);
-    private scoped;
-    /**
-     * {@link TreeNodeSchema} for holding a JavaScript `string`.
-     *
-     * @remarks
-     * Strings containing unpaired UTF-16 surrogate pair code units may not be handled correctly.
-     *
-     * These limitations come from the use of UTF-8 encoding of the strings, which requires them to be valid unicode.
-     * JavaScript does not make this requirement for its strings so not all possible JavaScript strings are supported.
-     * @privateRemarks
-     * TODO:
-     * We should be much more clear about what happens if you use problematic values.
-     * We should validate and/or normalize them when inserting content.
-     */
-    readonly string: TreeNodeSchema<"com.fluidframework.leaf.string", NodeKind.Leaf, string, string>;
-    /**
-     * {@link TreeNodeSchema} for holding a JavaScript `number`.
-     *
-     * @remarks
-     * The number is a [double-precision 64-bit binary format IEEE 754](https://en.wikipedia.org/wiki/Double-precision_floating-point_format) value, however there are some exceptions:
-     * - `NaN`, and the infinities are converted to `null` (and may therefore only be used where `null` is allowed by the schema).
-     * - `-0` may be converted to `0` in some cases.
-     *
-     * These limitations match the limitations of JSON.
-     * @privateRemarks
-     * TODO:
-     * We should be much more clear about what happens if you use problematic values.
-     * We should validate and/or normalize them when inserting content.
-     */
-    readonly number: TreeNodeSchema<"com.fluidframework.leaf.number", NodeKind.Leaf, number, number>;
-    /**
-     * {@link TreeNodeSchema} for holding a boolean.
-     */
-    readonly boolean: TreeNodeSchema<"com.fluidframework.leaf.boolean", NodeKind.Leaf, boolean, boolean>;
-    /**
-     * {@link TreeNodeSchema} for JavaScript `null`.
-     *
-     * @remarks
-     * There are good [reasons to avoid using null](https://www.npmjs.com/package/%40rushstack/eslint-plugin#rushstackno-new-null) in JavaScript, however sometimes it is desired.
-     * This {@link TreeNodeSchema} node provides the option to include nulls in trees when desired.
-     * Unless directly inter-operating with existing data using null, consider other approaches, like wrapping the value in an optional field, or using a more specifically named empty object node.
-     */
-    readonly null: TreeNodeSchema<"com.fluidframework.leaf.null", NodeKind.Leaf, null, null>;
-    /**
-     * {@link TreeNodeSchema} for holding an {@link @fluidframework/core-interfaces#(IFluidHandle:interface)}.
-     */
-    readonly handle: TreeNodeSchema<"com.fluidframework.leaf.handle", NodeKind.Leaf, IFluidHandle<FluidObject<unknown> & IFluidLoadable>, IFluidHandle<FluidObject<unknown> & IFluidLoadable>>;
-    /**
-     * Construct a class that provides the common parts all TreeNodeSchemaClass share.
-     * More specific schema extend this class.
-     */
-    private nodeSchema;
-    /**
-     * Define a {@link TreeNodeSchema} for a {@link TreeObjectNode}.
-     *
-     * @param name - Unique identifier for this schema within this factory's scope.
-     * @param fields - Schema for fields of the object node's schema. Defines what children can be placed under each key.
-     */
-    object<const Name extends TName, const T extends RestrictiveReadonlyRecord<string, ImplicitFieldSchema>>(name: Name, fields: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Object, TreeObjectNode<T, ScopedSchemaName<TScope, Name>>, object & InsertableObjectFromSchemaRecord<T>, true, T>;
-    /**
-     * Define a structurally typed {@link TreeNodeSchema} for a {@link TreeMapNode}.
-     *
-     * @remarks
-     * The unique identifier for this Map is defined as a function of the provided types.
-     * It is still scoped to this SchemaBuilder, but multiple calls with the same arguments will return the same schema object, providing somewhat structural typing.
-     * This does not support recursive types.
-     *
-     * If using these structurally named maps, other types in this schema builder should avoid names of the form `Map<${string}>`.
-     *
-     * @example
-     * The returned schema should be used as a schema directly:
-     * ```typescript
-     * const MyMap = factory.map(factory.number);
-     * type MyMap = NodeFromSchema<typeof MyMap>;
-     * ```
-     * Or inline:
-     * ```typescript
-     * factory.object("Foo", {myMap: factory.map(factory.number)});
-     * ```
-     * @privateRemarks
-     * See note on array.
-     */
-    map<const T extends TreeNodeSchema | readonly TreeNodeSchema[]>(allowedTypes: T): TreeNodeSchema<ScopedSchemaName<TScope, `Map<${string}>`>, NodeKind.Map, TreeMapNode<T> & WithType<ScopedSchemaName<TScope, `Map<${string}>`>>, Iterable<[string, InsertableTreeNodeFromImplicitAllowedTypes<T>]>, true, T>;
-    /**
-     * Define a {@link TreeNodeSchema} for a {@link TreeMapNode}.
-     *
-     * @param name - Unique identifier for this schema within this factory's scope.
-     *
-     * @example
-     * ```typescript
-     * class NamedMap extends factory.map("name", factory.number) {}
-     * ```
-     */
-    map<Name extends TName, const T extends ImplicitAllowedTypes>(name: Name, allowedTypes: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Map, TreeMapNode<T> & WithType<ScopedSchemaName<TScope, Name>>, Iterable<[string, InsertableTreeNodeFromImplicitAllowedTypes<T>]>, true, T>;
-    /**
-     * Define a {@link TreeNodeSchema} for a {@link (TreeMapNode:interface)}.
-     *
-     * @param name - Unique identifier for this schema within this factory's scope.
-     *
-     * @remarks See remarks on {@link SchemaFactory.namedArray_internal}.
-     */
-    namedMap_internal<Name extends TName | string, const T extends ImplicitAllowedTypes, const ImplicitlyConstructable extends boolean>(name: Name, allowedTypes: T, customizable: boolean, implicitlyConstructable: ImplicitlyConstructable): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Map, TreeMapNode<T> & WithType<ScopedSchemaName<TScope, Name>>, Iterable<[string, InsertableTreeNodeFromImplicitAllowedTypes<T>]>, ImplicitlyConstructable, T>;
-    /**
-     * Define a structurally typed {@link TreeNodeSchema} for a {@link (TreeArrayNode:interface)}.
-     *
-     * @remarks
-     * The identifier for this Array is defined as a function of the provided types.
-     * It is still scoped to this SchemaFactory, but multiple calls with the same arguments will return the same schema object, providing somewhat structural typing.
-     * This does not support recursive types.
-     *
-     * If using these structurally named arrays, other types in this schema builder should avoid names of the form `Array<${string}>`.
-     *
-     * @example
-     * The returned schema should be used as a schema directly:
-     * ```typescript
-     * const MyArray = factory.array(factory.number);
-     * type MyArray = NodeFromSchema<typeof MyArray>;
-     * ```
-     * Or inline:
-     * ```typescript
-     * factory.object("Foo", {myArray: factory.array(factory.number)});
-     * ```
-     * @privateRemarks
-     * The name produced at the type level here is not as specific as it could be, however doing type level sorting and escaping is a real mess.
-     * There are cases where not having this full type provided will be less than ideal since TypeScript's structural types.
-     * For example attempts to narrow unions of structural arrays by name won't work.
-     * Planned future changes to move to a class based schema system as well as factor function based node construction should mostly avoid these issues,
-     * though there may still be some problematic cases even after that work is done.
-     *
-     * The return value is a class, but its the type is intentionally not specific enough to indicate it is a class.
-     * This prevents callers of this from sub-classing it, which is unlikely to work well (due to the ease of accidentally giving two different calls o this different subclasses)
-     * when working with structural typing.
-     *
-     * {@label STRUCTURAL}
-     */
-    array<const T extends TreeNodeSchema | readonly TreeNodeSchema[]>(allowedTypes: T): TreeNodeSchema<ScopedSchemaName<TScope, `Array<${string}>`>, NodeKind.Array, TreeArrayNode<T> & WithType<ScopedSchemaName<TScope, `Array<${string}>`>>, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>, true, T>;
-    /**
-     * Define (and add to this library) a {@link TreeNodeSchemaClass} for a {@link (TreeArrayNode:interface)}.
-     *
-     * @param name - Unique identifier for this schema within this factory's scope.
-     *
-     * @example
-     * ```typescript
-     * class NamedArray extends factory.array("name", factory.number) {}
-     * ```
-     *
-     * {@label NAMED}
-     */
-    array<const Name extends TName, const T extends ImplicitAllowedTypes>(name: Name, allowedTypes: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Array, TreeArrayNode<T> & WithType<ScopedSchemaName<TScope, Name>>, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>, true, T>;
-    /**
-     * Define a {@link TreeNodeSchema} for a {@link (TreeArrayNode:interface)}.
-     *
-     * @param name - Unique identifier for this schema within this factory's scope.
-     *
-     * @remarks
-     * This is not intended to be used directly, use the overload of `array` which takes a name instead.
-     * This is only public to work around a compiler limitation.
-     *
-     * @privateRemarks
-     * TODO: this should be made private or protected.
-     * Doing so breaks due to:
-     * `src/class-tree/schemaFactoryRecursive.ts:42:9 - error TS2310: Type 'Array' recursively references itself as a base type.`
-     * Once recursive APIs are better sorted out and integrated into this class, switch this back to private.
-     */
-    namedArray_internal<Name extends TName | string, const T extends ImplicitAllowedTypes, const ImplicitlyConstructable extends boolean>(name: Name, allowedTypes: T, customizable: boolean, implicitlyConstructable: ImplicitlyConstructable): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Array, TreeArrayNode<T> & WithType<ScopedSchemaName<TScope, string>>, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>, ImplicitlyConstructable, T>;
-    /**
-     * Make a field optional instead of the default, which is required.
-     *
-     * @param t - The types allowed under the field.
-     * @param props - Optional properties to associate with the field.
-     */
-    optional<const T extends ImplicitAllowedTypes>(t: T, props?: FieldProps): FieldSchema<FieldKind.Optional, T>;
-    /**
-     * Make a field explicitly required.
-     *
-     * @param t - The types allowed under the field.
-     * @param props - Optional properties to associate with the field.
-     *
-     * @remarks
-     * Fields are required by default, but this API can be used to make the required nature explicit in the schema,
-     * and allows associating custom {@link FieldProps | properties} with the field.
-     */
-    required<const T extends ImplicitAllowedTypes>(t: T, props?: FieldProps): FieldSchema<FieldKind.Required, T>;
-    /**
-     * Make a field of type identifier instead of the default which is required.
-     */
-    get identifier(): FieldSchema<FieldKind.Identifier>;
-    /**
-     * Function which can be used for its compile time side-effects to tweak the evaluation order of recursive types to make them compile.
-     * @remarks
-     * Some related information in https://github.com/microsoft/TypeScript/issues/55758.
-     *
-     * Also be aware that code which relies on this tends to break VSCode's IntelliSense every time anything related to that code (even comments) is edited.
-     * Running the command `TypeScript: Restart TS Server` with the schema file focused should fix it.
-     * Sometimes this does not work: closing all open files except the schema before running the command can help.
-     * Real compile errors (for example elsewhere in the file) can also cause the IntelliSense to not work correctly ever after `TypeScript: Restart TS Server`.
-     *
-     * Intellisense has also shown problems when schema files with recursive types are part of a cyclic file dependency.
-     * Splitting the schema into its own file with minimal dependencies can help with this.
-     *
-     * Ensure `"noImplicitAny": true` is set in the `tsconfig.json`.
-     * Without it, recursive types that are not working properly can infer `any` and give very non-type-safe results instead of erroring.
-     *
-     * @example
-     * ```typescript
-     * const factory = new SchemaFactory("example");
-     * const recursiveReference = () => RecursiveObject;
-     * factory.fixRecursiveReference(recursiveReference);
-     * export class RecursiveObject extends factory.object("exampleObject", {
-     * 	recursive: [recursiveReference],
-     * }) {}
-     * ```
-     * @deprecated Use special `recursive` versions of builders instead of relying on this.
-     */
-    fixRecursiveReference<T extends AllowedTypes>(...types: T): void;
-}
-
-/**
- * Information about how a view schema was incompatible.
- * @public
- */
-export declare interface SchemaIncompatible {
-    /**
-     * True iff the view schema supports all possible documents permitted by the stored schema.
-     *
-     * @remarks
-     * When true, this is still an error because the view schema supports more documents than the stored schema.
-     * This means that writes to the document using the view schema could make the document violate its stored schema.
-     * In this case, the stored schema could be updated to match the provided view schema, allowing read write access to the tree.
-     *
-     * Future version of SharedTree may provide readonly access to the document in this case because that would be safe:
-     * but this is not currently supported.
-     */
-    readonly canUpgrade: boolean;
-}
-
-/**
- * The name of a schema produced by {@link SchemaFactory}, including its optional scope prefix.
- *
- * @public
- */
-export declare type ScopedSchemaName<TScope extends string | undefined, TName extends number | string> = TScope extends undefined ? `${TName}` : `${TScope}.${TName}`;
-
-/**
- * Entrypoint for {@link ISharedMap} creation.
- * @public
- * @deprecated Please use SharedTree for new containers. SharedMap is supported for loading preexisting Fluid Framework 1.0 containers only.
- */
-export declare const SharedMap: ISharedObjectKind<ISharedMap>;
-
-/**
- * Entrypoint for {@link ISharedMap} creation.
- * @public
- * @deprecated Use ISharedMap instead.
- * @privateRemarks
- * This alias is for legacy compat from when the SharedMap class was exported as public.
- */
-export declare type SharedMap = ISharedMap;
-
-/**
- * SharedTree is a hierarchical data structure for collaboratively editing strongly typed JSON-like trees
- * of objects, arrays, and other data types.
- * @public
- */
-export declare const SharedTree: ISharedObjectKind<ITree>;
-
-/**
- * The `Tree` object holds various functions for interacting with {@link TreeNode}s.
- * @public
- */
-export declare const Tree: TreeApi;
-
-/**
- * Provides various functions for interacting with {@link TreeNode}s.
- * @public
- */
-export declare interface TreeApi extends TreeNodeApi {
-    /**
-     * Apply one or more edits to the tree as a single atomic unit.
-     * @param node - The node that will be passed to `transaction`.
-     * This is typically the root node of the subtree that will be modified by the transaction.
-     * @param transaction - The function to run as the body of the transaction.
-     * This function is passed the provided `node`.
-     * At any point during the transaction, the function may return the value `"rollback"` to abort the transaction and discard any changes it made so far.
-     * @remarks
-     * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or from a remote client) can be interleaved with those changes.
-     * Note that this is guaranteed by Fluid for any sequence of changes that are submitted synchronously, whether in a transaction or not.
-     * However, using a transaction has the following additional consequences:
-     * - If reverted (e.g. via an "undo" operation), all the changes in the transaction are reverted together.
-     * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.
-     *
-     * Local change events will be emitted for each change as the transaction is being applied.
-     * If the transaction is cancelled and rolled back, a corresponding change event will also be emitted for the rollback.
-     */
-    runTransaction<TNode extends TreeNode>(node: TNode, transaction: (node: TNode) => void | "rollback"): void;
-    /**
-     * Apply one or more edits to the tree as a single atomic unit.
-     * @param tree - The tree which will be edited by the transaction
-     * @param transaction - The function to run as the body of the transaction.
-     * This function is passed the root of the tree.
-     * At any point during the transaction, the function may return the value `"rollback"` to abort the transaction and discard any changes it made so far.
-     * @remarks
-     * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or from a remote client) can be interleaved with those changes.
-     * Note that this is guaranteed by Fluid for any sequence of changes that are submitted synchronously, whether in a transaction or not.
-     * However, using a transaction has the following additional consequences:
-     * - If reverted (e.g. via an "undo" operation), all the changes in the transaction are reverted together.
-     * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.
-     *
-     * Local change events will be emitted for each change as the transaction is being applied.
-     * If the transaction is cancelled and rolled back, a corresponding change event will also be emitted for the rollback.
-     */
-    runTransaction<TView extends TreeView<ImplicitFieldSchema>>(tree: TView, transaction: (root: TView["root"]) => void | "rollback"): void;
-    /**
-     * Check if the subtree defined by `node` contains `other`.
-     *
-     * @returns true if `other` is an inclusive descendant of `node`, and false otherwise.
-     * @remarks
-     * This includes direct and indirect children:
-     * as long as `node` is an ancestor of `other` (occurs in its parentage chain), this returns true, regardless of the number of levels of the tree between.
-     *
-     * `node` is considered to contain itself, so the case where `node === other` returns true.
-     *
-     * This is handy when checking if moving `node` into `other` would create a cycle and thus is invalid.
-     *
-     * This check walks the parents of `other` looking for `node`,
-     * and thus runs in time proportional to the depth of child in the tree.
-     */
-    contains(node: TreeNode, other: TreeNode): boolean;
-}
-
-/**
- * A {@link TreeNode} which implements 'readonly T[]' and the array mutation APIs.
- *
- * @typeParam TAllowedTypes - Schema for types which are allowed as members of this array.
- *
- * @public
- */
-export declare interface TreeArrayNode<TAllowedTypes extends ImplicitAllowedTypes = ImplicitAllowedTypes> extends TreeArrayNodeBase<TreeNodeFromImplicitAllowedTypes<TAllowedTypes>, InsertableTreeNodeFromImplicitAllowedTypes<TAllowedTypes>, TreeArrayNode> {
-}
-
-/**
- * A {@link TreeNode} which implements 'readonly T[]' and the array mutation APIs.
- * @public
- */
-export declare const TreeArrayNode: {
-    /**
-     * Wrap an iterable of items to inserted as consecutive items in a array.
-     * @remarks
-     * The object returned by this function can be inserted into a {@link (TreeArrayNode:interface)}.
-     * Its contents will be inserted consecutively in the corresponding location in the array.
-     * @example
-     * ```ts
-     * array.insertAtEnd(TreeArrayNode.spread(iterable))
-     * ```
-     */
-    spread: <T>(content: Iterable<T>) => IterableTreeArrayContent<T>;
-};
-
-/**
- * A generic array type, used to defined types like {@link (TreeArrayNode:interface)}.
- *
- * @privateRemarks
- * Inlining this into TreeArrayNode causes recursive array use to stop compiling.
- *
- * @public
- */
-export declare interface TreeArrayNodeBase<out T, in TNew, in TMoveFrom> extends ReadonlyArray<T>, TreeNode {
-    /**
-     * Inserts new item(s) at a specified location.
-     * @param index - The index at which to insert `value`.
-     * @param value - The content to insert.
-     * @throws Throws if `index` is not in the range [0, `array.length`).
-     */
-    insertAt(index: number, ...value: (TNew | IterableTreeArrayContent<TNew>)[]): void;
-    /**
-     * Inserts new item(s) at the start of the array.
-     * @param value - The content to insert.
-     */
-    insertAtStart(...value: (TNew | IterableTreeArrayContent<TNew>)[]): void;
-    /**
-     * Inserts new item(s) at the end of the array.
-     * @param value - The content to insert.
-     */
-    insertAtEnd(...value: (TNew | IterableTreeArrayContent<TNew>)[]): void;
-    /**
-     * Removes the item at the specified location.
-     * @param index - The index at which to remove the item.
-     * @throws Throws if `index` is not in the range [0, `array.length`).
-     */
-    removeAt(index: number): void;
-    /**
-     * Removes all items between the specified indices.
-     * @param start - The starting index of the range to remove (inclusive). Defaults to the start of the array.
-     * @param end - The ending index of the range to remove (exclusive).
-     * @throws Throws if `start` is not in the range [0, `array.length`).
-     * @throws Throws if `end` is less than `start`.
-     * If `end` is not supplied or is greater than the length of the array, all items after `start` are removed.
-     */
-    removeRange(start?: number, end?: number): void;
-    /**
-     * Moves the specified item to the start of the array.
-     * @param sourceIndex - The index of the item to move.
-     * @throws Throws if `sourceIndex` is not in the range [0, `array.length`).
-     */
-    moveToStart(sourceIndex: number): void;
-    /**
-     * Moves the specified item to the start of the array.
-     * @param sourceIndex - The index of the item to move.
-     * @param source - The source array to move the item out of.
-     * @throws Throws if `sourceIndex` is not in the range [0, `array.length`).
-     */
-    moveToStart(sourceIndex: number, source: TMoveFrom): void;
-    /**
-     * Moves the specified item to the end of the array.
-     * @param sourceIndex - The index of the item to move.
-     * @throws Throws if `sourceIndex` is not in the range [0, `array.length`).
-     */
-    moveToEnd(sourceIndex: number): void;
-    /**
-     * Moves the specified item to the end of the array.
-     * @param sourceIndex - The index of the item to move.
-     * @param source - The source array to move the item out of.
-     * @throws Throws if `sourceIndex` is not in the range [0, `array.length`).
-     */
-    moveToEnd(sourceIndex: number, source: TMoveFrom): void;
-    /**
-     * Moves the specified item to the desired location in the array.
-     * @param index - The index to move the item to.
-     * This is based on the state of the array before moving the source item.
-     * @param sourceIndex - The index of the item to move.
-     * @throws Throws if any of the input indices are not in the range [0, `array.length`).
-     */
-    moveToIndex(index: number, sourceIndex: number): void;
-    /**
-     * Moves the specified item to the desired location in the array.
-     * @param index - The index to move the item to.
-     * @param sourceIndex - The index of the item to move.
-     * @param source - The source array to move the item out of.
-     * @throws Throws if any of the input indices are not in the range [0, `array.length`).
-     */
-    moveToIndex(index: number, sourceIndex: number, source: TMoveFrom): void;
-    /**
-     * Moves the specified items to the start of the array.
-     * @param sourceStart - The starting index of the range to move (inclusive).
-     * @param sourceEnd - The ending index of the range to move (exclusive)
-     * @throws Throws if either of the input indices are not in the range [0, `array.length`) or if `sourceStart` is greater than `sourceEnd`.
-     */
-    moveRangeToStart(sourceStart: number, sourceEnd: number): void;
-    /**
-     * Moves the specified items to the start of the array.
-     * @param sourceStart - The starting index of the range to move (inclusive).
-     * @param sourceEnd - The ending index of the range to move (exclusive)
-     * @param source - The source array to move items out of.
-     * @throws Throws if the types of any of the items being moved are not allowed in the destination array,
-     * if either of the input indices are not in the range [0, `array.length`) or if `sourceStart` is greater than `sourceEnd`.
-     */
-    moveRangeToStart(sourceStart: number, sourceEnd: number, source: TMoveFrom): void;
-    /**
-     * Moves the specified items to the end of the array.
-     * @param sourceStart - The starting index of the range to move (inclusive).
-     * @param sourceEnd - The ending index of the range to move (exclusive)
-     * @throws Throws if either of the input indices are not in the range [0, `array.length`) or if `sourceStart` is greater than `sourceEnd`.
-     */
-    moveRangeToEnd(sourceStart: number, sourceEnd: number): void;
-    /**
-     * Moves the specified items to the end of the array.
-     * @param sourceStart - The starting index of the range to move (inclusive).
-     * @param sourceEnd - The ending index of the range to move (exclusive)
-     * @param source - The source array to move items out of.
-     * @throws Throws if the types of any of the items being moved are not allowed in the destination array,
-     * if either of the input indices are not in the range [0, `array.length`) or if `sourceStart` is greater than `sourceEnd`.
-     */
-    moveRangeToEnd(sourceStart: number, sourceEnd: number, source: TMoveFrom): void;
-    /**
-     * Moves the specified items to the desired location within the array.
-     * @param index - The index to move the items to.
-     * This is based on the state of the array before moving the source items.
-     * @param sourceStart - The starting index of the range to move (inclusive).
-     * @param sourceEnd - The ending index of the range to move (exclusive)
-     * @throws Throws if any of the input indices are not in the range [0, `array.length`) or if `sourceStart` is greater than `sourceEnd`.
-     */
-    moveRangeToIndex(index: number, sourceStart: number, sourceEnd: number): void;
-    /**
-     * Moves the specified items to the desired location within the array.
-     * @param index - The index to move the items to.
-     * @param sourceStart - The starting index of the range to move (inclusive).
-     * @param sourceEnd - The ending index of the range to move (exclusive)
-     * @param source - The source array to move items out of.
-     * @throws Throws if the types of any of the items being moved are not allowed in the destination array,
-     * if any of the input indices are not in the range [0, `array.length`) or if `sourceStart` is greater than `sourceEnd`.
-     */
-    moveRangeToIndex(index: number, sourceStart: number, sourceEnd: number, source: TMoveFrom): void;
-}
-
-/**
- * A collection of events that can be raised by a {@link TreeNode}.
- *
- * @privateRemarks
- * TODO: add a way to subscribe to a specific field (for nodeChanged and treeChanged).
- * Probably have object node and map node specific APIs for this.
- *
- * TODO: ensure that subscription API for fields aligns with API for subscribing to the root.
- *
- * TODO: add more wider area (avoid needing tons of nodeChanged registration) events for use-cases other than treeChanged.
- * Some ideas:
- *
- * - treeChanged, but with some subtrees/fields/paths excluded
- * - helper to batch several nodeChanged calls to a treeChanged scope
- * - parent change (ex: registration on the parent field for a specific index: maybe allow it for a range. Ex: node event takes optional field and optional index range?)
- * - new content inserted into subtree. Either provide event for this and/or enough info to treeChanged to find and search the new sub-trees.
- * Add separate (non event related) API to efficiently scan tree for given set of types (using low level cursor and schema based filtering)
- * to allow efficiently searching for new content (and initial content) of a given type.
- *
- * @public
- */
-export declare interface TreeChangeEvents {
-    /**
-     * Emitted by a node when a batch of changes is applied to it, where a change is:
-     *
-     * - For an object node, when the value of one of its properties changes (i.e., the property's value is set
-     * to something else, including `undefined`).
-     *
-     * - For an array node, when an element is added, removed, or moved.
-     *
-     * - For a map node, when an entry is added, updated, or removed.
-     *
-     * @remarks
-     * This event is not raised when:
-     *
-     * - Properties of a child node change. Notably, updates to an array node or a map node (like adding or removing
-     * elements/entries) will raise this event on the array/map node itself, but not on the node that contains the
-     * array/map node as one of its properties.
-     *
-     * - The node is moved to a different location in the tree or removed from the tree.
-     * In this case the event is raised on the _parent_ node, not the node itself.
-     *
-     * For remote edits, this event is not guaranteed to occur in the same order or quantity that it did in
-     * the client that made the original edit.
-     * While a batch of edits will as a whole update the tree to the appropriate end state, no guarantees are made about
-     * how many times this event will be raised during any intermediate states.
-     * When it is raised, the tree is guaranteed to be in-schema.
-     *
-     * @privateRemarks
-     * This event occurs whenever the apparent contents of the node instance change, regardless of what caused the change.
-     * For example, it will fire when the local client reassigns a child, when part of a remote edit is applied to the
-     * node, or when the node has to be updated due to resolution of a merge conflict
-     * (for example a previously applied local change might be undone, then reapplied differently or not at all).
-     */
-    nodeChanged(): void;
-    /**
-     * Emitted by a node when something _may_ have changed anywhere in the subtree rooted at it.
-     *
-     * @remarks
-     * This event is guaranteed to be emitted whenever the subtree _has_ changed.
-     * However, it might also be emitted when the subtree has no visible changes compared to before the event firing.
-     *
-     * Consumers of this event have the guarantee that they won't miss any changes, but should also handle the scenario
-     * where the event fires with no visible changes as well.
-     *
-     * This event is not raised when the node itself is moved to a different location in the tree or removed from the tree.
-     * In that case it is raised on the _parent_ node, not the node itself.
-     *
-     * The node itself is part of the subtree, so this event will be emitted even if the only changes are to the properties
-     * of the node itself.
-     *
-     * For remote edits, this event is not guaranteed to occur in the same order or quantity that it did in
-     * the client that made the original edit.
-     * While a batch of edits will as a whole update the tree to the appropriate end state, no guarantees are made about
-     * how many times this event will be raised during any intermediate states.
-     * When it is raised, the tree is guaranteed to be in-schema.
-     */
-    treeChanged(): void;
-}
-
-/**
- * Configuration for how to {@link ITree.schematize|schematize} a tree.
- * @public
- */
-export declare class TreeConfiguration<TSchema extends ImplicitFieldSchema = ImplicitFieldSchema> {
-    readonly schema: TSchema;
-    readonly initialTree: () => InsertableTreeFieldFromImplicitField<TSchema>;
-    /**
-     * @param schema - The schema which the application wants to view the tree with.
-     * @param initialTree - A function that returns the default tree content to initialize the tree with iff the tree is uninitialized
-     * (meaning it does not even have any schema set at all).
-     * If `initialTree` returns any actual node instances, they should be recreated each time `initialTree` runs.
-     * This is because if the config is used a second time any nodes that were not recreated could error since nodes cannot be inserted into the tree multiple times.
-     */
-    constructor(schema: TSchema, initialTree: () => InsertableTreeFieldFromImplicitField<TSchema>);
-}
-
-/**
- * Converts ImplicitFieldSchema to the corresponding tree node's field type.
- * @public
- */
-export declare type TreeFieldFromImplicitField<TSchema extends ImplicitFieldSchema = FieldSchema> = TSchema extends FieldSchema<infer Kind, infer Types> ? ApplyKind<TreeNodeFromImplicitAllowedTypes<Types>, Kind> : TSchema extends ImplicitAllowedTypes ? TreeNodeFromImplicitAllowedTypes<TSchema> : unknown;
-
-/**
- * Value that may be stored as a leaf node.
- * @public
- */
-export declare type TreeLeafValue = number | string | boolean | IFluidHandle | null;
-
-/**
- * A map of string keys to tree objects.
- *
- * @privateRemarks
- * Add support for `clear` once we have established merge semantics for it.
- *
- * @public
- */
-export declare interface TreeMapNode<T extends ImplicitAllowedTypes = ImplicitAllowedTypes> extends ReadonlyMap<string, TreeNodeFromImplicitAllowedTypes<T>>, TreeNode {
-    /**
-     * Adds or updates an entry in the map with a specified `key` and a `value`.
-     *
-     * @param key - The key of the element to add to the map.
-     * @param value - The value of the element to add to the map.
-     *
-     * @remarks
-     * Setting the value at a key to `undefined` is equivalent to calling {@link TreeMapNode.delete} with that key.
-     */
-    set(key: string, value: InsertableTreeNodeFromImplicitAllowedTypes<T> | undefined): void;
-    /**
-     * Removes the specified element from this map by its `key`.
-     *
-     * @remarks
-     * Note: unlike JavaScript's Map API, this method does not return a flag indicating whether or not the value was
-     * deleted.
-     *
-     * @privateRemarks
-     * Regarding the choice to not return a boolean: Since this data structure is distributed in nature, it isn't
-     * possible to tell whether or not the item was deleted as a result of this method call. Returning a "best guess"
-     * is more likely to create issues / promote bad usage patterns than offer useful information.
-     *
-     * @param key - The key of the element to remove from the map.
-     */
-    delete(key: string): void;
-}
-
-/**
- * A non-leaf SharedTree node. Includes objects, arrays, and maps.
- *
- * @remarks
- * Base type which all nodes implement.
- *
- * This can be used as a type to indicate/document values which should be tree nodes.
- * Runtime use of this class object (for example when used with `instanceof` or subclassed), is not supported:
- * it may be replaced with an interface or union in the future.
- * @privateRemarks
- * Future changes may replace this with a branded interface if the runtime oddities related to this are not cleaned up.
- *
- * Currently not all node implications include this in their prototype chain (some hide it with a proxy), and thus cause `instanceof` to fail.
- * This results in the runtime and compile time behavior of `instanceof` differing.
- * TypeScript 5.3 allows altering the compile time behavior of `instanceof`.
- * The runtime behavior can be changed by implementing `Symbol.hasInstance`.
- * One of those approaches could be used to resolve this inconsistency if TreeNode is kept as a class.
- * @public
- */
-export declare abstract class TreeNode implements WithType {
-    /**
-     * This is added to prevent TypeScript from implicitly allowing non-TreeNode types to be used as TreeNodes.
-     * @privateRemarks
-     * This is a JavaScript private field, so is not accessible from outside this class.
-     * This prevents it from having name collisions with object fields.
-     * Since this is private, the type of this field is stripped in the d.ts file.
-     * To get matching type checking within and from outside the package, the least informative type (`unknown`) is used.
-     * To avoid this having any runtime impact, the field is uninitialized.
-     *
-     * Making this field optional results in different type checking within this project than outside of it, since the d.ts file drops the optional aspect of the field.
-     * This is extra confusing since sin ce the tests get in-project typing for intellisense and separate project checking at build time.
-     * To avoid all this mess, this field is required, not optional.
-     *
-     * Another option would be to use a symbol (possibly as a private field).
-     * That approach ran into some strange difficulties causing SchemaFactory to fail to compile, and was not investigated further.
-     *
-     * TODO: This is disabled due to compilation of this project not targeting es2022,
-     * which causes this to polyfill to use of a weak map which has some undesired runtime overhead.
-     * Consider enabling this for stronger typing after targeting es2022.
-     * The [type] symbol here provides a lot of the value this private brand would, but is not all of it:
-     * someone could manually make an object literal with it and pass it off as a node: this private brand would prevent that.
-     * Another option would be to add a protected or private symbol, which would also get the stronger typing.
-     */
-    /**
-     * {@inheritdoc "type"}
-     * @privateRemarks
-     * Subclasses provide more specific strings for this to get strong typing of otherwise type compatible nodes.
-     */
-    abstract get [type](): string;
-}
-
-/**
- * Provides various functions for analyzing {@link TreeNode}s.
- *
- * @privateRemarks
- * Inlining the typing of this interface onto the `Tree` object provides slightly different .d.ts generation,
- * which avoids typescript expanding the type of TreeNodeSchema and thus encountering
- * https://github.com/microsoft/rushstack/issues/1958.
- * @public
- */
-export declare interface TreeNodeApi {
-    /**
-     * The schema information for this node.
-     */
-    schema<T extends TreeNode | TreeLeafValue>(node: T): TreeNodeSchema<string, NodeKind, unknown, T>;
-    /**
-     * Narrow the type of the given value if it satisfies the given schema.
-     * @example
-     * ```ts
-     * if (node.is(myNode, point)) {
-     *     const y = myNode.y; // `myNode` is now known to satisfy the `point` schema and therefore has a `y` coordinate.
-     * }
-     * ```
-     */
-    is<TSchema extends TreeNodeSchema>(value: unknown, schema: TSchema): value is NodeFromSchema<TSchema>;
-    /**
-     * Return the node under which this node resides in the tree (or undefined if this is a root node of the tree).
-     */
-    parent(node: TreeNode): TreeNode | undefined;
-    /**
-     * The key of the given node under its parent.
-     * @remarks
-     * If `node` is an element in a {@link (TreeArrayNode:interface)}, this returns the index of `node` in the array node (a `number`).
-     * Otherwise, this returns the key of the field that it is under (a `string`).
-     */
-    key(node: TreeNode): string | number;
-    /**
-     * Register an event listener on the given node.
-     * @param node - The node whose events should be subscribed to.
-     * @param eventName - Which event to subscribe to.
-     * @param listener - The callback to trigger for the event. The tree can be read during the callback, but it is invalid to modify the tree during this callback.
-     * @returns A callback function which will deregister the event.
-     * This callback should be called only once.
-     */
-    on<K extends keyof TreeChangeEvents>(node: TreeNode, eventName: K, listener: TreeChangeEvents[K]): () => void;
-    /**
-     * Returns the {@link TreeStatus} of the given node.
-     */
-    readonly status: (node: TreeNode) => TreeStatus;
-    /**
-     * If the given node has an identifier specified by a field of kind "identifier" then this returns the compressed form of that identifier.
-     * Otherwise returns undefined.
-     */
-    shortId(node: TreeNode): number | undefined;
-}
-
-/**
- * Type of of tree node for a field of the given schema.
- * @public
- */
-export declare type TreeNodeFromImplicitAllowedTypes<TSchema extends ImplicitAllowedTypes = TreeNodeSchema> = TSchema extends TreeNodeSchema ? NodeFromSchema<TSchema> : TSchema extends AllowedTypes ? NodeFromSchema<FlexListToUnion<TSchema>> : unknown;
-
-/**
- * Schema for a tree node.
- * @typeParam Name - The full (including scope) name/identifier for the schema.
- * @typeParam Kind - Which kind of node this schema is for.
- * @typeParam TNode - API for nodes that use this schema.
- * @typeParam TBuild - Data which can be used to construct an {@link Unhydrated} node of this type.
- * @typeParam Info - Data used when defining this schema.
- * @remarks
- * Captures the schema both as runtime data and compile time type information.
- * @public
- */
-export declare type TreeNodeSchema<Name extends string = string, Kind extends NodeKind = NodeKind, TNode = unknown, TBuild = never, ImplicitlyConstructable extends boolean = boolean, Info = unknown> = TreeNodeSchemaClass<Name, Kind, TNode, TBuild, ImplicitlyConstructable, Info> | TreeNodeSchemaNonClass<Name, Kind, TNode, TBuild, ImplicitlyConstructable, Info>;
-
-/**
- * Tree node schema which is implemented using a class.
- * @remarks
- * Instances of this class are nodes in the tree.
- * This is also a constructor so that it can be subclassed.
- *
- * Using classes in this way allows introducing a named type and a named value at the same time, helping keep the runtime and compile time information together and easy to refer to un a uniform way.
- * Additionally, this works around https://github.com/microsoft/TypeScript/issues/55832 which causes similar patterns with less explicit types to infer "any" in the d.ts file.
- * @public
- */
-export declare interface TreeNodeSchemaClass<out Name extends string = string, out Kind extends NodeKind = NodeKind, out TNode = unknown, in TInsertable = never, out ImplicitlyConstructable extends boolean = boolean, out Info = unknown> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
-    /**
-     * Constructs an {@link Unhydrated} node with this schema.
-     * @remarks
-     * This constructor is also used internally to construct hydrated nodes with a different parameter type.
-     * Therefor overriding this constructor is not type-safe and is not supported.
-     * @sealed
-     */
-    new (data: TInsertable): Unhydrated<TNode>;
-}
-
-/**
- * Data common to all tree node schema.
- * @public
- */
-export declare interface TreeNodeSchemaCore<out Name extends string, out Kind extends NodeKind, out ImplicitlyConstructable extends boolean, out Info = unknown> {
-    readonly identifier: Name;
-    readonly kind: Kind;
-    /**
-     * Data used to define this schema.
-     *
-     * @remarks
-     * The format depends on the kind of node it is for.
-     * For example, the "object" node kind could store the field schema here.
-     */
-    readonly info: Info;
-    /**
-     * When constructing insertable content,
-     * data that could be passed to the node's constructor can be used instead of an {@link Unhydrated} node
-     * iff implicitlyConstructable is true.
-     * @privateRemarks
-     * Currently the logic for traversing insertable content,
-     * both to build trees and to hydrate them does not defer to the schema classes to handle the policy,
-     * so if their constructors differ from what is supported, some cases will not work.
-     * Setting this to false adjusts the insertable types to disallow cases which could be impacted by these inconsistencies.
-     */
-    readonly implicitlyConstructable: ImplicitlyConstructable;
-}
-
-/**
- * Schema which is not a class.
- * @remarks
- * This is used for schema which cannot have their instances constructed using constructors, like leaf schema.
- * @privateRemarks
- * Non-class based schema can have issues with recursive types due to https://github.com/microsoft/TypeScript/issues/55832.
- * @public
- */
-export declare interface TreeNodeSchemaNonClass<out Name extends string = string, out Kind extends NodeKind = NodeKind, out TNode = unknown, in TInsertable = never, out ImplicitlyConstructable extends boolean = boolean, out Info = unknown> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
-    create(data: TInsertable): TNode;
-}
-
-/**
- * A {@link TreeNode} which modules a JavaScript object.
- * @remarks
- * Object nodes consist of a type which specifies which {@link TreeNodeSchema} they use (see {@link TreeNodeApi.schema}), and a collections of fields, each with a distinct `key` and its own {@link FieldSchema} defining what can be placed under that key.
- *
- * All non-empty fields on an object node are exposed as enumerable own properties with string keys.
- * No other own `own` or `enumerable` properties are included on object nodes unless the user of the node manually adds custom session only state.
- * This allows a majority of general purpose JavaScript object processing operations (like `for...in`, `Reflect.ownKeys()` and `Object.entries()`) to enumerate all the children.
- * @public
- */
-export declare type TreeObjectNode<T extends RestrictiveReadonlyRecord<string, ImplicitFieldSchema>, TypeName extends string = string> = TreeNode & ObjectFromSchemaRecord<T> & WithType<TypeName>;
-
-/**
- * Status of the tree that a particular node belongs to.
- * @public
- */
-export declare enum TreeStatus {
-    /**
-     * Is parented under the root field.
-     */
-    InDocument = 0,
-    /**
-     * Is not parented under the root field, but can be added back to the original document tree.
-     */
-    Removed = 1,
-    /**
-     * Is removed and cannot be added back to the original document tree.
-     */
-    Deleted = 2
-}
-
-/**
- * An editable view of a (version control style) branch of a shared tree.
- *
- * This view is always in one of two states:
- * 1. In schema: the stored schema is compatible with the provided view schema. There is no error, and root can be used.
- * 2. Out of schema: the stored schema is incompatible with the provided view schema. There is an error, and root cannot be used.
- *
- * @privateRemarks
- * From an API design perspective, `upgradeSchema` could be merged into `schematize` anb/or `schematize` could return errors explicitly.
- * Such approaches would make it discoverable that out of schema handling may need to be done.
- * Doing that would however complicate trivial "hello world" style example slightly, as well as be a breaking API change.
- * It also seems more complex to handle invalidation with that pattern.
- * Thus this design was chosen at the risk of apps blindly accessing `root` then breaking unexpectedly when the document is incompatible.
- * If this does become a problem,
- * it could be mitigated by adding a `rootOrError` member and deprecating `root` to give users a warning if they might be missing the error checking.
- * @public
- */
-export declare interface TreeView<TSchema extends ImplicitFieldSchema> extends IDisposable {
-    /**
-     * The current root of the tree.
-     *
-     * If in the out of schema state, accessing this will throw.
-     * To handle this case, check `error` before using.
-     *
-     * To get notified about changes to this field (including to it being in an `error` state),
-     * use {@link TreeViewEvents.rootChanged} via `view.events.on("rootChanged", callback)`.
-     */
-    get root(): TreeFieldFromImplicitField<TSchema>;
-    set root(newRoot: InsertableTreeFieldFromImplicitField<TSchema>);
-    /**
-     * Description of the error state, if any.
-     * When this is undefined, the view schema and stored schema are compatible, and `root` can be used.
-     */
-    readonly error?: SchemaIncompatible;
-    /**
-     * When there is an `error` and {@link SchemaIncompatible.canUpgrade} is true,
-     * this can be used to modify the stored schema to make it match the view schema.
-     * This will clear the error state, and allow access to `root`.
-     * @remarks
-     * It is an error to call this when {@link SchemaIncompatible.canUpgrade} is false, and a no-op when not in an `error` state.
-     * When this changes the stored schema, any existing or future clients which were compatible with the old stored schema will get an `error` state when trying to schematize the document.
-     * @privateRemarks
-     * In the future, more upgrade options could be provided here.
-     * Some options that could be added:
-     * - check the actual document contents (not just the schema) and attempt an atomic document update if the data is compatible.
-     * - apply converters and upgrade the document.
-     * - apply converters to lazily to adapt the document to the requested view schema (with optional lazy schema updates or transparent conversions on write).
-     */
-    upgradeSchema(): void;
-    /**
-     * Events for the tree.
-     */
-    readonly events: ISubscribable<TreeViewEvents>;
-}
-
-/**
- * Events for {@link TreeView}.
- * @public
- */
-export declare interface TreeViewEvents {
-    /**
-     * A batch of changes has finished processing and the view has been updated.
-     */
-    afterBatch(): void;
-    /**
-     * {@link TreeView.root} has changed.
-     * This includes going into or out of an `error` state where the root is unavailable due to stored schema changes.
-     * It also includes changes to the field containing the root such as setting or clearing an optional root or changing which node is the root.
-     * This does NOT include changes to the content (fields/children) of the root node: for that case subscribe to events on the root node.
-     */
-    rootChanged(): void;
-    /**
-     * Fired when:
-     * - a local commit is applied outside of a transaction
-     * - a local transaction is committed
-     *
-     * The event is not fired when:
-     * - a local commit is applied within a transaction
-     * - a remote commit is applied
-     *
-     * @param data - information about the commit that was applied
-     * @param getRevertible - a function provided that allows users to get a revertible for the commit that was applied. If not provided,
-     * this commit is not revertible.
-     */
-    commitApplied(data: CommitMetadata, getRevertible?: RevertibleFactory): void;
-}
-
-/**
- * The type of a {@link TreeNode}.
- * For moore information about the type, use `Tree.schema(theNode)` instead.
- * @remarks
- * This symbol mainly exists on nodes to allow TypeScript to provide more accurate type checking.
- * `Tree.is` and `Tree.schema` provide a superset of this information in more friendly ways.
- *
- * This symbol should not manually be added to objects as doing so allows the object to be invalidly used where nodes are expected.
- * Instead construct a real node of the desired type using its constructor.
- * @privateRemarks
- * This prevents non-nodes from being accidentally used as nodes, as well as allows the type checker to distinguish different node types.
- * @public
- */
-export declare const type: unique symbol;
-
-/**
- * Type alias to document which values are un-hydrated.
- *
- * Un-hydrated values are nodes produced from schema's create functions that haven't been inserted into a tree yet.
- *
- * Since un-hydrated nodes become hydrated when inserted, strong typing can't be used to distinguish them.
- * This no-op wrapper is used instead.
- * @public
- */
-export declare type Unhydrated<T> = T;
-
-/**
- * Adds a {@link "type"} field.
- * @public
- */
-export declare interface WithType<TName extends string = string> {
-    /**
-     * {@inheritdoc "type"}
-     */
-    get [type](): TName;
-}
-
-export { }