@sidekick-coder/zenith-kit 0.3.7 → 0.3.9

package/dist/components/src/client/facades/acl.d.ts

@@ -0,0 +1,3 @@
+import { default as AclEntity } from '../../shared/entities/AclEntity.ts';
+declare const acl: AclEntity;
+export default acl;

package/dist/components/src/client/facades/auth.d.ts

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

package/dist/components/src/client/facades/config.d.ts

@@ -0,0 +1,3 @@
+import { default as ConfigService } from '../../shared/services/ConfigService.ts';
+declare const config: ConfigService;
+export default config;

package/dist/components/src/client/facades/container.d.ts

@@ -0,0 +1,3 @@
+import { default as ContainerService } from '../../shared/services/ContainerService.ts';
+declare const _default: ContainerService;
+export default _default;

package/dist/components/src/client/facades/dashboardRegistry.d.ts

@@ -0,0 +1,3 @@
+import { default as DashboardWidgetRegistry } from '../registry/DashboardWidgetRegistry.ts';
+declare const dashboardRegistry: DashboardWidgetRegistry;
+export default dashboardRegistry;

package/dist/components/src/client/facades/emmitter.d.ts

@@ -0,0 +1,3 @@
+import { EmmitterService } from '../../shared/index.ts';
+declare const emmitter: EmmitterService<Record<string, any>>;
+export default emmitter;

package/dist/components/src/client/facades/fetcher.d.ts

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

package/dist/components/src/client/facades/layout.d.ts

@@ -0,0 +1,2 @@
+declare const layout: any;
+export default layout;

package/dist/components/src/client/facades/lifecycle.d.ts

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

package/dist/components/src/client/facades/logger.d.ts

@@ -0,0 +1,3 @@
+import { default as LoggerService } from '../../shared/services/LoggerService.ts';
+declare const logger: LoggerService;
+export default logger;

package/dist/components/src/client/facades/menu.d.ts

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

package/dist/components/src/client/facades/route.d.ts

@@ -0,0 +1,3 @@
+import { RouteLocationNormalizedGeneric } from 'vue-router';
+declare const route: RouteLocationNormalizedGeneric;
+export default route;

package/dist/components/src/client/facades/router.d.ts

@@ -0,0 +1,3 @@
+import { Router } from '../services/RouterService.ts';
+declare const router: Router;
+export default router;

package/dist/components/src/client/facades/toast.d.ts

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

package/dist/components/src/client/guards/authGuard.d.ts

@@ -0,0 +1,8 @@
+import { NavigationGuard, RouteLocationNormalized } from 'vue-router';
+export interface AuthGuardOptions {
+    redirect: string | ((to: RouteLocationNormalized) => string);
+    exclude?: string[];
+}
+export declare function createAuthGuard(options: AuthGuardOptions): NavigationGuard;
+declare const authGuard: NavigationGuard;
+export default authGuard;

package/dist/components/src/client/guards/guestGuard.d.ts

@@ -0,0 +1,6 @@
+export interface GuestGuardOptions {
+    redirect: string;
+}
+export declare function createGuestGuard(options: GuestGuardOptions): () => string | undefined;
+declare const guestGuard: () => string | undefined;
+export default guestGuard;

package/dist/components/src/client/guards/setupGuard.d.ts

@@ -0,0 +1,3 @@
+import { NavigationGuard } from 'vue-router';
+declare const setupGuard: NavigationGuard;
+export default setupGuard;

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

