mongodb-livedata-server 0.0.4 → 0.0.5

package/dist/livedata_server.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LiveCursor = exports.LiveMongoConnection = exports.DDPServer = void 0;
+exports.LiveCursor = exports.LiveMongoConnection = exports.ddpError = exports.DDPServer = void 0;
 var livedata_server_1 = require("./meteor/ddp/livedata_server");
 Object.defineProperty(exports, "DDPServer", { enumerable: true, get: function () { return livedata_server_1.DDPServer; } });
+var livedata_server_2 = require("./meteor/ddp/livedata_server");
+Object.defineProperty(exports, "ddpError", { enumerable: true, get: function () { return livedata_server_2.ddpError; } });
 var live_connection_1 = require("./meteor/mongo/live_connection");
 Object.defineProperty(exports, "LiveMongoConnection", { enumerable: true, get: function () { return live_connection_1.LiveMongoConnection; } });
 var live_cursor_1 = require("./meteor/mongo/live_cursor");

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "mongodb-livedata-server",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "MongoDB live data server, extracted from Meteor, Fibers removed and converted to TypeScript",
   "main": "dist/livedata_server.js",
-  "types": "livedata_server.ts",
+  "types": "types/livedata_server.d.ts",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },

package/types/livedata_server.d.ts

@@ -0,0 +1,4 @@
+export { DDPServer } from "./meteor/ddp/livedata_server";
+export { ddpError } from "./meteor/ddp/livedata_server";
+export { LiveMongoConnection } from "./meteor/mongo/live_connection";
+export { LiveCursor } from "./meteor/mongo/live_cursor";

package/types/meteor/binary-heap/max_heap.d.ts

@@ -0,0 +1,31 @@
+export interface MaxHeapOptions {
+    initData?: {
+        id: string;
+        value: any;
+    }[];
+    IdMap?: any;
+}
+export declare class MaxHeap {
+    protected _comparator: (a: any, b: any) => number;
+    protected _heap: any[];
+    private _heapIdx;
+    constructor(comparator: (a: any, b: any) => number, options?: MaxHeapOptions);
+    _initFromData(data: any): void;
+    _downHeap(idx: any): void;
+    _upHeap(idx: any): void;
+    _maxIndex(idxA: any, idxB: any): any;
+    _get(idx: any): any;
+    _swap(idxA: any, idxB: any): void;
+    get(id: any): any;
+    set(id: any, value: any): void;
+    remove(id: any): void;
+    has(id: any): any;
+    empty(): boolean;
+    clear(): void;
+    forEach(iterator: any): void;
+    size(): number;
+    setDefault(id: any, def: any): any;
+    clone(): MaxHeap;
+    maxElementId(): any;
+    _selfCheck(): void;
+}

package/types/meteor/binary-heap/min_heap.d.ts

@@ -0,0 +1,6 @@
+import { MaxHeap, MaxHeapOptions } from './max_heap';
+export declare class MinHeap extends MaxHeap {
+    constructor(comparator: any, options?: MaxHeapOptions);
+    maxElementId(): void;
+    minElementId(): any;
+}

package/types/meteor/binary-heap/min_max_heap.d.ts

@@ -0,0 +1,11 @@
+import { MaxHeap, MaxHeapOptions } from './max_heap';
+export declare class MinMaxHeap extends MaxHeap {
+    private _minHeap;
+    constructor(comparator: any, options?: MaxHeapOptions);
+    set(id: string, value: any): void;
+    remove(id: string): void;
+    clear(): void;
+    setDefault(id: string, def: any): any;
+    clone(): MinMaxHeap;
+    minElementId(): any;
+}

package/types/meteor/callback-hook/hook.d.ts

@@ -0,0 +1,11 @@
+export declare class Hook {
+    private nextCallbackId;
+    private callbacks;
+    private exceptionHandler;
+    constructor(options?: any);
+    register(callback: any): {
+        callback: any;
+        stop: () => void;
+    };
+    each(iterator: (callback: Function) => boolean): void;
+}

