@sidekick-coder/zenith-kit 0.3.7 → 0.3.9

package/dist/client/src/client/utils/toast.d.ts

@@ -0,0 +1,54 @@
+import { Component, CSSProperties } from 'vue';
+import { ExternalToast, Action, ToastT, ToastClasses, PromiseIExtendedResult, ToastToDismiss } from 'vue-sonner';
+export declare const $toast: ((message: string | (() => string | Component) | Component, data?: ExternalToast) => string | number) & {
+    success: (message: string | (() => string | Component) | Component, data?: ExternalToast) => string | number;
+    info: (message: string | (() => string | Component) | Component, data?: ExternalToast) => string | number;
+    warning: (message: string | (() => string | Component) | Component, data?: ExternalToast) => string | number;
+    error: (message: string | (() => string | Component) | Component, data?: ExternalToast) => string | number;
+    custom: (component: Component, data?: ExternalToast) => string | number;
+    message: (message: string | (() => string | Component) | Component, data?: ExternalToast) => string | number;
+    promise: <ToastData>(promise: Promise<ToastData> | (() => Promise<ToastData>), data?: ({
+        id?: number | string | undefined;
+        action?: ( Action | Component) | undefined;
+        icon?: Component | undefined;
+        component?: Component | undefined;
+        position?: ("top-left" | "top-right" | "bottom-left" | "bottom-right" | "top-center" | "bottom-center") | undefined;
+        style?: CSSProperties | undefined;
+        toasterId?: string | undefined;
+        componentProps?: any;
+        richColors?: boolean | undefined;
+        invert?: boolean | undefined;
+        closeButton?: boolean | undefined;
+        dismissible?: boolean | undefined;
+        duration?: number | undefined;
+        important?: boolean | undefined;
+        cancel?: ( Action | Component) | undefined;
+        onDismiss?: ((toast: ToastT) => void) | undefined;
+        onAutoClose?: ((toast: ToastT) => void) | undefined;
+        cancelButtonStyle?: CSSProperties | undefined;
+        actionButtonStyle?: CSSProperties | undefined;
+        unstyled?: boolean | undefined;
+        class?: string | undefined;
+        classes?: ToastClasses | undefined;
+        descriptionClass?: string | undefined;
+        closeButtonPosition?: ("top-left" | "top-right" | "bottom-left" | "bottom-right") | undefined;
+        testId?: string | undefined;
+    } & {
+        loading?: string | Component;
+        success?: (string | Component | ((data: ToastData) => Component | string | Promise< Component | string>)) | ( PromiseIExtendedResult | ((data: ToastData) => PromiseIExtendedResult | Promise< PromiseIExtendedResult>)) | undefined;
+        error?: (string | Component | ((data: any) => Component | string | Promise< Component | string>)) | ( PromiseIExtendedResult | ((data: any) => PromiseIExtendedResult | Promise< PromiseIExtendedResult>));
+        description?: string | Component | ((data: any) => Component | string | Promise< Component | string>);
+        finally?: () => void | Promise<void>;
+    }) | undefined) => (string & {
+        unwrap: () => Promise<ToastData>;
+    }) | (number & {
+        unwrap: () => Promise<ToastData>;
+    }) | {
+        unwrap: () => Promise<ToastData>;
+    } | undefined;
+    dismiss: (id?: number | string) => string | number | undefined;
+    loading: (message: string | (() => string | Component) | Component, data?: ExternalToast) => string | number;
+} & {
+    getHistory: () => ( ToastT<Component> | ToastToDismiss)[];
+    getToasts: () => ( ToastT<Component> | ToastToDismiss)[];
+};

package/dist/client/src/client/utils/twMerge.d.ts

@@ -0,0 +1,5 @@
+import { ClassValue } from 'clsx';
+import { ClassNameValue } from 'tailwind-merge';
+export declare function twMerge(...inputs: ClassNameValue[]): string;
+export declare function clsx(...inputs: ClassValue[]): string;
+export declare function cn(...inputs: ClassValue[]): string;

package/dist/client/src/shared/entities/AclEntity.d.ts

@@ -0,0 +1,14 @@
+import { defineAbility, ForcedSubject } from '@casl/ability';
+import { default as Permission } from './PermissionEntity.ts';
+import { default as LoggerService } from '../services/LoggerService.ts';
+export default class AclEntity {
+    static __container_entry_key: string;
+    ability: ReturnType<typeof defineAbility>;
+    permissions: Permission[];
+    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> & ForcedSubject<string>;
+}

package/dist/client/src/shared/entities/CookieMapEntity.d.ts

@@ -0,0 +1,14 @@
+export interface CookieMapEntityOptions {
+    cookies?: Map<string, string>;
+    prefix?: string;
+}
+export default class CookieMapEntity {
+    static __container_entry_key: string;
+    cookies: Map<string, string>;
+    prefix: string;
+    constructor(data?: CookieMapEntityOptions);
+    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>;
+}

