react-native-mosquito-transport 0.0.14

package/src/helpers/utils.js

@@ -0,0 +1,113 @@
+import AsyncStorage from "@react-native-async-storage/async-storage";
+import { ServerReachableListener, StoreReadyListener } from "./listeners";
+import { CACHE_PROTOCOL, CACHE_STORAGE_PATH, DEFAULT_CACHE_PASSWORD, LOCAL_STORAGE_PATH } from "./values";
+import { CacheStore, Scoped } from "./variables";
+import { decryptString, encryptString, niceTry, serializeE2E } from "./peripherals";
+
+export const updateCacheStore = () => {
+    const { cachePassword = DEFAULT_CACHE_PASSWORD, cacheProtocol = CACHE_PROTOCOL.ASYNC_STORAGE } = Scoped.ReleaseCacheData;
+
+    clearTimeout(Scoped.cacheStorageReducer);
+    Scoped.cacheStorageReducer = setTimeout(() => {
+        const txt = encryptString(
+            JSON.stringify({ ...CacheStore }),
+            cachePassword,
+            cachePassword
+        );
+
+        if (cacheProtocol === CACHE_PROTOCOL.ASYNC_STORAGE) {
+            AsyncStorage.setItem(CACHE_STORAGE_PATH, txt);
+        } else {
+            const fs = require('react-native-fs');
+            fs.writeFile(LOCAL_STORAGE_PATH(), txt, 'utf8');
+        }
+    }, 500);
+}
+
+export const releaseCacheStore = async (builder) => {
+    const { cachePassword = DEFAULT_CACHE_PASSWORD, cacheProtocol = CACHE_PROTOCOL.ASYNC_STORAGE } = builder;
+
+    let txt;
+
+    if (cacheProtocol === CACHE_PROTOCOL.ASYNC_STORAGE) {
+        txt = await niceTry(() => AsyncStorage.getItem(CACHE_STORAGE_PATH));
+    } else {
+        const fs = require('react-native-fs');
+        txt = await niceTry(() => fs.readFile(LOCAL_STORAGE_PATH(), 'utf8'));
+    }
+
+    const j = JSON.parse(decryptString(txt || '', cachePassword, cachePassword) || '{}');
+    
+    Object.entries(j).forEach(([k, v]) => {
+        CacheStore[k] = v;
+    });
+    Object.entries(CacheStore.AuthStore).forEach(([key, value]) => {
+        Scoped.AuthJWTToken[key] = value?.token;
+    });
+    Scoped.IsStoreReady = true;
+    StoreReadyListener.dispatch('_', 'ready');
+    // TODO: commit pending write
+}
+
+export const awaitStore = () => new Promise(resolve => {
+    if (Scoped.IsStoreReady) {
+        resolve();
+        return;
+    }
+    const l = StoreReadyListener.listenTo('_', t => {
+        if (t === 'ready') {
+            resolve();
+            l();
+        }
+    }, true);
+});
+
+export const awaitReachableServer = (projectUrl) => new Promise(resolve => {
+    if (Scoped.IS_CONNECTED[projectUrl]) {
+        resolve();
+        return;
+    }
+    const l = ServerReachableListener.listenTo(projectUrl, t => {
+        if (t) {
+            resolve();
+            l();
+        }
+    }, true);
+});
+
+export const getReachableServer = (projectUrl) => new Promise(resolve => {
+    if (typeof Scoped.IS_CONNECTED[projectUrl] === 'boolean') {
+        resolve(Scoped.IS_CONNECTED[projectUrl]);
+        return;
+    }
+    const l = ServerReachableListener.listenTo(projectUrl, t => {
+        if (typeof t === 'boolean') {
+            resolve(t);
+            l();
+        }
+    }, true);
+});
+
+export const buildFetchInterface = ({ body, accessKey, authToken, method, uglify, serverE2E_PublicKey }) => {
+    if (!uglify) body = JSON.stringify({ ...body });
+    const [plate, keyPair] = uglify ? serializeE2E(body, authToken, serverE2E_PublicKey) : [undefined, []];
+
+    return [{
+        body: uglify ? plate : body,
+        cache: 'no-cache',
+        headers: {
+            'Content-type': uglify ? 'text/plain' : 'application/json',
+            'Authorization': accessKey,
+            ...((authToken && !uglify) ? { 'Mosquito-Token': authToken } : {})
+        },
+        method: method || 'POST'
+    }, keyPair];
+};
+
+export const simplifyError = (error, message) => ({
+    simpleError: { error, message }
+});
+
+export const validateRequestMethod = (method) => {
+    // TODO:
+}

