@akanjs/constant 0.0.39 → 0.0.40

package/src/fieldMeta.js

@@ -0,0 +1,104 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 fieldMeta_exports = {};
+__export(fieldMeta_exports, {
+  Field: () => Field
+});
+module.exports = __toCommonJS(fieldMeta_exports);
+var import_base = require("@akanjs/base");
+var import_scalar = require("./scalar");
+const applyFieldMeta = /* @__PURE__ */ __name((modelRef, arrDepth, option, optionArrDepth) => {
+  const isArray = arrDepth > 0;
+  const isClass = !(0, import_base.isGqlScalar)(modelRef);
+  const isMap = (0, import_base.isGqlMap)(modelRef);
+  const { refName, type } = isClass ? (0, import_scalar.getClassMeta)(modelRef) : {
+    refName: "",
+    type: "scalar"
+  };
+  const name = isClass ? refName : import_base.scalarNameMap.get(modelRef) ?? "Unknown";
+  if (isMap && !option.of) throw new Error("Map type must have 'of' option");
+  return (prototype, key) => {
+    const metadata = {
+      nullable: option.nullable ?? false,
+      ref: option.ref,
+      refPath: option.refPath,
+      refType: option.refType,
+      default: option.default ?? (isArray ? [] : null),
+      type: option.type,
+      fieldType: option.fieldType ?? "property",
+      immutable: option.immutable ?? false,
+      min: option.min,
+      max: option.max,
+      enum: option.enum,
+      select: option.select ?? true,
+      minlength: option.minlength,
+      maxlength: option.maxlength,
+      query: option.query,
+      accumulate: option.accumulate,
+      example: option.example,
+      validate: option.validate,
+      key,
+      name,
+      isClass,
+      isScalar: type === "scalar",
+      modelRef,
+      arrDepth,
+      isArray,
+      optArrDepth: optionArrDepth,
+      isMap,
+      of: option.of,
+      text: option.text
+    };
+    const metadataMap = (0, import_scalar.getFieldMetaMapOnPrototype)(prototype);
+    metadataMap.set(key, metadata);
+    (0, import_scalar.setFieldMetaMapOnPrototype)(prototype, metadataMap);
+  };
+}, "applyFieldMeta");
+const makeField = /* @__PURE__ */ __name((customOption) => (returns, fieldOption) => {
+  const [modelRef, arrDepth] = (0, import_base.getNonArrayModel)(returns());
+  if (!fieldOption) return applyFieldMeta(modelRef, arrDepth, {
+    ...customOption
+  }, arrDepth);
+  const [opt, optArrDepth] = (0, import_base.getNonArrayModel)(fieldOption);
+  return applyFieldMeta(modelRef, arrDepth, {
+    ...opt,
+    ...customOption
+  }, optArrDepth);
+}, "makeField");
+const Field = {
+  Prop: makeField({
+    fieldType: "property"
+  }),
+  Hidden: makeField({
+    fieldType: "hidden",
+    nullable: true
+  }),
+  Secret: makeField({
+    fieldType: "hidden",
+    select: false,
+    nullable: true
+  }),
+  Resolve: makeField({
+    fieldType: "resolve"
+  })
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Field
+});

package/src/filterMeta.d.ts