package/dist/client/src/shared/entities/DriveConfigEntity.d.ts

@@ -0,0 +1,125 @@
+export declare const TYPES: () => ({
+    id: string;
+    label: string;
+    description: string;
+    config_fields: {
+        directory: {
+            component: string;
+            label: string;
+            description: string;
+            hint: string;
+        };
+        accessKeyId?: undefined;
+        secretAccessKey?: undefined;
+        bucket?: undefined;
+        region?: undefined;
+        prefix?: undefined;
+        endpoint?: undefined;
+    };
+} | {
+    id: string;
+    label: string;
+    description: string;
+    config_fields: {
+        accessKeyId: {
+            component: string;
+            label: string;
+            hint: string;
+            type: string;
+        };
+        secretAccessKey: {
+            component: string;
+            label: string;
+            hint: string;
+            type: string;
+        };
+        bucket: {
+            component: string;
+            label: string;
+            hint: string;
+        };
+        region: {
+            component: string;
+            label: string;
+            hint: string;
+        };
+        prefix: {
+            component: string;
+            label: string;
+            hint: string;
+        };
+        endpoint: {
+            component: string;
+            label: string;
+            hint: string;
+        };
+        directory?: undefined;
+    };
+})[];
+export default class DriveConfig {
+    static get TYPES(): ({
+        id: string;
+        label: string;
+        description: string;
+        config_fields: {
+            directory: {
+                component: string;
+                label: string;
+                description: string;
+                hint: string;
+            };
+            accessKeyId?: undefined;
+            secretAccessKey?: undefined;
+            bucket?: undefined;
+            region?: undefined;
+            prefix?: undefined;
+            endpoint?: undefined;
+        };
+    } | {
+        id: string;
+        label: string;
+        description: string;
+        config_fields: {
+            accessKeyId: {
+                component: string;
+                label: string;
+                hint: string;
+                type: string;
+            };
+            secretAccessKey: {
+                component: string;
+                label: string;
+                hint: string;
+                type: string;
+            };
+            bucket: {
+                component: string;
+                label: string;
+                hint: string;
+            };
+            region: {
+                component: string;
+                label: string;
+                hint: string;
+            };
+            prefix: {
+                component: string;
+                label: string;
+                hint: string;
+            };
+            endpoint: {
+                component: string;
+                label: string;
+                hint: string;
+            };
+            directory?: undefined;
+        };
+    })[];
+    id: string;
+    name: string;
+    type: string;
+    is_default: boolean;
+    config: Record<string, any>;
+    constructor(data: DriveConfig);
+    get config_fields(): {};
+}

package/dist/client/src/shared/entities/DriveEntryEntity.d.ts

@@ -0,0 +1,7 @@
+export default class DriveEntry {
+    name: string;
+    path: string;
+    type: 'file' | 'directory';
+    metas: Record<string, any>;
+    constructor(data: DriveEntry);
+}

package/dist/client/src/shared/entities/FileEntity.d.ts

@@ -0,0 +1,29 @@
+import { Constructor } from '../utils/compose.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;
+    };
+};
+export default 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;
+}
+export {};

package/dist/client/src/shared/entities/FileMetaEntity.d.ts

@@ -0,0 +1,23 @@
+import { Constructor } from '../utils/compose.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;
+    };
+};
+export default class FileMeta extends FileMeta_base {
+    id: number;
+    file_id: number;
+    name: string;
+    value: string | null;
+}
+export {};

package/dist/client/src/shared/entities/FileUploadSessionEntity.d.ts

@@ -0,0 +1,28 @@
+import { Constructor } from '../utils/compose.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;
+    };
+};
+export default 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;
+}
+export {};

package/dist/client/src/shared/entities/GitBranchEntity.d.ts

@@ -0,0 +1,7 @@
+export default class GitBranchEntity {
+    name: string;
+    remote: string | null;
+    is_current: boolean;
+    is_remote: boolean;
+    constructor(data: GitBranchEntity);
+}

package/dist/client/src/shared/entities/GitCommitEntity.d.ts

@@ -0,0 +1,10 @@
+export default class GitCommitEntity {
+    hash: string;
+    short_hash: string;
+    message: string;
+    body: string;
+    author_name: string;
+    author_email: string;
+    date: string;
+    constructor(data: GitCommitEntity);
+}

package/dist/client/src/shared/entities/HeaderMapEntity.d.ts

