@ulu/frontend-vue 0.1.1-beta.2 → 0.1.1-beta.4

package/types/components/systems/table-sticky/UluTableStickyRows.vue.d.ts

@@ -0,0 +1,34 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    rows: ArrayConstructor;
+    rowColumns: ArrayConstructor;
+    columnWidth: StringConstructor;
+    optionalAttr: FunctionConstructor;
+    resolveClasses: FunctionConstructor;
+    getCellHeaders: FunctionConstructor;
+    value: FunctionConstructor;
+    isActual: BooleanConstructor;
+    classes: ObjectConstructor;
+    foot: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    rows: ArrayConstructor;
+    rowColumns: ArrayConstructor;
+    columnWidth: StringConstructor;
+    optionalAttr: FunctionConstructor;
+    resolveClasses: FunctionConstructor;
+    getCellHeaders: FunctionConstructor;
+    value: FunctionConstructor;
+    isActual: BooleanConstructor;
+    classes: ObjectConstructor;
+    foot: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    isActual: boolean;
+    foot: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=UluTableStickyRows.vue.d.ts.map

package/types/components/systems/table-sticky/UluTableStickyRows.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UluTableStickyRows.vue.d.ts","sourceRoot":"","sources":["../../../../lib/components/systems/table-sticky/UluTableStickyRows.vue"],"names":[],"mappings":""}

package/types/components/systems/table-sticky/UluTableStickyTable.vue.d.ts

