wapi-client 0.12.0-beta.3 → 0.12.5-beta.0

package/dist/lib/query-builder/find-query-builder.browser.js

@@ -0,0 +1,283 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/lib/query-builder/find-query-builder.ts
+import { mergeFnOptionsOrderBy } from "../utils.browser.js";
+import { hardValidate } from "../validation.browser.js";
+import {
+  QueryBuilder
+} from "./query-builder.browser.js";
+function queryBuilderOrderByToTxOrderBy(input) {
+  return input.map((item) => {
+    if (typeof item === "string") {
+      if (item.includes(" ")) {
+        throw new TypeError("invalid order option: " + item);
+      }
+      return {
+        field: item,
+        direction: "asc"
+      };
+    }
+    return {
+      field: item.column,
+      direction: item.order,
+      nulls: item.nulls
+    };
+  });
+}
+var FindQueryBuilder = class _FindQueryBuilder extends QueryBuilder {
+  constructor({
+    $queries,
+    $options,
+    start,
+    schema,
+    schemaBasic,
+    optionsSchema
+  }) {
+    super(schemaBasic, schema, $queries);
+    __publicField(this, "$options");
+    __publicField(this, "$optionsSchema");
+    __publicField(this, "$start");
+    this.$options = $options;
+    this.$optionsSchema = optionsSchema;
+    this.$start = start;
+  }
+  add(addQuery) {
+    return new _FindQueryBuilder({
+      $queries: [...this.$queries, addQuery],
+      $options: this.$options,
+      start: this.$start,
+      schemaBasic: this.$schemaBasic,
+      schema: this.$schema,
+      optionsSchema: this.$optionsSchema
+    });
+  }
+  start() {
+    return this.$start(this.toJSON());
+  }
+  toJSON() {
+    return {
+      filter: super.toQuery(),
+      options: __spreadValues({}, this.$options)
+    };
+  }
+  then(onfulfilled, onrejected) {
+    return this.start().then(onfulfilled, onrejected);
+  }
+  catch(onerror) {
+    return this.start().catch(onerror);
+  }
+  finally(fn) {
+    return this.start().finally(fn);
+  }
+  stream() {
+    return this.start().stream();
+  }
+  select(first, ...select) {
+    var _a, _b;
+    return new _FindQueryBuilder({
+      $queries: this.$queries,
+      $options: __spreadProps(__spreadValues({}, this.$options), {
+        deselect: void 0,
+        select: Array.from(
+          /* @__PURE__ */ new Set([first, ...select, ...(_b = (_a = this.$options) == null ? void 0 : _a.select) != null ? _b : []])
+        )
+      }),
+      start: this.$start,
+      schemaBasic: this.$schemaBasic,
+      schema: this.$schema,
+      optionsSchema: this.$optionsSchema
+    });
+  }
+  deselect(first, ...deselect) {
+    var _a, _b;
+    return new _FindQueryBuilder({
+      $queries: this.$queries,
+      $options: __spreadProps(__spreadValues({}, this.$options), {
+        select: void 0,
+        deselect: Array.from(
+          /* @__PURE__ */ new Set([first, ...deselect, ...(_b = (_a = this.$options) == null ? void 0 : _a.deselect) != null ? _b : []])
+        )
+      }),
+      start: this.$start,
+      schemaBasic: this.$schemaBasic,
+      schema: this.$schema,
+      optionsSchema: this.$optionsSchema
+    });
+  }
+  de() {
+    return [];
+  }
+  options(options) {
+    const validatedOptions = hardValidate(this.$optionsSchema, options);
+    const mergedOptions = mergeFnOptionsOrderBy(validatedOptions);
+    return new _FindQueryBuilder({
+      $queries: this.$queries,
+      $options: __spreadValues(__spreadValues({}, this.$options), mergedOptions),
+      start: this.$start,
+      schemaBasic: this.$schemaBasic,
+      schema: this.$schema,
+      optionsSchema: this.$optionsSchema
+    });
+  }
+  limit(limit) {
+    return this.options({
+      limit
+    });
+  }
+  offset(offset) {
+    return this.options({
+      offset
+    });
+  }
+  orderBy(input, direction, nullsDirection) {
+    if (!Array.isArray(input) && typeof input !== "string") {
+      throw new TypeError("invalid input");
+    }
+    if (Array.isArray(input)) {
+      return this.options({
+        order: queryBuilderOrderByToTxOrderBy(input)
+      });
+    }
+    const internalArr = [input];
+    if (direction) {
+      internalArr.push(direction);
+    }
+    if (nullsDirection) {
+      internalArr.push("nulls", nullsDirection);
+    }
+    return this.options({
+      order_by: internalArr.join(" ")
+    });
+  }
+  where(field, operator, value) {
+    return this.addWhere({
+      fn: "where",
+      field,
+      operator,
+      value
+    });
+  }
+  orWhere(field, operator, value) {
+    return this.addWhere({
+      fn: "orWhere",
+      field,
+      operator,
+      value
+    });
+  }
+  whereIn(field, value) {
+    return this.addIn({
+      fn: "whereIn",
+      field,
+      value
+    });
+  }
+  orWhereIn(field, value) {
+    return this.addIn({
+      fn: "orWhereIn",
+      field,
+      value
+    });
+  }
+  whereNull(field) {
+    return this.addNull({
+      fn: "whereNull",
+      field
+    });
+  }
+  orWhereNull(field) {
+    return this.addNull({
+      fn: "orWhereNull",
+      field
+    });
+  }
+  whereNotNull(field) {
+    return this.addNull({
+      fn: "whereNotNull",
+      field
+    });
+  }
+  orWhereNotNull(field) {
+    return this.addNull({
+      fn: "orWhereNotNull",
+      field
+    });
+  }
+  whereMetadata(field, operator, value) {
+    return this.addMetadata({
+      fn: "whereMetadata",
+      field,
+      operator,
+      value
+    });
+  }
+  orWhereMetadata(field, operator, value) {
+    return this.addMetadata({
+      fn: "orWhereMetadata",
+      field,
+      operator,
+      value
+    });
+  }
+  whereMetadataIn(field, value) {
+    return this.addMetadataIn({
+      fn: "whereMetadataIn",
+      field,
+      value
+    });
+  }
+  orWhereMetadataIn(field, value) {
+    return this.addMetadataIn({
+      fn: "orWhereMetadataIn",
+      field,
+      value
+    });
+  }
+  whereMetadataNull(field) {
+    return this.addMetadataNull({
+      fn: "whereMetadataNull",
+      field
+    });
+  }
+  orWhereMetadataNull(field) {
+    return this.addMetadataNull({
+      fn: "orWhereMetadataNull",
+      field
+    });
+  }
+  whereMetadataNotNull(field) {
+    return this.addMetadataNull({
+      fn: "whereMetadataNotNull",
+      field
+    });
+  }
+  orWhereMetadataNotNull(field) {
+    return this.addMetadataNull({
+      fn: "orWhereMetadataNotNull",
+      field
+    });
+  }
+  // FILTERING FUNCTIONS
+};
+export {
+  FindQueryBuilder
+};

