@sidekick-coder/zenith-kit 0.0.12 → 0.0.13

package/dist/client/index.d.mts

@@ -0,0 +1,448 @@
+import * as _$_casl_ability0 from "@casl/ability";
+import { defineAbility } from "@casl/ability";
+import { NavigationGuard, RouteLocationNormalizedGeneric, RouteRecordRaw, Router as Router$1 } from "vue-router";
+import { DefineComponent } from "vue";
+
+//#region src/shared/utils/compose.d.ts
+type Constructor$1<T = {}> = new (...args: any[]) => 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$1;
+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/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$1 & {
+  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$1 & {
+  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
+//#region src/client/services/AuthService.d.ts
+interface LogoutOptions {
+  redirect?: string;
+}
+declare class AuthService {
+  static __container_entry_key: string;
+  user: UserEntity | null;
+  constructor(data?: Partial<AuthService>);
+  logout(options?: LogoutOptions): Promise<void>;
+}
+//#endregion
+//#region src/client/services/FetchService.d.ts
+interface FetchOptions extends RequestInit {
+  query?: Record<string, any>;
+  data?: Record<string, any>;
+}
+declare class FetchService {
+  static __container_entry_key: string;
+  protected handleError(response: Response): Promise<void>;
+  protected buildUrl(url: string, query?: Record<string, any>): string;
+  protected buildRequestInit(options: FetchOptions): RequestInit;
+  protected parseResponse<T>(response: Response): Promise<T>;
+  fetch<T>(_url: string, _options?: FetchOptions): Promise<T>;
+  try<T = any>(url: string, options?: FetchOptions): Promise<[Error, null] | [null, Awaited<T>]>;
+  get<T = any>(url: string, options?: FetchOptions): Promise<T>;
+  post<T = any>(url: string, options?: FetchOptions): Promise<T>;
+  put<T = any>(url: string, options?: FetchOptions): Promise<T>;
+  delete<T = any>(url: string, options?: FetchOptions): Promise<T>;
+}
+//#endregion
+//#region src/client/services/FetchBrowserService.d.ts
+declare class FetchBrowserService extends FetchService {
+  fetch<T>(url: string, options?: FetchOptions): Promise<T>;
+}
+//#endregion
+//#region src/client/services/FetchNodeService.d.ts
+declare class FetchNodeService extends FetchService {
+  fetch<T>(url: string, options?: FetchOptions): Promise<T>;
+  protected fetchExternal<T>(url: string, options?: FetchOptions): Promise<T>;
+  protected fetchInternal<T>(url: string, options?: FetchOptions): Promise<T>;
+}
+//#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;
+  error(message: string, meta?: any): void;
+  child(options: any): LoggerService;
+}
+//#endregion
+//#region src/shared/entities/LifecycleHook.d.ts
+declare class LifecycleHook {
+  hook_id: string;
+  hook_aliases?: string[];
+  order?: number;
+  subhooks?: LifecycleHook[];
+  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
+//#region src/shared/services/LifecycleService.d.ts
+type LifecycleMethod = 'register' | 'load' | 'boot' | 'shutdown';
+interface ListOptions {
+  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$1 {
+  static __container_entry_key: string;
+  hooks: Map<string, LifecycleHook>;
+  logger: LoggerService;
+  debug: boolean;
+  constructor(data?: LifecycleServiceOptions);
+  onError(error: Error, context: {
+    hookId: string;
+    method: LifecycleMethod;
+  }): void;
+  mapAliases(args: string[]): string[];
+  list(options?: ListOptions): LifecycleHook[];
+  add(...payload: (LifecycleHook | Constructor$1<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>;
+  shutdown(options?: ListOptions): Promise<void>;
+  clear(): void;
+}
+//#endregion
+//#region src/client/services/LifecycleService.d.ts
+declare class LifecycleService extends LifecycleService$1 {
+  addImports(imports: Record<string, any>): void;
+}
+//#endregion
+//#region src/client/entities/MenuItemEntity.d.ts
+declare const MenuItem_base: {
+  new (...args: any[]): {
+    merge(data: Partial< /*elided*/any>): /*elided*/any;
+  };
+  from<T>(this: new () => T, data: Partial<T>): T;
+} & Constructor$1;
+declare class MenuItem extends MenuItem_base {
+  id: string;
+  label: string;
+  layout: string;
+  to?: string;
+  target?: '_blank' | '_self' | '_parent' | '_top';
+  group?: string;
+  order?: number;
+  icon?: string;
+  parent?: string;
+}
+//#endregion
+//#region src/client/services/MenuService.d.ts
+interface ListFilter {
+  layout?: string;
+  group?: string;
+  parent?: string;
+  allowed?: boolean;
+}
+declare class MenuService {
+  static __container_entry_key: string;
+  items: Map<string, MenuItem>;
+  add(...item: Omit<Partial<MenuItem>, 'merge' | 'from'>[]): void;
+  remove(id: MenuItem['id']): void;
+  list(filter?: ListFilter): MenuItem[];
+  clear(): void;
+}
+//#endregion
+//#region src/client/services/RouterService.d.ts
+interface Router extends Router$1 {
+  auto: typeof auto;
+}
+interface AutoOptions {
+  guards?: NavigationGuard[] | ((record: RouteRecordRaw) => NavigationGuard[]);
+  strip?: (string | RegExp)[];
+  exclude?: (string | RegExp)[];
+  prefix?: string;
+  refine?: (records: RouteRecordRaw[]) => RouteRecordRaw[];
+}
+declare function auto(imports: Record<string, DefineComponent | (() => Promise<DefineComponent>)>, options?: AutoOptions): RouteRecordRaw[];
+declare function createRouter(): Router;
+//#endregion
+//#region src/client/services/ToastService.d.ts
+declare class ToastService {
+  static __container_entry_key: string;
+  success(message: string, options?: Record<string, any>): void;
+  error(message: string, options?: Record<string, any>): void;
+}
+//#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/client/facades/acl.d.ts
+declare const acl: AclEntity;
+//#endregion
+//#region src/client/facades/auth.d.ts
+declare const auth: AuthService;
+//#endregion
+//#region src/shared/services/ConfigService.d.ts
+interface Entry {
+  key: string;
+  value: any;
+  source: string;
+}
+declare class ConfigService {
+  static __container_entry_key: string;
+  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/client/facades/config.d.ts
+declare const config: ConfigService;
+//#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>;
+  private getKey;
+  set(payload: EntryKey, value: any): this;
+  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/client/facades/container.d.ts
+declare const _default: ContainerService;
+//#endregion
+//#region src/client/facades/fetch.d.ts
+declare const $fetch$1: FetchService;
+//#endregion
+//#region src/client/facades/logger.d.ts
+declare const logger: LoggerService;
+//#endregion
+//#region src/client/facades/menu.d.ts
+declare const menu: MenuService;
+//#endregion
+//#region src/client/facades/route.d.ts
+declare const route: RouteLocationNormalizedGeneric;
+//#endregion
+//#region src/client/facades/router.d.ts
+declare const router: Router;
+//#endregion
+//#region src/client/facades/toast.d.ts
+declare const toast: ToastService;
+//#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/client/entities/ModuleEntity.d.ts
+declare const Module_base: typeof Module$1;
+declare class Module extends Module_base {}
+//#endregion
+//#region src/shared/entities/PluginEntity.d.ts
+declare const PluginEntity_base$1: {
+  new (...args: any[]): {
+    merge(data: Partial< /*elided*/any>): /*elided*/any;
+  };
+  from<T>(this: new () => T, data: Partial<T>): T;
+} & Constructor$1;
+declare class PluginEntity$1 extends PluginEntity_base$1 {
+  id: string;
+  name: string;
+  version: string;
+  enabled: boolean;
+}
+//#endregion
+//#region src/client/entities/PluginEntity.d.ts
+declare const PluginEntity_base: typeof PluginEntity$1;
+declare class PluginEntity extends PluginEntity_base {
+  addPagesFolder(imports: any, options?: AutoOptions): void;
+  load(): Promise<void>;
+}
+//#endregion
+//#region src/client/utils/fetcher.d.ts
+/** @deprecated Use $fetch facade */
+declare const $fetch: FetchService;
+//#endregion
+//#region src/client/utils/file.d.ts
+interface PickOptions {
+  accept?: string;
+  multiple?: boolean;
+}
+type PickResult<T extends PickOptions> = T['multiple'] extends true ? File[] : File | null;
+declare function pick<T extends PickOptions>(options: T): Promise<PickResult<T>>;
+declare function toUint8Array(file: File): Promise<Uint8Array>;
+interface UploadOptions {
+  driveId: string;
+  file: File;
+  directory?: string;
+}
+declare function upload(options: UploadOptions): Promise<any>;
+declare const $file: {
+  pick: typeof pick;
+  upload: typeof upload;
+  toUint8Array: typeof toUint8Array;
+};
+//#endregion
+//#region src/client/guards/authGuard.d.ts
+interface AuthGuardOptions {
+  redirect: string;
+  exclude?: string[];
+}
+declare function createAuthGuard(options: AuthGuardOptions): NavigationGuard;
+declare const authGuard: NavigationGuard;
+//#endregion
+//#region src/client/guards/guestGuard.d.ts
+interface GuestGuardOptions {
+  redirect: string;
+}
+declare function createGuestGuard(options: GuestGuardOptions): () => string | undefined;
+declare const guestGuard: () => string | undefined;
+//#endregion
+//#region src/client/guards/setupGuard.d.ts
+declare const setupGuard: NavigationGuard;
+//#endregion
+export { $fetch, $file, AuthGuardOptions, AuthService, AutoOptions, FetchBrowserService, FetchNodeService, FetchOptions, FetchService, GuestGuardOptions, LifecycleService, ListFilter, MenuItem as MenuItemEntity, MenuService, Module as ModuleEntity, PluginEntity, Router, ToastService, acl, auth, authGuard, auto, config, _default as container, createAuthGuard, createGuestGuard, createRouter, $fetch$1 as fetch, guestGuard, logger, menu, route, router, setupGuard, toast };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/shared/utils/compose.d.ts","../../src/shared/entities/PermissionEntity.d.ts","../../src/shared/entities/RoleEntity.d.ts","../../src/shared/entities/UserEntity.d.ts","../../src/client/services/AuthService.d.ts","../../src/client/services/FetchService.d.ts","../../src/client/services/FetchBrowserService.d.ts","../../src/client/services/FetchNodeService.d.ts","../../src/shared/services/LoggerService.d.ts","../../src/shared/entities/LifecycleHook.d.ts","../../src/shared/services/LifecycleService.d.ts","../../src/client/services/LifecycleService.d.ts","../../src/client/entities/MenuItemEntity.d.ts","../../src/client/services/MenuService.d.ts","../../src/client/services/RouterService.d.ts","../../src/client/services/ToastService.d.ts","../../src/shared/entities/AclEntity.d.ts","../../src/client/facades/acl.d.ts","../../src/client/facades/auth.d.ts","../../src/shared/services/ConfigService.d.ts","../../src/client/facades/config.d.ts","../../src/shared/services/ContainerService.d.ts","../../src/client/facades/container.d.ts","../../src/client/facades/fetch.d.ts","../../src/client/facades/logger.d.ts","../../src/client/facades/menu.d.ts","../../src/client/facades/route.d.ts","../../src/client/facades/router.d.ts","../../src/client/facades/toast.d.ts","../../src/shared/entities/ModuleManifestEntity.d.ts","../../src/shared/entities/ModuleEntity.d.ts","../../src/client/entities/ModuleEntity.d.ts","../../src/shared/entities/PluginEntity.d.ts","../../src/client/entities/PluginEntity.d.ts","../../src/client/utils/fetcher.d.ts","../../src/client/utils/file.d.ts","../../src/client/guards/authGuard.d.ts","../../src/client/guards/guestGuard.d.ts","../../src/client/guards/setupGuard.d.ts"],"sourcesContent":["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","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","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","import User from '#shared/entities/UserEntity.ts';\ninterface LogoutOptions {\n    redirect?: string;\n}\nexport default class AuthService {\n    static __container_entry_key: string;\n    user: User | null;\n    constructor(data?: Partial<AuthService>);\n    logout(options?: LogoutOptions): Promise<void>;\n}\nexport {};\n","export interface FetchOptions extends RequestInit {\n    query?: Record<string, any>;\n    data?: Record<string, any>;\n}\nexport default class FetchService {\n    static __container_entry_key: string;\n    protected handleError(response: Response): Promise<void>;\n    protected buildUrl(url: string, query?: Record<string, any>): string;\n    protected buildRequestInit(options: FetchOptions): RequestInit;\n    protected parseResponse<T>(response: Response): Promise<T>;\n    fetch<T>(_url: string, _options?: FetchOptions): Promise<T>;\n    try<T = any>(url: string, options?: FetchOptions): Promise<[Error, null] | [null, Awaited<T>]>;\n    get<T = any>(url: string, options?: FetchOptions): Promise<T>;\n    post<T = any>(url: string, options?: FetchOptions): Promise<T>;\n    put<T = any>(url: string, options?: FetchOptions): Promise<T>;\n    delete<T = any>(url: string, options?: FetchOptions): Promise<T>;\n}\n","import type { FetchOptions } from './FetchService.ts';\nimport FetchService from './FetchService.ts';\nexport default class FetchBrowserService extends FetchService {\n    fetch<T>(url: string, options?: FetchOptions): Promise<T>;\n}\n","import type { FetchOptions } from './FetchService.ts';\nimport FetchService from './FetchService.ts';\nexport default class FetchNodeService extends FetchService {\n    fetch<T>(url: string, options?: FetchOptions): Promise<T>;\n    protected fetchExternal<T>(url: string, options?: FetchOptions): Promise<T>;\n    protected fetchInternal<T>(url: string, options?: FetchOptions): Promise<T>;\n}\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","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","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 BaseLifecycleService from '#shared/services/LifecycleService.ts';\nexport default class LifecycleService extends BaseLifecycleService {\n    addImports(imports: Record<string, any>): void;\n}\n","declare const MenuItem_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 MenuItem extends MenuItem_base {\n    id: string;\n    label: string;\n    layout: string;\n    to?: string;\n    target?: '_blank' | '_self' | '_parent' | '_top';\n    group?: string;\n    order?: number;\n    icon?: string;\n    parent?: string;\n}\nexport {};\n","import MenuItem from '#client/entities/MenuItemEntity.ts';\nexport interface ListFilter {\n    layout?: string;\n    group?: string;\n    parent?: string;\n    allowed?: boolean;\n}\nexport default class MenuService {\n    static __container_entry_key: string;\n    items: Map<string, MenuItem>;\n    add(...item: Omit<Partial<MenuItem>, 'merge' | 'from'>[]): void;\n    remove(id: MenuItem['id']): void;\n    list(filter?: ListFilter): MenuItem[];\n    clear(): void;\n}\n","import type { NavigationGuard, Router as VueRouter } from 'vue-router';\nimport type { RouteRecordRaw } from 'vue-router';\nimport type { DefineComponent } from 'vue';\nexport interface Router extends VueRouter {\n    auto: typeof auto;\n}\nexport interface AutoOptions {\n    guards?: NavigationGuard[] | ((record: RouteRecordRaw) => NavigationGuard[]);\n    strip?: (string | RegExp)[];\n    exclude?: (string | RegExp)[];\n    prefix?: string;\n    refine?: (records: RouteRecordRaw[]) => RouteRecordRaw[];\n}\nexport declare function auto(imports: Record<string, DefineComponent | (() => Promise<DefineComponent>)>, options?: AutoOptions): RouteRecordRaw[];\nexport declare function createRouter(): Router;\n","export default class ToastService {\n    static __container_entry_key: string;\n    success(message: string, options?: Record<string, any>): void;\n    error(message: string, options?: Record<string, any>): void;\n}\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","import AclEntity from '#shared/entities/AclEntity.ts';\ndeclare const acl: AclEntity;\nexport default acl;\n","import AuthService from '#client/services/AuthService.ts';\ndeclare const auth: AuthService;\nexport default auth;\n","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}\nexport {};\n","import ConfigService from '#shared/services/ConfigService.ts';\ndeclare const config: ConfigService;\nexport default config;\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","import ContainerService from \"#shared/services/ContainerService.ts\";\ndeclare const _default: ContainerService;\nexport default _default;\n","import FetchService from '#client/services/FetchService.ts';\ndeclare const $fetch: FetchService;\nexport default $fetch;\n","import LoggerService from '#shared/services/LoggerService.ts';\ndeclare const logger: LoggerService;\nexport default logger;\n","import MenuService from '#client/services/MenuService.ts';\ndeclare const menu: MenuService;\nexport default menu;\n","import type { RouteLocationNormalizedGeneric } from 'vue-router';\ndeclare const route: RouteLocationNormalizedGeneric;\nexport default route;\n","import type { Router } from '#client/services/RouterService.ts';\ndeclare const router: Router;\nexport default router;\n","import ToastService from '#client/services/ToastService.ts';\ndeclare const toast: ToastService;\nexport default toast;\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","import Base from '#shared/entities/ModuleEntity.ts';\ndeclare const Module_base: typeof Base;\nexport default class Module extends Module_base {\n}\nexport {};\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}\nexport {};\n","import Base from '#shared/entities/PluginEntity.ts';\nimport type { AutoOptions } from '#client/services/RouterService.ts';\ndeclare const PluginEntity_base: typeof Base;\nexport default class PluginEntity extends PluginEntity_base {\n    addPagesFolder(imports: any, options?: AutoOptions): void;\n    load(): Promise<void>;\n}\nexport {};\n","/** @deprecated Use $fetch facade */\nexport declare const $fetch: import(\"..\").FetchService;\n","interface PickOptions {\n    accept?: string;\n    multiple?: boolean;\n}\ntype PickResult<T extends PickOptions> = T['multiple'] extends true ? File[] : File | null;\ndeclare function pick<T extends PickOptions>(options: T): Promise<PickResult<T>>;\ndeclare function toUint8Array(file: File): Promise<Uint8Array>;\ninterface UploadOptions {\n    driveId: string;\n    file: File;\n    directory?: string;\n}\ndeclare function upload(options: UploadOptions): Promise<any>;\nexport declare const $file: {\n    pick: typeof pick;\n    upload: typeof upload;\n    toUint8Array: typeof toUint8Array;\n};\nexport {};\n","import type { NavigationGuard } from 'vue-router';\nexport interface AuthGuardOptions {\n    redirect: string;\n    exclude?: string[];\n}\nexport declare function createAuthGuard(options: AuthGuardOptions): NavigationGuard;\ndeclare const authGuard: NavigationGuard;\nexport default authGuard;\n","export interface GuestGuardOptions {\n    redirect: string;\n}\nexport declare function createGuestGuard(options: GuestGuardOptions): () => string | undefined;\ndeclare const guestGuard: () => string | undefined;\nexport default guestGuard;\n","import type { NavigationGuard } from 'vue-router';\ndeclare const setupGuard: NavigationGuard;\nexport default setupGuard;\n"],"mappings":"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"}