@@ -0,0 +1,69 @@
+import { T as Type } from '../types-b-U-yQib.js';
+import { ConstantFilterMeta, FilterKeyMeta, FilterArgMeta, FilterKeyProps, ReturnType, FilterArgProps } from './scalar.js';
+import { S as SortType } from '../types-DdO4B_Um.js';
+import { FilterQuery } from 'mongoose';
+import '../base-D8mO_G-C.js';
+import 'dayjs';
+import 'fs';
+import 'stream';
+
+declare const isFilterModel: (filterRef: Type) => boolean;
+declare const getFilterMeta: (filterRef: Type) => ConstantFilterMeta;
+declare const setFilterMeta: (filterRef: Type, filterMeta: ConstantFilterMeta) => void;
+declare const getFilterKeyMetaMapOnPrototype: (prototype: object) => Map<string, FilterKeyMeta>;
+declare const setFilterKeyMetaMapOnPrototype: (prototype: object, metadataMap: Map<string, FilterKeyMeta>) => void;
+declare const setFilterArgMetasOnPrototype: (prototype: object, key: string, filterArgMetas: FilterArgMeta[]) => void;
+declare const getFilterArgMetas: (filterRef: Type, key: string) => FilterArgMeta[];
+declare const getFilterQuery: (filterRef: Type, key: string) => (...args: any[]) => FilterQuery<any>;
+declare const getFilterQueryMap: (filterRef: Type) => Map<string, FilterKeyMeta>;
+declare const getFilterSort: (filterRef: Type, key: string) => {
+    [key: string]: number;
+};
+declare const getFilterSortMap: (filterRef: Type) => SortType;
+declare const Filter: {
+    Mongo: (fieldOption?: Omit<FilterKeyProps, "type">) => (prototype: object, key: string, descriptor: PropertyDescriptor) => void;
+    Arg: (name: string, returns: ReturnType, argOption?: FilterArgProps | FilterArgProps[]) => (prototype: object, key: string, idx: number) => void;
+};
+type BaseFilterKey = "latest" | "oldest" | "any" | "byStatuses";
+declare const sortOf: <Sort extends SortType>(modelRef: Type, sort: Sort) => Type<{
+    latest: {
+        createdAt: number;
+    };
+    oldest: {
+        createdAt: number;
+    };
+    any(): {
+        removedAt: {
+            $exists: boolean;
+        };
+    };
+    byStatuses(statuses: string[] | null): {
+        status: {
+            $in: string[];
+        };
+    } | {
+        status?: undefined;
+    };
+} & Sort>;
+declare function BaseFilter<Sort extends SortType>(modelRef: Type, sort: Sort): Type<{
+    latest: {
+        createdAt: number;
+    };
+    oldest: {
+        createdAt: number;
+    };
+    any(): {
+        removedAt: {
+            $exists: boolean;
+        };
+    };
+    byStatuses(statuses: string[] | null): {
+        status: {
+            $in: string[];
+        };
+    } | {
+        status?: undefined;
+    };
+} & Sort>;
+
+export { BaseFilter, type BaseFilterKey, Filter, getFilterArgMetas, getFilterKeyMetaMapOnPrototype, getFilterMeta, getFilterQuery, getFilterQueryMap, getFilterSort, getFilterSortMap, isFilterModel, setFilterArgMetasOnPrototype, setFilterKeyMetaMapOnPrototype, setFilterMeta, sortOf };

package/src/filterMeta.js

