@naturalcycles/db-lib 9.4.0 → 9.4.1

package/dist/adapter/cachedb/cache.db.d.ts

@@ -1,4 +1,4 @@
-import { JsonSchemaObject, JsonSchemaRootObject, PartialObjectWithId, Saved } from '@naturalcycles/js-lib';
+import { JsonSchemaObject, JsonSchemaRootObject, ObjectWithId } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { BaseCommonDB } from '../../base.common.db';
 import { CommonDB, CommonDBSupport } from '../../common.db';
@@ -20,13 +20,13 @@ export declare class CacheDB extends BaseCommonDB implements CommonDB {
      * Resets InMemory DB data
      */
     getTables(): Promise<string[]>;
-    getTableSchema<ROW extends PartialObjectWithId>(table: string): Promise<JsonSchemaRootObject<ROW>>;
-    createTable<ROW extends PartialObjectWithId>(table: string, schema: JsonSchemaObject<ROW>, opt?: CacheDBCreateOptions): Promise<void>;
-    getByIds<ROW extends PartialObjectWithId>(table: string, ids: string[], opt?: CacheDBSaveOptions<ROW>): Promise<Saved<ROW>[]>;
-    saveBatch<ROW extends PartialObjectWithId>(table: string, rows: ROW[], opt?: CacheDBSaveOptions<ROW>): Promise<void>;
-    runQuery<ROW extends PartialObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBSaveOptions<ROW>): Promise<RunQueryResult<Saved<ROW>>>;
-    runQueryCount<ROW extends PartialObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBOptions): Promise<number>;
-    streamQuery<ROW extends PartialObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBStreamOptions): ReadableTyped<Saved<ROW>>;
-    deleteByQuery<ROW extends PartialObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBOptions): Promise<number>;
-    updateByQuery<ROW extends PartialObjectWithId>(q: DBQuery<ROW>, patch: DBPatch<ROW>, opt?: CacheDBOptions): Promise<number>;
+    getTableSchema<ROW extends ObjectWithId>(table: string): Promise<JsonSchemaRootObject<ROW>>;
+    createTable<ROW extends ObjectWithId>(table: string, schema: JsonSchemaObject<ROW>, opt?: CacheDBCreateOptions): Promise<void>;
+    getByIds<ROW extends ObjectWithId>(table: string, ids: string[], opt?: CacheDBSaveOptions<ROW>): Promise<ROW[]>;
+    saveBatch<ROW extends ObjectWithId>(table: string, rows: ROW[], opt?: CacheDBSaveOptions<ROW>): Promise<void>;
+    runQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBSaveOptions<ROW>): Promise<RunQueryResult<ROW>>;
+    runQueryCount<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBOptions): Promise<number>;
+    streamQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBStreamOptions): ReadableTyped<ROW>;
+    deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBOptions): Promise<number>;
+    updateByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, patch: DBPatch<ROW>, opt?: CacheDBOptions): Promise<number>;
 }

package/dist/adapter/cachedb/cache.db.model.d.ts

@@ -1,4 +1,4 @@
-import { CommonLogger, PartialObjectWithId } from '@naturalcycles/js-lib';
+import { CommonLogger, ObjectWithId } from '@naturalcycles/js-lib';
 import { CommonDB } from '../../common.db';
 import { CommonDBCreateOptions, CommonDBOptions, CommonDBSaveOptions, CommonDBStreamOptions } from '../../db.model';
 export interface CacheDBCfg {
@@ -47,7 +47,7 @@ export interface CacheDBOptions extends CommonDBOptions {
      */
     onlyCache?: boolean;
 }
-export interface CacheDBSaveOptions<ROW extends PartialObjectWithId> extends CacheDBOptions, CommonDBSaveOptions<ROW> {
+export interface CacheDBSaveOptions<ROW extends ObjectWithId> extends CacheDBOptions, CommonDBSaveOptions<ROW> {
 }
 export interface CacheDBStreamOptions extends CacheDBOptions, CommonDBStreamOptions {
 }

package/dist/adapter/file/file.db.d.ts

@@ -1,4 +1,4 @@
-import { JsonSchemaRootObject, Saved, PartialObjectWithId } from '@naturalcycles/js-lib';
+import { JsonSchemaRootObject, ObjectWithId } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { BaseCommonDB, CommonDBSupport, DBSaveBatchOperation } from '../..';
 import { CommonDB } from '../../common.db';
@@ -21,18 +21,18 @@ export declare class FileDB extends BaseCommonDB implements CommonDB {
     cfg: FileDBCfg;
     ping(): Promise<void>;
     getTables(): Promise<string[]>;
-    getByIds<ROW extends PartialObjectWithId>(table: string, ids: string[], _opt?: CommonDBOptions): Promise<Saved<ROW>[]>;
-    saveBatch<ROW extends PartialObjectWithId>(table: string, rows: ROW[], _opt?: CommonDBSaveOptions<ROW>): Promise<void>;
-    runQuery<ROW extends PartialObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<RunQueryResult<Saved<ROW>>>;
-    runQueryCount<ROW extends PartialObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<number>;
-    streamQuery<ROW extends PartialObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBStreamOptions): ReadableTyped<ROW>;
-    deleteByQuery<ROW extends PartialObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<number>;
+    getByIds<ROW extends ObjectWithId>(table: string, ids: string[], _opt?: CommonDBOptions): Promise<ROW[]>;
+    saveBatch<ROW extends ObjectWithId>(table: string, rows: ROW[], _opt?: CommonDBSaveOptions<ROW>): Promise<void>;
+    runQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<RunQueryResult<ROW>>;
+    runQueryCount<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<number>;
+    streamQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBStreamOptions): ReadableTyped<ROW>;
+    deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<number>;
     deleteByIds(table: string, ids: string[], _opt?: CommonDBOptions): Promise<number>;
-    getTableSchema<ROW extends PartialObjectWithId>(table: string): Promise<JsonSchemaRootObject<ROW>>;
-    loadFile<ROW extends PartialObjectWithId>(table: string): Promise<Saved<ROW>[]>;
-    saveFile<ROW extends PartialObjectWithId>(table: string, _rows: ROW[]): Promise<void>;
-    saveFiles<ROW extends PartialObjectWithId>(ops: DBSaveBatchOperation<ROW>[]): Promise<void>;
-    sortRows<ROW extends PartialObjectWithId>(rows: ROW[]): ROW[];
+    getTableSchema<ROW extends ObjectWithId>(table: string): Promise<JsonSchemaRootObject<ROW>>;
+    loadFile<ROW extends ObjectWithId>(table: string): Promise<ROW[]>;
+    saveFile<ROW extends ObjectWithId>(table: string, _rows: ROW[]): Promise<void>;
+    saveFiles<ROW extends ObjectWithId>(ops: DBSaveBatchOperation<ROW>[]): Promise<void>;
+    sortRows<ROW extends ObjectWithId>(rows: ROW[]): ROW[];
     private logStarted;
     private logFinished;
 }

