ngx-pk-ui 0.0.1

package/types/ngx-pk-ui.d.ts

@@ -0,0 +1,665 @@
+import * as i0 from '@angular/core';
+import { TemplateRef, AfterContentInit, AfterViewInit, ElementRef, ChangeDetectorRef, OnInit, EventEmitter, ViewContainerRef, DoCheck, OnChanges, OnDestroy, QueryList, SimpleChanges } from '@angular/core';
+import { SafeHtml } from '@angular/platform-browser';
+import * as i10 from '@angular/common';
+import * as i11 from '@angular/forms';
+import { ControlValueAccessor } from '@angular/forms';
+import * as rxjs from 'rxjs';
+import { Observable } from 'rxjs';
+
+declare class PkTab {
+    label: i0.InputSignal<string>;
+    disabled: i0.InputSignal<boolean>;
+    content: i0.Signal<TemplateRef<unknown>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PkTab, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PkTab, "pk-tab", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class PkTabs implements AfterContentInit {
+    tabs: i0.Signal<readonly PkTab[]>;
+    activeIndex: i0.WritableSignal<number>;
+    ngAfterContentInit(): void;
+    selectTab(index: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PkTabs, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PkTabs, "pk-tabs", never, {}, {}, ["tabs"], never, true, never>;
+}
+
+type ToastType = 'success' | 'error' | 'info' | 'warning';
+interface Toast {
+    id: number;
+    type: ToastType;
+    message: string;
+    title?: string;
+    duration: number;
+}
+
+declare class PkToastrService {
+    private _counter;
+    toasts: i0.WritableSignal<Toast[]>;
+    show(type: ToastType, message: string, title?: string, duration?: number): void;
+    success(message: string, title?: string, duration?: number): void;
+    error(message: string, title?: string, duration?: number): void;
+    info(message: string, title?: string, duration?: number): void;
+    warning(message: string, title?: string, duration?: number): void;
+    dismiss(id: number): void;
+    clear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PkToastrService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PkToastrService>;
+}
+
+declare class PkToastr {
+    toastr: PkToastrService;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PkToastr, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PkToastr, "pk-toastr", never, {}, {}, never, never, true, never>;
+}
+
+type AlertType = 'success' | 'warn' | 'error' | 'confirm' | 'input';
+type AlertInputType = 'string' | 'number' | 'date' | 'boolean';
+interface AlertConfig {
+    type: AlertType;
+    title?: string;
+    message: string;
+    /** Only relevant when type === 'input' */
+    inputType?: AlertInputType;
+    /** Pre-filled value for input dialogs */
+    defaultValue?: string | number | boolean | null;
+    confirmLabel?: string;
+    cancelLabel?: string;
+}
+/** Resolved value of an alert:
+ *  - success / warn / error  → void (undefined)
+ *  - confirm                 → boolean
+ *  - input                   → string | number | boolean | null  (null = cancelled)
+ */
+type AlertResult = void | boolean | string | number | null;
+/** Internal slot kept in the service signal */
+interface AlertSlot {
+    config: AlertConfig;
+    resolve: (value: AlertResult) => void;
+}
+
+declare class PkAlertService {
+    /** The component reads this signal to know what (if anything) to display. */
+    readonly slot: i0.WritableSignal<AlertSlot | null>;
+    private _open;
+    success(message: string, title?: string): Promise<void>;
+    warn(message: string, title?: string): Promise<void>;
+    error(message: string, title?: string): Promise<void>;
+    confirm(message: string, title?: string, confirmLabel?: string, cancelLabel?: string): Promise<boolean>;
+    input(message: string, inputType?: AlertInputType, title?: string, defaultValue?: string | number | boolean | null): Promise<string | number | boolean | null>;
+    /** Called by the component after the user makes a choice. */
+    _resolve(value: AlertResult): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PkAlertService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PkAlertService>;
+}
+
+declare class PkAlert {
+    svc: PkAlertService;
+    /** Local copy of input value while the dialog is open */
+    inputValue: i0.WritableSignal<string | number | boolean | null>;
+    constructor();
+    confirm(): void;
+    cancel(): void;
+    private _defaultFor;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PkAlert, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PkAlert, "pk-alert", never, {}, {}, never, never, true, never>;
+}
+
+type PkModalSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl' | 'full';
+type PkModalTheme = 'none' | 'white' | 'success' | 'warn' | 'error' | 'sky' | 'blue' | 'gray';
+
+declare class PkModalHeader {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PkModalHeader, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PkModalHeader, "pk-modal-header", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class PkModalBody {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PkModalBody, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PkModalBody, "pk-modal-body", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class PkModalFooter {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PkModalFooter, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PkModalFooter, "pk-modal-footer", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class PkModal {
+    openModal: i0.InputSignal<boolean>;
+    customStyle: i0.InputSignal<Record<string, string> | null>;
+    customClass: i0.InputSignal<string | null>;
+    blur: i0.InputSignal<boolean>;
+    size: i0.InputSignal<PkModalSize>;
+    theme: i0.InputSignal<PkModalTheme>;
+    closeAny: i0.InputSignal<boolean>;
+    closeMarker: i0.InputSignal<boolean>;
+    onClose: i0.OutputEmitterRef<void>;
+    readonly dialogClass: i0.Signal<string>;
+    close(): void;
+    onOverlayClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PkModal, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PkModal, "pk-modal", never, { "openModal": { "alias": "openModal"; "required": false; "isSignal": true; }; "customStyle": { "alias": "customStyle"; "required": false; "isSignal": true; }; "customClass": { "alias": "customClass"; "required": false; "isSignal": true; }; "blur": { "alias": "blur"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "theme": { "alias": "theme"; "required": false; "isSignal": true; }; "closeAny": { "alias": "closeAny"; "required": false; "isSignal": true; }; "closeMarker": { "alias": "closeMarker"; "required": false; "isSignal": true; }; }, { "onClose": "onClose"; }, never, ["pk-modal-header", "pk-modal-body", "pk-modal-footer", "*"], true, never>;
+}
+
+type PkIconName = 'search' | 'menu' | 'user' | 'users' | 'profile' | 'close' | 'sort' | 'login' | 'logout' | 'map' | 'map-point' | 'folder-close' | 'folder-open' | 'document' | 'report' | 'chart-pie' | 'chart-bar' | 'dashboard' | 'database' | 'cog' | 'setting' | 'email' | 'upload' | 'download' | 'export' | 'import' | 'csv' | 'xls' | 'pdf' | 'text' | 'link' | 'unlink' | 'reload' | 'phone' | 'check-mark' | 'check-mark-circle' | 'shield' | 'server' | 'eye' | 'eye-off' | 'plus' | 'pencil' | 'save' | 'trash' | 'list' | 'clock' | 'calendar' | 'venn' | 'ambulance' | 'car' | 'car-crash' | 'bed' | 'xray' | 'lab' | 'print' | 'time' | 'wait' | 'success' | 'warning' | 'error' | 'question' | 'youtube' | 'facebook' | 'line' | 'telegram' | 'wechat' | 'linkedin';
+type PkIconSet = 'pk' | 'material-symbols';
+type PkMaterialSymbolVariant = 'outlined' | 'rounded' | 'sharp';
+type PkMaterialSymbolWeight = 100 | 200 | 300 | 400 | 500 | 600 | 700;
+type PkMaterialSymbolGrade = -25 | 0 | 200;
+type PkMaterialSymbolOpticalSize = 20 | 24 | 40 | 48;
+declare const PK_ICONS: Record<PkIconName, string>;
+
+declare class PkIcon {
+    name: i0.InputSignal<string>;
+    iconSet: i0.InputSignal<PkIconSet>;
+    size: i0.InputSignal<number>;
+    color: i0.InputSignal<string>;
+    fillColor: i0.InputSignal<string>;
+    viewBox: i0.InputSignal<string>;
+    strokeWidth: i0.InputSignal<number>;
+    variant: i0.InputSignal<PkMaterialSymbolVariant>;
+    fill: i0.InputSignal<0 | 1>;
+    weight: i0.InputSignal<PkMaterialSymbolWeight>;
+    grade: i0.InputSignal<PkMaterialSymbolGrade>;
+    opticalSize: i0.InputSignal<PkMaterialSymbolOpticalSize>;
+    private sanitizer;
+    svgHtml: i0.Signal<SafeHtml>;
+    materialVariantClass: i0.Signal<string>;
+    materialVariationSettings: i0.Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PkIcon, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PkIcon, "pk-icon", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; "iconSet": { "alias": "iconSet"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "fillColor": { "alias": "fillColor"; "required": false; "isSignal": true; }; "viewBox": { "alias": "viewBox"; "required": false; "isSignal": true; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "fill": { "alias": "fill"; "required": false; "isSignal": true; }; "weight": { "alias": "weight"; "required": false; "isSignal": true; }; "grade": { "alias": "grade"; "required": false; "isSignal": true; }; "opticalSize": { "alias": "opticalSize"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class PkDgColumnComponent implements AfterViewInit {
+    private el;
+    pkDgField?: string;
+    pkDgFilterKey?: string;
+    widthPx?: number;
+    width?: string;
+    headerText: string;
+    constructor(el: ElementRef);
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PkDgColumnComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PkDgColumnComponent, "pk-dg-column", never, { "pkDgField": { "alias": "pkDgField"; "required": false; }; "pkDgFilterKey": { "alias": "pkDgFilterKey"; "required": false; }; "widthPx": { "alias": "style.width.px"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class PkDgPageSizeComponent {
+    private cdr;
+    pkPageSizeOptions: number[];
+    pagination: PkDgPaginationComponent | null;
+    constructor(cdr: ChangeDetectorRef);
+    setPagination(p: PkDgPaginationComponent): void;
+    get currentSize(): number;
+    onChange(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PkDgPageSizeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PkDgPageSizeComponent, "pk-dg-page-size", never, { "pkPageSizeOptions": { "alias": "pkPageSizeOptions"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class PkDgPaginationComponent implements OnInit, AfterContentInit {
+    pageSize?: PkDgPageSizeComponent;
+    pkDgPageSize: number;
+    totalItems: number;
+    pkDgPageChange: EventEmitter<number>;
+    pkDgPageSizeChange: EventEmitter<number>;
+    currentPage: number;
+    firstItem: number;
+    lastItem: number;
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    ngOnChanges(): void;
+    updatePagination(): void;
+    get totalPages(): number;
+    goToPage(page: number): void;
+    onPageSizeChange(size: number): void;
+    get pages(): number[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<PkDgPaginationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PkDgPaginationComponent, "pk-dg-pagination", never, { "pkDgPageSize": { "alias": "pkDgPageSize"; "required": false; }; "totalItems": { "alias": "totalItems"; "required": false; }; }, { "pkDgPageChange": "pkDgPageChange"; "pkDgPageSizeChange": "pkDgPageSizeChange"; }, ["pageSize"], ["*"], false, never>;
+}
+
+declare class PkDgRowComponent {
+    pkDgItem: any;
+    detailTemplate?: TemplateRef<any>;
+    isExpanded: boolean;
+    hasDetail: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PkDgRowComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PkDgRowComponent, "pk-dg-row", never, { "pkDgItem": { "alias": "pkDgItem"; "required": false; }; }, {}, ["detailTemplate"], ["*", "pk-dg-row-detail"], false, never>;
+}
+
+declare class PkDgRowDetailComponent implements OnInit {
+    row?: PkDgRowComponent | undefined;
+    constructor(row?: PkDgRowComponent | undefined);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PkDgRowDetailComponent, [{ optional: true; host: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PkDgRowDetailComponent, "pk-dg-row-detail", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class PkDgItemsDirective implements DoCheck {
+    private templateRef;
+    private viewContainer;
+    private datagrid?;
+    private _items;
+    private _lastVersion;
+    constructor(templateRef: TemplateRef<any>, viewContainer: ViewContainerRef, datagrid?: PkDatagridComponent | undefined);
+    ngDoCheck(): void;
+    set pkDgItemsOf(items: any[]);
+    private renderItems;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PkDgItemsDirective, [null, null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PkDgItemsDirective, "[pkDgItems]", never, { "pkDgItemsOf": { "alias": "pkDgItemsOf"; "required": false; }; }, {}, never, never, false, never>;
+}
+declare class PkIfExpandedDirective {
+    private templateRef;
+    private viewContainer;
+    private row?;
+    constructor(templateRef: TemplateRef<any>, viewContainer: ViewContainerRef, row?: PkDgRowComponent | undefined);
+    ngAfterViewInit(): void;
+    ngDoCheck(): void;
+    private updateView;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PkIfExpandedDirective, [null, null, { optional: true; host: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PkIfExpandedDirective, "[pkIfExpanded]", never, {}, {}, never, never, false, never>;
+}
+declare class NowrapDirective {
+    nowrap: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NowrapDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NowrapDirective, "[nowrap]", never, {}, {}, never, never, false, never>;
+}
+
+declare class PkDatagridComponent implements AfterContentInit, AfterViewInit, OnChanges, OnDestroy {
+    private cdr;
+    columns: QueryList<PkDgColumnComponent>;
+    pagination?: PkDgPaginationComponent;
+    rowDetails: QueryList<PkDgRowDetailComponent>;
+    expandDirectives: QueryList<PkIfExpandedDirective>;
+    get hasExpandCol(): boolean;
+    pkDgLoading: boolean;
+    items: any[];
+    filterValues: Record<string, string>;
+    pkDgRefresh: EventEmitter<void>;
+    filterChange: EventEmitter<{
+        key: string;
+        value: string;
+    }>;
+    displayedItems: any[];
+    displayedItemsVersion: number;
+    expandedRows: Set<any>;
+    sortColumn: string | null;
+    sortDirection: 'asc' | 'desc' | null;
+    activeFilterCol: string | null;
+    activeFilterHeader: string;
+    filterPopupPos: {
+        top: number;
+        left: number;
+    };
+    columnWidths: number[];
+    private _resizingIdx;
+    private _resizeStartX;
+    private _resizeStartWidth;
+    private _resizeMoveRef;
+    private _resizeEndRef;
+    get totalWidth(): number;
+    private _initColumnWidths;
+    onDocumentClick(): void;
+    constructor(cdr: ChangeDetectorRef);
+    ngAfterContentInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    updateDisplayedItems(): void;
+    onSort(field: string): void;
+    getSortIcon(field: string): string;
+    toggleRowExpansion(row: any): void;
+    isRowExpanded(row: any): boolean;
+    openFilter(key: string, event: MouseEvent, headerText?: string): void;
+    onFilterInput(key: string, event: Event): void;
+    startResize(colIdx: number, event: MouseEvent): void;
+    private _onResizeMove;
+    private _onResizeEnd;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PkDatagridComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PkDatagridComponent, "pk-datagrid", never, { "pkDgLoading": { "alias": "pkDgLoading"; "required": false; }; "items": { "alias": "items"; "required": false; }; "filterValues": { "alias": "filterValues"; "required": false; }; }, { "pkDgRefresh": "pkDgRefresh"; "filterChange": "filterChange"; }, ["pagination", "columns", "rowDetails", "expandDirectives"], ["pk-dg-row", "pk-dg-footer"], false, never>;
+}
+
+declare class PkDgCellComponent {
+    set nowrap(value: boolean);
+    get nowrap(): boolean;
+    _nowrap: boolean;
+    tdStyle: {
+        [key: string]: string;
+    } | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PkDgCellComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PkDgCellComponent, "pk-dg-cell", never, { "nowrap": { "alias": "nowrap"; "required": false; }; "tdStyle": { "alias": "tdStyle"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class PkDgFooterComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PkDgFooterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PkDgFooterComponent, "pk-dg-footer", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class PkDatagridModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PkDatagridModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PkDatagridModule, [typeof PkDatagridComponent, typeof PkDgColumnComponent, typeof PkDgRowComponent, typeof PkDgCellComponent, typeof PkDgFooterComponent, typeof PkDgPaginationComponent, typeof PkDgPageSizeComponent, typeof PkDgRowDetailComponent, typeof PkDgItemsDirective, typeof PkIfExpandedDirective, typeof NowrapDirective], [typeof i10.CommonModule, typeof i11.FormsModule, typeof PkIcon], [typeof PkDatagridComponent, typeof PkDgColumnComponent, typeof PkDgRowComponent, typeof PkDgCellComponent, typeof PkDgFooterComponent, typeof PkDgPaginationComponent, typeof PkDgPageSizeComponent, typeof PkDgRowDetailComponent, typeof PkDgItemsDirective, typeof PkIfExpandedDirective, typeof NowrapDirective, typeof PkIcon]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<PkDatagridModule>;
+}
+
+declare class DatepickerService {
+    private activeDatepicker;
+    openDatepicker(component: PkDatepickerComponent): void;
+    getActiveDatepicker(): rxjs.Observable<PkDatepickerComponent | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatepickerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DatepickerService>;
+}
+
+interface Holiday {
+    date: Date;
+    title: string;
+}
+declare class HolidayService {
+    constructor();
+    getHolidays(year: number): Observable<Holiday[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HolidayService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HolidayService>;
+}
+
+declare class PkDatepickerComponent implements ControlValueAccessor, OnInit, OnDestroy {
+    private elementRef;
+    private datepickerService;
+    private holidayService;
+    disabled: boolean;
+    setNull: boolean;
+    dateInput: boolean;
+    locale: string;
+    minDate: Date | null;
+    maxDate: Date | null;
+    startOfWeek: 'monday' | 'sunday';
+    style: string | null;
+    placeholder: string;
+    onDateChange: EventEmitter<Date | null>;
+    private holidays;
+    private innerValue;
+    isOpen: boolean;
+    currentMonth: Date;
+    daysInMonth: Date[];
+    weekdays: string[];
+    months: {
+        name: string;
+        value: number;
+    }[];
+    years: number[];
+    selectedMonth: number;
+    selectedYear: number;
+    dropdownStyles: Record<string, string>;
+    private onChange;
+    private onTouched;
+    private subscription?;
+    get localeMode(): 'TH' | 'EN';
+    constructor(elementRef: ElementRef, datepickerService: DatepickerService, holidayService: HolidayService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onClickOutside(event: Event): void;
+    onWindowResize(): void;
+    onWindowScroll(): void;
+    get value(): Date | null;
+    set value(val: Date | null);
+    get formattedDate(): string;
+    get currentMonthYear(): string;
+    get isTodayDisabled(): boolean;
+    get canGoPrevMonth(): boolean;
+    get canGoNextMonth(): boolean;
+    updateCalendar(): void;
+    generateMonths(): void;
+    generateYears(): void;
+    fetchHolidays(year: number): void;
+    onMonthChange(month: number): void;
+    onYearChange(year: number): void;
+    onChangeDate(event: any): void;
+    resetDate(): void;
+    prevMonth(): void;
+    nextMonth(): void;
+    selectToday(): void;
+    writeValue(value: Date | null): void;
+    registerOnChange(fn: (value: Date | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onDateSelect(date: Date): void;
+    togglePicker(event: Event): void;
+    private updateDropdownPosition;
+    isSelected(date: Date): boolean;
+    isCurrentMonth(date: Date): boolean;
+    isDateInRange(date: Date | null): boolean;
+    isMonthDisabled(month: number): boolean;
+    isWeekend(date: Date): boolean;
+    isExplicitHoliday(date: Date): boolean;
+    getHolidayTitle(date: Date): string;
+    adjustCurrentMonthToRange(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PkDatepickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PkDatepickerComponent, "pk-datepicker", never, { "disabled": { "alias": "disabled"; "required": false; }; "setNull": { "alias": "setNull"; "required": false; }; "dateInput": { "alias": "dateInput"; "required": false; }; "locale": { "alias": "locale"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "startOfWeek": { "alias": "startOfWeek"; "required": false; }; "style": { "alias": "style"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; }, { "onDateChange": "onDateChange"; }, never, never, true, never>;
+}
+
+type ProgressType = 'line' | 'circle';
+type ProgressStatus = 'normal' | 'success' | 'error' | 'warning';
+interface ProgressConfig {
+    type?: ProgressType;
+    percent?: number;
+    status?: ProgressStatus;
+    showInfo?: boolean;
+    strokeWidth?: number;
+    striped?: boolean;
+    animated?: boolean;
+    indeterminate?: boolean;
+    label?: string;
+    color?: string;
+}
+
+declare class PkProgressComponent {
+    config: i0.InputSignal<ProgressConfig>;
+    circleSize: i0.Signal<number>;
+    radius: i0.Signal<number>;
+    circumference: i0.Signal<number>;
+    offset: i0.Signal<number>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PkProgressComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PkProgressComponent, "pk-progress", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type TreeSelectionMode = 'none' | 'single' | 'multi';
+interface TreeNode {
+    /** Unique key (auto-assigned if omitted) */
+    key?: string;
+    label: string;
+    /** icon name for pk-icon */
+    icon?: string;
+    /** route for RouterLink */
+    routerLink?: string | string[];
+    data?: any;
+    children?: TreeNode[];
+    /** Runtime state — do not set manually */
+    _selected?: boolean;
+    _indeterminate?: boolean;
+    _expanded?: boolean;
+}
+
+declare class PkTreeviewComponent implements OnChanges {
+    private cdr;
+    /** Tree data */
+    nodes: TreeNode[];
+    /** 'none' | 'single' | 'multi' */
+    selection: TreeSelectionMode;
+    /** Show "เลือกทั้งหมด" row (multi only) */
+    showSelectAll: boolean;
+    /** Initially expanded depth (0 = root collapsed) */
+    expandDepth: number;
+    selected: EventEmitter<TreeNode[]>;
+    nodeToggle: EventEmitter<TreeNode>;
+    allSelected: boolean;
+    someSelected: boolean;
+    constructor(cdr: ChangeDetectorRef);
+    ngOnChanges(changes: SimpleChanges): void;
+    private initKeys;
+    private expandToDepth;
+    toggleSelectAll(): void;
+    onNodeToggled(node: TreeNode): void;
+    onSelectionChanged(selectedNodes: TreeNode[]): void;
+    private setAll;
+    /** Returns true=all-selected, false=none, 'indeterminate'=some */
+    private updateParentStates;
+    private updateSelectAllState;
+    private calcSelectState;
+    private getAllLeafs;
+    private getSelected;
+    /** Public API: get currently selected nodes */
+    getSelection(): TreeNode[];
+    /** Public API: clear all selection */
+    clearSelection(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PkTreeviewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PkTreeviewComponent, "pk-treeview", never, { "nodes": { "alias": "nodes"; "required": false; }; "selection": { "alias": "selection"; "required": false; }; "showSelectAll": { "alias": "showSelectAll"; "required": false; }; "expandDepth": { "alias": "expandDepth"; "required": false; }; }, { "selected": "selected"; "nodeToggle": "nodeToggle"; }, never, never, true, never>;
+}
+
+declare class PkTreeviewNodeComponent {
+    nodes: TreeNode[];
+    selection: TreeSelectionMode;
+    nodeToggled: EventEmitter<TreeNode>;
+    selectionChanged: EventEmitter<TreeNode[]>;
+    toggleExpand(node: TreeNode, e: Event): void;
+    onRowClick(node: TreeNode, e: Event): void;
+    onCheckClick(node: TreeNode, e: Event): void;
+    private clearAllSelection;
+    private setNodeAndChildren;
+    private getSelected;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PkTreeviewNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PkTreeviewNodeComponent, "pk-treeview-node", never, { "nodes": { "alias": "nodes"; "required": false; }; "selection": { "alias": "selection"; "required": false; }; }, { "nodeToggled": "nodeToggled"; "selectionChanged": "selectionChanged"; }, never, never, true, never>;
+}
+
+declare class PkTreeviewModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PkTreeviewModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PkTreeviewModule, never, [typeof PkTreeviewComponent, typeof PkTreeviewNodeComponent], [typeof PkTreeviewComponent, typeof PkTreeviewNodeComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<PkTreeviewModule>;
+}
+
+interface SelectOption {
+    label?: string;
+    value?: string | number;
+    disabled?: boolean;
+    [key: string]: any;
+}
+type SelectMode = 'single' | 'multi';
+
+declare class PkSelectComponent implements ControlValueAccessor {
+    private elementRef;
+    options: i0.InputSignal<SelectOption[]>;
+    mode: i0.InputSignal<SelectMode>;
+    placeholder: i0.InputSignal<string>;
+    searchable: i0.InputSignal<boolean>;
+    disabled: i0.InputSignal<boolean>;
+    labelField: i0.InputSignal<string>;
+    valueField: i0.InputSignal<string>;
+    returnObjects: i0.InputSignal<boolean>;
+    change: i0.OutputEmitterRef<any>;
+    isOpen: i0.WritableSignal<boolean>;
+    searchQuery: i0.WritableSignal<string>;
+    selectedValues: i0.WritableSignal<(string | number)[]>;
+    private onChange;
+    private onTouched;
+    filteredOptions: i0.Signal<SelectOption[]>;
+    displayValue: i0.Signal<string>;
+    toggleDropdown(): void;
+    selectOption(option: SelectOption): void;
+    isSelected(value: string | number): boolean;
+    onSearchInput(event: Event): void;
+    onDocumentClick(event: MouseEvent): void;
+    onCheckboxClick(option: SelectOption, event: MouseEvent): void;
+    private emitValue;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    private getOptionLabel;
+    getOptionValue(option: SelectOption): string | number;
+    private extractIncomingValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PkSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PkSelectComponent, "pk-select", never, { "options": { "alias": "options"; "required": true; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "searchable": { "alias": "searchable"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "labelField": { "alias": "labelField"; "required": false; "isSignal": true; }; "valueField": { "alias": "valueField"; "required": false; "isSignal": true; }; "returnObjects": { "alias": "returnObjects"; "required": false; "isSignal": true; }; }, { "change": "change"; }, never, never, true, never>;
+}
+
+interface AutocompleteOption {
+    label: string;
+    value: any;
+    disabled?: boolean;
+    [key: string]: any;
+}
+type AutocompleteFetchFn = (searchTerm: string) => Promise<AutocompleteOption[]>;
+
+declare class PkAutocompleteComponent implements ControlValueAccessor {
+    private elementRef;
+    options: i0.InputSignal<AutocompleteOption[]>;
+    fetchFn: i0.InputSignal<AutocompleteFetchFn | null>;
+    placeholder: i0.InputSignal<string>;
+    minChars: i0.InputSignal<number>;
+    debounceTime: i0.InputSignal<number>;
+    disabled: i0.InputSignal<boolean>;
+    displayKey: i0.InputSignal<string>;
+    searchTerm: i0.WritableSignal<string>;
+    isOpen: i0.WritableSignal<boolean>;
+    loading: i0.WritableSignal<boolean>;
+    highlightedIndex: i0.WritableSignal<number>;
+    selectedValue: i0.WritableSignal<any>;
+    fetchedOptions: i0.WritableSignal<AutocompleteOption[]>;
+    private debounceTimer;
+    private onChange;
+    private onTouched;
+    constructor();
+    filteredOptions: i0.Signal<AutocompleteOption[]>;
+    displayValue: i0.Signal<string>;
+    onClickOutside(event: MouseEvent): void;
+    onInput(event: Event): void;
+    onFocus(): void;
+    onKeyDown(event: KeyboardEvent): void;
+    performSearch(term: string): Promise<void>;
+    selectOption(option: AutocompleteOption): void;
+    clear(): void;
+    close(): void;
+    isSelected(option: AutocompleteOption): boolean;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PkAutocompleteComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PkAutocompleteComponent, "pk-autocomplete", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "fetchFn": { "alias": "fetchFn"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "minChars": { "alias": "minChars"; "required": false; "isSignal": true; }; "debounceTime": { "alias": "debounceTime"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "displayKey": { "alias": "displayKey"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class PkTypeaheadComponent implements ControlValueAccessor {
+    private elementRef;
+    items: any[];
+    placeholder: string;
+    disabled: boolean;
+    style: string;
+    customClass: string;
+    customStyle: {
+        [key: string]: string;
+    };
+    labelField: string;
+    valueField: string;
+    allowCustomValue: boolean;
+    maxItems: number;
+    minChars: number;
+    itemSelected: EventEmitter<any>;
+    value: string;
+    isOpen: boolean;
+    highlightedIndex: number;
+    onChange: (value: any) => void;
+    onTouch: () => void;
+    constructor(elementRef: ElementRef);
+    get filteredItems(): any[];
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    onInput(event: Event): void;
+    onFocus(): void;
+    onBlur(): void;
+    onKeydown(event: KeyboardEvent): void;
+    selectItem(item: any): void;
+    getItemLabel(item: any): string;
+    getItemValue(item: any): string;
+    trackByItem(_: number, item: any): string;
+    onDocumentClick(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PkTypeaheadComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PkTypeaheadComponent, "pk-typeahead", never, { "items": { "alias": "items"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "style": { "alias": "style"; "required": false; }; "customClass": { "alias": "customClass"; "required": false; }; "customStyle": { "alias": "customStyle"; "required": false; }; "labelField": { "alias": "labelField"; "required": false; }; "valueField": { "alias": "valueField"; "required": false; }; "allowCustomValue": { "alias": "allowCustomValue"; "required": false; }; "maxItems": { "alias": "maxItems"; "required": false; }; "minChars": { "alias": "minChars"; "required": false; }; }, { "itemSelected": "itemSelected"; }, never, never, true, never>;
+}
+
+export { DatepickerService, HolidayService, NowrapDirective, PK_ICONS, PkAlert, PkAlertService, PkAutocompleteComponent, PkDatagridComponent, PkDatagridModule, PkDatepickerComponent, PkDgCellComponent, PkDgColumnComponent, PkDgFooterComponent, PkDgItemsDirective, PkDgPageSizeComponent, PkDgPaginationComponent, PkDgRowComponent, PkDgRowDetailComponent, PkIcon, PkIfExpandedDirective, PkModal, PkModalBody, PkModalFooter, PkModalHeader, PkProgressComponent, PkSelectComponent, PkTab, PkTabs, PkToastr, PkToastrService, PkTreeviewComponent, PkTreeviewModule, PkTreeviewNodeComponent, PkTypeaheadComponent };
+export type { AlertConfig, AlertInputType, AlertResult, AlertSlot, AlertType, AutocompleteFetchFn, AutocompleteOption, PkIconName, PkIconSet, PkMaterialSymbolGrade, PkMaterialSymbolOpticalSize, PkMaterialSymbolVariant, PkMaterialSymbolWeight, PkModalSize, PkModalTheme, ProgressConfig, ProgressStatus, ProgressType, SelectMode, SelectOption, Toast, ToastType, TreeNode, TreeSelectionMode };