@@ -0,0 +1,291 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 filterMeta_exports = {};
+__export(filterMeta_exports, {
+  BaseFilter: () => BaseFilter,
+  Filter: () => Filter,
+  getFilterArgMetas: () => getFilterArgMetas,
+  getFilterKeyMetaMapOnPrototype: () => getFilterKeyMetaMapOnPrototype,
+  getFilterMeta: () => getFilterMeta,
+  getFilterQuery: () => getFilterQuery,
+  getFilterQueryMap: () => getFilterQueryMap,
+  getFilterSort: () => getFilterSort,
+  getFilterSortMap: () => getFilterSortMap,
+  isFilterModel: () => isFilterModel,
+  setFilterArgMetasOnPrototype: () => setFilterArgMetasOnPrototype,
+  setFilterKeyMetaMapOnPrototype: () => setFilterKeyMetaMapOnPrototype,
+  setFilterMeta: () => setFilterMeta,
+  sortOf: () => sortOf
+});
+module.exports = __toCommonJS(filterMeta_exports);
+var import_base = require("@akanjs/base");
+var import_scalar = require("./scalar");
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+const isFilterModel = /* @__PURE__ */ __name((filterRef) => {
+  return Reflect.getMetadata("filter", filterRef.prototype) !== void 0;
+}, "isFilterModel");
+const getFilterMeta = /* @__PURE__ */ __name((filterRef) => {
+  const filterMeta = Reflect.getMetadata("filter", filterRef.prototype);
+  if (!filterMeta) throw new Error("filterMeta is not defined");
+  return filterMeta;
+}, "getFilterMeta");
+const setFilterMeta = /* @__PURE__ */ __name((filterRef, filterMeta) => {
+  const existingFilterMeta = Reflect.getMetadata("filter", filterRef.prototype);
+  if (existingFilterMeta) Object.assign(filterMeta.sort, existingFilterMeta.sort);
+  Reflect.defineMetadata("filter", filterMeta, filterRef.prototype);
+}, "setFilterMeta");
+const getFilterKeyMetaMapOnPrototype = /* @__PURE__ */ __name((prototype) => {
+  const metadataMap = Reflect.getMetadata("filterKey", prototype) ?? /* @__PURE__ */ new Map();
+  return new Map(metadataMap);
+}, "getFilterKeyMetaMapOnPrototype");
+const setFilterKeyMetaMapOnPrototype = /* @__PURE__ */ __name((prototype, metadataMap) => {
+  Reflect.defineMetadata("filterKey", new Map(metadataMap), prototype);
+}, "setFilterKeyMetaMapOnPrototype");
+const applyFilterKeyMeta = /* @__PURE__ */ __name((option) => {
+  return (prototype, key, descriptor) => {
+    const metadata = {
+      key,
+      ...option,
+      descriptor
+    };
+    const metadataMap = getFilterKeyMetaMapOnPrototype(prototype);
+    metadataMap.set(key, metadata);
+    setFilterKeyMetaMapOnPrototype(prototype, metadataMap);
+  };
+}, "applyFilterKeyMeta");
+const makeFilter = /* @__PURE__ */ __name((customOption) => (fieldOption) => {
+  return applyFilterKeyMeta({
+    ...customOption,
+    ...fieldOption
+  });
+}, "makeFilter");
+const getFilterArgMetasOnPrototype = /* @__PURE__ */ __name((prototype, key) => {
+  const filterArgMetas = Reflect.getMetadata("filterArg", prototype, key) ?? [];
+  return filterArgMetas;
+}, "getFilterArgMetasOnPrototype");
+const setFilterArgMetasOnPrototype = /* @__PURE__ */ __name((prototype, key, filterArgMetas) => {
+  Reflect.defineMetadata("filterArg", filterArgMetas, prototype, key);
+}, "setFilterArgMetasOnPrototype");
+const getFilterArgMetas = /* @__PURE__ */ __name((filterRef, key) => {
+  const filterArgMetas = getFilterArgMetasOnPrototype(filterRef.prototype, key);
+  return filterArgMetas;
+}, "getFilterArgMetas");
+const applyFilterArgMeta = /* @__PURE__ */ __name((name, returns, argOption) => {
+  return (prototype, key, idx) => {
+    const [modelRef, arrDepth] = (0, import_base.getNonArrayModel)(returns());
+    const [opt, optArrDepth] = (0, import_base.getNonArrayModel)(argOption ?? {});
+    const filterArgMeta = {
+      name,
+      ...opt,
+      modelRef,
+      arrDepth,
+      isArray: arrDepth > 0,
+      optArrDepth
+    };
+    const filterArgMetas = getFilterArgMetasOnPrototype(prototype, key);
+    filterArgMetas[idx] = filterArgMeta;
+    setFilterArgMetasOnPrototype(prototype, key, filterArgMetas);
+  };
+}, "applyFilterArgMeta");
+const getFilterQuery = /* @__PURE__ */ __name((filterRef, key) => {
+  const filterKeyMetaMap = getFilterKeyMetaMapOnPrototype(filterRef.prototype);
+  const filterKeyMeta = filterKeyMetaMap.get(key);
+  if (!filterKeyMeta?.descriptor.value) throw new Error(`filterKeyMeta is not defined for key: ${key}`);
+  return filterKeyMeta.descriptor.value;
+}, "getFilterQuery");
+const getFilterQueryMap = /* @__PURE__ */ __name((filterRef) => {
+  const filterKeyMetaMap = getFilterKeyMetaMapOnPrototype(filterRef.prototype);
+  return filterKeyMetaMap;
+}, "getFilterQueryMap");
+const getFilterSort = /* @__PURE__ */ __name((filterRef, key) => {
+  const filterMeta = getFilterMeta(filterRef);
+  const sort = filterMeta.sort[key];
+  return sort;
+}, "getFilterSort");
+const getFilterSortMap = /* @__PURE__ */ __name((filterRef) => {
+  const filterMeta = getFilterMeta(filterRef);
+  return filterMeta.sort;
+}, "getFilterSortMap");
+const Filter = {
+  Mongo: makeFilter({
+    type: "mongo"
+  }),
+  // Meili: makeFilter({ fieldType: "hidden", nullable: true }),
+  Arg: applyFilterArgMeta
+};
+const sortOf = /* @__PURE__ */ __name((modelRef, sort) => {
+  const fieldMetaMap = (0, import_scalar.getFieldMetaMap)(modelRef);
+  const statusFieldMeta = fieldMetaMap.get("status");
+  if (!statusFieldMeta) throw new Error(`No status field meta fount in ${modelRef.name}`);
+  let BaseFilter2 = class BaseFilter {
+    static {
+      __name(this, "BaseFilter");
+    }
+    latest = {
+      createdAt: -1
+    };
+    oldest = {
+      createdAt: 1
+    };
+    any() {
+      return {
+        removedAt: {
+          $exists: false
+        }
+      };
+    }
+    byStatuses(statuses) {
+      return statuses?.length ? {
+        status: {
+          $in: statuses
+        }
+      } : {};
+    }
+  };
+  _ts_decorate([
+    Filter.Mongo(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", void 0)
+  ], BaseFilter2.prototype, "any", null);
+  _ts_decorate([
+    Filter.Mongo(),
+    _ts_param(0, Filter.Arg("statuses", () => [
+      String
+    ], {
+      nullable: true,
+      enum: statusFieldMeta?.enum
+    })),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+      Object
+    ]),
+    _ts_metadata("design:returntype", void 0)
+  ], BaseFilter2.prototype, "byStatuses", null);
+  Object.assign(BaseFilter2.prototype, sort);
+  setFilterMeta(BaseFilter2, {
+    refName: "BaseFilter",
+    sort: Object.assign({
+      latest: {
+        createdAt: -1
+      },
+      oldest: {
+        createdAt: 1
+      }
+    }, sort)
+  });
+  return BaseFilter2;
+}, "sortOf");
+function BaseFilter(modelRef, sort) {
+  const fieldMetaMap = (0, import_scalar.getFieldMetaMap)(modelRef);
+  const statusFieldMeta = fieldMetaMap.get("status");
+  if (!statusFieldMeta) throw new Error(`No status field meta fount in ${modelRef.name}`);
+  let BaseFilter2 = class BaseFilter {
+    static {
+      __name(this, "BaseFilter");
+    }
+    latest = {
+      createdAt: -1
+    };
+    oldest = {
+      createdAt: 1
+    };
+    any() {
+      return {
+        removedAt: {
+          $exists: false
+        }
+      };
+    }
+    byStatuses(statuses) {
+      return statuses?.length ? {
+        status: {
+          $in: statuses
+        }
+      } : {};
+    }
+  };
+  _ts_decorate([
+    Filter.Mongo(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", void 0)
+  ], BaseFilter2.prototype, "any", null);
+  _ts_decorate([
+    Filter.Mongo(),
+    _ts_param(0, Filter.Arg("statuses", () => [
+      String
+    ], {
+      nullable: true,
+      enum: statusFieldMeta?.enum
+    })),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+      Object
+    ]),
+    _ts_metadata("design:returntype", void 0)
+  ], BaseFilter2.prototype, "byStatuses", null);
+  Object.assign(BaseFilter2.prototype, sort);
+  setFilterMeta(BaseFilter2, {
+    refName: "BaseFilter",
+    sort: Object.assign({
+      latest: {
+        createdAt: -1
+      },
+      oldest: {
+        createdAt: 1
+      }
+    }, sort)
+  });
+  return BaseFilter2;
+}
+__name(BaseFilter, "BaseFilter");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseFilter,
+  Filter,
+  getFilterArgMetas,
+  getFilterKeyMetaMapOnPrototype,
+  getFilterMeta,
+  getFilterQuery,
+  getFilterQueryMap,
+  getFilterSort,
+  getFilterSortMap,
+  isFilterModel,
+  setFilterArgMetasOnPrototype,
+  setFilterKeyMetaMapOnPrototype,
+  setFilterMeta,
+  sortOf
+});

