@sidekick-coder/zenith-kit 0.0.8 → 0.0.11

package/dist/server/index.d.mts

@@ -1,4 +1,10 @@
+import * as v from "valibot";
 import { ChildProcess } from "node:child_process";
+import { Request as Request$1, Response as Response$1 } from "express";
+import UploadService from "#server/services/upload.service.ts";
+import CookieService from "#shared/services/cookie.service.ts";
+import Acl from "#server/entities/acl.entity.ts";
+import { ColumnType, Generated, Kysely } from "kysely";
 
 //#region src/shared/services/LoggerService.d.ts
 declare class LoggerService {
@@ -9,6 +15,74 @@ declare class LoggerService {
   child(options: any): LoggerService;
 }
 //#endregion
+//#region src/shared/services/EmmitterService.d.ts
+interface EmmitterHandler {
+  id: string;
+  event: string;
+  listener: (...args: any[]) => any;
+  originalListener?: (...args: any[]) => any;
+}
+interface OnOptions {
+  id?: string;
+  unique?: boolean;
+}
+interface OnDebounceOptions extends OnOptions {
+  debounce?: number;
+}
+interface EmmitterServiceOptions {
+  debug?: boolean;
+  logger?: LoggerService;
+}
+declare class EmmitterService$1<Events extends Record<string, any> = Record<string, any>> {
+  private handlers;
+  private debug;
+  private logger;
+  load(options?: EmmitterServiceOptions): void;
+  on<K extends keyof Events>(event: K, listener: (args: Events[K]) => void, options?: OnOptions): EmmitterHandler;
+  on(event: string, listener: (args: any) => void, options?: OnOptions): EmmitterHandler;
+  once<K extends keyof Events>(event: K, listener: (args: Events[K]) => void, options?: OnOptions): EmmitterHandler;
+  once(event: string, listener: (args: any) => void, options?: OnOptions): EmmitterHandler;
+  onDebounce<K extends keyof Events>(event: K, listener: (args: Events[K]) => void, options?: OnDebounceOptions): EmmitterHandler;
+  onDebounce(event: string, listener: (args: any) => void, options?: OnDebounceOptions): EmmitterHandler;
+  onAnyOf<K extends keyof Events>(events: K[], listener: (args: Events[K]) => void, options?: OnOptions): EmmitterHandler[];
+  onAnyOf(events: string[], listener: (args: any) => void, options?: OnOptions): EmmitterHandler[];
+  off(event: string, listener: Function): void;
+  emit<K extends keyof Events>(event: K, args: Events[K]): void;
+  emit(event: string, args?: any): void;
+  emitAndWait<K extends keyof Events>(event: K, args: Events[K]): Promise<void>;
+  emitAndWait(event: string, args?: any): Promise<void>;
+  list(): EmmitterHandler[];
+  listByEvent(event: string): EmmitterHandler[];
+  remove(payload: string | string[]): void;
+  clear(): void;
+  hasHandlers(): boolean;
+}
+//#endregion
+//#region src/server/contracts/EventContract.d.ts
+interface EventContract {
+  'user:before-create': {
+    user: any;
+  };
+  'user:after-create': {
+    user: any;
+  };
+  'user:before-update': {
+    user: any;
+  };
+  'user:after-update': {
+    user: any;
+  };
+  'user:before-delete': {
+    user: any;
+  };
+  'user:after-delete': {
+    user: any;
+  };
+}
+//#endregion
+//#region src/server/services/EmmitterService.d.ts
+declare class EmmitterService extends EmmitterService$1<EventContract> {}
+//#endregion
 //#region src/server/gateways/GitGateway.d.ts
 interface GitRepoInfo {
   directory: string;
@@ -159,4 +233,615 @@ declare class PluginRouter {
   delete(path: string, handler: RouteHandler): void;
 }
 //#endregion
-export { GitBranch, GitBranchFetchOptions, GitBranchRepository, GitCommit, GitCommitListOptions, GitCommitRef, GitCommitRepository, GitGateway, GitGatewayOptions, GitRepoInfo, HttpMethod, IpcMessage, PaginatedCommits, PluginIpcClient, PluginIpcHost, PluginRouter, RouteDefinition, RouteHandler, RouteReply, RouteRequest, RouteResponsePayload };
+//#region src/shared/utils/compose.d.ts
+type Constructor$1<T = {}> = new (...args: any[]) => T;
+//#endregion
+//#region src/shared/mixins/HooksMixin.d.ts
+interface Listener {
+  event: string;
+  listener: (...args: any[]) => void;
+}
+//#endregion
+//#region src/shared/services/ConfigService.d.ts
+interface Entry {
+  key: string;
+  value: any;
+  source: string;
+}
+declare class ConfigService {
+  entries: Map<string, Entry>;
+  constructor();
+  list(): Entry[];
+  parseValue(value: any): any;
+  loadFromRecord(record: Record<string, any>, source?: string): void;
+  loadFromEntries(entries: [string, any][], source?: string): void;
+  toRecord(): Record<string, any>;
+  has(key: string): boolean;
+  get<T = any | undefined>(key: string, defaultValue?: any): T;
+  getOne<T = any | undefined>(keys: string[], defaultValue?: any): T;
+  set(key: string, value: any, source?: string): void;
+  unset(key: string): void;
+  clear(): void;
+}
+//#endregion
+//#region src/shared/services/ContainerService.d.ts
+type Constructor<T = object> = new (...args: any[]) => T;
+type EntryKey = string | symbol | Constructor;
+declare class ContainerService {
+  private entries;
+  loadFromRecord(record: Record<string, any>): void;
+  toRecord(): Record<string, any>;
+  set(payload: EntryKey, value: any): void;
+  has(payload: EntryKey): boolean;
+  get<T>(payload: EntryKey): T;
+  singleton<T>(classConstructor: Constructor<T>): T;
+  load(entries: Record<any, any>): void;
+  proxy<T = unknown>(key: EntryKey): T;
+  keys(): EntryKey[];
+}
+//#endregion
+//#region src/shared/entities/LifecycleHook.d.ts
+declare class LifecycleHook {
+  hook_id: string;
+  order?: number;
+  subhooks?: LifecycleHook[];
+  constructor();
+  onRegister(): Promise<void>;
+  onLoad(): Promise<void>;
+  onBoot(): Promise<void>;
+  onShutdown(): Promise<void>;
+}
+//#endregion
+//#region src/shared/schemas/tokenSchema.d.ts
+type Token = v.InferOutput<typeof tokenSchema>;
+declare const tokenSchema: v.ObjectSchema<{
+  readonly id: v.NumberSchema<undefined>;
+  readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+  readonly type: v.StringSchema<undefined>;
+  readonly user_id: v.NumberSchema<undefined>;
+  readonly token: v.StringSchema<undefined>;
+  readonly created_at: v.StringSchema<undefined>;
+  readonly updated_at: v.StringSchema<undefined>;
+  readonly expires_at: v.StringSchema<undefined>;
+}, undefined>;
+//#endregion
+//#region src/shared/entities/ModuleManifestEntity.d.ts
+interface ModuleManifestBuildImport {
+  from: string;
+  to?: string;
+  type: 'global_import';
+}
+interface ModuleManifestBuild {
+  imports?: ModuleManifestBuildImport[];
+}
+declare const ModuleManifest_base: {
+  new (...args: any[]): {
+    merge(data: Partial< /*elided*/any>): /*elided*/any;
+  };
+  from<T>(this: new () => T, data: Partial<T>): T;
+} & Constructor$1;
+declare class ModuleManifest extends ModuleManifest_base {
+  id: string;
+  name: string;
+  version: string;
+  description?: string;
+  enabled: boolean;
+  author?: string;
+  dependencies?: Record<string, string>;
+  build?: ModuleManifestBuild;
+  [key: string]: any;
+}
+//#endregion
+//#region src/shared/entities/ModuleEntity.d.ts
+interface ModuleUpgradeInfo {
+  source: 'git' | 'zip';
+  [key: string]: any;
+}
+declare const Module_base$1: {
+  new (...args: any[]): {
+    merge(data: Partial< /*elided*/any>): /*elided*/any;
+  };
+  from<T>(this: new () => T, data: Partial<T>): T;
+} & Constructor$1 & Constructor$1<{}> & typeof LifecycleHook;
+declare class Module$1 extends Module_base$1 {
+  id: string;
+  name: string;
+  enabled: boolean;
+  dependencies: Record<string, any>;
+  build: ModuleManifest['build'];
+  directory: string;
+  upgrade_info?: ModuleUpgradeInfo;
+  setData(data: Partial<Module$1 | ModuleManifest>): void;
+}
+//#endregion
+//#region src/server/contracts/HttpContextContract.d.ts
+interface Request extends Request$1 {}
+interface Response extends Response$1 {}
+interface HttpContext {
+  url: string;
+  method: string;
+  params: Record<string, string>;
+  query: Record<string, string | string[]>;
+  body: any;
+  cookie: CookieService;
+  upload: UploadService;
+  acl: Acl;
+  request: Request;
+  response: Response;
+  [key: string]: any;
+}
+//#endregion
+//#region src/server/contracts/RouterContract.d.ts
+interface Redirect {
+  redirect: string;
+}
+type HandleResult = Record<string, any> | Redirect | void;
+interface Middleware {
+  handle(ctx: any): HandleResult | Promise<HandleResult>;
+}
+type ExtractMiddlewareContext<M extends Middleware> = Awaited<ReturnType<M['handle']>> extends Record<string, any> ? Awaited<ReturnType<M['handle']>> : {};
+type ProcessMiddlewareArray<T extends readonly Middleware[]> = T extends readonly [infer First extends Middleware, ...infer Rest extends readonly Middleware[]] ? ExtractMiddlewareContext<First> & ProcessMiddlewareArray<Rest> : {};
+type MiddlewareHandleResult<T extends readonly Middleware[] = readonly Middleware[]> = ProcessMiddlewareArray<T>;
+interface Handler<T = Record<string, any>> {
+  (ctx: HttpContext & T): Promise<any> | any;
+}
+//#endregion
+//#region src/server/entities/RouteEntity.d.ts
+type RouteMethod = 'get' | 'GET' | 'post' | 'POST' | 'put' | 'PUT' | 'patch' | 'PATCH' | 'delete' | 'DELETE';
+declare class Route {
+  path: string;
+  method: RouteMethod;
+  handler: Handler<any> | null;
+  middlewares: Middleware[];
+  metadata: Record<string, any> | null;
+  constructor(data?: Partial<Route>);
+  static params(routePath: string, requestPath: string): Record<string, string>;
+  static query(requestPath: string): Record<string, string>;
+  toJSON(): {
+    path: string;
+    method: RouteMethod;
+    middlewares: string[];
+    metadata: Record<string, any> | null;
+  };
+}
+//#endregion
+//#region src/server/services/RouterService.d.ts
+type RouteContext = 'global' | 'group' | 'route';
+interface MiddlewareRegister {
+  middleware: Middleware;
+  context: RouteContext;
+}
+interface LoadOptions {
+  debug?: boolean;
+}
+declare const Router_base: {
+  new (...args: any[]): {
+    listeners: Listener[];
+    on(event: string, listener: (...args: any[]) => void): void;
+    off(event: string, listener: (...args: any[]) => void): void;
+    emit(event: string, ...args: any[]): void;
+    emitAsync(event: string, ...args: any[]): Promise<void>;
+  };
+} & Constructor$1;
+declare class Router<C = {}> extends Router_base {
+  routes: Route[];
+  middlewares: MiddlewareRegister[];
+  prefixes: string[];
+  groups: Router<any>[];
+  groupPrefixes: string[];
+  debug: boolean;
+  logger: LoggerService;
+  metadata: Record<string, any>;
+  constructor(data?: Partial<Router<C>>);
+  use<T extends Middleware>(middleware: T, context?: RouteContext): Router<C & MiddlewareHandleResult<[typeof middleware]>>;
+  prefix(prefix: string): this;
+  makePath(args: string): string;
+  add(payload: Pick<Route, 'path' | 'method' | 'handler'>): void;
+  get(path: string, handler: Handler<C>): void;
+  post(path: string, handler: Handler<C>): void;
+  put(path: string, handler: Handler<C>): void;
+  patch(path: string, handler: Handler<C>): void;
+  many(methods: Route['method'][], path: string, handler: Handler<C>): void;
+  delete(path: string, handler: Handler<C>): void;
+  group(): Router<C>;
+  resolve(method: string, path: string): Route | null;
+  execute(route: Route, initialCtx: any): Promise<any>;
+  matchPath(routePath: string, requestPath: string): boolean;
+  clear(): void;
+  list(): Route[];
+  load(options?: LoadOptions): Promise<void>;
+  loadSync(options?: LoadOptions): void;
+}
+//#endregion
+//#region src/server/services/RouterFileBaseRoutingService.d.ts
+declare class RouterFileBaseRoutingService {
+  private directory;
+  private prefix;
+  private module?;
+  private router;
+  private logger;
+  private routes;
+  debug: boolean;
+  setDirectory(directory: string): this;
+  setPrefix(prefix: string): this;
+  setRouter(router: Router): this;
+  setModule(module: string): this;
+  setLogger(logger: LoggerService): this;
+  setDebug(debug: boolean): this;
+  static create(directory: string): RouterFileBaseRoutingService;
+  loadFiles(): Promise<void>;
+  registerRoutes(): Promise<void>;
+  load(): Promise<void>;
+}
+//#endregion
+//#region src/server/services/ShellService.d.ts
+interface CommandOptions {
+  cwd?: string;
+  env?: NodeJS.ProcessEnv;
+  shell?: boolean;
+}
+declare class ShellService {
+  debug: boolean;
+  logger: LoggerService;
+  init(data?: Partial<ShellService>): void;
+  /**
+   * Execute a shell command and return a promise
+   */
+  command(bin: string, args: string[], options?: CommandOptions): Promise<void>;
+  /**
+   * Execute a shell command and return the output as a string
+   */
+  executeCommandWithOutput(bin: string, args: string[], options?: CommandOptions): Promise<string>;
+}
+//#endregion
+//#region src/server/repositories/DatabaseRepository.d.ts
+interface Pagination<T = any> {
+  items: T[];
+  page: number;
+  per_page: number;
+  total: number;
+  total_pages: number;
+}
+interface FindManyOptions {
+  limit?: number;
+  offset?: number;
+  orderBy?: string | string[];
+  orderDirection?: 'asc' | 'desc' | ('asc' | 'desc')[];
+}
+interface PaginateOptions {
+  page?: number;
+  limit?: number;
+  orderBy?: FindManyOptions['orderBy'];
+  orderDirection?: FindManyOptions['orderDirection'];
+}
+interface DeleteManyOptions {
+  limit?: number;
+}
+declare class DatabaseRepository {
+  protected db: Kysely<any>;
+  protected table: string;
+  protected primaryKey: string;
+  constructor(db: Kysely<any>, table: string, primaryKey: string);
+  setDatabase(db: Kysely<any>): this;
+  setTable(table: string): this;
+  setPrimaryKey(primaryKey: string): this;
+  query(options?: {
+    qb?: any;
+  } & Record<string, any>): any;
+  count(options?: Record<string, any>): Promise<number>;
+  findMany(options?: FindManyOptions & Record<string, any>): Promise<any>;
+  findById(id: any, options?: Record<string, any>): Promise<any>;
+  findByIdOrFail(id: any, options?: Record<string, any>): Promise<any>;
+  paginate(options?: PaginateOptions & Record<string, any>): Promise<Pagination<any>>;
+  create(data: any): Promise<any>;
+  createMany(data: any[]): Promise<any[]>;
+  updateById(id: any, data: any): Promise<void>;
+  deleteById(id: any): Promise<void>;
+  deleteMany(options?: DeleteManyOptions & Record<string, any>): Promise<void>;
+}
+//#endregion
+//#region src/server/mixins/DatabaseRepositoryInferMixin.d.ts
+interface IRepositoryTypes<TEntity = Record<string, any>, TPrimaryKeyType = any, TOptions = Record<string, any>> {
+  count(options?: TOptions): Promise<number>;
+  findMany(options?: TOptions & FindManyOptions): Promise<TEntity[]>;
+  findById(id: TPrimaryKeyType, options?: TOptions): Promise<TEntity | null>;
+  findByIdOrFail(id: TPrimaryKeyType, options?: TOptions): Promise<TEntity>;
+  paginate(options?: TOptions & PaginateOptions): Promise<Pagination>;
+  create(data: Partial<TEntity>, options?: TOptions): Promise<TEntity>;
+  createMany(data: Partial<TEntity>[], options?: TOptions): Promise<TEntity[]>;
+  deleteById(id: TPrimaryKeyType): Promise<void>;
+  destroyMany(options?: TOptions): Promise<void>;
+}
+declare function DatabaseRepositoryInferMixin<TEntity = Record<string, any>, TPrimaryKeyType = any, TOptions = Record<string, any>>(): <TBase extends Constructor$1>(Base: TBase) => TBase & Constructor$1<IRepositoryTypes<TEntity, TPrimaryKeyType, TOptions>>;
+//#endregion
+//#region src/server/repositories/PermissionAssignmentRepository.d.ts
+interface PermissionAssignmentRepositoryQueryOptions {
+  id?: number | number[];
+  permissionId?: number | number[];
+  assignableId?: number | number[];
+  assignableType?: string | string[];
+}
+declare const PermissionAssignmentRepository_base: Constructor$1 & Constructor$1<IRepositoryTypes<{
+  id: number;
+  permission_id: number;
+  assignable_type: string;
+  assignable_id: string;
+  created_at: string;
+  updated_at: string;
+}, number, PermissionAssignmentRepositoryQueryOptions>> & Constructor$1<{}> & typeof DatabaseRepository;
+declare class PermissionAssignmentRepository extends PermissionAssignmentRepository_base {
+  constructor(db: DatabaseRepository['db']);
+  query(options?: PermissionAssignmentRepositoryQueryOptions): any;
+}
+//#endregion
+//#region src/server/repositories/PermissionRepository.d.ts
+interface PermissionRepositoryQueryOptions {
+  id?: number | number[];
+  search?: string;
+}
+declare const PermissionRepository_base: Constructor$1<{}> & typeof DatabaseRepository & Constructor$1 & Constructor$1<IRepositoryTypes<{
+  id: number;
+  name: string | null;
+  description: string | null;
+  action: string;
+  subject: string;
+  conditions: string | null;
+  created_at: string;
+  updated_at: string;
+  expires_at: string;
+}, number, PermissionRepositoryQueryOptions>>;
+declare class PermissionRepository extends PermissionRepository_base {
+  constructor(db: DatabaseRepository['db']);
+  query(options?: PermissionRepositoryQueryOptions): any;
+}
+//#endregion
+//#region src/server/repositories/TokenRepository.d.ts
+interface TokenRepositoryQueryOptions {
+  id?: number | number[];
+  search?: string;
+  type?: string | string[];
+}
+declare const TokenRepository_base: Constructor$1<{}> & typeof DatabaseRepository & Constructor$1 & Constructor$1<IRepositoryTypes<{
+  id: number;
+  name: string | null;
+  type: string;
+  user_id: number;
+  token: string;
+  created_at: string;
+  updated_at: string;
+  expires_at: string;
+}, number, TokenRepositoryQueryOptions>>;
+declare class TokenRepository extends TokenRepository_base {
+  constructor(db: DatabaseRepository['db']);
+  query(options?: TokenRepositoryQueryOptions): any;
+  findByToken(token: string): Promise<Token | null>;
+}
+//#endregion
+//#region src/server/facades/config.d.ts
+declare const config: ConfigService;
+//#endregion
+//#region src/server/facades/container.d.ts
+declare const _default: ContainerService;
+//#endregion
+//#region src/server/contracts/DatabaseContract.d.ts
+interface SoftDeleteTable {
+  deleted_at?: ColumnType<Date, string | undefined, never> | null;
+}
+interface TimestampTable {
+  created_at: ColumnType<Date, string | undefined, never>;
+  updated_at: ColumnType<Date, string | undefined, never>;
+}
+interface MigrationsTable {
+  name: string;
+  module: string | null;
+  executed_at: ColumnType<Date, string | undefined, never>;
+}
+interface UserTable extends TimestampTable, SoftDeleteTable {
+  id: Generated<number>;
+  name: string;
+  username: string;
+  email: string;
+  password: string;
+  verified_at?: Date | string | null;
+}
+interface UserMetaTable extends TimestampTable, SoftDeleteTable {
+  id: Generated<number>;
+  user_id: number;
+  name: string;
+  value: string | null;
+}
+interface TokenTable extends TimestampTable {
+  id: Generated<number>;
+  user_id: number;
+  token: string;
+  type: string;
+  expires_at: string | null;
+}
+interface RoleTable {
+  id: Generated<number>;
+  name: string;
+  description: string | null;
+}
+interface UserRoleTable {
+  user_id: number;
+  role_id: number;
+}
+interface PermissionTable extends TimestampTable, SoftDeleteTable {
+  id: Generated<number>;
+  name: string;
+  description: string | null;
+  origin: string;
+  subject: string;
+  action: string;
+  conditions: string | null;
+}
+interface PermissionAssignmentTable {
+  id: Generated<number>;
+  permission_id: number;
+  assignable_type: string;
+  assignable_id: string;
+}
+interface FileTable extends TimestampTable, SoftDeleteTable {
+  id: Generated<number>;
+  drive: string;
+  mimetype: string;
+  client_name: string;
+  filename: string;
+  purpose: string;
+  public: boolean;
+}
+interface FileMetaTable extends TimestampTable, SoftDeleteTable {
+  id: Generated<number>;
+  file_id: number;
+  name: string;
+  value: string | null;
+}
+interface UploadSessionTable {
+  id: Generated<number>;
+  purpose: string;
+  mime_types: string;
+  max_size: number;
+  expires_at: string;
+}
+interface JobTable extends TimestampTable {
+  id: string;
+  queue_id: string;
+  status: 'pending' | 'in_progress' | 'completed' | 'failed';
+  data: string | null;
+  result: string | null;
+  error: string | null;
+}
+interface EmailTemplateTable extends TimestampTable, SoftDeleteTable {
+  id: Generated<number>;
+  name: string;
+  subject: string;
+  key: string;
+  body: string | null;
+  engine: string | null;
+}
+interface EmailTemplateMetaTable extends TimestampTable, SoftDeleteTable {
+  id: Generated<number>;
+  template_id: number;
+  name: string;
+  value: string;
+}
+interface OauthAccountTable extends TimestampTable, SoftDeleteTable {
+  id: Generated<number>;
+  user_id: number;
+  provider: string;
+  provider_user_id: string;
+  provider_user_email: string | null;
+}
+interface OauthTokenTable {
+  id: Generated<number>;
+  user_id: number | null;
+  provider: string | null;
+  action: string;
+  token: string;
+  expires_at: string;
+  metadata: string;
+}
+interface DatabaseContract {
+  users: UserTable;
+  user_metas: UserMetaTable;
+  tokens: TokenTable;
+  migrations: MigrationsTable;
+  files: FileTable;
+  file_metas: FileMetaTable;
+  file_upload_sessions: UploadSessionTable;
+  roles: RoleTable;
+  user_roles: UserRoleTable;
+  permissions: PermissionTable;
+  permissions_assignments: PermissionAssignmentTable;
+  jobs: JobTable;
+  email_templates: EmailTemplateTable;
+  email_template_metas: EmailTemplateMetaTable;
+  oauth_accounts: OauthAccountTable;
+  oauth_tokens: OauthTokenTable;
+}
+//#endregion
+//#region src/server/facades/database.d.ts
+declare const key = "database";
+declare const database: Kysely<DatabaseContract>;
+//#endregion
+//#region src/server/facades/logger.d.ts
+declare const logger: LoggerService;
+//#endregion
+//#region src/server/facades/router.d.ts
+declare const router: Router<HttpContext>;
+//#endregion
+//#region src/server/facades/shell.d.ts
+declare const shell: ShellService;
+//#endregion
+//#region src/server/utils/defineLoader.d.ts
+interface Loader<T = Record<string, any>> {
+  load(entities: T[]): Promise<void>;
+}
+interface LoaderRecord<T = Record<string, any>> {
+  [key: string]: Loader<T>;
+}
+declare function defineLoader<T = Record<string, any>>(loader: Loader<T>): Loader<T>;
+//#endregion
+//#region src/server/loaders/createHasManyThroughLoader.d.ts
+type KeyOrFunction<T> = keyof T | ((entity: T) => any);
+interface HasManyThroughLoaderOptions<TEntity extends Record<string, any> = Record<string, any>, TPivotEntity extends Record<string, any> = Record<string, any>, TTargetEntity extends Record<string, any> = Record<string, any>> {
+  key: string;
+  pivot: {
+    sourceKey: KeyOrFunction<TEntity>;
+    targetKey: KeyOrFunction<TPivotEntity>;
+    findEntities(ids: (string | number)[]): Promise<TPivotEntity[]>;
+  };
+  target: {
+    sourceKey: KeyOrFunction<TPivotEntity>;
+    targetKey: KeyOrFunction<TTargetEntity>;
+    findEntities(ids: (string | number)[]): Promise<TTargetEntity[]>;
+  };
+}
+declare function loadHasManyThrough<TEntity extends Record<string, any> = Record<string, any>, TPivotEntity extends Record<string, any> = Record<string, any>, TTargetEntity extends Record<string, any> = Record<string, any>>(payload: any | any[], options: HasManyThroughLoaderOptions<TEntity, TPivotEntity, TTargetEntity>): Promise<void>;
+declare function createHasManyThroughLoader<TEntity extends Record<string, any> = Record<string, any>, TPivotEntity extends Record<string, any> = Record<string, any>, TTargetEntity extends Record<string, any> = Record<string, any>>(options: HasManyThroughLoaderOptions<TEntity, TPivotEntity, TTargetEntity>): Loader<TEntity>;
+//#endregion
+//#region src/server/entities/ModuleEntity.d.ts
+declare const Module_base: typeof Module$1;
+declare class Module extends Module_base {
+  get git(): GitGateway;
+  makePath(...parts: string[]): string;
+  staticPath(...parts: string[]): string;
+  command: typeof shell.command;
+  load(): void;
+}
+//#endregion
+//#region src/server/utils/basePath.d.ts
+declare function basePath(...args: string[]): string;
+declare function tmpPath(...args: string[]): string;
+//#endregion
+//#region src/server/utils/createLoaderFactory.d.ts
+declare function createLoaderFactory<E extends Record<string, any> = Record<string, any>, R extends LoaderRecord<E> = LoaderRecord<E>>(loaders: R): {
+  keys: (keyof R)[];
+  loaders: R;
+  load: (entities: E | E[], names: keyof R | (keyof R)[]) => Promise<void>;
+};
+//#endregion
+//#region src/server/utils/importAll.d.ts
+interface Options {
+  cache?: boolean;
+  onBeforeImport?: (ctx: {
+    filename: string;
+  }) => void | Promise<void>;
+  onAfterImport?: (ctx: {
+    filename: string;
+    module: any;
+  }) => void | Promise<void>;
+  onError?: (ctx: {
+    filename: string;
+    error: Error;
+  }) => void | Promise<void>;
+  exclude?: string[];
+}
+declare function importFiles(files: string[], options?: Options): Promise<Record<string, any>>;
+declare function importGlob(pattern: string, options?: Options): Promise<Record<string, any>>;
+declare function importAll(directory: string, options?: Options): Promise<Record<string, any>>;
+//#endregion
+//#region src/server/utils/importOne.d.ts
+declare function importOne(filenames: string[]): Promise<any>;
+//#endregion
+export { DatabaseContract, DatabaseRepository, DatabaseRepositoryInferMixin, DeleteManyOptions, EmailTemplateMetaTable, EmailTemplateTable, EmmitterService, EventContract, FileMetaTable, FileTable, FindManyOptions, GitBranch, GitBranchFetchOptions, GitBranchRepository, GitCommit, GitCommitListOptions, GitCommitRef, GitCommitRepository, GitGateway, GitGatewayOptions, GitRepoInfo, HandleResult, Handler, HasManyThroughLoaderOptions, HttpContext, HttpMethod, IRepositoryTypes, IpcMessage, JobTable, Loader, LoaderRecord, Middleware, MiddlewareHandleResult, MigrationsTable, Module as ModuleEntity, OauthAccountTable, OauthTokenTable, PaginateOptions, PaginatedCommits, Pagination, PermissionAssignmentRepository, PermissionAssignmentRepositoryQueryOptions, PermissionAssignmentTable, PermissionRepository, PermissionRepositoryQueryOptions, PermissionTable, PluginIpcClient, PluginIpcHost, PluginRouter, Redirect, Request, Response, RoleTable, RouteDefinition, Route as RouteEntity, RouteHandler, RouteReply, RouteRequest, RouteResponsePayload, RouterFileBaseRoutingService, Router as RouterService, ShellService, SoftDeleteTable, TimestampTable, TokenRepository, TokenRepositoryQueryOptions, TokenTable, UploadSessionTable, UserMetaTable, UserRoleTable, UserTable, basePath, config, _default as container, createHasManyThroughLoader, createLoaderFactory, database, defineLoader, importAll, importFiles, importGlob, importOne, key, loadHasManyThrough, logger, router, shell, tmpPath };