/*!
 * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
 * Licensed under the MIT License.
 */
import { IContainer } from "@fluidframework/container-definitions";
import { IChannelAttributes, IChannelServices, IFluidDataStoreRuntime } from "@fluidframework/datastore-definitions";
import { ITestObjectProvider, SummaryInfo } from "@fluidframework/test-utils";
import { ISharedTree, ITreeCheckout, SharedTreeFactory, TreeContent, CheckoutEvents, SharedTree, InitializeAndSchematizeConfiguration, SharedTreeContentSnapshot, CheckoutFlexTreeView, TreeCheckout } from "../shared-tree/index.js";
import { FlexFieldSchema, NodeKeyManager, FlexTreeTypedField, ContextuallyTypedNodeData } from "../feature-libraries/index.js";
import { JsonableTree, TreeStoredSchema, UpPath, ChangeFamilyEditor, ChangeFamily, TaggedChange, FieldUpPath, AllowedUpdateType, IEditableForest, DeltaVisitor, DetachedFieldIndex, AnnouncedVisitor, FieldKey, Revertible, RevisionMetadataSource, RevisionInfo, RevisionTag, DeltaFieldChanges, DeltaMark, DeltaFieldMap, DeltaRoot, RevisionTagCodec, DeltaDetachedNodeBuild, DeltaDetachedNodeDestruction } from "../core/index.js";
import { JsonCompatible, Mutable } from "../util/index.js";
import { ICodecFamily, IJsonCodec } from "../codec/index.js";
import { HasListeners, IEmitter, ISubscribable } from "../events/index.js";
import { SharedTreeOptions } from "../shared-tree/sharedTree.js";
import { SchematizingSimpleTreeView } from "../shared-tree/schematizingTreeView.js";
import { ImplicitFieldSchema, TreeConfiguration } from "../simple-tree/index.js";
/**
 * A {@link IJsonCodec} implementation which fails on encode and decode.
 *
 * Useful for testing codecs which compose over other codecs (in cases where the "inner" codec should never be called)
 */
export declare const failCodec: IJsonCodec<any, any, any, any>;
/**
 * Recursively freezes the given object.
 *
 * WARNING: this function mutates Map and Set instances to override their mutating methods in order to ensure that the
 * state of those instances cannot be changed. This is necessary because calling `Object.freeze` on a Set or Map does
 * not prevent it from being mutated.
 *
 * @param object - The object to freeze.
 */
export declare function deepFreeze<T>(object: T): void;
/**
 * Manages the creation, connection, and retrieval of SharedTrees and related components for ease of testing.
 * Satisfies the {@link ITestObjectProvider} interface.
 */
export type ITestTreeProvider = TestTreeProvider & ITestObjectProvider;
export declare enum SummarizeType {
    onDemand = 0,
    automatic = 1,
    disabled = 2
}
/**
 * A test helper class that manages the creation, connection and retrieval of SharedTrees. Instances of this
 * class are created via {@link TestTreeProvider.create} and satisfy the {@link ITestObjectProvider} interface.
 */
export declare class TestTreeProvider {
    private static readonly treeId;
    private readonly provider;
    private readonly _trees;
    private readonly _containers;
    private readonly summarizer?;
    get trees(): readonly SharedTree[];
    get containers(): readonly IContainer[];
    /**
     * Create a new {@link TestTreeProvider} with a number of trees pre-initialized.
     * @param trees - the number of trees to initialize this provider with. This is the same as calling
     * {@link create} followed by {@link createTree} _trees_ times.
     * @param summarizeType - enum to manually, automatically, or disable summarization
     * @param factory - The factory to use for creating and loading trees. See {@link SharedTreeTestFactory}.
     *
     * @example
     *
     * ```typescript
     * const provider = await TestTreeProvider.create(2);
     * assert(provider.trees[0].isAttached());
     * assert(provider.trees[1].isAttached());
     * await trees.ensureSynchronized();
     * ```
     */
    static create(trees?: number, summarizeType?: SummarizeType, factory?: SharedTreeFactory): Promise<ITestTreeProvider>;
    /**
     * Create and initialize a new {@link ISharedTree} that is connected to all other trees from this provider.
     * @returns the tree that was created. For convenience, the tree can also be accessed via `this[i]` where
     * _i_ is the index of the tree in order of creation.
     */
    createTree(): Promise<SharedTree>;
    /**
     * Give this {@link TestTreeProvider} the ability to summarize on demand during a test by creating a summarizer
     * client for the container at the given index.  This can only be called when the summarizeOnDemand parameter
     * was set to true when calling the create() method.
     * @returns void after a summary has been resolved. May be called multiple times.
     */
    summarize(): Promise<SummaryInfo>;
    [Symbol.iterator](): IterableIterator<ISharedTree>;
    private constructor();
}
export interface ConnectionSetter {
    readonly setConnected: (connectionState: boolean) => void;
}
export type SharedTreeWithConnectionStateSetter = SharedTree & ConnectionSetter;
/**
 * A test helper class that creates one or more SharedTrees connected to mock services.
 */