package/src/index.d.ts

@@ -0,0 +1,13 @@
+export { i as DEFAULT_PAGE_SIZE, D as DocumentModel, F as FilterType, b as FindQueryOption, f as GetActionObject, G as GetPlainObject, e as GetStateObject, c as ListOption, L as ListQueryOption, N as NonFunctionalKeys, g as ProtoAppInfo, P as ProtoFile, h as ProtoPatch, a as SortOf, S as SortType, T as TextDoc, d as defaultListOption } from '../types-DdO4B_Um.js';
+export { Field } from './fieldMeta.js';
+export { ConstantClassMeta, ConstantFieldMeta, ConstantFieldProps, ConstantFilterMeta, FieldType, FilterArgMeta, FilterArgProps, FilterKeyMeta, FilterKeyProps, ReturnType, fieldTypes, getClassMeta, getFieldMetaMap, getFieldMetaMapOnPrototype, getFieldMetas, getGqlTypeStr, getQueryMap, getScalarExample, isConstantModel, scalarExampleMap, setFieldMetaMap, setFieldMetaMapOnPrototype } from './scalar.js';
+export { ConstantModel, cnstOf, getCnstMeta } from './constantDecorator.js';
+export { BaseFilter, BaseFilterKey, Filter, getFilterArgMetas, getFilterKeyMetaMapOnPrototype, getFilterMeta, getFilterQuery, getFilterQueryMap, getFilterSort, getFilterSortMap, isFilterModel, setFilterArgMetasOnPrototype, setFilterKeyMetaMapOnPrototype, setFilterMeta, sortOf } from './filterMeta.js';
+export { as, from, mixModelOf, over, via } from './baseGql.js';
+export { ClassType, FilterModelStorage, FullModelStorage, InputModelStorage, LightModelStorage, Model, ScalarModelStorage, getAllFilterModelRefs, getAllFullModelRefs, getAllScalarModelRefs, getChildClassRefs, getFieldEnumMetas, getFullModelRef, getInputModelRef, getLightModelRef, getScalarModelRef, hasTextField } from './classMeta.js';
+export { FilterQuery as QueryOf } from 'mongoose';
+import 'dayjs';
+import 'fs';
+import 'stream';
+import '../types-b-U-yQib.js';
+import '../base-D8mO_G-C.js';