package/dist/adapter/file/file.db.model.d.ts

@@ -1,10 +1,10 @@
-import { CommonLogger, PartialObjectWithId, Saved } from '@naturalcycles/js-lib';
+import { CommonLogger, ObjectWithId } from '@naturalcycles/js-lib';
 import { DBSaveBatchOperation } from '../../db.model';
 import type { DBQueryOrder } from '../../query/dbQuery';
 export interface FileDBPersistencePlugin {
     ping: () => Promise<void>;
     getTables: () => Promise<string[]>;
-    loadFile: <ROW extends PartialObjectWithId>(table: string) => Promise<Saved<ROW>[]>;
+    loadFile: <ROW extends ObjectWithId>(table: string) => Promise<ROW[]>;
     saveFiles: (ops: DBSaveBatchOperation<any>[]) => Promise<void>;
 }
 export interface FileDBCfg {
@@ -12,7 +12,7 @@ export interface FileDBCfg {
     /**
      * @default undefined, which means "insertion order"
      */
-    sortOnSave?: DBQueryOrder;
+    sortOnSave?: DBQueryOrder<any>;
     /**
      * @default true
      * If true - will run `sortObjectDeep()` on each object to achieve deterministic sort

package/dist/adapter/file/inMemory.persistence.plugin.d.ts

@@ -9,5 +9,5 @@ export declare class InMemoryPersistencePlugin implements FileDBPersistencePlugi
     ping(): Promise<void>;
     getTables(): Promise<string[]>;
     loadFile<ROW extends ObjectWithId>(table: string): Promise<ROW[]>;
-    saveFiles(ops: DBSaveBatchOperation[]): Promise<void>;
+    saveFiles(ops: DBSaveBatchOperation<any>[]): Promise<void>;
 }

package/dist/adapter/file/localFile.persistence.plugin.d.ts

@@ -1,4 +1,4 @@
-import { PartialObjectWithId, Saved } from '@naturalcycles/js-lib';
+import { ObjectWithId } from '@naturalcycles/js-lib';
 import { DBSaveBatchOperation } from '../../db.model';
 import { FileDBPersistencePlugin } from './file.db.model';
 export interface LocalFilePersistencePluginCfg {
@@ -19,7 +19,7 @@ export declare class LocalFilePersistencePlugin implements FileDBPersistencePlug
     cfg: LocalFilePersistencePluginCfg;
     ping(): Promise<void>;
     getTables(): Promise<string[]>;
-    loadFile<ROW extends PartialObjectWithId>(table: string): Promise<Saved<ROW>[]>;
-    saveFiles(ops: DBSaveBatchOperation[]): Promise<void>;
-    saveFile<ROW extends PartialObjectWithId>(table: string, rows: ROW[]): Promise<void>;
+    loadFile<ROW extends ObjectWithId>(table: string): Promise<ROW[]>;
+    saveFiles(ops: DBSaveBatchOperation<any>[]): Promise<void>;
+    saveFile<ROW extends ObjectWithId>(table: string, rows: ROW[]): Promise<void>;
 }

package/dist/adapter/file/noop.persistence.plugin.d.ts

@@ -1,9 +1,9 @@
-import { PartialObjectWithId, Saved } from '@naturalcycles/js-lib';
+import { ObjectWithId } from '@naturalcycles/js-lib';
 import { DBSaveBatchOperation } from '../../db.model';
 import { FileDBPersistencePlugin } from './file.db.model';
 export declare class NoopPersistencePlugin implements FileDBPersistencePlugin {
     ping(): Promise<void>;
     getTables(): Promise<string[]>;
-    loadFile<ROW extends PartialObjectWithId>(_table: string): Promise<Saved<ROW>[]>;
-    saveFiles(_ops: DBSaveBatchOperation[]): Promise<void>;
+    loadFile<ROW extends ObjectWithId>(_table: string): Promise<ROW[]>;
+    saveFiles(_ops: DBSaveBatchOperation<any>[]): Promise<void>;
 }

package/dist/adapter/inmemory/inMemory.db.d.ts

@@ -1,4 +1,4 @@
-import { JsonSchemaObject, StringMap, JsonSchemaRootObject, ObjectWithId, CommonLogger, PartialObjectWithId, Saved } from '@naturalcycles/js-lib';
+import { JsonSchemaObject, StringMap, JsonSchemaRootObject, ObjectWithId, CommonLogger } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { CommonDB, CommonDBTransactionOptions, CommonDBType, DBOperation, DBPatch, DBTransactionFn } from '../..';
 import { CommonDBCreateOptions, CommonDBOptions, CommonDBSaveOptions, DBTransaction, RunQueryResult } from '../../db.model';
@@ -78,16 +78,16 @@ export declare class InMemoryDB implements CommonDB {
      */
     resetCache(_table?: string): Promise<void>;
     getTables(): Promise<string[]>;
-    getTableSchema<ROW extends PartialObjectWithId>(_table: string): Promise<JsonSchemaRootObject<ROW>>;
-    createTable<ROW extends PartialObjectWithId>(_table: string, _schema: JsonSchemaObject<ROW>, opt?: CommonDBCreateOptions): Promise<void>;
-    getByIds<ROW extends PartialObjectWithId>(_table: string, ids: string[], _opt?: CommonDBOptions): Promise<Saved<ROW>[]>;
-    saveBatch<ROW extends PartialObjectWithId>(_table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>): Promise<void>;
-    deleteByQuery<ROW extends PartialObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<number>;
+    getTableSchema<ROW extends ObjectWithId>(_table: string): Promise<JsonSchemaRootObject<ROW>>;
+    createTable<ROW extends ObjectWithId>(_table: string, _schema: JsonSchemaObject<ROW>, opt?: CommonDBCreateOptions): Promise<void>;
+    getByIds<ROW extends ObjectWithId>(_table: string, ids: string[], _opt?: CommonDBOptions): Promise<ROW[]>;
+    saveBatch<ROW extends ObjectWithId>(_table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>): Promise<void>;
+    deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<number>;
     deleteByIds(_table: string, ids: string[], _opt?: CommonDBOptions): Promise<number>;
-    updateByQuery<ROW extends PartialObjectWithId>(q: DBQuery<ROW>, patch: DBPatch<ROW>): Promise<number>;
-    runQuery<ROW extends PartialObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<RunQueryResult<Saved<ROW>>>;
-    runQueryCount<ROW extends PartialObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<number>;
-    streamQuery<ROW extends PartialObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): ReadableTyped<Saved<ROW>>;
+    updateByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, patch: DBPatch<ROW>): Promise<number>;
+    runQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<RunQueryResult<ROW>>;
+    runQueryCount<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<number>;
+    streamQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): ReadableTyped<ROW>;
     runInTransaction(fn: DBTransactionFn, opt?: CommonDBTransactionOptions): Promise<void>;
     /**
      * Flushes all tables (all namespaces) at once.
@@ -104,8 +104,8 @@ export declare class InMemoryDBTransaction implements DBTransaction {
     constructor(db: InMemoryDB, opt: Required<CommonDBTransactionOptions>);
     ops: DBOperation[];
     writeOperationHappened: boolean;
-    getByIds<ROW extends PartialObjectWithId>(table: string, ids: string[], opt?: CommonDBOptions): Promise<ROW[]>;
-    saveBatch<ROW extends PartialObjectWithId>(table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>): Promise<void>;
+    getByIds<ROW extends ObjectWithId>(table: string, ids: string[], opt?: CommonDBOptions): Promise<ROW[]>;
+    saveBatch<ROW extends ObjectWithId>(table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>): Promise<void>;
     deleteByIds(table: string, ids: string[], opt?: CommonDBOptions): Promise<number>;
     commit(): Promise<void>;
     rollback(): Promise<void>;

package/dist/adapter/inmemory/queryInMemory.d.ts

@@ -1,3 +1,3 @@
-import { PartialObjectWithId } from '@naturalcycles/js-lib';
+import { ObjectWithId } from '@naturalcycles/js-lib';
 import { DBQuery } from '../../query/dbQuery';
-export declare function queryInMemory<ROW extends PartialObjectWithId>(q: DBQuery<ROW>, rows?: ROW[]): ROW[];
+export declare function queryInMemory<ROW extends ObjectWithId>(q: DBQuery<ROW>, rows?: ROW[]): ROW[];

package/dist/base.common.db.d.ts

@@ -1,4 +1,4 @@
-import { JsonSchemaObject, JsonSchemaRootObject, PartialObjectWithId, Saved } from '@naturalcycles/js-lib';
+import { JsonSchemaObject, JsonSchemaRootObject, ObjectWithId } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { CommonDB, CommonDBSupport, CommonDBType } from './common.db';
 import { CommonDBOptions, CommonDBSaveOptions, CommonDBTransactionOptions, DBPatch, DBTransactionFn, RunQueryResult } from './db.model';
@@ -12,15 +12,15 @@ export declare class BaseCommonDB implements CommonDB {
     support: CommonDBSupport;
     ping(): Promise<void>;
     getTables(): Promise<string[]>;
-    getTableSchema<ROW extends PartialObjectWithId>(table: string): Promise<JsonSchemaRootObject<ROW>>;
-    createTable<ROW extends PartialObjectWithId>(table: string, schema: JsonSchemaObject<ROW>): Promise<void>;
-    getByIds<ROW extends PartialObjectWithId>(table: string, ids: string[]): Promise<Saved<ROW>[]>;
-    deleteByQuery<ROW extends PartialObjectWithId>(q: DBQuery<ROW>): Promise<number>;
-    updateByQuery<ROW extends PartialObjectWithId>(q: DBQuery<ROW>, patch: DBPatch<ROW>, opt?: CommonDBOptions): Promise<number>;
-    runQuery<ROW extends PartialObjectWithId>(q: DBQuery<ROW>): Promise<RunQueryResult<Saved<ROW>>>;
-    runQueryCount<ROW extends PartialObjectWithId>(q: DBQuery<ROW>): Promise<number>;
-    saveBatch<ROW extends PartialObjectWithId>(table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>): Promise<void>;
-    streamQuery<ROW extends PartialObjectWithId>(q: DBQuery<ROW>): ReadableTyped<Saved<ROW>>;
+    getTableSchema<ROW extends ObjectWithId>(table: string): Promise<JsonSchemaRootObject<ROW>>;
+    createTable<ROW extends ObjectWithId>(table: string, schema: JsonSchemaObject<ROW>): Promise<void>;
+    getByIds<ROW extends ObjectWithId>(table: string, ids: string[]): Promise<ROW[]>;
+    deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>): Promise<number>;
+    updateByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, patch: DBPatch<ROW>, opt?: CommonDBOptions): Promise<number>;
+    runQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>): Promise<RunQueryResult<ROW>>;
+    runQueryCount<ROW extends ObjectWithId>(q: DBQuery<ROW>): Promise<number>;
+    saveBatch<ROW extends ObjectWithId>(table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>): Promise<void>;
+    streamQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>): ReadableTyped<ROW>;
     deleteByIds(table: string, ids: string[], opt?: CommonDBOptions): Promise<number>;
     runInTransaction(fn: DBTransactionFn, opt?: CommonDBTransactionOptions): Promise<void>;
 }

package/dist/common.db.d.ts

@@ -1,4 +1,4 @@
-import { JsonSchemaObject, JsonSchemaRootObject, PartialObjectWithId, Saved } from '@naturalcycles/js-lib';
+import { JsonSchemaObject, JsonSchemaRootObject, ObjectWithId } from '@naturalcycles/js-lib';
 import type { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { CommonDBCreateOptions, CommonDBOptions, CommonDBSaveOptions, CommonDBStreamOptions, CommonDBTransactionOptions, DBPatch, DBTransactionFn, RunQueryResult } from './db.model';
 import { DBQuery } from './query/dbQuery';
@@ -47,27 +47,27 @@ export interface CommonDB {
      *
      * This is important for the code to rely on it, and it's verified by dbTest
      */
