intelliwaketssveltekitv25 1.0.29 → 1.0.31

package/dist/About.svelte.d.ts

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

package/dist/AboutBullets.svelte.d.ts

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

package/dist/AccordianSelect.svelte.d.ts

@@ -1,43 +1,14 @@
-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;
-    };
-    exports: {};
-    bindings: "value" | "show";
-    slots: {};
-    events: {};
-};
+import { SvelteComponentTyped } from "svelte";
 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(): {};
+    props(): Record<string, never>;
+    events(): {} & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots(): {};
 }
-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 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>> {
 }
-declare const AccordianSelect: $$IsomorphicComponent;
-type AccordianSelect<T> = InstanceType<typeof AccordianSelect<T>>;
-export default AccordianSelect;
+export {};

package/dist/ActivityOverlay.svelte.d.ts

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

package/dist/ArrayTable.svelte.d.ts

@@ -1,34 +1,14 @@
-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;
-    };
-    exports: {};
-    bindings: "tableRef";
-    slots: {};
-    events: {};
-};
+import { SvelteComponentTyped } from "svelte";
 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(): {};
+    props(): Record<string, never>;
+    events(): {} & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots(): {};
 }
-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 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>> {
 }
-declare const ArrayTable: $$IsomorphicComponent;
-type ArrayTable<T extends Record<string, any>> = InstanceType<typeof ArrayTable<T>>;
-export default ArrayTable;
+export {};

package/dist/BlockNav.svelte.d.ts

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

package/dist/ButtonGroup.svelte.d.ts

@@ -1,36 +1,14 @@
-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;
-    };
-    exports: {};
-    bindings: "value";
-    slots: {};
-    events: {};
-};
+import { SvelteComponentTyped } from "svelte";
 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(): {};
+    props(): Record<string, never>;
+    events(): {} & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots(): {};
 }
-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 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>> {
 }
-declare const ButtonGroup: $$IsomorphicComponent;
-type ButtonGroup<T> = InstanceType<typeof ButtonGroup<T>>;
-export default ButtonGroup;
+export {};

package/dist/Calendar.svelte.d.ts

@@ -1,21 +1,14 @@
-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;
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
 };
-declare const Calendar: import("svelte").Component<$$ComponentProps, {}, "baseDate" | "dateRangeString" | "applyRangeToSecondDate">;
-type Calendar = ReturnType<typeof Calendar>;
-export default Calendar;
+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 {};

package/dist/CheckBox.svelte.d.ts

@@ -1,22 +1,14 @@
-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;
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
 };
-declare const CheckBox: import("svelte").Component<$$ComponentProps, {}, "checked">;
-type CheckBox = ReturnType<typeof CheckBox>;
-export default CheckBox;
+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 {};

package/dist/DateRangePicker.svelte.d.ts

@@ -1,17 +1,14 @@
-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;
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
 };
-declare const DateRangePicker: import("svelte").Component<$$ComponentProps, {}, "show" | "dateRange">;
-type DateRangePicker = ReturnType<typeof DateRangePicker>;
-export default DateRangePicker;
+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 {};

package/dist/DisplayColor.svelte.d.ts

@@ -1,14 +1,14 @@
-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;
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
 };
-declare const DisplayColor: import("svelte").Component<$$ComponentProps, {}, "">;
-type DisplayColor = ReturnType<typeof DisplayColor>;
-export default DisplayColor;
+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 {};

package/dist/DisplayFraction.svelte.d.ts

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

package/dist/DisplayHTML.svelte.d.ts

@@ -1,13 +1,14 @@
-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;
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
 };
-declare const DisplayHtml: import("svelte").Component<$$ComponentProps, {}, "">;
-type DisplayHtml = ReturnType<typeof DisplayHtml>;
-export default DisplayHtml;
+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 {};

package/dist/DropDown.svelte

@@ -282,8 +282,9 @@
 				tabindex={0}>
 				{#if button}
 					{@render button()}
+				{:else if buttonTitle}
+					{buttonTitle}
 				{/if}
-				{buttonTitle ?? ''}
 				{#if !noCaret}
 					<svg
 						class='-mr-1 h-5 w-5 mt-0.5 absolute right-1 top-1/2 -translate-y-1/2 transition-transform duration-300'

package/dist/DropDown.svelte.d.ts

@@ -1,28 +1,14 @@
-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;
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
 };
-declare const DropDown: import("svelte").Component<$$ComponentProps, {}, "show" | "clientWidth">;
-type DropDown = ReturnType<typeof DropDown>;
-export default DropDown;
+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 {};

package/dist/DropDownControl.svelte.d.ts

@@ -1,38 +1,14 @@
-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;
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
 };
-declare const DropDownControl: import("svelte").Component<$$ComponentProps, {}, "show" | "parentDivElement" | "clientWidth">;
-type DropDownControl = ReturnType<typeof DropDownControl>;
-export default DropDownControl;
+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 {};

package/dist/EllipsesTruncate.svelte.d.ts

@@ -1,14 +1,14 @@
-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;
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
 };
-declare const EllipsesTruncate: import("svelte").Component<$$ComponentProps, {}, "">;
-type EllipsesTruncate = ReturnType<typeof EllipsesTruncate>;
-export default EllipsesTruncate;
+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 {};

package/dist/Icon.svelte.d.ts

@@ -1,30 +1,14 @@
-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;
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
 };
-declare const Icon: import("svelte").Component<$$ComponentProps, {}, "">;
-type Icon = ReturnType<typeof Icon>;
-export default Icon;
+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 {};

package/dist/InputNumber.svelte.d.ts

@@ -1,4 +1,14 @@
-import { type TInputNumberAttributes } from './Functions';
-declare const InputNumber: import("svelte").Component<TInputNumberAttributes, {}, "value" | "thisRef">;
-type InputNumber = ReturnType<typeof InputNumber>;
-export default InputNumber;
+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 {};