@@ -0,0 +1,14 @@
+export interface HeaderMapEntityOptions {
+    headers?: Record<string, string>;
+    setHeader?: (name: string, value: string) => void;
+}
+export default class HeaderMapEntity {
+    static __container_entry_key: string;
+    entries: Map<string, string>;
+    setHeader?: (name: string, value: string) => void;
+    constructor(data?: HeaderMapEntityOptions);
+    loadFromRecord(cookies: Record<string, string>): void;
+    get(name: string, defaultValue?: string | null): string | null;
+    set(name: string, value: string): void;
+    toRecord(): Record<string, string>;
+}

package/dist/client/src/shared/entities/LifecycleHook.d.ts

@@ -0,0 +1,18 @@
+export default 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>;
+}

package/dist/client/src/shared/entities/ModuleEntity.d.ts

@@ -0,0 +1,24 @@
+import { default as ModuleManifest } from './ModuleManifestEntity.ts';
+import { default as LifecycleHook } from './LifecycleHook.ts';
+import { Constructor } from '../utils/compose.ts';
+interface ModuleUpgradeInfo {
+    source: 'git' | 'zip';
+    [key: string]: any;
+}
+declare const Module_base: {
+    new (...args: any[]): {
+        merge(data: Partial</*elided*/ any>): /*elided*/ any;
+    };
+    from<T>(this: new () => T, data: Partial<T>): T;
+} & Constructor & Constructor<{}> & typeof LifecycleHook;
+export default class Module extends Module_base {
+    id: string;
+    name: string;
+    enabled: boolean;
+    dependencies: Record<string, any>;
+    build: ModuleManifest['build'];
+    directory: string;
+    upgrade_info?: ModuleUpgradeInfo;
+    setData(data: Partial<Module | ModuleManifest>): void;
+}
+export {};

package/dist/client/src/shared/entities/ModuleManifestEntity.d.ts

@@ -0,0 +1,27 @@
+import { Constructor } from '../utils/compose.ts';
+export interface ModuleManifestBuildImport {
+    from: string;
+    to?: string;
+    type: 'global_import';
+}
+export 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;
+export default 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;
+}
+export {};

package/dist/client/src/shared/entities/PaginationEntity.d.ts

@@ -0,0 +1,9 @@
+export default 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>;
+}

package/dist/client/src/shared/entities/PermissionEntity.d.ts

@@ -0,0 +1,19 @@
+import { Constructor } from '../utils/compose.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;
+export default 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;
+}
+export {};

package/dist/client/src/shared/entities/PluginEntity.d.ts

@@ -0,0 +1,17 @@
+import { Constructor } from '../utils/compose.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;
+export default class PluginEntity extends PluginEntity_base {
+    id: string;
+    name: string;
+    version: string;
+    enabled: boolean;
+    aliases: string[];
+    version_channel: string;
+    version_available_channels: string[];
+}
+export {};

package/dist/client/src/shared/entities/RoleEntity.d.ts

@@ -0,0 +1,22 @@
+import { Constructor } from '../utils/compose.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;
+    };
+};
+export default class Role extends Role_base {
+    id: number;
+    name: string;
+    description?: string;
+}
+export {};

package/dist/client/src/shared/entities/UserEntity.d.ts

@@ -0,0 +1,30 @@
+import { default as Permission } from './PermissionEntity.ts';
+import { default as Role } from './RoleEntity.ts';
+import { Constructor } from '../utils/compose.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;
+    };
+};
+export default class UserEntity extends UserEntity_base {
+    id: number;
+    email: string;
+    name: string;
+    username: string;
+    password?: string;
+    verified_at?: Date | string | null;
+    permissions?: Permission[];
+    roles?: Role[];
+    get initials(): string;
+}
+export {};

package/dist/client/src/shared/exceptions/BaseException.d.ts

@@ -0,0 +1,5 @@
+export default class BaseException extends Error {
+    status: number;
+    constructor(message: string, status?: number);
+    static fromError(error: Error): BaseException;
+}

package/dist/client/src/shared/exceptions/ShellException.d.ts

@@ -0,0 +1,7 @@
+import { default as BaseException } from './BaseException.ts';
+export default class ShellException extends BaseException {
+    output: string;
+    bin: string;
+    args: string[];
+    constructor(message: string, output: string, bin: string, args: string[]);
+}

package/dist/client/src/shared/facades/validator.d.ts

@@ -0,0 +1,3 @@
+import { default as ValidatorService } from '../services/ValidatorService';
+export declare const validator: ValidatorService;
+export default validator;

package/dist/client/src/shared/index.d.ts