@@ -0,0 +1,90 @@
+export * from './services/AuthService.ts';
+export { default as AuthService } from './services/AuthService.ts';
+export * from './services/FetchBrowserService.ts';
+export { default as FetchBrowserService } from './services/FetchBrowserService.ts';
+export * from './services/FetchNodeService.ts';
+export { default as FetchNodeService } from './services/FetchNodeService.ts';
+export * from './services/FetchService.ts';
+export { default as FetchService } from './services/FetchService.ts';
+export * from './services/LayoutService.ts';
+export { default as LayoutService } from './services/LayoutService.ts';
+export * from './services/LifecycleService.ts';
+export { default as LifecycleService } from './services/LifecycleService.ts';
+export * from './services/MenuService.ts';
+export { default as MenuService } from './services/MenuService.ts';
+export * from './services/RouterService.ts';
+export * from './services/ToastService.ts';
+export { default as ToastService } from './services/ToastService.ts';
+export * from './composables/useBreakpoint.ts';
+export * from './composables/useColor.ts';
+export * from './composables/useDashboard.ts';
+export * from './composables/useDashboardWidget.ts';
+export * from './composables/useFetchPagination.ts';
+export * from './composables/useForm.ts';
+export * from './composables/useHead.ts';
+export * from './composables/useLayoutOptions.ts';
+export * from './composables/useLoading.ts';
+export * from './composables/useMenu.ts';
+export * from './composables/useRouteQuery.ts';
+export * from './composables/useState.ts';
+export * from './facades/acl.ts';
+export { default as acl } from './facades/acl.ts';
+export * from './facades/auth.ts';
+export { default as auth } from './facades/auth.ts';
+export * from './facades/config.ts';
+export { default as config } from './facades/config.ts';
+export * from './facades/container.ts';
+export { default as container } from './facades/container.ts';
+export * from './facades/dashboardRegistry.ts';
+export { default as dashboardRegistry } from './facades/dashboardRegistry.ts';
+export * from './facades/emmitter.ts';
+export { default as emmitter } from './facades/emmitter.ts';
+export * from './facades/fetcher.ts';
+export { default as fetcher } from './facades/fetcher.ts';
+export * from './facades/layout.ts';
+export { default as layout } from './facades/layout.ts';
+export * from './facades/lifecycle.ts';
+export { default as lifecycle } from './facades/lifecycle.ts';
+export * from './facades/logger.ts';
+export { default as logger } from './facades/logger.ts';
+export * from './facades/menu.ts';
+export { default as menu } from './facades/menu.ts';
+export * from './facades/route.ts';
+export { default as route } from './facades/route.ts';
+export * from './facades/router.ts';
+export { default as router } from './facades/router.ts';
+export * from './facades/toast.ts';
+export { default as toast } from './facades/toast.ts';
+export * from './entities/Dashboard.ts';
+export { default as Dashboard } from './entities/Dashboard.ts';
+export * from './entities/DashboardWidget.ts';
+export { default as DashboardWidget } from './entities/DashboardWidget.ts';
+export * from './entities/DashboardWidgetData.ts';
+export { default as DashboardWidgetData } from './entities/DashboardWidgetData.ts';
+export * from './entities/DashboardWidgetDefinition.ts';
+export { default as DashboardWidgetDefinition } from './entities/DashboardWidgetDefinition.ts';
+export * from './entities/DashboardWidgetDefinitionChart.ts';
+export { default as DashboardWidgetDefinitionChart } from './entities/DashboardWidgetDefinitionChart.ts';
+export * from './entities/MenuItemEntity.ts';
+export { default as MenuItemEntity } from './entities/MenuItemEntity.ts';
+export * from './entities/ModuleEntity.ts';
+export { default as ModuleEntity } from './entities/ModuleEntity.ts';
+export * from './entities/PluginEntity.ts';
+export { default as PluginEntity } from './entities/PluginEntity.ts';
+export * from './utils/autoPages.ts';
+export * from './utils/createId.ts';
+export * from './utils/defineColumns.ts';
+export * from './utils/defineFormFields.ts';
+export * from './utils/fetcher.ts';
+export * from './utils/file.ts';
+export * from './utils/parseTo.ts';
+export * from './utils/toast.ts';
+export * from './utils/twMerge.ts';
+export * from './guards/authGuard.ts';
+export { default as authGuard } from './guards/authGuard.ts';
+export * from './guards/guestGuard.ts';
+export { default as guestGuard } from './guards/guestGuard.ts';
+export * from './guards/setupGuard.ts';
+export { default as setupGuard } from './guards/setupGuard.ts';
+export * from './registry/DashboardWidgetRegistry.ts';
+export { default as DashboardWidgetRegistry } from './registry/DashboardWidgetRegistry.ts';