-    getTableSchema: <ROW extends PartialObjectWithId>(table: string) => Promise<JsonSchemaRootObject<ROW>>;
+    getTableSchema: <ROW extends ObjectWithId>(table: string) => Promise<JsonSchemaRootObject<ROW>>;
     /**
      * Will do like `create table ...` for mysql.
      * Caution! dropIfExists defaults to false. If set to true - will actually DROP the table!
      */
-    createTable: <ROW extends PartialObjectWithId>(table: string, schema: JsonSchemaObject<ROW>, opt?: CommonDBCreateOptions) => Promise<void>;
+    createTable: <ROW extends ObjectWithId>(table: string, schema: JsonSchemaObject<ROW>, opt?: CommonDBCreateOptions) => Promise<void>;
     /**
      * Order of items returned is not guaranteed to match order of ids.
      * (Such limitation exists because Datastore doesn't support it).
      */
-    getByIds: <ROW extends PartialObjectWithId>(table: string, ids: string[], opt?: CommonDBOptions) => Promise<Saved<ROW>[]>;
+    getByIds: <ROW extends ObjectWithId>(table: string, ids: string[], opt?: CommonDBOptions) => Promise<ROW[]>;
     /**
      * Order by 'id' is not supported by all implementations (for example, Datastore doesn't support it).
      */