package/dist/lib/query-builder/find-query-builder.cjs

@@ -0,0 +1,302 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/lib/query-builder/find-query-builder.ts
+var find_query_builder_exports = {};
+__export(find_query_builder_exports, {
+  FindQueryBuilder: () => FindQueryBuilder
+});
+module.exports = __toCommonJS(find_query_builder_exports);
+var import_utils = require('../utils.cjs');
+var import_validation = require('../validation.cjs');
+var import_query_builder = require('./query-builder.cjs');
+function queryBuilderOrderByToTxOrderBy(input) {
+  return input.map((item) => {
+    if (typeof item === "string") {
+      if (item.includes(" ")) {
+        throw new TypeError("invalid order option: " + item);
+      }
+      return {
+        field: item,
+        direction: "asc"
+      };
+    }
+    return {
+      field: item.column,
+      direction: item.order,
+      nulls: item.nulls
+    };
+  });
+}
+var FindQueryBuilder = class _FindQueryBuilder extends import_query_builder.QueryBuilder {
+  constructor({
+    $queries,
+    $options,
+    start,
+    schema,
+    schemaBasic,
+    optionsSchema
+  }) {
+    super(schemaBasic, schema, $queries);
+    __publicField(this, "$options");
+    __publicField(this, "$optionsSchema");
+    __publicField(this, "$start");
+    this.$options = $options;
+    this.$optionsSchema = optionsSchema;
+    this.$start = start;
+  }
+  add(addQuery) {
+    return new _FindQueryBuilder({
+      $queries: [...this.$queries, addQuery],
+      $options: this.$options,
+      start: this.$start,
+      schemaBasic: this.$schemaBasic,
+      schema: this.$schema,
+      optionsSchema: this.$optionsSchema
+    });
+  }
+  start() {
+    return this.$start(this.toJSON());
+  }
+  toJSON() {
+    return {
+      filter: super.toQuery(),
+      options: __spreadValues({}, this.$options)
+    };
+  }
+  then(onfulfilled, onrejected) {
+    return this.start().then(onfulfilled, onrejected);
+  }
+  catch(onerror) {
+    return this.start().catch(onerror);
+  }
+  finally(fn) {
+    return this.start().finally(fn);
+  }
+  stream() {
+    return this.start().stream();
+  }
+  select(first, ...select) {
+    var _a, _b;
+    return new _FindQueryBuilder({
+      $queries: this.$queries,
+      $options: __spreadProps(__spreadValues({}, this.$options), {
+        deselect: void 0,
+        select: Array.from(
+          /* @__PURE__ */ new Set([first, ...select, ...(_b = (_a = this.$options) == null ? void 0 : _a.select) != null ? _b : []])
+        )
+      }),
+      start: this.$start,
+      schemaBasic: this.$schemaBasic,
+      schema: this.$schema,
+      optionsSchema: this.$optionsSchema
+    });
+  }
+  deselect(first, ...deselect) {
+    var _a, _b;
+    return new _FindQueryBuilder({
+      $queries: this.$queries,
+      $options: __spreadProps(__spreadValues({}, this.$options), {
+        select: void 0,
+        deselect: Array.from(
+          /* @__PURE__ */ new Set([first, ...deselect, ...(_b = (_a = this.$options) == null ? void 0 : _a.deselect) != null ? _b : []])
+        )
+      }),
+      start: this.$start,
+      schemaBasic: this.$schemaBasic,
+      schema: this.$schema,
+      optionsSchema: this.$optionsSchema
+    });
+  }
+  de() {
+    return [];
+  }
+  options(options) {
+    const validatedOptions = (0, import_validation.hardValidate)(this.$optionsSchema, options);
+    const mergedOptions = (0, import_utils.mergeFnOptionsOrderBy)(validatedOptions);
+    return new _FindQueryBuilder({
+      $queries: this.$queries,
+      $options: __spreadValues(__spreadValues({}, this.$options), mergedOptions),
+      start: this.$start,
+      schemaBasic: this.$schemaBasic,
+      schema: this.$schema,
+      optionsSchema: this.$optionsSchema
+    });
+  }
+  limit(limit) {
+    return this.options({
+      limit
+    });
+  }
+  offset(offset) {
+    return this.options({
+      offset
+    });
+  }
+  orderBy(input, direction, nullsDirection) {
+    if (!Array.isArray(input) && typeof input !== "string") {
+      throw new TypeError("invalid input");
+    }
+    if (Array.isArray(input)) {
+      return this.options({
+        order: queryBuilderOrderByToTxOrderBy(input)
+      });
+    }
+    const internalArr = [input];
+    if (direction) {
+      internalArr.push(direction);
+    }
+    if (nullsDirection) {
+      internalArr.push("nulls", nullsDirection);
+    }
+    return this.options({
+      order_by: internalArr.join(" ")
+    });
+  }
+  where(field, operator, value) {
+    return this.addWhere({
+      fn: "where",
+      field,
+      operator,
+      value
+    });
+  }
+  orWhere(field, operator, value) {
+    return this.addWhere({
+      fn: "orWhere",
+      field,
+      operator,
+      value
+    });
+  }
+  whereIn(field, value) {
+    return this.addIn({
+      fn: "whereIn",
+      field,
+      value
+    });
+  }
+  orWhereIn(field, value) {
+    return this.addIn({
+      fn: "orWhereIn",
+      field,
+      value
+    });
+  }
+  whereNull(field) {
+    return this.addNull({
+      fn: "whereNull",
+      field
+    });
+  }
+  orWhereNull(field) {
+    return this.addNull({
+      fn: "orWhereNull",
+      field
+    });
+  }
+  whereNotNull(field) {
+    return this.addNull({
+      fn: "whereNotNull",
+      field
+    });
+  }
+  orWhereNotNull(field) {
+    return this.addNull({
+      fn: "orWhereNotNull",
+      field
+    });
+  }
+  whereMetadata(field, operator, value) {
+    return this.addMetadata({
+      fn: "whereMetadata",
+      field,
+      operator,
+      value
+    });
+  }
+  orWhereMetadata(field, operator, value) {
+    return this.addMetadata({
+      fn: "orWhereMetadata",
+      field,
+      operator,
+      value
+    });
+  }
+  whereMetadataIn(field, value) {
+    return this.addMetadataIn({
+      fn: "whereMetadataIn",
+      field,
+      value
+    });
+  }
+  orWhereMetadataIn(field, value) {
+    return this.addMetadataIn({
+      fn: "orWhereMetadataIn",
+      field,
+      value
+    });
+  }
+  whereMetadataNull(field) {
+    return this.addMetadataNull({
+      fn: "whereMetadataNull",
+      field
+    });
+  }
+  orWhereMetadataNull(field) {
+    return this.addMetadataNull({
+      fn: "orWhereMetadataNull",
+      field
+    });
+  }
+  whereMetadataNotNull(field) {
+    return this.addMetadataNull({
+      fn: "whereMetadataNotNull",
+      field
+    });
+  }
+  orWhereMetadataNotNull(field) {
+    return this.addMetadataNull({
+      fn: "orWhereMetadataNotNull",
+      field
+    });
+  }
+  // FILTERING FUNCTIONS
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FindQueryBuilder
+});