package/types/meteor/ddp/crossbar.d.ts

@@ -0,0 +1,15 @@
+export declare class _Crossbar {
+    private listenersByCollection;
+    private listenersByCollectionCount;
+    private nextId;
+    constructor(options: any);
+    _collectionForMessage(msg: {
+        collection?: any;
+    }): string;
+    listen(trigger: any, callback: any): {
+        stop: () => void;
+    };
+    fire(notification: Record<string, any>): void;
+    _matches(notification: Record<string, any>, trigger: Record<string, any>): boolean;
+}
+export declare const _InvalidationCrossbar: _Crossbar;

package/types/meteor/ddp/heartbeat.d.ts

@@ -0,0 +1,19 @@
+export declare class Heartbeat {
+    private heartbeatInterval;
+    private heartbeatTimeout;
+    private _sendPing;
+    private _onTimeout;
+    private _seenPacket;
+    private _heartbeatIntervalHandle;
+    private _heartbeatTimeoutHandle;
+    constructor(options: any);
+    stop(): void;
+    start(): void;
+    _startHeartbeatIntervalTimer(): void;
+    _startHeartbeatTimeoutTimer(): void;
+    _clearHeartbeatIntervalTimer(): void;
+    _clearHeartbeatTimeoutTimer(): void;
+    _heartbeatIntervalFired(): void;
+    _heartbeatTimeoutFired(): void;
+    messageReceived(): void;
+}

package/types/meteor/ddp/livedata_server.d.ts

