@firebase/database 1.0.9 → 1.0.10

package/dist/node-esm/src/core/view/EventRegistration.d.ts

@@ -1,87 +1,87 @@
-/**
- * @license
- * Copyright 2017 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { DataSnapshot } from '../../api/Reference_impl';
-import { Repo } from '../Repo';
-import { Path } from '../util/Path';
-import { Change } from './Change';
-import { CancelEvent, Event } from './Event';
-import { QueryParams } from './QueryParams';
-/**
- * A user callback. Callbacks issues from the Legacy SDK maintain references
- * to the original user-issued callbacks, which allows equality
- * comparison by reference even though this callbacks are wrapped before
- * they can be passed to the firebase@exp SDK.
- *
- * @internal
- */
-export interface UserCallback {
-    (dataSnapshot: DataSnapshot, previousChildName?: string | null): unknown;
-    userCallback?: unknown;
-    context?: object | null;
-}
-/**
- * A wrapper class that converts events from the database@exp SDK to the legacy
- * Database SDK. Events are not converted directly as event registration relies
- * on reference comparison of the original user callback (see `matches()`) and
- * relies on equality of the legacy SDK's `context` object.
- */
-export declare class CallbackContext {
-    private readonly snapshotCallback;
-    private readonly cancelCallback?;
-    constructor(snapshotCallback: UserCallback, cancelCallback?: (error: Error) => unknown);
-    onValue(expDataSnapshot: DataSnapshot, previousChildName?: string | null): void;
-    onCancel(error: Error): void;
-    get hasCancelCallback(): boolean;
-    matches(other: CallbackContext): boolean;
-}
-export interface QueryContext {
-    readonly _queryIdentifier: string;
-    readonly _queryObject: object;
-    readonly _repo: Repo;
-    readonly _path: Path;
-    readonly _queryParams: QueryParams;
-}
-/**
- * An EventRegistration is basically an event type ('value', 'child_added', etc.) and a callback
- * to be notified of that type of event.
- *
- * That said, it can also contain a cancel callback to be notified if the event is canceled.  And
- * currently, this code is organized around the idea that you would register multiple child_ callbacks
- * together, as a single EventRegistration.  Though currently we don't do that.
- */
-export interface EventRegistration {
-    /**
-     * True if this container has a callback to trigger for this event type
-     */
-    respondsTo(eventType: string): boolean;
-    createEvent(change: Change, query: QueryContext): Event;
-    /**
-     * Given event data, return a function to trigger the user's callback
-     */
-    getEventRunner(eventData: Event): () => void;
-    createCancelEvent(error: Error, path: Path): CancelEvent | null;
-    matches(other: EventRegistration): boolean;
-    /**
-     * False basically means this is a "dummy" callback container being used as a sentinel
-     * to remove all callback containers of a particular type.  (e.g. if the user does
-     * ref.off('value') without specifying a specific callback).
-     *
-     * (TODO: Rework this, since it's hacky)
-     *
-     */
-    hasAnyCallback(): boolean;
-}
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { DataSnapshot } from '../../api/Reference_impl';
+import { Repo } from '../Repo';
+import { Path } from '../util/Path';
+import { Change } from './Change';
+import { CancelEvent, Event } from './Event';
+import { QueryParams } from './QueryParams';
+/**
+ * A user callback. Callbacks issues from the Legacy SDK maintain references
+ * to the original user-issued callbacks, which allows equality
+ * comparison by reference even though this callbacks are wrapped before
+ * they can be passed to the firebase@exp SDK.
+ *
+ * @internal
+ */
+export interface UserCallback {
+    (dataSnapshot: DataSnapshot, previousChildName?: string | null): unknown;
+    userCallback?: unknown;
+    context?: object | null;
+}
+/**
+ * A wrapper class that converts events from the database@exp SDK to the legacy
+ * Database SDK. Events are not converted directly as event registration relies
+ * on reference comparison of the original user callback (see `matches()`) and
+ * relies on equality of the legacy SDK's `context` object.
+ */
+export declare class CallbackContext {
+    private readonly snapshotCallback;
+    private readonly cancelCallback?;
+    constructor(snapshotCallback: UserCallback, cancelCallback?: (error: Error) => unknown);
+    onValue(expDataSnapshot: DataSnapshot, previousChildName?: string | null): void;
+    onCancel(error: Error): void;
+    get hasCancelCallback(): boolean;
+    matches(other: CallbackContext): boolean;
+}
+export interface QueryContext {
+    readonly _queryIdentifier: string;
+    readonly _queryObject: object;
+    readonly _repo: Repo;
+    readonly _path: Path;
+    readonly _queryParams: QueryParams;
+}
+/**
+ * An EventRegistration is basically an event type ('value', 'child_added', etc.) and a callback
+ * to be notified of that type of event.
+ *
+ * That said, it can also contain a cancel callback to be notified if the event is canceled.  And
+ * currently, this code is organized around the idea that you would register multiple child_ callbacks
+ * together, as a single EventRegistration.  Though currently we don't do that.
+ */
+export interface EventRegistration {
+    /**
+     * True if this container has a callback to trigger for this event type
+     */
+    respondsTo(eventType: string): boolean;
+    createEvent(change: Change, query: QueryContext): Event;
+    /**
+     * Given event data, return a function to trigger the user's callback
+     */
+    getEventRunner(eventData: Event): () => void;
+    createCancelEvent(error: Error, path: Path): CancelEvent | null;
+    matches(other: EventRegistration): boolean;
+    /**
+     * False basically means this is a "dummy" callback container being used as a sentinel
+     * to remove all callback containers of a particular type.  (e.g. if the user does
+     * ref.off('value') without specifying a specific callback).
+     *
+     * (TODO: Rework this, since it's hacky)
+     *
+     */
+    hasAnyCallback(): boolean;
+}