package/src/index.js

@@ -0,0 +1,33 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./types"), module.exports);
+__reExport(src_exports, require("./fieldMeta"), module.exports);
+__reExport(src_exports, require("./scalar"), module.exports);
+__reExport(src_exports, require("./constantDecorator"), module.exports);
+__reExport(src_exports, require("./filterMeta"), module.exports);
+__reExport(src_exports, require("./baseGql"), module.exports);
+__reExport(src_exports, require("./classMeta"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./types"),
+  ...require("./fieldMeta"),
+  ...require("./scalar"),
+  ...require("./constantDecorator"),
+  ...require("./filterMeta"),
+  ...require("./baseGql"),
+  ...require("./classMeta")
+});

package/src/scalar.d.ts

@@ -0,0 +1,97 @@
+import { E as Enum } from '../base-D8mO_G-C.js';
+import { j as SingleFieldType, k as GqlScalar, I as Int, U as Upload, l as Float, m as ID, J as JSON, S as SortType } from '../types-DdO4B_Um.js';
+import { T as Type } from '../types-b-U-yQib.js';
+import { FilterQuery, AccumulatorOperator } from 'mongoose';
+import { Dayjs } from 'dayjs';
+import 'fs';
+import 'stream';
+
+declare const scalarExampleMap: Map<MapConstructor | typeof Int | typeof Upload | typeof Float | typeof ID | typeof JSON | StringConstructor | BooleanConstructor | DateConstructor, string | number | boolean | object>;
+declare const getScalarExample: (ref: GqlScalar) => string | number | boolean | object | null;
+declare const getGqlTypeStr: (ref: GqlScalar) => string;
+interface ConstantClassMeta {
+    refName: string;
+    modelRef: any;
+    type: "input" | "full" | "light" | "scalar";
+    modelType: "data" | "ephemeral" | "summary" | "insight";
+    hasTextField: boolean;
+}
+interface ConstantFilterMeta {
+    refName: string;
+    sort: SortType;
+}
+interface FilterKeyProps {
+    type?: "mongo" | "meili";
+}
+interface FilterKeyMeta extends FilterKeyProps {
+    key: string;
+    descriptor: PropertyDescriptor;
+}
+interface FilterArgProps {
+    nullable?: boolean;
+    ref?: string;
+    default?: string | number | boolean | object | null | (() => string | number | boolean | object | null);
+    renderOption?: (value: any) => string;
+    enum?: Enum<string | number>;
+}
+interface FilterArgMeta extends FilterArgProps {
+    name: string;
+    modelRef: Type;
+    arrDepth: number;
+    isArray: boolean;
+    optArrDepth: number;
+}
+declare const fieldTypes: readonly ["email", "password", "url"];
+type FieldType = (typeof fieldTypes)[number];
+type ReturnType<T extends SingleFieldType = SingleFieldType> = (of?: any) => T | [T] | [[T]] | Map<string, any>;
+interface ConstantFieldProps {
+    nullable?: boolean;
+    ref?: string;
+    refPath?: string;
+    refType?: "child" | "parent" | "relation";
+    default?: string | number | boolean | object | null | Enum<string | number>;
+    type?: FieldType;
+    fieldType?: "property" | "hidden" | "resolve";
+    immutable?: boolean;
+    min?: number;
+    max?: number;
+    enum?: Enum<string | number>;
+    select?: boolean;
+    minlength?: number;
+    maxlength?: number;
+    query?: FilterQuery<any> | (() => FilterQuery<any>);
+    accumulate?: AccumulatorOperator;
+    example?: string | number | boolean | Dayjs | string[] | number[] | boolean[] | Dayjs[];
+    of?: GqlScalar;
+    validate?: (value: any, model: any) => boolean;
+    text?: "search" | "filter";
+}
+type ConstantFieldMeta = ConstantFieldProps & {
+    nullable: boolean;
+    default: any;
+    fieldType: "property" | "hidden" | "resolve";
+    immutable: boolean;
+    select: boolean;
+} & {
+    key: string;
+    name: string;
+    isClass: boolean;
+    isScalar: boolean;
+    modelRef: Type;
+    arrDepth: number;
+    isArray: boolean;
+    optArrDepth: number;
+    isMap: boolean;
+};
+declare const getClassMeta: (modelRef: Type) => ConstantClassMeta;
+declare const getFieldMetas: (modelRef: Type) => ConstantFieldMeta[];
+declare const isConstantModel: (modelRef: Type) => boolean;
+declare const getFieldMetaMap: (modelRef: Type) => Map<string, ConstantFieldMeta>;
+declare const setFieldMetaMap: (modelRef: Type, metadataMap: Map<string, ConstantFieldMeta>) => void;
+declare const getFieldMetaMapOnPrototype: (prototype: object) => Map<string, ConstantFieldMeta>;
+declare const setFieldMetaMapOnPrototype: (prototype: object, metadataMap: Map<string, ConstantFieldMeta>) => void;
+declare const getQueryMap: (modelRef: Type) => {
+    [key: string]: FilterQuery<any> | undefined | (() => FilterQuery<any>);
+};
+
+export { type ConstantClassMeta, type ConstantFieldMeta, type ConstantFieldProps, type ConstantFilterMeta, type FieldType, type FilterArgMeta, type FilterArgProps, type FilterKeyMeta, type FilterKeyProps, type ReturnType, fieldTypes, getClassMeta, getFieldMetaMap, getFieldMetaMapOnPrototype, getFieldMetas, getGqlTypeStr, getQueryMap, getScalarExample, isConstantModel, scalarExampleMap, setFieldMetaMap, setFieldMetaMapOnPrototype };