@@ -0,0 +1,141 @@
+/// <reference types="node" />
+import { MethodInvocation } from "./method-invocation";
+import { StreamServerSocket } from "./stream_server";
+import { DDPSession, SessionConnectionHandle } from "./session";
+import { Server } from "http";
+import { Subscription } from "./subscription";
+export declare const DDP: {
+    _CurrentPublicationInvocation: Subscription;
+    _CurrentMethodInvocation: MethodInvocation;
+};
+/******************************************************************************/
+/******************************************************************************/
+interface PublicationStrategy {
+    useCollectionView: boolean;
+    doAccountingForCollection: boolean;
+}
+export declare class DDPServer {
+    private options;
+    private onConnectionHook;
+    private onMessageHook;
+    private publish_handlers;
+    private universal_publish_handlers;
+    private method_handlers;
+    private _publicationStrategies;
+    private sessions;
+    private stream_server;
+    constructor(options: {}, httpServer: Server);
+    static publicationStrategies: {
+        SERVER_MERGE: {
+            useCollectionView: boolean;
+            doAccountingForCollection: boolean;
+        };
+        NO_MERGE_NO_HISTORY: {
+            useCollectionView: boolean;
+            doAccountingForCollection: boolean;
+        };
+        NO_MERGE: {
+            useCollectionView: boolean;
+            doAccountingForCollection: boolean;
+        };
+    };
+    /**
+     * @summary Register a callback to be called when a new DDP connection is made to the server.
+     * @locus Server
+     * @param {function} callback The function to call when a new DDP connection is established.
+     * @memberOf Meteor
+     * @importFromPackage meteor
+     */
+    onConnection(fn: (conn: SessionConnectionHandle) => void): {
+        callback: any;
+        stop: () => void;
+    };
+    /**
+     * @summary Set publication strategy for the given publication. Publications strategies are available from `DDPServer.publicationStrategies`. You call this method from `Meteor.server`, like `Meteor.server.setPublicationStrategy()`
+     * @locus Server
+     * @alias setPublicationStrategy
+     * @param publicationName {String}
+     * @param strategy {{useCollectionView: boolean, doAccountingForCollection: boolean}}
+     * @memberOf Meteor.server
+     * @importFromPackage meteor
+     */
+    setPublicationStrategy(publicationName: string, strategy: PublicationStrategy): void;
+    /**
+     * @summary Gets the publication strategy for the requested publication. You call this method from `Meteor.server`, like `Meteor.server.getPublicationStrategy()`
+     * @locus Server
+     * @alias getPublicationStrategy
+     * @param publicationName {String}
+     * @memberOf Meteor.server
+     * @importFromPackage meteor
+     * @return {{useCollectionView: boolean, doAccountingForCollection: boolean}}
+     */
+    getPublicationStrategy(publicationName: string): PublicationStrategy;
+    /**
+     * @summary Register a callback to be called when a new DDP message is received.
+     * @locus Server
+     * @param {function} callback The function to call when a new DDP message is received.
+     * @memberOf Meteor
+     * @importFromPackage meteor
+     */
+    onMessage(fn: any): {
+        callback: any;
+        stop: () => void;
+    };
+    _handleConnect(socket: StreamServerSocket, msg: any): void;
+    /**
+     * Register a publish handler function.
+     *
+     * @param name {String} identifier for query
+     * @param handler {Function} publish handler
+     *
+     * Server will call handler function on each new subscription,
+     * either when receiving DDP sub message for a named subscription, or on
+     * DDP connect for a universal subscription.
+     *
+     * If name is null, this will be a subscription that is
+     * automatically established and permanently on for all connected
+     * client, instead of a subscription that can be turned on and off
+     * with subscribe().
+     *
+     */
+    /**
+     * @summary Publish a record set.
+     * @memberOf Meteor
+     * @importFromPackage meteor
+     * @locus Server
+     * @param {String|Object} name If String, name of the record set.  If Object, publications Dictionary of publish functions by name.  If `null`, the set has no name, and the record set is automatically sent to all connected clients.
+     * @param {Function} func Function called on the server each time a client subscribes.  Inside the function, `this` is the publish handler object, described below.  If the client passed arguments to `subscribe`, the function is called with the same arguments.
+     */
+    publish(name: string | Record<string, (this: MethodInvocation, ...args: any[]) => Promise<any>> | null, handler?: (this: MethodInvocation, ...args: any[]) => Promise<any>): void;
+    _removeSession(session: DDPSession): void;
+    /**
+     * @summary Defines functions that can be invoked over the network by clients.
+     * @locus Anywhere
+     * @param {Object} methods Dictionary whose keys are method names and values are functions.
+     * @memberOf Meteor
+     * @importFromPackage meteor
+     */
+    methods(methods: Record<string, (this: MethodInvocation, ...args: any[]) => Promise<any>>): void;
+    callAsync(name: string, ...args: any[]): Promise<unknown>;
+    applyAsync(name: string, args: any[]): Promise<unknown>;
+    _urlForSession(sessionId: any): string;
+}
+export declare function _calculateVersion(clientSupportedVersions: any, serverSupportedVersions: any): any;
+export declare function wrapInternalException(exception: any, context: any): any;
+export declare function maybeAuditArgumentChecks(f: Function, context: any, args: any[] | null, description: string): any;
+export declare function ddpError(error: string | number, reason?: string, details?: string): {
+    isClientSafe: boolean;
+    error: string | number;
+    reason: string;
+    message: string;
+    errorType: string;
+};
+export declare class ClientSafeError extends Error {
+    error: string | number;
+    reason?: string;
+    details?: string;
+    constructor(error: string | number, reason?: string, details?: string);
+    isClientSafe: boolean;
+    errorType: string;
+}
+export {};

package/types/meteor/ddp/method-invocation.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @summary The state for a single invocation of a method, referenced by this
+ * inside a method definition.
+ * @param {Object} options
+ * @instanceName this
+ * @showInstanceName true
+ */
+export declare class MethodInvocation {
+    userId: string;
+    connection: any;
+    private isSimulation;
+    private _isFromCallAsync;
+    private _setUserId;
+    private randomSeed;
+    private randomStream;
+    constructor(options: any);
+    /**
+     * @summary Set the logged in user.
+     * @locus Server
+     * @memberOf DDPCommon.MethodInvocation
+     * @instance
+     * @param {String | null} userId The value that should be returned by `userId` on this connection.
+     */
+    setUserId(userId: string | null): void;
+}