-    runQuery: <ROW extends PartialObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBOptions) => Promise<RunQueryResult<Saved<ROW>>>;
-    runQueryCount: <ROW extends PartialObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBOptions) => Promise<number>;
-    streamQuery: <ROW extends PartialObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBStreamOptions) => ReadableTyped<Saved<ROW>>;
+    runQuery: <ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBOptions) => Promise<RunQueryResult<ROW>>;
+    runQueryCount: <ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBOptions) => Promise<number>;
+    streamQuery: <ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBStreamOptions) => ReadableTyped<ROW>;
     /**
      * rows can have missing ids only if DB supports auto-generating them (like mysql auto_increment).
      */
-    saveBatch: <ROW extends PartialObjectWithId>(table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>) => Promise<void>;
+    saveBatch: <ROW extends ObjectWithId>(table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>) => Promise<void>;
     /**
      * Returns number of deleted items.
      * Not supported by all implementations (e.g Datastore will always return same number as number of ids).
@@ -77,7 +77,7 @@ export interface CommonDB {
      * Returns number of deleted items.
      * Not supported by all implementations (e.g Datastore will always return same number as number of ids).
      */
-    deleteByQuery: <ROW extends PartialObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBOptions) => Promise<number>;
+    deleteByQuery: <ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBOptions) => Promise<number>;
     /**
      * Applies patch to the rows returned by the query.
      *
@@ -96,7 +96,7 @@ export interface CommonDB {
      *
      * Returns number of rows affected.
      */