@@ -0,0 +1,83 @@
+export * from './services/ConfigService.ts';
+export { default as ConfigService } from './services/ConfigService.ts';
+export * from './services/ContainerService.ts';
+export { default as ContainerService } from './services/ContainerService.ts';
+export * from './services/EmmitterService.ts';
+export { default as EmmitterService } from './services/EmmitterService.ts';
+export * from './services/LifecycleService.ts';
+export { default as LifecycleService } from './services/LifecycleService.ts';
+export * from './services/LoggerService.ts';
+export { default as LoggerService } from './services/LoggerService.ts';
+export * from './services/TranslatorService.ts';
+export { default as TranslatorService } from './services/TranslatorService.ts';
+export * from './services/UploadService.ts';
+export { default as UploadService } from './services/UploadService.ts';
+export * from './services/ValidatorService.ts';
+export { default as ValidatorService } from './services/ValidatorService.ts';
+export * from './utils/compose.ts';
+export * from './utils/createId.ts';
+export * from './utils/flatten.ts';
+export * from './utils/formatBytes.ts';
+export * from './utils/index.ts';
+export * from './utils/matchPaths.ts';
+export * from './utils/parseRouteUrl.ts';
+export * from './utils/safeJson.ts';
+export * from './utils/tryCatch.ts';
+export * from './utils/typing.ts';
+export * from './schemas/dashboardMetaSchema.ts';
+export * from './schemas/dashboardSchema.ts';
+export * from './schemas/permissionAssignmentSchema.ts';
+export * from './schemas/permissionSchema.ts';
+export * from './schemas/tokenSchema.ts';
+export * from './schemas/userSchema.ts';
+export { default as userSchema } from './schemas/userSchema.ts';
+export * from './exceptions/BaseException.ts';
+export { default as BaseException } from './exceptions/BaseException.ts';
+export * from './exceptions/ShellException.ts';
+export { default as ShellException } from './exceptions/ShellException.ts';
+export * from './facades/validator.ts';
+export { default as validator } from './facades/validator.ts';
+export * from './mixins/BaseEntityMixin.ts';
+export { default as BaseEntityMixin } from './mixins/BaseEntityMixin.ts';
+export * from './mixins/HooksMixin.ts';
+export { default as HooksMixin } from './mixins/HooksMixin.ts';
+export * from './mixins/SoftDeleteMixin.ts';
+export { default as SoftDeleteMixin } from './mixins/SoftDeleteMixin.ts';
+export * from './mixins/TimestampMixin.ts';
+export { default as TimestampMixin } from './mixins/TimestampMixin.ts';
+export * from './entities/AclEntity.ts';
+export { default as AclEntity } from './entities/AclEntity.ts';
+export * from './entities/CookieMapEntity.ts';
+export { default as CookieMapEntity } from './entities/CookieMapEntity.ts';
+export * from './entities/DriveConfigEntity.ts';
+export { default as DriveConfigEntity } from './entities/DriveConfigEntity.ts';
+export * from './entities/DriveEntryEntity.ts';
+export { default as DriveEntryEntity } from './entities/DriveEntryEntity.ts';
+export * from './entities/FileEntity.ts';
+export { default as FileEntity } from './entities/FileEntity.ts';
+export * from './entities/FileMetaEntity.ts';
+export { default as FileMetaEntity } from './entities/FileMetaEntity.ts';
+export * from './entities/FileUploadSessionEntity.ts';
+export { default as FileUploadSessionEntity } from './entities/FileUploadSessionEntity.ts';
+export * from './entities/GitBranchEntity.ts';
+export { default as GitBranchEntity } from './entities/GitBranchEntity.ts';
+export * from './entities/GitCommitEntity.ts';
+export { default as GitCommitEntity } from './entities/GitCommitEntity.ts';
+export * from './entities/HeaderMapEntity.ts';
+export { default as HeaderMapEntity } from './entities/HeaderMapEntity.ts';
+export * from './entities/LifecycleHook.ts';
+export { default as LifecycleHook } from './entities/LifecycleHook.ts';
+export * from './entities/ModuleEntity.ts';
+export { default as ModuleEntity } from './entities/ModuleEntity.ts';
+export * from './entities/ModuleManifestEntity.ts';
+export { default as ModuleManifestEntity } from './entities/ModuleManifestEntity.ts';
+export * from './entities/PaginationEntity.ts';
+export { default as PaginationEntity } from './entities/PaginationEntity.ts';
+export * from './entities/PermissionEntity.ts';
+export { default as PermissionEntity } from './entities/PermissionEntity.ts';
+export * from './entities/PluginEntity.ts';
+export { default as PluginEntity } from './entities/PluginEntity.ts';
+export * from './entities/RoleEntity.ts';
+export { default as RoleEntity } from './entities/RoleEntity.ts';
+export * from './entities/UserEntity.ts';
+export { default as UserEntity } from './entities/UserEntity.ts';

package/dist/client/src/shared/mixins/BaseEntityMixin.d.ts

@@ -0,0 +1,17 @@
+import { Constructor } from '../utils/compose.ts';
+interface CreateBaseEntityOptions {
+    parse?: (data: any) => any;
+}
+export 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;
+export default 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;
+export {};