package/types/meteor/ddp/random-stream.d.ts

@@ -0,0 +1,8 @@
+export declare class RandomStream {
+    private seed;
+    private sequences;
+    constructor(options: any);
+    _sequence(name: any): any;
+    static get(scope: any, name: any): any;
+}
+export declare function makeRpcSeed(enclosing: any, methodName: any): any;

package/types/meteor/ddp/session-collection-view.d.ts

@@ -0,0 +1,27 @@
+import { SessionDocumentView } from "./session-document-view";
+interface SubscriptionCallbacks {
+    added: (collectionName: string, id: string, fields: Record<string, any>) => void;
+    changed: (collectionName: string, id: string, fields: Record<string, any>) => void;
+    removed: (collectionName: string, id: string) => void;
+}
+interface SubscriptionHandle {
+}
+/**
+ * Represents a client's view of a single collection
+ * @param {String} collectionName Name of the collection it represents
+ * @param {Object.<String, Function>} sessionCallbacks The callbacks for added, changed, removed
+ * @class SessionCollectionView
+ */
+export declare class SessionCollectionView {
+    private collectionName;
+    private callbacks;
+    private documents;
+    constructor(collectionName: string, callbacks: SubscriptionCallbacks);
+    isEmpty(): boolean;
+    diff(previous: SessionCollectionView): void;
+    diffDocument(id: string, prevDV: SessionDocumentView, nowDV: SessionDocumentView): void;
+    added(subscriptionHandle: SubscriptionHandle, id: string, fields: Record<string, any>): void;
+    changed(subscriptionHandle: SubscriptionHandle, id: string, changed: Record<string, any>): void;
+    removed(subscriptionHandle: any, id: string): void;
+}
+export {};

package/types/meteor/ddp/session-document-view.d.ts

@@ -0,0 +1,8 @@
+export declare class SessionDocumentView {
+    existsIn: Set<any>;
+    private dataByKey;
+    constructor();
+    getFields(): Record<string, any>;
+    clearField(subscriptionHandle: any, key: string, changeCollector: Object): void;
+    changeField(subscriptionHandle: any, key: string, value: any, changeCollector: Object, isAdd: boolean): void;
+}

package/types/meteor/ddp/session.d.ts

@@ -0,0 +1,69 @@
+import DoubleEndedQueue from "double-ended-queue";
+import { StreamServerSocket } from "./stream_server";
+import { DDPServer } from "./livedata_server";
+export interface SessionConnectionHandle {
+    id: string;
+    close: Function;
+    onClose: Function;
+    clientAddress: any;
+    httpHeaders: Record<string, any>;
+}
+interface DDPMessage {
+    msg: string;
+    id: string;
+    version?: string;
+    name?: string;
+    method?: string;
+    params?: any[];
+    randomSeed?: any;
+}
+export declare class DDPSession {
+    id: string;
+    server: any;
+    inQueue: DoubleEndedQueue<any>;
+    userId: string | null;
+    connectionHandle: SessionConnectionHandle;
+    _dontStartNewUniversalSubs: boolean;
+    _socketUrl: string;
+    private version;
+    private socket;
+    private initialized;
+    private workerRunning;
+    private _namedSubs;
+    private _universalSubs;
+    private collectionViews;
+    private _isSending;
+    private _pendingReady;
+    private _closeCallbacks;
+    private _respondToPings;
+    private heartbeat;
+    constructor(server: DDPServer, version: string, socket: StreamServerSocket, options: any);
+    sendReady(subscriptionIds: any): void;
+    _canSend(collectionName: any): boolean;
+    sendAdded(collectionName: string, id: string, fields: Record<string, any>): void;
+    sendChanged(collectionName: string, id: string, fields: Record<string, any>): void;
+    sendRemoved(collectionName: string, id: string): void;
+    getSendCallbacks(): {
+        added: any;
+        changed: any;
+        removed: any;
+    };
+    getCollectionView(collectionName: any): any;
+    added(subscriptionHandle: any, collectionName: any, id: any, fields: any): void;
+    removed(subscriptionHandle: any, collectionName: any, id: any): void;
+    changed(subscriptionHandle: any, collectionName: any, id: any, fields: any): void;
+    startUniversalSubs(): void;
+    close(): void;
+    send(msg: any): void;
+    sendError(reason: any, offendingMessage: any): void;
+    processMessage(msg_in: DDPMessage): Promise<void>;
+    private protocol_handlers;
+    _eachSub(f: any): void;
+    _diffCollectionViews(beforeCVs: any): void;
+    _setUserId(userId: any): void;
+    _startSubscription(handler: any, subId?: any, params?: any, name?: any): void;
+    _stopSubscription(subId: any, error?: any): void;
+    _deactivateAllSubscriptions(): void;
+    _clientAddress(): string;
+}
+export {};