-    updateByQuery: <ROW extends PartialObjectWithId>(q: DBQuery<ROW>, patch: DBPatch<ROW>, opt?: CommonDBOptions) => Promise<number>;
+    updateByQuery: <ROW extends ObjectWithId>(q: DBQuery<ROW>, patch: DBPatch<ROW>, opt?: CommonDBOptions) => Promise<number>;
     /**
      * Should be implemented as a Transaction (best effort), which means that
      * either ALL or NONE of the operations should be applied.

package/dist/commondao/common.dao.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { Transform } from 'node:stream';
-import { AnyObject, AsyncMapper, BaseDBEntity, CommonLogger, JsonSchemaObject, JsonSchemaRootObject, PartialObjectWithId, Saved, UnixTimestampMillisNumber, ZodSchema } from '@naturalcycles/js-lib';
+import { AnyObject, AsyncMapper, BaseDBEntity, CommonLogger, JsonSchemaObject, JsonSchemaRootObject, Saved, UnixTimestampMillisNumber, UnsavedId, ZodSchema } from '@naturalcycles/js-lib';
 import { AjvSchema, ObjectSchema, ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { CommonDBTransactionOptions, DBModelType, DBPatch, DBTransaction, RunQueryResult } from '../db.model';
 import { DBQuery, RunnableDBQuery } from '../query/dbQuery';
@@ -12,7 +12,7 @@ import { CommonDaoCfg, CommonDaoCreateOptions, CommonDaoOptions, CommonDaoSaveBa
  * BM = Backend model (optimized for API access)
  * TM = Transport model (optimized to be sent over the wire)
  */
