@kupola/kupola 1.2.0 → 1.3.1

package/dist/types/kupola.d.ts

@@ -48,79 +48,6 @@ interface PersistOptions {
   debounce?: number;
 }
 
-interface RouteConfig {
-  path: string;
-  component: string | (() => Promise<{ default: typeof KupolaComponent } | typeof KupolaComponent>);
-  name?: string;
-  meta?: Record<string, unknown>;
-  children?: RouteConfig[];
-}
-
-interface RouterOptions {
-  mode?: 'hash' | 'history';
-  routes: RouteConfig[];
-  base?: string;
-}
-
-interface HttpRequestConfig {
-  url: string;
-  method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
-  headers?: Record<string, string>;
-  params?: Record<string, string | number | boolean>;
-  data?: Record<string, unknown> | unknown[];
-  timeout?: number;
-  withCredentials?: boolean;
-  responseType?: 'json' | 'text' | 'blob' | 'formData';
-  cache?: boolean;
-  retry?: boolean;
-}
-
-interface HttpResponse<T = unknown> {
-  data: T;
-  status: number;
-  statusText: string;
-  headers: Record<string, string>;
-  config: HttpRequestConfig;
-}
-
-interface HttpError {
-  message: string;
-  code?: number;
-  response?: HttpResponse;
-  config: HttpRequestConfig;
-}
-
-interface HttpInterceptor {
-  request?: (config: HttpRequestConfig) => HttpRequestConfig | Promise<HttpRequestConfig>;
-  requestError?: (error: unknown) => Promise<never>;
-  response?: <T = unknown>(response: HttpResponse<T>) => HttpResponse<T> | Promise<HttpResponse<T>>;
-  responseError?: (error: HttpError) => Promise<never>;
-}
-
-interface HttpOptions {
-  baseURL?: string;
-  timeout?: number;
-  headers?: Record<string, string>;
-  interceptors?: HttpInterceptor;
-  cacheTTL?: number;
-  maxRetries?: number;
-  retryDelay?: number;
-}
-
-interface UploadProgress {
-  progress: number;
-  uploaded: number;
-  total: number;
-  currentChunk: number;
-  totalChunks: number;
-}
-
-interface UploadOptions {
-  chunkSize?: number;
-  onProgress?: (progress: UploadProgress) => void;
-  headers?: Record<string, string>;
-  parallel?: boolean;
-}
 
 interface StoreOptions<S extends object = Record<string, unknown>> {
   state?: () => S;
@@ -205,14 +132,6 @@ interface VirtualListItem<T = unknown> {
   element: HTMLElement;
 }
 
-interface VirtualListOptions<T = unknown> {
-  data?: T[];
-  itemHeight?: number;
-  containerHeight?: number;
-  renderItem?: (item: T, index: number) => string;
-  onItemClick?: (item: VirtualListItem<T>) => void;
-}
-
 declare class KupolaDataBind<T extends object = Record<string, unknown>> {
   constructor();
   
@@ -584,50 +503,6 @@ declare class KupolaValidator {
 
 declare const validator: KupolaValidator;
 
-declare class KupolaRouter {
-  constructor(options: RouterOptions);
-  
-  push(path: string): void;
-  replace(path: string): void;
-  go(delta: number): void;
-  back(): void;
-  forward(): void;
-  
-  readonly currentRoute: RouteConfig | null;
-  readonly path: string;
-  readonly params: Record<string, string>;
-  readonly query: Record<string, string>;
-  
-  beforeEach(callback: (to: RouteConfig, from: RouteConfig | null) => boolean | void | Promise<boolean>): void;
-  afterEach(callback: (to: RouteConfig) => void): void;
-  
-  setAnimation(name: string): void;
-  
-  destroy(): void;
-}
-
-declare class KupolaHttp {
-  constructor(options?: HttpOptions);
-  
-  get<T = unknown>(url: string, config?: Omit<HttpRequestConfig, 'method' | 'url'>): Promise<HttpResponse<T>>;
-  post<T = unknown>(url: string, data?: HttpRequestConfig['data'], config?: Omit<HttpRequestConfig, 'method' | 'url'>): Promise<HttpResponse<T>>;
-  put<T = unknown>(url: string, data?: HttpRequestConfig['data'], config?: Omit<HttpRequestConfig, 'method' | 'url'>): Promise<HttpResponse<T>>;
-  delete<T = unknown>(url: string, config?: Omit<HttpRequestConfig, 'method' | 'url'>): Promise<HttpResponse<T>>;
-  patch<T = unknown>(url: string, data?: HttpRequestConfig['data'], config?: Omit<HttpRequestConfig, 'method' | 'url'>): Promise<HttpResponse<T>>;
-  
-  uploadFile<T = unknown>(url: string, file: File, options?: UploadOptions): Promise<HttpResponse<T>>;
-  
-  setHeader(name: string, value: string): void;
-  setToken(token: string, type?: string): void;
-  setCacheTTL(ttl: number): void;
-  setMaxRetries(retries: number): void;
-  
-  cancelRequest(url: string, params?: Record<string, string | number | boolean>): boolean;
-  clearCache(): void;
-  clearCacheByUrl(url: string): void;
-  
-  interceptors: HttpInterceptor;
-}
 
 interface ComponentMixin {
   [key: string]: unknown;
@@ -749,6 +624,8 @@ declare function toggleTheme(): void;
 
 declare function setBrand(brand: BrandColor): void;
 declare function getBrand(): BrandColor;
+declare function createThemeToggle(): { toggleBtn: HTMLElement; container: HTMLElement };
+declare function createBrandPicker(): { toggleBtn: HTMLElement; container: HTMLElement };
 declare const BRAND_OPTIONS: readonly BrandOption[];
 
 declare function showToast(options: ToastOptions | string): void;
@@ -763,10 +640,6 @@ declare function showAlert(content: string, title?: string): Promise<void>;
 
 declare function showNotification(options: NotificationOptions): void;
 
-declare function createRouter(options: RouterOptions): KupolaRouter;
-
-declare function createHttp(options?: HttpOptions): KupolaHttp;
-
 declare function registerComponent(name: string, componentClass: typeof KupolaComponent): void;
 
 declare function registerLazyComponent(name: string, loader: () => Promise<{ default: typeof KupolaComponent } | typeof KupolaComponent>): void;
@@ -777,50 +650,279 @@ declare function defineMixin(name: string, mixin: ComponentMixin): void;
 
 declare function useMixin(componentClass: typeof KupolaComponent, ...mixinNames: string[]): void;
 
+interface DefineComponentOptions {
+  componentClass?: typeof KupolaComponent;
+  lazy?: () => Promise<{ default: typeof KupolaComponent } | typeof KupolaComponent>;
+  init?: (element: HTMLElement) => void | Promise<void>;
+  cleanup?: (element: HTMLElement) => void;
+  dataAttribute?: string;
+  cssClass?: string;
+}
+declare function defineComponent(name: string, options: DefineComponentOptions): void;
+
+declare function registerWebComponents(): void;
+
+declare class KupolaDropdownElement extends HTMLElement {
+  static get observedAttributes(): string[];
+}
+declare class KupolaTooltipElement extends HTMLElement {
+  static get observedAttributes(): string[];
+}
+declare class KupolaCollapseElement extends HTMLElement {}
+declare class KupolaCollapseItemElement extends HTMLElement {
+  static get observedAttributes(): string[];
+}
+declare class KupolaDrawerElement extends HTMLElement {
+  static get observedAttributes(): string[];
+}
+declare class KupolaModalElement extends HTMLElement {
+  static get observedAttributes(): string[];
+  open(): void;
+  close(): void;
+}
+
+declare function createModal(options?: Record<string, unknown>): any;
+declare function confirmModal(options: Record<string, unknown> | string): any;
+declare function alertModal(options: Record<string, unknown> | string): any;
+
+declare function cleanupAllDropdowns(): void;
+declare function cleanupAllSlideCaptchas(): void;
+
+declare function ref<T = unknown>(initialValue?: T): { value: T; _subscribers: Set<Function> };
+
+declare class Modal {
+  constructor(element: HTMLElement, options?: Record<string, unknown>);
+  open(): void;
+  close(): void;
+  toggleFullscreen(): void;
+  isVisible(): boolean;
+  destroy(): void;
+}
+
 declare const kupolaRegistry: KupolaComponentRegistry;
 
 declare const kupolaPersist: KupolaStatePersist;
 
 declare const kupolaStoreManager: KupolaStoreManager;
 
-declare class KupolaDevTools {
-  constructor(options?: { enabled?: boolean });
-  
-  init(): void;
-  togglePanel(): void;
-  switchTab(tabName: 'storage' | 'network'): void;
-  renderStorageContent(): void;
-  renderNetworkContent(): void;
-  clearNetworkHistory(): void;
-  addRequest(entry: NetworkRequest): void;
-  updateRequest(entry: NetworkRequest): void;
-  destroy(): void;
-  
-  enabled: boolean;
-  isOpen: boolean;
-  activeTab: 'storage' | 'network';
-  activeStorageType: 'cookies' | 'localStorage' | 'sessionStorage';
-  requestHistory: NetworkRequest[];
-}
+declare function createStore<S extends object = Record<string, unknown>>(name: string, options?: StoreOptions<S>): KupolaStore<S>;
+
+declare function getStore<S extends object = Record<string, unknown>>(name: string): KupolaStore<S> | undefined;
 
-interface NetworkRequest {
-  id?: number;
-  method: string;
-  url: string;
-  params?: Record<string, string>;
-  requestBody?: string;
+// ============================================================
+// @kupola/depends - Declarative Data Dependencies
+// ============================================================
+
+// --- HTTP Client Plugin System ---
+interface KupolaHttpResponse {
+  ok: boolean;
   status: number;
-  response?: unknown;
-  duration?: number;
+  statusText?: string;
+  headers: Record<string, string>;
+  url?: string;
+  json(): Promise<any>;
+  text(): Promise<string>;
 }
 
-declare const kupolaDevTools: KupolaDevTools;
+interface KupolaHttpClient {
+  fetch(url: string, options?: {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+  }): Promise<KupolaHttpResponse>;
+}
 
-declare function initDevTools(): void;
+declare function configureHttpClient(client: KupolaHttpClient): void;
+declare function getHttpClient(): KupolaHttpClient['fetch'];
+declare function resetHttpClient(): void;
 
-declare function createStore<S extends object = Record<string, unknown>>(name: string, options?: StoreOptions<S>): KupolaStore<S>;
+declare class Scheduler {
+  constructor();
+  schedule(fn: () => void): void;
+}
+
+declare class CacheEntry<T = unknown> {
+  constructor(data: T, ttl: number);
+  readonly data: T;
+  readonly createdAt: number;
+  readonly ttl: number;
+  readonly isFresh: boolean;
+  readonly isStale: boolean;
+}
+
+declare class CacheManager {
+  constructor();
+  get<T = unknown>(key: string): CacheEntry<T> | null;
+  set<T = unknown>(key: string, data: T, ttl?: number): void;
+  has(key: string): boolean;
+  delete(key: string): void;
+  clear(): void;
+  getStale<T = unknown>(key: string): T | null;
+}
+
+declare class DependsError extends Error {
+  constructor(message: string, code: string, cause?: unknown);
+  readonly code: string;
+  readonly cause?: unknown;
+  readonly timestamp: number;
+}
+
+type SourceType = string | ((params: Record<string, unknown>) => unknown | Promise<unknown>);
+
+interface DepsSourceConfig {
+  source: SourceType;
+  cacheKey?: string;
+  staleTime?: number;
+  retry?: number;
+  retryDelay?: number;
+  onError?: (error: DependsError) => void;
+  method?: 'GET' | 'POST' | 'PUT' | 'DELETE';
+  headers?: Record<string, string>;
+  query?: Record<string, string | number | boolean>;
+  default?: unknown;
+  sync?: boolean;
+  reconnect?: boolean;
+  reconnectDelay?: number;
+}
+
+interface DepRef<T = unknown> {
+  data: { value: T | null };
+  loading: { value: boolean };
+  error: { value: string | null };
+  lastUpdated: { value: number | null };
+  refresh(): Promise<void>;
+  setValue?(value: unknown): void;
+  send?(msg: unknown): void;
+}
+
+type DepsConfig = Record<string, DepsSourceConfig | string>;
+type DepsProps = Record<string, unknown | { value: unknown }>;
+type DepsResult<C extends DepsConfig> = {
+  [K in keyof C]: DepRef;
+} & { _dispose(): void };
+
+declare function useDeps<C extends DepsConfig>(props: DepsProps, depsConfig: C): DepsResult<C>;
+
+declare function useQuery<T = unknown>(config: DepsSourceConfig): {
+  data: { value: T | null };
+  loading: { value: boolean };
+  error: { value: string | null };
+  refresh(): Promise<void>;
+};
+
+declare function clearCache(): void;
+
+// ============================================================
+// Table & Pagination Components
+// ============================================================
+
+interface KupolaTableColumn {
+  key: string;
+  title: string;
+  width?: string | number;
+  minWidth?: string | number;
+  align?: 'left' | 'center' | 'right';
+  sortable?: boolean;
+  sorter?: (a: unknown, b: unknown, order?: string) => number;
+  fixed?: 'left' | 'right';
+  render?: (value: unknown, row: unknown, index?: number) => string | HTMLElement;
+  editable?: boolean;
+  editType?: string;
+  editOptions?: Array<{ value: string; label: string }>;
+}
+
+interface KupolaTableTreeOptions {
+  childrenKey?: string;
+  defaultExpandAll?: boolean;
+}
+
+interface KupolaTableVirtualScrollOptions {
+  rowHeight: number;
+  overscan?: number;
+  maxHeight?: string;
+}
+
+interface KupolaTableOptions {
+  columns: KupolaTableColumn[];
+  rowKey?: string;
+  striped?: boolean;
+  bordered?: boolean;
+  hoverable?: boolean;
+  compact?: boolean;
+  pageSize?: number;
+  pageSizes?: number[];
+  emptyText?: string;
+  loadingText?: string;
+  showFilter?: boolean;
+  showToolbar?: boolean;
+  showExport?: boolean;
+  showPageSize?: boolean;
+  selection?: 'checkbox' | 'radio';
+  expandable?: (row: unknown) => string | HTMLElement;
+  editable?: boolean;
+  resizable?: boolean;
+  draggable?: boolean;
+  multiSort?: boolean;
+  tree?: KupolaTableTreeOptions;
+  virtualScroll?: KupolaTableVirtualScrollOptions;
+  mergeCells?: (data: unknown[]) => Array<{ row: number; col: number; rowSpan: number; colSpan: number }>;
+  onSort?: (sorts: Array<{ key: string; order: string }>) => void;
+  onFilter?: (text: string) => void;
+  onRowClick?: (row: unknown, index: number, event: Event) => void;
+  onPageChange?: (page: number, pageSize: number) => void;
+  onSelect?: (selectedKeys: unknown[], selectedRows: unknown[]) => void;
+  onExpand?: (key: unknown, isExpanded: boolean) => void;
+  onEditSave?: (row: unknown, colKey: string, newValue: unknown, allData: unknown[]) => void;
+  onEditCancel?: (editingCell: unknown) => void;
+  onColumnResize?: (colKey: string, newWidth: number) => void;
+  onRowDragEnd?: (movedRow: unknown, fromIndex: number, toIndex: number, newData: unknown[]) => void;
+}
+
+declare class KupolaTable {
+  constructor(element: HTMLElement | string, options?: KupolaTableOptions);
+  setData(data: unknown[] | { value: unknown[] | null }): void;
+  setLoading(loading: boolean): void;
+  setColumns(columns: KupolaTableColumn[]): void;
+  setPageSize(size: number): void;
+  getSortState(): { key: string | null; order: string | null } | Array<{ key: string; order: string }>;
+  getPage(): { current: number; pageSize: number; total: number };
+  refresh(): void;
+  exportCSV(filename?: string): void;
+  selectAll(): void;
+  deselectAll(): void;
+  invertSelection(): void;
+  selectRow(key: unknown): void;
+  deselectRow(key: unknown): void;
+  getSelectedKeys(): unknown[];
+  getSelectedRows(): unknown[];
+  destroy(): void;
+}
+
+declare function initTable(element: HTMLElement | string, options?: KupolaTableOptions): KupolaTable;
+declare function initAllTables(): KupolaTable[];
+
+interface KupolaPaginationOptions {
+  current?: number;
+  total?: number;
+  pageSize?: number;
+  maxPages?: number;
+  showTotal?: boolean;
+  showSizeChanger?: boolean;
+  pageSizes?: number[];
+  simple?: boolean;
+  onChange?: (page: number, pageSize: number) => void;
+}
+
+declare class KupolaPagination {
+  constructor(element: HTMLElement | string, options?: KupolaPaginationOptions);
+  setCurrent(page: number): void;
+  setTotal(total: number): void;
+  setPageSize(size: number): void;
+  destroy(): void;
+}
+
+declare function initPagination(element: HTMLElement | string, options?: KupolaPaginationOptions): KupolaPagination;
 
-declare function getStore<S extends object = Record<string, unknown>>(name: string): KupolaStore<S> | undefined;
 
 declare module 'kupola' {
   export type Primitive = string | number | boolean | null | undefined;
@@ -869,72 +971,6 @@ declare module 'kupola' {
     storage?: 'local' | 'session';
     debounce?: number;
   }
-  export interface RouteConfig {
-    path: string;
-    component: string | (() => Promise<{ default: typeof KupolaComponent } | typeof KupolaComponent>);
-    name?: string;
-    meta?: Record<string, unknown>;
-    children?: RouteConfig[];
-  }
-  export interface RouterOptions {
-    mode?: 'hash' | 'history';
-    routes: RouteConfig[];
-    base?: string;
-  }
-  export interface HttpRequestConfig {
-    url: string;
-    method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
-    headers?: Record<string, string>;
-    params?: Record<string, string | number | boolean>;
-    data?: Record<string, unknown> | unknown[];
-    timeout?: number;
-    withCredentials?: boolean;
-    responseType?: 'json' | 'text' | 'blob' | 'formData';
-  }
-  export interface HttpResponse<T = unknown> {
-    data: T;
-    status: number;
-    statusText: string;
-    headers: Record<string, string>;
-    config: HttpRequestConfig;
-  }
-  export interface HttpError {
-    message: string;
-    code?: number;
-    response?: HttpResponse;
-    config: HttpRequestConfig;
-  }
-  export interface HttpInterceptor {
-    request?: (config: HttpRequestConfig) => HttpRequestConfig | Promise<HttpRequestConfig>;
-    requestError?: (error: unknown) => Promise<never>;
-    response?: <T = unknown>(response: HttpResponse<T>) => HttpResponse<T> | Promise<HttpResponse<T>>;
-    responseError?: (error: HttpError) => Promise<never>;
-  }
-  export interface HttpOptions {
-    baseURL?: string;
-    timeout?: number;
-    headers?: Record<string, string>;
-    interceptors?: HttpInterceptor;
-    cacheTTL?: number;
-    maxRetries?: number;
-    retryDelay?: number;
-  }
-
-  export interface UploadProgress {
-    progress: number;
-    uploaded: number;
-    total: number;
-    currentChunk: number;
-    totalChunks: number;
-  }
-
-  export interface UploadOptions {
-    chunkSize?: number;
-    onProgress?: (progress: UploadProgress) => void;
-    headers?: Record<string, string>;
-    abortController?: AbortController;
-    parallel?: boolean;
-  }
 
   export interface FormState {
     valid: boolean;
@@ -945,19 +981,6 @@ declare module 'kupola' {
     disabled: boolean;
   }
 
-  export interface HttpRequestConfig {
-    url: string;
-    method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
-    headers?: Record<string, string>;
-    params?: Record<string, string | number | boolean>;
-    data?: Record<string, unknown> | unknown[];
-    timeout?: number;
-    withCredentials?: boolean;
-    responseType?: 'json' | 'text' | 'blob' | 'formData';
-    cache?: boolean;
-    retry?: boolean;
-  }
-
   export interface StoreOptions<S extends object = Record<string, unknown>> {
     state?: () => S;
     getters?: Record<string, (state: S) => unknown>;
@@ -1124,51 +1147,7 @@ declare module 'kupola' {
     dispose(): void;
   }
   
-  export class KupolaRouter {
-    constructor(options: RouterOptions);
-    
-    push(path: string): void;
-    replace(path: string): void;
-    go(delta: number): void;
-    back(): void;
-    forward(): void;
-    
-    readonly currentRoute: RouteConfig | null;
-    readonly path: string;
-    readonly params: Record<string, string>;
-    readonly query: Record<string, string>;
-    
-    beforeEach(callback: (to: RouteConfig, from: RouteConfig | null) => boolean | void | Promise<boolean>): void;
-    afterEach(callback: (to: RouteConfig) => void): void;
-    
-    setAnimation(name: string): void;
-    
-    destroy(): void;
-  }
-  
-  export class KupolaHttp {
-    constructor(options?: HttpOptions);
-    
-    get<T = unknown>(url: string, config?: Omit<HttpRequestConfig, 'method' | 'url'>): Promise<HttpResponse<T>>;
-    post<T = unknown>(url: string, data?: HttpRequestConfig['data'], config?: Omit<HttpRequestConfig, 'method' | 'url'>): Promise<HttpResponse<T>>;
-    put<T = unknown>(url: string, data?: HttpRequestConfig['data'], config?: Omit<HttpRequestConfig, 'method' | 'url'>): Promise<HttpResponse<T>>;
-    delete<T = unknown>(url: string, config?: Omit<HttpRequestConfig, 'method' | 'url'>): Promise<HttpResponse<T>>;
-    patch<T = unknown>(url: string, data?: HttpRequestConfig['data'], config?: Omit<HttpRequestConfig, 'method' | 'url'>): Promise<HttpResponse<T>>;
-    
-    uploadFile<T = unknown>(url: string, file: File, options?: UploadOptions): Promise<HttpResponse<T>>;
-    
-    setHeader(name: string, value: string): void;
-    setToken(token: string, type?: string): void;
-    setCacheTTL(ttl: number): void;
-    setMaxRetries(retries: number): void;
-    
-    cancelRequest(url: string, params?: Record<string, string | number | boolean>): boolean;
-    clearCache(): void;
-    clearCacheByUrl(url: string): void;
-    
-    interceptors: HttpInterceptor;
-  }
-  
+
   export interface ComponentMixin {
     [key: string]: unknown;
   }
@@ -1218,37 +1197,7 @@ declare module 'kupola' {
     destroy(): void;
   }
   
-  export interface NetworkRequest {
-    id?: number;
-    method: string;
-    url: string;
-    params?: Record<string, string>;
-    requestBody?: string;
-    status: number;
-    response?: unknown;
-    duration?: number;
-  }
-  
-  export class KupolaDevTools {
-    constructor(options?: { enabled?: boolean });
-    
-    init(): void;
-    togglePanel(): void;
-    switchTab(tabName: 'storage' | 'network'): void;
-    renderStorageContent(): void;
-    renderNetworkContent(): void;
-    clearNetworkHistory(): void;
-    addRequest(entry: NetworkRequest): void;
-    updateRequest(entry: NetworkRequest): void;
-    destroy(): void;
-    
-    enabled: boolean;
-    isOpen: boolean;
-    activeTab: 'storage' | 'network';
-    activeStorageType: 'cookies' | 'localStorage' | 'sessionStorage';
-    requestHistory: NetworkRequest[];
-  }
-  
+
   export class KupolaStatePersist {
     constructor();
     
@@ -1321,6 +1270,8 @@ declare module 'kupola' {
   
   export function setBrand(brand: BrandColor): void;
   export function getBrand(): BrandColor;
+  export function createThemeToggle(): { toggleBtn: HTMLElement; container: HTMLElement };
+  export function createBrandPicker(): { toggleBtn: HTMLElement; container: HTMLElement };
   export const BRAND_OPTIONS: readonly BrandOption[];
   
   export function showToast(options: ToastOptions | string): void;
@@ -1335,10 +1286,6 @@ declare module 'kupola' {
   
   export function showNotification(options: NotificationOptions): void;
   
-  export function createRouter(options: RouterOptions): KupolaRouter;
-  
-  export function createHttp(options?: HttpOptions): KupolaHttp;
-  
   export function registerComponent(name: string, componentClass: typeof KupolaComponent): void;
   
   export function registerLazyComponent(name: string, loader: () => Promise<{ default: typeof KupolaComponent } | typeof KupolaComponent>): void;
@@ -1348,12 +1295,163 @@ declare module 'kupola' {
   export function defineMixin(name: string, mixin: ComponentMixin): void;
   
   export function useMixin(componentClass: typeof KupolaComponent, ...mixinNames: string[]): void;
-  
+
+  export interface DefineComponentOptions {
+    componentClass?: typeof KupolaComponent;
+    lazy?: () => Promise<{ default: typeof KupolaComponent } | typeof KupolaComponent>;
+    init?: (element: HTMLElement) => void | Promise<void>;
+    cleanup?: (element: HTMLElement) => void;
+    dataAttribute?: string;
+    cssClass?: string;
+  }
+  export function defineComponent(name: string, options: DefineComponentOptions): void;
+
+  export function registerWebComponents(): void;
+
+  export class KupolaDropdownElement extends HTMLElement {
+    static get observedAttributes(): string[];
+  }
+  export class KupolaTooltipElement extends HTMLElement {
+    static get observedAttributes(): string[];
+  }
+  export class KupolaCollapseElement extends HTMLElement {}
+  export class KupolaCollapseItemElement extends HTMLElement {
+    static get observedAttributes(): string[];
+  }
+  export class KupolaDrawerElement extends HTMLElement {
+    static get observedAttributes(): string[];
+  }
+  export class KupolaModalElement extends HTMLElement {
+    static get observedAttributes(): string[];
+    open(): void;
+    close(): void;
+  }
+
+  export function createModal(options?: Record<string, unknown>): InstanceType<typeof Modal>;
+  export function confirmModal(options: Record<string, unknown> | string): InstanceType<typeof Modal>;
+  export function alertModal(options: Record<string, unknown> | string): InstanceType<typeof Modal>;
+
+  export function cleanupAllDropdowns(): void;
+  export function cleanupAllSlideCaptchas(): void;
+
+  export function ref<T = unknown>(initialValue?: T): { value: T; _subscribers: Set<Function> };
+
+  export class Modal {
+    constructor(element: HTMLElement, options?: Record<string, unknown>);
+    open(): void;
+    close(): void;
+    toggleFullscreen(): void;
+    isVisible(): boolean;
+    destroy(): void;
+  }
+
   export function createStore<S extends object = Record<string, unknown>>(name: string, options?: StoreOptions<S>): KupolaStore<S>;
   
   export function getStore<S extends object = Record<string, unknown>>(name: string): KupolaStore<S> | undefined;
   
-  export const kupolaDevTools: KupolaDevTools;
-  
-  export function initDevTools(): void;
+  // @kupola/depends
+
+  // HTTP Client Plugin System
+  export interface KupolaHttpResponse {
+    ok: boolean;
+    status: number;
+    statusText?: string;
+    headers: Record<string, string>;
+    url?: string;
+    json(): Promise<any>;
+    text(): Promise<string>;
+  }
+
+  export interface KupolaHttpClient {
+    fetch(url: string, options?: {
+      method?: string;
+      headers?: Record<string, string>;
+      body?: string;
+    }): Promise<KupolaHttpResponse>;
+  }
+
+  export function configureHttpClient(client: KupolaHttpClient): void;
+  export function getHttpClient(): KupolaHttpClient['fetch'];
+  export function resetHttpClient(): void;
+
+  export class Scheduler {
+    constructor();
+    schedule(fn: () => void): void;
+  }
+
+  export class CacheEntry<T = unknown> {
+    constructor(data: T, ttl: number);
+    readonly data: T;
+    readonly createdAt: number;
+    readonly ttl: number;
+    readonly isFresh: boolean;
+    readonly isStale: boolean;
+  }
+
+  export class CacheManager {
+    constructor();
+    get<T = unknown>(key: string): CacheEntry<T> | null;
+    set<T = unknown>(key: string, data: T, ttl?: number): void;
+    has(key: string): boolean;
+    delete(key: string): void;
+    clear(): void;
+    getStale<T = unknown>(key: string): T | null;
+  }
+
+  export class DependsError extends Error {
+    constructor(message: string, code: string, cause?: unknown);
+    readonly code: string;
+    readonly cause?: unknown;
+    readonly timestamp: number;
+  }
+
+  export type SourceType = string | ((params: Record<string, unknown>) => unknown | Promise<unknown>);
+
+  export interface DepsSourceConfig {
+    source: SourceType;
+    cacheKey?: string;
+    staleTime?: number;
+    retry?: number;
+    retryDelay?: number;
+    onError?: (error: DependsError) => void;
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    headers?: Record<string, string>;
+    query?: Record<string, string | number | boolean>;
+    default?: unknown;
+    sync?: boolean;
+    reconnect?: boolean;
+    reconnectDelay?: number;
+  }
+
+  export interface DepRef<T = unknown> {
+    data: { value: T | null };
+    loading: { value: boolean };
+    error: { value: string | null };
+    lastUpdated: { value: number | null };
+    refresh(): Promise<void>;
+    setValue?(value: unknown): void;
+    send?(msg: unknown): void;
+  }
+
+  export type DepsConfig = Record<string, DepsSourceConfig | string>;
+  export type DepsProps = Record<string, unknown | { value: unknown }>;
+  export type DepsResult<C extends DepsConfig> = {
+    [K in keyof C]: DepRef;
+  } & { _dispose(): void };
+
+  export function useDeps<C extends DepsConfig>(props: DepsProps, depsConfig: C): DepsResult<C>;
+
+  export function useQuery<T = unknown>(config: DepsSourceConfig): {
+    data: { value: T | null };
+    loading: { value: boolean };
+    error: { value: string | null };
+    refresh(): Promise<void>;
+  };
+
+  export function clearCache(): void;
+
+  // Table & Pagination
+  export { KupolaTable, KupolaTableColumn, KupolaTableOptions, KupolaPagination, KupolaPaginationOptions };
+  export { initTable, initAllTables, initPagination };
+
 }