package/dist/lib/query-builder/find-query-builder.d.ts

@@ -0,0 +1,97 @@
+import { Merge, OperatorType, RemoveMetadata, SearchableInObject, SearchableNullObject, SearchableObject, StringKeyObject } from '.';
+import { DbFilterType } from '../../db/consts';
+import { DbFilterAllowedValue, DbFilterOperatorEquals, DbFilterOperatorForNumbers, DbFilterOperatorForStrings } from '../../db/consts.enums';
+import { ITxFindMetadata, ITxNullsOrderingDirection, ITxOrderingDirection } from '../../txs/consts.enums';
+import { ReadStream } from '../isomorphic/node/streams';
+import { StreamPromise } from '../stream-promise';
+import { InnerBuiltQuery, InnerWhereBuilder, QueryBuilder } from './query-builder';
+type ResultSelect<T> = {
+    [K in keyof T]?: boolean;
+};
+type SelectMap<T> = {
+    [k in T as k & string]: true;
+};
+export type AllTrue<T> = {
+    [K in keyof T]: true;
+};
+type DeSelectFields<ResultFields, DeSelectedFields extends ResultSelect<ResultFields>> = {
+    [k in keyof ResultFields as DeSelectedFields[k] extends true ? never : k]: true;
+};
+type SearchResultType<K extends string | object, V> = K extends string ? {
+    [key in K]: V[];
+} & {
+    metadata: ITxFindMetadata;
+} : K;
+type FinalSearchItem<ResItem, SelectedFields extends ResultSelect<ResItem>, DeSelectedFields extends ResultSelect<ResItem>> = SelectedSearchItem<ResItem, DeSelectFields<SelectedFields, DeSelectedFields> & ResultSelect<ResItem>>;
+type SelectedSearchItem<ResItem, SelectedFields extends ResultSelect<ResItem>> = {
+    [k in keyof ResItem as SelectedFields[k] extends true ? k : never]: ResItem[k];
+};
+export type BuiltFindQuery = InnerBuiltQuery & {
+    options: StringKeyObject;
+};
+type SelectOptionsObject<ResultFields extends StringKeyObject> = {
+    select?: (keyof ResultFields)[];
+    deselect?: (keyof ResultFields)[];
+};
+export type QueryBuilderOrderingInputObject = {
+    column: string;
+    order?: ITxOrderingDirection;
+    nulls?: ITxNullsOrderingDirection;
+};
+export type QueryBuilderOrderingInput = string | QueryBuilderOrderingInputObject;
+export declare class FindQueryBuilder<SearchableBasic extends Zod.AnyZodObject, Searchable extends Zod.AnyZodObject, Options extends Zod.AnyZodObject, ResultKey extends string | object, ResultFields extends StringKeyObject, SelectedFields extends ResultSelect<ResultFields>, DeSelectedFields extends ResultSelect<ResultFields> = {}, IsBaseSelect extends boolean = true> extends QueryBuilder<SearchableBasic, Searchable> {
+    $options: Zod.infer<Options> & SelectOptionsObject<ResultFields>;
+    $optionsSchema: Options;
+    $start: (q: BuiltFindQuery) => StreamPromise<unknown>;
+    constructor({ $queries, $options, start, schema, schemaBasic, optionsSchema, }: {
+        start: (q: BuiltFindQuery) => StreamPromise<unknown>;
+        schemaBasic: SearchableBasic;
+        schema: Searchable;
+        optionsSchema: Options;
+        $queries?: DbFilterType[];
+        $options?: Zod.infer<Options> & SelectOptionsObject<ResultFields>;
+    });
+    protected add(addQuery: DbFilterType): FindQueryBuilder<SearchableBasic, Searchable, Options, ResultKey, ResultFields, SelectedFields, DeSelectedFields, IsBaseSelect>;
+    private start;
+    toJSON(): BuiltFindQuery;
+    then<TResult1 = SearchResultType<ResultKey, FinalSearchItem<ResultFields, SelectedFields, DeSelectedFields>>, TResult2 = never>(onfulfilled?: (value: SearchResultType<ResultKey, FinalSearchItem<ResultFields, SelectedFields, DeSelectedFields>>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: Error) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>;
+    catch<TResult2 = never>(onerror: (reason: Error) => TResult2 | PromiseLike<TResult2>): Promise<SearchResultType<ResultKey, FinalSearchItem<ResultFields, SelectedFields, DeSelectedFields>> | TResult2>;
+    finally(fn: () => void): Promise<SearchResultType<ResultKey, SelectedSearchItem<ResultFields, DeSelectFields<SelectedFields, DeSelectedFields> & ResultSelect<ResultFields>>>>;
+    stream(): ReadStream;
+    select<First extends keyof ResultFields, Selected extends Exclude<keyof ResultFields, First> | undefined = undefined>(first: First, ...select: ReadonlyArray<Selected>): FindQueryBuilder<SearchableBasic, Searchable, Options, ResultKey, ResultFields, IsBaseSelect extends true ? SelectMap<First | Selected> : SelectedFields & SelectMap<First | Selected>, {}, false>;
+    deselect<First extends keyof ResultFields, Deselected extends Exclude<keyof ResultFields, First> | undefined = undefined>(first: First, ...deselect: ReadonlyArray<Deselected>): FindQueryBuilder<SearchableBasic, Searchable, Options, ResultKey, ResultFields, AllTrue<ResultFields>, DeSelectedFields & SelectMap<First | Deselected>, true>;
+    de(): [SelectedFields, DeSelectedFields, IsBaseSelect];
+    options(options: Zod.input<Options>): FindQueryBuilder<SearchableBasic, Searchable, Options, ResultKey, ResultFields, SelectedFields, DeSelectedFields, IsBaseSelect>;
+    limit(limit: number): FindQueryBuilder<SearchableBasic, Searchable, Options, ResultKey, ResultFields, SelectedFields, DeSelectedFields, IsBaseSelect>;
+    offset(offset: number): FindQueryBuilder<SearchableBasic, Searchable, Options, ResultKey, ResultFields, SelectedFields, DeSelectedFields, IsBaseSelect>;
+    orderBy(input: (keyof ResultFields & string) | `${keyof ResultFields & string} ${ITxOrderingDirection}` | `${keyof ResultFields & string} ${ITxOrderingDirection} nulls ${ITxNullsOrderingDirection}` | QueryBuilderOrderingInput[], direction?: ITxOrderingDirection, nullsDirection?: ITxNullsOrderingDirection): FindQueryBuilder<SearchableBasic, Searchable, Options, ResultKey, ResultFields, SelectedFields, DeSelectedFields, IsBaseSelect>;
+    where(field: SearchableObject<Zod.input<SearchableBasic>>): ReturnType<typeof this.add>;
+    where(field: InnerWhereBuilder<SearchableBasic, Searchable>): ReturnType<typeof this.add>;
+    where<F extends keyof RemoveMetadata<Zod.input<Searchable>>, V extends Zod.input<Merge<SearchableBasic, Searchable>>[F]>(field: F, operator: V): ReturnType<typeof this.add>;
+    where<F extends keyof RemoveMetadata<Zod.input<Searchable>>, V extends Zod.input<Merge<SearchableBasic, Searchable>>[F]>(field: F, operator: OperatorType<V>, value: V): ReturnType<typeof this.add>;
+    orWhere(field: SearchableObject<Zod.input<SearchableBasic>>): ReturnType<typeof this.add>;
+    orWhere(field: InnerWhereBuilder<SearchableBasic, Searchable>): ReturnType<typeof this.add>;
+    orWhere<F extends keyof RemoveMetadata<Zod.input<Searchable>>, V extends Zod.input<Merge<SearchableBasic, Searchable>>[F]>(field: F, operator: V): ReturnType<typeof this.add>;
+    orWhere<F extends keyof RemoveMetadata<Zod.input<Searchable>>, V extends Zod.input<Merge<SearchableBasic, Searchable>>[F]>(field: F, operator: OperatorType<V>, value: V): ReturnType<typeof this.add>;
+    whereIn<F extends keyof SearchableInObject<Zod.input<Searchable>>, V extends SearchableInObject<Zod.input<Searchable>>[F]>(field: F, value: V): ReturnType<typeof this.add>;
+    orWhereIn<F extends keyof SearchableInObject<Zod.input<Searchable>>, V extends SearchableInObject<Zod.input<Searchable>>[F]>(field: F, value: V): ReturnType<typeof this.add>;
+    whereNull<F extends keyof SearchableNullObject<Searchable>>(field: F): ReturnType<typeof this.add>;
+    orWhereNull<F extends keyof SearchableNullObject<Zod.input<Searchable>>>(field: F): ReturnType<typeof this.add>;
+    whereNotNull<F extends keyof SearchableNullObject<Zod.input<Searchable>>>(field: F): ReturnType<typeof this.add>;
+    orWhereNotNull<F extends keyof SearchableNullObject<Zod.input<Searchable>>>(field: F): ReturnType<typeof this.add>;
+    whereMetadata(field: string, value: DbFilterAllowedValue): ReturnType<typeof this.add>;
+    whereMetadata(field: string, operator: DbFilterOperatorEquals, value: boolean): ReturnType<typeof this.add>;
+    whereMetadata(field: string, operator: DbFilterOperatorForNumbers, value: number): ReturnType<typeof this.add>;
+    whereMetadata(field: string, operator: DbFilterOperatorForStrings, value: string): ReturnType<typeof this.add>;
+    orWhereMetadata(field: string, value: DbFilterAllowedValue): ReturnType<typeof this.add>;
+    orWhereMetadata(field: string, operator: DbFilterOperatorEquals, value: boolean): ReturnType<typeof this.add>;
+    orWhereMetadata(field: string, operator: DbFilterOperatorForNumbers, value: number): ReturnType<typeof this.add>;
+    orWhereMetadata(field: string, operator: DbFilterOperatorForStrings, value: string): ReturnType<typeof this.add>;
+    whereMetadataIn(field: string, value: string[] | number[]): ReturnType<typeof this.add>;
+    orWhereMetadataIn(field: string, value: string[] | number[]): ReturnType<typeof this.add>;
+    whereMetadataNull(field: string): ReturnType<typeof this.add>;
+    orWhereMetadataNull(field: string): ReturnType<typeof this.add>;
+    whereMetadataNotNull(field: string): ReturnType<typeof this.add>;
+    orWhereMetadataNotNull(field: string): ReturnType<typeof this.add>;
+}
+export {};