@akanjs/server 0.0.4

package/src/searchDaemon.js

@@ -0,0 +1,228 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+var searchDaemon_exports = {};
+__export(searchDaemon_exports, {
+  SearchDaemonModule: () => SearchDaemonModule,
+  makeTextFilter: () => makeTextFilter
+});
+module.exports = __toCommonJS(searchDaemon_exports);
+var import_common = require("@akanjs/common");
+var import_constant = require("@akanjs/constant");
+var import_common2 = require("@nestjs/common");
+var import_mongoose = require("@nestjs/mongoose");
+var import_dbDecorators = require("./dbDecorators");
+const hasTextField = (modelRef) => {
+  const fieldMetas = (0, import_constant.getFieldMetas)(modelRef);
+  return fieldMetas.some(
+    (fieldMeta) => !!fieldMeta.text || fieldMeta.isScalar && fieldMeta.isClass && fieldMeta.select && hasTextField(fieldMeta.modelRef)
+  );
+};
+const getTextFieldKeys = (modelRef) => {
+  const allSearchFields = [];
+  const allFilterFields = [];
+  const fieldMetaMap = (0, import_constant.getFieldMetaMap)(modelRef);
+  const fieldMetas = [...fieldMetaMap.values()];
+  const stringTextFields = fieldMetas.filter((fieldMeta) => !!fieldMeta.text).map((fieldMeta) => {
+    if (fieldMeta.text === "filter")
+      allFilterFields.push(fieldMeta.key);
+    else if (fieldMeta.text === "search")
+      allSearchFields.push(fieldMeta.key);
+    return fieldMeta.key;
+  });
+  const scalarTextFields = fieldMetas.filter(
+    (fieldMeta) => fieldMeta.isScalar && fieldMeta.isClass && fieldMeta.select && hasTextField(fieldMeta.modelRef)
+  ).map((fieldMeta) => fieldMeta.key);
+  const deepFields = scalarTextFields.map((key) => {
+    const fieldMeta = fieldMetaMap.get(key);
+    if (!fieldMeta)
+      throw new Error(`No fieldMeta for ${key}`);
+    const { stringTextFields: stringTextFields2, allTextFields, allSearchFields: allSearchFields2, allFilterFields: allFilterFields2 } = getTextFieldKeys(
+      fieldMeta.modelRef
+    );
+    allFilterFields2.push(...allSearchFields2.map((field) => `${key}.${field}`));
+    allSearchFields2.push(...stringTextFields2.map((field) => `${key}.${field}`));
+    return [
+      ...stringTextFields2.map((field) => `${key}.${field}`),
+      ...allTextFields.map((field) => `${key}.${field}`)
+    ];
+  }).flat();
+  return {
+    stringTextFields,
+    scalarTextFields,
+    allTextFields: [...stringTextFields, ...deepFields],
+    allSearchFields,
+    allFilterFields
+  };
+};
+const makeTextFilter = (modelRef) => {
+  const fieldMetaMap = (0, import_constant.getFieldMetaMap)(modelRef);
+  const { stringTextFields, scalarTextFields } = getTextFieldKeys(modelRef);
+  const filterData = (data, assignObj = {}) => {
+    if (Array.isArray(data))
+      return data.map((d) => filterData(d));
+    return Object.assign(
+      Object.fromEntries([
+        ...stringTextFields.map((key) => [key, data[key]]),
+        ...scalarTextFields.map((key) => {
+          const fieldMeta = fieldMetaMap.get(key);
+          if (!fieldMeta)
+            throw new Error(`No fieldMeta for ${key}`);
+          const filterFunc = makeTextFilter(fieldMeta.modelRef);
+          return [key, filterFunc(data[key])];
+        })
+      ]),
+      assignObj
+    );
+  };
+  return filterData;
+};
+const getSortableAttributes = (refName) => {
+  const cnst = (0, import_constant.getCnstMeta)(refName);
+  const sortMap = (0, import_constant.getFilterSortMap)(cnst.Filter);
+  const sortFields = Object.values(sortMap).filter((val) => typeof val === "object").map((sort) => Object.keys(sort)).flat();
+  return [...new Set(sortFields)];
+};
+let SearchDaemon = class {
+  constructor(connection, meili) {
+    this.connection = connection;
+    this.meili = meili;
+  }
+  logger = new import_common.Logger("SearchDaemon");
+  async onModuleInit() {
+    const databaseModelNames = (0, import_dbDecorators.getAllDatabaseModelNames)();
+    const indexes = (await this.meili.getIndexes({ limit: 1e3 })).results;
+    const indexMap = new Map(indexes.map((index) => [index.uid, index]));
+    const indexCreationNames = [];
+    const indexUpdateNames = [];
+    for (const modelName of databaseModelNames) {
+      const indexName = (0, import_common.lowerlize)(modelName);
+      const modelRef = (0, import_constant.getFullModelRef)(modelName);
+      if (!hasTextField(modelRef))
+        continue;
+      const index = indexMap.get(indexName);
+      if (!index)
+        indexCreationNames.push(indexName);
+      else if (index.primaryKey !== "id")
+        indexUpdateNames.push(indexName);
+    }
+    for (const indexName of indexCreationNames)
+      await this.meili.createIndex(indexName, { primaryKey: "id" });
+    for (const indexName of indexUpdateNames)
+      await this.meili.updateIndex(indexName, { primaryKey: "id" });
+    for (const modelName of databaseModelNames) {
+      const indexName = (0, import_common.lowerlize)(modelName);
+      const model = this.connection.models[modelName];
+      const modelRef = (0, import_constant.getFullModelRef)(modelName);
+      if (!hasTextField(modelRef))
+        continue;
+      const searchIndex = this.meili.index(indexName);
+      const { stringTextFields, scalarTextFields, allSearchFields, allFilterFields } = getTextFieldKeys(modelRef);
+      const settings = await searchIndex.getSettings();
+      const allSearchFieldSet = new Set(allSearchFields);
+      const allFilterFieldSet = new Set(allFilterFields);
+      const searchFieldSet = new Set(settings.searchableAttributes);
+      const filterFieldSet = new Set(settings.filterableAttributes);
+      const needUpdateSetting = !allSearchFields.every((field) => searchFieldSet.has(field)) || !allFilterFields.every((field) => filterFieldSet.has(field)) || !settings.searchableAttributes?.every((field) => allSearchFieldSet.has(field)) || !settings.filterableAttributes?.every((field) => allFilterFieldSet.has(field));
+      if (needUpdateSetting) {
+        this.logger.info(`update index settings (${modelName})`);
+        await searchIndex.updateSettings({
+          searchableAttributes: allSearchFields,
+          filterableAttributes: allFilterFields,
+          sortableAttributes: getSortableAttributes(indexName)
+        });
+      }
+      const stringTextFieldSet = new Set(stringTextFields);
+      const scalarTextFieldSet = new Set(scalarTextFields);
+      const filterText = makeTextFilter(modelRef);
+      model.watch().on("change", async (data) => {
+        try {
+          const id = data.documentKey._id.toString();
+          if (data.operationType === "delete") {
+            this.logger.trace(`delete text doc (${modelName}): ${id}`);
+            return await searchIndex.deleteDocument(id);
+          } else if (data.operationType === "insert") {
+            this.logger.trace(`insert text doc (${modelName}): ${data.documentKey._id}`);
+            if (!data.fullDocument)
+              throw new Error("No fullDocument");
+            const textFilteredData = filterText(data.fullDocument);
+            return await searchIndex.addDocuments([textFilteredData]);
+          } else if (data.operationType === "update") {
+            const updatedFields = data.updateDescription?.updatedFields ?? {};
+            const isRemoved = !!updatedFields.removedAt;
+            if (isRemoved) {
+              this.logger.trace(`remove text doc (${modelName}): ${id}`);
+              return await searchIndex.deleteDocument(id);
+            }
+            this.logger.trace(`update text doc (${modelName}): ${data.documentKey._id}`);
+            const updatedFieldKeys = Object.keys(updatedFields);
+            const removedFieldKeys = data.updateDescription?.removedFields ?? [];
+            const isScalarTextFieldUpdated = [...updatedFieldKeys, ...removedFieldKeys].map((key) => key.split(".")[0]).some((key) => scalarTextFieldSet.has(key));
+            if (isScalarTextFieldUpdated) {
+              const doc = await model.findById(data.documentKey._id);
+              if (!doc)
+                this.logger.error(`No doc for ${data.documentKey._id}`);
+              const textFilteredData = filterText(doc, { id });
+              return await searchIndex.updateDocuments([textFilteredData]);
+            } else {
+              const updateKeys = updatedFieldKeys.filter((key) => stringTextFieldSet.has(key));
+              const removeKeys = removedFieldKeys.filter((key) => stringTextFieldSet.has(key));
+              if (!updateKeys.length && !removeKeys.length)
+                return;
+              const textFilteredData = Object.fromEntries([
+                ["id", id],
+                ...updateKeys.map((key) => [key, updatedFields[key]]),
+                ...removeKeys.map((key) => [key, null])
+              ]);
+              return await searchIndex.updateDocuments([textFilteredData]);
+            }
+          }
+        } catch (e) {
+          this.logger.error(e);
+        }
+      });
+    }
+  }
+};
+SearchDaemon = __decorateClass([
+  (0, import_common2.Injectable)(),
+  __decorateParam(0, (0, import_mongoose.InjectConnection)()),
+  __decorateParam(1, (0, import_common2.Inject)("MEILI_CLIENT"))
+], SearchDaemon);
+let SearchDaemonModule = class {
+};
+SearchDaemonModule = __decorateClass([
+  (0, import_common2.Global)(),
+  (0, import_common2.Module)({
+    providers: [SearchDaemon]
+  })
+], SearchDaemonModule);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SearchDaemonModule,
+  makeTextFilter
+});

