import { AllowedComponentProps } from 'vue';
import { AsTag } from 'reka-ui';
import { CellClickedEvent } from 'ag-grid-community';
import { CellValueChangedEvent } from 'ag-grid-community';
import { ClassProp } from 'class-variance-authority/types';
import { ColDef } from 'ag-grid-community';
import { Component } from 'vue';
import { ComponentCustomProperties } from 'vue';
import { ComponentCustomProps } from 'vue';
import { ComponentInternalInstance } from 'vue';
import { ComponentOptionsBase } from 'vue';
import { ComponentOptionsMixin } from 'vue';
import { ComponentProvideOptions } from 'vue';
import { ComponentPublicInstance } from 'vue';
import { ComputedRef } from 'vue';
import { CreateComponentPublicInstanceWithMixins } from 'vue';
import { DebuggerEvent } from 'vue';
import { DefineComponent } from 'vue';
import { DefineSetupFnComponent } from 'vue';
import { GlobalComponents } from 'vue';
import { GlobalDirectives } from 'vue';
import { GridReadyEvent } from 'ag-grid-community';
import { HTMLAttributes } from 'vue';
import { default as JLayoutAdvanced } from './JLayoutAdvanced.vue';
import { toast as JToast } from 'vue-sonner';
import { nextTick } from 'vue';
import { OnCleanup } from '@vue/reactivity';
import { PublicProps } from 'vue';
import { Ref } from 'vue';
import { RowClickedEvent } from 'ag-grid-community';
import { RowDoubleClickedEvent } from 'ag-grid-community';
import { SelectionChangedEvent } from 'ag-grid-community';
import { ShallowUnwrapRef } from 'vue';
import { SheetSide } from './SheetContent.vue';
import { Slot } from 'vue';
import { SplitterPanelProps } from 'reka-ui';
import { ToasterProps } from 'vue-sonner';
import { useBreakpoint } from './composables/useBreakpoint';
import { VariantProps } from 'class-variance-authority';
import { VNodeProps } from 'vue';
import { WatchOptions } from 'vue';
import { WatchStopHandle } from 'vue';

