@wxn0brp/db-core 0.10.0 → 0.10.1

package/dist/base/actions.d.ts

@@ -1,6 +1,6 @@
 import { ActionsBaseInterface } from "../types/action.js";
 import { DataInternal } from "../types/data.js";
-import * as Query from "../types/query.js";
+import { VQueryT } from "../types/query.js";
 export declare abstract class ActionsBase implements ActionsBaseInterface {
     _inited: boolean;
     numberId: boolean;
@@ -9,13 +9,13 @@ export declare abstract class ActionsBase implements ActionsBaseInterface {
     abstract ensureCollection(collection: string): Promise<boolean>;
     abstract issetCollection(collection: string): Promise<boolean>;
     abstract removeCollection(collection: string): Promise<boolean>;
-    abstract add(config: Query.AddQuery): Promise<DataInternal>;
-    abstract find(config: Query.FindQuery): Promise<DataInternal[]>;
-    abstract findOne(config: Query.FindOneQuery): Promise<DataInternal | null>;
-    abstract update(config: Query.UpdateQuery): Promise<DataInternal[]>;
-    abstract updateOne(config: Query.UpdateQuery): Promise<DataInternal | null>;
-    abstract remove(config: Query.RemoveQuery): Promise<DataInternal[]>;
-    abstract removeOne(config: Query.RemoveQuery): Promise<DataInternal | null>;
-    updateOneOrAdd(config: Query.UpdateOneOrAddQuery): Promise<Query.UpdateOneOrAddResult<DataInternal>>;
-    toggleOne(config: Query.ToggleOneQuery): Promise<Query.ToggleOneResult<DataInternal>>;
+    abstract add(config: VQueryT.Add): Promise<DataInternal>;
+    abstract find(config: VQueryT.Find): Promise<DataInternal[]>;
+    abstract findOne(config: VQueryT.FindOne): Promise<DataInternal | null>;
+    abstract update(config: VQueryT.Update): Promise<DataInternal[]>;
+    abstract updateOne(config: VQueryT.Update): Promise<DataInternal | null>;
+    abstract remove(config: VQueryT.Remove): Promise<DataInternal[]>;
+    abstract removeOne(config: VQueryT.Remove): Promise<DataInternal | null>;
+    updateOneOrAdd(config: VQueryT.UpdateOneOrAdd): Promise<VQueryT.UpdateOneOrAddResult<DataInternal>>;
+    toggleOne(config: VQueryT.ToggleOne): Promise<VQueryT.ToggleOneResult<DataInternal>>;
 }

package/dist/base/custom.d.ts

@@ -1,6 +1,6 @@
 import { CustomFileCpu } from "../customFileCpu.js";
 import { Data } from "../types/data.js";
-import * as Query from "../types/query.js";
+import { VQueryT } from "../types/query.js";
 import { ActionsBase } from "./actions.js";
 export declare abstract class CustomActionsBase extends ActionsBase {
     fileCpu: CustomFileCpu;
@@ -8,29 +8,29 @@ export declare abstract class CustomActionsBase extends ActionsBase {
     /**
      * Add a new entry to the specified database.
      */
-    add(query: Query.AddQuery): Promise<import("../types/arg.js").Arg<Data>>;
+    add(query: VQueryT.Add): Promise<import("../types/arg.js").Arg<Data>>;
     /**
      * Find entries in the specified database based on search criteria.
      */
-    find(query: Query.FindQuery): Promise<Data[]>;
+    find(query: VQueryT.Find): Promise<Data[]>;
     /**
      * Find the first matching entry in the specified database based on search criteria.
      */
-    findOne(query: Query.FindOneQuery): Promise<Data>;
+    findOne(query: VQueryT.FindOne): Promise<Data>;
     /**
      * Update entries in the specified database based on search criteria and an updater function or object.
      */
-    update(query: Query.UpdateQuery): Promise<Data[]>;
+    update(query: VQueryT.Update): Promise<Data[]>;
     /**
      * Update the first matching entry in the specified database based on search criteria and an updater function or object.
      */
-    updateOne(query: Query.UpdateQuery): Promise<Data>;
+    updateOne(query: VQueryT.Update): Promise<Data>;
     /**
      * Remove entries from the specified database based on search criteria.
      */
-    remove(query: Query.RemoveQuery): Promise<Data[]>;
+    remove(query: VQueryT.Remove): Promise<Data[]>;
     /**
      * Remove the first matching entry from the specified database based on search criteria.
      */
-    removeOne(query: Query.RemoveQuery): Promise<Data>;
+    removeOne(query: VQueryT.Remove): Promise<Data>;
 }

package/dist/customFileCpu.d.ts

@@ -1,6 +1,6 @@
 import { Data } from "./types/data.js";
 import { FileCpu } from "./types/fileCpu.js";
-import * as Query from "./types/query.js";
+import { VQueryT } from "./types/query.js";
 export type WriteFile = (file: string, data: any[]) => Promise<void>;
 export type ReadFile = (file: string) => Promise<any[]>;
 export declare function pathRepair(path: string): string;
@@ -8,9 +8,9 @@ export declare class CustomFileCpu implements FileCpu {
     _readFile: ReadFile;
     _writeFile: WriteFile;
     constructor(readFile: ReadFile, writeFile: WriteFile);
-    add(file: string, config: Query.AddQuery): Promise<void>;
-    find(file: string, config: Query.FindQuery): Promise<Data[]>;
-    findOne(file: string, config: Query.FindOneQuery): Promise<Data | false>;
-    remove(file: string, config: Query.RemoveQuery, one: boolean): Promise<Data[]>;
-    update(file: string, config: Query.UpdateQuery, one: boolean): Promise<Data[]>;
+    add(file: string, config: VQueryT.Add): Promise<void>;
+    find(file: string, config: VQueryT.Find): Promise<Data[]>;
+    findOne(file: string, config: VQueryT.FindOne): Promise<Data | false>;
+    remove(file: string, config: VQueryT.Remove, one: boolean): Promise<Data[]>;
+    update(file: string, config: VQueryT.Update, one: boolean): Promise<Data[]>;
 }

package/dist/db/multiStorage.d.ts

@@ -1,17 +1,17 @@
 import { ActionsBase } from "../base/actions.js";
-import * as Query from "../types/query.js";
+import { VQueryT } from "../types/query.js";
 export declare class MultiBackend extends ActionsBase {
     backends: ActionsBase[];
     primaryBackend: ActionsBase;
     constructor(backends: ActionsBase[], primaryIndex?: number);
     init(...args: any[]): Promise<void>;
-    add(config: Query.AddQuery): Promise<import("../types/data.js").DataInternal>;
-    find(config: Query.FindQuery): Promise<import("../types/data.js").DataInternal[]>;
-    findOne(config: Query.FindOneQuery): Promise<import("../types/data.js").DataInternal>;
-    update(config: Query.UpdateQuery): Promise<import("../types/data.js").DataInternal[]>;
-    updateOne(config: Query.UpdateQuery): Promise<import("../types/data.js").DataInternal>;
-    remove(config: Query.RemoveQuery): Promise<import("../types/data.js").DataInternal[]>;
-    removeOne(config: Query.RemoveQuery): Promise<import("../types/data.js").DataInternal>;
+    add(config: VQueryT.Add): Promise<import("../types/data.js").DataInternal>;
+    find(config: VQueryT.Find): Promise<import("../types/data.js").DataInternal[]>;
+    findOne(config: VQueryT.FindOne): Promise<import("../types/data.js").DataInternal>;
+    update(config: VQueryT.Update): Promise<import("../types/data.js").DataInternal[]>;
+    updateOne(config: VQueryT.Update): Promise<import("../types/data.js").DataInternal>;
+    remove(config: VQueryT.Remove): Promise<import("../types/data.js").DataInternal[]>;
+    removeOne(config: VQueryT.Remove): Promise<import("../types/data.js").DataInternal>;
     ensureCollection(collection: string): Promise<boolean>;
     issetCollection(collection: string): Promise<boolean>;
     removeCollection(collection: string): Promise<boolean>;

package/dist/db/routedStorage.d.ts

@@ -1,6 +1,6 @@
 import { ActionsBase } from "../base/actions.js";
-import * as Query from "../types/query.js";
-export type MatchRule = string | RegExp | ((config: Query.VQuery) => boolean);
+import { VQueryT, VQuery } from "../types/query.js";
+export type MatchRule = string | RegExp | ((config: VQuery) => boolean);
 export interface RouteEntry {
     match: MatchRule;
     backends: ActionsBase[];
@@ -9,17 +9,17 @@ export declare class RoutedStorage extends ActionsBase {
     rules: RouteEntry[];
     defaultBackend: ActionsBase[];
     constructor(rules: RouteEntry[], defaultBackend: ActionsBase | ActionsBase[]);
-    _matchBackends(config: Query.VQuery): ActionsBase[];
-    _withAll<T>(config: Query.VQuery | string, fn: (b: ActionsBase) => Promise<T>, gather?: boolean): Promise<T>;
-    _withFirst<T>(config: Query.VQuery | string, fn: (b: ActionsBase) => Promise<T>): Promise<T>;
+    _matchBackends(config: VQuery): ActionsBase[];
+    _withAll<T>(config: VQuery | string, fn: (b: ActionsBase) => Promise<T>, gather?: boolean): Promise<T>;
+    _withFirst<T>(config: VQuery | string, fn: (b: ActionsBase) => Promise<T>): Promise<T>;
     init(...args: any[]): Promise<void>;
-    add(config: Query.AddQuery): Promise<import("../types/data.js").DataInternal>;
-    find(config: Query.FindQuery): Promise<import("../types/data.js").DataInternal[]>;
-    findOne(config: Query.FindOneQuery): Promise<import("../types/data.js").DataInternal>;
-    update(config: Query.UpdateQuery): Promise<import("../types/data.js").DataInternal[]>;
-    updateOne(config: Query.UpdateQuery): Promise<import("../types/data.js").DataInternal>;
-    remove(config: Query.RemoveQuery): Promise<import("../types/data.js").DataInternal[]>;
-    removeOne(config: Query.RemoveQuery): Promise<import("../types/data.js").DataInternal>;
+    add(config: VQueryT.Add): Promise<import("../types/data.js").DataInternal>;
+    find(config: VQueryT.Find): Promise<import("../types/data.js").DataInternal[]>;
+    findOne(config: VQueryT.FindOne): Promise<import("../types/data.js").DataInternal>;
+    update(config: VQueryT.Update): Promise<import("../types/data.js").DataInternal[]>;
+    updateOne(config: VQueryT.Update): Promise<import("../types/data.js").DataInternal>;
+    remove(config: VQueryT.Remove): Promise<import("../types/data.js").DataInternal[]>;
+    removeOne(config: VQueryT.Remove): Promise<import("../types/data.js").DataInternal>;
     ensureCollection(collection: string): Promise<boolean>;
     issetCollection(collection: string): Promise<boolean>;
     removeCollection(collection: string): Promise<boolean>;

package/dist/db/valthera.d.ts

@@ -4,7 +4,7 @@ import { Collection } from "../helpers/collection.js";
 import { Executor } from "../helpers/executor.js";
 import { Data } from "../types/data.js";
 import { DbOpts } from "../types/options.js";
-import { AddQuery, FindOneQuery, FindQuery, RemoveQuery, ToggleOneQuery, ToggleOneResult, UpdateOneOrAddQuery, UpdateOneOrAddResult, UpdateQuery, VQuery } from "../types/query.js";
+import { VQueryT, VQuery } from "../types/query.js";
 import { ValtheraCompatible } from "../types/valthera.js";
 /**
  * Represents a database management class for performing CRUD operations.
@@ -41,42 +41,42 @@ export declare class ValtheraClass implements ValtheraCompatible {
     /**
      * Add data to a database.
      */
-    add<T = Data>(query: AddQuery<T>): Promise<T>;
+    add<T = Data>(query: VQueryT.Add<T>): Promise<T>;
     /**
      * Find data in a database.
      */
-    find<T = Data>(query: FindQuery<T>): Promise<T[]>;
+    find<T = Data>(query: VQueryT.Find<T>): Promise<T[]>;
     /**
      * Find one data entry in a database.
      */
-    findOne<T = Data>(query: FindOneQuery<T>): Promise<T>;
+    findOne<T = Data>(query: VQueryT.FindOne<T>): Promise<T>;
     /**
      * Update data in a database.
      */
-    update<T = Data>(query: UpdateQuery<T>): Promise<T[]>;
+    update<T = Data>(query: VQueryT.Update<T>): Promise<T[]>;
     /**
      * Update one data entry in a database.
      */
-    updateOne<T = Data>(query: UpdateQuery<T>): Promise<T>;
+    updateOne<T = Data>(query: VQueryT.Update<T>): Promise<T>;
     /**
      * Remove data from a database.
      */
-    remove<T = Data>(query: RemoveQuery<T>): Promise<T[]>;
+    remove<T = Data>(query: VQueryT.Remove<T>): Promise<T[]>;
     /**
      * Remove one data entry from a database.
      */
-    removeOne<T = Data>(query: RemoveQuery<T>): Promise<T>;
+    removeOne<T = Data>(query: VQueryT.Remove<T>): Promise<T>;
     /**
      * Asynchronously updates one entry in a database or adds a new one if it doesn't exist.
      */
-    updateOneOrAdd<T = Data>(query: UpdateOneOrAddQuery<T>): Promise<UpdateOneOrAddResult<T>>;
+    updateOneOrAdd<T = Data>(query: VQueryT.UpdateOneOrAdd<T>): Promise<VQueryT.UpdateOneOrAddResult<T>>;
     /**
      * Asynchronously removes one entry in a database or adds a new one if it doesn't exist. Usage e.g. for toggling a flag.
      * Returns a promise resolving to `false` if the entry was found and removed,
      * or `true` if the entry was added. The returned value reflects the state of the database
      * after the operation.
      */
-    toggleOne<T = Data>(query: ToggleOneQuery<T>): Promise<ToggleOneResult<T>>;
+    toggleOne<T = Data>(query: VQueryT.ToggleOne<T>): Promise<VQueryT.ToggleOneResult<T>>;
     /**
      * Removes a database collection from the file system.
      */

package/dist/helpers/collection.d.ts

@@ -2,7 +2,7 @@ import { Arg, Search, Updater } from "../types/arg.js";
 import { UpdateOneOrAdd } from "../types/collection.js";
 import { Data } from "../types/data.js";
 import { DbFindOpts, FindOpts } from "../types/options.js";
-import { ToggleOneResult, UpdateOneOrAddResult } from "../types/query.js";
+import { VQueryT } from "../types/query.js";
 import { VContext } from "../types/types.js";
 import { ValtheraCompatible } from "../types/valthera.js";
 export declare class Collection<D = Data> {
@@ -43,12 +43,12 @@ export declare class Collection<D = Data> {
     /**
      * Asynchronously updates one entry in a database or adds a new one if it doesn't exist.
      */
-    updateOneOrAdd(search: Search<D>, updater: Updater<D>, { add_arg, context, id_gen }?: UpdateOneOrAdd<D>): Promise<UpdateOneOrAddResult<D>>;
+    updateOneOrAdd(search: Search<D>, updater: Updater<D>, { add_arg, context, id_gen }?: UpdateOneOrAdd<D>): Promise<VQueryT.UpdateOneOrAddResult<D>>;
     /**
      * Asynchronously removes one entry in a database or adds a new one if it doesn't exist. Usage e.g. for toggling a flag.
      * Returns a promise resolving to `false` if the entry was found and removed,
      * or `true` if the entry was added. The returned value reflects the state of the database
      * after the operation.
      */
-    toggleOne(search: Search<D>, data?: Arg<D>, context?: VContext): Promise<ToggleOneResult<D>>;
+    toggleOne(search: Search<D>, data?: Arg<D>, context?: VContext): Promise<VQueryT.ToggleOneResult<D>>;
 }

package/dist/types/action.d.ts

@@ -1,5 +1,5 @@
 import { DataInternal } from "./data.js";
-import * as Query from "./query.js";
+import { VQueryT } from "./query.js";
 export interface ActionsBaseInterface {
     _inited: boolean;
     numberId: boolean;
@@ -8,13 +8,13 @@ export interface ActionsBaseInterface {
     ensureCollection(collection: string): Promise<boolean>;
     issetCollection(collection: string): Promise<boolean>;
     removeCollection(collection: string): Promise<boolean>;
-    add(query: Query.AddQuery): Promise<DataInternal>;
-    find(query: Query.FindQuery): Promise<DataInternal[]>;
-    findOne(query: Query.FindOneQuery): Promise<DataInternal | null>;
-    update(query: Query.UpdateQuery): Promise<DataInternal[]>;
-    updateOne(query: Query.UpdateQuery): Promise<DataInternal | null>;
-    remove(query: Query.RemoveQuery): Promise<DataInternal[]>;
-    removeOne(query: Query.RemoveQuery): Promise<DataInternal | null>;
-    updateOneOrAdd(query: Query.UpdateOneOrAddQuery): Promise<Query.UpdateOneOrAddResult<DataInternal>>;
-    toggleOne(query: Query.ToggleOneQuery): Promise<Query.ToggleOneResult<DataInternal>>;
+    add(query: VQueryT.Add): Promise<DataInternal>;
+    find(query: VQueryT.Find): Promise<DataInternal[]>;
+    findOne(query: VQueryT.FindOne): Promise<DataInternal | null>;
+    update(query: VQueryT.Update): Promise<DataInternal[]>;
+    updateOne(query: VQueryT.Update): Promise<DataInternal | null>;
+    remove(query: VQueryT.Remove): Promise<DataInternal[]>;
+    removeOne(query: VQueryT.Remove): Promise<DataInternal | null>;
+    updateOneOrAdd(query: VQueryT.UpdateOneOrAdd): Promise<VQueryT.UpdateOneOrAddResult<DataInternal>>;
+    toggleOne(query: VQueryT.ToggleOne): Promise<VQueryT.ToggleOneResult<DataInternal>>;
 }

package/dist/types/fileCpu.d.ts

@@ -1,31 +1,31 @@
 import { DataInternal } from "./data.js";
-import * as Query from "./query.js";
+import { VQueryT } from "./query.js";
 export interface FileCpu {
     /**
      * Asynchronously adds an entry to a file.
      * @returns A promise resolving to `void`.
      */
-    add(file: string, config: Query.AddQuery): Promise<void>;
+    add(file: string, config: VQueryT.Add): Promise<void>;
     /**
      * Asynchronously finds multiple entries in a file based on search criteria.
      * @returns A promise resolving to an array of found entries, or `false` if the file does not exist.
      */
-    find(file: string, config: Query.FindQuery): Promise<DataInternal[]>;
+    find(file: string, config: VQueryT.Find): Promise<DataInternal[]>;
     /**
      * Asynchronously finds one entry in a file based on search criteria.
      * @returns A promise resolving to the found entry or `false` if not found.
      */
-    findOne(file: string, config: Query.FindOneQuery): Promise<DataInternal | false>;
+    findOne(file: string, config: VQueryT.FindOne): Promise<DataInternal | false>;
     /**
    * Asynchronously removes entries from a file based on search criteria.
    * @param one If `true`, removes only the first matching entry.
    * @returns A promise resolving to `true` if at least one entry was removed, otherwise `false`.
    */
-    remove(file: string, config: Query.RemoveQuery, one: boolean): Promise<DataInternal[]>;
+    remove(file: string, config: VQueryT.Remove, one: boolean): Promise<DataInternal[]>;
     /**
      * Asynchronously updates entries in a file based on search criteria and an updater function or object.
      * @param one If `true`, updates only the first matching entry.
      * @returns A promise resolving to `true` if at least one entry was updated, otherwise `false`.
      */
-    update(file: string, config: Query.UpdateQuery, one: boolean): Promise<DataInternal[]>;
+    update(file: string, config: VQueryT.Update, one: boolean): Promise<DataInternal[]>;
 }

package/dist/types/query.d.ts

@@ -26,19 +26,31 @@ export interface VQuery<T = Data> {
     updater?: Updater<T>;
     control?: VQuery_Control;
 }
-export type QueryBase<T = Data> = Required<Pick<VQuery<T>, "collection" | "search">> & Pick<VQuery<T>, "control">;
-export type AddQuery<T = Data> = Required<Pick<VQuery<T>, "data" | "collection">> & Pick<VQuery<T>, "id_gen" | "control">;
-export type FindQuery<T = Data> = Omit<QueryBase, "search"> & Pick<VQuery<T>, "search"> & Pick<VQuery<T>, "findOpts" | "dbFindOpts" | "context">;
-export type FindOneQuery<T = Data> = QueryBase & Pick<VQuery<T>, "findOpts" | "context">;
-export type UpdateQuery<T = Data> = QueryBase & Required<Pick<VQuery<T>, "updater">> & Pick<VQuery<T>, "context">;
-export type RemoveQuery<T = Data> = QueryBase & Pick<VQuery<T>, "context">;
-export type UpdateOneOrAddQuery<T = Data> = QueryBase & UpdateQuery & Pick<VQuery<T>, "add_arg" | "id_gen">;
-export type ToggleOneQuery<T = Data> = QueryBase & Pick<VQuery<T>, "data" | "context">;
-export interface UpdateOneOrAddResult<T> {
-    data: T;
-    type: "added" | "updated";
-}
-export interface ToggleOneResult<T> {
-    data: T;
-    type: "added" | "removed";
+export declare namespace VQueryT {
+    type QueryBase<T = Data> = Required<Pick<VQuery<T>, "collection" | "search">> & Pick<VQuery<T>, "control">;
+    type Add<T = Data> = Required<Pick<VQuery<T>, "data" | "collection">> & Pick<VQuery<T>, "id_gen" | "control">;
+    type Find<T = Data> = Omit<QueryBase, "search"> & Pick<VQuery<T>, "search"> & Pick<VQuery<T>, "findOpts" | "dbFindOpts" | "context">;
+    type FindOne<T = Data> = QueryBase & Pick<VQuery<T>, "findOpts" | "context">;
+    type Update<T = Data> = QueryBase & Required<Pick<VQuery<T>, "updater">> & Pick<VQuery<T>, "context">;
+    type Remove<T = Data> = QueryBase & Pick<VQuery<T>, "context">;
+    type UpdateOneOrAdd<T = Data> = QueryBase & Update & Pick<VQuery<T>, "add_arg" | "id_gen">;
+    type ToggleOne<T = Data> = QueryBase & Pick<VQuery<T>, "data" | "context">;
+    interface UpdateOneOrAddResult<T> {
+        data: T;
+        type: "added" | "updated";
+    }
+    interface ToggleOneResult<T> {
+        data: T;
+        type: "added" | "removed";
+    }
 }
+export type QueryBase<T = Data> = VQueryT.QueryBase<T>;
+export type AddQuery<T = Data> = VQueryT.Add<T>;
+export type FindQuery<T = Data> = VQueryT.Find<T>;
+export type FindOneQuery<T = Data> = VQueryT.FindOne<T>;
+export type UpdateQuery<T = Data> = VQueryT.Update<T>;
+export type RemoveQuery<T = Data> = VQueryT.Remove<T>;
+export type UpdateOneOrAddQuery<T = Data> = VQueryT.UpdateOneOrAdd<T>;
+export type ToggleOneQuery<T = Data> = VQueryT.ToggleOne<T>;
+export type UpdateOneOrAddResult<T> = VQueryT.UpdateOneOrAddResult<T>;
+export type ToggleOneResult<T> = VQueryT.ToggleOneResult<T>;

package/dist/types/query.js

@@ -1,3 +1,5 @@
-;
-;
-export {};
+export var VQueryT;
+(function (VQueryT) {
+    ;
+    ;
+})(VQueryT || (VQueryT = {}));

package/dist/types/valthera.d.ts

@@ -1,19 +1,19 @@
 import { Collection } from "../helpers/collection.js";
 import { Data } from "./data.js";
-import * as Query from "./query.js";
+import { VQueryT } from "./query.js";
 export interface ValtheraCompatible {
     c<T = Data>(collection: string): Collection<T>;
     getCollections(): Promise<string[]>;
     ensureCollection(collection: string): Promise<boolean>;
     issetCollection(collection: string): Promise<boolean>;
-    add<T = Data>(query: Query.AddQuery<T>): Promise<T>;
-    find<T = Data>(query: Query.FindQuery<T>): Promise<T[]>;
-    findOne<T = Data>(query: Query.FindOneQuery<T>): Promise<T | null>;
-    update<T = Data>(query: Query.UpdateQuery<T>): Promise<T[]>;
-    updateOne<T = Data>(query: Query.UpdateQuery<T>): Promise<T | null>;
-    remove<T = Data>(query: Query.RemoveQuery<T>): Promise<T[]>;
-    removeOne<T = Data>(query: Query.RemoveQuery<T>): Promise<T | null>;
+    add<T = Data>(query: VQueryT.Add<T>): Promise<T>;
+    find<T = Data>(query: VQueryT.Find<T>): Promise<T[]>;
+    findOne<T = Data>(query: VQueryT.FindOne<T>): Promise<T | null>;
+    update<T = Data>(query: VQueryT.Update<T>): Promise<T[]>;
+    updateOne<T = Data>(query: VQueryT.Update<T>): Promise<T | null>;
+    remove<T = Data>(query: VQueryT.Remove<T>): Promise<T[]>;
+    removeOne<T = Data>(query: VQueryT.Remove<T>): Promise<T | null>;
     removeCollection(collection: string): Promise<boolean>;
-    updateOneOrAdd<T = Data>(query: Query.UpdateOneOrAddQuery<T>): Promise<Query.UpdateOneOrAddResult<T>>;
-    toggleOne<T = Data>(query: Query.ToggleOneQuery<T>): Promise<Query.ToggleOneResult<T>>;
+    updateOneOrAdd<T = Data>(query: VQueryT.UpdateOneOrAdd<T>): Promise<VQueryT.UpdateOneOrAddResult<T>>;
+    toggleOne<T = Data>(query: VQueryT.ToggleOne<T>): Promise<VQueryT.ToggleOneResult<T>>;
 }

package/dist/utils/action.d.ts

@@ -1,4 +1,4 @@
 import { Data } from "../types/data.js";
 import { FileCpu } from "../types/fileCpu.js";
-import { FindQuery } from "../types/query.js";
-export declare function findUtil(query: FindQuery, fileCpu: FileCpu, files: string[]): Promise<Data[]>;
+import { VQueryT } from "../types/query.js";
+export declare function findUtil(query: VQueryT.Find, fileCpu: FileCpu, files: string[]): Promise<Data[]>;

package/dist/version.js

@@ -1 +1 @@
-export const version = "0.10.0";
+export const version = "0.10.1";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wxn0brp/db-core",
-  "version": "0.10.0",
+  "version": "0.10.1",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",
   "author": "wxn0brP",