package/src/serviceDecorators.d.ts

@@ -0,0 +1,178 @@
+import "reflect-metadata";
+import { BaseObject, Dayjs, Type } from "@akanjs/base";
+import { Logger } from "@akanjs/common";
+import { type DocumentModel, type FilterType, FindQueryOption, type GetActionObject, ListQueryOption, QueryOf, type SortOf } from "@akanjs/constant";
+import { FilterOutInternalArgs } from "@akanjs/signal";
+import { CronExpression } from "@nestjs/schedule";
+import type { Job, Queue as BullQueue } from "bull";
+import type { HydratedDocument } from "mongoose";
+import type { Server } from "socket.io";
+import { type BaseMiddleware, type Database, type DatabaseModel, type DataInputOf } from ".";
+export type GetServices<AllSrvs extends {
+    [key: string]: Type | undefined;
+}> = {
+    [key in keyof AllSrvs]: AllSrvs[key] extends Type<infer Srv> | undefined ? Srv : AllSrvs[key] extends Type<infer Srv> ? Srv : never;
+};
+export declare class ServiceStorage {
+}
+export interface ServiceInjectMeta {
+    type: "Db" | "Srv" | "Use" | "Queue" | "Websocket";
+    name: string;
+    key: string;
+}
+export declare function Service(name: string): (target: Type) => Type;
+export declare function Srv(name?: string): PropertyDecorator;
+export declare function Use(name?: string): PropertyDecorator;
+export declare function Queue(name?: string): PropertyDecorator;
+export type Queue<Signal> = {
+    [K in keyof Signal as K extends string ? Signal[K] extends (...args: any) => Promise<{
+        __Returns__: "Done";
+    }> ? K : never : never]: Signal[K] extends (...args: infer Args) => Promise<infer R> ? (...args: FilterOutInternalArgs<Args>) => Promise<Job> : never;
+} & BullQueue;
+export declare function Websocket(name?: string): PropertyDecorator;
+export type Websocket<Signal> = {
+    [K in keyof Signal as K extends string ? Signal[K] extends (...args: any) => Promise<{
+        __Returns__: "Subscribe";
+    }> ? K : Signal[K] extends (...args: any) => {
+        __Returns__: "Subscribe";
+    } ? K : never : never]: Signal[K] extends (...args: infer Args) => Promise<{
+        __Returns__: "Subscribe";
+    } & infer R> ? (...args: [...FilterOutInternalArgs<Args>, data: DocumentModel<R>]) => Promise<void> : Signal[K] extends (...args: infer Args) => {
+        __Returns__: "Subscribe";
+    } & infer R ? (...args: [...FilterOutInternalArgs<Args>, data: DocumentModel<R>]) => void : never;
+} & {
+    server: Server;
+};
+export declare function Db(name: string): PropertyDecorator;
+export declare const serviceOf: (srvRef: Type) => Type;
+export declare function MixSrvs<T1 = unknown, T2 = unknown, T3 = unknown, T4 = unknown, T5 = unknown, T6 = unknown, T7 = unknown, T8 = unknown, T9 = unknown, T10 = unknown, T11 = unknown, T12 = unknown, T13 = unknown, T14 = unknown, T15 = unknown, T16 = unknown, T17 = unknown, T18 = unknown, T19 = unknown, T20 = unknown>(t1: Type<T1>, t2?: Type<T2>, t3?: Type<T3>, t4?: Type<T4>, t5?: Type<T5>, t6?: Type<T6>, t7?: Type<T7>, t8?: Type<T8>, t9?: Type<T9>, t10?: Type<T10>, t11?: Type<T11>, t12?: Type<T12>, t13?: Type<T13>, t14?: Type<T14>, t15?: Type<T15>, t16?: Type<T16>, t17?: Type<T17>, t18?: Type<T18>, t19?: Type<T19>, t20?: Type<T20>): Type<T1 & T2 & T3 & T4 & T5 & T6 & T7 & T8 & T9 & T10 & T11 & T12 & T13 & T14 & T15 & T16 & T17 & T18 & T19 & T20>;
+export declare const LogService: <T extends string>(name: T) => {
+    new (): {
+        logger: Logger;
+    };
+};
+type QueueService<Signal> = {
+    [K in keyof Signal as K extends string ? Signal[K] extends (...args: any) => Promise<{
+        __Returns__: "Done";
+    }> ? K : never : never]: Signal[K] extends (...args: infer Args) => Promise<infer R> ? (...args: FilterOutInternalArgs<Args>) => Promise<Job> : never;
+};
+type DatabaseService<T extends string, Input, Doc, Obj, Model, Insight, Filter, Summary> = DatabaseServiceWithQuerySort<T, Input, Doc, Obj, Model, Insight, GetActionObject<Filter>, SortOf<Filter>>;
+type DatabaseServiceWithQuerySort<T extends string, Input, Doc, Obj, Model, Insight, Query, Sort> = {
+    logger: Logger;
+    __databaseModel: Model;
+    __list(query?: QueryOf<Doc>, queryOption?: ListQueryOption<Sort, Obj>): Promise<Doc[]>;
+    __listIds(query?: QueryOf<Doc>, queryOption?: ListQueryOption<Sort, Obj>): Promise<string[]>;
+    __find(query?: QueryOf<Doc>, queryOption?: FindQueryOption<Sort, Obj>): Promise<Doc | null>;
+    __findId(query?: QueryOf<Doc>, queryOption?: FindQueryOption<Sort, Obj>): Promise<string | null>;
+    __pick(query?: QueryOf<Doc>, queryOption?: FindQueryOption<Sort, Obj>): Promise<Doc>;
+    __pickId(query?: QueryOf<Doc>, queryOption?: FindQueryOption<Sort, Obj>): Promise<string>;
+    __exists(query?: QueryOf<Doc>): Promise<string | null>;
+    __count(query?: QueryOf<Doc>): Promise<number>;
+    __insight(query?: QueryOf<Doc>): Promise<Insight>;
+    __search(query: QueryOf<Doc>, queryOption?: ListQueryOption<Sort, Obj>): Promise<{
+        docs: Doc[];
+        count: number;
+    }>;
+    __searchDocs(query: QueryOf<Doc>, queryOption?: ListQueryOption<Sort, Obj>): Promise<Doc[]>;
+    __searchCount(query: QueryOf<Doc>): Promise<number>;
+    _preCreate(data: DataInputOf<Input, Doc>): Promise<DataInputOf<Input, Doc>> | DataInputOf<Input, Doc>;
+    _postCreate(doc: Doc): Promise<Doc> | Doc;
+    _preUpdate(id: string, data: Partial<Doc>): Promise<Partial<Doc>> | Partial<Doc>;
+    _postUpdate(doc: Doc): Promise<Doc> | Doc;
+    _preRemove(id: string): Promise<void> | void;
+    _postRemove(doc: Doc): Promise<Doc> | Doc;
+} & {
+    [key in `${T}Model`]: Model;
+} & {
+    [K in `get${Capitalize<T>}`]: (id: string) => Promise<Doc>;
+} & {
+    [K in `load${Capitalize<T>}`]: (id?: string) => Promise<Doc | null>;
+} & {
+    [K in `load${Capitalize<T>}Many`]: (ids: string[]) => Promise<Doc[]>;
+} & {
+    [K in `create${Capitalize<T>}`]: (data: DataInputOf<Input, Doc>) => Promise<Doc>;
+} & {
+    [K in `update${Capitalize<T>}`]: (id: string, data: Partial<Doc>) => Promise<Doc>;
+} & {
+    [K in `remove${Capitalize<T>}`]: (id: string) => Promise<Doc>;
+} & {
+    [K in `search${Capitalize<T>}`]: (searchText: string, queryOption?: ListQueryOption<Sort, Obj>) => Promise<{
+        docs: Doc[];
+        count: number;
+    }>;
+} & {
+    [K in `searchDocs${Capitalize<T>}`]: (searchText: string, queryOption?: ListQueryOption<Sort, Obj>) => Promise<Doc[]>;
+} & {
+    [K in `searchCount${Capitalize<T>}`]: (searchText: string) => Promise<number>;
+} & {
+    [K in keyof Query as K extends string ? `list${Capitalize<K>}` : never]: Query[K] extends (...args: infer Args) => any ? (...args: [...Args, queryOption?: ListQueryOption<Sort, Obj>]) => Promise<Doc[]> : never;
+} & {
+    [K in keyof Query as K extends string ? `listIds${Capitalize<K>}` : never]: Query[K] extends (...args: infer Args) => any ? (...args: [...Args, queryOption?: ListQueryOption<Sort, Obj>]) => Promise<string[]> : never;
+} & {
+    [K in keyof Query as K extends string ? `find${Capitalize<K>}` : never]: Query[K] extends (...args: infer Args) => any ? (...args: [...Args, queryOption?: FindQueryOption<Sort, Obj>]) => Promise<Doc | null> : never;
+} & {
+    [K in keyof Query as K extends string ? `findId${Capitalize<K>}` : never]: Query[K] extends (...args: infer Args) => any ? (...args: [...Args, queryOption?: FindQueryOption<Sort, Obj>]) => Promise<string | null> : never;
+} & {
+    [K in keyof Query as K extends string ? `pick${Capitalize<K>}` : never]: Query[K] extends (...args: infer Args) => any ? (...args: [...Args, queryOption?: FindQueryOption<Sort, Obj>]) => Promise<Doc> : never;
+} & {
+    [K in keyof Query as K extends string ? `pickId${Capitalize<K>}` : never]: Query[K] extends (...args: infer Args) => any ? (...args: [...Args, queryOption?: FindQueryOption<Sort, Obj>]) => Promise<string> : never;
+} & {
+    [K in keyof Query as K extends string ? `exists${Capitalize<K>}` : never]: Query[K] extends (...args: infer Args) => any ? (...args: [...Args]) => Promise<string | null> : never;
+} & {
+    [K in keyof Query as K extends string ? `count${Capitalize<K>}` : never]: Query[K] extends (...args: infer Args) => any ? (...args: [...Args]) => Promise<number> : never;
+} & {
+    [K in keyof Query as K extends string ? `insight${Capitalize<K>}` : never]: Query[K] extends (...args: infer Args) => any ? (...args: [...Args]) => Promise<Insight> : never;
+};
+export declare const DbService: <T extends string, Input, Doc extends unknown, Model extends DatabaseModel<T, Input, Doc, Obj, Insight, Filter, Summary>, Middleware extends BaseMiddleware, Obj, Insight, Filter extends FilterType, Summary, Signal = unknown>(database: Database<T, Input, Doc, Model, Middleware, Obj, Insight, Filter, Summary>, sigRef?: Type<Signal>) => Type<DatabaseService<T, Input, Doc, Obj, Model, Insight, Filter, Summary>>;
+export declare const ExtendedUserService: <T extends string, Input, Doc extends unknown, Model extends DatabaseModel<T, Input, Doc, Obj, Insight, Filter, Summary>, Middleware extends BaseMiddleware, Obj, Insight, Filter extends FilterType, Summary, Srv, Signal = unknown>(database: Database<T, Input, Doc, Model, Middleware, Obj, Insight, Filter, Summary>, srvRef: Type<Srv>, sigRef?: Type<Signal>) => Type<DatabaseService<T, Input, Doc, BaseObject & {
+    nickname: string;
+}, Model, Insight, Filter, Summary> & {
+    queue: QueueService<Signal>;
+} & { [K in keyof Srv]: Srv[K] extends (...args: infer Args) => Promise<BaseObject & {
+    nickname: string;
+}> ? (...args: Args) => Promise<Doc> : Srv[K] extends (...args: infer Args) => Promise<(BaseObject & {
+    nickname: string;
+})[]> ? (...args: Args) => Promise<Doc[]> : Srv[K] extends BaseObject & {
+    nickname: string;
+} ? Doc : Srv[K] extends (BaseObject & {
+    nickname: string;
+})[] ? Doc[] : Srv[K]; }>;
+export declare const ExtendedSummaryService: <T extends string, Input, Doc extends unknown, Model, Middleware extends BaseMiddleware, Obj, Insight, Filter extends FilterType, Summary, Srv, Signal = unknown>(database: Database<T, Input, Doc, Model, Middleware, Obj, Insight, Filter, Summary>, srvRef: Type<Srv>, sigRef?: Type<Signal>) => Type<Omit<DatabaseService<T, Input, Doc, Obj, Model, Insight, Filter, Summary> & {
+    queue: QueueService<Signal>;
+} & { [K in keyof Srv]: Srv[K] extends (...args: infer Args) => Promise<BaseObject & {
+    type: string;
+    at: Dayjs;
+}> ? (...args: Args) => Promise<Doc> : Srv[K] extends (...args: infer Args) => Promise<(BaseObject & {
+    type: string;
+    at: Dayjs;
+})[]> ? (...args: Args) => Promise<Doc[]> : Srv[K] extends BaseObject & {
+    type: string;
+    at: Dayjs;
+} ? Doc : Srv[K] extends (BaseObject & {
+    type: string;
+    at: Dayjs;
+})[] ? Doc[] : Srv[K]; }, "userService">>;
+export declare const ExtendedSettingService: <T extends string, Input, Doc extends unknown, Model extends DatabaseModel<T, Input, Doc, Obj, Insight, Filter, Summary>, Middleware extends BaseMiddleware, Obj, Insight, Filter extends FilterType, Summary, Srv, Signal = unknown>(database: Database<T, Input, Doc, Model, Middleware, Obj, Insight, Filter, Summary>, srvRef: Type<Srv>, sigRef?: Type<Signal>) => Type<DatabaseService<T, Input, Doc, BaseObject & {
+    resignupDays: number;
+}, Model, Insight, Filter, Summary> & {
+    queue: QueueService<Signal>;
+} & { [K in keyof Srv]: Srv[K] extends (...args: infer Args) => Promise<BaseObject & {
+    resignupDays: number;
+}> ? (...args: Args) => Promise<Doc> : Srv[K] extends (...args: infer Args) => Promise<(BaseObject & {
+    resignupDays: number;
+})[]> ? (...args: Args) => Promise<Doc[]> : Srv[K] extends BaseObject & {
+    resignupDays: number;
+} ? Doc : Srv[K] extends (BaseObject & {
+    resignupDays: number;
+})[] ? Doc[] : Srv[K]; }>;
+export declare const Try: () => (target: any, key: string, descriptor: PropertyDescriptor) => void;
+interface TimerOptions {
+    lock?: boolean;
+    serverMode?: "federation" | "batch";
+    enabled?: boolean;
+}
+export declare const Cron: (cronTime: CronExpression | string, { lock, serverMode, enabled }?: TimerOptions) => (target: any, key: string, descriptor: PropertyDescriptor) => void;
+export declare const Interval: (ms: number, { lock, serverMode, enabled }?: TimerOptions) => (target: any, key: string, descriptor: PropertyDescriptor) => PropertyDescriptor | undefined;
+export declare const Transaction: () => (target: any, key: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare const Cache: (timeout?: number, getCacheKey?: (...args: any) => string) => MethodDecorator;
+export {};