-export declare class CommonDao<BM extends PartialObjectWithId, DBM extends PartialObjectWithId = BM, TM extends AnyObject = BM> {
+export declare class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM, TM extends AnyObject = BM> {
     cfg: CommonDaoCfg<BM, DBM, TM>;
     constructor(cfg: CommonDaoCfg<BM, DBM, TM>);
     create(part?: Partial<BM>, opt?: CommonDaoOptions): Saved<BM>;
@@ -82,11 +82,11 @@ export declare class CommonDao<BM extends PartialObjectWithId, DBM extends Parti
      * Mutates!
      * "Returns", just to have a type of "Saved"
      */
-    assignIdCreatedUpdated<T extends BaseDBEntity>(obj: T, opt?: CommonDaoOptions): Saved<T>;
+    assignIdCreatedUpdated<T extends BaseDBEntity>(obj: Partial<T>, opt?: CommonDaoOptions): T;
     /**
      * Mutates with id, created, updated
      */
-    save(bm: BM, opt?: CommonDaoSaveOptions<BM, DBM>): Promise<Saved<BM>>;
+    save(bm: UnsavedId<BM>, opt?: CommonDaoSaveOptions<BM, DBM>): Promise<Saved<BM>>;
     /**
      * 1. Applies the patch
      * 2. If object is the same after patching - skips saving it
@@ -95,7 +95,7 @@ export declare class CommonDao<BM extends PartialObjectWithId, DBM extends Parti
      * Similar to `save` with skipIfEquals.
      * Similar to `patch`, but doesn't load the object from the Database.
      */
-    savePatch(bm: Saved<BM>, patch: Partial<BM>, opt: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>>;
+    savePatch(bm: BM, patch: Partial<BM>, opt: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>>;
     /**
      * Convenience method to replace 3 operations (loading+patching+saving) with one:
      *
@@ -116,14 +116,14 @@ export declare class CommonDao<BM extends PartialObjectWithId, DBM extends Parti
      * Otherwise, similar behavior as patchById.
      * It still loads the row from the DB.
      */
-    patch(bm: Saved<BM>, patch: Partial<BM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>>;
+    patch(bm: BM, patch: Partial<BM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>>;
     /**
      * Like patch, but runs all operations within a Transaction.
      */
-    patchInTransaction(bm: Saved<BM>, patch: Partial<BM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>>;
-    saveAsDBM(dbm: DBM, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<DBM>>;
-    saveBatch(bms: BM[], opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>[]>;
-    saveBatchAsDBM(dbms: DBM[], opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<DBM>[]>;
+    patchInTransaction(bm: BM, patch: Partial<BM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>>;
+    saveAsDBM(dbm: UnsavedId<DBM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<DBM>>;
+    saveBatch(bms: UnsavedId<BM>[], opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>[]>;
+    saveBatchAsDBM(dbms: UnsavedId<DBM>[], opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<DBM>[]>;
     /**
      * "Streaming" is implemented by buffering incoming rows into **batches**
      * (of size opt.batchSize, which defaults to 500),
@@ -147,8 +147,8 @@ export declare class CommonDao<BM extends PartialObjectWithId, DBM extends Parti
     updateByIds(ids: string[], patch: DBPatch<DBM>, opt?: CommonDaoOptions): Promise<number>;
     updateByQuery(q: DBQuery<DBM>, patch: DBPatch<DBM>, opt?: CommonDaoOptions): Promise<number>;
     dbmToBM(_dbm: undefined, opt?: CommonDaoOptions): Promise<undefined>;
-    dbmToBM(_dbm?: Saved<DBM>, opt?: CommonDaoOptions): Promise<Saved<BM>>;
-    dbmsToBM(dbms: Saved<DBM>[], opt?: CommonDaoOptions): Promise<Saved<BM>[]>;
+    dbmToBM(_dbm?: DBM, opt?: CommonDaoOptions): Promise<Saved<BM>>;
+    dbmsToBM(dbms: DBM[], opt?: CommonDaoOptions): Promise<Saved<BM>[]>;
     /**
      * Mutates object with properties: id, created, updated.
      * Returns DBM (new reference).
@@ -158,10 +158,10 @@ export declare class CommonDao<BM extends PartialObjectWithId, DBM extends Parti
     bmsToDBM(bms: BM[], opt?: CommonDaoOptions): Promise<Saved<DBM>[]>;
     anyToDBM(dbm: undefined, opt?: CommonDaoOptions): undefined;
     anyToDBM(dbm?: any, opt?: CommonDaoOptions): Saved<DBM>;
-    anyToDBMs(entities: Saved<DBM>[], opt?: CommonDaoOptions): Saved<DBM>[];
+    anyToDBMs(entities: DBM[], opt?: CommonDaoOptions): Saved<DBM>[];
     bmToTM(bm: undefined, opt?: CommonDaoOptions): TM | undefined;
-    bmToTM(bm?: Saved<BM>, opt?: CommonDaoOptions): TM;
-    bmsToTM(bms: Saved<BM>[], opt?: CommonDaoOptions): TM[];
+    bmToTM(bm?: BM, opt?: CommonDaoOptions): TM;
+    bmsToTM(bms: BM[], opt?: CommonDaoOptions): TM[];
     /**
      * Returns *converted value*.
      * Validates (unless `skipValidation=true` passed).
@@ -199,10 +199,10 @@ export declare class CommonDaoTransaction {
      * Perform a graceful rollback without throwing/re-throwing any error.
      */
     rollback(): Promise<void>;
-    getById<BM extends PartialObjectWithId, DBM extends PartialObjectWithId>(dao: CommonDao<BM, DBM, any>, id?: string | null, opt?: CommonDaoOptions): Promise<Saved<BM> | null>;
-    getByIds<BM extends PartialObjectWithId, DBM extends PartialObjectWithId>(dao: CommonDao<BM, DBM, any>, ids: string[], opt?: CommonDaoOptions): Promise<Saved<BM>[]>;
-    save<BM extends PartialObjectWithId, DBM extends PartialObjectWithId>(dao: CommonDao<BM, DBM, any>, bm: BM, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>>;
-    saveBatch<BM extends PartialObjectWithId, DBM extends PartialObjectWithId>(dao: CommonDao<BM, DBM, any>, bms: BM[], opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>[]>;
+    getById<BM extends BaseDBEntity, DBM extends BaseDBEntity>(dao: CommonDao<BM, DBM, any>, id?: string | null, opt?: CommonDaoOptions): Promise<Saved<BM> | null>;
+    getByIds<BM extends BaseDBEntity, DBM extends BaseDBEntity>(dao: CommonDao<BM, DBM, any>, ids: string[], opt?: CommonDaoOptions): Promise<Saved<BM>[]>;
+    save<BM extends BaseDBEntity, DBM extends BaseDBEntity>(dao: CommonDao<BM, DBM, any>, bm: UnsavedId<BM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>>;
+    saveBatch<BM extends BaseDBEntity, DBM extends BaseDBEntity>(dao: CommonDao<BM, DBM, any>, bms: UnsavedId<BM>[], opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>[]>;
     deleteById(dao: CommonDao<any>, id?: string | null, opt?: CommonDaoOptions): Promise<number>;
     deleteByIds(dao: CommonDao<any>, ids: string[], opt?: CommonDaoOptions): Promise<number>;
 }

package/dist/commondao/common.dao.js

@@ -508,6 +508,7 @@ class CommonDao {
         }
         const idWasGenerated = !bm.id && this.cfg.generateId;
         this.assignIdCreatedUpdated(bm, opt); // mutates
+        (0, js_lib_1._typeCast)(bm);
         let dbm = await this.bmToDBM(bm, opt);
         if (this.cfg.hooks.beforeSave) {
             dbm = (await this.cfg.hooks.beforeSave(dbm));

package/dist/commondao/common.dao.model.d.ts

@@ -1,8 +1,8 @@
-import { AnyObject, CommonLogger, ErrorMode, PartialObjectWithId, Promisable, Saved, ZodError, ZodSchema } from '@naturalcycles/js-lib';
+import { AnyObject, BaseDBEntity, CommonLogger, ErrorMode, Promisable, Saved, ZodError, ZodSchema } from '@naturalcycles/js-lib';
 import { AjvSchema, AjvValidationError, JoiValidationError, ObjectSchema, TransformLogProgressOptions, TransformMapOptions } from '@naturalcycles/nodejs-lib';
 import { CommonDB } from '../common.db';
 import { CommonDBCreateOptions, CommonDBOptions, CommonDBSaveOptions } from '../db.model';
-export interface CommonDaoHooks<BM extends PartialObjectWithId, DBM extends PartialObjectWithId, TM> {
+export interface CommonDaoHooks<BM extends BaseDBEntity, DBM extends BaseDBEntity, TM> {
     /**
      * Allows to override the id generation function.
      * By default it uses `stringId` from nodejs-lib
@@ -38,7 +38,7 @@ export interface CommonDaoHooks<BM extends PartialObjectWithId, DBM extends Part
      * as it only validates "final state", not intermediate
      */
     beforeDBMValidate: (dbm: Partial<DBM>) => Partial<DBM>;
-    beforeDBMToBM: (dbm: Saved<DBM>) => Partial<BM> | Promise<Partial<BM>>;
+    beforeDBMToBM: (dbm: DBM) => Partial<BM> | Promise<Partial<BM>>;
     beforeBMToDBM: (bm: BM) => Partial<DBM> | Promise<Partial<DBM>>;
     beforeBMToTM: (bm: BM) => Partial<TM>;
     /**
@@ -77,7 +77,7 @@ export interface CommonDaoHooks<BM extends PartialObjectWithId, DBM extends Part
      * It still applies to BM "transitively", during dbmToBM
      * (e.g after loaded from the Database).
      */
-    anonymize: (dbm: Saved<DBM>) => Saved<DBM>;
+    anonymize: (dbm: DBM) => DBM;
     /**
      * If hook is defined - allows to prevent or modify the error thrown.
      * Return `false` to prevent throwing an error.
@@ -104,7 +104,7 @@ export declare enum CommonDaoLogLevel {
      */
     DATA_FULL = 30
 }
-export interface CommonDaoCfg<BM extends PartialObjectWithId, DBM extends PartialObjectWithId = BM, TM extends AnyObject = BM> {
+export interface CommonDaoCfg<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM, TM extends AnyObject = BM> {
     db: CommonDB;
     table: string;
     /**
@@ -230,7 +230,7 @@ export interface CommonDaoOptions extends CommonDBOptions {
      */
     table?: string;
 }
-export interface CommonDaoSaveOptions<BM extends PartialObjectWithId, DBM extends PartialObjectWithId> extends CommonDaoSaveBatchOptions<DBM> {
+export interface CommonDaoSaveOptions<BM extends BaseDBEntity, DBM extends BaseDBEntity> extends CommonDaoSaveBatchOptions<DBM> {
     /**
      * If provided - a check will be made.
      * If the object for saving equals to the object passed to `skipIfEquals` - save operation will be skipped.
@@ -244,7 +244,7 @@ export interface CommonDaoSaveOptions<BM extends PartialObjectWithId, DBM extend
 /**
  * All properties default to undefined.
  */
-export interface CommonDaoSaveBatchOptions<DBM extends PartialObjectWithId> extends CommonDaoOptions, CommonDBSaveOptions<DBM> {
+export interface CommonDaoSaveBatchOptions<DBM extends BaseDBEntity> extends CommonDaoOptions, CommonDBSaveOptions<DBM> {
     /**
      * @default false
      *
@@ -256,9 +256,9 @@ export interface CommonDaoSaveBatchOptions<DBM extends PartialObjectWithId> exte
      */
     ensureUniqueId?: boolean;
 }
-export interface CommonDaoStreamDeleteOptions<DBM extends PartialObjectWithId> extends CommonDaoStreamOptions<DBM> {
+export interface CommonDaoStreamDeleteOptions<DBM extends BaseDBEntity> extends CommonDaoStreamOptions<DBM> {
 }
-export interface CommonDaoStreamSaveOptions<DBM extends PartialObjectWithId> extends CommonDaoSaveBatchOptions<DBM>, CommonDaoStreamOptions<DBM> {
+export interface CommonDaoStreamSaveOptions<DBM extends BaseDBEntity> extends CommonDaoSaveBatchOptions<DBM>, CommonDaoStreamOptions<DBM> {
 }
 export interface CommonDaoStreamForEachOptions<IN> extends CommonDaoStreamOptions<IN>, TransformMapOptions<IN, any> {
 }

package/dist/db.model.d.ts

@@ -1,4 +1,4 @@
-import type { PartialObjectWithId } from '@naturalcycles/js-lib';
+import { ObjectWithId } from '@naturalcycles/js-lib';
 import { CommonDB } from './common.db';
 /**
  * Similar to SQL INSERT, UPDATE.
@@ -48,7 +48,7 @@ export interface CommonDBOptions {
 /**
  * All properties default to undefined.
  */
-export interface CommonDBSaveOptions<ROW extends PartialObjectWithId = any> extends CommonDBOptions {
+export interface CommonDBSaveOptions<ROW extends ObjectWithId> extends CommonDBOptions {
     excludeFromIndexes?: (keyof ROW)[];
     /**
      * Default is `upsert`
@@ -75,8 +75,8 @@ export interface RunQueryResult<T> {
     rows: T[];
     endCursor?: string;
 }
-export type DBOperation = DBSaveBatchOperation | DBDeleteByIdsOperation;
-export interface DBSaveBatchOperation<ROW extends PartialObjectWithId = any> {
+export type DBOperation = DBSaveBatchOperation<any> | DBDeleteByIdsOperation;
+export interface DBSaveBatchOperation<ROW extends ObjectWithId> {
     type: 'saveBatch';
     table: string;
     rows: ROW[];
@@ -109,4 +109,4 @@ export declare class DBIncrement {
     private constructor();
     static of(amount: number): DBIncrement;
 }
-export type DBPatch<ROW extends PartialObjectWithId> = Partial<Record<keyof ROW, ROW[keyof ROW] | DBIncrement>>;
+export type DBPatch<ROW extends ObjectWithId> = Partial<Record<keyof ROW, ROW[keyof ROW] | DBIncrement>>;

package/dist/pipeline/dbPipelineBackup.d.ts

@@ -46,7 +46,7 @@ export interface DBPipelineBackupOptions extends TransformLogProgressOptions {
      * But if queryPerTable is set for a table - it will override the Query that is ran for that table
      * (and ignore sinceUpdated, sinceUpdatedPerTable, limit, and any other properties that modify the query).
      */
-    queryPerTable?: StringMap<DBQuery>;
+    queryPerTable?: StringMap<DBQuery<any>>;
     /**
      * Directory path to store dumped files. Will create `${tableName}.ndjson` (or .ndjson.gz if gzip=true) files.
      * All parent directories will be created.

package/dist/pipeline/dbPipelineCopy.d.ts

@@ -55,7 +55,7 @@ export interface DBPipelineCopyOptions extends TransformLogProgressOptions {
      * `metric` will be set to table name
      */
     transformMapOptions?: TransformMapOptions;
-    saveOptionsPerTable?: Record<string, CommonDBSaveOptions>;
+    saveOptionsPerTable?: Record<string, CommonDBSaveOptions<any>>;
 }
 /**
  * Pipeline from input stream(s) to CommonDB .saveBatch().

package/dist/pipeline/dbPipelineRestore.d.ts

@@ -68,7 +68,7 @@ export interface DBPipelineRestoreOptions extends TransformLogProgressOptions {
      * `metric` will be set to table name
      */
     transformMapOptions?: TransformMapOptions;
-    saveOptionsPerTable?: Record<string, CommonDBSaveOptions>;
+    saveOptionsPerTable?: Record<string, CommonDBSaveOptions<any>>;
 }
 /**
  * Pipeline from NDJSON files in a folder (optionally gzipped) to CommonDB.

package/dist/query/dbQuery.d.ts

@@ -1,4 +1,4 @@
-import { AsyncMapper, Saved, AnyObject, PartialObjectWithId, AnyPartialObjectWithId } from '@naturalcycles/js-lib';
+import { AsyncMapper, Saved, AnyObject, BaseDBEntity, ObjectWithId } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { CommonDaoOptions, CommonDaoStreamDeleteOptions, CommonDaoStreamForEachOptions, CommonDaoStreamOptions, DBPatch } from '..';
 import { CommonDao } from '../commondao/common.dao';
@@ -24,12 +24,12 @@ import { RunQueryResult } from '../db.model';
  */
 export type DBQueryFilterOperator = '<' | '<=' | '==' | '!=' | '>=' | '>' | 'in' | 'not-in' | 'array-contains' | 'array-contains-any';
 export declare const dbQueryFilterOperatorValues: DBQueryFilterOperator[];
-export interface DBQueryFilter<ROW extends PartialObjectWithId = AnyPartialObjectWithId> {
+export interface DBQueryFilter<ROW extends ObjectWithId> {
     name: keyof ROW;
     op: DBQueryFilterOperator;
     val: any;
 }
-export interface DBQueryOrder<ROW extends PartialObjectWithId = AnyPartialObjectWithId> {
+export interface DBQueryOrder<ROW extends ObjectWithId> {
     name: keyof ROW;
     descending?: boolean;
 }
@@ -43,14 +43,14 @@ export interface DBQueryOrder<ROW extends PartialObjectWithId = AnyPartialObject
  *
  * <DBM> is the type of **queried** object (so e.g `key of DBM` can be used), not **returned** object.
  */
-export declare class DBQuery<ROW extends PartialObjectWithId = AnyPartialObjectWithId> {
+export declare class DBQuery<ROW extends ObjectWithId> {
     table: string;
     constructor(table: string);
     /**
      * Convenience method.
      */
-    static create<ROW extends PartialObjectWithId = AnyPartialObjectWithId>(table: string): DBQuery<ROW>;
-    static fromPlainObject<ROW extends PartialObjectWithId = AnyPartialObjectWithId>(obj: Partial<DBQuery<ROW>> & {
+    static create<ROW extends ObjectWithId>(table: string): DBQuery<ROW>;
+    static fromPlainObject<ROW extends ObjectWithId>(obj: Partial<DBQuery<ROW>> & {
         table: string;
     }): DBQuery<ROW>;
     _filters: DBQueryFilter<ROW>[];
@@ -84,7 +84,7 @@ export declare class DBQuery<ROW extends PartialObjectWithId = AnyPartialObjectW
 /**
  * DBQuery that has additional method to support Fluent API style.
  */
-export declare class RunnableDBQuery<BM extends PartialObjectWithId, DBM extends PartialObjectWithId = BM, TM extends AnyObject = BM> extends DBQuery<DBM> {
+export declare class RunnableDBQuery<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM, TM extends AnyObject = BM> extends DBQuery<DBM> {
     dao: CommonDao<BM, DBM, TM>;
     /**
      * Pass `table` to override table.

package/dist/transaction/dbTransaction.util.d.ts

@@ -1,4 +1,4 @@
-import { PartialObjectWithId } from '@naturalcycles/js-lib';
+import { ObjectWithId } from '@naturalcycles/js-lib';
 import type { CommonDB } from '../common.db';
 import { CommonDBOptions, CommonDBSaveOptions, DBTransaction } from '../db.model';
 /**
@@ -22,7 +22,7 @@ export declare class FakeDBTransaction implements DBTransaction {
     protected db: CommonDB;
     constructor(db: CommonDB);
     rollback(): Promise<void>;
-    getByIds<ROW extends PartialObjectWithId>(table: string, ids: string[], opt?: CommonDBOptions): Promise<ROW[]>;
-    saveBatch<ROW extends PartialObjectWithId>(table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>): Promise<void>;
+    getByIds<ROW extends ObjectWithId>(table: string, ids: string[], opt?: CommonDBOptions): Promise<ROW[]>;
+    saveBatch<ROW extends ObjectWithId>(table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>): Promise<void>;
     deleteByIds(table: string, ids: string[], opt?: CommonDBOptions | undefined): Promise<number>;
 }

package/dist/validation/index.d.ts

@@ -3,6 +3,6 @@ import { DBQuery, DBQueryFilter, DBQueryFilterOperator, DBQueryOrder } from '../
 export declare const commonDBOptionsSchema: import("joi").ObjectSchema<CommonDBOptions>;
 export declare const commonDBSaveOptionsSchema: import("joi").ObjectSchema<CommonDBSaveOptions<any>>;
 export declare const dbQueryFilterOperatorSchema: import("@naturalcycles/nodejs-lib/dist/validation/joi/string.extensions").StringSchema<DBQueryFilterOperator>;
-export declare const dbQueryFilterSchema: import("joi").ObjectSchema<DBQueryFilter<import("@naturalcycles/js-lib").AnyPartialObjectWithId>>;
-export declare const dbQueryOrderSchema: import("joi").ObjectSchema<DBQueryOrder<import("@naturalcycles/js-lib").AnyPartialObjectWithId>>;
+export declare const dbQueryFilterSchema: import("joi").ObjectSchema<DBQueryFilter<any>>;
+export declare const dbQueryOrderSchema: import("joi").ObjectSchema<DBQueryOrder<any>>;
 export declare const dbQuerySchema: import("joi").ObjectSchema<DBQuery<any>>;