intelliwaketssveltekitv25 1.0.31 → 1.0.33

package/dist/About.svelte.d.ts

@@ -1,14 +1,7 @@
-import { SvelteComponentTyped } from "svelte";
-declare const __propDef: {
-    props: Record<string, never>;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
+import type { TAbout } from './AboutData';
+type $$ComponentProps = {
+    abouts: TAbout[];
 };
-export type AboutProps = typeof __propDef.props;
-export type AboutEvents = typeof __propDef.events;
-export type AboutSlots = typeof __propDef.slots;
-export default class About extends SvelteComponentTyped<AboutProps, AboutEvents, AboutSlots> {
-}
-export {};
+declare const About: import("svelte").Component<$$ComponentProps, {}, "">;
+type About = ReturnType<typeof About>;
+export default About;

package/dist/AboutBullets.svelte.d.ts

@@ -1,14 +1,8 @@
-import { SvelteComponentTyped } from "svelte";
-declare const __propDef: {
-    props: Record<string, never>;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
+import type { TAboutBullets } from './AboutData';
+import { AboutBullets } from './';
+type $$ComponentProps = {
+    bullets: TAboutBullets[];
 };
-export type AboutBulletsProps = typeof __propDef.props;
-export type AboutBulletsEvents = typeof __propDef.events;
-export type AboutBulletsSlots = typeof __propDef.slots;
-export default class AboutBullets extends SvelteComponentTyped<AboutBulletsProps, AboutBulletsEvents, AboutBulletsSlots> {
-}
-export {};
+declare const AboutBullets: import("svelte").Component<$$ComponentProps, {}, "">;
+type AboutBullets = ReturnType<typeof AboutBullets>;
+export default AboutBullets;

package/dist/AccordianSelect.svelte.d.ts

@@ -1,14 +1,43 @@
-import { SvelteComponentTyped } from "svelte";
-declare class __sveltets_Render<T> {
-    props(): Record<string, never>;
-    events(): {} & {
-        [evt: string]: CustomEvent<any>;
+import type { ISpinItem } from './Definitions';
+import { type ActionArray } from './useActions';
+declare function $$render<T>(): {
+    props: {
+        items: ISpinItem<T>[];
+        class?: string;
+        centered?: boolean;
+        height?: string;
+        maxHeight?: string;
+        minHeight?: string;
+        value?: T | null | undefined;
+        disabled?: boolean;
+        readonly?: boolean;
+        name?: string | undefined;
+        form?: string | undefined;
+        hidden?: boolean;
+        use?: ActionArray;
+        required?: boolean;
+        show?: any;
+        id?: any;
     };
-    slots(): {};
+    exports: {};
+    bindings: "value" | "show";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<T> {
+    props(): ReturnType<typeof $$render<T>>['props'];
+    events(): ReturnType<typeof $$render<T>>['events'];
+    slots(): ReturnType<typeof $$render<T>>['slots'];
+    bindings(): "value" | "show";
+    exports(): {};
 }
-export type AccordianSelectProps<T> = ReturnType<__sveltets_Render<T>['props']>;
-export type AccordianSelectEvents<T> = ReturnType<__sveltets_Render<T>['events']>;
-export type AccordianSelectSlots<T> = ReturnType<__sveltets_Render<T>['slots']>;
-export default class AccordianSelect<T> extends SvelteComponentTyped<AccordianSelectProps<T>, AccordianSelectEvents<T>, AccordianSelectSlots<T>> {
+interface $$IsomorphicComponent {
+    new <T>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<T>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<T>['props']>, ReturnType<__sveltets_Render<T>['events']>, ReturnType<__sveltets_Render<T>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<T>['bindings']>;
+    } & ReturnType<__sveltets_Render<T>['exports']>;
+    <T>(internal: unknown, props: ReturnType<__sveltets_Render<T>['props']> & {}): ReturnType<__sveltets_Render<T>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
 }
-export {};
+declare const AccordianSelect: $$IsomorphicComponent;
+type AccordianSelect<T> = InstanceType<typeof AccordianSelect<T>>;
+export default AccordianSelect;

package/dist/ActivityOverlay.svelte.d.ts

@@ -1,14 +1,11 @@
-import { SvelteComponentTyped } from "svelte";
-declare const __propDef: {
-    props: Record<string, never>;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
+type $$ComponentProps = {
+    show?: boolean;
+    allowCancelAfterSeconds?: number;
+    size?: string;
+    position?: 'fixed' | 'absolute';
+    zIndex?: number;
+    onManualClose?: () => void;
 };
-export type ActivityOverlayProps = typeof __propDef.props;
-export type ActivityOverlayEvents = typeof __propDef.events;
-export type ActivityOverlaySlots = typeof __propDef.slots;
-export default class ActivityOverlay extends SvelteComponentTyped<ActivityOverlayProps, ActivityOverlayEvents, ActivityOverlaySlots> {
-}
-export {};
+declare const ActivityOverlay: import("svelte").Component<$$ComponentProps, {}, "show">;
+type ActivityOverlay = ReturnType<typeof ActivityOverlay>;
+export default ActivityOverlay;

package/dist/ArrayTable.svelte.d.ts

@@ -1,14 +1,34 @@
-import { SvelteComponentTyped } from "svelte";
-declare class __sveltets_Render<T extends Record<string, any>> {
-    props(): Record<string, never>;
-    events(): {} & {
-        [evt: string]: CustomEvent<any>;
+import { type IArrayStructure } from './ArrayFunctions';
+declare function $$render<T extends Record<string, any>>(): {
+    props: {
+        arrayData: T[] | null;
+        arrayStructure: IArrayStructure<T>;
+        bordered?: boolean;
+        scrollable?: boolean;
+        class?: string;
+        minWidth?: string;
+        hideCosts?: boolean;
+        tableRef?: HTMLTableElement | undefined;
     };
-    slots(): {};
+    exports: {};
+    bindings: "tableRef";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<T extends Record<string, any>> {
+    props(): ReturnType<typeof $$render<T>>['props'];
+    events(): ReturnType<typeof $$render<T>>['events'];
+    slots(): ReturnType<typeof $$render<T>>['slots'];
+    bindings(): "tableRef";
+    exports(): {};
 }
-export type ArrayTableProps<T extends Record<string, any>> = ReturnType<__sveltets_Render<T>['props']>;
-export type ArrayTableEvents<T extends Record<string, any>> = ReturnType<__sveltets_Render<T>['events']>;
-export type ArrayTableSlots<T extends Record<string, any>> = ReturnType<__sveltets_Render<T>['slots']>;
-export default class ArrayTable<T extends Record<string, any>> extends SvelteComponentTyped<ArrayTableProps<T>, ArrayTableEvents<T>, ArrayTableSlots<T>> {
+interface $$IsomorphicComponent {
+    new <T extends Record<string, any>>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<T>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<T>['props']>, ReturnType<__sveltets_Render<T>['events']>, ReturnType<__sveltets_Render<T>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<T>['bindings']>;
+    } & ReturnType<__sveltets_Render<T>['exports']>;
+    <T extends Record<string, any>>(internal: unknown, props: ReturnType<__sveltets_Render<T>['props']> & {}): ReturnType<__sveltets_Render<T>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
 }
-export {};
+declare const ArrayTable: $$IsomorphicComponent;
+type ArrayTable<T extends Record<string, any>> = InstanceType<typeof ArrayTable<T>>;
+export default ArrayTable;

package/dist/BlockNav.svelte.d.ts

@@ -1,14 +1,8 @@
-import { SvelteComponentTyped } from "svelte";
-declare const __propDef: {
-    props: Record<string, never>;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
+type $$ComponentProps = {
+    when: boolean;
+    id?: string;
+    forceNav?: boolean;
 };
-export type BlockNavProps = typeof __propDef.props;
-export type BlockNavEvents = typeof __propDef.events;
-export type BlockNavSlots = typeof __propDef.slots;
-export default class BlockNav extends SvelteComponentTyped<BlockNavProps, BlockNavEvents, BlockNavSlots> {
-}
-export {};
+declare const BlockNav: import("svelte").Component<$$ComponentProps, {}, "forceNav">;
+type BlockNav = ReturnType<typeof BlockNav>;
+export default BlockNav;

package/dist/ButtonGroup.svelte.d.ts

@@ -1,14 +1,36 @@
-import { SvelteComponentTyped } from "svelte";
-declare class __sveltets_Render<T> {
-    props(): Record<string, never>;
-    events(): {} & {
-        [evt: string]: CustomEvent<any>;
+declare function $$render<T>(): {
+    props: {
+        value?: T | null;
+        options?: (string | {
+            key: T;
+            name: string;
+            disabled?: boolean;
+            hidden?: boolean;
+        })[];
+        class?: string;
+        name?: string;
+        readonly?: boolean;
+        dataColor?: TDefaultColorPalate;
     };
-    slots(): {};
+    exports: {};
+    bindings: "value";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<T> {
+    props(): ReturnType<typeof $$render<T>>['props'];
+    events(): ReturnType<typeof $$render<T>>['events'];
+    slots(): ReturnType<typeof $$render<T>>['slots'];
+    bindings(): "value";
+    exports(): {};
 }
-export type ButtonGroupProps<T> = ReturnType<__sveltets_Render<T>['props']>;
-export type ButtonGroupEvents<T> = ReturnType<__sveltets_Render<T>['events']>;
-export type ButtonGroupSlots<T> = ReturnType<__sveltets_Render<T>['slots']>;
-export default class ButtonGroup<T> extends SvelteComponentTyped<ButtonGroupProps<T>, ButtonGroupEvents<T>, ButtonGroupSlots<T>> {
+interface $$IsomorphicComponent {
+    new <T>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<T>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<T>['props']>, ReturnType<__sveltets_Render<T>['events']>, ReturnType<__sveltets_Render<T>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<T>['bindings']>;
+    } & ReturnType<__sveltets_Render<T>['exports']>;
+    <T>(internal: unknown, props: ReturnType<__sveltets_Render<T>['props']> & {}): ReturnType<__sveltets_Render<T>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
 }
-export {};
+declare const ButtonGroup: $$IsomorphicComponent;
+type ButtonGroup<T> = InstanceType<typeof ButtonGroup<T>>;
+export default ButtonGroup;

package/dist/Calendar.svelte.d.ts

@@ -1,14 +1,21 @@
-import { SvelteComponentTyped } from "svelte";
-declare const __propDef: {
-    props: Record<string, never>;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
+import { type IWeek, type TDateRangeString } from './DateRangeFunctions';
+import type { Snippet } from 'svelte';
+type $$ComponentProps = {
+    baseDate?: string;
+    dateRangeString?: TDateRangeString | null;
+    applyRangeToSecondDate?: boolean;
+    onSelectRange?: (dateRangeString: TDateRangeString) => void;
+    selectRange?: 'None' | 'Single' | 'Range' | 'Month' | 'Week';
+    minYear?: number;
+    maxYear?: number;
+    maxWidth?: string;
+    fyMonthsAdjust?: number | null;
+    class?: string;
+    dayBlock?: Snippet<[IWeek['days'][number], IWeek]>;
+    navigator?: Snippet;
+    hideNavigation?: boolean;
+    disabled?: boolean;
 };
-export type CalendarProps = typeof __propDef.props;
-export type CalendarEvents = typeof __propDef.events;
-export type CalendarSlots = typeof __propDef.slots;
-export default class Calendar extends SvelteComponentTyped<CalendarProps, CalendarEvents, CalendarSlots> {
-}
-export {};
+declare const Calendar: import("svelte").Component<$$ComponentProps, {}, "baseDate" | "dateRangeString" | "applyRangeToSecondDate">;
+type Calendar = ReturnType<typeof Calendar>;
+export default Calendar;

package/dist/CheckBox.svelte.d.ts

@@ -1,14 +1,22 @@
-import { SvelteComponentTyped } from "svelte";
-declare const __propDef: {
-    props: Record<string, never>;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
+type $$ComponentProps = {
+    /** Whether or not the input is checked */
+    checked?: boolean;
+    /** Allows for styling border */
+    inputClass?: string;
+    /** Allows for styling the indicator box */
+    indicatorClass?: string;
+    /** Changes appearance to radial for single option selections */
+    radial?: boolean;
+    /** Text label for checkbox */
+    label?: string;
+    /** name for form actions */
+    name?: string;
+    /** Allows for firing a input event */
+    fireInputEvent?: boolean;
+    stopPropagation?: boolean;
+    preventDefault?: boolean;
+    onchange?: (e: Event, checked: boolean) => void;
 };
-export type CheckBoxProps = typeof __propDef.props;
-export type CheckBoxEvents = typeof __propDef.events;
-export type CheckBoxSlots = typeof __propDef.slots;
-export default class CheckBox extends SvelteComponentTyped<CheckBoxProps, CheckBoxEvents, CheckBoxSlots> {
-}
-export {};
+declare const CheckBox: import("svelte").Component<$$ComponentProps, {}, "checked">;
+type CheckBox = ReturnType<typeof CheckBox>;
+export default CheckBox;

package/dist/DateRangePicker.svelte.d.ts

@@ -1,14 +1,17 @@
-import { SvelteComponentTyped } from "svelte";
-declare const __propDef: {
-    props: Record<string, never>;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
+import { type TDateRangeString } from './DateRangeFunctions';
+type $$ComponentProps = {
+    dateRange: TDateRangeString;
+    dateRanges?: TDateRangeString[];
+    controlClass?: string;
+    toggleClass?: string;
+    bodyClass?: string;
+    setCookieName?: string;
+    invalidate?: string | string[] | 'All' | 'app:All' | null;
+    allowCustom?: boolean;
+    onchange?: (dateRange: TDateRangeString) => void;
+    show?: boolean;
+    fyMonthsAdjust?: number | null;
 };
-export type DateRangePickerProps = typeof __propDef.props;
-export type DateRangePickerEvents = typeof __propDef.events;
-export type DateRangePickerSlots = typeof __propDef.slots;
-export default class DateRangePicker extends SvelteComponentTyped<DateRangePickerProps, DateRangePickerEvents, DateRangePickerSlots> {
-}
-export {};
+declare const DateRangePicker: import("svelte").Component<$$ComponentProps, {}, "show" | "dateRange">;
+type DateRangePicker = ReturnType<typeof DateRangePicker>;
+export default DateRangePicker;

package/dist/DisplayColor.svelte.d.ts

@@ -1,14 +1,14 @@
-import { SvelteComponentTyped } from "svelte";
-declare const __propDef: {
-    props: Record<string, never>;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
+type $$ComponentProps = {
+    /** 0-360 (0/360 red, 120 green, 240 blue */
+    hue?: number | null;
+    /** 0-100 */
+    saturation?: number | null;
+    /** 0-100 */
+    lightness?: number | null;
+    allowInvisible?: boolean;
+    showNoColorSymbol?: boolean;
+    forceNoColorSymbol?: boolean;
 };
-export type DisplayColorProps = typeof __propDef.props;
-export type DisplayColorEvents = typeof __propDef.events;
-export type DisplayColorSlots = typeof __propDef.slots;
-export default class DisplayColor extends SvelteComponentTyped<DisplayColorProps, DisplayColorEvents, DisplayColorSlots> {
-}
-export {};
+declare const DisplayColor: import("svelte").Component<$$ComponentProps, {}, "">;
+type DisplayColor = ReturnType<typeof DisplayColor>;
+export default DisplayColor;

package/dist/DisplayFraction.svelte.d.ts

@@ -1,14 +1,9 @@
-import { SvelteComponentTyped } from "svelte";
-declare const __propDef: {
-    props: Record<string, never>;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
+type $$ComponentProps = {
+    value: number | null | undefined;
+    onNullUndefined?: 'Zero' | 'Dash' | 'Blank';
+    onBlank?: 'Zero' | 'Dash' | 'Blank';
+    maxDigitsDisplay?: number;
 };
-export type DisplayFractionProps = typeof __propDef.props;
-export type DisplayFractionEvents = typeof __propDef.events;
-export type DisplayFractionSlots = typeof __propDef.slots;
-export default class DisplayFraction extends SvelteComponentTyped<DisplayFractionProps, DisplayFractionEvents, DisplayFractionSlots> {
-}
-export {};
+declare const DisplayFraction: import("svelte").Component<$$ComponentProps, {}, "">;
+type DisplayFraction = ReturnType<typeof DisplayFraction>;
+export default DisplayFraction;

package/dist/DisplayHTML.svelte.d.ts

@@ -1,14 +1,13 @@
-import { SvelteComponentTyped } from "svelte";
-declare const __propDef: {
-    props: Record<string, never>;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
+import type { Snippet } from 'svelte';
+type $$ComponentProps = {
+    value: string | null | undefined | Snippet;
+    anchorClasses?: string;
+    hidden?: boolean;
+    /**
+     * Use the noLinkReplace property to not try to change a URL into an anchor link
+     */
+    noLinkReplace?: boolean;
 };
-export type DisplayHtmlProps = typeof __propDef.props;
-export type DisplayHtmlEvents = typeof __propDef.events;
-export type DisplayHtmlSlots = typeof __propDef.slots;
-export default class DisplayHtml extends SvelteComponentTyped<DisplayHtmlProps, DisplayHtmlEvents, DisplayHtmlSlots> {
-}
-export {};
+declare const DisplayHtml: import("svelte").Component<$$ComponentProps, {}, "">;
+type DisplayHtml = ReturnType<typeof DisplayHtml>;
+export default DisplayHtml;

package/dist/DropDown.svelte.d.ts

@@ -1,14 +1,28 @@
-import { SvelteComponentTyped } from "svelte";
-declare const __propDef: {
-    props: Record<string, never>;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
+import { type Snippet } from 'svelte';
+import type { IDDAction, TDropDownControlPosition } from './Definitions';
+type $$ComponentProps = {
+    show?: boolean;
+    position?: TDropDownControlPosition;
+    ddActions?: IDDAction[];
+    noCaret?: boolean;
+    buttonTitle?: string | null;
+    buttonClass?: string;
+    controlClass?: string;
+    toggleClass?: string;
+    inputControl?: boolean;
+    fullBlock?: boolean;
+    bodyClass?: string;
+    sameSize?: boolean;
+    zIndex?: number;
+    disabled?: boolean;
+    hidden?: boolean;
+    hideEmptyDDActions?: boolean;
+    button?: Snippet;
+    verbose?: boolean;
+    actions?: Snippet;
+    dataColor?: TDefaultColorPalate;
+    clientWidth?: number;
 };
-export type DropDownProps = typeof __propDef.props;
-export type DropDownEvents = typeof __propDef.events;
-export type DropDownSlots = typeof __propDef.slots;
-export default class DropDown extends SvelteComponentTyped<DropDownProps, DropDownEvents, DropDownSlots> {
-}
-export {};
+declare const DropDown: import("svelte").Component<$$ComponentProps, {}, "show" | "clientWidth">;
+type DropDown = ReturnType<typeof DropDown>;
+export default DropDown;

package/dist/DropDownControl.svelte.d.ts

@@ -1,14 +1,38 @@
-import { SvelteComponentTyped } from "svelte";
-declare const __propDef: {
-    props: Record<string, never>;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
+import { type Snippet } from 'svelte';
+import type { TDropDownControlDrop, TDropDownControlPosition } from './Definitions';
+import type { FocusEventHandler, KeyboardEventHandler, MouseEventHandler } from 'svelte/elements';
+type $$ComponentProps = {
+    show?: boolean;
+    onblur?: FocusEventHandler<HTMLDivElement>;
+    onkeydown?: KeyboardEventHandler<HTMLDivElement>;
+    onfocusin?: FocusEventHandler<HTMLDivElement>;
+    onfocusout?: FocusEventHandler<HTMLDivElement>;
+    onkeyup?: KeyboardEventHandler<HTMLDivElement>;
+    onclick?: MouseEventHandler<HTMLDivElement>;
+    manualShowHide?: boolean;
+    allowOutsideClose?: boolean;
+    position?: TDropDownControlPosition | null;
+    drop?: TDropDownControlDrop | null;
+    sameSize?: boolean;
+    controlClass?: string;
+    toggleClass?: string;
+    bodyClass?: string;
+    noScroll?: boolean;
+    fullBlock?: boolean;
+    bubble?: boolean;
+    verbose?: boolean;
+    resizeTS?: number;
+    elFocus?: HTMLElement | null;
+    zIndex?: number;
+    disabled?: boolean;
+    index?: number;
+    parentDivElement?: HTMLDivElement | null;
+    hidden?: boolean;
+    toggle?: Snippet;
+    body?: Snippet;
+    dataColor?: TDefaultColorPalate;
+    clientWidth?: number;
 };
-export type DropDownControlProps = typeof __propDef.props;
-export type DropDownControlEvents = typeof __propDef.events;
-export type DropDownControlSlots = typeof __propDef.slots;
-export default class DropDownControl extends SvelteComponentTyped<DropDownControlProps, DropDownControlEvents, DropDownControlSlots> {
-}
-export {};
+declare const DropDownControl: import("svelte").Component<$$ComponentProps, {}, "show" | "parentDivElement" | "clientWidth">;
+type DropDownControl = ReturnType<typeof DropDownControl>;
+export default DropDownControl;

package/dist/EllipsesTruncate.svelte.d.ts

@@ -1,14 +1,14 @@
-import { SvelteComponentTyped } from "svelte";
-declare const __propDef: {
-    props: Record<string, never>;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
+import type { Snippet } from 'svelte';
+type $$ComponentProps = {
+    text: string | number | null | undefined;
+    prefix?: string | null;
+    suffix?: string | null;
+    class?: string;
+    hidden?: boolean;
+    noTruncate?: boolean;
+    print?: boolean;
+    children?: Snippet;
 };
-export type EllipsesTruncateProps = typeof __propDef.props;
-export type EllipsesTruncateEvents = typeof __propDef.events;
-export type EllipsesTruncateSlots = typeof __propDef.slots;
-export default class EllipsesTruncate extends SvelteComponentTyped<EllipsesTruncateProps, EllipsesTruncateEvents, EllipsesTruncateSlots> {
-}
-export {};
+declare const EllipsesTruncate: import("svelte").Component<$$ComponentProps, {}, "">;
+type EllipsesTruncate = ReturnType<typeof EllipsesTruncate>;
+export default EllipsesTruncate;

package/dist/Icon.svelte.d.ts

@@ -1,14 +1,30 @@
-import { SvelteComponentTyped } from "svelte";
-declare const __propDef: {
-    props: Record<string, never>;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
+import type { IconDefinition } from '@fortawesome/fontawesome-common-types';
+type $$ComponentProps = {
+    class?: string;
+    id?: string;
+    style?: string;
+    icon?: IconDefinition | null | undefined;
+    title?: string | undefined;
+    size?: string;
+    color?: string | null;
+    dataColor?: TDefaultColorPalate | null;
+    fw?: boolean;
+    pull?: 'left' | 'right';
+    scale?: number;
+    translateX?: number;
+    translateY?: number;
+    rotate?: string | number | undefined;
+    flip?: 'horizontal' | 'vertical' | 'both' | boolean;
+    spin?: boolean;
+    pulse?: boolean;
+    primaryColor?: string;
+    secondaryColor?: string;
+    primaryOpacity?: number;
+    secondaryOpacity?: number;
+    swapOpacity?: boolean;
+    invisible?: boolean;
+    hidden?: boolean;
 };
-export type IconProps = typeof __propDef.props;
-export type IconEvents = typeof __propDef.events;
-export type IconSlots = typeof __propDef.slots;
-export default class Icon extends SvelteComponentTyped<IconProps, IconEvents, IconSlots> {
-}
-export {};
+declare const Icon: import("svelte").Component<$$ComponentProps, {}, "">;
+type Icon = ReturnType<typeof Icon>;
+export default Icon;

package/dist/InputNumber.svelte.d.ts

@@ -1,14 +1,4 @@
-import { SvelteComponentTyped } from "svelte";
-declare const __propDef: {
-    props: Record<string, never>;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-export type InputNumberProps = typeof __propDef.props;
-export type InputNumberEvents = typeof __propDef.events;
-export type InputNumberSlots = typeof __propDef.slots;
-export default class InputNumber extends SvelteComponentTyped<InputNumberProps, InputNumberEvents, InputNumberSlots> {
-}
-export {};
+import { type TInputNumberAttributes } from './Functions';
+declare const InputNumber: import("svelte").Component<TInputNumberAttributes, {}, "value" | "thisRef">;
+type InputNumber = ReturnType<typeof InputNumber>;
+export default InputNumber;