export declare class TestTreeProviderLite {
    private readonly factory;
    private static readonly treeId;
    private readonly runtimeFactory;
    readonly trees: readonly SharedTreeWithConnectionStateSetter[];
    /**
     * Create a new {@link TestTreeProviderLite} with a number of trees pre-initialized.
     * @param trees - the number of trees created by this provider.
     * @param factory - an optional factory to use for creating and loading trees. See {@link SharedTreeTestFactory}.
     * @param useDeterministicSessionIds - Whether or not to deterministically generate session ids
     * @example
     *
     * ```typescript
     * const provider = new TestTreeProviderLite(2);
     * assert(provider.trees[0].isAttached());
     * assert(provider.trees[1].isAttached());
     * provider.processMessages();
     * ```
     */
    constructor(trees?: number, factory?: SharedTreeFactory, useDeterministicSessionIds?: boolean);
    processMessages(count?: number): void;
    get minimumSequenceNumber(): number;
    get sequenceNumber(): number;
}
/**
 * Run a custom "spy function" every time the given method is invoked.
 * @param methodClass - the class that has the method
 * @param methodName - the name of the method
 * @param spy - the spy function to run alongside the method
 * @returns a function which will remove the spy function when invoked. Should be called exactly once
 * after the spy is no longer needed.
 */
export declare function spyOnMethod(methodClass: Function, methodName: string, spy: () => void): () => void;
/**
 * @returns `true` iff the given delta has a visible impact on the document tree.
 */
export declare function isDeltaVisible(delta: DeltaFieldChanges): boolean;
/**
 * Assert two MarkList are equal, handling cursors.
 */
export declare function assertFieldChangesEqual(a: DeltaFieldChanges, b: DeltaFieldChanges): void;
/**
 * Assert two MarkList are equal, handling cursors.
 */
export declare function assertMarkListEqual(a: readonly DeltaMark[], b: readonly DeltaMark[]): void;
/**
 * Assert two Delta are equal, handling cursors.
 */
export declare function assertDeltaFieldMapEqual(a: DeltaFieldMap, b: DeltaFieldMap): void;
/**
 * Assert two Delta are equal, handling cursors.
 */
export declare function assertDeltaEqual(a: DeltaRoot, b: DeltaRoot): void;
/**
 * A test helper that allows custom code to be injected when a tree is created/loaded.
 */
export declare class SharedTreeTestFactory extends SharedTreeFactory {
    private readonly onCreate;
    private readonly onLoad?;
    /**
     * @param onCreate - Called once for each created tree (not called for trees loaded from summaries).
     * @param onLoad - Called once for each tree that is loaded from a summary.
     */
    constructor(onCreate: (tree: SharedTree) => void, onLoad?: ((tree: SharedTree) => void) | undefined);
    load(runtime: IFluidDataStoreRuntime, id: string, services: IChannelServices, channelAttributes: Readonly<IChannelAttributes>): Promise<SharedTree>;
    create(runtime: IFluidDataStoreRuntime, id: string): SharedTree;
}
export declare function validateTree(tree: ITreeCheckout, expected: JsonableTree[]): void;
export declare function checkRemovedRootsAreSynchronized(trees: readonly ITreeCheckout[]): void;
/**
 * This does NOT check that the trees have the same edits, same edit manager state or anything like that.
 * This ONLY checks if the content of the forest of the main branch of the trees match.
 */
