@depup/firebase__database 1.1.1-depup.0

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

@@ -0,0 +1,64 @@
+/**
+ * @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 as ExpDataSnapshot } from '../../api/Reference_impl';
+import { Path } from '../util/Path';
+import { EventRegistration } from './EventRegistration';
+/**
+ * Encapsulates the data needed to raise an event
+ * @interface
+ */
+export interface Event {
+    getPath(): Path;
+    getEventType(): string;
+    getEventRunner(): () => void;
+    toString(): string;
+}
+/**
+ * One of the following strings: "value", "child_added", "child_changed",
+ * "child_removed", or "child_moved."
+ */
+export type EventType = 'value' | 'child_added' | 'child_changed' | 'child_moved' | 'child_removed';
+/**
+ * Encapsulates the data needed to raise an event
+ */
+export declare class DataEvent implements Event {
+    eventType: EventType;
+    eventRegistration: EventRegistration;
+    snapshot: ExpDataSnapshot;
+    prevName?: string | null;
+    /**
+     * @param eventType - One of: value, child_added, child_changed, child_moved, child_removed
+     * @param eventRegistration - The function to call to with the event data. User provided
+     * @param snapshot - The data backing the event
+     * @param prevName - Optional, the name of the previous child for child_* events.
+     */
+    constructor(eventType: EventType, eventRegistration: EventRegistration, snapshot: ExpDataSnapshot, prevName?: string | null);
+    getPath(): Path;
+    getEventType(): string;
+    getEventRunner(): () => void;
+    toString(): string;
+}
+export declare class CancelEvent implements Event {
+    eventRegistration: EventRegistration;
+    error: Error;
+    path: Path;
+    constructor(eventRegistration: EventRegistration, error: Error, path: Path);
+    getPath(): Path;
+    getEventType(): string;
+    getEventRunner(): () => void;
+    toString(): string;
+}

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

@@ -0,0 +1,42 @@
+/**
+ * @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 { Node } from '../snap/Node';
+import { Change } from './Change';
+import { Event } from './Event';
+import { EventRegistration, QueryContext } from './EventRegistration';
+/**
+ * An EventGenerator is used to convert "raw" changes (Change) as computed by the
+ * CacheDiffer into actual events (Event) that can be raised.  See generateEventsForChanges()
+ * for details.
+ *
+ */
+export declare class EventGenerator {
+    query_: QueryContext;
+    index_: Index;
+    constructor(query_: QueryContext);
+}
+/**
+ * Given a set of raw changes (no moved events and prevName not specified yet), and a set of
+ * EventRegistrations that should be notified of these changes, generate the actual events to be raised.
+ *
+ * Notes:
+ *  - child_moved events will be synthesized at this time for any child_changed events that affect
+ *    our index.
+ *  - prevName will be calculated based on the index ordering.
+ */
+export declare function eventGeneratorGenerateEventsForChanges(eventGenerator: EventGenerator, changes: Change[], eventCache: Node, eventRegistrations: EventRegistration[]): Event[];

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

@@ -0,0 +1,67 @@
+/**
+ * @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 { Path } from '../util/Path';
+import { Event } from './Event';
+/**
+ * The event queue serves a few purposes:
+ * 1. It ensures we maintain event order in the face of event callbacks doing operations that result in more
+ *    events being queued.
+ * 2. raiseQueuedEvents() handles being called reentrantly nicely.  That is, if in the course of raising events,
+ *    raiseQueuedEvents() is called again, the "inner" call will pick up raising events where the "outer" call
+ *    left off, ensuring that the events are still raised synchronously and in order.
+ * 3. You can use raiseEventsAtPath and raiseEventsForChangedPath to ensure only relevant previously-queued
+ *    events are raised synchronously.
+ *
+ * NOTE: This can all go away if/when we move to async events.
+ *
+ */
+export declare class EventQueue {
+    eventLists_: EventList[];
+    /**
+     * Tracks recursion depth of raiseQueuedEvents_, for debugging purposes.
+     */
+    recursionDepth_: number;
+}
+/**
+ * @param eventDataList - The new events to queue.
+ */
+export declare function eventQueueQueueEvents(eventQueue: EventQueue, eventDataList: Event[]): void;
+/**
+ * Queues the specified events and synchronously raises all events (including previously queued ones)
+ * for the specified path.
+ *
+ * It is assumed that the new events are all for the specified path.
+ *
+ * @param path - The path to raise events for.
+ * @param eventDataList - The new events to raise.
+ */
+export declare function eventQueueRaiseEventsAtPath(eventQueue: EventQueue, path: Path, eventDataList: Event[]): void;
+/**
+ * Queues the specified events and synchronously raises all events (including previously queued ones) for
+ * locations related to the specified change path (i.e. all ancestors and descendants).
+ *
+ * It is assumed that the new events are all related (ancestor or descendant) to the specified path.
+ *
+ * @param changedPath - The path to raise events for.
+ * @param eventDataList - The events to raise
+ */
+export declare function eventQueueRaiseEventsForChangedPath(eventQueue: EventQueue, changedPath: Path, eventDataList: Event[]): void;
+interface EventList {
+    events: Event[];
+    path: Path;
+}
+export {};

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

@@ -0,0 +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;
+}

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

@@ -0,0 +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>;

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

@@ -0,0 +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[];

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

@@ -0,0 +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;

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

@@ -0,0 +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;

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