declare const __VLS_component: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: MouseEvent) => any;
}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
onClick?: ((event: MouseEvent) => any) | undefined;
}>, {
disabled: boolean;
type: "button" | "submit" | "reset";
loading: boolean;
styletype: StyleType;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_10: DefineComponent<__VLS_Props_27, {
clearError: () => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (value: any) => any;
search: () => any;
change: (value: any) => any;
focus: (event: FocusEvent) => any;
blur: (event: FocusEvent) => any;
save: (value: string) => any;
}, string, PublicProps, Readonly<__VLS_Props_27> & Readonly<{
"onUpdate:modelValue"?: ((value: any) => any) | undefined;
onSearch?: (() => any) | undefined;
onChange?: ((value: any) => any) | undefined;
onFocus?: ((event: FocusEvent) => any) | undefined;
onBlur?: ((event: FocusEvent) => any) | undefined;
onSave?: ((value: string) => any) | undefined;
}>, {
orientation: "vertical" | "horizontal" | "responsive";
type: ComponentType;
labelAlign: "left" | "middle" | "right";
labelWidth: string;
radioDirection: "horizontal" | "vertical";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

declare const __VLS_component_11: DefineComponent<JTabsProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
tabChange: (id: string) => any;
tabClose: (id: string) => any;
"update:activeTabId": (id: string) => any;
}, string, PublicProps, Readonly<JTabsProps> & Readonly<{
onTabChange?: ((id: string) => any) | undefined;
onTabClose?: ((id: string) => any) | undefined;
"onUpdate:activeTabId"?: ((id: string) => any) | undefined;
}>, {
styletype: "default" | "minimal";
keepAlive: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_12: DefineComponent<JContextMenuProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
select: (itemId: string) => any;
open: () => any;
close: () => any;
}, string, PublicProps, Readonly<JContextMenuProps> & Readonly<{
onSelect?: ((itemId: string) => any) | undefined;
onOpen?: (() => any) | undefined;
onClose?: (() => any) | undefined;
}>, {
disabled: boolean;
items: ContextMenuGroup[];
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_13: DefineComponent<__VLS_Props_31, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_31> & Readonly<{}>, {
variant: CardVariant;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

declare const __VLS_component_14: DefineComponent<__VLS_Props_32, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
confirm: () => any;
}, string, PublicProps, Readonly<__VLS_Props_32> & Readonly<{
onConfirm?: (() => any) | undefined;
}>, {
variant: "default" | "destructive";
buttonText: string;
showFooter: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

declare const __VLS_component_15: DefineSetupFnComponent<Record<string, any>, {}, {}, Record<string, any> & {}, PublicProps>;

declare const __VLS_component_16: DefineComponent<__VLS_Props_33, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
buttonClick: (button: TitlebarButton) => any;
help: () => any;
}, string, PublicProps, Readonly<__VLS_Props_33> & Readonly<{
onButtonClick?: ((button: TitlebarButton) => any) | undefined;
onHelp?: (() => any) | undefined;
}>, {
styletype: StyleType_23;
buttons: TitlebarButton[];
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

declare const __VLS_component_17: DefineComponent<__VLS_Props_34, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_34> & Readonly<{}>, {
orientation: "vertical" | "horizontal" | null;
showButtonSeparators: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_18: DefineComponent<JEmptyStateProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
action: () => any;
}, string, PublicProps, Readonly<JEmptyStateProps> & Readonly<{
onAction?: (() => any) | undefined;
}>, {
variant: "default" | "simple";
icon: string;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_19: DefineComponent<JDynamicTabsProps, {
addTab: (tab: DynamicTab) => void;
closeTab: (id: string) => void;
activateTab: (id: string) => void;
findTab: (id: string) => DynamicTab | undefined;
closeAllTabs: () => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
tabChange: (id: string) => any;
tabClose: (id: string) => any;
tabAdd: (tab: DynamicTab) => any;
}, string, PublicProps, Readonly<JDynamicTabsProps> & Readonly<{
onTabChange?: ((id: string) => any) | undefined;
onTabClose?: ((id: string) => any) | undefined;
onTabAdd?: ((tab: DynamicTab) => any) | undefined;
}>, {
styletype: "default" | "minimal";
initialTabs: DynamicTab[];
maxTabs: number;
emptyMessage: string;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

declare const __VLS_component_2: DefineComponent<__VLS_Props_2, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (value: string | number) => any;
change: (value: string | number) => any;
focus: (event: FocusEvent) => any;
blur: (event: FocusEvent) => any;
}, string, PublicProps, Readonly<__VLS_Props_2> & Readonly<{
"onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
onChange?: ((value: string | number) => any) | undefined;
onFocus?: ((event: FocusEvent) => any) | undefined;
onBlur?: ((event: FocusEvent) => any) | undefined;
}>, {
disabled: boolean;
type: string;
placeholder: string;
readonly: boolean;
required: boolean;
styletype: StyleType_2;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLInputElement>;

declare const __VLS_component_20: DefineComponent<JModalProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:open": (value: boolean) => any;
cancel: () => any;
confirm: (value?: string | undefined) => any;
}, string, PublicProps, Readonly<JModalProps> & Readonly<{
"onUpdate:open"?: ((value: boolean) => any) | undefined;
onCancel?: (() => any) | undefined;
onConfirm?: ((value?: string | undefined) => any) | undefined;
}>, {
disabled: boolean;
size: "sm" | "md" | "lg" | "xl" | "2xl" | "full";
open: boolean;
showFormField: boolean;
formFieldInputType: "text" | "email" | "password" | "number" | "tel" | "url";
formFieldType: "input" | "textarea" | "checkbox" | "switch" | "combo" | "radio" | "searchCombo" | "datepicker";
buttonType: "Ok" | "OkCancel";
confirmText: string;
cancelText: string;
confirmVariant: "default" | "destructive" | "outline" | "secondary" | "ghost" | "link";
confirmDisabled: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_21: DefineComponent<JFormModalProps, {
reset: () => void | undefined;
submit: () => void | undefined;
formState: ComputedRef<Record<string, any> | undefined>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (value: Record<string, any>) => any;
error: (errors: any) => any;
"update:open": (value: boolean) => any;
submit: (value: Record<string, any>) => any;
change: (data: {
field: string;
value: any;
}) => any;
cancel: () => any;
confirm: (value: Record<string, any>) => any;
}, string, PublicProps, Readonly<JFormModalProps> & Readonly<{
"onUpdate:modelValue"?: ((value: Record<string, any>) => any) | undefined;
onError?: ((errors: any) => any) | undefined;
"onUpdate:open"?: ((value: boolean) => any) | undefined;
onSubmit?: ((value: Record<string, any>) => any) | undefined;
onChange?: ((data: {
field: string;
value: any;
}) => any) | undefined;
onCancel?: (() => any) | undefined;
onConfirm?: ((value: Record<string, any>) => any) | undefined;
}>, {
size: "sm" | "md" | "lg" | "xl" | "2xl" | "full";
open: boolean;
buttonType: "Ok" | "OkCancel";
confirmText: string;
cancelText: string;
confirmVariant: "default" | "destructive" | "outline" | "secondary" | "ghost" | "link";
confirmDisabled: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {
dynamicFormRef: CreateComponentPublicInstanceWithMixins<Readonly<{
schema: FormSchema;
modelValue?: Record<string, any>;
}> & Readonly<{
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
onError?: ((...args: any[]) => any) | undefined;
onSubmit?: ((...args: any[]) => any) | undefined;
onChange?: ((...args: any[]) => any) | undefined;
}>, {
formState: Record<string, any>;
submit: () => void;
reset: () => void;
handleError: (errs: any) => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (...args: any[]) => void;
error: (...args: any[]) => void;
submit: (...args: any[]) => void;
change: (...args: any[]) => void;
}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLFormElement, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<{
schema: FormSchema;
modelValue?: Record<string, any>;
}> & Readonly<{
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
onError?: ((...args: any[]) => any) | undefined;
onSubmit?: ((...args: any[]) => any) | undefined;
onChange?: ((...args: any[]) => any) | undefined;
}>, {
formState: Record<string, any>;
submit: () => void;
reset: () => void;
handleError: (errs: any) => void;
}, {}, {}, {}, {}> | null;
}, any>;

declare const __VLS_component_22: DefineComponent<JFilterBarProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
search: () => any;
reset: () => any;
"update:collapsed": (value: boolean) => any;
"update:filterValues": (value: Record<string, unknown>) => any;
}, string, PublicProps, Readonly<JFilterBarProps> & Readonly<{
onSearch?: (() => any) | undefined;
onReset?: (() => any) | undefined;
"onUpdate:collapsed"?: ((value: boolean) => any) | undefined;
"onUpdate:filterValues"?: ((value: Record<string, unknown>) => any) | undefined;
}>, {
collapsible: boolean;
collapsed: boolean;
filterValues: Record<string, unknown>;
filterDisplay: Record<string, FilterDisplayItem>;
showResetButton: boolean;
showSearchButton: boolean;
resetButtonText: string;
searchButtonText: string;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

declare const __VLS_component_23: DefineComponent<__VLS_Props_37, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
logoClick: () => any;
navClick: (item: HeaderNavItem, index: number) => any;
notificationClick: (item: NotificationItem) => any;
userMenuSelect: (itemId: string) => any;
sidebarToggle: () => any;
login: () => any;
}, string, PublicProps, Readonly<__VLS_Props_37> & Readonly<{
onLogoClick?: (() => any) | undefined;
onNavClick?: ((item: HeaderNavItem, index: number) => any) | undefined;
onNotificationClick?: ((item: NotificationItem) => any) | undefined;
onUserMenuSelect?: ((itemId: string) => any) | undefined;
onSidebarToggle?: (() => any) | undefined;
onLogin?: (() => any) | undefined;
}>, {
styletype: StyleType_25;
logoText: string;
showNotifications: boolean;
notifications: NotificationItem[];
showSidebarToggle: boolean;
isSidebarOpen: boolean;
showThemeSelector: boolean;
defaultTheme: string;
availableThemes: string[];
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLElement>;

declare const __VLS_component_24: DefineComponent<__VLS_Props_41, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
breadcrumbClick: (item: BreadcrumbItem, index: number) => any;
titlebarButtonClick: (button: TitlebarButton) => any;
}, string, PublicProps, Readonly<__VLS_Props_41> & Readonly<{
onBreadcrumbClick?: ((item: BreadcrumbItem, index: number) => any) | undefined;
onTitlebarButtonClick?: ((button: TitlebarButton) => any) | undefined;
}>, {
styletype: StyleType_28;
breadcrumbItems: BreadcrumbItem[];
showBreadcrumb: boolean;
showTitlebar: boolean;
contentScroll: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

declare const __VLS_component_25: DefineComponent<JDrawerProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:open": (value: boolean) => any;
cancel: () => any;
resize: (size: number) => any;
confirm: () => any;
"resize-end": (size: number) => any;
}, string, PublicProps, Readonly<JDrawerProps> & Readonly<{
"onUpdate:open"?: ((value: boolean) => any) | undefined;
onCancel?: (() => any) | undefined;
onResize?: ((size: number) => any) | undefined;
onConfirm?: (() => any) | undefined;
"onResize-end"?: ((size: number) => any) | undefined;
}>, {
size: "sm" | "md" | "lg" | "full";
side: SheetSide;
showClose: boolean;
resizable: boolean;
minSize: number;
showFooter: boolean;
buttonType: "Ok" | "OkCancel";
confirmText: string;
cancelText: string;
confirmVariant: "link" | "default" | "destructive" | "secondary" | "outline" | "ghost" | null;
confirmDisabled: boolean;
closeOnOverlayClick: boolean;
closeOnEscape: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {
handleRef: HTMLDivElement;
}, any>;

declare const __VLS_component_26: DefineComponent<__VLS_Props_43, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"backdrop-click": () => any;
}, string, PublicProps, Readonly<__VLS_Props_43> & Readonly<{
"onBackdrop-click"?: (() => any) | undefined;
}>, {
styletype: StyleType_30;
contentScroll: boolean;
sidebarOverlay: boolean;
sidebarOpen: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

declare const __VLS_component_27: DefineComponent<__VLS_Props_44, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"menu-click": (item: SidebarMenuItem, event: MouseEvent) => any;
}, string, PublicProps, Readonly<__VLS_Props_44> & Readonly<{
"onMenu-click"?: ((item: SidebarMenuItem, event: MouseEvent) => any) | undefined;
}>, {
styletype: "default" | "minimal";
menuItems: SidebarMenuItem[];
contentScroll: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

declare const __VLS_component_3: DefineComponent<__VLS_Props_12, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_12> & Readonly<{}>, {
disabled: boolean;
styletype: StyleType_10;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_4: DefineComponent<__VLS_Props_14, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_14> & Readonly<{}>, {
size: "xs" | "sm" | "md" | "lg";
variant: "default" | "secondary" | "destructive" | "outline";
styletype: StyleType_12;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

declare const __VLS_component_5: DefineComponent<__VLS_Props_18, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_18> & Readonly<{}>, {
size: SizeType_2;
styletype: StyleType_16;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLElement>;

declare const __VLS_component_6: DefineComponent<__VLS_Props_19, {
showTooltip: () => void;
hideTooltip: () => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_19> & Readonly<{}>, {
disabled: boolean;
size: Size_2;
side: "top" | "right" | "bottom" | "left";
align: "start" | "center" | "end";
styletype: StyleType_17;
delay: number;
maxWidth: string | number;
trigger: Trigger;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_7: DefineComponent<__VLS_Props_21, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_21> & Readonly<{}>, {
text: string;
required: boolean;
styletype: StyleType_19;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_8: DefineComponent<__VLS_Props_22, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:open": (open: boolean) => any;
openChange: (open: boolean) => any;
}, string, PublicProps, Readonly<__VLS_Props_22> & Readonly<{
"onUpdate:open"?: ((open: boolean) => any) | undefined;
onOpenChange?: ((open: boolean) => any) | undefined;
}>, {
disabled: boolean;
open: boolean;
position: PositionType;
sideOffset: number;
align: "start" | "center" | "end";
alignOffset: number;
modal: boolean;
styletype: StyleType_20;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_9: DefineComponent<__VLS_Props_25, {
resizeFirst: (size: number) => Promise<void>;
resizeSecond: (size: number) => Promise<void>;
getSizes: () => SplitterSizes;
collapseFirst: () => void;
expandFirst: () => void;
collapseSecond: () => void;
expandSecond: () => void;
resetToDefault: () => Promise<void>;
isFirstCollapsed: ComputedRef<boolean>;
isSecondCollapsed: ComputedRef<boolean>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
resize: (sizes: SplitterSizes, source: "drag" | "api" | "prop") => any;
"update:sizes": (sizes: SplitterSizes) => any;
}, string, PublicProps, Readonly<__VLS_Props_25> & Readonly<{
onResize?: ((sizes: SplitterSizes, source: "drag" | "api" | "prop") => any) | undefined;
"onUpdate:sizes"?: ((sizes: SplitterSizes) => any) | undefined;
}>, {
direction: Orientation;
responsive: boolean;
gap: number;
withHandle: boolean;
defaultSize: number;
minSize: number;
collapsibleFirst: boolean;
collapsibleSecond: boolean;
collapsedSizeFirst: number;
collapsedSizeSecond: number;
animated: boolean;
animationDuration: number;
}, {}, {}, {}, string, ComponentProvideOptions, false, {
firstPanelRef: ({
$: ComponentInternalInstance;
$data: {};
$props: {
readonly collapsedSize?: number | undefined;
readonly collapsible?: boolean | undefined;
readonly defaultSize?: number | undefined;
readonly id?: string | undefined;
readonly maxSize?: number | undefined;
readonly minSize?: number | undefined;
readonly order?: number | undefined;
readonly asChild?: boolean | undefined;
readonly as?: (AsTag | Component) | undefined;
readonly onResize?: ((size: number, prevSize: number | undefined) => any) | undefined | undefined;
readonly onCollapse?: (() => any) | undefined | undefined;
readonly onExpand?: (() => any) | undefined | undefined;
} & VNodeProps & AllowedComponentProps & ComponentCustomProps;
$attrs: {
[x: string]: unknown;
};
$refs: {
[x: string]: unknown;
};
$slots: Readonly<{
[name: string]: Slot<any> | undefined;
}>;
$root: ComponentPublicInstance | null;
$parent: ComponentPublicInstance | null;
$host: Element | null;
$emit: ((event: "expand") => void) & ((event: "resize", size: number, prevSize: number | undefined) => void) & ((event: "collapse") => void);
$el: any;
$options: ComponentOptionsBase<Readonly<SplitterPanelProps> & Readonly<{
onResize?: ((size: number, prevSize: number | undefined) => any) | undefined;
onCollapse?: (() => any) | undefined;
onExpand?: (() => any) | undefined;
}>, {
collapse: () => void;
expand: () => void;
getSize(): number;
resize: (size: number) => void;
isCollapsed: ComputedRef<boolean>;
isExpanded: ComputedRef<boolean>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
resize: (size: number, prevSize: number | undefined) => any;
collapse: () => any;
expand: () => any;
}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
beforeCreate?: (() => void) | (() => void)[];
created?: (() => void) | (() => void)[];
beforeMount?: (() => void) | (() => void)[];
mounted?: (() => void) | (() => void)[];
beforeUpdate?: (() => void) | (() => void)[];
updated?: (() => void) | (() => void)[];
activated?: (() => void) | (() => void)[];
deactivated?: (() => void) | (() => void)[];
beforeDestroy?: (() => void) | (() => void)[];
beforeUnmount?: (() => void) | (() => void)[];
destroyed?: (() => void) | (() => void)[];
unmounted?: (() => void) | (() => void)[];
renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
};
$forceUpdate: () => void;
$nextTick: typeof nextTick;
$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
} & Readonly<{}> & Omit<Readonly<SplitterPanelProps> & Readonly<{
onResize?: ((size: number, prevSize: number | undefined) => any) | undefined;
onCollapse?: (() => any) | undefined;
onExpand?: (() => any) | undefined;
}>, "expand" | "resize" | "collapse" | "getSize" | "isCollapsed" | "isExpanded"> & ShallowUnwrapRef<    {
collapse: () => void;
expand: () => void;
getSize(): number;
resize: (size: number) => void;
isCollapsed: ComputedRef<boolean>;
isExpanded: ComputedRef<boolean>;
}> & {} & ComponentCustomProperties & {} & {
$slots: {
default?: (props: {
isCollapsed: boolean;
isExpanded: boolean;
collapse: () => void;
expand: () => void;
resize: (size: number) => void;
}) => any;
};
}) | null;
secondPanelRef: ({
$: ComponentInternalInstance;
$data: {};
$props: {
readonly collapsedSize?: number | undefined;
readonly collapsible?: boolean | undefined;
readonly defaultSize?: number | undefined;
readonly id?: string | undefined;
readonly maxSize?: number | undefined;
readonly minSize?: number | undefined;
readonly order?: number | undefined;
readonly asChild?: boolean | undefined;
readonly as?: (AsTag | Component) | undefined;
readonly onResize?: ((size: number, prevSize: number | undefined) => any) | undefined | undefined;
readonly onCollapse?: (() => any) | undefined | undefined;
readonly onExpand?: (() => any) | undefined | undefined;
} & VNodeProps & AllowedComponentProps & ComponentCustomProps;
$attrs: {
[x: string]: unknown;
};
$refs: {
[x: string]: unknown;
};
$slots: Readonly<{
[name: string]: Slot<any> | undefined;
}>;
$root: ComponentPublicInstance | null;
$parent: ComponentPublicInstance | null;
$host: Element | null;
$emit: ((event: "expand") => void) & ((event: "resize", size: number, prevSize: number | undefined) => void) & ((event: "collapse") => void);
$el: any;
$options: ComponentOptionsBase<Readonly<SplitterPanelProps> & Readonly<{
onResize?: ((size: number, prevSize: number | undefined) => any) | undefined;
onCollapse?: (() => any) | undefined;
onExpand?: (() => any) | undefined;
}>, {
collapse: () => void;
expand: () => void;
getSize(): number;
resize: (size: number) => void;
isCollapsed: ComputedRef<boolean>;
isExpanded: ComputedRef<boolean>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
resize: (size: number, prevSize: number | undefined) => any;
collapse: () => any;
expand: () => any;
}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
beforeCreate?: (() => void) | (() => void)[];
created?: (() => void) | (() => void)[];
beforeMount?: (() => void) | (() => void)[];
mounted?: (() => void) | (() => void)[];
beforeUpdate?: (() => void) | (() => void)[];
updated?: (() => void) | (() => void)[];
activated?: (() => void) | (() => void)[];
deactivated?: (() => void) | (() => void)[];
beforeDestroy?: (() => void) | (() => void)[];
beforeUnmount?: (() => void) | (() => void)[];
destroyed?: (() => void) | (() => void)[];
unmounted?: (() => void) | (() => void)[];
renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
};
$forceUpdate: () => void;
$nextTick: typeof nextTick;
$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
} & Readonly<{}> & Omit<Readonly<SplitterPanelProps> & Readonly<{
onResize?: ((size: number, prevSize: number | undefined) => any) | undefined;
onCollapse?: (() => any) | undefined;
onExpand?: (() => any) | undefined;
}>, "expand" | "resize" | "collapse" | "getSize" | "isCollapsed" | "isExpanded"> & ShallowUnwrapRef<    {
collapse: () => void;
expand: () => void;
getSize(): number;
resize: (size: number) => void;
isCollapsed: ComputedRef<boolean>;
isExpanded: ComputedRef<boolean>;
}> & {} & ComponentCustomProperties & {} & {
$slots: {
default?: (props: {
isCollapsed: boolean;
isExpanded: boolean;
collapse: () => void;
expand: () => void;
resize: (size: number) => void;
}) => any;
};
}) | null;
}, any>;

declare type __VLS_Props = {
    /** 버튼 타입 */
    type?: 'button' | 'submit' | 'reset';
    /** 비활성화 상태 */
    disabled?: boolean;
    /** 로딩 상태 */
    loading?: boolean;
    /** shadcn variant */
    variant?: ButtonVariants['variant'];
    /** shadcn size */
    size?: ButtonVariants['size'];
    /** 추가 CSS 클래스 */
    class?: string;
    /** 스타일 프리셋 (variant + size 조합) */
    styletype?: StyleType;
};

declare type __VLS_Props_10 = {
    /** 구분선 방향 */
    orientation?: 'horizontal' | 'vertical';
    /** 구분선 스타일 테마 */
    styletype?: StyleType_9;
    /** 추가 CSS 클래스 */
    class?: string;
};

declare type __VLS_Props_11 = {
    /** 마크다운 내용 (v-model) */
    modelValue?: string;
    /** 플레이스홀더 텍스트 */
    placeholder?: string;
    /** 비활성화 상태 */
    disabled?: boolean;
    /** 읽기 전용 상태 */
    readonly?: boolean;
    /** 에디터 높이 */
    height?: string | number;
    /** 테마 (light/dark) - 설정하지 않으면 자동으로 다크모드 감지 */
    theme?: 'light' | 'dark';
    /** 추가 CSS 클래스 */
    class?: string;
};

declare type __VLS_Props_12 = {
    /** 링크 URL */
    href?: string;
    /** 링크 텍스트 */
    text?: string;
    /** 새 탭에서 열기 */
    target?: '_blank' | '_self' | '_parent' | '_top';
    /** 링크 스타일 테마 */
    styletype?: StyleType_10;
    /** 비활성화 상태 */
    disabled?: boolean;
    /** 추가 CSS 클래스 */
    class?: string;
};

declare type __VLS_Props_13 = {
    /** 이미지 소스 */
    src?: string;
    /** 이미지 너비 */
    width?: string | number;
    /** 이미지 높이 */
    height?: string | number;
    /** 이미지 대체 텍스트 */
    alt?: string;
    /** 이미지 스타일 테마 */
    styletype?: StyleType_11;
    /** 에러 메시지 */
    errorText?: string;
    /** 플레이스홀더 텍스트 */
    placeholder?: string;
    /** 클릭 가능 여부 */
    clickable?: boolean;
    /** 추가 CSS 클래스 */
    class?: string;
};

declare type __VLS_Props_14 = {
    variant?: 'default' | 'secondary' | 'destructive' | 'outline';
    class?: string;
    /** 스타일 프리셋 */
    styletype?: StyleType_12;
    /** 배지 크기 */
    size?: 'xs' | 'sm' | 'md' | 'lg';
};

declare type __VLS_Props_15 = {
    value?: number;
    max?: number;
    class?: string;
    /** 스타일 프리셋 */
    styletype?: StyleType_13;
    /** 크기 프리셋 */
    size?: SizeType;
    /** 라벨 텍스트 */
    label?: string;
    /** 진행률 퍼센트 표시 여부 */
    showLabel?: boolean;
    /** 설명 텍스트 */
    description?: string;
    /** 프로그레스 바 모양 */
    variant?: VariantType;
    /** 무한 로딩 애니메이션 여부 */
    indeterminate?: boolean;
};

declare type __VLS_Props_16 = {
    size?: 'xs' | 'sm' | 'md' | 'lg';
    class?: string;
    /** 스타일 프리셋 */
    styletype?: StyleType_14;
    /** 스피너 원의 테두리 두께 */
    thickness?: number;
    /** 스피너 옆에 표시될 텍스트 */
    label?: string;
    /** 라벨 위치 */
    labelPosition?: LabelPosition;
};

declare type __VLS_Props_17 = {
    src?: string;
    alt?: string;
    fallback?: string;
    class?: string;
    /** 스타일 프리셋 */
    styletype?: StyleType_15;
    /** 아바타 크기 */
    size?: Size;
    /** 아바타 모양 */
    shape?: Shape;
    /** 상태 표시 */
    status?: Status;
};

declare type __VLS_Props_18 = {
    class?: string;
    /** 스타일 프리셋 */
    styletype?: StyleType_16;
    /** 키보드 키 크기 */
    size?: SizeType_2;
};

declare type __VLS_Props_19 = {
    content?: string;
    side?: 'top' | 'right' | 'bottom' | 'left';
    align?: 'start' | 'center' | 'end';
    class?: string;
    /** 스타일 프리셋 */
    styletype?: StyleType_17;
    /** 툴팁 크기 */
    size?: Size_2;
    /** 툴팁 비활성화 */
    disabled?: boolean;
    /** 표시 지연 시간 (ms) */
    delay?: number;
    /** 툴팁 최대 너비 */
    maxWidth?: string | number;
    /** 툴팁 트리거 타입 */
    trigger?: Trigger;
};

declare type __VLS_Props_2 = {
    modelValue?: string | number;
    type?: string;
    placeholder?: string;
    disabled?: boolean;
    readonly?: boolean;
    required?: boolean;
    name?: string;
    id?: string;
    class?: string;
    /** 스타일 프리셋 */
    styletype?: StyleType_2;
};

declare type __VLS_Props_20 = {
    name: IconName;
    size?: SizeType_3;
    color?: string;
    class?: string;
    /** 스타일 프리셋 */
    styletype?: StyleType_18;
    /** 접근성 라벨 */
    ariaLabel?: string;
    /** 접근성 역할 */
    role?: string;
};

declare type __VLS_Props_21 = {
    /** 라벨 텍스트 */
    text?: string;
    /** 필수 필드 여부 */
    required?: boolean;
    /** 스타일 프리셋 */
    styletype?: StyleType_19;
    /** HTML for 속성 (연결할 input의 id) */
    for?: string;
    /** 추가 클래스 (외부 커스터마이징용) */
    class?: string;
};

declare type __VLS_Props_22 = {
    /** 팝오버 열림 상태 */
    open?: boolean;
    /** 비활성화 상태 */
    disabled?: boolean;
    /** 모달 모드 여부 */
    modal?: boolean;
    /** 스타일 프리셋 (크기 포함) */
    styletype?: StyleType_20;
    /** 위치 프리셋 */
    position?: PositionType;
    /** 정렬 방식 */
    align?: 'start' | 'center' | 'end';
    /** 사이드 오프셋 */
    sideOffset?: number;
    /** 정렬 오프셋 */
    alignOffset?: number;
};

declare type __VLS_Props_23 = {
    /** 마크다운 또는 HTML 내용 */
    modelValue?: string;
    /** 테마 (light/dark) - 설정하지 않으면 자동으로 다크모드 감지 */
    theme?: 'light' | 'dark';
    /** 추가 CSS 클래스 */
    class?: string;
};

declare type __VLS_Props_24 = {
    /** 추가 클래스 (외부 커스터마이징용) */
    class?: string;
    /** 그리드에 표시할 데이터 배열 */
    rowData: any[];
    /** 컬럼 정의 배열 */
    columnDefs: ColDef[];
    /** 페이지네이션 활성화 여부 */
    pagination?: boolean;
    /** 체크박스 선택 활성화 여부 */
    checkbox?: boolean;
    /** 행 번호 표시 여부 (Enterprise) */
    rowNumbers?: boolean;
    /** 플로팅 필터 표시 여부 */
    floatingFilters?: boolean;
    /** 플로팅 필터 표시 여부 (하위호환 alias) */
    floatingFilter?: boolean;
    /** 행 번호 컬럼 너비(px) */
    rowNumberWidth?: number;
    /** 행별 액션 버튼 목록 */
    actionButtons?: ActionButton[];
    /** 요약 컬럼 표시 여부 */
    summaryColumn?: boolean;
    /** 숨김 컬럼 관리 활성화 여부 */
    hiddenColumn?: boolean;
    /** 그룹핑 기능 활성화 여부 (Enterprise) */
    enableGrouping?: boolean;
    /** 피벗 기능 활성화 여부 (Enterprise) */
    enablePivot?: boolean;
    /** Excel 내보내기 기능 활성화 여부 (Enterprise) */
    enableExcelExport?: boolean;
    /** Tree Data 기능 활성화 여부 (Enterprise) */
    enableTreeData?: boolean;
    /** Tree Data 계층 경로를 반환하는 함수 */
    getDataPath?: (data: any) => (string | number)[];
    /** Tree Data 그룹 컬럼 정의 */
    autoGroupColumnDef?: ColDef;
    /** 선택된 행 데이터 배열 (v-model:selected-rows) */
    selectedRows?: any[];
    /** 컬럼 호버 하이라이트 활성화 여부 */
    columnHover?: boolean;
    /** Columns Tool Panel 활성화 여부 (Enterprise) */
    enableColumnsToolPanel?: boolean;
    /** Status Bar 활성화 여부 (Enterprise) */
    statusBar?: boolean;
    /** 간소화된 Footer 모드 (Status Bar 제거, Pagination만 표시) */
    compactFooter?: boolean;
    /** Row Group Panel 표시 여부 ('always' | 'onlyWhenGrouping' | 'never') */
    rowGroupPanelShow?: 'always' | 'onlyWhenGrouping' | 'never';
    /** 그룹 기본 확장 레벨 (-1: 모두 닫힘, 0: 첫 레벨만, 1: 2레벨까지...) */
    groupDefaultExpanded?: number;
    /** Pivot Mode Panel 표시 여부 */
    pivotPanelShow?: 'always' | 'onlyWhenPivoting' | 'never';
    /** Pivot Mode 활성화 여부 */
    pivotMode?: boolean;
    /** Row Drag 관리 모드 (AG Grid 내장 정렬 사용). true 시 pagination 은 강제로 false */
    rowDragManaged?: boolean;
    /** Row 전체를 드래그 핸들로 사용 (행 어느 곳이든 드래그 시작 가능) */
    rowDragEntireRow?: boolean;
    /** 다중 행 드래그 허용 (rowSelection='multiRow' 필요) */
    rowDragMultiRow?: boolean;
    /** rowData 내부 필드 변경(깊은 변이)에 반응할지 여부. 기본 true(기존 동작). */
    /** managed drag 사용 시 false 로 두어 내부 mutation 으로 인한 전체 재주입(드래그 롤백) 방지 권장. */
    /** 주의: watcher 의 deep 옵션은 컴포넌트 마운트 시점에 고정됩니다. */
    reactiveRowData?: boolean;
};

declare type __VLS_Props_25 = {
    /** 분할 방향 (horizontal: 좌우, vertical: 상하) */
    direction?: Orientation;
    /** 첫 번째 패널의 기본 크기 (%) */
    defaultSize?: number;
    /** 첫 번째 패널의 최소 크기 (%) */
    minSize?: number;
    /** 첫 번째 패널의 최대 크기 (%) */
    maxSize?: number;
    /** 두 번째 패널의 최소 크기 (%) */
    secondMinSize?: number;
    /** 두 번째 패널의 최대 크기 (%) */
    secondMaxSize?: number;
    /** ResizableHandle에 grip 아이콘 표시 여부 */
    withHandle?: boolean;
    /** 패널 간 여백 (px) */
    gap?: number;
    /** 추가 CSS 클래스 */
    class?: string;
    /** 모바일에서 자동 수직 전환 (기본: true) */
    responsive?: boolean;
    /** v-model:sizes - [firstSize, secondSize], 합계는 100이어야 함 */
    sizes?: SplitterSizes;
    /** 첫 번째 패널 collapsible 여부 */
    collapsibleFirst?: boolean;
    /** 두 번째 패널 collapsible 여부 */
    collapsibleSecond?: boolean;
    /** collapsible 시 첫 번째 패널 축소 크기 (%) */
    collapsedSizeFirst?: number;
    /** collapsible 시 두 번째 패널 축소 크기 (%) */
    collapsedSizeSecond?: number;
    /** collapse/expand 시 슬라이드 애니메이션 여부 */
    animated?: boolean;
    /** 슬라이드 애니메이션 지속 시간 (ms) */
    animationDuration?: number;
};

declare type __VLS_Props_26 = {
    modelValue?: string | number;
    placeholder?: string;
    /** 입력란 비활성화 (버튼도 함께 비활성화) */
    disabled?: boolean;
    /** 입력란을 읽기 전용으로 (버튼은 동작). 팝업으로만 값을 채울 때 true */
    readonly?: boolean;
    /** 찾기 버튼 텍스트 */
    buttonText?: string;
    /** 찾기 버튼만 별도 비활성화 */
    buttonDisabled?: boolean;
    /** 찾기 버튼에 돋보기 아이콘 표시 여부 */
    showIcon?: boolean;
    name?: string;
    id?: string;
    class?: string;
    /** 스타일 프리셋 */
    styletype?: StyleType_21;
};

declare type __VLS_Props_27 = {
    /** 추가 클래스 (외부 커스터마이징용) */
    class?: string;
    /** 필드 레이블 */
    label?: string;
    /** 필드 설명 (레이블 아래 표시) */
    description?: string;
    /** 에러 메시지 */
    errorMsg?: string;
    /** 컴포넌트 타입 (렌더링할 컴포넌트 지정) */
    type?: ComponentType;
    /** 체크박스/스위치 타입일 때만 사용하는 옆 라벨 */
    inlineLabel?: string;
    /** 레이블과 컨트롤의 배치 방향 */
    orientation?: 'vertical' | 'horizontal' | 'responsive';
    /** 레이블 텍스트 정렬 */
    labelAlign?: 'left' | 'middle' | 'right';
    /** 레이블 영역 너비 (horizontal orientation일 때만 적용) */
    labelWidth?: string;
    /** Input 요소의 id (label for와 연결) */
    id?: string;
    /** v-model로 양방향 데이터 바인딩 */
    modelValue?: any;
    /** 입력 전 표시되는 안내문 (Input/Textarea/Select/Combobox) */
    placeholder?: string;
    /** 비활성화 상태 (전체) */
    disabled?: boolean;
    /** 읽기 전용 상태 (Input/Textarea) */
    readonly?: boolean;
    /** 필수 입력/선택 여부 (전체) */
    required?: boolean;
    /** form 데이터 전송 시 키 이름 (전체) */
    name?: string;
    /** 스타일 테마 지정 (J-prefixed 컴포넌트의 styleType) */
    styleType?: string;
    /** Input 타입 (text, email, password 등) */
    inputType?: string;
    /** 선택 가능한 항목 배열 */
    options?: Array<{
        label: string;
        value: string | number;
        disabled?: boolean;
    }>;
    /** 다중 선택 허용 여부 */
    multiple?: boolean;
    /** Radio 옵션 나열 방향 */
    radioDirection?: 'horizontal' | 'vertical';
    /** 상태 라벨 노출 여부 (기본: true) */
    showStateLabel?: boolean;
    /** 활성(Y) 상태 라벨 텍스트 (기본: '활성') */
    activeLabel?: string;
    /** 비활성(N) 상태 라벨 텍스트 (기본: '비활성') */
    inactiveLabel?: string;
    /** 에디터 높이 (기본값: '300px') */
    editorHeight?: string | number;
    /** 에디터가 남은 세로 공간을 모두 채우도록 확장 (type='editor'일 때만 적용) */
    fillHeight?: boolean;
    /** 찾기 버튼 텍스트 (기본: '찾기') */
    buttonText?: string;
    /** 찾기 버튼만 별도 비활성화 */
    buttonDisabled?: boolean;
    /** 찾기 버튼에 돋보기 아이콘 표시 (기본: true) */
    showIcon?: boolean;
    /** 범위 입력 옵션 */
    rangeOptions?: {
        min?: string | number;
        max?: string | number;
        step?: number;
        suffix?: string;
        separator?: string;
        placeholder?: {
            start?: string;
            end?: string;
        };
    };
};

declare type __VLS_Props_28 = {
    modelValue?: DateRangeValue;
    min?: string;
    max?: string;
    disabled?: boolean;
    required?: boolean;
    placeholder?: {
        start?: string;
        end?: string;
    };
    separator?: string;
    class?: string;
    id?: string;
    name?: string;
};

declare type __VLS_Props_29 = {
    modelValue?: NumberRangeValue;
    min?: number;
    max?: number;
    step?: number;
    disabled?: boolean;
    required?: boolean;
    placeholder?: {
        start?: string;
        end?: string;
    };
    separator?: string;
    suffix?: string;
    class?: string;
    id?: string;
    name?: string;
};

declare type __VLS_Props_3 = {
    modelValue?: string;
    placeholder?: string;
    disabled?: boolean;
    readonly?: boolean;
    required?: boolean;
    name?: string;
    id?: string;
    rows?: number;
    class?: string;
    /** 스타일 프리셋 */
    styletype?: StyleType_3;
};

declare type __VLS_Props_30 = {
    modelValue?: string | number;
    groupedOptions?: GroupedOption[];
    placeholder?: string;
    disabled?: boolean;
    required?: boolean;
    name?: string;
    id?: string;
    class?: string;
    /** 스타일 프리셋 */
    styletype?: StyleType_22;
};

declare type __VLS_Props_31 = {
    /** Card 자체의 클래스 */
    class?: HTMLAttributes["class"];
    /** 카드 제목 */
    title?: string;
    /** 카드 설명 */
    description?: string;
    /** 카드 푸터 텍스트 */
    footer?: string;
    /** 카드 variant (패턴 4) */
    variant?: CardVariant;
    /** CardContent가 남은 세로 공간을 채우도록 flex column 적용 */
    fillContent?: boolean;
};

declare type __VLS_Props_32 = {
    /** Alert 자체의 클래스 */
    class?: HTMLAttributes["class"];
    /** Alert variant 스타일 */
    variant?: "default" | "destructive";
    /** Alert 제목 (Header) */
    title?: string;
    /** Alert 설명/내용 (Body) */
    description?: string;
    /** Footer에 표시할 버튼 텍스트 */
    buttonText?: string;
    /** Footer 버튼 클릭 핸들러 */
    onConfirm?: () => void;
    /** Footer 표시 여부 */
    showFooter?: boolean;
};

declare type __VLS_Props_33 = {
    /** Titlebar 스타일 타입 */
    styletype?: StyleType_23;
    /** 프로그램 아이콘 */
    icon?: string;
    /** 프로그램명 */
    title?: string;
    /** 프로그램 설명 (Popover에 표시) */
    description?: string;
    /** 도움말 아이콘(?) 표시 여부 — 클릭 시 help 이벤트 emit */
    showHelp?: boolean;
    /** 메인 버튼 목록 */
    buttons?: TitlebarButton[];
    /** 추가 클래스 (외부 커스터마이징용) */
    class?: string;
};

declare type __VLS_Props_34 = {
    orientation?: ButtonGroupVariants['orientation'];
    showButtonSeparators?: boolean;
};

declare type __VLS_Props_35 = {
    /** 브레드크럼 아이템 목록 */
    items: BreadcrumbItem[];
    /** 구분자 (기본값: /) */
    separator?: string;
    /** 스타일 타입 */
    styletype?: StyleType_24;
    /** 추가 CSS 클래스 */
    class?: string;
};

declare type __VLS_Props_36 = {
    schema: FormSchema;
    modelValue?: Record<string, any>;
};

declare type __VLS_Props_37 = {
    /** 로고 이미지 URL */
    logo?: string;
    /** 로고 텍스트 (기본값, 이미지가 없을 때) */
    logoText?: string;
    /** 네비게이션 아이템 목록 */
    navItems?: HeaderNavItem[];
    /** 알림 표시 여부 */
    showNotifications?: boolean;
    /** 알림 목록 */
    notifications?: NotificationItem[];
    /** 사용자 아바타 이미지 */
    userAvatar?: string;
    /** 사용자 이름 */
    userName?: string;
    /** 로그인 상태 */
    isLoggedIn?: boolean;
    /** 사용자 이메일 */
    userEmail?: string;
    /** 사용자 ID */
    userId?: string;
    /** 스타일 타입 */
    styletype?: StyleType_25;
    /** 사이드바 토글 버튼 표시 여부 */
    showSidebarToggle?: boolean;
    /** 사이드바 열림 상태 */
    isSidebarOpen?: boolean;
    /** 테마 선택기 표시 여부 */
    showThemeSelector?: boolean;
    /** 초기 테마 (기본값: 'default' 또는 저장된 테마) */
    defaultTheme?: string;
    /** 선택 가능한 테마 목록 (지정하지 않으면 모든 감지된 테마 사용) */
    availableThemes?: string[];
};

/**
 * JSidebar - 통합 사이드바 컴포넌트
 *
 * DB 트리 데이터 기반, provide/inject로 상태 공유.
 * collapsed 모드, 검색, 즐겨찾기(localStorage) 지원.
 * 라우터를 모름 — @menu-click으로 아이템을 올려보냄.
 */
declare type __VLS_Props_38 = {
    /** 메뉴 트리 데이터 */
    items: SidebarMenuItem[];
    /** 접힘 상태 (v-model:collapsed) */
    collapsed?: boolean;
    /** 현재 활성 경로 */
    activePath?: string;
    /** 펼침 너비 */
    width?: string;
    /** 접힘 너비 */
    collapsedWidth?: string;
    /** 즐겨찾기 localStorage 키 (없으면 즐겨찾기 비활성) */
    storageKey?: string;
    /** 검색 표시 여부 */
    showSearch?: boolean;
    /** 즐겨찾기 섹션 표시 여부 */
    showFavorites?: boolean;
};

declare type __VLS_Props_39 = {
    /** 메뉴 아이템 목록 */
    menuItems: SidebarMenuItem_2[];
    /** 권한 목록 */
    permissions?: MenuPermission[];
    /** 검색어 */
    searchQuery?: string;
    /** 스타일 타입 */
    styletype?: StyleType_26;
    /** 추가 CSS 클래스 */
    class?: string;
    /** 너비 */
    width?: string;
    /** 표시 여부 */
    isVisible?: boolean;
};

declare type __VLS_Props_4 = {
    modelValue?: string;
    disabled?: boolean;
    required?: boolean;
    name?: string;
    id?: string;
    class?: string;
    /** 스타일 프리셋 */
    styletype?: StyleType_4;
};

declare type __VLS_Props_40 = {
    /** 메뉴 아이템 목록 */
    menuItems: SidebarMenuItem_2[];
    /** 권한 목록 */
    permissions?: MenuPermission[];
    /** 즐겨찾기 메뉴 키 목록 */
    favorites?: (number | string)[];
    /** 스타일 타입 */
    styletype?: StyleType_27;
    /** 추가 CSS 클래스 */
    class?: string;
    /** 너비 */
    width?: string;
    /** 표시 여부 */
    isVisible?: boolean;
};

declare type __VLS_Props_41 = {
    /** 브레드크럼 아이템 목록 */
    breadcrumbItems?: BreadcrumbItem[];
    /** 브레드크럼 표시 여부 */
    showBreadcrumb?: boolean;
    /** JTitlebar의 모든 props 전달 */
    title?: string;
    icon?: string;
    description?: string;
    titlebarButtons?: TitlebarButton[];
    titlebarStyletype?: 'default' | 'primary' | 'accent' | 'neutral' | 'elevated';
    /** JTitlebar 표시 여부 */
    showTitlebar?: boolean;
    /** 스타일 타입 */
    styletype?: StyleType_28;
    /** 콘텐츠 영역 스크롤 가능 여부 */
    contentScroll?: boolean;
    /** 추가 CSS 클래스 */
    class?: string;
};

declare type __VLS_Props_42 = {
    /** 트리 노드 데이터 */
    items: SidebarMenuItem_2[];
    /** 펼쳐진 노드 키 목록 (v-model 지원, 배열) */
    expandedKeys?: (number | string)[];
    /** 현재 선택(하이라이트)된 노드의 menuKey (v-model 지원) */
    activeKey?: number | string | null;
    /** 권한 목록 */
    permissions?: MenuPermission[];
    /** 최대 깊이 제한 (무한 루프 방지) */
    maxDepth?: number;
    /** 스타일 타입 */
    styletype?: StyleType_29;
    /** 검색어 (노드 필터링) */
    searchQuery?: string;
    /** 추가 CSS 클래스 */
    class?: string;
};

declare type __VLS_Props_43 = {
    /** 레이아웃 스타일 타입 */
    styletype?: StyleType_30;
    /** 콘텐츠 영역 스크롤 가능 여부 */
    contentScroll?: boolean;
    /** 추가 CSS 클래스 */
    class?: string;
    /** 모바일에서 사이드바를 오버레이 드로어로 표시 */
    sidebarOverlay?: boolean;
    /** 사이드바 오버레이 열림 상태 (sidebarOverlay=true일 때만 사용) */
    sidebarOpen?: boolean;
};

/**
 * JLayoutSimple - JSidebar + 일반 PageContainer 조합 템플릿
 *
 * 모바일에서는 사이드바가 오버레이 드로어로 전환되며,
 * 메뉴 클릭 시 자동으로 닫힙니다.
 *
 * @example
 * ```vue
 * <JLayoutSimple :menu-items="menuItems" storage-key="my-app-favorites">
 *   <template #content>
 *     <RouterView />
 *   </template>
 * </JLayoutSimple>
 * ```
 */
declare type __VLS_Props_44 = {
    /** 레이아웃 스타일 타입 */
    styletype?: 'default' | 'minimal';
    /** 콘텐츠 영역 스크롤 가능 여부 */
    contentScroll?: boolean;
    /** 추가 CSS 클래스 */
    class?: string;
    /** 메뉴 아이템 목록 */
    menuItems?: SidebarMenuItem[];
    /** 현재 활성 경로 */
    activePath?: string;
    /** 즐겨찾기 localStorage 키 */
    storageKey?: string;
};

declare type __VLS_Props_5 = {
    modelValue?: string | number;
    options?: Option_2[];
    placeholder?: string;
    disabled?: boolean;
    required?: boolean;
    name?: string;
    id?: string;
    multiple?: boolean;
    class?: string;
    /** 스타일 프리셋 */
    styletype?: StyleType_5;
};

declare type __VLS_Props_6 = {
    modelValue?: ComboboxOption;
    options?: ComboboxOption[];
    placeholder?: string;
    searchPlaceholder?: string;
    emptyText?: string;
    disabled?: boolean;
    required?: boolean;
    name?: string;
    id?: string;
    multiple?: boolean;
    class?: string;
    /** 스타일 프리셋 */
    styletype?: StyleType_6;
};

declare type __VLS_Props_7 = {
    modelValue?: string | number;
    options?: Option_3[];
    disabled?: boolean;
    required?: boolean;
    name?: string;
    id?: string;
    class?: string;
    /** 스타일 프리셋 */
    styletype?: StyleType_7;
};

declare type __VLS_Props_8 = {
    modelValue?: string;
    disabled?: boolean;
    name?: string;
    id?: string;
    class?: string;
    /** 스타일 프리셋 */
    styletype?: StyleType_8;
    /** 상태 라벨 노출 여부 */
    showStateLabel?: boolean;
    /** 활성(Y) 상태 라벨 */
    activeLabel?: string;
    /** 비활성(N) 상태 라벨 */
    inactiveLabel?: string;
};

declare type __VLS_Props_9 = {
    /** v-model로 양방향 데이터 바인딩 (ISO 8601 문자열: YYYY-MM-DD) */
    modelValue?: string | null;
    /** Input 요소의 id */
    id?: string;
    /** 입력 전 표시되는 안내문 */
    placeholder?: string;
    /** 비활성화 상태 */
    disabled?: boolean;
    /** 필수 입력 여부 */
    required?: boolean;
    /** form 데이터 전송 시 키 이름 */
    name?: string;
    /** 추가 CSS 클래스 */
    class?: string;
    /** 스타일 테마 지정 */
    styletype?: 'default' | 'sm' | 'lg';
};

declare function __VLS_template(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_10(): {
    attrs: Partial<{}>;
    slots: {
        description?(_: {}): any;
    };
    refs: {};
    rootEl: HTMLDivElement;
};

declare function __VLS_template_11(): {
    attrs: Partial<{}>;
    slots: Partial<Record<`content-${string}`, (_: {
        tab: DynamicTab;
    }) => any>> & Partial<Record<`content-${string}`, (_: {
        tab: DynamicTab;
    }) => any>>;
    refs: {};
    rootEl: any;
};

declare function __VLS_template_12(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
        item?(_: {
            item: ContextMenuItem;
        }): any;
        item?(_: {
            item: ContextMenuItem;
        }): any;
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_13(): {
    attrs: Partial<{}>;
    slots: {
        actions?(_: {}): any;
        default?(_: {}): any;
        footer?(_: {}): any;
    };
    refs: {};
    rootEl: HTMLDivElement;
};

declare function __VLS_template_14(): {
    attrs: Partial<{}>;
    slots: {
        header?(_: {}): any;
        default?(_: {}): any;
        footer?(_: {}): any;
    };
    refs: {};
    rootEl: HTMLDivElement;
};

declare function __VLS_template_15(): {
    attrs: Partial<{}>;
    slots: {
        trigger?(_: {
            item: JAccordionItem;
        }): any;
        content?(_: {
            item: JAccordionItem;
        }): any;
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_16(): {
    attrs: Partial<{}>;
    slots: {
        buttons?(_: {}): any;
    };
    refs: {};
    rootEl: HTMLDivElement;
};

declare function __VLS_template_17(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_18(): {
    attrs: Partial<{}>;
    slots: {
        icon?(_: {}): any;
        icon?(_: {}): any;
        title?(_: {}): any;
        title?(_: {}): any;
        description?(_: {}): any;
        action?(_: {}): any;
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_19(): {
    attrs: Partial<{}>;
    slots: Partial<Record<`content-${string}`, (_: {
        tab: DynamicTab;
    }) => any>>;
    refs: {};
    rootEl: HTMLDivElement;
};

declare function __VLS_template_2(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    rootEl: HTMLInputElement;
};

declare function __VLS_template_20(): {
    attrs: Partial<{}>;
    slots: {
        body?(_: {}): any;
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_21(): {
    attrs: Partial<{}>;
    slots: {
        body?(_: {}): any;
        footer?(_: {}): any;
    };
    refs: {
        dynamicFormRef: CreateComponentPublicInstanceWithMixins<Readonly<{
        schema: FormSchema;
        modelValue?: Record<string, any>;
        }> & Readonly<{
        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
        onError?: ((...args: any[]) => any) | undefined;
        onSubmit?: ((...args: any[]) => any) | undefined;
        onChange?: ((...args: any[]) => any) | undefined;
        }>, {
        formState: Record<string, any>;
        submit: () => void;
        reset: () => void;
        handleError: (errs: any) => void;
        }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
        "update:modelValue": (...args: any[]) => void;
        error: (...args: any[]) => void;
        submit: (...args: any[]) => void;
        change: (...args: any[]) => void;
        }, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLFormElement, ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
        }, Readonly<{
        schema: FormSchema;
        modelValue?: Record<string, any>;
        }> & Readonly<{
        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
        onError?: ((...args: any[]) => any) | undefined;
        onSubmit?: ((...args: any[]) => any) | undefined;
        onChange?: ((...args: any[]) => any) | undefined;
        }>, {
        formState: Record<string, any>;
        submit: () => void;
        reset: () => void;
        handleError: (errs: any) => void;
        }, {}, {}, {}, {}> | null;
    };
    rootEl: any;
};

declare function __VLS_template_22(): {
    attrs: Partial<{}>;
    slots: {
        actions?(_: {}): any;
        filters?(_: {}): any;
    };
    refs: {};
    rootEl: HTMLDivElement;
};

declare function __VLS_template_23(): {
    attrs: Partial<{}>;
    slots: {
        toolbar?(_: {}): any;
    };
    refs: {};
    rootEl: HTMLElement;
};

declare function __VLS_template_24(): {
    attrs: Partial<{}>;
    slots: {
        'titlebar-buttons'?(_: {}): any;
        default?(_: {}): any;
    };
    refs: {};
    rootEl: HTMLDivElement;
};

declare function __VLS_template_25(): {
    attrs: Partial<{}>;
    slots: {
        header?(_: {}): any;
        'title-suffix'?(_: {}): any;
        description?(_: {}): any;
        default?(_: {}): any;
        footer?(_: {}): any;
        'footer-extra'?(_: {}): any;
    };
    refs: {
        handleRef: HTMLDivElement;
    };
    rootEl: any;
};

declare function __VLS_template_26(): {
    attrs: Partial<{}>;
    slots: {
        header?(_: {}): any;
        sidebar?(_: {}): any;
        sidebar?(_: {}): any;
        content?(_: {}): any;
        default?(_: {}): any;
    };
    refs: {};
    rootEl: HTMLDivElement;
};

declare function __VLS_template_27(): {
    attrs: Partial<{}>;
    slots: {
        header?(_: {
            isSidebarCollapsed: boolean;
            onSidebarToggle: () => void;
        }): any;
        sidebar?(_: {
            isSidebarCollapsed: boolean;
        }): any;
        content?(_: {}): any;
        default?(_: {}): any;
    };
    refs: {};
    rootEl: HTMLDivElement;
};

declare function __VLS_template_3(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_4(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    rootEl: HTMLDivElement;
};

declare function __VLS_template_5(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    rootEl: HTMLElement;
};

declare function __VLS_template_6(): {
    attrs: Partial<{}>;
    slots: {
        trigger?(_: {}): any;
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_7(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_8(): {
    attrs: Partial<{}>;
    slots: {
        trigger?(_: {}): any;
        default?(_: {}): any;
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_9(): {
    attrs: Partial<{}>;
    slots: {
        first?(_: {}): any;
        left?(_: {}): any;
        top?(_: {}): any;
        second?(_: {}): any;
        right?(_: {}): any;
        bottom?(_: {}): any;
    };
    refs: {
        firstPanelRef: ({
            $: ComponentInternalInstance;
            $data: {};
            $props: {
                readonly collapsedSize?: number | undefined;
                readonly collapsible?: boolean | undefined;
                readonly defaultSize?: number | undefined;
                readonly id?: string | undefined;
                readonly maxSize?: number | undefined;
                readonly minSize?: number | undefined;
                readonly order?: number | undefined;
                readonly asChild?: boolean | undefined;
                readonly as?: (AsTag | Component) | undefined;
                readonly onResize?: ((size: number, prevSize: number | undefined) => any) | undefined | undefined;
                readonly onCollapse?: (() => any) | undefined | undefined;
                readonly onExpand?: (() => any) | undefined | undefined;
            } & VNodeProps & AllowedComponentProps & ComponentCustomProps;
            $attrs: {
                [x: string]: unknown;
            };
            $refs: {
                [x: string]: unknown;
            };
            $slots: Readonly<{
                [name: string]: Slot<any> | undefined;
            }>;
            $root: ComponentPublicInstance | null;
            $parent: ComponentPublicInstance | null;
            $host: Element | null;
            $emit: ((event: "expand") => void) & ((event: "resize", size: number, prevSize: number | undefined) => void) & ((event: "collapse") => void);
            $el: any;
            $options: ComponentOptionsBase<Readonly<SplitterPanelProps> & Readonly<{
            onResize?: ((size: number, prevSize: number | undefined) => any) | undefined;
            onCollapse?: (() => any) | undefined;
            onExpand?: (() => any) | undefined;
            }>, {
            collapse: () => void;
            expand: () => void;
            getSize(): number;
            resize: (size: number) => void;
            isCollapsed: ComputedRef<boolean>;
            isExpanded: ComputedRef<boolean>;
            }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
            resize: (size: number, prevSize: number | undefined) => any;
            collapse: () => any;
            expand: () => any;
            }, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
                beforeCreate?: (() => void) | (() => void)[];
                created?: (() => void) | (() => void)[];
                beforeMount?: (() => void) | (() => void)[];
                mounted?: (() => void) | (() => void)[];
                beforeUpdate?: (() => void) | (() => void)[];
                updated?: (() => void) | (() => void)[];
                activated?: (() => void) | (() => void)[];
                deactivated?: (() => void) | (() => void)[];
                beforeDestroy?: (() => void) | (() => void)[];
                beforeUnmount?: (() => void) | (() => void)[];
                destroyed?: (() => void) | (() => void)[];
                unmounted?: (() => void) | (() => void)[];
                renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
                renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
                errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
            };
            $forceUpdate: () => void;
            $nextTick: typeof nextTick;
            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
        } & Readonly<{}> & Omit<Readonly<SplitterPanelProps> & Readonly<{
            onResize?: ((size: number, prevSize: number | undefined) => any) | undefined;
            onCollapse?: (() => any) | undefined;
            onExpand?: (() => any) | undefined;
        }>, "expand" | "resize" | "collapse" | "getSize" | "isCollapsed" | "isExpanded"> & ShallowUnwrapRef<    {
        collapse: () => void;
        expand: () => void;
        getSize(): number;
        resize: (size: number) => void;
        isCollapsed: ComputedRef<boolean>;
        isExpanded: ComputedRef<boolean>;
        }> & {} & ComponentCustomProperties & {} & {
            $slots: {
                default?: (props: {
                    isCollapsed: boolean;
                    isExpanded: boolean;
                    collapse: () => void;
                    expand: () => void;
                    resize: (size: number) => void;
                }) => any;
            };
        }) | null;
        secondPanelRef: ({
            $: ComponentInternalInstance;
            $data: {};
            $props: {
                readonly collapsedSize?: number | undefined;
                readonly collapsible?: boolean | undefined;
                readonly defaultSize?: number | undefined;
                readonly id?: string | undefined;
                readonly maxSize?: number | undefined;
                readonly minSize?: number | undefined;
                readonly order?: number | undefined;
                readonly asChild?: boolean | undefined;
                readonly as?: (AsTag | Component) | undefined;
                readonly onResize?: ((size: number, prevSize: number | undefined) => any) | undefined | undefined;
                readonly onCollapse?: (() => any) | undefined | undefined;
                readonly onExpand?: (() => any) | undefined | undefined;
            } & VNodeProps & AllowedComponentProps & ComponentCustomProps;
            $attrs: {
                [x: string]: unknown;
            };
            $refs: {
                [x: string]: unknown;
            };
            $slots: Readonly<{
                [name: string]: Slot<any> | undefined;
            }>;
            $root: ComponentPublicInstance | null;
            $parent: ComponentPublicInstance | null;
            $host: Element | null;
            $emit: ((event: "expand") => void) & ((event: "resize", size: number, prevSize: number | undefined) => void) & ((event: "collapse") => void);
            $el: any;
            $options: ComponentOptionsBase<Readonly<SplitterPanelProps> & Readonly<{
            onResize?: ((size: number, prevSize: number | undefined) => any) | undefined;
            onCollapse?: (() => any) | undefined;
            onExpand?: (() => any) | undefined;
            }>, {
            collapse: () => void;
            expand: () => void;
            getSize(): number;
            resize: (size: number) => void;
            isCollapsed: ComputedRef<boolean>;
            isExpanded: ComputedRef<boolean>;
            }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
            resize: (size: number, prevSize: number | undefined) => any;
            collapse: () => any;
            expand: () => any;
            }, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
                beforeCreate?: (() => void) | (() => void)[];
                created?: (() => void) | (() => void)[];
                beforeMount?: (() => void) | (() => void)[];
                mounted?: (() => void) | (() => void)[];
                beforeUpdate?: (() => void) | (() => void)[];
                updated?: (() => void) | (() => void)[];
                activated?: (() => void) | (() => void)[];
                deactivated?: (() => void) | (() => void)[];
                beforeDestroy?: (() => void) | (() => void)[];
                beforeUnmount?: (() => void) | (() => void)[];
                destroyed?: (() => void) | (() => void)[];
                unmounted?: (() => void) | (() => void)[];
                renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
                renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
                errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
            };
            $forceUpdate: () => void;
            $nextTick: typeof nextTick;
            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
        } & Readonly<{}> & Omit<Readonly<SplitterPanelProps> & Readonly<{
            onResize?: ((size: number, prevSize: number | undefined) => any) | undefined;
            onCollapse?: (() => any) | undefined;
            onExpand?: (() => any) | undefined;
        }>, "expand" | "resize" | "collapse" | "getSize" | "isCollapsed" | "isExpanded"> & ShallowUnwrapRef<    {
        collapse: () => void;
        expand: () => void;
        getSize(): number;
        resize: (size: number) => void;
        isCollapsed: ComputedRef<boolean>;
        isExpanded: ComputedRef<boolean>;
        }> & {} & ComponentCustomProperties & {} & {
            $slots: {
                default?: (props: {
                    isCollapsed: boolean;
                    isExpanded: boolean;
                    collapse: () => void;
                    expand: () => void;
                    resize: (size: number) => void;
                }) => any;
            };
        }) | null;
    };
    rootEl: any;
};

declare type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;

declare type __VLS_TemplateResult_10 = ReturnType<typeof __VLS_template_10>;

declare type __VLS_TemplateResult_11 = ReturnType<typeof __VLS_template_11>;

declare type __VLS_TemplateResult_12 = ReturnType<typeof __VLS_template_12>;

declare type __VLS_TemplateResult_13 = ReturnType<typeof __VLS_template_13>;

declare type __VLS_TemplateResult_14 = ReturnType<typeof __VLS_template_14>;

declare type __VLS_TemplateResult_15 = ReturnType<typeof __VLS_template_15>;

declare type __VLS_TemplateResult_16 = ReturnType<typeof __VLS_template_16>;

declare type __VLS_TemplateResult_17 = ReturnType<typeof __VLS_template_17>;

declare type __VLS_TemplateResult_18 = ReturnType<typeof __VLS_template_18>;

declare type __VLS_TemplateResult_19 = ReturnType<typeof __VLS_template_19>;

declare type __VLS_TemplateResult_2 = ReturnType<typeof __VLS_template_2>;

declare type __VLS_TemplateResult_20 = ReturnType<typeof __VLS_template_20>;

declare type __VLS_TemplateResult_21 = ReturnType<typeof __VLS_template_21>;

declare type __VLS_TemplateResult_22 = ReturnType<typeof __VLS_template_22>;

declare type __VLS_TemplateResult_23 = ReturnType<typeof __VLS_template_23>;

declare type __VLS_TemplateResult_24 = ReturnType<typeof __VLS_template_24>;

declare type __VLS_TemplateResult_25 = ReturnType<typeof __VLS_template_25>;

declare type __VLS_TemplateResult_26 = ReturnType<typeof __VLS_template_26>;

declare type __VLS_TemplateResult_27 = ReturnType<typeof __VLS_template_27>;

declare type __VLS_TemplateResult_3 = ReturnType<typeof __VLS_template_3>;

declare type __VLS_TemplateResult_4 = ReturnType<typeof __VLS_template_4>;

declare type __VLS_TemplateResult_5 = ReturnType<typeof __VLS_template_5>;

declare type __VLS_TemplateResult_6 = ReturnType<typeof __VLS_template_6>;

declare type __VLS_TemplateResult_7 = ReturnType<typeof __VLS_template_7>;

declare type __VLS_TemplateResult_8 = ReturnType<typeof __VLS_template_8>;

declare type __VLS_TemplateResult_9 = ReturnType<typeof __VLS_template_9>;

declare type __VLS_WithTemplateSlots<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_10<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_11<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_12<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_13<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_14<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_15<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_16<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_17<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_18<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_19<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_2<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_20<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_21<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_22<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_23<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_24<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_25<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_26<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_27<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_3<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_4<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_5<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_6<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_7<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_8<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_9<T, S> = T & {
    new (): {
        $slots: S;
    };
};

/**
 * Action Button 정의 타입
 */
export declare type ActionButton = {
    /** 버튼 아이콘 이름 (lucide) - label이 없을 때 기본 텍스트 생성에 사용 */
    icon?: string;
    /** 버튼 라벨 */
    label?: string;
    /** 툴팁 텍스트 */
    tooltip?: string;
    /** 버튼 클릭 핸들러 (rowData 전달) */
    onClick: (rowData: any) => void;
    /** 버튼 스타일 타입 */
    styletype?: 'default' | 'primary' | 'secondary' | 'success' | 'warning' | 'danger';
    /** 조건부 표시 함수 (rowData를 받아 boolean 반환) */
    show?: (rowData: any) => boolean;
};

/**
 * 주소 검색 결과 (간소화)
 */
declare interface AddressResult {
    /** 우편번호 */
    zonecode: string;
    /** 주 주소 (도로명 또는 지번) */
    address: string;
    /** 상세 주소 (건물명 등 포함) */
    addressDetail?: string;
    /** 주소 타입 */
    addressType: AddressType;
    /** 언어 타입 */
    languageType: LanguageType;
    /** 시도 */
    sido?: string;
    /** 시군구 */
    sigungu?: string;
    /** 법정동명 */
    bname?: string;
}

/**
 * 주소 검색 관련 TypeScript 타입 정의
 * Daum Postcode API 기반
 */
/**
 * 주소 타입
 */
declare type AddressType = 'R' | 'J';

declare type BaseIconName = 'house' | 'user' | 'settings' | 'search' | 'plus' | 'minus' | 'squarePen' | 'trash2' | 'save' | 'download' | 'upload' | 'eye' | 'eyeOff' | 'heart' | 'star' | 'check' | 'x' | 'circleAlert' | 'info' | 'chevronDown' | 'chevronUp' | 'chevronLeft' | 'chevronRight' | 'menu' | 'ellipsis' | 'ellipsisVertical' | 'palette' | 'package' | 'packageCheck' | 'packageX' | 'truck' | 'warehouse' | 'boxes' | 'archive' | 'clipboardList' | 'clipboardCheck' | 'fileText' | 'chartBar' | 'trendingUp' | 'trendingDown' | 'calendar' | 'clock' | 'mapPin' | 'table' | 'list' | 'listFilter' | 'arrowUpWideNarrow' | 'arrowDownWideNarrow' | 'scale' | 'server' | 'database' | 'link' | 'arrowLeftRight' | 'circleQuestionMark' | 'monitor' | 'users' | 'code' | 'fileKey' | 'cpu' | 'rocket' | 'fileSpreadsheet' | 'activity' | 'messageCircle' | 'book' | 'logIn' | 'logOut' | 'copy' | 'clipboard' | 'undo2' | 'redo2' | 'pencil' | 'folder' | 'folderPlus' | 'folderOpen' | 'filePlus' | 'fileSearch' | 'filePen' | 'fileMinus' | 'mail' | 'send' | 'phone' | 'bell' | 'bellOff' | 'messageSquare' | 'arrowUp' | 'arrowDown' | 'arrowLeft' | 'arrowRight' | 'rotateCw' | 'rotateCcw' | 'refreshCw' | 'move' | 'circleCheckBig' | 'circleX' | 'circle' | 'lock' | 'lockOpen' | 'shield' | 'shieldCheck' | 'shieldAlert' | 'userPlus' | 'userMinus' | 'userCheck' | 'userX' | 'circleUser' | 'power' | 'zap' | 'target' | 'flag' | 'funnel' | 'building' | 'briefcase' | 'globe' | 'printer' | 'share2' | 'externalLink' | 'maximize2' | 'minimize2' | 'moveVertical' | 'moveHorizontal' | 'sun' | 'moon';

/**
 * JBreadcrumb - 브레드크럼 네비게이션 컴포넌트 (molecules)
 * Breadcrumb Navigation Component
 *
 * @description
 * 페이지의 네비게이션 경로를 표시하는 브레드크럼 컴포넌트입니다.
 *
 * Features:
 * - 경로 아이템 표시
 * - 클릭 가능한 링크 지원
 * - 아이콘 지원
 * - 커스터마이징 가능한 구분자
 *
 * @example
 * ```vue
 * <JBreadcrumb
 *   :items="[
 *     { label: '홈', href: '/' },
 *     { label: '제품', href: '/products' },
 *     { label: '상세' }
 *   ]"
 * />
 * ```
 */
export declare type BreadcrumbItem = {
    /** 라벨 텍스트 */
    label: string;
    /** 링크 URL (없으면 텍스트만 표시) */
    href?: string;
    /** 아이콘 이름 */
    icon?: string;
    /** 클릭 핸들러 */
    onClick?: () => void;
};

declare type ButtonGroupVariants = VariantProps<typeof buttonGroupVariants>;

declare const buttonGroupVariants: (props?: ({
    orientation?: "vertical" | "horizontal" | null | undefined;
} & ClassProp) | undefined) => string;

declare type ButtonVariants = VariantProps<typeof buttonVariants>;

declare const buttonVariants: (props?: ({
    variant?: "link" | "default" | "destructive" | "secondary" | "outline" | "ghost" | null | undefined;
    size?: "sm" | "lg" | "xs" | "md" | "icon" | null | undefined;
} & ClassProp) | undefined) => string;

declare type CardVariant = 'default' | 'elevated';

declare interface ComboboxOption {
    value: string | number;
    label: string;
}

declare type ComponentType = 'input' | 'textarea' | 'checkbox' | 'switch' | 'combo' | 'radio' | 'searchCombo' | 'searchInput' | 'datepicker' | 'editor' | 'dateRange' | 'numberRange';

/**
 * Context Menu Group 타입
 */
declare interface ContextMenuGroup {
    /** 그룹 라벨 (없으면 구분선만 표시) */
    label?: string;
    /** 그룹 내 아이템들 */
    items: ContextMenuItem[];
}

/**
 * Context Menu 관련 TypeScript 타입 정의
 */
/**
 * Context Menu Item 타입
 */
declare interface ContextMenuItem {
    /** 고유 식별자 */
    id: string;
    /** 메뉴 라벨 */
    label: string;
    /** 아이콘 (Lucide 아이콘 이름) */
    icon?: string;
    /** 단축키 표시 */
    shortcut?: string;
    /** 비활성화 여부 */
    disabled?: boolean;
    /** 클릭 핸들러 */
    onClick?: () => void;
    /** 구분선 표시 (이 아이템 이후) */
    separator?: boolean;
    /** 서브메뉴 아이템들 */
    children?: ContextMenuItem[];
}

declare type ControlStyleType = 'typeA' | 'typeB' | 'typeC';

declare type ControlType = string;

declare type CustomIconName = string;

export declare type DateRangeValue = {
    start: string | null;
    end: string | null;
};

declare interface DynamicFormField {
    controlId: string;
    controlName: string;
    label: string;
    type: ControlType;
    sortOrder: number;
    colSpan: number;
    options?: DynamicFormOption[];
    placeholder?: string;
    isRequired: boolean;
    isReadonly: boolean;
    isDisabled: boolean;
    optionSource?: string;
    addAll?: boolean;
    multiple?: boolean;
    dataType: string;
    maxLength?: number;
    validationRule?: string;
    inputType?: string;
    description?: string;
    inlineLabel?: string;
    showStateLabel?: boolean;
    activeLabel?: string;
    inactiveLabel?: string;
    rangeOptions?: {
        min?: string | number;
        max?: string | number;
        step?: number;
        suffix?: string;
        separator?: string;
        placeholder?: {
            start?: string;
            end?: string;
        };
    };
    events?: {
        onChange?: string;
        onFocus?: string;
        onBlur?: string;
        onSubmit?: string;
    };
    isVisible?: boolean;
}

declare interface DynamicFormOption {
    label: string;
    value: string;
}

/**
 * 동적 탭 아이템 인터페이스
 * Dynamic tab item interface
 */
declare interface DynamicTab {
    /** 탭의 고유 식별자 (Unique identifier for the tab) */
    id: string;
    /** 탭에 표시될 레이블 (Label to display on the tab) */
    label: string;
    /** 탭 닫기 가능 여부 (Whether the tab can be closed) */
    closable?: boolean;
    /** 탭 콘텐츠로 렌더링할 컴포넌트 (Component to render as tab content) */
    component?: Component | string;
    /** 컴포넌트에 전달할 props (Props to pass to the component) */
    props?: Record<string, any>;
    /** 탭 아이콘 (Optional icon for the tab) */
    icon?: string;
    /** 메타 데이터 (Additional metadata) */
    meta?: Record<string, any>;
    /** 이 탭의 KeepAlive 설정 (JTabs의 keepAlive보다 우선) */
    keepAlive?: boolean;
}

export declare const ExampleCrudPage: DefineComponent<    {}, {
gridRef: Ref<any, any>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {
gridRef: CreateComponentPublicInstanceWithMixins<Readonly<{
class?: string;
rowData: any[];
columnDefs: ColDef[];
pagination?: boolean;
checkbox?: boolean;
rowNumbers?: boolean;
floatingFilters?: boolean;
floatingFilter?: boolean;
rowNumberWidth?: number;
actionButtons?: ActionButton[];
summaryColumn?: boolean;
hiddenColumn?: boolean;
enableGrouping?: boolean;
enablePivot?: boolean;
enableExcelExport?: boolean;
enableTreeData?: boolean;
getDataPath?: (data: any) => (string | number)[];
autoGroupColumnDef?: ColDef;
selectedRows?: any[];
columnHover?: boolean;
enableColumnsToolPanel?: boolean;
statusBar?: boolean;
compactFooter?: boolean;
rowGroupPanelShow?: "always" | "onlyWhenGrouping" | "never";
groupDefaultExpanded?: number;
pivotPanelShow?: "always" | "onlyWhenPivoting" | "never";
pivotMode?: boolean;
rowDragManaged?: boolean;
rowDragEntireRow?: boolean;
rowDragMultiRow?: boolean;
reactiveRowData?: boolean;
}> & Readonly<{
onRowClicked?: ((event: RowClickedEvent<any, any>) => any) | undefined;
onRowDoubleClicked?: ((event: RowDoubleClickedEvent<any, any>) => any) | undefined;
onCellClicked?: ((event: CellClickedEvent<any, any, any>) => any) | undefined;
onSelectionChanged?: ((event: SelectionChangedEvent<any, any>) => any) | undefined;
onCellValueChanged?: ((event: CellValueChangedEvent<any, any, any>) => any) | undefined;
onGridReady?: ((event: GridReadyEvent<any, any>) => any) | undefined;
"onUpdate:selectedRows"?: ((rows: any[]) => any) | undefined;
}>, {
gridApi: Ref<any, any>;
gridColumnApi: Ref<any, any>;
exportToExcel: () => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
rowClicked: (event: RowClickedEvent<any, any>) => any;
rowDoubleClicked: (event: RowDoubleClickedEvent<any, any>) => any;
cellClicked: (event: CellClickedEvent<any, any, any>) => any;
selectionChanged: (event: SelectionChangedEvent<any, any>) => any;
cellValueChanged: (event: CellValueChangedEvent<any, any, any>) => any;
gridReady: (event: GridReadyEvent<any, any>) => any;
"update:selectedRows": (rows: any[]) => any;
}, PublicProps, {
pagination: boolean;
checkbox: boolean;
rowNumbers: boolean;
floatingFilters: boolean;
floatingFilter: boolean;
rowNumberWidth: number;
actionButtons: ActionButton[];
summaryColumn: boolean;
hiddenColumn: boolean;
enableGrouping: boolean;
enablePivot: boolean;
enableExcelExport: boolean;
enableTreeData: boolean;
getDataPath: (data: any) => (string | number)[];
autoGroupColumnDef: ColDef;
selectedRows: any[];
columnHover: boolean;
enableColumnsToolPanel: boolean;
statusBar: boolean;
compactFooter: boolean;
rowGroupPanelShow: "always" | "onlyWhenGrouping" | "never";
groupDefaultExpanded: number;
pivotPanelShow: "always" | "onlyWhenPivoting" | "never";
pivotMode: boolean;
rowDragManaged: boolean;
rowDragEntireRow: boolean;
rowDragMultiRow: boolean;
reactiveRowData: boolean;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {
gridContainerRef: HTMLDivElement;
}, HTMLDivElement, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<{
class?: string;
rowData: any[];
columnDefs: ColDef[];
pagination?: boolean;
checkbox?: boolean;
rowNumbers?: boolean;
floatingFilters?: boolean;
floatingFilter?: boolean;
rowNumberWidth?: number;
actionButtons?: ActionButton[];
summaryColumn?: boolean;
hiddenColumn?: boolean;
enableGrouping?: boolean;
enablePivot?: boolean;
enableExcelExport?: boolean;
enableTreeData?: boolean;
getDataPath?: (data: any) => (string | number)[];
autoGroupColumnDef?: ColDef;
selectedRows?: any[];
columnHover?: boolean;
enableColumnsToolPanel?: boolean;
statusBar?: boolean;
compactFooter?: boolean;
rowGroupPanelShow?: "always" | "onlyWhenGrouping" | "never";
groupDefaultExpanded?: number;
pivotPanelShow?: "always" | "onlyWhenPivoting" | "never";
pivotMode?: boolean;
rowDragManaged?: boolean;
rowDragEntireRow?: boolean;
rowDragMultiRow?: boolean;
reactiveRowData?: boolean;
}> & Readonly<{
onRowClicked?: ((event: RowClickedEvent<any, any>) => any) | undefined;
onRowDoubleClicked?: ((event: RowDoubleClickedEvent<any, any>) => any) | undefined;
onCellClicked?: ((event: CellClickedEvent<any, any, any>) => any) | undefined;
onSelectionChanged?: ((event: SelectionChangedEvent<any, any>) => any) | undefined;
onCellValueChanged?: ((event: CellValueChangedEvent<any, any, any>) => any) | undefined;
onGridReady?: ((event: GridReadyEvent<any, any>) => any) | undefined;
"onUpdate:selectedRows"?: ((rows: any[]) => any) | undefined;
}>, {
gridApi: Ref<any, any>;
gridColumnApi: Ref<any, any>;
exportToExcel: () => void;
}, {}, {}, {}, {
pagination: boolean;
checkbox: boolean;
rowNumbers: boolean;
floatingFilters: boolean;
floatingFilter: boolean;
rowNumberWidth: number;
actionButtons: ActionButton[];
summaryColumn: boolean;
hiddenColumn: boolean;
enableGrouping: boolean;
enablePivot: boolean;
enableExcelExport: boolean;
enableTreeData: boolean;
getDataPath: (data: any) => (string | number)[];
autoGroupColumnDef: ColDef;
selectedRows: any[];
columnHover: boolean;
enableColumnsToolPanel: boolean;
statusBar: boolean;
compactFooter: boolean;
rowGroupPanelShow: "always" | "onlyWhenGrouping" | "never";
groupDefaultExpanded: number;
pivotPanelShow: "always" | "onlyWhenPivoting" | "never";
pivotMode: boolean;
rowDragManaged: boolean;
rowDragEntireRow: boolean;
rowDragMultiRow: boolean;
reactiveRowData: boolean;
}> | null;
}, HTMLDivElement>;

export declare const ExampleFullCrudPage: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;

export declare const ExampleTabMappingPage: DefineComponent<    {}, {
masterGridRef: Ref<any, any>;
mappingMasterGridRef: Ref<any, any>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {
masterGridRef: CreateComponentPublicInstanceWithMixins<Readonly<{
class?: string;
rowData: any[];
columnDefs: ColDef[];
pagination?: boolean;
checkbox?: boolean;
rowNumbers?: boolean;
floatingFilters?: boolean;
floatingFilter?: boolean;
rowNumberWidth?: number;
actionButtons?: ActionButton[];
summaryColumn?: boolean;
hiddenColumn?: boolean;
enableGrouping?: boolean;
enablePivot?: boolean;
enableExcelExport?: boolean;
enableTreeData?: boolean;
getDataPath?: (data: any) => (string | number)[];
autoGroupColumnDef?: ColDef;
selectedRows?: any[];
columnHover?: boolean;
enableColumnsToolPanel?: boolean;
statusBar?: boolean;
compactFooter?: boolean;
rowGroupPanelShow?: "always" | "onlyWhenGrouping" | "never";
groupDefaultExpanded?: number;
pivotPanelShow?: "always" | "onlyWhenPivoting" | "never";
pivotMode?: boolean;
rowDragManaged?: boolean;
rowDragEntireRow?: boolean;
rowDragMultiRow?: boolean;
reactiveRowData?: boolean;
}> & Readonly<{
onRowClicked?: ((event: RowClickedEvent<any, any>) => any) | undefined;
onRowDoubleClicked?: ((event: RowDoubleClickedEvent<any, any>) => any) | undefined;
onCellClicked?: ((event: CellClickedEvent<any, any, any>) => any) | undefined;
onSelectionChanged?: ((event: SelectionChangedEvent<any, any>) => any) | undefined;
onCellValueChanged?: ((event: CellValueChangedEvent<any, any, any>) => any) | undefined;
onGridReady?: ((event: GridReadyEvent<any, any>) => any) | undefined;
"onUpdate:selectedRows"?: ((rows: any[]) => any) | undefined;
}>, {
gridApi: Ref<any, any>;
gridColumnApi: Ref<any, any>;
exportToExcel: () => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
rowClicked: (event: RowClickedEvent<any, any>) => any;
rowDoubleClicked: (event: RowDoubleClickedEvent<any, any>) => any;
cellClicked: (event: CellClickedEvent<any, any, any>) => any;
selectionChanged: (event: SelectionChangedEvent<any, any>) => any;
cellValueChanged: (event: CellValueChangedEvent<any, any, any>) => any;
gridReady: (event: GridReadyEvent<any, any>) => any;
"update:selectedRows": (rows: any[]) => any;
}, PublicProps, {
pagination: boolean;
checkbox: boolean;
rowNumbers: boolean;
floatingFilters: boolean;
floatingFilter: boolean;
rowNumberWidth: number;
actionButtons: ActionButton[];
summaryColumn: boolean;
hiddenColumn: boolean;
enableGrouping: boolean;
enablePivot: boolean;
enableExcelExport: boolean;
enableTreeData: boolean;
getDataPath: (data: any) => (string | number)[];
autoGroupColumnDef: ColDef;
selectedRows: any[];
columnHover: boolean;
enableColumnsToolPanel: boolean;
statusBar: boolean;
compactFooter: boolean;
rowGroupPanelShow: "always" | "onlyWhenGrouping" | "never";
groupDefaultExpanded: number;
pivotPanelShow: "always" | "onlyWhenPivoting" | "never";
pivotMode: boolean;
rowDragManaged: boolean;
rowDragEntireRow: boolean;
rowDragMultiRow: boolean;
reactiveRowData: boolean;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {
gridContainerRef: HTMLDivElement;
}, HTMLDivElement, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<{
class?: string;
rowData: any[];
columnDefs: ColDef[];
pagination?: boolean;
checkbox?: boolean;
rowNumbers?: boolean;
floatingFilters?: boolean;
floatingFilter?: boolean;
rowNumberWidth?: number;
actionButtons?: ActionButton[];
summaryColumn?: boolean;
hiddenColumn?: boolean;
enableGrouping?: boolean;
enablePivot?: boolean;
enableExcelExport?: boolean;
enableTreeData?: boolean;
getDataPath?: (data: any) => (string | number)[];
autoGroupColumnDef?: ColDef;
selectedRows?: any[];
columnHover?: boolean;
enableColumnsToolPanel?: boolean;
statusBar?: boolean;
compactFooter?: boolean;
rowGroupPanelShow?: "always" | "onlyWhenGrouping" | "never";
groupDefaultExpanded?: number;
pivotPanelShow?: "always" | "onlyWhenPivoting" | "never";
pivotMode?: boolean;
rowDragManaged?: boolean;
rowDragEntireRow?: boolean;
rowDragMultiRow?: boolean;
reactiveRowData?: boolean;
}> & Readonly<{
onRowClicked?: ((event: RowClickedEvent<any, any>) => any) | undefined;
onRowDoubleClicked?: ((event: RowDoubleClickedEvent<any, any>) => any) | undefined;
onCellClicked?: ((event: CellClickedEvent<any, any, any>) => any) | undefined;
onSelectionChanged?: ((event: SelectionChangedEvent<any, any>) => any) | undefined;
onCellValueChanged?: ((event: CellValueChangedEvent<any, any, any>) => any) | undefined;
onGridReady?: ((event: GridReadyEvent<any, any>) => any) | undefined;
"onUpdate:selectedRows"?: ((rows: any[]) => any) | undefined;
}>, {
gridApi: Ref<any, any>;
gridColumnApi: Ref<any, any>;
exportToExcel: () => void;
}, {}, {}, {}, {
pagination: boolean;
checkbox: boolean;
rowNumbers: boolean;
floatingFilters: boolean;
floatingFilter: boolean;
rowNumberWidth: number;
actionButtons: ActionButton[];
summaryColumn: boolean;
hiddenColumn: boolean;
enableGrouping: boolean;
enablePivot: boolean;
enableExcelExport: boolean;
enableTreeData: boolean;
getDataPath: (data: any) => (string | number)[];
autoGroupColumnDef: ColDef;
selectedRows: any[];
columnHover: boolean;
enableColumnsToolPanel: boolean;
statusBar: boolean;
compactFooter: boolean;
rowGroupPanelShow: "always" | "onlyWhenGrouping" | "never";
groupDefaultExpanded: number;
pivotPanelShow: "always" | "onlyWhenPivoting" | "never";
pivotMode: boolean;
rowDragManaged: boolean;
rowDragEntireRow: boolean;
rowDragMultiRow: boolean;
reactiveRowData: boolean;
}> | null;
mappingMasterGridRef: CreateComponentPublicInstanceWithMixins<Readonly<{
class?: string;
rowData: any[];
columnDefs: ColDef[];
pagination?: boolean;
checkbox?: boolean;
rowNumbers?: boolean;
floatingFilters?: boolean;
floatingFilter?: boolean;
rowNumberWidth?: number;
actionButtons?: ActionButton[];
summaryColumn?: boolean;
hiddenColumn?: boolean;
enableGrouping?: boolean;
enablePivot?: boolean;
enableExcelExport?: boolean;
enableTreeData?: boolean;
getDataPath?: (data: any) => (string | number)[];
autoGroupColumnDef?: ColDef;
selectedRows?: any[];
columnHover?: boolean;
enableColumnsToolPanel?: boolean;
statusBar?: boolean;
compactFooter?: boolean;
rowGroupPanelShow?: "always" | "onlyWhenGrouping" | "never";
groupDefaultExpanded?: number;
pivotPanelShow?: "always" | "onlyWhenPivoting" | "never";
pivotMode?: boolean;
rowDragManaged?: boolean;
rowDragEntireRow?: boolean;
rowDragMultiRow?: boolean;
reactiveRowData?: boolean;
}> & Readonly<{
onRowClicked?: ((event: RowClickedEvent<any, any>) => any) | undefined;
onRowDoubleClicked?: ((event: RowDoubleClickedEvent<any, any>) => any) | undefined;
onCellClicked?: ((event: CellClickedEvent<any, any, any>) => any) | undefined;
onSelectionChanged?: ((event: SelectionChangedEvent<any, any>) => any) | undefined;
onCellValueChanged?: ((event: CellValueChangedEvent<any, any, any>) => any) | undefined;
onGridReady?: ((event: GridReadyEvent<any, any>) => any) | undefined;
"onUpdate:selectedRows"?: ((rows: any[]) => any) | undefined;
}>, {
gridApi: Ref<any, any>;
gridColumnApi: Ref<any, any>;
exportToExcel: () => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
rowClicked: (event: RowClickedEvent<any, any>) => any;
rowDoubleClicked: (event: RowDoubleClickedEvent<any, any>) => any;
cellClicked: (event: CellClickedEvent<any, any, any>) => any;
selectionChanged: (event: SelectionChangedEvent<any, any>) => any;
cellValueChanged: (event: CellValueChangedEvent<any, any, any>) => any;
gridReady: (event: GridReadyEvent<any, any>) => any;
"update:selectedRows": (rows: any[]) => any;
}, PublicProps, {
pagination: boolean;
checkbox: boolean;
rowNumbers: boolean;
floatingFilters: boolean;
floatingFilter: boolean;
rowNumberWidth: number;
actionButtons: ActionButton[];
summaryColumn: boolean;
hiddenColumn: boolean;
enableGrouping: boolean;
enablePivot: boolean;
enableExcelExport: boolean;
enableTreeData: boolean;
getDataPath: (data: any) => (string | number)[];
autoGroupColumnDef: ColDef;
selectedRows: any[];
columnHover: boolean;
enableColumnsToolPanel: boolean;
statusBar: boolean;
compactFooter: boolean;
rowGroupPanelShow: "always" | "onlyWhenGrouping" | "never";
groupDefaultExpanded: number;
pivotPanelShow: "always" | "onlyWhenPivoting" | "never";
pivotMode: boolean;
rowDragManaged: boolean;
rowDragEntireRow: boolean;
rowDragMultiRow: boolean;
reactiveRowData: boolean;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {
gridContainerRef: HTMLDivElement;
}, HTMLDivElement, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<{
class?: string;
rowData: any[];
columnDefs: ColDef[];
pagination?: boolean;
checkbox?: boolean;
rowNumbers?: boolean;
floatingFilters?: boolean;
floatingFilter?: boolean;
rowNumberWidth?: number;
actionButtons?: ActionButton[];
summaryColumn?: boolean;
hiddenColumn?: boolean;
enableGrouping?: boolean;
enablePivot?: boolean;
enableExcelExport?: boolean;
enableTreeData?: boolean;
getDataPath?: (data: any) => (string | number)[];
autoGroupColumnDef?: ColDef;
selectedRows?: any[];
columnHover?: boolean;
enableColumnsToolPanel?: boolean;
statusBar?: boolean;
compactFooter?: boolean;
rowGroupPanelShow?: "always" | "onlyWhenGrouping" | "never";
groupDefaultExpanded?: number;
pivotPanelShow?: "always" | "onlyWhenPivoting" | "never";
pivotMode?: boolean;
rowDragManaged?: boolean;
rowDragEntireRow?: boolean;
rowDragMultiRow?: boolean;
reactiveRowData?: boolean;
}> & Readonly<{
onRowClicked?: ((event: RowClickedEvent<any, any>) => any) | undefined;
onRowDoubleClicked?: ((event: RowDoubleClickedEvent<any, any>) => any) | undefined;
onCellClicked?: ((event: CellClickedEvent<any, any, any>) => any) | undefined;
onSelectionChanged?: ((event: SelectionChangedEvent<any, any>) => any) | undefined;
onCellValueChanged?: ((event: CellValueChangedEvent<any, any, any>) => any) | undefined;
onGridReady?: ((event: GridReadyEvent<any, any>) => any) | undefined;
"onUpdate:selectedRows"?: ((rows: any[]) => any) | undefined;
}>, {
gridApi: Ref<any, any>;
gridColumnApi: Ref<any, any>;
exportToExcel: () => void;
}, {}, {}, {}, {
pagination: boolean;
checkbox: boolean;
rowNumbers: boolean;
floatingFilters: boolean;
floatingFilter: boolean;
rowNumberWidth: number;
actionButtons: ActionButton[];
summaryColumn: boolean;
hiddenColumn: boolean;
enableGrouping: boolean;
enablePivot: boolean;
enableExcelExport: boolean;
enableTreeData: boolean;
getDataPath: (data: any) => (string | number)[];
autoGroupColumnDef: ColDef;
selectedRows: any[];
columnHover: boolean;
enableColumnsToolPanel: boolean;
statusBar: boolean;
compactFooter: boolean;
rowGroupPanelShow: "always" | "onlyWhenGrouping" | "never";
groupDefaultExpanded: number;
pivotPanelShow: "always" | "onlyWhenPivoting" | "never";
pivotMode: boolean;
rowDragManaged: boolean;
rowDragEntireRow: boolean;
rowDragMultiRow: boolean;
reactiveRowData: boolean;
}> | null;
}, any>;

/** 필터 설정 타입 */
declare interface FilterDisplayItem {
    /** 표시할 라벨 */
    label: string;
    /** 값을 표시용 문자열로 변환 (예: combo value -> label) */
    displayValue?: (value: unknown) => string;
}

declare interface FormSchema {
    id: string;
    name: string;
    type: 'simple' | 'sectioned' | 'wizard' | 'conditional';
    fields?: DynamicFormField[];
    sections?: FormSection[];
    steps?: FormStep[];
    layout?: {
        columns?: number;
    };
    globalStyle?: GlobalStyle;
    events?: {
        onSubmit?: (values: Record<string, any>) => void;
        onChange?: (field: string, value: any) => void;
        onError?: (errors: any) => void;
    };
}

declare interface FormSection {
    id: string;
    title: string;
    collapsible: boolean;
    defaultCollapsed: boolean;
    fields: DynamicFormField[];
}

declare interface FormStep {
    id: string;
    title: string;
    description?: string;
    fields: DynamicFormField[];
}

declare interface GlobalStyle {
    colCount?: 'row-1' | 'row' | 'row-3' | 'row-4' | 'row-5' | 'row-6' | 'row-7' | 'row-8';
    labelPosition?: 'horizontal' | 'vertical';
    labelAlign?: 'left' | 'middle' | 'right';
    styleType?: ControlStyleType;
    controlSize?: 'sm' | 'md' | 'lg';
    variant?: 'default' | 'outline' | 'secondary' | 'destructive' | 'ghost';
}

declare interface GroupedOption {
    groupLabel: string;
    options: Option_4[];
}

declare function handleError(errs: any): void;

declare function handleSubmit(): void;

/**
 * JHeader - 상단 헤더 컴포넌트 (organisms)
 * Header Component
 *
 * @description
 * 애플리케이션의 상단 헤더 영역을 담당하는 컴포넌트입니다.
 * 로고, 네비게이션, 검색, 알림, 사용자 메뉴 등을 포함할 수 있습니다.
 *
 * @example
 * ```vue
 * <JHeader
 *   logo="/logo.png"
 *   :user-menu-items="userMenuItems"
 *   @logo-click="handleLogoClick"
 * />
 * ```
 */
export declare type HeaderNavItem = {
    /** 라벨 */
    label: string;
    /** 링크 URL */
    href?: string;
    /** 아이콘 */
    icon?: string;
    /** 활성 상태 */
    active?: boolean;
    /** 클릭 핸들러 */
    onClick?: () => void;
};

declare type IconName = BaseIconName | CustomIconName;

export declare const JAccordion: __VLS_WithTemplateSlots_15<typeof __VLS_component_15, __VLS_TemplateResult_15["slots"]>;

declare interface JAccordionItem {
    /** 아이템 고유값 */
    value: string;
    /** 트리거(제목) 텍스트 */
    title?: string;
    /** 내용 텍스트 */
    content?: string;
    /** 비활성화 여부 */
    disabled?: boolean;
}

export declare const JAlert: __VLS_WithTemplateSlots_14<typeof __VLS_component_14, __VLS_TemplateResult_14["slots"]>;

export declare const JAvatar: DefineComponent<__VLS_Props_17, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_17> & Readonly<{}>, {
size: Size;
shape: Shape;
styletype: StyleType_15;
alt: string;
fallback: string;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

export declare const JBadge: __VLS_WithTemplateSlots_4<typeof __VLS_component_4, __VLS_TemplateResult_4["slots"]>;

export declare const JBreadcrumb: DefineComponent<__VLS_Props_35, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
itemClick: (item: BreadcrumbItem, index: number) => any;
}, string, PublicProps, Readonly<__VLS_Props_35> & Readonly<{
onItemClick?: ((item: BreadcrumbItem, index: number) => any) | undefined;
}>, {
styletype: StyleType_24;
separator: string;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLElement>;

export declare const JButton: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;

export declare const JButtonGroup: __VLS_WithTemplateSlots_17<typeof __VLS_component_17, __VLS_TemplateResult_17["slots"]>;

export declare const JCard: __VLS_WithTemplateSlots_13<typeof __VLS_component_13, __VLS_TemplateResult_13["slots"]>;

export declare const JCheckbox: DefineComponent<__VLS_Props_4, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (value: string) => any;
change: (value: string) => any;
}, string, PublicProps, Readonly<__VLS_Props_4> & Readonly<{
"onUpdate:modelValue"?: ((value: string) => any) | undefined;
onChange?: ((value: string) => any) | undefined;
}>, {
disabled: boolean;
modelValue: string;
required: boolean;
styletype: StyleType_4;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

export declare const JCombo: DefineComponent<__VLS_Props_5, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (value: string | number) => any;
change: (value: string | number) => any;
focus: (event: FocusEvent) => any;
blur: (event: FocusEvent) => any;
}, string, PublicProps, Readonly<__VLS_Props_5> & Readonly<{
"onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
onChange?: ((value: string | number) => any) | undefined;
onFocus?: ((event: FocusEvent) => any) | undefined;
onBlur?: ((event: FocusEvent) => any) | undefined;
}>, {
disabled: boolean;
multiple: boolean;
placeholder: string;
required: boolean;
styletype: StyleType_5;
options: Option_2[];
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

export declare const JContextMenu: __VLS_WithTemplateSlots_12<typeof __VLS_component_12, __VLS_TemplateResult_12["slots"]>;

/**
 * JContextMenu Props 인터페이스
 */
declare interface JContextMenuProps {
    /** 메뉴 구조 (아이템 배열) */
    items: ContextMenuGroup[];
    /** 비활성화 여부 */
    disabled?: boolean;
    /** 추가 CSS 클래스 */
    class?: string;
}

export declare const JDatepicker: DefineComponent<__VLS_Props_9, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (value: string | null) => any;
change: (value: string | null) => any;
focus: (event: FocusEvent) => any;
blur: (event: FocusEvent) => any;
}, string, PublicProps, Readonly<__VLS_Props_9> & Readonly<{
"onUpdate:modelValue"?: ((value: string | null) => any) | undefined;
onChange?: ((value: string | null) => any) | undefined;
onFocus?: ((event: FocusEvent) => any) | undefined;
onBlur?: ((event: FocusEvent) => any) | undefined;
}>, {
placeholder: string;
styletype: "default" | "sm" | "lg";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

export declare const JDateRangeField: DefineComponent<__VLS_Props_28, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (value: DateRangeValue) => any;
change: (value: DateRangeValue) => any;
focus: (event: FocusEvent) => any;
blur: (event: FocusEvent) => any;
}, string, PublicProps, Readonly<__VLS_Props_28> & Readonly<{
"onUpdate:modelValue"?: ((value: DateRangeValue) => any) | undefined;
onChange?: ((value: DateRangeValue) => any) | undefined;
onFocus?: ((event: FocusEvent) => any) | undefined;
onBlur?: ((event: FocusEvent) => any) | undefined;
}>, {
separator: string;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

export declare const JDivider: DefineComponent<__VLS_Props_10, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_10> & Readonly<{}>, {
orientation: "horizontal" | "vertical";
styletype: StyleType_9;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

export declare const JDrawer: __VLS_WithTemplateSlots_25<typeof __VLS_component_25, __VLS_TemplateResult_25["slots"]>;

export declare interface JDrawerProps {
    open: boolean;
    side?: SheetSide;
    size?: 'sm' | 'md' | 'lg' | 'full';
    title?: string;
    description?: string;
    showClose?: boolean;
    showFooter?: boolean;
    buttonType?: 'Ok' | 'OkCancel';
    confirmText?: string;
    cancelText?: string;
    confirmVariant?: ButtonVariants['variant'];
    confirmDisabled?: boolean;
    closeOnOverlayClick?: boolean;
    closeOnEscape?: boolean;
    resizable?: boolean;
    minSize?: number;
    maxSize?: number;
    defaultSize?: number;
}

export declare const JDynamicForm: DefineComponent<__VLS_Props_36, {
formState: Record<string, any>;
submit: typeof handleSubmit;
reset: typeof reset;
handleError: typeof handleError;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (...args: any[]) => void;
error: (...args: any[]) => void;
submit: (...args: any[]) => void;
change: (...args: any[]) => void;
}, string, PublicProps, Readonly<__VLS_Props_36> & Readonly<{
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
onError?: ((...args: any[]) => any) | undefined;
onSubmit?: ((...args: any[]) => any) | undefined;
onChange?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLFormElement>;

export declare const JDynamicTabs: __VLS_WithTemplateSlots_19<typeof __VLS_component_19, __VLS_TemplateResult_19["slots"]>;

/**
 * JDynamicTabs Props 인터페이스 (organisms)
 * JDynamicTabs Props interface for dynamic tabs
 */
declare interface JDynamicTabsProps {
    /** 초기 탭 배열 (Initial tabs array) */
    initialTabs?: DynamicTab[];
    /** 기본 활성화 탭 ID (Default active tab ID) */
    defaultActiveId?: string;
    /** 최대 탭 개수 (Maximum number of tabs, 0 = unlimited) */
    maxTabs?: number;
    /** 탭이 없을 때 표시할 메시지 (Message to show when no tabs) */
    emptyMessage?: string;
    /** 루트 컨테이너 추가 클래스 (Additional class for root container) */
    class?: string;
    /** 콘텐츠 영역 추가 클래스 (Additional class for content area) */
    contentClass?: string;
    /** 스타일 타입 */
    styletype?: 'default' | 'minimal';
    /** 비활성 탭 DOM/인스턴스 유지 여부 (JTabs로 pass-through) */
    keepAlive?: boolean;
}

export declare const JEditor: DefineComponent<__VLS_Props_11, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (value: string) => any;
change: (value: string) => any;
save: (value: string) => any;
}, string, PublicProps, Readonly<__VLS_Props_11> & Readonly<{
"onUpdate:modelValue"?: ((value: string) => any) | undefined;
onChange?: ((value: string) => any) | undefined;
onSave?: ((value: string) => any) | undefined;
}>, {
disabled: boolean;
modelValue: string;
placeholder: string;
height: string | number;
readonly: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

export declare const JEmptyState: __VLS_WithTemplateSlots_18<typeof __VLS_component_18, __VLS_TemplateResult_18["slots"]>;

declare interface JEmptyStateProps {
    /** 아이콘 이름 */
    icon?: string;
    /** 제목 */
    title?: string;
    /** 설명 */
    description?: string;
    /** 액션 버튼 텍스트 */
    actionText?: string;
    /** variant */
    variant?: 'default' | 'simple';
    /** 추가 CSS 클래스 */
    class?: string;
}

export declare const JFilterBar: __VLS_WithTemplateSlots_22<typeof __VLS_component_22, __VLS_TemplateResult_22["slots"]>;

declare interface JFilterBarProps {
    /** 추가 클래스 (외부 커스터마이징용) */
    class?: string;
    /** 필터바 타이틀 */
    title?: string;
    /** 필터 접힘 상태 (v-model 지원) */
    collapsed?: boolean;
    /** 접기/펼치기 가능 여부. false면 토글 버튼 숨김 & 필터 항상 표시 */
    collapsible?: boolean;
    /** 필터 값 객체 (v-model:filterValues 지원) */
    filterValues?: Record<string, unknown>;
    /** 필터 표시 설정 (label, displayValue 등) */
    filterDisplay?: Record<string, FilterDisplayItem>;
    /** 초기화 버튼 표시 여부 */
    showResetButton?: boolean;
    /** 조회 버튼 표시 여부 */
    showSearchButton?: boolean;
    /** 초기화 버튼 텍스트 */
    resetButtonText?: string;
    /** 조회 버튼 텍스트 */
    searchButtonText?: string;
}

export declare const JFormField: __VLS_WithTemplateSlots_10<typeof __VLS_component_10, __VLS_TemplateResult_10["slots"]>;

export declare const JFormModal: __VLS_WithTemplateSlots_21<typeof __VLS_component_21, __VLS_TemplateResult_21["slots"]>;

declare interface JFormModalProps {
    open: boolean;
    title?: string;
    description?: string;
    schema?: FormSchema;
    modelValue?: Record<string, any>;
    size?: 'sm' | 'md' | 'lg' | 'xl' | '2xl' | 'full';
    buttonType?: 'Ok' | 'OkCancel';
    confirmText?: string;
    cancelText?: string;
    confirmVariant?: 'default' | 'destructive' | 'outline' | 'secondary' | 'ghost' | 'link';
    confirmDisabled?: boolean;
}

export declare const JGrid: DefineComponent<__VLS_Props_24, {
gridApi: Ref<any, any>;
gridColumnApi: Ref<any, any>;
exportToExcel: () => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
rowClicked: (event: RowClickedEvent<any, any>) => any;
rowDoubleClicked: (event: RowDoubleClickedEvent<any, any>) => any;
cellClicked: (event: CellClickedEvent<any, any, any>) => any;
selectionChanged: (event: SelectionChangedEvent<any, any>) => any;
cellValueChanged: (event: CellValueChangedEvent<any, any, any>) => any;
gridReady: (event: GridReadyEvent<any, any>) => any;
"update:selectedRows": (rows: any[]) => any;
}, string, PublicProps, Readonly<__VLS_Props_24> & Readonly<{
onRowClicked?: ((event: RowClickedEvent<any, any>) => any) | undefined;
onRowDoubleClicked?: ((event: RowDoubleClickedEvent<any, any>) => any) | undefined;
onCellClicked?: ((event: CellClickedEvent<any, any, any>) => any) | undefined;
onSelectionChanged?: ((event: SelectionChangedEvent<any, any>) => any) | undefined;
onCellValueChanged?: ((event: CellValueChangedEvent<any, any, any>) => any) | undefined;
onGridReady?: ((event: GridReadyEvent<any, any>) => any) | undefined;
"onUpdate:selectedRows"?: ((rows: any[]) => any) | undefined;
}>, {
pagination: boolean;
checkbox: boolean;
rowNumbers: boolean;
floatingFilters: boolean;
floatingFilter: boolean;
rowNumberWidth: number;
actionButtons: ActionButton[];
summaryColumn: boolean;
hiddenColumn: boolean;
enableGrouping: boolean;
enablePivot: boolean;
enableExcelExport: boolean;
enableTreeData: boolean;
getDataPath: (data: any) => (string | number)[];
autoGroupColumnDef: ColDef;
selectedRows: any[];
columnHover: boolean;
enableColumnsToolPanel: boolean;
statusBar: boolean;
compactFooter: boolean;
rowGroupPanelShow: "always" | "onlyWhenGrouping" | "never";
groupDefaultExpanded: number;
pivotPanelShow: "always" | "onlyWhenPivoting" | "never";
pivotMode: boolean;
rowDragManaged: boolean;
rowDragEntireRow: boolean;
rowDragMultiRow: boolean;
reactiveRowData: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {
gridContainerRef: HTMLDivElement;
}, HTMLDivElement>;

export declare const JGroupCombo: DefineComponent<__VLS_Props_30, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (value: string | number) => any;
change: (value: string | number) => any;
focus: (event: FocusEvent) => any;
blur: (event: FocusEvent) => any;
}, string, PublicProps, Readonly<__VLS_Props_30> & Readonly<{
"onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
onChange?: ((value: string | number) => any) | undefined;
onFocus?: ((event: FocusEvent) => any) | undefined;
onBlur?: ((event: FocusEvent) => any) | undefined;
}>, {
disabled: boolean;
placeholder: string;
required: boolean;
styletype: StyleType_22;
groupedOptions: GroupedOption[];
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

export declare const JHeader: __VLS_WithTemplateSlots_23<typeof __VLS_component_23, __VLS_TemplateResult_23["slots"]>;

export declare const JIcon: DefineComponent<__VLS_Props_20, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_20> & Readonly<{}>, {
size: SizeType_3;
role: string;
styletype: StyleType_18;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

export declare const JImage: DefineComponent<__VLS_Props_13, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: MouseEvent) => any;
mouseover: (event: MouseEvent) => any;
mouseout: (event: MouseEvent) => any;
}, string, PublicProps, Readonly<__VLS_Props_13> & Readonly<{
onClick?: ((event: MouseEvent) => any) | undefined;
onMouseover?: ((event: MouseEvent) => any) | undefined;
onMouseout?: ((event: MouseEvent) => any) | undefined;
}>, {
placeholder: string;
styletype: StyleType_11;
alt: string;
errorText: string;
clickable: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

export declare const JInput: __VLS_WithTemplateSlots_2<typeof __VLS_component_2, __VLS_TemplateResult_2["slots"]>;

export declare const JKbd: __VLS_WithTemplateSlots_5<typeof __VLS_component_5, __VLS_TemplateResult_5["slots"]>;

export declare const JLabel: __VLS_WithTemplateSlots_7<typeof __VLS_component_7, __VLS_TemplateResult_7["slots"]>;

export declare const JLayout: __VLS_WithTemplateSlots_26<typeof __VLS_component_26, __VLS_TemplateResult_26["slots"]>;

export { JLayoutAdvanced }

export declare const JLayoutSimple: __VLS_WithTemplateSlots_27<typeof __VLS_component_27, __VLS_TemplateResult_27["slots"]>;

export declare const JLink: __VLS_WithTemplateSlots_3<typeof __VLS_component_3, __VLS_TemplateResult_3["slots"]>;

export declare const JModal: __VLS_WithTemplateSlots_20<typeof __VLS_component_20, __VLS_TemplateResult_20["slots"]>;

declare interface JModalProps {
    open: boolean;
    title?: string;
    description?: string;
    size?: 'sm' | 'md' | 'lg' | 'xl' | '2xl' | 'full';
    showFormField?: boolean;
    formFieldLabel?: string;
    formFieldError?: string;
    formFieldRequired?: boolean;
    formFieldInputType?: 'text' | 'email' | 'password' | 'number' | 'tel' | 'url';
    formFieldInputPlaceholder?: string;
    formFieldValue?: string;
    formFieldType?: 'input' | 'textarea' | 'checkbox' | 'switch' | 'combo' | 'radio' | 'searchCombo' | 'datepicker';
    buttonType?: 'Ok' | 'OkCancel';
    confirmText?: string;
    cancelText?: string;
    confirmVariant?: 'default' | 'destructive' | 'outline' | 'secondary' | 'ghost' | 'link';
    confirmDisabled?: boolean;
    disabled?: boolean;
}

export declare const JNumberRangeField: DefineComponent<__VLS_Props_29, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (value: NumberRangeValue) => any;
change: (value: NumberRangeValue) => any;
focus: (event: FocusEvent) => any;
blur: (event: FocusEvent) => any;
}, string, PublicProps, Readonly<__VLS_Props_29> & Readonly<{
"onUpdate:modelValue"?: ((value: NumberRangeValue) => any) | undefined;
onChange?: ((value: NumberRangeValue) => any) | undefined;
onFocus?: ((event: FocusEvent) => any) | undefined;
onBlur?: ((event: FocusEvent) => any) | undefined;
}>, {
separator: string;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

export declare const JPageContainer: __VLS_WithTemplateSlots_24<typeof __VLS_component_24, __VLS_TemplateResult_24["slots"]>;

export declare const JPopover: __VLS_WithTemplateSlots_8<typeof __VLS_component_8, __VLS_TemplateResult_8["slots"]>;

export declare const JPreview: DefineComponent<__VLS_Props_23, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_23> & Readonly<{}>, {
modelValue: string;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

export declare const JProgress: DefineComponent<__VLS_Props_15, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_15> & Readonly<{}>, {
label: string;
size: SizeType;
value: number;
max: number;
variant: VariantType;
indeterminate: boolean;
styletype: StyleType_13;
showLabel: boolean;
description: string;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

export declare const JRadio: DefineComponent<__VLS_Props_7, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (value: string | number) => any;
change: (value: string | number) => any;
}, string, PublicProps, Readonly<__VLS_Props_7> & Readonly<{
"onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
onChange?: ((value: string | number) => any) | undefined;
}>, {
disabled: boolean;
required: boolean;
styletype: StyleType_7;
options: Option_3[];
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

export declare const JSearchAddr: DefineComponent<JSearchAddrProps, {
close: () => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
search: () => any;
error: (error: Error) => any;
close: () => any;
complete: (result: AddressResult) => any;
"complete-raw": (data: PostcodeData) => any;
}, string, PublicProps, Readonly<JSearchAddrProps> & Readonly<{
onSearch?: (() => any) | undefined;
onError?: ((error: Error) => any) | undefined;
onClose?: (() => any) | undefined;
onComplete?: ((result: AddressResult) => any) | undefined;
"onComplete-raw"?: ((data: PostcodeData) => any) | undefined;
}>, {
title: string;
height: string;
width: string;
theme: "default" | "dark";
isOpen: boolean;
closeOnBackdrop: boolean;
closeOnEsc: boolean;
defaultLanguage: LanguageType;
autoComplete: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {
modalRef: HTMLDivElement;
postcodeLayerRef: HTMLDivElement;
}, any>;

/**
 * JSearchAddr Props 인터페이스
 */
declare interface JSearchAddrProps {
    /** 모달 열림 여부 */
    isOpen?: boolean;
    /** 모달 제목 */
    title?: string;
    /** 모달 너비 */
    width?: string;
    /** 모달 높이 */
    height?: string;
    /** 배경 클릭 시 닫기 */
    closeOnBackdrop?: boolean;
    /** ESC 키로 닫기 */
    closeOnEsc?: boolean;
    /** 기본 언어 설정 */
    defaultLanguage?: LanguageType;
    /** 테마 설정 */
    theme?: 'default' | 'dark';
    /** 검색 시 자동완성 사용 여부 */
    autoComplete?: boolean;
}

export declare const JSearchCombo: DefineComponent<__VLS_Props_6, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (value: ComboboxOption | undefined) => any;
change: (value: ComboboxOption | undefined) => any;
focus: (event: FocusEvent) => any;
blur: (event: FocusEvent) => any;
}, string, PublicProps, Readonly<__VLS_Props_6> & Readonly<{
"onUpdate:modelValue"?: ((value: ComboboxOption | undefined) => any) | undefined;
onChange?: ((value: ComboboxOption | undefined) => any) | undefined;
onFocus?: ((event: FocusEvent) => any) | undefined;
onBlur?: ((event: FocusEvent) => any) | undefined;
}>, {
disabled: boolean;
multiple: boolean;
placeholder: string;
required: boolean;
styletype: StyleType_6;
options: ComboboxOption[];
searchPlaceholder: string;
emptyText: string;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

export declare const JSearchInput: DefineComponent<__VLS_Props_26, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (value: string | number) => any;
search: () => any;
change: (value: string | number) => any;
focus: (event: FocusEvent) => any;
blur: (event: FocusEvent) => any;
}, string, PublicProps, Readonly<__VLS_Props_26> & Readonly<{
"onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
onSearch?: (() => any) | undefined;
onChange?: ((value: string | number) => any) | undefined;
onFocus?: ((event: FocusEvent) => any) | undefined;
onBlur?: ((event: FocusEvent) => any) | undefined;
}>, {
disabled: boolean;
placeholder: string;
readonly: boolean;
styletype: StyleType_21;
buttonText: string;
buttonDisabled: boolean;
showIcon: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

export declare const JSearchPanel: DefineComponent<JSearchPanelProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (value: Record<string, any>) => any;
submit: (values: Record<string, any>) => any;
reset: () => any;
}, string, PublicProps, Readonly<JSearchPanelProps> & Readonly<{
"onUpdate:modelValue"?: ((value: Record<string, any>) => any) | undefined;
onSubmit?: ((values: Record<string, any>) => any) | undefined;
onReset?: (() => any) | undefined;
}>, {
collapsible: boolean;
title: string;
defaultCollapsed: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {
dynamicFormRef: CreateComponentPublicInstanceWithMixins<Readonly<{
schema: FormSchema;
modelValue?: Record<string, any>;
}> & Readonly<{
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
onError?: ((...args: any[]) => any) | undefined;
onSubmit?: ((...args: any[]) => any) | undefined;
onChange?: ((...args: any[]) => any) | undefined;
}>, {
formState: Record<string, any>;
submit: () => void;
reset: () => void;
handleError: (errs: any) => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (...args: any[]) => void;
error: (...args: any[]) => void;
submit: (...args: any[]) => void;
change: (...args: any[]) => void;
}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLFormElement, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<{
schema: FormSchema;
modelValue?: Record<string, any>;
}> & Readonly<{
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
onError?: ((...args: any[]) => any) | undefined;
onSubmit?: ((...args: any[]) => any) | undefined;
onChange?: ((...args: any[]) => any) | undefined;
}>, {
formState: Record<string, any>;
submit: () => void;
reset: () => void;
handleError: (errs: any) => void;
}, {}, {}, {}, {}> | null;
}, HTMLDivElement>;

declare interface JSearchPanelProps {
    /** 패널 제목 */
    title?: string;
    /** JDynamicForm에 전달할 FormSchema */
    schema: FormSchema;
    /** JDynamicForm의 v-model 값 */
    modelValue?: Record<string, any>;
    /** 기본 접힘 상태 */
    defaultCollapsed?: boolean;
    /** 접기/펼치기 가능 여부 */
    collapsible?: boolean;
}

export declare const JSectionTitle: DefineComponent<JSectionTitleProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<JSectionTitleProps> & Readonly<{}>, {
variant: SectionTitleVariant;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

declare interface JSectionTitleProps {
    /** 섹션 제목 */
    title: string;
    /** 서브 타이틀 (선택) */
    subtitle?: string;
    /** 스타일 variant */
    variant?: SectionTitleVariant;
    /** 아이콘 이름 (선택) */
    icon?: string;
    /** 추가 CSS 클래스 */
    class?: string;
}

export declare const JShuttle: DefineComponent<JShuttleProps, {
leftGridRef: Ref<any, any>;
rightGridRef: Ref<any, any>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
move: (args_0: {
items: ShuttleItem[];
direction: "toRight" | "toLeft";
}) => any;
"update:leftData": (data: ShuttleItem[]) => any;
"update:rightData": (data: ShuttleItem[]) => any;
}, string, PublicProps, Readonly<JShuttleProps> & Readonly<{
onMove?: ((args_0: {
items: ShuttleItem[];
direction: "toRight" | "toLeft";
}) => any) | undefined;
"onUpdate:leftData"?: ((data: ShuttleItem[]) => any) | undefined;
"onUpdate:rightData"?: ((data: ShuttleItem[]) => any) | undefined;
}>, {
leftTitle: string;
rightTitle: string;
searchable: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {
leftGridRef: CreateComponentPublicInstanceWithMixins<Readonly<{
class?: string;
rowData: any[];
columnDefs: ColDef[];
pagination?: boolean;
checkbox?: boolean;
rowNumbers?: boolean;
floatingFilters?: boolean;
floatingFilter?: boolean;
rowNumberWidth?: number;
actionButtons?: ActionButton[];
summaryColumn?: boolean;
hiddenColumn?: boolean;
enableGrouping?: boolean;
enablePivot?: boolean;
enableExcelExport?: boolean;
enableTreeData?: boolean;
getDataPath?: (data: any) => (string | number)[];
autoGroupColumnDef?: ColDef;
selectedRows?: any[];
columnHover?: boolean;
enableColumnsToolPanel?: boolean;
statusBar?: boolean;
compactFooter?: boolean;
rowGroupPanelShow?: "always" | "onlyWhenGrouping" | "never";
groupDefaultExpanded?: number;
pivotPanelShow?: "always" | "onlyWhenPivoting" | "never";
pivotMode?: boolean;
rowDragManaged?: boolean;
rowDragEntireRow?: boolean;
rowDragMultiRow?: boolean;
reactiveRowData?: boolean;
}> & Readonly<{
onRowClicked?: ((event: RowClickedEvent<any, any>) => any) | undefined;
onRowDoubleClicked?: ((event: RowDoubleClickedEvent<any, any>) => any) | undefined;
onCellClicked?: ((event: CellClickedEvent<any, any, any>) => any) | undefined;
onSelectionChanged?: ((event: SelectionChangedEvent<any, any>) => any) | undefined;
onCellValueChanged?: ((event: CellValueChangedEvent<any, any, any>) => any) | undefined;
onGridReady?: ((event: GridReadyEvent<any, any>) => any) | undefined;
"onUpdate:selectedRows"?: ((rows: any[]) => any) | undefined;
}>, {
gridApi: Ref<any, any>;
gridColumnApi: Ref<any, any>;
exportToExcel: () => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
rowClicked: (event: RowClickedEvent<any, any>) => any;
rowDoubleClicked: (event: RowDoubleClickedEvent<any, any>) => any;
cellClicked: (event: CellClickedEvent<any, any, any>) => any;
selectionChanged: (event: SelectionChangedEvent<any, any>) => any;
cellValueChanged: (event: CellValueChangedEvent<any, any, any>) => any;
gridReady: (event: GridReadyEvent<any, any>) => any;
"update:selectedRows": (rows: any[]) => any;
}, PublicProps, {
pagination: boolean;
checkbox: boolean;
rowNumbers: boolean;
floatingFilters: boolean;
floatingFilter: boolean;
rowNumberWidth: number;
actionButtons: ActionButton[];
summaryColumn: boolean;
hiddenColumn: boolean;
enableGrouping: boolean;
enablePivot: boolean;
enableExcelExport: boolean;
enableTreeData: boolean;
getDataPath: (data: any) => (string | number)[];
autoGroupColumnDef: ColDef;
selectedRows: any[];
columnHover: boolean;
enableColumnsToolPanel: boolean;
statusBar: boolean;
compactFooter: boolean;
rowGroupPanelShow: "always" | "onlyWhenGrouping" | "never";
groupDefaultExpanded: number;
pivotPanelShow: "always" | "onlyWhenPivoting" | "never";
pivotMode: boolean;
rowDragManaged: boolean;
rowDragEntireRow: boolean;
rowDragMultiRow: boolean;
reactiveRowData: boolean;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {
gridContainerRef: HTMLDivElement;
}, HTMLDivElement, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<{
class?: string;
rowData: any[];
columnDefs: ColDef[];
pagination?: boolean;
checkbox?: boolean;
rowNumbers?: boolean;
floatingFilters?: boolean;
floatingFilter?: boolean;
rowNumberWidth?: number;
actionButtons?: ActionButton[];
summaryColumn?: boolean;
hiddenColumn?: boolean;
enableGrouping?: boolean;
enablePivot?: boolean;
enableExcelExport?: boolean;
enableTreeData?: boolean;
getDataPath?: (data: any) => (string | number)[];
autoGroupColumnDef?: ColDef;
selectedRows?: any[];
columnHover?: boolean;
enableColumnsToolPanel?: boolean;
statusBar?: boolean;
compactFooter?: boolean;
rowGroupPanelShow?: "always" | "onlyWhenGrouping" | "never";
groupDefaultExpanded?: number;
pivotPanelShow?: "always" | "onlyWhenPivoting" | "never";
pivotMode?: boolean;
rowDragManaged?: boolean;
rowDragEntireRow?: boolean;
rowDragMultiRow?: boolean;
reactiveRowData?: boolean;
}> & Readonly<{
onRowClicked?: ((event: RowClickedEvent<any, any>) => any) | undefined;
onRowDoubleClicked?: ((event: RowDoubleClickedEvent<any, any>) => any) | undefined;
onCellClicked?: ((event: CellClickedEvent<any, any, any>) => any) | undefined;
onSelectionChanged?: ((event: SelectionChangedEvent<any, any>) => any) | undefined;
onCellValueChanged?: ((event: CellValueChangedEvent<any, any, any>) => any) | undefined;
onGridReady?: ((event: GridReadyEvent<any, any>) => any) | undefined;
"onUpdate:selectedRows"?: ((rows: any[]) => any) | undefined;
}>, {
gridApi: Ref<any, any>;
gridColumnApi: Ref<any, any>;
exportToExcel: () => void;
}, {}, {}, {}, {
pagination: boolean;
checkbox: boolean;
rowNumbers: boolean;
floatingFilters: boolean;
floatingFilter: boolean;
rowNumberWidth: number;
actionButtons: ActionButton[];
summaryColumn: boolean;
hiddenColumn: boolean;
enableGrouping: boolean;
enablePivot: boolean;
enableExcelExport: boolean;
enableTreeData: boolean;
getDataPath: (data: any) => (string | number)[];
autoGroupColumnDef: ColDef;
selectedRows: any[];
columnHover: boolean;
enableColumnsToolPanel: boolean;
statusBar: boolean;
compactFooter: boolean;
rowGroupPanelShow: "always" | "onlyWhenGrouping" | "never";
groupDefaultExpanded: number;
pivotPanelShow: "always" | "onlyWhenPivoting" | "never";
pivotMode: boolean;
rowDragManaged: boolean;
rowDragEntireRow: boolean;
rowDragMultiRow: boolean;
reactiveRowData: boolean;
}> | null;
rightGridRef: CreateComponentPublicInstanceWithMixins<Readonly<{
class?: string;
rowData: any[];
columnDefs: ColDef[];
pagination?: boolean;
checkbox?: boolean;
rowNumbers?: boolean;
floatingFilters?: boolean;
floatingFilter?: boolean;
rowNumberWidth?: number;
actionButtons?: ActionButton[];
summaryColumn?: boolean;
hiddenColumn?: boolean;
enableGrouping?: boolean;
enablePivot?: boolean;
enableExcelExport?: boolean;
enableTreeData?: boolean;
getDataPath?: (data: any) => (string | number)[];
autoGroupColumnDef?: ColDef;
selectedRows?: any[];
columnHover?: boolean;
enableColumnsToolPanel?: boolean;
statusBar?: boolean;
compactFooter?: boolean;
rowGroupPanelShow?: "always" | "onlyWhenGrouping" | "never";
groupDefaultExpanded?: number;
pivotPanelShow?: "always" | "onlyWhenPivoting" | "never";
pivotMode?: boolean;
rowDragManaged?: boolean;
rowDragEntireRow?: boolean;
rowDragMultiRow?: boolean;
reactiveRowData?: boolean;
}> & Readonly<{
onRowClicked?: ((event: RowClickedEvent<any, any>) => any) | undefined;
onRowDoubleClicked?: ((event: RowDoubleClickedEvent<any, any>) => any) | undefined;
onCellClicked?: ((event: CellClickedEvent<any, any, any>) => any) | undefined;
onSelectionChanged?: ((event: SelectionChangedEvent<any, any>) => any) | undefined;
onCellValueChanged?: ((event: CellValueChangedEvent<any, any, any>) => any) | undefined;
onGridReady?: ((event: GridReadyEvent<any, any>) => any) | undefined;
"onUpdate:selectedRows"?: ((rows: any[]) => any) | undefined;
}>, {
gridApi: Ref<any, any>;
gridColumnApi: Ref<any, any>;
exportToExcel: () => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
rowClicked: (event: RowClickedEvent<any, any>) => any;
rowDoubleClicked: (event: RowDoubleClickedEvent<any, any>) => any;
cellClicked: (event: CellClickedEvent<any, any, any>) => any;
selectionChanged: (event: SelectionChangedEvent<any, any>) => any;
cellValueChanged: (event: CellValueChangedEvent<any, any, any>) => any;
gridReady: (event: GridReadyEvent<any, any>) => any;
"update:selectedRows": (rows: any[]) => any;
}, PublicProps, {
pagination: boolean;
checkbox: boolean;
rowNumbers: boolean;
floatingFilters: boolean;
floatingFilter: boolean;
rowNumberWidth: number;
actionButtons: ActionButton[];
summaryColumn: boolean;
hiddenColumn: boolean;
enableGrouping: boolean;
enablePivot: boolean;
enableExcelExport: boolean;
enableTreeData: boolean;
getDataPath: (data: any) => (string | number)[];
autoGroupColumnDef: ColDef;
selectedRows: any[];
columnHover: boolean;
enableColumnsToolPanel: boolean;
statusBar: boolean;
compactFooter: boolean;
rowGroupPanelShow: "always" | "onlyWhenGrouping" | "never";
groupDefaultExpanded: number;
pivotPanelShow: "always" | "onlyWhenPivoting" | "never";
pivotMode: boolean;
rowDragManaged: boolean;
rowDragEntireRow: boolean;
rowDragMultiRow: boolean;
reactiveRowData: boolean;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {
gridContainerRef: HTMLDivElement;
}, HTMLDivElement, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<{
class?: string;
rowData: any[];
columnDefs: ColDef[];
pagination?: boolean;
checkbox?: boolean;
rowNumbers?: boolean;
floatingFilters?: boolean;
floatingFilter?: boolean;
rowNumberWidth?: number;
actionButtons?: ActionButton[];
summaryColumn?: boolean;
hiddenColumn?: boolean;
enableGrouping?: boolean;
enablePivot?: boolean;
enableExcelExport?: boolean;
enableTreeData?: boolean;
getDataPath?: (data: any) => (string | number)[];
autoGroupColumnDef?: ColDef;
selectedRows?: any[];
columnHover?: boolean;
enableColumnsToolPanel?: boolean;
statusBar?: boolean;
compactFooter?: boolean;
rowGroupPanelShow?: "always" | "onlyWhenGrouping" | "never";
groupDefaultExpanded?: number;
pivotPanelShow?: "always" | "onlyWhenPivoting" | "never";
pivotMode?: boolean;
rowDragManaged?: boolean;
rowDragEntireRow?: boolean;
rowDragMultiRow?: boolean;
reactiveRowData?: boolean;
}> & Readonly<{
onRowClicked?: ((event: RowClickedEvent<any, any>) => any) | undefined;
onRowDoubleClicked?: ((event: RowDoubleClickedEvent<any, any>) => any) | undefined;
onCellClicked?: ((event: CellClickedEvent<any, any, any>) => any) | undefined;
onSelectionChanged?: ((event: SelectionChangedEvent<any, any>) => any) | undefined;
onCellValueChanged?: ((event: CellValueChangedEvent<any, any, any>) => any) | undefined;
onGridReady?: ((event: GridReadyEvent<any, any>) => any) | undefined;
"onUpdate:selectedRows"?: ((rows: any[]) => any) | undefined;
}>, {
gridApi: Ref<any, any>;
gridColumnApi: Ref<any, any>;
exportToExcel: () => void;
}, {}, {}, {}, {
pagination: boolean;
checkbox: boolean;
rowNumbers: boolean;
floatingFilters: boolean;
floatingFilter: boolean;
rowNumberWidth: number;
actionButtons: ActionButton[];
summaryColumn: boolean;
hiddenColumn: boolean;
enableGrouping: boolean;
enablePivot: boolean;
enableExcelExport: boolean;
enableTreeData: boolean;
getDataPath: (data: any) => (string | number)[];
autoGroupColumnDef: ColDef;
selectedRows: any[];
columnHover: boolean;
enableColumnsToolPanel: boolean;
statusBar: boolean;
compactFooter: boolean;
rowGroupPanelShow: "always" | "onlyWhenGrouping" | "never";
groupDefaultExpanded: number;
pivotPanelShow: "always" | "onlyWhenPivoting" | "never";
pivotMode: boolean;
rowDragManaged: boolean;
rowDragEntireRow: boolean;
rowDragMultiRow: boolean;
reactiveRowData: boolean;
}> | null;
}, HTMLDivElement>;

declare interface JShuttleProps {
    /** 왼쪽 그리드 제목 */
    leftTitle?: string;
    /** 오른쪽 그리드 제목 */
    rightTitle?: string;
    /** 왼쪽 그리드 데이터 (Unmapped) */
    leftData: ShuttleItem[];
    /** 오른쪽 그리드 데이터 (Mapped) */
    rightData: ShuttleItem[];
    /** 컬럼 정의 (양쪽 그리드 공통) */
    columnDefs: ColDef[];
    /** 검색 활성화 여부 */
    searchable?: boolean;
    /** 추가 CSS 클래스 */
    class?: string;
}

export declare const JSidebar: DefineComponent<__VLS_Props_38, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:collapsed": (value: boolean) => any;
"menu-click": (item: SidebarMenuItem, event: MouseEvent) => any;
}, string, PublicProps, Readonly<__VLS_Props_38> & Readonly<{
"onUpdate:collapsed"?: ((value: boolean) => any) | undefined;
"onMenu-click"?: ((item: SidebarMenuItem, event: MouseEvent) => any) | undefined;
}>, {
width: string;
collapsed: boolean;
collapsedWidth: string;
showSearch: boolean;
showFavorites: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLElement>;

export declare const JSidebarAdvanced: DefineComponent<__VLS_Props_40, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
menuClick: (event: MenuClickEvent) => any;
favoriteChange: (menuKey: string | number | undefined, isFavorite: boolean) => any;
}, string, PublicProps, Readonly<__VLS_Props_40> & Readonly<{
onMenuClick?: ((event: MenuClickEvent) => any) | undefined;
onFavoriteChange?: ((menuKey: string | number | undefined, isFavorite: boolean) => any) | undefined;
}>, {
width: string;
styletype: StyleType_27;
isVisible: boolean;
favorites: (number | string)[];
permissions: MenuPermission[];
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

export declare const JSidebarSimple: DefineComponent<__VLS_Props_39, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
menuClick: (event: MenuClickEvent) => any;
}, string, PublicProps, Readonly<__VLS_Props_39> & Readonly<{
onMenuClick?: ((event: MenuClickEvent) => any) | undefined;
}>, {
width: string;
styletype: StyleType_26;
isVisible: boolean;
searchQuery: string;
permissions: MenuPermission[];
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

export declare const JSpinner: DefineComponent<__VLS_Props_16, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_16> & Readonly<{}>, {
label: string;
size: "xs" | "sm" | "md" | "lg";
styletype: StyleType_14;
thickness: number;
labelPosition: LabelPosition;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

export declare const JSplitter: __VLS_WithTemplateSlots_9<typeof __VLS_component_9, __VLS_TemplateResult_9["slots"]>;

export declare const JSwitch: DefineComponent<__VLS_Props_8, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (value: string) => any;
change: (value: string) => any;
}, string, PublicProps, Readonly<__VLS_Props_8> & Readonly<{
"onUpdate:modelValue"?: ((value: string) => any) | undefined;
onChange?: ((value: string) => any) | undefined;
}>, {
disabled: boolean;
modelValue: string;
styletype: StyleType_8;
showStateLabel: boolean;
activeLabel: string;
inactiveLabel: string;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLSpanElement>;

export declare const JTabs: __VLS_WithTemplateSlots_11<typeof __VLS_component_11, __VLS_TemplateResult_11["slots"]>;

/**
 * JTabs Props 인터페이스 (molecules)
 * JTabs Props interface for basic static tabs
 */
declare interface JTabsProps {
    /** 탭 아이템 배열 (Array of tab items) */
    tabs: DynamicTab[];
    /** 현재 활성화된 탭 ID (Current active tab ID) */
    activeTabId?: string;
    /** 루트 컨테이너 추가 클래스 (Additional class for root container) */
    class?: string;
    /** 탭 리스트 추가 클래스 (Additional class for tabs list) */
    listClass?: string;
    /** 스타일 타입 */
    styletype?: 'default' | 'minimal';
    /** 비활성 탭 DOM/인스턴스 유지 여부 (기본 false) */
    keepAlive?: boolean;
}

export declare const JTextarea: DefineComponent<__VLS_Props_3, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (value: string) => any;
change: (value: string) => any;
focus: (event: FocusEvent) => any;
blur: (event: FocusEvent) => any;
}, string, PublicProps, Readonly<__VLS_Props_3> & Readonly<{
"onUpdate:modelValue"?: ((value: string) => any) | undefined;
onChange?: ((value: string) => any) | undefined;
onFocus?: ((event: FocusEvent) => any) | undefined;
onBlur?: ((event: FocusEvent) => any) | undefined;
}>, {
disabled: boolean;
placeholder: string;
readonly: boolean;
required: boolean;
styletype: StyleType_3;
rows: number;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLTextAreaElement>;

export declare const JTitlebar: __VLS_WithTemplateSlots_16<typeof __VLS_component_16, __VLS_TemplateResult_16["slots"]>;

export { JToast }

export declare const JToaster: DefineComponent<ToasterProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ToasterProps> & Readonly<{}>, {
position: "top-left" | "top-right" | "bottom-left" | "bottom-right" | "top-center" | "bottom-center";
richColors: boolean;
expand: boolean;
closeButton: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

export declare const JTooltip: __VLS_WithTemplateSlots_6<typeof __VLS_component_6, __VLS_TemplateResult_6["slots"]>;

export declare const JTree: DefineComponent<__VLS_Props_42, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
expandChange: (menuKey: string | number | undefined, expanded: boolean) => any;
nodeClick: (event: MenuClickEvent) => any;
"update:expandedKeys": (keys: (string | number)[]) => any;
"update:activeKey": (key: string | number | null) => any;
}, string, PublicProps, Readonly<__VLS_Props_42> & Readonly<{
onExpandChange?: ((menuKey: string | number | undefined, expanded: boolean) => any) | undefined;
onNodeClick?: ((event: MenuClickEvent) => any) | undefined;
"onUpdate:expandedKeys"?: ((keys: (string | number)[]) => any) | undefined;
"onUpdate:activeKey"?: ((key: string | number | null) => any) | undefined;
}>, {
styletype: StyleType_29;
searchQuery: string;
permissions: MenuPermission[];
expandedKeys: (number | string)[];
maxDepth: number;
activeKey: number | string | null;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

declare type LabelPosition = 'right' | 'left' | 'top' | 'bottom';

/**
 * 언어 타입
 */
declare type LanguageType = 'K' | 'E';

/**
 * 메뉴 클릭 이벤트 타입
 * Menu Click Event Type
 */
declare interface MenuClickEvent {
    /** 클릭된 메뉴 아이템 */
    menuItem: SidebarMenuItem_2;
    /** 메뉴 경로 (부모 메뉴 포함) */
    path: SidebarMenuItem_2[];
    /** 이벤트 객체 */
    event: MouseEvent;
}

/**
 * 메뉴 권한 데이터 구조
 * Menu Permission Data Structure
 */
declare interface MenuPermission {
    /** 메뉴 키 */
    menuKey: number;
    /** 권한 레벨 (예: 1=읽기, 2=쓰기, 3=삭제 등) */
    permissionLevel: number;
}

/**
 * JSidebar 타입 정의
 * JSidebar Type Definitions
 */
/** 메뉴 타입: F=폴더(그룹), L=링크(페이지) */
export declare type MenuType = 'F' | 'L';

/**
 * 사이드바 메뉴 관련 타입 정의
 * Sidebar Menu Type Definitions
 */
/**
 * 메뉴 타입
 * - 'F': Folder (폴더 - 하위 메뉴를 가지는 메뉴)
 * - 'L': Link (링크 - 실제 페이지로 이동하는 메뉴)
 */
declare type MenuType_2 = 'F' | 'L';

export declare type NotificationItem = {
    /** 알림 ID */
    id: string;
    /** 알림 제목 */
    title: string;
    /** 알림 내용 */
    message?: string;
    /** 알림 시간 */
    time?: string;
    /** 읽음 상태 */
    read?: boolean;
    /** 아이콘 */
    icon?: string;
    /** 클릭 핸들러 */
    onClick?: () => void;
};

export declare type NumberRangeValue = {
    start: number | null;
    end: number | null;
};

declare interface Option_2 {
    value: string | number;
    label: string;
}

declare interface Option_3 {
    value: string | number;
    label: string;
    disabled?: boolean;
}

declare interface Option_4 {
    value: string | number;
    label: string;
}

declare type Orientation = 'horizontal' | 'vertical';

declare type PositionType = 'top' | 'bottom' | 'left' | 'right';

/**
 * Daum Postcode 완료 데이터
 */
declare interface PostcodeData {
    /** 우편번호 */
    zonecode: string;
    /** 도로명 주소 */
    roadAddress: string;
    /** 지번 주소 */
    jibunAddress: string;
    /** 영문 도로명 주소 */
    roadAddressEnglish: string;
    /** 영문 지번 주소 */
    jibunAddressEnglish: string;
    /** 사용자가 선택한 주소 타입 */
    userSelectedType: AddressType;
    /** 사용자가 선택한 언어 */
    userLanguageType: LanguageType;
    /** 법정동/법정리 이름 */
    bname: string;
    /** 건물명 */
    buildingName: string;
    /** 아파트명 */
    apartment: string;
    /** 시도 */
    sido: string;
    /** 시군구 */
    sigungu: string;
    /** 법정리명 */
    bname1: string;
    /** 법정동코드 */
    bcode: string;
    /** 도로명 */
    roadname: string;
    /** 도로명 코드 */
    roadnameCode: string;
}

declare function reset(): void;

declare type SectionTitleVariant = 'default' | 'primary' | 'secondary' | 'accent';

declare type Shape = 'circle' | 'square' | 'rounded';

declare interface ShuttleItem {
    /** 아이템 고유 ID */
    id: string | number;
    /** 아이템 데이터 (AG Grid row data) */
    [key: string]: any;
}

/**
 * 사이드바 메뉴 아이템 (DB J_마스터_프로그램 트리 매핑)
 */
export declare interface SidebarMenuItem {
    /** 프로그램 아이디 */
    id: string;
    /** 부모 아이디 */
    parentId?: string;
    /** 메뉴 표시 이름 */
    label: string;
    /** lucide 아이콘 이름 */
    icon?: string;
    /** 라우트 경로 (L 타입만) */
    path?: string;
    /** 메뉴 타입: F=폴더(그룹), L=링크(페이지) */
    menuType: MenuType;
    /** 정렬 순서 */
    sortOrder?: number;
    /** 하위 메뉴 (서버에서 트리로 변환) */
    children?: SidebarMenuItem[];
    /** 비활성화 여부 */
    disabled?: boolean;
}

/**
 * 사이드바 메뉴 아이템
 * Sidebar Menu Item
 */
declare interface SidebarMenuItem_2 {
    /** 메뉴 표시 이름 */
    label: string;
    /** 메뉴 아이콘 이름 (lucide-vue-next 아이콘 이름 또는 컴포넌트) */
    icon?: string;
    /** 메뉴 타입 (Folder/Link) */
    menuType?: MenuType_2;
    /** 메뉴 키 (권한 체크용) */
    menuKey?: number;
    /** 라우팅 경로 (menuType이 'L'일 때 사용) */
    path?: string;
    /** 하위 메뉴 목록 */
    children?: SidebarMenuItem_2[];
    /** 비활성화 여부 */
    disabled?: boolean;
    /** 추가 메타데이터 */
    meta?: Record<string, any>;
}

declare type Size = 'xs' | 'sm' | 'md' | 'lg' | 'xl';

declare type Size_2 = 'xs' | 'sm' | 'md' | 'lg';

declare type SizeType = 'xs' | 'sm' | 'md' | 'lg';

declare type SizeType_2 = 'xs' | 'sm' | 'md' | 'lg';

declare type SizeType_3 = 'xs' | 'sm' | 'md' | 'lg' | 'xl';

declare type SplitterSizes = [number, number];

declare type Status = 'online' | 'offline' | 'away' | 'busy';

declare type StyleType = 'default' | 'primary' | 'secondary' | 'success' | 'warning' | 'danger' | 'outline' | 'ghost' | 'link' | 'sm' | 'lg' | 'icon';

declare type StyleType_10 = 'default' | 'primary' | 'secondary' | 'destructive' | 'outline' | 'ghost' | 'sm' | 'lg';

declare type StyleType_11 = 'default' | 'primary' | 'secondary' | 'muted' | 'sm' | 'lg' | 'rounded';

declare type StyleType_12 = 'default' | 'primary' | 'success' | 'warning' | 'danger';

declare type StyleType_13 = 'default' | 'primary' | 'success' | 'warning' | 'danger';

declare type StyleType_14 = 'default' | 'primary' | 'success' | 'warning' | 'danger';

declare type StyleType_15 = 'default' | 'primary' | 'success' | 'warning' | 'danger';

declare type StyleType_16 = 'default' | 'primary' | 'success' | 'warning' | 'danger';

declare type StyleType_17 = 'default' | 'primary' | 'success' | 'warning' | 'danger';

declare type StyleType_18 = 'default' | 'primary' | 'success' | 'warning' | 'danger';

declare type StyleType_19 = 'default' | 'required' | 'optional' | 'error' | 'success' | 'warning' | 'sm' | 'lg';

declare type StyleType_2 = 'default' | 'error' | 'success' | 'warning' | 'sm' | 'lg';

declare type StyleType_20 = 'default' | 'default-sm' | 'default-lg' | 'default-xl' | 'card' | 'card-sm' | 'card-lg' | 'card-xl' | 'minimal' | 'minimal-sm' | 'minimal-lg' | 'minimal-xl' | 'outlined' | 'outlined-sm' | 'outlined-lg' | 'outlined-xl' | 'auto';

declare type StyleType_21 = 'default' | 'sm' | 'lg' | 'error' | 'success' | 'warning';

declare type StyleType_22 = 'default' | 'error' | 'success' | 'warning' | 'sm' | 'lg';

declare type StyleType_23 = 'default' | 'primary' | 'accent' | 'neutral' | 'elevated';

declare type StyleType_24 = 'default' | 'minimal';

declare type StyleType_25 = 'default' | 'minimal';

/**
 * JSidebarSimple - 간단한 사이드바 컴포넌트
 * Simple Sidebar Component
 *
 * @description
 * 다단계 메뉴 구조를 지원하는 기본 사이드바 컴포넌트입니다.
 * 권한 체크, 메뉴 검색 등의 기능을 제공합니다.
 *
 * @example
 * ```vue
 * <JSidebarSimple
 *   :menu-items="menuItems"
 *   :permissions="userPermissions"
 *   @menu-click="handleMenuClick"
 * />
 * ```
 *
 * @example JSON 메뉴 데이터 예시
 * ```json
 * [
 *   {
 *     "label": "대시보드",
 *     "icon": "house",
 *     "menuType": "L",
 *     "menuKey": 1,
 *     "path": "/dashboard"
 *   },
 *   {
 *     "label": "재고 관리",
 *     "icon": "package",
 *     "menuType": "F",
 *     "menuKey": 2,
 *     "children": [
 *       {
 *         "label": "재고 현황",
 *         "menuType": "L",
 *         "menuKey": 21,
 *         "path": "/inventory/status"
 *       },
 *       {
 *         "label": "입고 관리",
 *         "menuType": "L",
 *         "menuKey": 22,
 *         "path": "/inventory/receiving"
 *       }
 *     ]
 *   }
 * ]
 * ```
 */
declare type StyleType_26 = 'default' | 'minimal';

declare type StyleType_27 = 'default' | 'minimal';

/**
 * JPageContainer - 기본 페이지 컨테이너 컴포넌트 (organisms)
 * Page Container Component
 *
 * @description
 * 페이지의 기본 레이아웃을 담당하는 컨테이너 컴포넌트입니다.
 * 브레드크럼, 제목 영역(JTitlebar), 콘텐츠 영역을 포함합니다.
 *
 * @example
 * ```vue
 * <JPageContainer
 *   :breadcrumb-items="breadcrumbItems"
 *   title="페이지 제목"
 *   :titlebar-buttons="buttons"
 * >
 *   <div>페이지 콘텐츠</div>
 * </JPageContainer>
 * ```
 */
declare type StyleType_28 = 'default' | 'minimal';

/**
 * JTree - 트리 뷰 컴포넌트
 * Tree View Component
 *
 * @description
 * 계층 데이터를 조회/탐색하는 읽기 전용 트리 컴포넌트입니다.
 * JDynamicMenuItem을 재귀적으로 렌더링하며, 네비게이션 기능을 비활성화하고
 * nodeClick 이벤트로 선택을 처리합니다.
 *
 * @example
 * ```vue
 * <JTree
 *   :items="treeData"
 *   v-model:expanded-keys="expandedKeys"
 *   v-model:active-key="activeKey"
 *   @node-click="handleNodeClick"
 * />
 * ```
 *
 * @example JSON 트리 데이터 예시
 * ```json
 * [
 *   {
 *     "label": "프로그램 관리",
 *     "icon": "folder",
 *     "menuType": "F",
 *     "menuKey": 1,
 *     "children": [
 *       {
 *         "label": "시스템 관리",
 *         "menuType": "L",
 *         "menuKey": 11
 *       },
 *       {
 *         "label": "사용자 관리",
 *         "menuType": "L",
 *         "menuKey": 12
 *       }
 *     ]
 *   }
 * ]
 * ```
 */
declare type StyleType_29 = 'default' | 'minimal';

declare type StyleType_3 = 'default' | 'error' | 'success' | 'warning' | 'sm' | 'lg';

/**
 * JLayout - 기본 레이아웃 컴포넌트 (templates)
 * Base Layout Component
 *
 * @description
 * 공통 레이아웃 구조를 제공하는 기본 컴포넌트입니다.
 * Header, Sidebar, Content 영역을 슬롯으로 제공하여 유연한 레이아웃 구성이 가능합니다.
 * 모바일에서는 사이드바가 오버레이 드로어로 전환됩니다.
 *
 * 레이아웃 구조:
 * - header: 상단 헤더 영역 (슬롯)
 * - sidebar: 사이드바 영역 (슬롯)
 * - content: 메인 콘텐츠 영역 (슬롯, 기본 슬롯도 지원)
 *
 * @example
 * ```vue
 * <JLayout styletype="default" :content-scroll="true">
 *   <template #header>
 *     <JHeader logo-text="JWMS Portal" />
 *   </template>
 *   <template #sidebar>
 *     <JSidebarSimple :menu-items="menuItems" />
 *   </template>
 *   <template #content>
 *     <div>메인 콘텐츠</div>
 *   </template>
 * </JLayout>
 * ```
 */
declare type StyleType_30 = 'default' | 'minimal';

declare type StyleType_4 = 'default' | 'primary' | 'success' | 'danger' | 'sm' | 'lg';

declare type StyleType_5 = 'default' | 'error' | 'success' | 'warning' | 'sm' | 'lg';

declare type StyleType_6 = 'default' | 'error' | 'success' | 'warning' | 'sm' | 'lg';

declare type StyleType_7 = 'default' | 'primary' | 'success' | 'danger' | 'sm' | 'lg' | 'horizontal' | 'vertical';

declare type StyleType_8 = 'default' | 'primary' | 'success' | 'danger' | 'sm' | 'lg';

declare type StyleType_9 = 'default' | 'primary' | 'secondary' | 'muted' | 'sm' | 'lg';

declare type TitlebarButton = {
    /** 버튼 아이콘 */
    icon?: string;
    /** 버튼 텍스트 */
    text?: string;
    /** 버튼 클릭 핸들러 */
    onClick?: () => void;
    /** 버튼 variant */
    variant?: ButtonVariants['variant'];
    /** 버튼 스타일 타입 */
    styletype?: 'default' | 'primary' | 'secondary' | 'success' | 'warning' | 'danger' | 'outline' | 'ghost' | 'link' | 'sm' | 'lg' | 'icon';
    /** 버튼 size */
    size?: 'sm' | 'md' | 'lg';
    /** 버튼 비활성화 */
    disabled?: boolean;
    /** 버튼 로딩 상태 */
    loading?: boolean;
};

declare type Trigger = 'hover' | 'focus' | 'click' | 'manual';

export { useBreakpoint }

declare type VariantType = 'linear' | 'circular';

export { }