package/dist/node-esm/src/core/view/QueryParams.d.ts

@@ -1,95 +1,95 @@
-/**
- * @license
- * Copyright 2017 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { Index } from '../snap/indexes/Index';
-import { PriorityIndex } from '../snap/indexes/PriorityIndex';
-import { NodeFilter } from './filter/NodeFilter';
-/**
- * This class is an immutable-from-the-public-api struct containing a set of query parameters defining a
- * range to be returned for a particular location. It is assumed that validation of parameters is done at the
- * user-facing API level, so it is not done here.
- *
- * @internal
- */
-export declare class QueryParams {
-    limitSet_: boolean;
-    startSet_: boolean;
-    startNameSet_: boolean;
-    startAfterSet_: boolean;
-    endSet_: boolean;
-    endNameSet_: boolean;
-    endBeforeSet_: boolean;
-    limit_: number;
-    viewFrom_: string;
-    indexStartValue_: unknown | null;
-    indexStartName_: string;
-    indexEndValue_: unknown | null;
-    indexEndName_: string;
-    index_: PriorityIndex;
-    hasStart(): boolean;
-    /**
-     * @returns True if it would return from left.
-     */
-    isViewFromLeft(): boolean;
-    /**
-     * Only valid to call if hasStart() returns true
-     */
-    getIndexStartValue(): unknown;
-    /**
-     * Only valid to call if hasStart() returns true.
-     * Returns the starting key name for the range defined by these query parameters
-     */
-    getIndexStartName(): string;
-    hasEnd(): boolean;
-    /**
-     * Only valid to call if hasEnd() returns true.
-     */
-    getIndexEndValue(): unknown;
-    /**
-     * Only valid to call if hasEnd() returns true.
-     * Returns the end key name for the range defined by these query parameters
-     */
-    getIndexEndName(): string;
-    hasLimit(): boolean;
-    /**
-     * @returns True if a limit has been set and it has been explicitly anchored
-     */
-    hasAnchoredLimit(): boolean;
-    /**
-     * Only valid to call if hasLimit() returns true
-     */
-    getLimit(): number;
-    getIndex(): Index;
-    loadsAllData(): boolean;
-    isDefault(): boolean;
-    copy(): QueryParams;
-}
-export declare function queryParamsGetNodeFilter(queryParams: QueryParams): NodeFilter;
-export declare function queryParamsLimit(queryParams: QueryParams, newLimit: number): QueryParams;
-export declare function queryParamsLimitToFirst(queryParams: QueryParams, newLimit: number): QueryParams;
-export declare function queryParamsLimitToLast(queryParams: QueryParams, newLimit: number): QueryParams;
-export declare function queryParamsStartAt(queryParams: QueryParams, indexValue: unknown, key?: string | null): QueryParams;
-export declare function queryParamsStartAfter(queryParams: QueryParams, indexValue: unknown, key?: string | null): QueryParams;
-export declare function queryParamsEndAt(queryParams: QueryParams, indexValue: unknown, key?: string | null): QueryParams;
-export declare function queryParamsEndBefore(queryParams: QueryParams, indexValue: unknown, key?: string | null): QueryParams;
-export declare function queryParamsOrderBy(queryParams: QueryParams, index: Index): QueryParams;
-/**
- * Returns a set of REST query string parameters representing this query.
- *
- * @returns query string parameters
- */
-export declare function queryParamsToRestQueryStringParameters(queryParams: QueryParams): Record<string, string | number>;
-export declare function queryParamsGetQueryObject(queryParams: QueryParams): Record<string, unknown>;
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Index } from '../snap/indexes/Index';
+import { PriorityIndex } from '../snap/indexes/PriorityIndex';
+import { NodeFilter } from './filter/NodeFilter';
+/**
+ * This class is an immutable-from-the-public-api struct containing a set of query parameters defining a
+ * range to be returned for a particular location. It is assumed that validation of parameters is done at the
+ * user-facing API level, so it is not done here.
+ *
+ * @internal
+ */
+export declare class QueryParams {
+    limitSet_: boolean;
+    startSet_: boolean;
+    startNameSet_: boolean;
+    startAfterSet_: boolean;
+    endSet_: boolean;
+    endNameSet_: boolean;
+    endBeforeSet_: boolean;
+    limit_: number;
+    viewFrom_: string;
+    indexStartValue_: unknown | null;
+    indexStartName_: string;
+    indexEndValue_: unknown | null;
+    indexEndName_: string;
+    index_: PriorityIndex;
+    hasStart(): boolean;
+    /**
+     * @returns True if it would return from left.
+     */
+    isViewFromLeft(): boolean;
+    /**
+     * Only valid to call if hasStart() returns true
+     */
+    getIndexStartValue(): unknown;
+    /**
+     * Only valid to call if hasStart() returns true.
+     * Returns the starting key name for the range defined by these query parameters
+     */
+    getIndexStartName(): string;
+    hasEnd(): boolean;
+    /**
+     * Only valid to call if hasEnd() returns true.
+     */
+    getIndexEndValue(): unknown;
+    /**
+     * Only valid to call if hasEnd() returns true.
+     * Returns the end key name for the range defined by these query parameters
+     */
+    getIndexEndName(): string;
+    hasLimit(): boolean;
+    /**
+     * @returns True if a limit has been set and it has been explicitly anchored
+     */
+    hasAnchoredLimit(): boolean;
+    /**
+     * Only valid to call if hasLimit() returns true
+     */
+    getLimit(): number;
+    getIndex(): Index;
+    loadsAllData(): boolean;
+    isDefault(): boolean;
+    copy(): QueryParams;
+}
+export declare function queryParamsGetNodeFilter(queryParams: QueryParams): NodeFilter;
+export declare function queryParamsLimit(queryParams: QueryParams, newLimit: number): QueryParams;
+export declare function queryParamsLimitToFirst(queryParams: QueryParams, newLimit: number): QueryParams;
+export declare function queryParamsLimitToLast(queryParams: QueryParams, newLimit: number): QueryParams;
+export declare function queryParamsStartAt(queryParams: QueryParams, indexValue: unknown, key?: string | null): QueryParams;
+export declare function queryParamsStartAfter(queryParams: QueryParams, indexValue: unknown, key?: string | null): QueryParams;
+export declare function queryParamsEndAt(queryParams: QueryParams, indexValue: unknown, key?: string | null): QueryParams;
+export declare function queryParamsEndBefore(queryParams: QueryParams, indexValue: unknown, key?: string | null): QueryParams;
+export declare function queryParamsOrderBy(queryParams: QueryParams, index: Index): QueryParams;
+/**
+ * Returns a set of REST query string parameters representing this query.
+ *
+ * @returns query string parameters
+ */
+export declare function queryParamsToRestQueryStringParameters(queryParams: QueryParams): Record<string, string | number>;
+export declare function queryParamsGetQueryObject(queryParams: QueryParams): Record<string, unknown>;