@@ -0,0 +1,151 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    resolveClasses: FunctionConstructor;
+    classes: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    caption: StringConstructor;
+    idPrefix: StringConstructor;
+    headerRows: {
+        type: ArrayConstructor;
+        required: true;
+    };
+    rows: ArrayConstructor;
+    footerRows: ArrayConstructor;
+    rowColumns: ArrayConstructor;
+    /**
+     * Is the actual table not a clone for sticky headers
+     */
+    isActual: {
+        type: BooleanConstructor;
+    };
+    columnWidth: {
+        type: StringConstructor;
+    };
+    /**
+     * Optional user overridden value getter (for rows)
+     * @param {Object} row The current row
+     * @param {Object} column The current column in the row
+     */
+    getRowValue: {
+        type: FunctionConstructor;
+        default: ({ row, column }: {
+            row: any;
+            column: any;
+        }) => any;
+    };
+    /**
+     * Optional user overridden value getter (for rows)
+     * @param {Object} row The current row
+     * @param {Object} column The current column in the row
+     */
+    getColumnTitle: {
+        type: FunctionConstructor;
+        default: ({ column }: {
+            column: any;
+        }) => any;
+    };
+}>, {}, {
+    headerRefs: {};
+}, {}, {
+    handleSortFocus(column: any, isFocused: any): void;
+    addHeaderRef(column: any, el: any): void;
+    /**
+     * False is no longer not printed
+     */
+    optionalAttr(val: any): any;
+    value({ row, column, rowIndex }: {
+        row: any;
+        column: any;
+        rowIndex: any;
+    }): any;
+    getCellHeaders(column: any, rowIndex: any): string;
+    getHeaderHeaders(column: any): any;
+}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    resolveClasses: FunctionConstructor;
+    classes: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    caption: StringConstructor;
+    idPrefix: StringConstructor;
+    headerRows: {
+        type: ArrayConstructor;
+        required: true;
+    };
+    rows: ArrayConstructor;
+    footerRows: ArrayConstructor;
+    rowColumns: ArrayConstructor;
+    /**
+     * Is the actual table not a clone for sticky headers
+     */
+    isActual: {
+        type: BooleanConstructor;
+    };
+    columnWidth: {
+        type: StringConstructor;
+    };
+    /**
+     * Optional user overridden value getter (for rows)
+     * @param {Object} row The current row
+     * @param {Object} column The current column in the row
+     */
+    getRowValue: {
+        type: FunctionConstructor;
+        default: ({ row, column }: {
+            row: any;
+            column: any;
+        }) => any;
+    };
+    /**
+     * Optional user overridden value getter (for rows)
+     * @param {Object} row The current row
+     * @param {Object} column The current column in the row
+     */
+    getColumnTitle: {
+        type: FunctionConstructor;
+        default: ({ column }: {
+            column: any;
+        }) => any;
+    };
+}>> & Readonly<{}>, {
+    classes: Record<string, any>;
+    isActual: boolean;
+    getRowValue: Function;
+    getColumnTitle: Function;
+}, {}, {
+    UluTableStickyRows: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        rows: ArrayConstructor;
+        rowColumns: ArrayConstructor;
+        columnWidth: StringConstructor;
+        optionalAttr: FunctionConstructor;
+        resolveClasses: FunctionConstructor;
+        getCellHeaders: FunctionConstructor;
+        value: FunctionConstructor;
+        isActual: BooleanConstructor;
+        classes: ObjectConstructor;
+        foot: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        rows: ArrayConstructor;
+        rowColumns: ArrayConstructor;
+        columnWidth: StringConstructor;
+        optionalAttr: FunctionConstructor;
+        resolveClasses: FunctionConstructor;
+        getCellHeaders: FunctionConstructor;
+        value: FunctionConstructor;
+        isActual: BooleanConstructor;
+        classes: ObjectConstructor;
+        foot: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{}>, {
+        isActual: boolean;
+        foot: boolean;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=UluTableStickyTable.vue.d.ts.map

package/types/components/systems/table-sticky/UluTableStickyTable.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UluTableStickyTable.vue.d.ts","sourceRoot":"","sources":["../../../../lib/components/systems/table-sticky/UluTableStickyTable.vue"],"names":[],"mappings":";;;;;;;;;;;;;;;IAmQM;;OAEG;;;;;;;IAOH;;;;OAIG;;;;;;;;IAKH;;;;OAIG;;;;;;;;;;;;IA4BH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;IApDH;;OAEG;;;;;;;IAOH;;;;OAIG;;;;;;;;IAKH;;;;OAIG"}

package/types/components/utils/UluCondText.vue.d.ts

@@ -0,0 +1,29 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    /**
+     * Text to print in element
+     */
+    text: (ObjectConstructor | StringConstructor | ArrayConstructor | NumberConstructor)[];
+    /**
+     * Element type to render (ie. h1, h2, p, etc)
+     */
+    element: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    /**
+     * Text to print in element
+     */
+    text: (ObjectConstructor | StringConstructor | ArrayConstructor | NumberConstructor)[];
+    /**
+     * Element type to render (ie. h1, h2, p, etc)
+     */
+    element: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    element: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=UluCondText.vue.d.ts.map

package/types/components/utils/UluCondText.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UluCondText.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/utils/UluCondText.vue"],"names":[],"mappings":";IAmCM;;OAEG;;IAEH;;OAEG;;;;;;IANH;;OAEG;;IAEH;;OAEG"}

package/types/components/utils/UluEmpty.vue.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=UluEmpty.vue.d.ts.map

package/types/components/utils/UluEmpty.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UluEmpty.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/utils/UluEmpty.vue"],"names":[],"mappings":";AA+BA,wBACG"}

package/types/components/utils/UluEmptyView.vue.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=UluEmptyView.vue.d.ts.map

package/types/components/utils/UluEmptyView.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UluEmptyView.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/utils/UluEmptyView.vue"],"names":[],"mappings":";AAuCA,wBACG"}

package/types/components/utils/UluPlaceholderImage.vue.d.ts

@@ -0,0 +1,61 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    imageId: StringConstructor;
+    /**
+     * Width of the image
+     */
+    width: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: string;
+    };
+    /**
+     * Height of the image
+     */
+    height: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: string;
+    };
+    /**
+     * Alt text for placeholder image
+     */
+    alt: StringConstructor;
+    /**
+     * Random size
+     */
+    random: BooleanConstructor;
+}>, {}, {}, {
+    src(): string;
+    size(): {
+        width: any;
+        height: any;
+    };
+}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    imageId: StringConstructor;
+    /**
+     * Width of the image
+     */
+    width: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: string;
+    };
+    /**
+     * Height of the image
+     */
+    height: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: string;
+    };
+    /**
+     * Alt text for placeholder image
+     */
+    alt: StringConstructor;
+    /**
+     * Random size
+     */
+    random: BooleanConstructor;
+}>> & Readonly<{}>, {
+    height: string | number;
+    width: string | number;
+    random: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=UluPlaceholderImage.vue.d.ts.map

package/types/components/utils/UluPlaceholderImage.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UluPlaceholderImage.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/utils/UluPlaceholderImage.vue"],"names":[],"mappings":";;IA2DM;;OAEG;;;;;IAKH;;OAEG;;;;;IAKH;;OAEG;;IAEH;;OAEG;;;;;;;;;;IApBH;;OAEG;;;;;IAKH;;OAEG;;;;;IAKH;;OAEG;;IAEH;;OAEG"}

package/types/components/utils/UluPlaceholderText.vue.d.ts

@@ -0,0 +1,24 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    amount: {
+        type: NumberConstructor;
+        default: number;
+    };
+    element: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    amount: {
+        type: NumberConstructor;
+        default: number;
+    };
+    element: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    element: string;
+    amount: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=UluPlaceholderText.vue.d.ts.map

package/types/components/utils/UluPlaceholderText.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UluPlaceholderText.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/utils/UluPlaceholderText.vue"],"names":[],"mappings":""}

package/types/components/utils/UluRouteAnnouncer.vue.d.ts

@@ -0,0 +1,63 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    /**
+     * Allow user to bypass this functionality
+     * - Function should return true if the page should be annouced
+     * - Function is passed  (to, from, $route) => {}
+     *   - to/from are path strings
+     */
+    validator: {
+        type: FunctionConstructor;
+        default: () => boolean;
+    };
+    /**
+     * Array of paths to exclude
+     * - Can be exact path "/about"
+     * - Or can be path with wildcard "/about/*" (match all paths under about)
+     */
+    exclude: {
+        type: ArrayConstructor;
+        default: () => never[];
+    };
+    /**
+     * Function to retrieve routes title
+     */
+    getTitle: {
+        type: FunctionConstructor;
+        default: (route: any) => any;
+    };
+}>, {}, {}, {
+    title(): any;
+}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    /**
+     * Allow user to bypass this functionality
+     * - Function should return true if the page should be annouced
+     * - Function is passed  (to, from, $route) => {}
+     *   - to/from are path strings
+     */
+    validator: {
+        type: FunctionConstructor;
+        default: () => boolean;
+    };
+    /**
+     * Array of paths to exclude
+     * - Can be exact path "/about"
+     * - Or can be path with wildcard "/about/*" (match all paths under about)
+     */
+    exclude: {
+        type: ArrayConstructor;
+        default: () => never[];
+    };
+    /**
+     * Function to retrieve routes title
+     */
+    getTitle: {
+        type: FunctionConstructor;
+        default: (route: any) => any;
+    };
+}>> & Readonly<{}>, {
+    validator: Function;
+    exclude: unknown[];
+    getTitle: Function;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=UluRouteAnnouncer.vue.d.ts.map

package/types/components/utils/UluRouteAnnouncer.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UluRouteAnnouncer.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/utils/UluRouteAnnouncer.vue"],"names":[],"mappings":";IAuFM;;;;;OAKG;;;;;IAKH;;;;OAIG;;;;;IAKH;;OAEG;;;;;;;;IArBH;;;;;OAKG;;;;;IAKH;;;;OAIG;;;;;IAKH;;OAEG"}

package/types/components/visualizations/UluAnimateNumber.vue.d.ts

@@ -0,0 +1,16 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    /**
+     * The target number to animate to.
+     */
+    value: NumberConstructor;
+}>, {}, {
+    currentValue: number | undefined;
+    tweenValue: number | undefined;
+}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    /**
+     * The target number to animate to.
+     */
+    value: NumberConstructor;
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=UluAnimateNumber.vue.d.ts.map