export declare function validateTreeConsistency(treeA: ISharedTree, treeB: ISharedTree): void;
export declare function validateTreeContent(tree: ITreeCheckout, content: TreeContent): void;
export declare function expectSchemaEqual(a: TreeStoredSchema, b: TreeStoredSchema, idDifferentiator?: string | undefined): void;
export declare function validateViewConsistency(treeA: ITreeCheckout, treeB: ITreeCheckout, idDifferentiator?: string | undefined): void;
export declare function validateSnapshotConsistency(treeA: SharedTreeContentSnapshot, treeB: SharedTreeContentSnapshot, idDifferentiator?: string | undefined): void;
export declare function checkoutWithContent(content: TreeContent, args?: {
    events?: ISubscribable<CheckoutEvents> & IEmitter<CheckoutEvents> & HasListeners<CheckoutEvents>;
}): TreeCheckout;
export declare function flexTreeViewWithContent<TRoot extends FlexFieldSchema>(content: TreeContent<TRoot>, args?: {
    events?: ISubscribable<CheckoutEvents> & IEmitter<CheckoutEvents> & HasListeners<CheckoutEvents>;
    nodeKeyManager?: NodeKeyManager;
    nodeKeyFieldKey?: FieldKey;
}): CheckoutFlexTreeView<TRoot>;
export declare function forestWithContent(content: TreeContent): IEditableForest;
export declare function flexTreeWithContent<TRoot extends FlexFieldSchema>(content: TreeContent<TRoot>, args?: {
    nodeKeyManager?: NodeKeyManager;
    nodeKeyFieldKey?: FieldKey;
    events?: ISubscribable<CheckoutEvents> & IEmitter<CheckoutEvents> & HasListeners<CheckoutEvents>;
}): FlexTreeTypedField<TRoot>;
export declare const jsonSequenceRootSchema: import("../feature-libraries/index.js").FlexTreeSchema<FlexFieldSchema<import("../feature-libraries/index.js").Sequence, readonly [() => import("../feature-libraries/index.js").FlexMapNodeSchema<"com.fluidframework.json.object", FlexFieldSchema<import("../feature-libraries/index.js").Optional, readonly [any, () => import("../feature-libraries/index.js").FlexFieldNodeSchema<"com.fluidframework.json.array", FlexFieldSchema<import("../feature-libraries/index.js").Sequence, readonly [any, any, import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.number", import("../core/index.js").ValueSchema.Number>, import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.boolean", import("../core/index.js").ValueSchema.Boolean>, import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.string", import("../core/index.js").ValueSchema.String>, import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.null", import("../core/index.js").ValueSchema.Null>]>>, import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.number", import("../core/index.js").ValueSchema.Number>, import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.boolean", import("../core/index.js").ValueSchema.Boolean>, import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.string", import("../core/index.js").ValueSchema.String>, import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.null", import("../core/index.js").ValueSchema.Null>]>>, () => import("../feature-libraries/index.js").FlexFieldNodeSchema<"com.fluidframework.json.array", FlexFieldSchema<import("../feature-libraries/index.js").Sequence, readonly [() => import("../feature-libraries/index.js").FlexMapNodeSchema<"com.fluidframework.json.object", FlexFieldSchema<import("../feature-libraries/index.js").Optional, readonly [any, any, import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.number", import("../core/index.js").ValueSchema.Number>, import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.boolean", import("../core/index.js").ValueSchema.Boolean>, import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.string", import("../core/index.js").ValueSchema.String>, import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.null", import("../core/index.js").ValueSchema.Null>]>>, any, import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.number", import("../core/index.js").ValueSchema.Number>, import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.boolean", import("../core/index.js").ValueSchema.Boolean>, import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.string", import("../core/index.js").ValueSchema.String>, import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.null", import("../core/index.js").ValueSchema.Null>]>>, import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.number", import("../core/index.js").ValueSchema.Number>, import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.boolean", import("../core/index.js").ValueSchema.Boolean>, import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.string", import("../core/index.js").ValueSchema.String>, import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.null", import("../core/index.js").ValueSchema.Null>]>>;
export declare const stringSequenceRootSchema: import("../feature-libraries/index.js").FlexTreeSchema<FlexFieldSchema<import("../feature-libraries/index.js").Sequence, readonly [import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.string", import("../core/index.js").ValueSchema.String>]>>;
export declare const numberSequenceRootSchema: import("../feature-libraries/index.js").FlexTreeSchema<FlexFieldSchema<import("../feature-libraries/index.js").Sequence, readonly [import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.number", import("../core/index.js").ValueSchema.Number>]>>;
export declare const emptyJsonSequenceConfig: {
    schema: import("../feature-libraries/index.js").FlexTreeSchema<FlexFieldSchema<import("../feature-libraries/index.js").Sequence, readonly [() => import("../feature-libraries/index.js").FlexMapNodeSchema<"com.fluidframework.json.object", FlexFieldSchema<import("../feature-libraries/index.js").Optional, readonly [any, () => import("../feature-libraries/index.js").FlexFieldNodeSchema<"com.fluidframework.json.array", FlexFieldSchema<import("../feature-libraries/index.js").Sequence, readonly [any, any, import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.number", import("../core/index.js").ValueSchema.Number>, import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.boolean", import("../core/index.js").ValueSchema.Boolean>, import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.string", import("../core/index.js").ValueSchema.String>, import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.null", import("../core/index.js").ValueSchema.Null>]>>, import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.number", import("../core/index.js").ValueSchema.Number>, import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.boolean", import("../core/index.js").ValueSchema.Boolean>, import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.string", import("../core/index.js").ValueSchema.String>, import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.null", import("../core/index.js").ValueSchema.Null>]>>, () => import("../feature-libraries/index.js").FlexFieldNodeSchema<"com.fluidframework.json.array", FlexFieldSchema<import("../feature-libraries/index.js").Sequence, readonly [() => import("../feature-libraries/index.js").FlexMapNodeSchema<"com.fluidframework.json.object", FlexFieldSchema<import("../feature-libraries/index.js").Optional, readonly [any, any, import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.number", import("../core/index.js").ValueSchema.Number>, import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.boolean", import("../core/index.js").ValueSchema.Boolean>, import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.string", import("../core/index.js").ValueSchema.String>, import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.null", import("../core/index.js").ValueSchema.Null>]>>, any, import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.number", import("../core/index.js").ValueSchema.Number>, import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.boolean", import("../core/index.js").ValueSchema.Boolean>, import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.string", import("../core/index.js").ValueSchema.String>, import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.null", import("../core/index.js").ValueSchema.Null>]>>, import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.number", import("../core/index.js").ValueSchema.Number>, import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.boolean", import("../core/index.js").ValueSchema.Boolean>, import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.string", import("../core/index.js").ValueSchema.String>, import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.null", import("../core/index.js").ValueSchema.Null>]>>;
    allowedSchemaModifications: AllowedUpdateType.Initialize;
    initialTree: never[];
};
export declare const emptyStringSequenceConfig: {
    schema: import("../feature-libraries/index.js").FlexTreeSchema<FlexFieldSchema<import("../feature-libraries/index.js").Sequence, readonly [import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.string", import("../core/index.js").ValueSchema.String>]>>;
    allowedSchemaModifications: AllowedUpdateType.Initialize;
    initialTree: never[];
};
/**
 * If the root is an array, this creates a sequence field at the root instead of a JSON array node.
 *
 * If the root is not an array, a single item root sequence is used.
 */
export declare function makeTreeFromJson(json: JsonCompatible[] | JsonCompatible): ITreeCheckout;
export declare function toJsonableTree(tree: ITreeCheckout): JsonableTree[];
/**
 * Assumes `tree` is in the json domain and returns its content as a json compatible object.
 */
export declare function toJsonTree(tree: ITreeCheckout): JsonCompatible[];
/**
 * Helper function to insert node at a given index.
 *
 * TODO: delete once the JSON editing API is ready for use.
 *
 * @param tree - The tree on which to perform the insert.
 * @param index - The index in the root field at which to insert.
 * @param value - The value of the inserted nodes.
 */
export declare function insert(tree: ITreeCheckout, index: number, ...values: ContextuallyTypedNodeData[]): void;
export declare function remove(tree: ITreeCheckout, index: number, count: number): void;
export declare function expectJsonTree(actual: ITreeCheckout | ITreeCheckout[], expected: JsonCompatible[], expectRemovedRootsAreSynchronized?: boolean): void;
export declare function expectEqualPaths(path: UpPath | undefined, expectedPath: UpPath | undefined): void;
export declare function expectEqualFieldPaths(path: FieldUpPath, expectedPath: FieldUpPath): void;
export declare const mockIntoDelta: (delta: DeltaRoot) => DeltaRoot<import("../core/index.js").ITreeCursorSynchronous>;
export interface EncodingTestData<TDecoded, TEncoded, TContext = void> {
    /**
     * Contains test cases which should round-trip successfully through all persisted formats.
     */
    successes: TContext extends void ? [name: string, data: TDecoded][] : [name: string, data: TDecoded, context: TContext][];
    /**
     * Contains malformed encoded data which a particular version's codec should fail to decode.
     */
    failures?: {
        [version: string]: TContext extends void ? [name: string, data: TEncoded][] : [name: string, data: TEncoded, context: TContext][];
    };
}
/**
 * Constructs a basic suite of round-trip tests for all versions of a codec family.
 * This helper should generally be wrapped in a `describe` block.
 *
 * Encoded data for JSON codecs within `family` will be validated using `typeboxValidator`.
 *
 * @privateRemarks It is generally not valid to compare the decoded formats with assert.deepEqual,
 * but since these round trip tests start with the decoded format (not the encoded format),
 * they require assert.deepEqual to be a valid comparison.
 * This can be problematic for some cases (for example edits containing cursors).
 *
 * TODO:
 * - Consider extending this to allow testing in a way where encoded formats (which can safely use deepEqual) are compared.
 * - Consider adding a custom comparison function for non-encoded data.
 * - Consider adding a way to test that specific values have specific encodings.
 * Maybe generalize test cases to each have an optional encoded and optional decoded form (require at least one), for example via:
 * `{name: string, encoded?: JsonCompatibleReadOnly, decoded?: TDecoded}`.
 */
export declare function makeEncodingTestSuite<TDecoded, TEncoded, TContext>(family: ICodecFamily<TDecoded, TContext>, encodingTestData: EncodingTestData<TDecoded, TEncoded, TContext>, assertEquivalent?: (a: TDecoded, b: TDecoded) => void): void;
/**
 * Creates a change receiver function for passing to an `EditBuilder` which records the changes
 * applied via that editor and allows them to be queried via a function.
 * @param _changeFamily - this optional change family allows for type inference of `TChange` for
 * convenience, but is otherwise unused.
 * @returns a change receiver function and a function that will return all changes received
 */
export declare function testChangeReceiver<TChange>(_changeFamily?: ChangeFamily<ChangeFamilyEditor, TChange>): [
    changeReceiver: Parameters<ChangeFamily<ChangeFamilyEditor, TChange>["buildEditor"]>[0],
    getChanges: () => readonly TChange[]
];
export declare function defaultRevisionMetadataFromChanges(changes: readonly TaggedChange<unknown>[]): RevisionMetadataSource;
export declare function defaultRevInfosFromChanges(changes: readonly TaggedChange<unknown>[]): RevisionInfo[];
export declare function applyTestDelta(delta: DeltaFieldMap, deltaProcessor: {
    acquireVisitor: () => DeltaVisitor;
}, detachedFieldIndex?: DetachedFieldIndex, build?: readonly DeltaDetachedNodeBuild[], destroy?: readonly DeltaDetachedNodeDestruction[]): void;
export declare function announceTestDelta(delta: DeltaFieldMap, deltaProcessor: {
    acquireVisitor: () => DeltaVisitor & AnnouncedVisitor;
}, detachedFieldIndex?: DetachedFieldIndex, build?: readonly DeltaDetachedNodeBuild[], destroy?: readonly DeltaDetachedNodeDestruction[]): void;
export declare function rootFromDeltaFieldMap(delta: DeltaFieldMap, build?: readonly DeltaDetachedNodeBuild[], destroy?: readonly DeltaDetachedNodeDestruction[]): Mutable<DeltaRoot>;
export declare function createTestUndoRedoStacks(events: ISubscribable<{
    newRevertible(type: Revertible): void;
    revertibleDisposed(revertible: Revertible): void;
}>): {
    undoStack: Revertible[];
    redoStack: Revertible[];
    unsubscribe: () => void;
};
export declare const testIdCompressor: import("@fluidframework/id-compressor").IIdCompressor & import("@fluidframework/id-compressor").IIdCompressorCore;
export declare function mintRevisionTag(): RevisionTag;
export declare const testRevisionTagCodec: RevisionTagCodec;
/**
 * Like {@link ITree.schematize}, but uses the flex-tree schema system and exposes the tree as a flex-tree.
 */
export declare function schematizeFlexTree<TRoot extends FlexFieldSchema>(tree: SharedTree, config: InitializeAndSchematizeConfiguration<TRoot>, onDispose?: () => void, nodeKeyManager?: NodeKeyManager, nodeKeyFieldKey?: FieldKey): CheckoutFlexTreeView<TRoot>;
/**
 * Simple non-factory based wrapper around `new SharedTree` with test appropriate defaults.
 *
 * See TestTreeProvider, TestTreeProviderLite and SharedTreeFactory for other ways to build trees.
 *
 * If what is needed is a view, see options to create one without making a SharedTree instance.
 */
export declare function treeTestFactory(options?: {
    id?: string;
    runtime?: IFluidDataStoreRuntime;
    attributes?: IChannelAttributes;
    options?: SharedTreeOptions;
    telemetryContextPrefix?: string;
}): SharedTree;
/**
 * Given the TreeConfiguration, returns a view.
 *
 * This works a much like the actual package public API as possible, while avoiding the actual SharedTree object.
 * This should allow realistic (app like testing) of all the simple-tree APIs.
 */
export declare function getView<TSchema extends ImplicitFieldSchema>(config: TreeConfiguration<TSchema>): SchematizingSimpleTreeView<TSchema>;
//# sourceMappingURL=utils.d.ts.map