package/dist/node-esm/src/core/view/View.d.ts

@@ -1,59 +1,59 @@
-/**
- * @license
- * Copyright 2017 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { Operation } from '../operation/Operation';
-import { Node } from '../snap/Node';
-import { Path } from '../util/Path';
-import { WriteTreeRef } from '../WriteTree';
-import { Event } from './Event';
-import { EventGenerator } from './EventGenerator';
-import { EventRegistration, QueryContext } from './EventRegistration';
-import { ViewCache } from './ViewCache';
-import { ViewProcessor } from './ViewProcessor';
-/**
- * A view represents a specific location and query that has 1 or more event registrations.
- *
- * It does several things:
- *  - Maintains the list of event registrations for this location/query.
- *  - Maintains a cache of the data visible for this location/query.
- *  - Applies new operations (via applyOperation), updates the cache, and based on the event
- *    registrations returns the set of events to be raised.
- */
-export declare class View {
-    private query_;
-    processor_: ViewProcessor;
-    viewCache_: ViewCache;
-    eventRegistrations_: EventRegistration[];
-    eventGenerator_: EventGenerator;
-    constructor(query_: QueryContext, initialViewCache: ViewCache);
-    get query(): QueryContext;
-}
-export declare function viewGetServerCache(view: View): Node | null;
-export declare function viewGetCompleteNode(view: View): Node | null;
-export declare function viewGetCompleteServerCache(view: View, path: Path): Node | null;
-export declare function viewIsEmpty(view: View): boolean;
-export declare function viewAddEventRegistration(view: View, eventRegistration: EventRegistration): void;
-/**
- * @param eventRegistration - If null, remove all callbacks.
- * @param cancelError - If a cancelError is provided, appropriate cancel events will be returned.
- * @returns Cancel events, if cancelError was provided.
- */
-export declare function viewRemoveEventRegistration(view: View, eventRegistration: EventRegistration | null, cancelError?: Error): Event[];
-/**
- * Applies the given Operation, updates our cache, and returns the appropriate events.
- */
-export declare function viewApplyOperation(view: View, operation: Operation, writesCache: WriteTreeRef, completeServerCache: Node | null): Event[];
-export declare function viewGetInitialEvents(view: View, registration: EventRegistration): Event[];
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Operation } from '../operation/Operation';
+import { Node } from '../snap/Node';
+import { Path } from '../util/Path';
+import { WriteTreeRef } from '../WriteTree';
+import { Event } from './Event';
+import { EventGenerator } from './EventGenerator';
+import { EventRegistration, QueryContext } from './EventRegistration';
+import { ViewCache } from './ViewCache';
+import { ViewProcessor } from './ViewProcessor';
+/**
+ * A view represents a specific location and query that has 1 or more event registrations.
+ *
+ * It does several things:
+ *  - Maintains the list of event registrations for this location/query.
+ *  - Maintains a cache of the data visible for this location/query.
+ *  - Applies new operations (via applyOperation), updates the cache, and based on the event
+ *    registrations returns the set of events to be raised.
+ */
+export declare class View {
+    private query_;
+    processor_: ViewProcessor;
+    viewCache_: ViewCache;
+    eventRegistrations_: EventRegistration[];
+    eventGenerator_: EventGenerator;
+    constructor(query_: QueryContext, initialViewCache: ViewCache);
+    get query(): QueryContext;
+}
+export declare function viewGetServerCache(view: View): Node | null;
+export declare function viewGetCompleteNode(view: View): Node | null;
+export declare function viewGetCompleteServerCache(view: View, path: Path): Node | null;
+export declare function viewIsEmpty(view: View): boolean;
+export declare function viewAddEventRegistration(view: View, eventRegistration: EventRegistration): void;
+/**
+ * @param eventRegistration - If null, remove all callbacks.
+ * @param cancelError - If a cancelError is provided, appropriate cancel events will be returned.
+ * @returns Cancel events, if cancelError was provided.
+ */
+export declare function viewRemoveEventRegistration(view: View, eventRegistration: EventRegistration | null, cancelError?: Error): Event[];
+/**
+ * Applies the given Operation, updates our cache, and returns the appropriate events.
+ */
+export declare function viewApplyOperation(view: View, operation: Operation, writesCache: WriteTreeRef, completeServerCache: Node | null): Event[];
+export declare function viewGetInitialEvents(view: View, registration: EventRegistration): Event[];