package/types/components/visualizations/UluAnimateNumber.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UluAnimateNumber.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/visualizations/UluAnimateNumber.vue"],"names":[],"mappings":";IAiDM;;OAEG;;;;;;IAFH;;OAEG"}

package/types/components/visualizations/UluProgressBar.vue.d.ts

@@ -0,0 +1,66 @@
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & (new () => {
+    $slots: S;
+});
+declare const __VLS_component: import("vue").DefineComponent<{}, {
+    $props: Partial<typeof props>;
+    classes: Record<string, any>;
+    small: boolean;
+    labelHidden: boolean;
+    amount: number;
+    labelElement: string;
+    total: number;
+    deficit: number;
+    positive: boolean;
+    negative: boolean;
+    loader: boolean;
+    indeterminate: boolean;
+    noValues: boolean;
+    amountInHeader: boolean;
+    label?: string | undefined;
+    formatValue?: Function | undefined;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+type __VLS_Slots = {
+    label?: ((props: {}) => any) | undefined;
+} & {
+    valueAmount?: ((props: {
+        value: number;
+    }) => any) | undefined;
+} & {
+    icon?: ((props: {}) => any) | undefined;
+} & {
+    valueAmount?: ((props: {
+        value: number;
+    }) => any) | undefined;
+} & {
+    valueDeficit?: ((props: {
+        value: number;
+    }) => any) | undefined;
+} & {
+    valueTotal?: ((props: {
+        value: number;
+    }) => any) | undefined;
+};
+/**
+ * A linear progress bar to display progress, with support for various styles and a deficit indicator.
+ * @slot icon - A slot for placing an icon in the header, typically to indicate status.
+ */
+declare const props: {
+    readonly classes: Record<string, any>;
+    readonly small: boolean;
+    readonly labelHidden: boolean;
+    readonly amount: number;
+    readonly labelElement: string;
+    readonly total: number;
+    readonly deficit: number;
+    readonly positive: boolean;
+    readonly negative: boolean;
+    readonly loader: boolean;
+    readonly indeterminate: boolean;
+    readonly noValues: boolean;
+    readonly amountInHeader: boolean;
+    readonly label?: string | undefined;
+    readonly formatValue?: Function | undefined;
+};
+//# sourceMappingURL=UluProgressBar.vue.d.ts.map

package/types/components/visualizations/UluProgressBar.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UluProgressBar.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/visualizations/UluProgressBar.vue"],"names":[],"mappings":"wBA+dqB,eAAe,CAAC,OAAO,eAAe,EAAE,WAAW,CAAC;;qBAEpD,CAAC,EAAE,CAAC;;;AARzB;YAGmB,OAAO,CAAC,OAAO,KAAK,CAAC;;;;;;;;;;;;;;;;2OAErC;;;;;;;;;;;;;;;;;;;;;;AAlTH;;;GAGG;AACH;;;;;;;;;;;;;;;;EAgFG"}

package/types/components/visualizations/UluProgressCircle.vue.d.ts

@@ -0,0 +1,48 @@
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & (new () => {
+    $slots: S;
+});
+declare const __VLS_component: import("vue").DefineComponent<{}, {
+    $props: Partial<typeof props>;
+    label: string;
+    small: boolean;
+    duration: number;
+    easing: string;
+    formatValue: Function;
+    percentage: number;
+    noValue: boolean;
+    outside: boolean;
+    outsideBelow: boolean;
+    status: string;
+    pieStyle: boolean;
+    noMask: boolean;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+type __VLS_Slots = {
+    value?: ((props: {
+        value: number;
+    }) => any) | undefined;
+} & {
+    value?: ((props: {
+        value: number;
+    }) => any) | undefined;
+};
+/**
+ * A circular progress indicator component.
+ * @slot value - The value display. Overrides the `formatValue` prop.
+ */
+declare const props: {
+    readonly label: string;
+    readonly small: boolean;
+    readonly duration: number;
+    readonly easing: string;
+    readonly formatValue: Function;
+    readonly percentage: number;
+    readonly noValue: boolean;
+    readonly outside: boolean;
+    readonly outsideBelow: boolean;
+    readonly status: string;
+    readonly pieStyle: boolean;
+    readonly noMask: boolean;
+};
+//# sourceMappingURL=UluProgressCircle.vue.d.ts.map

package/types/components/visualizations/UluProgressCircle.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UluProgressCircle.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/visualizations/UluProgressCircle.vue"],"names":[],"mappings":"wBAoZqB,eAAe,CAAC,OAAO,eAAe,EAAE,WAAW,CAAC;;qBAEpD,CAAC,EAAE,CAAC;;;AARzB;YAGmB,OAAO,CAAC,OAAO,KAAK,CAAC;;;;;;;;;;;;;2OAErC;;;;;;;;;;AAhPH;;;GAGG;AACH;;;;;;;;;;;;;EAoEG"}

package/types/composables/useBreakpointManager.d.ts

@@ -4,5 +4,5 @@
  * @param {Object} options Configuration options overrides
  * @return {Object} { manager, active, direction } (all are null in SSR environment until init)
  */
-export function useBreakpointManager(options: any): any;
+export function useBreakpointManager(options: Object): Object;
 //# sourceMappingURL=useBreakpointManager.d.ts.map

package/types/composables/useBreakpointManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useBreakpointManager.d.ts","sourceRoot":"","sources":["../../lib/composables/useBreakpointManager.js"],"names":[],"mappings":"AAoBA;;;;;GAKG;AACH,wDAyCC"}
+{"version":3,"file":"useBreakpointManager.d.ts","sourceRoot":"","sources":["../../lib/composables/useBreakpointManager.js"],"names":[],"mappings":"AAoBA;;;;;GAKG;AACH,8CAHW,MAAM,GACL,MAAM,CA2CjB"}

package/types/composables/useDocumentTitle.d.ts

@@ -14,9 +14,9 @@
  * @param {Function} [options.useHead=defaultUseHead] - Injectable `useHead` for testing.
  */
 export function useDocumentTitle(options?: {
-    title?: import("vue").Ref<string> | string;
-    titleTemplate?: string;
-    useRoute?: Function;
-    useHead?: Function;
+    title?: string | import("vue").Ref<string, string> | undefined;
+    titleTemplate?: string | undefined;
+    useRoute?: Function | undefined;
+    useHead?: Function | undefined;
 }): void;
 //# sourceMappingURL=useDocumentTitle.d.ts.map

package/types/composables/useDocumentTitle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDocumentTitle.d.ts","sourceRoot":"","sources":["../../lib/composables/useDocumentTitle.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;GAcG;AACH,2CALG;IAAqD,KAAK,GAAlD,OAAO,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,MAAM;IACjB,aAAa,GAA9B,MAAM;IACa,QAAQ;IACR,OAAO;CACpC,QAsCA"}
+{"version":3,"file":"useDocumentTitle.d.ts","sourceRoot":"","sources":["../../lib/composables/useDocumentTitle.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;GAcG;AACH,2CALG;IAAqD,KAAK;IACjC,aAAa;IACX,QAAQ;IACR,OAAO;CACpC,QAsCA"}

package/types/composables/useIcon.d.ts

@@ -2,5 +2,5 @@
  * Utility composable for handling and formatting icon props for UluIcon.
  * @returns {Object} An object with utility functions { getIconProps, getClassesFromDefinition }
  */
-export function useIcon(): any;
+export function useIcon(): Object;
 //# sourceMappingURL=useIcon.d.ts.map

package/types/composables/useIcon.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useIcon.d.ts","sourceRoot":"","sources":["../../lib/composables/useIcon.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH,+BAyDC"}
+{"version":3,"file":"useIcon.d.ts","sourceRoot":"","sources":["../../lib/composables/useIcon.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH,2BAFa,MAAM,CA2DlB"}

package/types/composables/useModifiers.d.ts

@@ -64,6 +64,6 @@ export function useModifiers({ props, baseClass, internal }: {
         [x: string]: any;
     } | import("vue").ComputedRef<string | string[] | {
         [x: string]: any;
-    }>;
+    }> | undefined;
 }): object;
 //# sourceMappingURL=useModifiers.d.ts.map

package/types/composables/useModifiers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useModifiers.d.ts","sourceRoot":"","sources":["../../lib/composables/useModifiers.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,6DAtDG;IAAwB,KAAK,EAArB,MAAM;IACsC,SAAS,EAArD,MAAM,GAAG,OAAO,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC;IAEuF,QAAQ,GAAjI,MAAM,GAAG,MAAM,EAAE,GAAG;YAAQ,MAAM,GAAE,GAAG;KAAC,GAAG,OAAO,KAAK,EAAE,WAAW,CAAC,MAAM,GAAG,MAAM,EAAE,GAAG;YAAQ,MAAM,GAAE,GAAG;KAAC,CAAC;CAEtH,GAAU,MAAM,CA0ElB"}
+{"version":3,"file":"useModifiers.d.ts","sourceRoot":"","sources":["../../lib/composables/useModifiers.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,6DAtDG;IAAwB,KAAK,EAArB,MAAM;IACsC,SAAS,EAArD,MAAM,GAAG,OAAO,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC;IAEuF,QAAQ;;;;;CAEzI,GAAU,MAAM,CA0ElB"}

package/types/composables/useWindowResize.d.ts

@@ -2,5 +2,5 @@
  * Composable function
  * @return {Object} Contains reactive 'resizing' and two methods for calling callbacks (onResizeStart, onResizeEnd)
  */
-export function useWindowResize(): any;
+export function useWindowResize(): Object;
 //# sourceMappingURL=useWindowResize.d.ts.map

package/types/composables/useWindowResize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useWindowResize.d.ts","sourceRoot":"","sources":["../../lib/composables/useWindowResize.js"],"names":[],"mappings":"AAiDA;;;GAGG;AACH,uCAUC"}
+{"version":3,"file":"useWindowResize.d.ts","sourceRoot":"","sources":["../../lib/composables/useWindowResize.js"],"names":[],"mappings":"AAiDA;;;GAGG;AACH,mCAFY,MAAM,CAYjB"}

package/types/plugins/modals/UluModalsDisplay.vue.d.ts

@@ -0,0 +1,14 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {
+    open: boolean;
+}, {
+    currentModal(): any;
+    currentProps(): any;
+}, {
+    modalMounted(): void;
+    modalUnmounted(): void;
+}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("modal-unmount" | "modal-mount")[], "modal-unmount" | "modal-mount", import("vue").PublicProps, Readonly<{}> & Readonly<{
+    "onModal-unmount"?: ((...args: any[]) => any) | undefined;
+    "onModal-mount"?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=UluModalsDisplay.vue.d.ts.map

package/types/plugins/modals/UluModalsDisplay.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UluModalsDisplay.vue.d.ts","sourceRoot":"","sources":["../../../lib/plugins/modals/UluModalsDisplay.vue"],"names":[],"mappings":""}