package/types/meteor/ddp/stream_server.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+import { Server } from "http";
+import sockjs from "sockjs";
+import { DDPSession } from "./session";
+export interface StreamServerSocket extends sockjs.Connection {
+    setWebsocketTimeout: Function;
+    _session?: any;
+    _meteorSession?: DDPSession;
+    send: Function;
+}
+export declare class StreamServer {
+    private httpServer;
+    private registration_callbacks;
+    private open_sockets;
+    private prefix;
+    private server;
+    constructor(httpServer: Server);
+    register(callback: (socket: StreamServerSocket) => void): void;
+    all_sockets(): StreamServerSocket[];
+    _redirectWebsocketEndpoint(): void;
+}

package/types/meteor/ddp/subscription.d.ts

@@ -0,0 +1,89 @@
+import { DDPSession, SessionConnectionHandle } from "./session";
+/**
+ * @summary The server's side of a subscription
+ * @class Subscription
+ * @instanceName this
+ * @showInstanceName true
+ */
+export declare class Subscription {
+    _session: DDPSession;
+    private _handler;
+    private _subscriptionId;
+    private _params;
+    private _name?;
+    connection: SessionConnectionHandle;
+    private _subscriptionHandle;
+    private _deactivated;
+    private _stopCallbacks;
+    private _documents;
+    private _ready;
+    userId: string | null;
+    private _idFilter;
+    constructor(_session: DDPSession, _handler: any, _subscriptionId: string, _params?: any[], _name?: string);
+    _runHandler(): void;
+    _publishHandlerResult(res: any): void;
+    _deactivate(): void;
+    _callStopCallbacks(): void;
+    _removeAllDocuments(): void;
+    _recreate(): Subscription;
+    /**
+     * @summary Call inside the publish function.  Stops this client's subscription, triggering a call on the client to the `onStop` callback passed to [`Meteor.subscribe`](#meteor_subscribe), if any. If `error` is not a [`Meteor.Error`](#meteor_error), it will be [sanitized](#meteor_error).
+     * @locus Server
+     * @param {Error} error The error to pass to the client.
+     * @instance
+     * @memberOf Subscription
+     */
+    error(error: Error): void;
+    /**
+     * @summary Call inside the publish function.  Stops this client's subscription and invokes the client's `onStop` callback with no error.
+     * @locus Server
+     * @instance
+     * @memberOf Subscription
+     */
+    stop(): void;
+    /**
+     * @summary Call inside the publish function.  Registers a callback function to run when the subscription is stopped.
+     * @locus Server
+     * @memberOf Subscription
+     * @instance
+     * @param {Function} func The callback function
+     */
+    onStop(func: () => void): void;
+    _isDeactivated(): boolean;
+    /**
+     * @summary Call inside the publish function.  Informs the subscriber that a document has been added to the record set.
+     * @locus Server
+     * @memberOf Subscription
+     * @instance
+     * @param {String} collection The name of the collection that contains the new document.
+     * @param {String} id The new document's ID.
+     * @param {Object} fields The fields in the new document.  If `_id` is present it is ignored.
+     */
+    added(collectionName: string, id: string, fields: Record<string, any>): void;
+    /**
+     * @summary Call inside the publish function.  Informs the subscriber that a document in the record set has been modified.
+     * @locus Server
+     * @memberOf Subscription
+     * @instance
+     * @param {String} collection The name of the collection that contains the changed document.
+     * @param {String} id The changed document's ID.
+     * @param {Object} fields The fields in the document that have changed, together with their new values.  If a field is not present in `fields` it was left unchanged; if it is present in `fields` and has a value of `undefined` it was removed from the document.  If `_id` is present it is ignored.
+     */
+    changed(collectionName: string, id: string, fields: Record<string, any>): void;
+    /**
+     * @summary Call inside the publish function.  Informs the subscriber that a document has been removed from the record set.
+     * @locus Server
+     * @memberOf Subscription
+     * @instance
+     * @param {String} collection The name of the collection that the document has been removed from.
+     * @param {String} id The ID of the document that has been removed.
+     */
+    removed(collectionName: string, id: string): void;
+    /**
+     * @summary Call inside the publish function.  Informs the subscriber that an initial, complete snapshot of the record set has been sent.  This will trigger a call on the client to the `onReady` callback passed to  [`Meteor.subscribe`](#meteor_subscribe), if any.
+     * @locus Server
+     * @memberOf Subscription
+     * @instance
+     */
+    ready(): void;
+}

