@sidekick-coder/zenith-kit 0.0.12 → 0.0.14

package/dist/shared/index.d.mts

@@ -1,4 +1,6 @@
 import * as v from "valibot";
+import * as _$_casl_ability0 from "@casl/ability";
+import { defineAbility } from "@casl/ability";
 
 //#region src/shared/services/ConfigService.d.ts
 interface Entry {
@@ -7,6 +9,7 @@ interface Entry {
   source: string;
 }
 declare class ConfigService {
+  static __container_entry_key: string;
   entries: Map<string, Entry>;
   constructor();
   list(): Entry[];
@@ -20,6 +23,7 @@ declare class ConfigService {
   set(key: string, value: any, source?: string): void;
   unset(key: string): void;
   clear(): void;
+  dump(): Record<string, any>;
 }
 //#endregion
 //#region src/shared/services/ContainerService.d.ts
@@ -29,6 +33,7 @@ declare class ContainerService {
   private entries;
   loadFromRecord(record: Record<string, any>): void;
   toRecord(): Record<string, any>;
+  private getKey;
   set(payload: EntryKey, value: any): this;
   has(payload: EntryKey): boolean;
   get<T>(payload: EntryKey): T;
@@ -38,19 +43,9 @@ declare class ContainerService {
   keys(): EntryKey[];
 }
 //#endregion
-//#region src/shared/services/CookieService.d.ts
-declare class CookieService {
-  cookies: Map<string, string>;
-  prefix: string;
-  constructor(data?: Partial<CookieService>);
-  load(cookies: Record<string, string> | Map<string, string>): void;
-  get(name: string, defaultValue?: string | null): string | null;
-  set(name: string, value: string, options?: any): void;
-  toRecord(): Record<string, string>;
-}
-//#endregion
 //#region src/shared/services/LoggerService.d.ts
 declare class LoggerService {
+  static __container_entry_key: string;
   info(message: string, meta?: any): void;
   debug(message: string, meta?: any): void;
   warn(message: string, meta?: any): void;
@@ -77,10 +72,14 @@ interface EmmitterServiceOptions {
   logger?: LoggerService;
 }
 declare class EmmitterService<Events extends Record<string, any> = Record<string, any>> {
+  static __container_entry_key: string;
   private handlers;
   private debug;
   private logger;
-  load(options?: EmmitterServiceOptions): void;
+  constructor(options?: EmmitterServiceOptions);
+  static create<Events extends Record<string, any> = Record<string, any>>(options?: EmmitterServiceOptions): EmmitterService<Events>;
+  setDebug(debug: boolean): void;
+  setLogger(logger: LoggerService): 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;
@@ -104,12 +103,20 @@ declare class EmmitterService<Events extends Record<string, any> = Record<string
 //#region src/shared/entities/LifecycleHook.d.ts
 declare class LifecycleHook {
   hook_id: string;
+  hook_aliases?: string[];
   order?: number;
   subhooks?: LifecycleHook[];
-  constructor();
+  register(): Promise<void>;
+  load(): Promise<void>;
+  boot(): Promise<void>;
+  shutdown(): Promise<void>;
+  /** @deprecated Use register */
   onRegister(): Promise<void>;
+  /** @deprecated Use load */
   onLoad(): Promise<void>;
+  /** @deprecated Use boot */
   onBoot(): Promise<void>;
+  /** @deprecated Use shutdown */
   onShutdown(): Promise<void>;
 }
 //#endregion
@@ -159,17 +166,35 @@ declare function composeWith<TBase extends Constructor, M extends Array<(base: C
 declare function mixin<TBase extends Constructor>(Source: TBase): <TTarget extends Constructor>(Target: TTarget) => TTarget & TBase;
 //#endregion
 //#region src/shared/services/LifecycleService.d.ts
+type LifecycleMethod = 'register' | 'load' | 'boot' | 'shutdown';
 interface ListOptions {
-  exclude?: (string | Constructor<LifecycleHook> | LifecycleHook)[];
+  include?: string | string[];
+  exclude?: string | string[];
+}
+interface LifecycleServiceOptions {
+  debug?: boolean;
+  hooks?: Map<string, LifecycleHook>;
+  logger?: LoggerService;
+  onError?: (error: Error, context: {
+    hookId: string;
+    method: LifecycleMethod;
+  }) => void;
 }
 declare class LifecycleService {
+  static __container_entry_key: string;
   hooks: Map<string, LifecycleHook>;
   logger: LoggerService;
   debug: boolean;
-  constructor(data?: Partial<LifecycleService>);
-  private executeHookMethod;
+  constructor(data?: LifecycleServiceOptions);
+  onError(error: Error, context: {
+    hookId: string;
+    method: LifecycleMethod;
+  }): void;
+  mapAliases(args: string[]): string[];
   list(options?: ListOptions): LifecycleHook[];
   add(...payload: (LifecycleHook | Constructor<LifecycleHook>)[]): void;
+  emitMethod(method: LifecycleMethod, options?: ListOptions): Promise<void>;
+  emit(payload: LifecycleMethod | LifecycleMethod[], options?: ListOptions): Promise<void>;
   register(options?: ListOptions): Promise<void>;
   load(options?: ListOptions): Promise<void>;
   boot(options?: ListOptions): Promise<void>;
@@ -179,6 +204,7 @@ declare class LifecycleService {
 //#endregion
 //#region src/shared/services/TranslatorService.d.ts
 declare class TranslatorService {
+  static __container_entry_key: string;
   entries: Map<string, string>;
   locale: string;
   localeLoaders: Map<string, () => Promise<Record<string, string>>>;
@@ -200,10 +226,11 @@ declare class TranslatorService {
 //#endregion
 //#region src/shared/services/UploadService.d.ts
 declare class UploadService {
+  static __container_entry_key: string;
   single(name: string): void;
   multiple(name: string): void;
 }
-declare namespace url_d_exports {
+declare namespace urlValidator_d_exports {
   export { array, arrayNumber, boolean, date, datetime, number, object };
 }
 declare const number: () => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, v.TransformAction<any, number>, v.IntegerAction<number, undefined>]>;
@@ -219,10 +246,24 @@ declare const object: () => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSc
 }>, v.TransformAction<{
   [x: string]: any;
 }, Record<string, any>>]>;
+declare namespace paginationValidator_d_exports {
+  export { PaginationParams, base };
+}
+interface PaginationParams {
+  maxLimit?: number;
+  orderFields?: string[];
+}
+declare const base: (options?: PaginationParams) => v.ObjectSchema<{
+  readonly page: v.OptionalSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, v.TransformAction<any, number>, v.IntegerAction<number, undefined>]>, 1>;
+  readonly limit: v.OptionalSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, v.TransformAction<any, number>, v.IntegerAction<number, undefined>]>, number>;
+  readonly orderBy: v.OptionalSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, v.TransformAction<string | string[], string[]>, v.ArraySchema<v.PicklistSchema<string[], undefined>, undefined>]> | v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, v.TransformAction<string | string[], string[]>, v.ArraySchema<v.StringSchema<undefined>, undefined>]>, readonly []>;
+  readonly orderDirection: v.OptionalSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, v.TransformAction<string | string[], string[]>, v.ArraySchema<v.UnionSchema<[v.LiteralSchema<"asc", undefined>, v.LiteralSchema<"desc", undefined>], undefined>, undefined>]>, readonly []>;
+}, undefined>;
 //#endregion
 //#region src/shared/services/ValidatorService.d.ts
 declare const extras: {
-  url: typeof url_d_exports;
+  url: typeof urlValidator_d_exports;
+  pagination: typeof paginationValidator_d_exports;
 };
 type Valibot = typeof v & {
   extras: typeof extras;
@@ -239,6 +280,7 @@ type ValidatorResult<T extends v.ObjectEntries> = v.InferOutput<v.ObjectSchema<T
 type ValidatePayload<T extends ValibotSchema = ValibotSchema> = ValidatorCallback<T> | T;
 type ValidateResult<T extends ValidatePayload> = T extends ValibotSchema ? v.InferOutput<T> : T extends ValidatorCallback<infer U> ? v.InferOutput<U> : unknown;
 declare class ValidatorService {
+  static __container_entry_key: string;
   v: Valibot;
   create<T extends ValibotSchema>(cb: ValidatorCallback<T>): T;
   validate<T extends ValibotSchema>(payload: any, cb: ValidatePayload<T>): v.InferOutput<T>;
@@ -256,6 +298,10 @@ declare function unflatten(obj: any): Record<string, any>;
 //#region src/shared/utils/formatBytes.d.ts
 declare function formatBytes(bytes: number, decimals?: number): string;
 //#endregion
+//#region src/shared/utils/parseRouteUrl.d.ts
+declare function parseUrlParams(routePath: string, requestPath: string): Record<string, string>;
+declare function parseUrlQuery(requestPath: string): Record<string, any>;
+//#endregion
 //#region src/shared/utils/tryCatch.d.ts
 interface Tryer {
   (...args: any[]): any;
@@ -326,6 +372,240 @@ declare class ShellException extends BaseException {
 //#region src/shared/facades/validator.d.ts
 declare const validator: ValidatorService;
 //#endregion
+//#region src/shared/mixins/BaseEntityMixin.d.ts
+interface CreateBaseEntityOptions {
+  parse?: (data: any) => any;
+}
+declare function createBaseEntity(options?: CreateBaseEntityOptions): <TBase extends Constructor>(Base: TBase) => {
+  new (...args: any[]): {
+    merge(data: Partial< /*elided*/any>): /*elided*/any;
+  };
+  from<T>(this: new () => T, data: Partial<T>): T;
+} & TBase;
+declare function BaseEntity<TBase extends Constructor>(Base: TBase): {
+  new (...args: any[]): {
+    merge(data: Partial< /*elided*/any>): /*elided*/any;
+  };
+  from<T>(this: new () => T, data: Partial<T>): T;
+} & TBase;
+//#endregion
+//#region src/shared/mixins/HooksMixin.d.ts
+interface Listener {
+  event: string;
+  listener: (...args: any[]) => void;
+}
+declare function emitHook(constructor: any, event: string, ...args: any[]): Promise<void>;
+declare function onHook(constructor: any, event: string, listener: (...args: any[]) => void): void;
+declare function HooksStatic<TBase extends Constructor>(Base: TBase): {
+  new (...args: any[]): {};
+  listeners: Array<(...args: any[]) => void>;
+  on(event: string, listener: (...args: any[]) => void): void;
+  emit(event: string, ...args: any[]): Promise<void>;
+} & TBase;
+declare namespace HooksStatic {
+  var emit: typeof emitHook;
+  var on: typeof onHook;
+}
+declare function Hooks<TBase extends Constructor>(Base: TBase): {
+  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>;
+  };
+} & TBase;
+//#endregion
+//#region src/shared/mixins/SoftDeleteMixin.d.ts
+declare function SoftDeleteMixin<T extends Constructor>(base: T): {
+  new (...args: any[]): {
+    deleted_at: Date | string | null;
+  };
+} & T;
+//#endregion
+//#region src/shared/mixins/TimestampMixin.d.ts
+declare function TimestampMixin<T extends Constructor>(base: T): {
+  new (...args: any[]): {
+    created_at: Date | string;
+    updated_at: Date | string;
+  };
+} & T;
+//#endregion
+//#region src/shared/entities/PermissionEntity.d.ts
+declare const PermissionEntity_base: {
+  new (...args: any[]): {
+    merge(data: Partial< /*elided*/any>): /*elided*/any;
+  };
+  from<T>(this: new () => T, data: Partial<T>): T;
+} & Constructor;
+declare class PermissionEntity extends PermissionEntity_base {
+  id: number;
+  name: string;
+  description: string | null;
+  origin: string;
+  subject: string;
+  action: string;
+  conditions: string | null | Record<string, any>;
+  get editable(): boolean;
+  get parsedConditions(): any;
+}
+//#endregion
+//#region src/shared/entities/AclEntity.d.ts
+declare class AclEntity {
+  static __container_entry_key: string;
+  ability: ReturnType<typeof defineAbility>;
+  permissions: PermissionEntity[];
+  debug: boolean;
+  logger: LoggerService;
+  constructor(data?: Partial<AclEntity>);
+  can(action: string, subject: any, object?: Record<string, any>): boolean;
+  cannot(action: string, subject: any, object?: Record<string, any>): boolean;
+  subject(subject: string, object: Record<string, any>): Record<string, any> & _$_casl_ability0.ForcedSubject<string>;
+}
+//#endregion
+//#region src/shared/entities/CookieMapEntity.d.ts
+interface CookieMapEntityOptions$1 {
+  cookies?: Map<string, string>;
+  prefix?: string;
+}
+declare class CookieMapEntity {
+  static __container_entry_key: string;
+  cookies: Map<string, string>;
+  prefix: string;
+  constructor(data?: CookieMapEntityOptions$1);
+  load(cookies: Record<string, string> | Map<string, string>): void;
+  get(name: string, defaultValue?: string | null): string | null;
+  set(name: string, value: string, options?: any): void;
+  toRecord(): Record<string, string>;
+}
+//#endregion
+//#region src/shared/entities/DriveConfigEntity.d.ts
+declare const TYPES: () => ({
+  id: string;
+  label: any;
+  description: any;
+  config_fields: {
+    directory: {
+      component: string;
+      label: any;
+      description: any;
+      hint: any;
+    };
+    accessKeyId?: undefined;
+    secretAccessKey?: undefined;
+    bucket?: undefined;
+    region?: undefined;
+    prefix?: undefined;
+    endpoint?: undefined;
+  };
+} | {
+  id: string;
+  label: string;
+  description: any;
+  config_fields: {
+    accessKeyId: {
+      component: string;
+      label: any;
+      hint: any;
+      type: string;
+    };
+    secretAccessKey: {
+      component: string;
+      label: any;
+      hint: any;
+      type: string;
+    };
+    bucket: {
+      component: string;
+      label: any;
+      hint: any;
+    };
+    region: {
+      component: string;
+      label: any;
+      hint: any;
+    };
+    prefix: {
+      component: string;
+      label: any;
+      hint: any;
+    };
+    endpoint: {
+      component: string;
+      label: any;
+      hint: any;
+    };
+    directory?: undefined;
+  };
+})[];
+declare class DriveConfig {
+  static get TYPES(): ({
+    id: string;
+    label: any;
+    description: any;
+    config_fields: {
+      directory: {
+        component: string;
+        label: any;
+        description: any;
+        hint: any;
+      };
+      accessKeyId?: undefined;
+      secretAccessKey?: undefined;
+      bucket?: undefined;
+      region?: undefined;
+      prefix?: undefined;
+      endpoint?: undefined;
+    };
+  } | {
+    id: string;
+    label: string;
+    description: any;
+    config_fields: {
+      accessKeyId: {
+        component: string;
+        label: any;
+        hint: any;
+        type: string;
+      };
+      secretAccessKey: {
+        component: string;
+        label: any;
+        hint: any;
+        type: string;
+      };
+      bucket: {
+        component: string;
+        label: any;
+        hint: any;
+      };
+      region: {
+        component: string;
+        label: any;
+        hint: any;
+      };
+      prefix: {
+        component: string;
+        label: any;
+        hint: any;
+      };
+      endpoint: {
+        component: string;
+        label: any;
+        hint: any;
+      };
+      directory?: undefined;
+    };
+  })[];
+  id: string;
+  name: string;
+  type: string;
+  is_default: boolean;
+  config: Record<string, any>;
+  constructor(data: DriveConfig);
+  get config_fields(): {};
+}
+//#endregion
 //#region src/shared/entities/DriveEntryEntity.d.ts
 declare class DriveEntry {
   name: string;
@@ -335,6 +615,102 @@ declare class DriveEntry {
   constructor(data: DriveEntry);
 }
 //#endregion
+//#region src/shared/entities/FileEntity.d.ts
+declare const FileEntity_base: {
+  new (...args: any[]): {
+    merge(data: Partial< /*elided*/any>): /*elided*/any;
+  };
+  from<T>(this: new () => T, data: Partial<T>): T;
+} & Constructor & {
+  new (...args: any[]): {
+    created_at: Date | string;
+    updated_at: Date | string;
+  };
+} & {
+  new (...args: any[]): {
+    deleted_at: Date | string | null;
+  };
+};
+declare class FileEntity extends FileEntity_base {
+  id: number;
+  drive: string;
+  mimetype: string;
+  purpose: string;
+  client_name: string;
+  filename: string;
+  public: boolean;
+  url?: string;
+  metas?: Record<string, any>;
+  isImage(): boolean;
+}
+//#endregion
+//#region src/shared/entities/FileMetaEntity.d.ts
+declare const FileMeta_base: {
+  new (...args: any[]): {
+    merge(data: Partial< /*elided*/any>): /*elided*/any;
+  };
+  from<T>(this: new () => T, data: Partial<T>): T;
+} & Constructor & {
+  new (...args: any[]): {
+    created_at: Date | string;
+    updated_at: Date | string;
+  };
+} & {
+  new (...args: any[]): {
+    deleted_at: Date | string | null;
+  };
+};
+declare class FileMeta extends FileMeta_base {
+  id: number;
+  file_id: number;
+  name: string;
+  value: string | null;
+}
+//#endregion
+//#region src/shared/entities/FileUploadSessionEntity.d.ts
+declare const UploadSession_base: {
+  new (...args: any[]): {
+    merge(data: Partial< /*elided*/any>): /*elided*/any;
+  };
+  from<T>(this: new () => T, data: Partial<T>): T;
+} & Constructor & {
+  new (...args: any[]): {
+    created_at: Date | string;
+    updated_at: Date | string;
+  };
+} & {
+  new (...args: any[]): {
+    deleted_at: Date | string | null;
+  };
+};
+declare class UploadSession extends UploadSession_base {
+  id: number;
+  purpose: string;
+  mime_types: string;
+  max_size: number;
+  upload_url?: string;
+  create_file_url?: string;
+  getParsedMimeTypes(): string[];
+  isAllowedMimeType(mimeType: string): boolean;
+  isAllowedSize(size: number): boolean;
+}
+//#endregion
+//#region src/shared/entities/HeaderMapEntity.d.ts
+interface CookieMapEntityOptions {
+  headers?: Record<string, string>;
+  setHeader?: (name: string, value: string) => void;
+}
+declare class HeaderMapEntity {
+  static __container_entry_key: string;
+  entries: Map<string, string>;
+  setHeader?: (name: string, value: string) => void;
+  constructor(data?: CookieMapEntityOptions);
+  loadFromRecord(cookies: Record<string, string>): void;
+  get(name: string, defaultValue?: string | null): string | null;
+  set(name: string, value: string): void;
+  toRecord(): Record<string, string>;
+}
+//#endregion
 //#region src/shared/entities/ModuleManifestEntity.d.ts
 interface ModuleManifestBuildImport {
   from: string;
@@ -384,4 +760,81 @@ declare class Module extends Module_base {
   setData(data: Partial<Module | ModuleManifest>): void;
 }
 //#endregion
-export { AnyClass, BaseException, ConfigService, Constructor, ContainerService, CookieService, DriveEntry as DriveEntryEntity, EmmitterService, EmmitterServiceOptions, LifecycleHook, LifecycleService, LoggerService, Mixin, Module as ModuleEntity, ModuleManifestBuild, ModuleManifestBuildImport, ModuleManifest as ModuleManifestEntity, PartialBy, Permission, PermissionAssignment, PublicData, ShellException, Token, TranslatorService, UnionToIntersection, UploadService, Valibot, ValibotSchema, ValibotSchemaAsync, ValidatePayload, ValidateResult, ValidatorCallback, ValidatorCallbackAsync, ValidatorResult, ValidatorService, compose, composeWith, createId, flatten, formatBytes, mixin, permissionAssignmentSchema, permissionSchema, tokenSchema, tryCatch, unflatten, validator };
+//#region src/shared/entities/PaginationEntity.d.ts
+declare class PaginationEntity<T = Record<string, any>> {
+  items: T[];
+  total: number;
+  page: number;
+  per_page: number;
+  total_pages: number;
+  constructor(data: Partial<PaginationEntity>);
+  static from<T = Record<string, string>>(payload: Partial<PaginationEntity<T>>): PaginationEntity<T>;
+}
+//#endregion
+//#region src/shared/entities/PluginEntity.d.ts
+declare const PluginEntity_base: {
+  new (...args: any[]): {
+    merge(data: Partial< /*elided*/any>): /*elided*/any;
+  };
+  from<T>(this: new () => T, data: Partial<T>): T;
+} & Constructor;
+declare class PluginEntity extends PluginEntity_base {
+  id: string;
+  name: string;
+  version: string;
+  enabled: boolean;
+  aliases: string[];
+}
+//#endregion
+//#region src/shared/entities/RoleEntity.d.ts
+declare const Role_base: {
+  new (...args: any[]): {
+    merge(data: Partial< /*elided*/any>): /*elided*/any;
+  };
+  from<T>(this: new () => T, data: Partial<T>): T;
+} & Constructor & {
+  new (...args: any[]): {
+    created_at: Date | string;
+    updated_at: Date | string;
+  };
+} & {
+  new (...args: any[]): {
+    deleted_at: Date | string | null;
+  };
+};
+declare class Role extends Role_base {
+  id: number;
+  name: string;
+  description?: string;
+}
+//#endregion
+//#region src/shared/entities/UserEntity.d.ts
+declare const UserEntity_base: {
+  new (...args: any[]): {
+    merge(data: Partial< /*elided*/any>): /*elided*/any;
+  };
+  from<T>(this: new () => T, data: Partial<T>): T;
+} & Constructor & {
+  new (...args: any[]): {
+    created_at: Date | string;
+    updated_at: Date | string;
+  };
+} & {
+  new (...args: any[]): {
+    deleted_at: Date | string | null;
+  };
+};
+declare class UserEntity extends UserEntity_base {
+  id: number;
+  email: string;
+  name: string;
+  username: string;
+  password?: string;
+  verified_at?: Date | string | null;
+  permissions?: PermissionEntity[];
+  roles?: Role[];
+  get initials(): string;
+}
+//#endregion
+export { AclEntity, AnyClass, BaseEntity as BaseEntityMixin, BaseException, ConfigService, Constructor, ContainerService, CookieMapEntity, DriveConfig as DriveConfigEntity, DriveEntry as DriveEntryEntity, EmmitterService, EmmitterServiceOptions, FileEntity, FileMeta as FileMetaEntity, UploadSession as FileUploadSessionEntity, HeaderMapEntity, Hooks as HooksMixin, HooksStatic, LifecycleHook, LifecycleService, LifecycleServiceOptions, Listener, LoggerService, Mixin, Module as ModuleEntity, ModuleManifestBuild, ModuleManifestBuildImport, ModuleManifest as ModuleManifestEntity, PaginationEntity, PartialBy, Permission, PermissionAssignment, PermissionEntity, PluginEntity, PublicData, Role as RoleEntity, ShellException, SoftDeleteMixin, TYPES, TimestampMixin, Token, TranslatorService, UnionToIntersection, UploadService, UserEntity, Valibot, ValibotSchema, ValibotSchemaAsync, ValidatePayload, ValidateResult, ValidatorCallback, ValidatorCallbackAsync, ValidatorResult, ValidatorService, compose, composeWith, createBaseEntity, createId, emitHook, flatten, formatBytes, mixin, onHook, parseUrlParams, parseUrlQuery, permissionAssignmentSchema, permissionSchema, tokenSchema, tryCatch, unflatten, validator };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/shared/services/ConfigService.d.ts","../../src/shared/services/ContainerService.d.ts","../../src/shared/services/LoggerService.d.ts","../../src/shared/services/EmmitterService.d.ts","../../src/shared/entities/LifecycleHook.d.ts","../../src/shared/utils/typing.d.ts","../../src/shared/utils/compose.d.ts","../../src/shared/services/LifecycleService.d.ts","../../src/shared/services/TranslatorService.d.ts","../../src/shared/services/UploadService.d.ts","../../src/shared/validators/urlValidator.d.ts","../../src/shared/validators/paginationValidator.d.ts","../../src/shared/services/ValidatorService.d.ts","../../src/shared/utils/createId.d.ts","../../src/shared/utils/flatten.d.ts","../../src/shared/utils/formatBytes.d.ts","../../src/shared/utils/parseRouteUrl.d.ts","../../src/shared/utils/tryCatch.d.ts","../../src/shared/schemas/permissionAssignmentSchema.d.ts","../../src/shared/schemas/permissionSchema.d.ts","../../src/shared/schemas/tokenSchema.d.ts","../../src/shared/exceptions/BaseException.d.ts","../../src/shared/exceptions/ShellException.d.ts","../../src/shared/facades/validator.d.ts","../../src/shared/mixins/BaseEntityMixin.d.ts","../../src/shared/mixins/HooksMixin.d.ts","../../src/shared/mixins/SoftDeleteMixin.d.ts","../../src/shared/mixins/TimestampMixin.d.ts","../../src/shared/entities/PermissionEntity.d.ts","../../src/shared/entities/AclEntity.d.ts","../../src/shared/entities/CookieMapEntity.d.ts","../../src/shared/entities/DriveConfigEntity.d.ts","../../src/shared/entities/DriveEntryEntity.d.ts","../../src/shared/entities/FileEntity.d.ts","../../src/shared/entities/FileMetaEntity.d.ts","../../src/shared/entities/FileUploadSessionEntity.d.ts","../../src/shared/entities/HeaderMapEntity.d.ts","../../src/shared/entities/ModuleManifestEntity.d.ts","../../src/shared/entities/ModuleEntity.d.ts","../../src/shared/entities/PaginationEntity.d.ts","../../src/shared/entities/PluginEntity.d.ts","../../src/shared/entities/RoleEntity.d.ts","../../src/shared/entities/UserEntity.d.ts"],"sourcesContent":["interface Entry {\n    key: string;\n    value: any;\n    source: string;\n}\nexport default class ConfigService {\n    static __container_entry_key: string;\n    entries: Map<string, Entry>;\n    constructor();\n    list(): Entry[];\n    parseValue(value: any): any;\n    loadFromRecord(record: Record<string, any>, source?: string): void;\n    loadFromEntries(entries: [string, any][], source?: string): void;\n    toRecord(): Record<string, any>;\n    has(key: string): boolean;\n    get<T = any | undefined>(key: string, defaultValue?: any): T;\n    getOne<T = any | undefined>(keys: string[], defaultValue?: any): T;\n    set(key: string, value: any, source?: string): void;\n    unset(key: string): void;\n    clear(): void;\n    dump(): Record<string, any>;\n}\nexport {};\n","type Constructor<T = object> = new (...args: any[]) => T;\ntype EntryKey = string | symbol | Constructor;\nexport default class ContainerService {\n    private entries;\n    loadFromRecord(record: Record<string, any>): void;\n    toRecord(): Record<string, any>;\n    private getKey;\n    set(payload: EntryKey, value: any): this;\n    has(payload: EntryKey): boolean;\n    get<T>(payload: EntryKey): T;\n    singleton<T>(classConstructor: Constructor<T>): T;\n    load(entries: Record<any, any>): void;\n    proxy<T = unknown>(key: EntryKey): T;\n    keys(): EntryKey[];\n}\nexport {};\n","export default class LoggerService {\n    static __container_entry_key: string;\n    info(message: string, meta?: any): void;\n    debug(message: string, meta?: any): void;\n    warn(message: string, meta?: any): void;\n    error(message: string, meta?: any): void;\n    child(options: any): LoggerService;\n}\n","import LoggerService from './LoggerService.ts';\ninterface EmmitterHandler {\n    id: string;\n    event: string;\n    listener: (...args: any[]) => any;\n    originalListener?: (...args: any[]) => any;\n}\ninterface OnOptions {\n    id?: string;\n    unique?: boolean;\n}\ninterface OnDebounceOptions extends OnOptions {\n    debounce?: number;\n}\nexport interface EmmitterServiceOptions {\n    debug?: boolean;\n    logger?: LoggerService;\n}\nexport default class EmmitterService<Events extends Record<string, any> = Record<string, any>> {\n    static __container_entry_key: string;\n    private handlers;\n    private debug;\n    private logger;\n    constructor(options?: EmmitterServiceOptions);\n    static create<Events extends Record<string, any> = Record<string, any>>(options?: EmmitterServiceOptions): EmmitterService<Events>;\n    setDebug(debug: boolean): void;\n    setLogger(logger: LoggerService): void;\n    on<K extends keyof Events>(event: K, listener: (args: Events[K]) => void, options?: OnOptions): EmmitterHandler;\n    on(event: string, listener: (args: any) => void, options?: OnOptions): EmmitterHandler;\n    once<K extends keyof Events>(event: K, listener: (args: Events[K]) => void, options?: OnOptions): EmmitterHandler;\n    once(event: string, listener: (args: any) => void, options?: OnOptions): EmmitterHandler;\n    onDebounce<K extends keyof Events>(event: K, listener: (args: Events[K]) => void, options?: OnDebounceOptions): EmmitterHandler;\n    onDebounce(event: string, listener: (args: any) => void, options?: OnDebounceOptions): EmmitterHandler;\n    onAnyOf<K extends keyof Events>(events: K[], listener: (args: Events[K]) => void, options?: OnOptions): EmmitterHandler[];\n    onAnyOf(events: string[], listener: (args: any) => void, options?: OnOptions): EmmitterHandler[];\n    off(event: string, listener: Function): void;\n    emit<K extends keyof Events>(event: K, args: Events[K]): void;\n    emit(event: string, args?: any): void;\n    emitAndWait<K extends keyof Events>(event: K, args: Events[K]): Promise<void>;\n    emitAndWait(event: string, args?: any): Promise<void>;\n    list(): EmmitterHandler[];\n    listByEvent(event: string): EmmitterHandler[];\n    remove(payload: string | string[]): void;\n    clear(): void;\n    hasHandlers(): boolean;\n}\nexport {};\n","export default class LifecycleHook {\n    hook_id: string;\n    hook_aliases?: string[];\n    order?: number;\n    subhooks?: LifecycleHook[];\n    register(): Promise<void>;\n    load(): Promise<void>;\n    boot(): Promise<void>;\n    shutdown(): Promise<void>;\n    /** @deprecated Use register */\n    onRegister(): Promise<void>;\n    /** @deprecated Use load */\n    onLoad(): Promise<void>;\n    /** @deprecated Use boot */\n    onBoot(): Promise<void>;\n    /** @deprecated Use shutdown */\n    onShutdown(): Promise<void>;\n}\n","export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;\nexport type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;\nexport type PublicData<T> = {\n    [K in keyof T as T[K] extends Function ? never : K]: T[K];\n};\n","import type { UnionToIntersection } from './typing.ts';\nexport type AnyClass = new (...args: any[]) => any;\nexport type Constructor<T = {}> = new (...args: any[]) => T;\nexport type Mixin<T> = (base: Constructor) => Constructor<T>;\n/**\n * Composes multiple mixins into a single class that can be extended.\n * Allows for multiple inheritance-like behavior by applying mixins sequentially.\n *\n * @param mixins - Array of mixin functions to compose\n * @returns A class constructor that includes all mixin functionality\n *\n * @example\n * ```typescript\n * class User extends compose(Timestamp, SoftDelete) {\n *   constructor(public name: string) {\n *     super()\n *   }\n * }\n * ```\n */\nexport declare function compose<M extends Array<(base: Constructor<any>) => Constructor<any>>>(...mixins: M): UnionToIntersection<ReturnType<M[number]>>;\n/**\n * Alternative compose function that starts with a base class\n *\n * @param baseClass - The base class to start with\n * @param mixins - Array of mixin functions to apply\n * @returns A class constructor that extends the base class with all mixin functionality\n *\n * @example\n * ```typescript\n * class User extends composeWith(BaseEntity, Timestamp, SoftDelete) {\n *   constructor(public name: string) {\n *     super()\n *   }\n * }\n * ```\n */\nexport declare function composeWith<TBase extends Constructor, M extends Array<(base: Constructor) => Constructor<any>>>(baseClass: TBase, ...mixins: M): TBase & UnionToIntersection<ReturnType<M[number]>>;\nexport declare function mixin<TBase extends Constructor>(Source: TBase): <TTarget extends Constructor>(Target: TTarget) => TTarget & TBase;\n","import LoggerService from './LoggerService.ts';\nimport type LifecycleHook from '#shared/entities/LifecycleHook.ts';\nimport type { Constructor } from '#shared/utils/compose.ts';\ntype LifecycleMethod = 'register' | 'load' | 'boot' | 'shutdown';\ninterface ListOptions {\n    include?: string | string[];\n    exclude?: string | string[];\n}\nexport interface LifecycleServiceOptions {\n    debug?: boolean;\n    hooks?: Map<string, LifecycleHook>;\n    logger?: LoggerService;\n    onError?: (error: Error, context: {\n        hookId: string;\n        method: LifecycleMethod;\n    }) => void;\n}\nexport default class LifecycleService {\n    static __container_entry_key: string;\n    hooks: Map<string, LifecycleHook>;\n    logger: LoggerService;\n    debug: boolean;\n    constructor(data?: LifecycleServiceOptions);\n    onError(error: Error, context: {\n        hookId: string;\n        method: LifecycleMethod;\n    }): void;\n    mapAliases(args: string[]): string[];\n    list(options?: ListOptions): LifecycleHook[];\n    add(...payload: (LifecycleHook | Constructor<LifecycleHook>)[]): void;\n    emitMethod(method: LifecycleMethod, options?: ListOptions): Promise<void>;\n    emit(payload: LifecycleMethod | LifecycleMethod[], options?: ListOptions): Promise<void>;\n    register(options?: ListOptions): Promise<void>;\n    load(options?: ListOptions): Promise<void>;\n    boot(options?: ListOptions): Promise<void>;\n    shutdown(options?: ListOptions): Promise<void>;\n    clear(): void;\n}\nexport {};\n","import LoggerService from './LoggerService.ts';\nexport default class TranslatorService {\n    static __container_entry_key: string;\n    entries: Map<string, string>;\n    locale: string;\n    localeLoaders: Map<string, () => Promise<Record<string, string>>>;\n    debug: boolean;\n    logger: LoggerService;\n    cache: Map<string, Record<string, string>>;\n    constructor(data?: Partial<TranslatorService>);\n    get locales(): string[];\n    list(): {\n        key: string;\n        value: string;\n    }[];\n    getEntries(locale: string): Promise<Record<string, string>>;\n    load(locale: string): Promise<void>;\n    t(key: string, args?: any): string;\n    date(data: string | number | Date): string;\n    datetime(data: string | number | Date): string;\n}\n","export default class UploadService {\n    static __container_entry_key: string;\n    single(name: string): void;\n    multiple(name: string): void;\n}\n","import * as v from 'valibot';\nexport declare const number: () => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, v.TransformAction<any, number>, v.IntegerAction<number, undefined>]>;\nexport declare const boolean: () => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.BooleanSchema<undefined>], undefined>, v.TransformAction<string | boolean, boolean>]>;\nexport declare const date: () => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.DateSchema<undefined>], undefined>, v.TransformAction<string | Date, Date>, v.TransformAction<Date, string | Date>]>;\nexport declare const datetime: () => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.DateSchema<undefined>], undefined>, v.TransformAction<string | Date, string | Date>]>;\nexport declare const array: <T extends v.BaseSchema<any, any, any>>(schema?: T) => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, v.TransformAction<string | string[], string[]>, v.ArraySchema<T, undefined>]>;\nexport declare const arrayNumber: () => v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, v.TransformAction<string | string[], string[]>, v.ArraySchema<v.BaseSchema<any, any, any>, undefined>]>, v.TransformAction<any[], number[]>]>;\nexport declare const object: () => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.AnySchema, undefined>], undefined>, v.TransformAction<string | {\n    [x: string]: any;\n}, {\n    [x: string]: any;\n}>, v.TransformAction<{\n    [x: string]: any;\n}, Record<string, any>>]>;\n","import * as v from 'valibot';\nexport interface PaginationParams {\n    maxLimit?: number;\n    orderFields?: string[];\n}\nexport declare const base: (options?: PaginationParams) => v.ObjectSchema<{\n    readonly page: v.OptionalSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, v.TransformAction<any, number>, v.IntegerAction<number, undefined>]>, 1>;\n    readonly limit: v.OptionalSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, v.TransformAction<any, number>, v.IntegerAction<number, undefined>]>, number>;\n    readonly orderBy: v.OptionalSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, v.TransformAction<string | string[], string[]>, v.ArraySchema<v.PicklistSchema<string[], undefined>, undefined>]> | v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, v.TransformAction<string | string[], string[]>, v.ArraySchema<v.StringSchema<undefined>, undefined>]>, readonly []>;\n    readonly orderDirection: v.OptionalSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, v.TransformAction<string | string[], string[]>, v.ArraySchema<v.UnionSchema<[v.LiteralSchema<\"asc\", undefined>, v.LiteralSchema<\"desc\", undefined>], undefined>, undefined>]>, readonly []>;\n}, undefined>;\n","import * as v from 'valibot';\nimport * as url from '#shared/validators/urlValidator.ts';\nimport * as pagination from '#shared/validators/paginationValidator.ts';\ndeclare const extras: {\n    url: typeof url;\n    pagination: typeof pagination;\n};\nexport type Valibot = typeof v & {\n    extras: typeof extras;\n};\nexport type ValibotSchema = v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>;\nexport type ValibotSchemaAsync = v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>;\nexport interface ValidatorCallback<T extends ValibotSchema> {\n    (_v: Valibot): T;\n}\nexport type ValidatorCallbackAsync<T extends ValibotSchemaAsync> = {\n    (_v: Valibot): T;\n};\nexport type ValidatorResult<T extends v.ObjectEntries> = v.InferOutput<v.ObjectSchema<T, undefined>>;\nexport type ValidatePayload<T extends ValibotSchema = ValibotSchema> = ValidatorCallback<T> | T;\nexport type ValidateResult<T extends ValidatePayload> = T extends ValibotSchema ? v.InferOutput<T> : T extends ValidatorCallback<infer U> ? v.InferOutput<U> : unknown;\nexport default class ValidatorService {\n    static __container_entry_key: string;\n    v: Valibot;\n    create<T extends ValibotSchema>(cb: ValidatorCallback<T>): T;\n    validate<T extends ValibotSchema>(payload: any, cb: ValidatePayload<T>): v.InferOutput<T>;\n    validateAsync<T extends ValibotSchemaAsync>(payload: any, cb: ValidatorCallbackAsync<T> | T): Promise<v.InferOutput<T>>;\n    isValid<T extends ValibotSchema>(payload: any, cb: ValidatePayload<T>): boolean;\n}\nexport {};\n","export declare function createId(prefix?: string): string;\n","export declare function flatten(obj: any, prefix?: string, res?: any): Record<string, any>;\nexport declare function unflatten(obj: any): Record<string, any>;\n","export declare function formatBytes(bytes: number, decimals?: number): string;\n","export declare function parseUrlParams(routePath: string, requestPath: string): Record<string, string>;\nexport declare function parseUrlQuery(requestPath: string): Record<string, any>;\n","interface Tryer {\n    (...args: any[]): any;\n}\ninterface TryerAsync {\n    (...args: any[]): Promise<any> | any;\n}\ntype TryCatchResult<T extends Tryer> = [null, ReturnType<T>] | [Error, null];\ntype TryCatchAsyncResult<T extends TryerAsync> = [null, Awaited<ReturnType<T>>] | [Error, null];\nexport declare function tryCatch<T extends TryerAsync>(tryer: T): Promise<TryCatchAsyncResult<T>>;\nexport declare namespace tryCatch {\n    var sync: <T extends Tryer>(tryer: T) => TryCatchResult<T>;\n}\nexport {};\n","import * as v from 'valibot';\nexport type PermissionAssignment = v.InferOutput<typeof permissionAssignmentSchema>;\nexport declare const permissionAssignmentSchema: v.ObjectSchema<{\n    readonly id: v.NumberSchema<undefined>;\n    readonly permission_id: v.NumberSchema<undefined>;\n    readonly assignable_type: v.StringSchema<undefined>;\n    readonly assignable_id: v.StringSchema<undefined>;\n    readonly created_at: v.StringSchema<undefined>;\n    readonly updated_at: v.StringSchema<undefined>;\n}, undefined>;\n","import * as v from 'valibot';\nexport type Permission = v.InferOutput<typeof permissionSchema>;\nexport declare const permissionSchema: v.ObjectSchema<{\n    readonly id: v.NumberSchema<undefined>;\n    readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;\n    readonly description: v.NullableSchema<v.StringSchema<undefined>, undefined>;\n    readonly action: v.StringSchema<undefined>;\n    readonly subject: v.StringSchema<undefined>;\n    readonly conditions: v.NullableSchema<v.StringSchema<undefined>, undefined>;\n    readonly created_at: v.StringSchema<undefined>;\n    readonly updated_at: v.StringSchema<undefined>;\n    readonly expires_at: v.StringSchema<undefined>;\n}, undefined>;\n","import * as v from 'valibot';\nexport type Token = v.InferOutput<typeof tokenSchema>;\nexport declare const tokenSchema: v.ObjectSchema<{\n    readonly id: v.NumberSchema<undefined>;\n    readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;\n    readonly type: v.StringSchema<undefined>;\n    readonly user_id: v.NumberSchema<undefined>;\n    readonly token: v.StringSchema<undefined>;\n    readonly created_at: v.StringSchema<undefined>;\n    readonly updated_at: v.StringSchema<undefined>;\n    readonly expires_at: v.StringSchema<undefined>;\n}, undefined>;\n","export default class BaseException extends Error {\n    statusCode: number;\n    constructor(message: string, statusCode?: number);\n    static fromError(error: Error): BaseException;\n}\n","import BaseException from './BaseException.ts';\nexport default class ShellException extends BaseException {\n    output: string;\n    bin: string;\n    args: string[];\n    constructor(message: string, output: string, bin: string, args: string[]);\n}\n","import ValidatorService from \"../services/ValidatorService\";\nexport declare const validator: ValidatorService;\nexport default validator;\n","import type { Constructor } from '#shared/utils/compose.ts';\ninterface CreateBaseEntityOptions {\n    parse?: (data: any) => any;\n}\nexport declare function createBaseEntity(options?: CreateBaseEntityOptions): <TBase extends Constructor>(Base: TBase) => {\n    new (...args: any[]): {\n        merge(data: Partial</*elided*/ any>): /*elided*/ any;\n    };\n    from<T>(this: new () => T, data: Partial<T>): T;\n} & TBase;\nexport default function BaseEntity<TBase extends Constructor>(Base: TBase): {\n    new (...args: any[]): {\n        merge(data: Partial</*elided*/ any>): /*elided*/ any;\n    };\n    from<T>(this: new () => T, data: Partial<T>): T;\n} & TBase;\nexport {};\n","import type { Constructor } from '#shared/utils/compose.ts';\nexport interface Listener {\n    event: string;\n    listener: (...args: any[]) => void;\n}\nexport declare function emitHook(constructor: any, event: string, ...args: any[]): Promise<void>;\nexport declare function onHook(constructor: any, event: string, listener: (...args: any[]) => void): void;\nexport declare function HooksStatic<TBase extends Constructor>(Base: TBase): {\n    new (...args: any[]): {};\n    listeners: Array<(...args: any[]) => void>;\n    on(event: string, listener: (...args: any[]) => void): void;\n    emit(event: string, ...args: any[]): Promise<void>;\n} & TBase;\nexport declare namespace HooksStatic {\n    var emit: typeof emitHook;\n    var on: typeof onHook;\n}\nexport default function Hooks<TBase extends Constructor>(Base: TBase): {\n    new (...args: any[]): {\n        listeners: Listener[];\n        on(event: string, listener: (...args: any[]) => void): void;\n        off(event: string, listener: (...args: any[]) => void): void;\n        emit(event: string, ...args: any[]): void;\n        emitAsync(event: string, ...args: any[]): Promise<void>;\n    };\n} & TBase;\n","import type { Constructor } from '#shared/utils/compose.ts';\nexport default function SoftDeleteMixin<T extends Constructor>(base: T): {\n    new (...args: any[]): {\n        deleted_at: Date | string | null;\n    };\n} & T;\n","import type { Constructor } from '#shared/utils/compose.ts';\nexport default function TimestampMixin<T extends Constructor>(base: T): {\n    new (...args: any[]): {\n        created_at: Date | string;\n        updated_at: Date | string;\n    };\n} & T;\n","declare const PermissionEntity_base: {\n    new (...args: any[]): {\n        merge(data: Partial</*elided*/ any>): /*elided*/ any;\n    };\n    from<T>(this: new () => T, data: Partial<T>): T;\n} & import(\"#shared/utils/compose.ts\").Constructor;\nexport default class PermissionEntity extends PermissionEntity_base {\n    id: number;\n    name: string;\n    description: string | null;\n    origin: string;\n    subject: string;\n    action: string;\n    conditions: string | null | Record<string, any>;\n    get editable(): boolean;\n    get parsedConditions(): any;\n}\nexport {};\n","import { defineAbility } from '@casl/ability';\nimport Permission from './PermissionEntity.ts';\nimport LoggerService from '#shared/services/LoggerService.ts';\nexport default class AclEntity {\n    static __container_entry_key: string;\n    ability: ReturnType<typeof defineAbility>;\n    permissions: Permission[];\n    debug: boolean;\n    logger: LoggerService;\n    constructor(data?: Partial<AclEntity>);\n    can(action: string, subject: any, object?: Record<string, any>): boolean;\n    cannot(action: string, subject: any, object?: Record<string, any>): boolean;\n    subject(subject: string, object: Record<string, any>): Record<string, any> & import(\"@casl/ability\").ForcedSubject<string>;\n}\n","export interface CookieMapEntityOptions {\n    cookies?: Map<string, string>;\n    prefix?: string;\n}\nexport default class CookieMapEntity {\n    static __container_entry_key: string;\n    cookies: Map<string, string>;\n    prefix: string;\n    constructor(data?: CookieMapEntityOptions);\n    load(cookies: Record<string, string> | Map<string, string>): void;\n    get(name: string, defaultValue?: string | null): string | null;\n    set(name: string, value: string, options?: any): void;\n    toRecord(): Record<string, string>;\n}\n","export declare const TYPES: () => ({\n    id: string;\n    label: any;\n    description: any;\n    config_fields: {\n        directory: {\n            component: string;\n            label: any;\n            description: any;\n            hint: any;\n        };\n        accessKeyId?: undefined;\n        secretAccessKey?: undefined;\n        bucket?: undefined;\n        region?: undefined;\n        prefix?: undefined;\n        endpoint?: undefined;\n    };\n} | {\n    id: string;\n    label: string;\n    description: any;\n    config_fields: {\n        accessKeyId: {\n            component: string;\n            label: any;\n            hint: any;\n            type: string;\n        };\n        secretAccessKey: {\n            component: string;\n            label: any;\n            hint: any;\n            type: string;\n        };\n        bucket: {\n            component: string;\n            label: any;\n            hint: any;\n        };\n        region: {\n            component: string;\n            label: any;\n            hint: any;\n        };\n        prefix: {\n            component: string;\n            label: any;\n            hint: any;\n        };\n        endpoint: {\n            component: string;\n            label: any;\n            hint: any;\n        };\n        directory?: undefined;\n    };\n})[];\nexport default class DriveConfig {\n    static get TYPES(): ({\n        id: string;\n        label: any;\n        description: any;\n        config_fields: {\n            directory: {\n                component: string;\n                label: any;\n                description: any;\n                hint: any;\n            };\n            accessKeyId?: undefined;\n            secretAccessKey?: undefined;\n            bucket?: undefined;\n            region?: undefined;\n            prefix?: undefined;\n            endpoint?: undefined;\n        };\n    } | {\n        id: string;\n        label: string;\n        description: any;\n        config_fields: {\n            accessKeyId: {\n                component: string;\n                label: any;\n                hint: any;\n                type: string;\n            };\n            secretAccessKey: {\n                component: string;\n                label: any;\n                hint: any;\n                type: string;\n            };\n            bucket: {\n                component: string;\n                label: any;\n                hint: any;\n            };\n            region: {\n                component: string;\n                label: any;\n                hint: any;\n            };\n            prefix: {\n                component: string;\n                label: any;\n                hint: any;\n            };\n            endpoint: {\n                component: string;\n                label: any;\n                hint: any;\n            };\n            directory?: undefined;\n        };\n    })[];\n    id: string;\n    name: string;\n    type: string;\n    is_default: boolean;\n    config: Record<string, any>;\n    constructor(data: DriveConfig);\n    get config_fields(): {};\n}\n","export default class DriveEntry {\n    name: string;\n    path: string;\n    type: 'file' | 'directory';\n    metas: Record<string, any>;\n    constructor(data: DriveEntry);\n}\n","declare const FileEntity_base: {\n    new (...args: any[]): {\n        merge(data: Partial</*elided*/ any>): /*elided*/ any;\n    };\n    from<T>(this: new () => T, data: Partial<T>): T;\n} & import(\"#shared/utils/compose.ts\").Constructor & {\n    new (...args: any[]): {\n        created_at: Date | string;\n        updated_at: Date | string;\n    };\n} & {\n    new (...args: any[]): {\n        deleted_at: Date | string | null;\n    };\n};\nexport default class FileEntity extends FileEntity_base {\n    id: number;\n    drive: string;\n    mimetype: string;\n    purpose: string;\n    client_name: string;\n    filename: string;\n    public: boolean;\n    url?: string;\n    metas?: Record<string, any>;\n    isImage(): boolean;\n}\nexport {};\n","declare const FileMeta_base: {\n    new (...args: any[]): {\n        merge(data: Partial</*elided*/ any>): /*elided*/ any;\n    };\n    from<T>(this: new () => T, data: Partial<T>): T;\n} & import(\"#shared/utils/compose.ts\").Constructor & {\n    new (...args: any[]): {\n        created_at: Date | string;\n        updated_at: Date | string;\n    };\n} & {\n    new (...args: any[]): {\n        deleted_at: Date | string | null;\n    };\n};\nexport default class FileMeta extends FileMeta_base {\n    id: number;\n    file_id: number;\n    name: string;\n    value: string | null;\n}\nexport {};\n","declare const UploadSession_base: {\n    new (...args: any[]): {\n        merge(data: Partial</*elided*/ any>): /*elided*/ any;\n    };\n    from<T>(this: new () => T, data: Partial<T>): T;\n} & import(\"#shared/utils/compose.ts\").Constructor & {\n    new (...args: any[]): {\n        created_at: Date | string;\n        updated_at: Date | string;\n    };\n} & {\n    new (...args: any[]): {\n        deleted_at: Date | string | null;\n    };\n};\nexport default class UploadSession extends UploadSession_base {\n    id: number;\n    purpose: string;\n    mime_types: string;\n    max_size: number;\n    upload_url?: string;\n    create_file_url?: string;\n    getParsedMimeTypes(): string[];\n    isAllowedMimeType(mimeType: string): boolean;\n    isAllowedSize(size: number): boolean;\n}\nexport {};\n","export interface CookieMapEntityOptions {\n    headers?: Record<string, string>;\n    setHeader?: (name: string, value: string) => void;\n}\nexport default class HeaderMapEntity {\n    static __container_entry_key: string;\n    entries: Map<string, string>;\n    setHeader?: (name: string, value: string) => void;\n    constructor(data?: CookieMapEntityOptions);\n    loadFromRecord(cookies: Record<string, string>): void;\n    get(name: string, defaultValue?: string | null): string | null;\n    set(name: string, value: string): void;\n    toRecord(): Record<string, string>;\n}\n","export interface ModuleManifestBuildImport {\n    from: string;\n    to?: string;\n    type: 'global_import';\n}\nexport interface ModuleManifestBuild {\n    imports?: ModuleManifestBuildImport[];\n}\ndeclare const ModuleManifest_base: {\n    new (...args: any[]): {\n        merge(data: Partial</*elided*/ any>): /*elided*/ any;\n    };\n    from<T>(this: new () => T, data: Partial<T>): T;\n} & import(\"#shared/utils/compose.ts\").Constructor;\nexport default class ModuleManifest extends ModuleManifest_base {\n    id: string;\n    name: string;\n    version: string;\n    description?: string;\n    enabled: boolean;\n    author?: string;\n    dependencies?: Record<string, string>;\n    build?: ModuleManifestBuild;\n    [key: string]: any;\n}\nexport {};\n","import type ModuleManifest from './ModuleManifestEntity.ts';\nimport LifecycleHook from '#shared/entities/LifecycleHook.ts';\ninterface ModuleUpgradeInfo {\n    source: 'git' | 'zip';\n    [key: string]: any;\n}\ndeclare const Module_base: {\n    new (...args: any[]): {\n        merge(data: Partial</*elided*/ any>): /*elided*/ any;\n    };\n    from<T>(this: new () => T, data: Partial<T>): T;\n} & import(\"#shared/utils/compose.ts\").Constructor & import(\"#shared/utils/compose.ts\").Constructor<{}> & typeof LifecycleHook;\nexport default class Module extends Module_base {\n    id: string;\n    name: string;\n    enabled: boolean;\n    dependencies: Record<string, any>;\n    build: ModuleManifest['build'];\n    directory: string;\n    upgrade_info?: ModuleUpgradeInfo;\n    setData(data: Partial<Module | ModuleManifest>): void;\n}\nexport {};\n","export default class PaginationEntity<T = Record<string, any>> {\n    items: T[];\n    total: number;\n    page: number;\n    per_page: number;\n    total_pages: number;\n    constructor(data: Partial<PaginationEntity>);\n    static from<T = Record<string, string>>(payload: Partial<PaginationEntity<T>>): PaginationEntity<T>;\n}\n","declare const PluginEntity_base: {\n    new (...args: any[]): {\n        merge(data: Partial</*elided*/ any>): /*elided*/ any;\n    };\n    from<T>(this: new () => T, data: Partial<T>): T;\n} & import(\"#shared/utils/compose.ts\").Constructor;\nexport default class PluginEntity extends PluginEntity_base {\n    id: string;\n    name: string;\n    version: string;\n    enabled: boolean;\n    aliases: string[];\n}\nexport {};\n","declare const Role_base: {\n    new (...args: any[]): {\n        merge(data: Partial</*elided*/ any>): /*elided*/ any;\n    };\n    from<T>(this: new () => T, data: Partial<T>): T;\n} & import(\"#shared/utils/compose.ts\").Constructor & {\n    new (...args: any[]): {\n        created_at: Date | string;\n        updated_at: Date | string;\n    };\n} & {\n    new (...args: any[]): {\n        deleted_at: Date | string | null;\n    };\n};\nexport default class Role extends Role_base {\n    id: number;\n    name: string;\n    description?: string;\n}\nexport {};\n","import type Permission from './PermissionEntity.ts';\nimport type Role from './RoleEntity.ts';\ndeclare const UserEntity_base: {\n    new (...args: any[]): {\n        merge(data: Partial</*elided*/ any>): /*elided*/ any;\n    };\n    from<T>(this: new () => T, data: Partial<T>): T;\n} & import(\"#shared/utils/compose.ts\").Constructor & {\n    new (...args: any[]): {\n        created_at: Date | string;\n        updated_at: Date | string;\n    };\n} & {\n    new (...args: any[]): {\n        deleted_at: Date | string | null;\n    };\n};\nexport default class UserEntity extends UserEntity_base {\n    id: number;\n    email: string;\n    name: string;\n    username: string;\n    password?: string;\n    verified_at?: Date | string | null;\n    permissions?: Permission[];\n    roles?: Role[];\n    get initials(): string;\n}\nexport {};\n"],"mappings":"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"}