@@ -0,0 +1,35 @@
+/**
+ * @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 { Node } from '../../snap/Node';
+import { Path } from '../../util/Path';
+import { ChildChangeAccumulator } from '../ChildChangeAccumulator';
+import { CompleteChildSource } from '../CompleteChildSource';
+import { NodeFilter } from './NodeFilter';
+/**
+ * Doesn't really filter nodes but applies an index to the node and keeps track of any changes
+ */
+export declare class IndexedFilter implements NodeFilter {
+    private readonly index_;
+    constructor(index_: Index);
+    updateChild(snap: Node, key: string, newChild: Node, affectedPath: Path, source: CompleteChildSource, optChangeAccumulator: ChildChangeAccumulator | null): Node;
+    updateFullNode(oldSnap: Node, newSnap: Node, optChangeAccumulator: ChildChangeAccumulator | null): Node;
+    updatePriority(oldSnap: Node, newPriority: Node): Node;
+    filtersNodes(): boolean;
+    getIndexedFilter(): IndexedFilter;
+    getIndex(): Index;
+}

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

@@ -0,0 +1,47 @@
+/**
+ * @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 { Node } from '../../snap/Node';
+import { Path } from '../../util/Path';
+import { ChildChangeAccumulator } from '../ChildChangeAccumulator';
+import { CompleteChildSource } from '../CompleteChildSource';
+import { QueryParams } from '../QueryParams';
+import { IndexedFilter } from './IndexedFilter';
+import { NodeFilter } from './NodeFilter';
+/**
+ * Applies a limit and a range to a node and uses RangedFilter to do the heavy lifting where possible
+ */
+export declare class LimitedFilter implements NodeFilter {
+    private readonly rangedFilter_;
+    private readonly index_;
+    private readonly limit_;
+    private readonly reverse_;
+    private readonly startIsInclusive_;
+    private readonly endIsInclusive_;
+    constructor(params: QueryParams);
+    updateChild(snap: Node, key: string, newChild: Node, affectedPath: Path, source: CompleteChildSource, optChangeAccumulator: ChildChangeAccumulator | null): Node;
+    updateFullNode(oldSnap: Node, newSnap: Node, optChangeAccumulator: ChildChangeAccumulator | null): Node;
+    updatePriority(oldSnap: Node, newPriority: Node): Node;
+    filtersNodes(): boolean;
+    getIndexedFilter(): IndexedFilter;
+    getIndex(): Index;
+    private fullLimitUpdateChild_;
+    private withinDirectionalStart;
+    private withinDirectionalEnd;
+    private withinStartPost;
+    private withinEndPost;
+}

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

@@ -0,0 +1,54 @@
+/**
+ * @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 { Node } from '../../snap/Node';
+import { Path } from '../../util/Path';
+import { ChildChangeAccumulator } from '../ChildChangeAccumulator';
+import { CompleteChildSource } from '../CompleteChildSource';
+/**
+ * NodeFilter is used to update nodes and complete children of nodes while applying queries on the fly and keeping
+ * track of any child changes. This class does not track value changes as value changes depend on more
+ * than just the node itself. Different kind of queries require different kind of implementations of this interface.
+ * @interface
+ */
+export interface NodeFilter {
+    /**
+     * Update a single complete child in the snap. If the child equals the old child in the snap, this is a no-op.
+     * The method expects an indexed snap.
+     */
+    updateChild(snap: Node, key: string, newChild: Node, affectedPath: Path, source: CompleteChildSource, optChangeAccumulator: ChildChangeAccumulator | null): Node;
+    /**
+     * Update a node in full and output any resulting change from this complete update.
+     */
+    updateFullNode(oldSnap: Node, newSnap: Node, optChangeAccumulator: ChildChangeAccumulator | null): Node;
+    /**
+     * Update the priority of the root node
+     */
+    updatePriority(oldSnap: Node, newPriority: Node): Node;
+    /**
+     * Returns true if children might be filtered due to query criteria
+     */
+    filtersNodes(): boolean;
+    /**
+     * Returns the index filter that this filter uses to get a NodeFilter that doesn't filter any children.
+     */
+    getIndexedFilter(): NodeFilter;
+    /**
+     * Returns the index that this filter uses
+     */
+    getIndex(): Index;
+}

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

@@ -0,0 +1,47 @@
+/**
+ * @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 { NamedNode, Node } from '../../../core/snap/Node';
+import { Index } from '../../snap/indexes/Index';
+import { Path } from '../../util/Path';
+import { ChildChangeAccumulator } from '../ChildChangeAccumulator';
+import { CompleteChildSource } from '../CompleteChildSource';
+import { QueryParams } from '../QueryParams';
+import { IndexedFilter } from './IndexedFilter';
+import { NodeFilter } from './NodeFilter';
+/**
+ * Filters nodes by range and uses an IndexFilter to track any changes after filtering the node
+ */
+export declare class RangedFilter implements NodeFilter {
+    private indexedFilter_;
+    private index_;
+    private startPost_;
+    private endPost_;
+    private startIsInclusive_;
+    private endIsInclusive_;
+    constructor(params: QueryParams);
+    getStartPost(): NamedNode;
+    getEndPost(): NamedNode;
+    matches(node: NamedNode): boolean;
+    updateChild(snap: Node, key: string, newChild: Node, affectedPath: Path, source: CompleteChildSource, optChangeAccumulator: ChildChangeAccumulator | null): Node;
+    updateFullNode(oldSnap: Node, newSnap: Node, optChangeAccumulator: ChildChangeAccumulator | null): Node;
+    updatePriority(oldSnap: Node, newPriority: Node): Node;
+    filtersNodes(): boolean;
+    getIndexedFilter(): IndexedFilter;
+    getIndex(): Index;
+    private static getStartPost_;
+    private static getEndPost_;
+}