package/types/meteor/ddp/utils.d.ts

@@ -0,0 +1,8 @@
+export declare const hasOwn: (v: PropertyKey) => boolean;
+export declare const slice: (start?: number, end?: number) => any[];
+export declare function keys(obj: any): string[];
+export declare function isEmpty(obj: any): boolean;
+export declare function last(array: any, n: any, guard: any): any;
+export declare const SUPPORTED_DDP_VERSIONS: string[];
+export declare function parseDDP(stringMessage: string): any;
+export declare function stringifyDDP(msg: any): string;

package/types/meteor/ddp/writefence.d.ts

@@ -0,0 +1,20 @@
+import { OplogObserveDriver } from "../mongo/oplog-observe-driver";
+export declare class _WriteFence {
+    fired: boolean;
+    _oplogObserveDrivers: Record<string, OplogObserveDriver>;
+    private armed;
+    private retired;
+    private outstanding_writes;
+    private before_fire_callbacks;
+    private completion_callbacks;
+    constructor();
+    static _CurrentWriteFence: _WriteFence;
+    beginWrite(): {
+        committed: () => void;
+    };
+    arm(): void;
+    onBeforeFire(func: any): void;
+    onAllCommitted(func: any): void;
+    _maybeFire(): void;
+    retire(): void;
+}

package/types/meteor/diff-sequence/diff.d.ts

@@ -0,0 +1,13 @@
+import { IdMap } from "../id-map/id_map";
+interface DiffSequence {
+    diffQueryChanges(ordered: boolean, oldResults: any[], newResults: any[], observer: any, options?: any): any;
+    diffQueryChanges(ordered: boolean, oldResults: IdMap, newResults: IdMap, observer: any, options?: any): any;
+    diffQueryUnorderedChanges(oldResults: any, newResults: any, observer: any, options?: any): any;
+    diffQueryOrderedChanges(old_results: any, new_results: any, observer: any, options?: any): any;
+    diffObjects(left: any, right: any, callbacks: any): any;
+    diffMaps(left: any, right: any, callbacks: any): any;
+    makeChangedFields(newDoc: any, oldDoc: any): any;
+    applyChanges(doc: any, changeFields: any): void;
+}
+export declare const DiffSequence: DiffSequence;
+export {};