package/dist/node-esm/src/core/view/ViewCache.d.ts

@@ -1,32 +1,32 @@
-/**
- * @license
- * Copyright 2017 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { Node } from '../snap/Node';
-import { CacheNode } from './CacheNode';
-/**
- * Stores the data we have cached for a view.
- *
- * serverSnap is the cached server data, eventSnap is the cached event data (server data plus any local writes).
- */
-export interface ViewCache {
-    readonly eventCache: CacheNode;
-    readonly serverCache: CacheNode;
-}
-export declare function newViewCache(eventCache: CacheNode, serverCache: CacheNode): ViewCache;
-export declare function viewCacheUpdateEventSnap(viewCache: ViewCache, eventSnap: Node, complete: boolean, filtered: boolean): ViewCache;
-export declare function viewCacheUpdateServerSnap(viewCache: ViewCache, serverSnap: Node, complete: boolean, filtered: boolean): ViewCache;
-export declare function viewCacheGetCompleteEventSnap(viewCache: ViewCache): Node | null;
-export declare function viewCacheGetCompleteServerSnap(viewCache: ViewCache): Node | null;
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Node } from '../snap/Node';
+import { CacheNode } from './CacheNode';
+/**
+ * Stores the data we have cached for a view.
+ *
+ * serverSnap is the cached server data, eventSnap is the cached event data (server data plus any local writes).
+ */
+export interface ViewCache {
+    readonly eventCache: CacheNode;
+    readonly serverCache: CacheNode;
+}
+export declare function newViewCache(eventCache: CacheNode, serverCache: CacheNode): ViewCache;
+export declare function viewCacheUpdateEventSnap(viewCache: ViewCache, eventSnap: Node, complete: boolean, filtered: boolean): ViewCache;
+export declare function viewCacheUpdateServerSnap(viewCache: ViewCache, serverSnap: Node, complete: boolean, filtered: boolean): ViewCache;
+export declare function viewCacheGetCompleteEventSnap(viewCache: ViewCache): Node | null;
+export declare function viewCacheGetCompleteServerSnap(viewCache: ViewCache): Node | null;