package/dist/components/src/client/layouts/AdminLayout.vue.d.ts

@@ -0,0 +1,14 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: DefineComponent<{}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/src/client/layouts/AdminLayoutDefaultMenu.vue.d.ts

@@ -0,0 +1,25 @@
+import { default as MenuItem } from '../entities/MenuItemEntity.ts';
+import { DefineComponent, ExtractPropTypes, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: DefineComponent<ExtractPropTypes<{
+    items: {
+        type: () => MenuItem[];
+        required: true;
+    };
+    open: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+    items: {
+        type: () => MenuItem[];
+        required: true;
+    };
+    open: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    open: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

package/dist/components/src/client/layouts/AdminLayoutPlainMenu.vue.d.ts

@@ -0,0 +1,15 @@
+import { default as MenuItem } from '../entities/MenuItemEntity.ts';
+import { DefineComponent, ExtractPropTypes, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: DefineComponent<ExtractPropTypes<{
+    items: {
+        type: () => MenuItem[];
+        required: true;
+    };
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+    items: {
+        type: () => MenuItem[];
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

package/dist/components/src/client/layouts/BaseLayout.vue.d.ts

@@ -0,0 +1,126 @@
+import { PropType, DefineComponent, ExtractPropTypes, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export interface LayoutBreadcrumbItem {
+    label: string;
+    to?: string;
+}
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots< DefineComponent<ExtractPropTypes<{
+    layoutId: {
+        type: StringConstructor;
+        required: true;
+    };
+    padding: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    hideBreadcrumbs: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    icon: {
+        type: StringConstructor;
+        default: null;
+    };
+    menuVariant: {
+        type: PropType<"default" | "plain">;
+        default: string;
+    };
+    homePath: {
+        type: StringConstructor;
+        default: string;
+    };
+    contentClass: {
+        type: StringConstructor;
+        default: string;
+    };
+    userMenuLinks: {
+        type: PropType<{
+            label: string;
+            to: string;
+            icon?: string;
+        }[]>;
+        default: () => never[];
+    };
+    breadcrumbs: {
+        type: PropType<LayoutBreadcrumbItem[]>;
+    };
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "update:breadcrumbs": (value: LayoutBreadcrumbItem[]) => any;
+}, string, PublicProps, Readonly< ExtractPropTypes<{
+    layoutId: {
+        type: StringConstructor;
+        required: true;
+    };
+    padding: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    hideBreadcrumbs: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    icon: {
+        type: StringConstructor;
+        default: null;
+    };
+    menuVariant: {
+        type: PropType<"default" | "plain">;
+        default: string;
+    };
+    homePath: {
+        type: StringConstructor;
+        default: string;
+    };
+    contentClass: {
+        type: StringConstructor;
+        default: string;
+    };
+    userMenuLinks: {
+        type: PropType<{
+            label: string;
+            to: string;
+            icon?: string;
+        }[]>;
+        default: () => never[];
+    };
+    breadcrumbs: {
+        type: PropType<LayoutBreadcrumbItem[]>;
+    };
+}>> & Readonly<{
+    "onUpdate:breadcrumbs"?: ((value: LayoutBreadcrumbItem[]) => any) | undefined;
+}>, {
+    icon: string;
+    title: string;
+    contentClass: string;
+    padding: boolean;
+    hideBreadcrumbs: boolean;
+    menuVariant: "default" | "plain";
+    homePath: string;
+    userMenuLinks: {
+        label: string;
+        to: string;
+        icon?: string;
+    }[];
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>, {
+    header?: (props: {}) => any;
+} & {
+    'sidebar-footer'?: (props: {
+        open: any;
+    }) => any;
+} & {
+    default?: (props: {}) => any;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/src/client/layouts/SettingLayout.vue.d.ts

@@ -0,0 +1,14 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+declare var __VLS_7: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_7) => any;
+};
+declare const __VLS_base: DefineComponent<{}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/src/client/lib/utils.d.ts

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

package/dist/components/src/client/registry/DashboardWidgetRegistry.d.ts

@@ -0,0 +1,8 @@
+import { default as DashboardWidgetDefinition } from '../entities/DashboardWidgetDefinition.ts';
+export default class DashboardWidgetRegistry {
+    static __container_entry_key: string;
+    private definitions;
+    register(...definition: DashboardWidgetDefinition[]): void;
+    get(id: string): DashboardWidgetDefinition | null;
+    list(): DashboardWidgetDefinition[];
+}

package/dist/components/src/client/services/AuthService.d.ts

@@ -0,0 +1,11 @@
+import { default as User } from '../../shared/entities/UserEntity.ts';
+interface LogoutOptions {
+    redirect?: string;
+}
+export default class AuthService {
+    static __container_entry_key: string;
+    user: User | null;
+    constructor(data?: Partial<AuthService>);
+    logout(options?: LogoutOptions): Promise<void>;
+}
+export {};

package/dist/components/src/client/services/FetchBrowserService.d.ts

@@ -0,0 +1,4 @@
+import { FetchOptions, default as FetchService } from './FetchService.ts';
+export default class FetchBrowserService extends FetchService {
+    fetch<T>(url: string, options?: FetchOptions): Promise<T>;
+}

package/dist/components/src/client/services/FetchNodeService.d.ts

@@ -0,0 +1,6 @@
+import { FetchOptions, default as FetchService } from './FetchService.ts';
+export default 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>;
+}

package/dist/components/src/client/services/FetchService.d.ts

@@ -0,0 +1,17 @@
+export interface FetchOptions extends RequestInit {
+    query?: Record<string, any>;
+    data?: Record<string, any>;
+}
+export default class FetchService {
+    static __container_entry_key: string;
+    protected handleError(response: Response): Promise<any>;
+    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>;
+}

package/dist/components/src/client/services/LayoutService.d.ts

@@ -0,0 +1,14 @@
+import { DefineComponent } from 'vue';
+export default class LayoutService {
+    static __container_entry_key: string;
+    components: Map<string, DefineComponent>;
+    options: Record<string, any>;
+    currendId: string | null;
+    setCurrent(id: string): void;
+    add(name: string, component: DefineComponent, options?: any): void;
+    has(name: string): boolean;
+    get(name: string): DefineComponent;
+    getOptions(): Record<string, any>;
+    getCurrent(): DefineComponent | null;
+    setOptions(options?: any): void;
+}

package/dist/components/src/client/services/LifecycleService.d.ts

@@ -0,0 +1,4 @@
+import { default as BaseLifecycleService } from '../../shared/services/LifecycleService.ts';
+export default class LifecycleService extends BaseLifecycleService {
+    addImports(imports: Record<string, any>): void;
+}

package/dist/components/src/client/services/MenuService.d.ts

@@ -0,0 +1,15 @@
+import { default as MenuItem } from '../entities/MenuItemEntity.ts';
+export interface ListFilter {
+    layout?: string;
+    group?: string;
+    parent?: string;
+    allowed?: boolean;
+}
+export default 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;
+}

package/dist/components/src/client/services/RouterService.d.ts

@@ -0,0 +1,14 @@
+import { NavigationGuard, Router as VueRouter, RouteRecordRaw } from 'vue-router';
+import { DefineComponent } from 'vue';
+export interface Router extends VueRouter {
+    auto: typeof auto;
+}
+export interface AutoOptions {
+    guards?: NavigationGuard[] | ((record: RouteRecordRaw) => NavigationGuard[]);
+    strip?: (string | RegExp)[];
+    exclude?: (string | RegExp)[];
+    prefix?: string;
+    refine?: (records: RouteRecordRaw[]) => RouteRecordRaw[];
+}
+export declare function auto(imports: Record<string, DefineComponent | (() => Promise<DefineComponent>)>, options?: AutoOptions): RouteRecordRaw[];
+export declare function createRouter(): Router;

package/dist/components/src/client/services/ToastService.d.ts

@@ -0,0 +1,5 @@
+export default class ToastService {
+    static __container_entry_key: string;
+    success(message: string, options?: Record<string, any>): void;
+    error(message: string, options?: Record<string, any>): void;
+}

package/dist/components/src/client/utils/autoPages.d.ts

@@ -0,0 +1,5 @@
+import { AutoOptions } from '../services/RouterService.ts';
+import { DefineComponent } from 'vue';
+import { RouteRecordRaw } from 'vue-router';
+/** @deprecated Use auto from RouterService instead */
+export declare function autoRoutes(imports: Record<string, DefineComponent | (() => Promise<DefineComponent>)>, options?: AutoOptions): RouteRecordRaw[];

package/dist/components/src/client/utils/createId.d.ts

@@ -0,0 +1 @@
+export { createId } from '../../shared/utils/createId.ts';

package/dist/components/src/client/utils/defineColumns.d.ts

@@ -0,0 +1,8 @@
+export interface DataTableColumn<T extends Record<string, any> = Record<string, any>> {
+    id?: string;
+    label?: string;
+    field?: keyof T | ((row: T) => any) | (string & {});
+    sortable?: boolean;
+    width?: string | number;
+}
+export declare function defineColumns<T extends Record<string, any>>(columns: DataTableColumn<T>[]): DataTableColumn<T>[];

package/dist/components/src/client/utils/defineFormFields.d.ts

@@ -0,0 +1,5 @@
+export interface DefineFormField {
+    component: 'text-field' | 'textarea' | 'select' | 'autocomplete' | 'switch' | 'file-upload' | 'image-upload' | 'color-picker' | 'string-list-input' | 'json-input' | 'date-picker' | 'hidden';
+    [key: string]: any;
+}
+export declare function defineFormFields(field: Record<string, DefineFormField>): Record<string, DefineFormField>;

package/dist/components/src/client/utils/fetcher.d.ts

@@ -0,0 +1,3 @@
+import { FetchService } from '..';
+/** @deprecated Use fetcher facade */
+export declare const $fetch: FetchService;

package/dist/components/src/client/utils/file.d.ts

@@ -0,0 +1,19 @@
+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>;
+export declare const $file: {
+    pick: typeof pick;
+    upload: typeof upload;
+    toUint8Array: typeof toUint8Array;
+};
+export {};

package/dist/components/src/client/utils/parseTo.d.ts

@@ -0,0 +1 @@
+export declare function parseTo(to: string): string;

package/dist/components/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;
+        position?: ("top-left" | "top-right" | "bottom-left" | "bottom-right" | "top-center" | "bottom-center") | undefined;
+        action?: ( Action | Component) | undefined;
+        icon?: Component | undefined;
+        component?: Component | undefined;
+        class?: string | undefined;
+        style?: CSSProperties | undefined;
+        duration?: number | undefined;
+        dismissible?: boolean | undefined;
+        cancel?: ( Action | Component) | undefined;
+        invert?: boolean | undefined;
+        closeButtonPosition?: ("top-left" | "top-right" | "bottom-left" | "bottom-right") | undefined;
+        richColors?: boolean | undefined;
+        closeButton?: boolean | undefined;
+        toasterId?: string | undefined;
+        componentProps?: any;
+        important?: boolean | undefined;
+        onDismiss?: ((toast: ToastT) => void) | undefined;
+        onAutoClose?: ((toast: ToastT) => void) | undefined;
+        cancelButtonStyle?: CSSProperties | undefined;
+        actionButtonStyle?: CSSProperties | undefined;
+        unstyled?: boolean | undefined;
+        classes?: ToastClasses | undefined;
+        descriptionClass?: string | 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/components/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/components/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>;
+}