package/src/helpers/values.js

@@ -0,0 +1,72 @@
+import { Platform } from 'react-native';
+import { encodeBinary } from './peripherals';
+
+export const CACHE_STORAGE_PATH = encodeBinary('MOSQUITO_TRANSPORT_FREEZER'),
+    DEFAULT_CACHE_PASSWORD = encodeBinary('MOSQUITO_TRANSPORT_CACHE_PASSWORD'),
+    LOCAL_STORAGE_PATH = () => {
+        const fs = require('react-native-fs');
+        return `${Platform.OS === 'android' ? fs.ExternalCachesDirectoryPath : fs.CachesDirectoryPath}/${encodeBinary('MOSQUITO_TRANSPORT_STORAGE')}`;
+    },
+    DEFAULT_DB_NAME = 'DEFAULT_DB',
+    DEFAULT_DB_URL = 'mongodb://127.0.0.1:27017',
+    DEFAULT_ENCRYPT_IV = '****';
+
+export const CACHE_PROTOCOL = {
+    ASYNC_STORAGE: 'async-storage',
+    REACT_NATIVE_FS: 'reat-native-fs'
+};
+
+export const RETRIEVAL = {
+    STICKY: 'sticky',
+    STICKY_NO_AWAIT: 'sticky-no-await',
+    STICKY_RELOAD: 'sticky-reload',
+    DEFAULT: 'default',
+    CACHE_NO_AWAIT: 'cache-no-await',
+    NO_CACHE_NO_AWAIT: 'no-cache-no-await'
+};
+
+export const DELIVERY = {
+    DEFAULT: 'default',
+    NO_CACHE: 'no-cache',
+    NO_AWAIT: 'no-await',
+    NO_AWAIT_NO_CACHE: 'no-await-no-cache',
+    AWAIT_NO_CACHE: 'await-no-cache',
+    CACHE_NO_AWAIT: 'cache-no-await'
+};
+
+export const WRITE_OPS = {
+    $SET: '$set',
+    $PUSH: '$push',
+    $PULL: '$pull',
+    $UNSET: '$unset',
+    $INC: '$inc',
+    $MAX: '$max',
+    $MIN: '$min',
+    $MUL: '$mul',
+    $RENAME: '$rename'
+    // $SET_ON_INSERT: '$setOnInsert'
+};
+export const WRITE_OPS_LIST = Object.values(WRITE_OPS);
+
+export const READ_OPS = {
+    $IN: '$in',
+    $ALL: '$all',
+    $NIN: '$nin',
+    $GT: '$gt',
+    $GTE: '$gte',
+    $LT: '$lt',
+    $LTE: '$lte',
+    $TEXT: '$text',
+    // $EQ: '$eq',
+    // $REGEX: '$regex',
+    // $EXISTS: '$exists',
+    $NEAR: '$near',
+    $TYPE: '$type',
+    $SIZE: '$size',
+    // $NE: '$ne'
+};
+export const READ_OPS_LIST = Object.values(READ_OPS);
+
+export const Regexs = {
+    LINK: () => /(\b(https?|ftp):\/\/[-A-Z0-9+&@#\/%?=~_|!:,.;]*[-A-Z0-9+&@#\/%=~_|])/ig
+}

package/src/helpers/variables.js

@@ -0,0 +1,34 @@
+export const Scoped = {
+    PendingIte: 0,
+    AnyProcessIte: 0,
+    IS_CONNECTED: {},
+    IS_TOKEN_READY: {},
+    InitializedProject: {},
+    ReleaseCacheData: undefined,
+    AuthJWTToken: {},
+    cacheStorageReducer: undefined,
+    IsStoreReady: false,
+    TokenRefreshTimer: {},
+    LastTokenRefreshRef: {},
+    StorageProcessID: 0,
+    InitiatedForcedToken: {},
+    PendingFetchCollective: {
+        pendingProcess: {},
+        pendingResolution: {}
+    },
+    PendingDbReadCollective: {
+        pendingProcess: {},
+        pendingResolution: {}
+    }
+}
+
+export const CacheStore = {
+    DatabaseStore: {},
+    DatabaseRecords: {},
+    DatabaseCountResult: {},
+    AuthStore: {},
+    PendingWrites: {},
+    FetchedStore: {}
+}
+
+export const CacheConstant = { ...CacheStore };

package/src/index.d.ts

@@ -0,0 +1,373 @@
+interface RNMTConfig {
+    dbName?: string;
+    dbUrl?: string;
+    heapMemory?: number;
+    projectUrl: string;
+    disableCache?: boolean;
+    accessKey: string;
+    maxRetries?: number;
+    /**
+     * setting this to true will encrypt all outgoing and incoming request. This enables end-to-end encryption using [Tweetnacl](https://github.com/dchest/tweetnacl-js) and to prevent request interception by browser extensions, network intermediaries or other hijacking tools
+     */
+    enableE2E_Encryption?: boolean;
+    /**
+     * this is the base64 public key for end-to-end encryption on the server
+     */
+    serverE2E_PublicKey?: string;
+}
+
+interface GetDatabase {
+    collection: (path: string) => RNMTCollection;
+}
+
+interface mtimestamp { $timestamp: 'now' }
+
+export const TIMESTAMP: mtimestamp;
+export function DOCUMENT_EXTRACTION(path: string): { $dynamicValue: number };
+
+interface ReleaseCacheOption {
+    /**
+     * This password will be used to securely store your data locally
+     */
+    cachePassword?: string;
+    /**
+     * select the mechanism for storing data locally
+     * - async-storage: uses [@react-native-async-storage/async-storage](https://github.com/react-native-async-storage/async-storage) for storing data, make sure you have this package installed before setting this as the value
+     * - reat-native-fs: uses [reat-native-fs](https://github.com/itinance/react-native-fs) for storing data, make sure you have this package installed before setting this as the value
+     */
+    cacheProtocol?: 'async-storage' | 'reat-native-fs';
+}
+
+interface RNMTSocket {
+    timeout: (timeout?: number) => ({
+        emitWithAck: (...args: any) => Promise<any>;
+    });
+    emit: (...args: any) => void;
+    emitWithAck: () => Promise<any>;
+    on: (route: string, callback?: () => any) => void;
+    once: (route: string, callback?: () => any) => void;
+    destroy: () => void;
+}
+
+interface BatchWriteValue {
+    scope: 'setOne' | 'setMany' | 'updateOne' | 'mergeOne' | 'deleteOne' | 'deleteMany' | 'replaceOne' | 'putOne';
+    find?: DocumentFind;
+    value?: DocumentWriteValue[] | DocumentWriteValue;
+    path: string;
+}
+
+interface BatchWriteConfig extends WriteConfig {
+    stepping?: boolean;
+}
+
+export default class RNMT {
+    constructor(config: RNMTConfig);
+    static releaseCache(option?: ReleaseCacheOption): void;
+    getDatabase(dbName?: string, dbUrl?: string): GetDatabase;
+    collection(path: string): RNMTCollection;
+    auth(): RNMTAuth;
+    storage(): RNMTStorage;
+    fetchHttp(endpoint: string, init?: RequestInit, config?: FetchHttpConfig): Promise<Response>;
+    listenReachableServer(callback: (reachable: boolean) => void): () => void;
+    getSocket(options: { disableAuth?: boolean; authHandshake?: Object }): RNMTSocket;
+    batchWrite(map: BatchWriteValue[], config?: BatchWriteConfig): Promise<DocumentWriteResult[] | undefined>;
+}
+
+interface RNMTCollection {
+    find: (find?: DocumentFind) => ({
+        get: (config?: GetConfig) => Promise<DocumentResult[]>;
+        listen: (callback: (snapshot?: DocumentResult[]) => void, onError?: (error?: DocumentError) => void, config?: GetConfig) => void;
+        count: () => Promise<number>;
+        limit: (limit: number) => ({
+            random: (config?: GetConfig) => Promise<DocumentResult[]>;
+            get: (config?: GetConfig) => Promise<DocumentResult[]>;
+            listen: (callback: (snapshot?: DocumentResult[]) => void, onError?: (error?: DocumentError) => void, config?: GetConfig) => void;
+            sort: (sort: Sort | string, direction?: SortDirection) => ({
+                get: (config?: GetConfig) => Promise<DocumentResult[]>;
+                listen: (callback: (snapshot?: DocumentResult[]) => void, onError?: (error?: DocumentError) => void, config?: GetConfig) => void;
+            })
+        });
+        sort: (sort: Sort | string, direction?: SortDirection) => ({
+            get: (config?: GetConfig) => Promise<DocumentResult[]>;
+            listen: (callback: (snapshot?: DocumentResult[]) => void, onError?: (error?: DocumentError) => void, config?: GetConfig) => void;
+            limit: (limit: number) => ({
+                get: (config?: GetConfig) => Promise<DocumentResult[]>;
+                listen: (callback: (snapshot?: DocumentResult[]) => void, onError?: (error?: DocumentError) => void, config?: GetConfig) => void;
+            })
+        })
+    });
+    sort: (sort: Sort | string, direction?: SortDirection) => ({
+        get: (config?: GetConfig) => Promise<DocumentResult[]>;
+        listen: (callback: (snapshot?: DocumentResult[]) => void, onError?: (error?: DocumentError) => void, config?: GetConfig) => void;
+        limit: (limit: number) => ({
+            get: (config?: GetConfig) => Promise<DocumentResult[]>;
+            listen: (callback: (snapshot?: DocumentResult[]) => void, onError?: (error?: DocumentError) => void, config?: GetConfig) => void;
+        })
+    });
+    limit: (limit: number) => ({
+        random: (config?: GetConfig) => Promise<DocumentResult[]>;
+        get: (config?: GetConfig) => Promise<DocumentResult[]>;
+        listen: (callback: (snapshot?: DocumentResult[]) => void, onError?: (error?: DocumentError) => void, config?: GetConfig) => void;
+        sort: (sort: Sort | string, direction?: SortDirection) => ({
+            get: (config?: GetConfig) => Promise<DocumentResult[]>;
+            listen: (callback: (snapshot?: DocumentResult[]) => void, onError?: (error?: DocumentError) => void, config?: GetConfig) => void;
+        })
+    });
+    count: () => Promise<number>;
+    get: (config?: GetConfig) => Promise<DocumentResult[]>;
+    listen: (callback: (snapshot?: DocumentResult[]) => void, onError?: (error?: DocumentError) => void, config?: GetConfig) => void;
+    findOne: (findOne?: DocumentFind) => ({
+        get: (config?: GetConfig) => Promise<DocumentResult>;
+        listen: (callback: (snapshot?: DocumentResult) => void, onError?: (error?: DocumentError) => void, config?: GetConfig) => void;
+    });
+    onDisconnect: () => ({
+        setOne: (value: DocumentWriteValue) => () => void;
+        setMany: (value: DocumentWriteValue[]) => () => void;
+        updateOne: (find: DocumentFind, value: DocumentWriteValue) => () => void;
+        updateMany: (find: DocumentFind, value: DocumentWriteValue) => () => void;
+        mergeOne: (find: DocumentFind, value: DocumentWriteValue) => () => void;
+        mergeMany: (find: DocumentFind, value: DocumentWriteValue) => () => void;
+        replaceOne: (find: DocumentFind, value: DocumentWriteValue) => () => void;
+        putOne: (find: DocumentFind, value: DocumentWriteValue) => () => void;
+        deleteOne: (find: DocumentFind) => () => void;
+        deleteMany: (find?: DocumentFind) => () => void;
+    })
+
+    setOne: (value: DocumentWriteValue, config?: WriteConfig) => Promise<DocumentWriteResult>;
+
+    setMany: (value: DocumentWriteValue[], config?: WriteConfig) => Promise<DocumentWriteResult>;
+
+    updateOne: (find: DocumentFind, value: DocumentWriteValue, config?: WriteConfig) => Promise<DocumentWriteResult>;
+
+    updateMany: (find: DocumentFind, value: DocumentWriteValue, config?: WriteConfig) => Promise<DocumentWriteResult>;
+
+    mergeOne: (find: DocumentFind, value: DocumentWriteValue, config?: WriteConfig) => Promise<DocumentWriteResult>;
+
+    mergeMany: (find: DocumentFind, value: DocumentWriteValue, config?: WriteConfig) => Promise<DocumentWriteResult>;
+
+    replaceOne: (find: DocumentFind, value: DocumentWriteValue, config?: WriteConfig) => Promise<DocumentWriteResult>;
+
+    putOne: (find: DocumentFind, value: DocumentWriteValue, config?: WriteConfig) => Promise<DocumentWriteResult>;
+
+    deleteOne: (find?: DocumentFind, config?: WriteConfig) => Promise<DocumentWriteResult>;
+
+    deleteMany: (find?: DocumentFind, config?: WriteConfig) => Promise<DocumentWriteResult>;
+}
+
+interface DocumentResult {
+    _id: any
+}
+
+interface DocumentError extends ErrorResponse {
+
+}
+
+interface FetchHttpConfig {
+    retrieval?: GetConfig['retrieval'];
+    disableAuth?: boolean;
+    enableMinimizer?: boolean;
+    rawApproach?: boolean;
+}
+
+type Delievery = 'default' | 'no-cache' | 'no-await' | 'no-await-no-cache' | 'await-no-cache' | 'cache-no-await';
+
+interface WriteConfig {
+    /**
+     * send authentication token along with this request
+     */
+    disableAuth?: boolean;
+
+    /**
+     * This property defines how the write will be committed and sent
+     * 
+     * - default: 
+     * - no-cache: 
+     * - no-await: 
+     * - no-await-no-cache: 
+     * - await-no-cache: 
+     * - cache-no-await: 
+     */
+    delivery?: Delievery;
+}
+
+type Retrieval = 'sticky' | 'sticky-no-await' | 'sticky-reload' | 'default' | 'cache-no-await' | 'no-cache-no-await';
+
+interface GetConfig {
+    excludeFields?: string | string[];
+    returnOnly?: string | string[];
+    extraction?: GetConfigExtraction | GetConfigExtraction[];
+    /**
+     * This property determines how requested data is being access and handled
+     * 
+     * - default: we try getting fresh data from server if server is reachable, else we check if local data exists and return it, if no local data exist we await for client->server connectivity, then try getting the data, return it and cache it for future need. ⚠️ This respect disableCache value
+     * 
+     * - sticky: if local data exists for the specified query, such data is returned and no-ops afterwards. If no local data is found, we await for client->server connectivity and try to get fresh data from serve, return the data and cache it for future need. ⚠️ This does not respect disableCache value
+     * 
+     * - sticky-no-await: if local data exists for the specified query, such data is returned and no-ops afterwards. If no local data is found, we try to get fresh data from serve, we throw an error if server is not reachable else if server returns requested data, we return such data and cache it for future need. ⚠️ This does not respect disableCache value
+     * 
+     * - sticky-reload: if local data exists for the specified query, such data is returned, then we try getting fresh data from the server and caching it for future need. If no local data is found, we await for client->server connectivity and try to get fresh data from serve, return the data and cache it for future need
+     * 
+     * - cache-no-await: we try getting fresh data from server if server is reachable, else we check if local data exists and return it, if no local data exist we throw an error
+     * 
+     * - no-cache-no-await: we try getting fresh data from server if server is reachable, else we throw an error
+     * 
+     * To learn and see more examples on this, Please visit https://brainbehindx.com/mosquito-transport/docs/reading_data/retrieval
+     */
+    retrieval?: Retrieval;
+    /**
+     * - 0: returns data that may have been internally updated locally with updateOne, updateMany, mergeOne, deleteOne, deleteMany, putOne, replaceOne
+     * - 1: returns exact data which was cached in the last query process
+     * 
+     * @defaults - 0
+     * 
+     * To learn and see more examples on this, Please visit https://brainbehindx.com/mosquito-transport/docs/reading_data/retrieval
+     */
+    episode?: 0 | 1;
+    /**
+     * send authentication token along with this request
+     * 
+     * @default - false
+     */
+    disableAuth?: boolean;
+    /**
+     * this reduces duplicate query calls with the same operation resultant to a single request call.
+     * 
+     * - Example:
+     * 
+     * ```js
+     * 
+     * const mserver = new RNMT({ projectUrl: 'http..', accessKey: '..'});
+     * const minimizedUser = ['james', 'john', 'james', 'john'];
+     * const unminimizedUser = ['anthony', 'albert', 'anthony', 'albert'];
+     * 
+     * // operation will be reduced to two request: james and john
+     * 
+     * minimizedUser.forEach(e=> {
+     *   mserver.collection('user').findOne({ _id: e }).get();
+     * });
+     * 
+     * // operation will not be reduced and therefore four request will be sent: anthony, albert, anthony, albert
+     * 
+     * unminimizedUser.forEach(e=> {
+     *   mserver.collection('user').findOne({ _id: e }).get();
+     * });
+     * ```
+     * defaults to false
+     * 
+     * To learn and see more examples on this, Please visit https://brainbehindx.com/mosquito-transport/docs/reading_data/retrieval
+     */
+    disableMinimizer?: boolean;
+}
+
+interface GetConfigExtraction {
+    limit?: number;
+    sort: string;
+    direction?: 'desc' | 'asc' | 1 | -1
+    collection: string;
+    find?: DocumentFind;
+    findOne?: DocumentFind
+}
+
+interface DocumentFind {
+    $and?: any[];
+    $nor?: any[];
+    $or?: any[];
+    $text?: {
+        $search: string;
+        $language?: string;
+        $caseSensitive?: boolean;
+        $diacriticSensitive?: boolean;
+    };
+    // $where?: string | ((this: TSchema) => boolean);
+    $comment?: string | Document;
+}
+
+declare interface Document {
+    [key: string]: any;
+}
+
+interface DocumentWriteResult { }
+
+interface DocumentWriteValue {
+
+}
+
+interface RNMTAuth {
+    customSignin: (email: string, password: string) => Promise<SigninResult>;
+    customSignup: (email: string, password: string, name?: string, metadata?: Object) => Promise<SigninResult>;
+    googleSignin: (token: string) => Promise<SignupResult>;
+    appleSignin: () => Promise<SignupResult>;
+    facebookSignin: () => Promise<SignupResult>;
+    twitterSignin: () => Promise<SignupResult>;
+    githubSignin: () => Promise<SignupResult>;
+    listenVerifiedStatus: (callback?: (verified?: boolean) => void, onError?: (error?: ErrorResponse) => void) => () => void;
+    listenAuthToken: (callback: (token: string) => void) => () => void;
+    getAuthToken: () => Promise<string>;
+    listenAuth: (callback: (auth: AuthData) => void) => () => void;
+    getAuth: () => Promise<AuthData>;
+    signOut: () => Promise<void>;
+    forceRefreshToken: () => Promise<string>;
+}
+
+interface SigninResult {
+    user: AuthData;
+    token: string;
+    refreshToken: string;
+}
+
+interface SignupResult extends SigninResult {
+    isNewUser: boolean;
+}
+
+interface AuthData {
+    email?: string;
+    metadata: Object;
+    signupMethod: 'google' | 'apple' | 'custom' | 'github' | 'twitter' | 'facebook' | string;
+    currentAuthMethod: 'google' | 'apple' | 'custom' | 'github' | 'twitter' | 'facebook' | string;
+    joinedOn: number;
+    encryptionKey: string;
+    uid: string;
+    claims: Object;
+    emailVerified: boolean;
+    profile: {
+        photo: string;
+        name: string;
+    }
+}
+
+interface RNMTStorage {
+    downloadFile: (link: string, onComplete?: (error?: ErrorResponse, filepath?: string) => void, destination?: string, onProgress?: (stats: DownloadProgressStats) => void) => () => void;
+    uploadFile: (file: string, destination: string, onComplete?: (error?: ErrorResponse, downloadUrl?: string) => void, onProgress?: (stats: UploadProgressStats) => void) => () => void;
+    deleteFile: (path: string) => Promise<void>;
+    deleteFolder: (folder: string) => Promise<void>;
+}
+
+interface DownloadProgressStats {
+    receivedBtyes: number;
+    expectedBytes: number;
+    isPaused: boolean;
+    pause: () => void;
+    resume: () => void;
+}
+
+interface UploadProgressStats {
+    sentBtyes: number;
+    totalBytes: number;
+}
+
+interface ErrorResponse {
+    error: string;
+    message: string;
+}
+
+/** @public */
+export declare type Sort = string | Exclude<SortDirection, {
+    $meta: string;
+}> | string[] | {
+    [key: string]: SortDirection;
+} | Map<string, SortDirection> | [string, SortDirection][] | [string, SortDirection];
+
+/** @public */
+export declare type SortDirection = 1 | -1 | 'asc' | 'desc' | 'ascending' | 'descending' | {
+    $meta: string;
+};