package/types/meteor/ejson/ejson.d.ts

@@ -0,0 +1,82 @@
+/**
+ * @summary Add a custom datatype to EJSON.
+ * @locus Anywhere
+ * @param {String} name A tag for your custom type; must be unique among
+ *                      custom data types defined in your project, and must
+ *                      match the result of your type's `typeName` method.
+ * @param {Function} factory A function that deserializes a JSON-compatible
+ *                           value into an instance of your type.  This should
+ *                           match the serialization performed by your
+ *                           type's `toJSONValue` method.
+ */
+export declare function addType(name: any, factory: any): void;
+export declare function _isCustomType(obj: any): boolean;
+export declare function _getTypes(isOriginal?: boolean): unknown;
+export declare function _getConverters(): any;
+export declare function _adjustTypesToJSONValue(obj: any): any;
+/**
+ * @summary Serialize an EJSON-compatible value into its plain JSON
+ *          representation.
+ * @locus Anywhere
+ * @param {EJSON} val A value to serialize to plain JSON.
+ */
+export declare function toJSONValue(item: any): any;
+export declare function _adjustTypesFromJSONValue(obj: any): any;
+/**
+ * @summary Deserialize an EJSON value from its plain JSON representation.
+ * @locus Anywhere
+ * @param {JSONCompatible} val A value to deserialize into EJSON.
+ */
+export declare function fromJSONValue(item: any): any;
+/**
+ * @summary Serialize a value to a string. For EJSON values, the serialization
+ *          fully represents the value. For non-EJSON values, serializes the
+ *          same way as `JSON.stringify`.
+ * @locus Anywhere
+ * @param {EJSON} val A value to stringify.
+ * @param {Object} [options]
+ * @param {Boolean | Integer | String} options.indent Indents objects and
+ * arrays for easy readability.  When `true`, indents by 2 spaces; when an
+ * integer, indents by that number of spaces; and when a string, uses the
+ * string as the indentation pattern.
+ * @param {Boolean} options.canonical When `true`, stringifies keys in an
+ *                                    object in sorted order.
+ */
+export declare function stringify(val: any, opts?: {
+    canonical?: boolean;
+    indent?: boolean | number | string;
+}): string;
+/**
+ * @summary Parse a string into an EJSON value. Throws an error if the string
+ *          is not valid EJSON.
+ * @locus Anywhere
+ * @param {String} str A string to parse into an EJSON value.
+ */
+export declare function parse(item: any): any;
+/**
+ * @summary Returns true if `x` is a buffer of binary data, as returned from
+ *          [`EJSON.newBinary`](#ejson_new_binary).
+ * @param {Object} x The variable to check.
+ * @locus Anywhere
+ */
+export declare function isBinary(obj: any): obj is Uint8Array;
+/**
+ * @summary Return true if `a` and `b` are equal to each other.  Return false
+ *          otherwise.  Uses the `equals` method on `a` if present, otherwise
+ *          performs a deep comparison.
+ * @locus Anywhere
+ * @param {EJSON} a
+ * @param {EJSON} b
+ * @param {Object} [options]
+ * @param {Boolean} options.keyOrderSensitive Compare in key sensitive order,
+ * if supported by the JavaScript implementation.  For example, `{a: 1, b: 2}`
+ * is equal to `{b: 2, a: 1}` only when `keyOrderSensitive` is `false`.  The
+ * default is `false`.
+ */
+export declare function equals(a: any, b: any, options?: any): any;
+/**
+ * @summary Return a deep copy of `val`.
+ * @locus Anywhere
+ * @param {EJSON} val A value to copy.
+ */
+export declare function clone<T>(v: T): T;

package/types/meteor/ejson/stringify.d.ts

@@ -0,0 +1,2 @@
+declare const canonicalStringify: (value: any, options: any) => string;
+export default canonicalStringify;