package/dist/node-esm/src/core/view/ViewProcessor.d.ts

@@ -1,32 +1,32 @@
-/**
- * @license
- * Copyright 2017 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { Operation } from '../operation/Operation';
-import { Node } from '../snap/Node';
-import { WriteTreeRef } from '../WriteTree';
-import { Change } from './Change';
-import { NodeFilter } from './filter/NodeFilter';
-import { ViewCache } from './ViewCache';
-export interface ProcessorResult {
-    readonly viewCache: ViewCache;
-    readonly changes: Change[];
-}
-export interface ViewProcessor {
-    readonly filter: NodeFilter;
-}
-export declare function newViewProcessor(filter: NodeFilter): ViewProcessor;
-export declare function viewProcessorAssertIndexed(viewProcessor: ViewProcessor, viewCache: ViewCache): void;
-export declare function viewProcessorApplyOperation(viewProcessor: ViewProcessor, oldViewCache: ViewCache, operation: Operation, writesCache: WriteTreeRef, completeCache: Node | null): ProcessorResult;
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Operation } from '../operation/Operation';
+import { Node } from '../snap/Node';
+import { WriteTreeRef } from '../WriteTree';
+import { Change } from './Change';
+import { NodeFilter } from './filter/NodeFilter';
+import { ViewCache } from './ViewCache';
+export interface ProcessorResult {
+    readonly viewCache: ViewCache;
+    readonly changes: Change[];
+}
+export interface ViewProcessor {
+    readonly filter: NodeFilter;
+}
+export declare function newViewProcessor(filter: NodeFilter): ViewProcessor;
+export declare function viewProcessorAssertIndexed(viewProcessor: ViewProcessor, viewCache: ViewCache): void;
+export declare function viewProcessorApplyOperation(viewProcessor: ViewProcessor, oldViewCache: ViewCache, operation: Operation, writesCache: WriteTreeRef, completeCache: Node | null): ProcessorResult;