intelliwaketssveltekitv25 1.0.31 → 1.0.34

package/dist/InputNumberScroll.svelte.d.ts

@@ -1,14 +1,31 @@
-import { SvelteComponentTyped } from "svelte";
-declare const __propDef: {
-    props: Record<string, never>;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
+type $$ComponentProps = {
+    value?: number | null | undefined;
+    valueHighlight?: number | undefined;
+    lowerRange?: number;
+    increment?: number;
+    upperRange?: number;
+    maxDigitsDisplay?: number;
+    offValue?: number | null;
+    name?: string | undefined;
+    allowManualEntryMode?: boolean;
+    saveManualEntryMode?: string | null;
+    readonly?: boolean;
+    manualEntryMode?: boolean;
+    /**
+     * Maximum number of digits allowed for manual entry.
+     *
+     * @type {number | null}
+     */
+    maxManualEntryDigits?: number | null;
+    displayPercent?: boolean;
+    center?: boolean;
+    buttonClassOff?: string;
+    buttonClassOn?: string;
+    buttonClassHighlightOn?: string;
+    buttonClassHighlightOff?: string;
+    displayQualifier?: string;
+    onChange?: (val: number | null | undefined) => void;
 };
-export type InputNumberScrollProps = typeof __propDef.props;
-export type InputNumberScrollEvents = typeof __propDef.events;
-export type InputNumberScrollSlots = typeof __propDef.slots;
-export default class InputNumberScroll extends SvelteComponentTyped<InputNumberScrollProps, InputNumberScrollEvents, InputNumberScrollSlots> {
-}
-export {};
+declare const InputNumberScroll: import("svelte").Component<$$ComponentProps, {}, "value">;
+type InputNumberScroll = ReturnType<typeof InputNumberScroll>;
+export default InputNumberScroll;

package/dist/ListGroupItems.svelte.d.ts

@@ -1,14 +1,27 @@
-import { SvelteComponentTyped } from "svelte";
-declare const __propDef: {
-    props: Record<string, never>;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
+import type { PathAnalyzer } from './PathAnalyzer';
+import { type TFindIsActive } from '@solidbasisventures/intelliwaketsfoundation';
+import type { TListGroupItem } from './Definitions';
+import { type Snippet } from 'svelte';
+import { ListGroupItems } from './';
+type $$ComponentProps = {
+    listItems?: TListGroupItem[];
+    emptyListMessage?: string | null;
+    borders?: boolean;
+    subsExist?: boolean;
+    topValue?: string | null;
+    active?: TFindIsActive;
+    indentLevel?: number;
+    collapsedValues?: string[];
+    collapsedSections?: string[];
+    rememberKey?: string | null;
+    pathAnalyzer?: PathAnalyzer | null | undefined;
+    wrapText?: boolean;
+    ellipses?: boolean;
+    noLinkReplace?: boolean;
+    rounded?: boolean;
+    caret?: boolean | 'left' | 'right';
+    empty?: Snippet;
 };
-export type ListGroupItemsProps = typeof __propDef.props;
-export type ListGroupItemsEvents = typeof __propDef.events;
-export type ListGroupItemsSlots = typeof __propDef.slots;
-export default class ListGroupItems extends SvelteComponentTyped<ListGroupItemsProps, ListGroupItemsEvents, ListGroupItemsSlots> {
-}
-export {};
+declare const ListGroupItems: import("svelte").Component<$$ComponentProps, {}, "collapsedValues" | "collapsedSections">;
+type ListGroupItems = ReturnType<typeof ListGroupItems>;
+export default ListGroupItems;

package/dist/MasterDetailLayout.svelte.d.ts

@@ -1,14 +1,34 @@
-import { SvelteComponentTyped } from "svelte";
-declare const __propDef: {
-    props: Record<string, never>;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
+import type { IFAProps, TMasterDetailListGroupItem } from './Definitions';
+import { type TFindIsActive } from '@solidbasisventures/intelliwaketsfoundation';
+import { type Snippet } from 'svelte';
+import { type TBreakAt } from './BreakAtManager.js';
+type $$ComponentProps = {
+    pageRoute: string;
+    breakAt?: TBreakAt;
+    backName?: string | null;
+    listItems?: TMasterDetailListGroupItem[] | null;
+    caret?: boolean | 'left' | 'right';
+    emptyListMessage?: string | null;
+    active?: TFindIsActive;
+    mdClass?: string;
+    masterClass?: string;
+    detailClass?: string;
+    wrapText?: boolean;
+    ellipses?: boolean;
+    borders?: boolean;
+    noLinkReplace?: boolean;
+    rounded?: boolean;
+    roundedDetailFormatted?: boolean;
+    roundedDetailFormattedHome?: boolean;
+    detailShowHeader?: boolean | string;
+    detailShowHeaderFAProps?: IFAProps | null;
+    empty?: Snippet;
+    header?: Snippet;
+    subheader?: Snippet;
+    list?: Snippet;
+    footer?: Snippet;
+    detail?: Snippet;
 };
-export type MasterDetailLayoutProps = typeof __propDef.props;
-export type MasterDetailLayoutEvents = typeof __propDef.events;
-export type MasterDetailLayoutSlots = typeof __propDef.slots;
-export default class MasterDetailLayout extends SvelteComponentTyped<MasterDetailLayoutProps, MasterDetailLayoutEvents, MasterDetailLayoutSlots> {
-}
-export {};
+declare const MasterDetailLayout: import("svelte").Component<$$ComponentProps, {}, "">;
+type MasterDetailLayout = ReturnType<typeof MasterDetailLayout>;
+export default MasterDetailLayout;

package/dist/MessageBoxes.svelte.d.ts

@@ -1,14 +1,18 @@
-import { SvelteComponentTyped } from "svelte";
-declare const __propDef: {
-    props: Record<string, never>;
-    events: {
-        [evt: string]: CustomEvent<any>;
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
     };
-    slots: {};
-};
-export type MessageBoxesProps = typeof __propDef.props;
-export type MessageBoxesEvents = typeof __propDef.events;
-export type MessageBoxesSlots = typeof __propDef.slots;
-export default class MessageBoxes extends SvelteComponentTyped<MessageBoxesProps, MessageBoxesEvents, MessageBoxesSlots> {
+    z_$$bindings?: Bindings;
 }
-export {};
+declare const MessageBoxes: $$__sveltets_2_IsomorphicComponent<Record<string, never>, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type MessageBoxes = InstanceType<typeof MessageBoxes>;
+export default MessageBoxes;

package/dist/Modal.svelte.d.ts

@@ -1,19 +1,46 @@
-import { SvelteComponentTyped } from "svelte";
-declare const __propDef: {
-    props: Record<string, never>;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
+import { type Snippet } from 'svelte';
+import { type IFAProps } from './Definitions';
+type $$ComponentProps = {
+    header?: Snippet;
+    body?: Snippet;
+    leftFooter?: Snippet;
+    centerFooter?: Snippet;
+    rightFooter?: Snippet;
+    /**  A value equal to the 'noShowValue' or 'false' will have the modal hidden, any other value will show it */
+    show: unknown;
+    /** The value to compare against to have the modal hidden, default 'false' */
+    noShowValue?: unknown;
+    forceNoShow?: boolean;
+    width?: string;
+    cancelButton?: string | false;
+    okButton?: string | false;
+    okFAProps?: IFAProps;
+    okActionNotOnEnter?: boolean;
+    okDisabled?: boolean;
+    noCloseOnOK?: boolean;
+    overflowY?: 'auto' | 'visible' | 'hidden';
+    disable?: boolean;
+    okType?: 'submit' | 'button';
+    marginForStickyHeader?: boolean;
+    okButtonWrap?: boolean;
+    class?: string;
+    okColor?: TDefaultColorPalate;
+    color?: TDefaultColorPalate;
+    classHeader?: string;
+    classBody?: string;
+    classFooter?: string;
+    classButton?: string;
+    borderFooter?: boolean;
+    onOK?: () => void;
+    onOKPromise?: () => Promise<unknown>;
+    onCancel?: () => void;
+    onClose?: () => void;
 };
-export type ModalProps = typeof __propDef.props;
-export type ModalEvents = typeof __propDef.events;
-export type ModalSlots = typeof __propDef.slots;
 /**
  * This component presents a modal window using the HTML5 dialog element
  * @param {any} show A property that determines if the modal should be shown or not
  * @param {any} noShowValue A property that, if equal to the show property, will hide the modal, otherwise show the modal
  */
-export default class Modal extends SvelteComponentTyped<ModalProps, ModalEvents, ModalSlots> {
-}
-export {};
+declare const Modal: import("svelte").Component<$$ComponentProps, {}, "show">;
+type Modal = ReturnType<typeof Modal>;
+export default Modal;

package/dist/ModalFormAction.svelte.d.ts

@@ -1,14 +1,32 @@
-import { SvelteComponentTyped } from "svelte";
-declare const __propDef: {
-    props: Record<string, never>;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
+import { type Snippet } from 'svelte';
+import type { TEnhanceOptions } from './FormEnhance';
+import { type IFAProps } from './index';
+type $$ComponentProps = {
+    header?: Snippet;
+    body?: Snippet;
+    leftFooter?: Snippet;
+    rightFooter?: Snippet;
+    action: string;
+    formEnhance?: TEnhanceOptions | null | undefined;
+    show?: unknown;
+    noShowValue?: unknown;
+    width?: string;
+    cancelButton?: string | false;
+    okButton?: string | false;
+    okDisabled?: boolean;
+    okFAProps?: IFAProps;
+    noCloseOnOK?: boolean;
+    overflowVisible?: boolean;
+    disable?: boolean;
+    marginForStickyHeader?: boolean;
+    okButtonWrap?: boolean;
+    class?: string;
+    classHeader?: string;
+    classButton?: string;
+    borderFooter?: boolean;
+    onCancel?: () => void;
+    onClose?: () => void;
 };
-export type ModalFormActionProps = typeof __propDef.props;
-export type ModalFormActionEvents = typeof __propDef.events;
-export type ModalFormActionSlots = typeof __propDef.slots;
-export default class ModalFormAction extends SvelteComponentTyped<ModalFormActionProps, ModalFormActionEvents, ModalFormActionSlots> {
-}
-export {};
+declare const ModalFormAction: import("svelte").Component<$$ComponentProps, {}, "show">;
+type ModalFormAction = ReturnType<typeof ModalFormAction>;
+export default ModalFormAction;

package/dist/ModalPromptControl.svelte.d.ts

@@ -1,14 +1,3 @@
-import { SvelteComponentTyped } from "svelte";
-declare const __propDef: {
-    props: Record<string, never>;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-export type ModalPromptControlProps = typeof __propDef.props;
-export type ModalPromptControlEvents = typeof __propDef.events;
-export type ModalPromptControlSlots = typeof __propDef.slots;
-export default class ModalPromptControl extends SvelteComponentTyped<ModalPromptControlProps, ModalPromptControlEvents, ModalPromptControlSlots> {
-}
-export {};
+declare const ModalPromptControl: import("svelte").Component<Record<string, never>, {}, "">;
+type ModalPromptControl = ReturnType<typeof ModalPromptControl>;
+export default ModalPromptControl;

package/dist/MultiSelect.svelte.d.ts

@@ -1,15 +1,69 @@
-import { SvelteComponentTyped } from "svelte";
 import { type TGenericMultiSelect } from './Definitions';
-declare class __sveltets_Render<T extends TGenericMultiSelect> {
-    props(): Record<string, never>;
-    events(): {} & {
-        [evt: string]: CustomEvent<any>;
+import { type ActionArray } from './useActions';
+declare function $$render<T extends TGenericMultiSelect>(): {
+    props: {
+        id?: string;
+        show?: boolean;
+        use?: ActionArray;
+        possibles: T[];
+        selected?: T[];
+        selectedIDs?: (number | string)[] | undefined;
+        created?: T[];
+        existing?: T[];
+        name?: string | null;
+        placeholder?: string;
+        disabled?: boolean;
+        readonly?: boolean;
+        required?: boolean;
+        invalid?: boolean;
+        isMulti?: boolean;
+        allowClearAll?: boolean;
+        createPrefix?: string;
+        create?: undefined | ((value: string) => T | null);
+        createValid?: undefined | ((value: string) => boolean | string);
+        tabindex?: number;
+        displayValue?: ((item: T) => string | number);
+        idValue?: ((item: T) => any);
+        /** Compute the value of the "key" in the "each" statements to make them unique */
+        keyValue?: ((item: T, idx?: number) => any);
+        inputValue?: ((item: T) => any);
+        headerValue?: ((item: T | null | undefined) => string | null | undefined);
+        sameSize?: boolean;
+        resizeTS?: number;
+        autoFocus?: boolean;
+        zIndex?: number;
+        bodyClass?: string;
+        toggleClass?: string;
+        controlClass?: string;
+        inputClass?: string;
+        parentDivElement?: HTMLDivElement | null;
+        form?: string | undefined;
+        onadd?: (id: string | number) => void;
+        onselect?: (id: string | number) => void;
+        oncreate?: (item: string) => void;
+        onchange?: (items: T[]) => void;
+        onclear?: (id: string | number) => void;
+        onclearall?: () => void;
     };
-    slots(): {};
+    exports: {};
+    bindings: "selected" | "show" | "selectedIDs" | "created" | "existing";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<T extends TGenericMultiSelect> {
+    props(): ReturnType<typeof $$render<T>>['props'];
+    events(): ReturnType<typeof $$render<T>>['events'];
+    slots(): ReturnType<typeof $$render<T>>['slots'];
+    bindings(): "selected" | "show" | "selectedIDs" | "created" | "existing";
+    exports(): {};
 }
-export type MultiSelectProps<T extends TGenericMultiSelect> = ReturnType<__sveltets_Render<T>['props']>;
-export type MultiSelectEvents<T extends TGenericMultiSelect> = ReturnType<__sveltets_Render<T>['events']>;
-export type MultiSelectSlots<T extends TGenericMultiSelect> = ReturnType<__sveltets_Render<T>['slots']>;
-export default class MultiSelect<T extends TGenericMultiSelect> extends SvelteComponentTyped<MultiSelectProps<T>, MultiSelectEvents<T>, MultiSelectSlots<T>> {
+interface $$IsomorphicComponent {
+    new <T extends TGenericMultiSelect>(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 TGenericMultiSelect>(internal: unknown, props: ReturnType<__sveltets_Render<T>['props']> & {}): ReturnType<__sveltets_Render<T>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
 }
-export {};
+declare const MultiSelect: $$IsomorphicComponent;
+type MultiSelect<T extends TGenericMultiSelect> = InstanceType<typeof MultiSelect<T>>;
+export default MultiSelect;

package/dist/NumberFormat.svelte.d.ts

@@ -1,14 +1,9 @@
-import { SvelteComponentTyped } from "svelte";
-declare const __propDef: {
-    props: Record<string, never>;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-export type NumberFormatProps = typeof __propDef.props;
-export type NumberFormatEvents = typeof __propDef.events;
-export type NumberFormatSlots = typeof __propDef.slots;
-export default class NumberFormat extends SvelteComponentTyped<NumberFormatProps, NumberFormatEvents, NumberFormatSlots> {
-}
-export {};
+import { type TNumberStringOptions } from '@solidbasisventures/intelliwaketsfoundation';
+type $$ComponentProps = ({
+    value?: number | null;
+    className?: string;
+    classNameAddOnNegative?: string;
+} & TNumberStringOptions);
+declare const NumberFormat: import("svelte").Component<$$ComponentProps, {}, "">;
+type NumberFormat = ReturnType<typeof NumberFormat>;
+export default NumberFormat;

package/dist/Paginator.svelte

@@ -15,6 +15,7 @@
 	import { goto, invalidate as doInvalidate, invalidateAll } from '$app/navigation'
 	import { browser } from '$app/environment'
 	import DropDown from './DropDown.svelte'
+	import { untrack } from 'svelte'
 
 	let {
 		page = $bindable(),
@@ -24,7 +25,8 @@
 		cookieParms = false,
 		cookieDays,
 		invalidate,
-		class: clazz = ''
+		class: clazz = '',
+		onPageChange
 	}: (Pick<IPaginatorResponse, 'page' | 'pageCount'> &
 		{
 			verbose?: boolean
@@ -32,7 +34,8 @@
 			cookieParms?: boolean | string
 			cookieDays?: number
 			invalidate?: string | string[] | (string | URL | ((url: URL) => boolean)) | (string | URL | ((url: URL) => boolean))[] | null
-			class?: string
+			class?: string,
+			onPageChange?: (page: number) => void | Promise<void>
 		}) = $props()
 
 	type TDisplay = {
@@ -49,6 +52,7 @@
 
 	function setPage(newPage: number) {
 		page = newPage
+		if (onPageChange) onPageChange(page)
 	}
 
 	function createDisplay(parm_page: number, parm_pageCount: number, parm_clientWidth: number): TDisplay {
@@ -95,7 +99,9 @@
 				.map<IDDAction>((pg, idx) => ({
 					title: !pg ? '...' : `Page ${ToDigits(pg)}`,
 					active: !!pg && usePage === pg,
-					action: !pg ? undefined : () => setPage(pg),
+					action: !pg ? undefined : () => {
+						untrack(() => setPage(pg))
+					},
 					key: idx.toString()
 				})),
 			showBackNext: remainingButtonsFittable >= 2,

package/dist/Paginator.svelte.d.ts

@@ -1,14 +1,13 @@
-import { SvelteComponentTyped } from "svelte";
-declare const __propDef: {
-    props: Record<string, never>;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-export type PaginatorProps = typeof __propDef.props;
-export type PaginatorEvents = typeof __propDef.events;
-export type PaginatorSlots = typeof __propDef.slots;
-export default class Paginator extends SvelteComponentTyped<PaginatorProps, PaginatorEvents, PaginatorSlots> {
-}
-export {};
+import { type IPaginatorResponse } from '@solidbasisventures/intelliwaketsfoundation';
+type $$ComponentProps = (Pick<IPaginatorResponse, 'page' | 'pageCount'> & {
+    verbose?: boolean;
+    updateQueryParams?: boolean | string;
+    cookieParms?: boolean | string;
+    cookieDays?: number;
+    invalidate?: string | string[] | (string | URL | ((url: URL) => boolean)) | (string | URL | ((url: URL) => boolean))[] | null;
+    class?: string;
+    onPageChange?: (page: number) => void | Promise<void>;
+});
+declare const Paginator: import("svelte").Component<$$ComponentProps, {}, "page">;
+type Paginator = ReturnType<typeof Paginator>;
+export default Paginator;

package/dist/Search.svelte.d.ts

@@ -1,14 +1,18 @@
-import { SvelteComponentTyped } from "svelte";
-declare const __propDef: {
-    props: Record<string, never>;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
+import { type ActionArray } from './useActions';
+import type { HTMLInputAttributes } from 'svelte/elements';
+type $$ComponentProps = HTMLInputAttributes & {
+    id?: string | undefined;
+    value?: string;
+    use?: ActionArray;
+    delayMS?: number;
+    placeholder?: string;
+    bordered?: boolean;
+    element?: HTMLInputElement | undefined;
+    class?: string;
+    sessionKey?: string;
+    noMagnifyingGlass?: boolean;
+    onChange?: (val: string) => void;
 };
-export type SearchProps = typeof __propDef.props;
-export type SearchEvents = typeof __propDef.events;
-export type SearchSlots = typeof __propDef.slots;
-export default class Search extends SvelteComponentTyped<SearchProps, SearchEvents, SearchSlots> {
-}
-export {};
+declare const Search: import("svelte").Component<$$ComponentProps, {}, "value">;
+type Search = ReturnType<typeof Search>;
+export default Search;

package/dist/SelectTimezone.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 TDateAny } from '@solidbasisventures/intelliwaketsfoundation';
+type $$ComponentProps = {
+    value?: string | null;
+    id?: string | undefined;
+    name?: string | undefined;
+    timezoneList?: 'AmericaCommon' | 'America' | 'All';
+    hideIANA?: boolean;
+    forDate?: TDateAny;
+    showPrefix?: boolean;
 };
-export type SelectTimezoneProps = typeof __propDef.props;
-export type SelectTimezoneEvents = typeof __propDef.events;
-export type SelectTimezoneSlots = typeof __propDef.slots;
-export default class SelectTimezone extends SvelteComponentTyped<SelectTimezoneProps, SelectTimezoneEvents, SelectTimezoneSlots> {
-}
-export {};
+declare const SelectTimezone: import("svelte").Component<$$ComponentProps, {}, "value">;
+type SelectTimezone = ReturnType<typeof SelectTimezone>;
+export default SelectTimezone;

package/dist/SlideDown.svelte.d.ts

@@ -1,14 +1,18 @@
-import { SvelteComponentTyped } from "svelte";
-declare const __propDef: {
-    props: Record<string, never>;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
+import type { IDDAction } from './Definitions';
+import { type Snippet } from 'svelte';
+import { type ActionArray } from './useActions';
+type $$ComponentProps = {
+    button?: Snippet;
+    actions?: Snippet;
+    ddActions: IDDAction[];
+    use?: ActionArray;
+    show?: boolean;
+    width?: string;
+    maxHeight?: string | null;
+    caret?: boolean;
+    buttonTitle?: string | null;
+    highlightedIndex?: number;
 };
-export type SlideDownProps = typeof __propDef.props;
-export type SlideDownEvents = typeof __propDef.events;
-export type SlideDownSlots = typeof __propDef.slots;
-export default class SlideDown extends SvelteComponentTyped<SlideDownProps, SlideDownEvents, SlideDownSlots> {
-}
-export {};
+declare const SlideDown: import("svelte").Component<$$ComponentProps, {}, "show">;
+type SlideDown = ReturnType<typeof SlideDown>;
+export default SlideDown;

package/dist/SliderDual.svelte.d.ts

@@ -1,14 +1,29 @@
-import { SvelteComponentTyped } from "svelte";
-declare class __sveltets_Render<T extends number> {
-    props(): Record<string, never>;
-    events(): {} & {
-        [evt: string]: CustomEvent<any>;
+declare function $$render<T extends number>(): {
+    props: {
+        values: T[];
+        minValue?: T;
+        maxValue?: T;
+        onchange?: (minValue: T, maxValue: T) => void;
     };
-    slots(): {};
+    exports: {};
+    bindings: "minValue" | "maxValue";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<T extends number> {
+    props(): ReturnType<typeof $$render<T>>['props'];
+    events(): ReturnType<typeof $$render<T>>['events'];
+    slots(): ReturnType<typeof $$render<T>>['slots'];
+    bindings(): "minValue" | "maxValue";
+    exports(): {};
 }
-export type SliderDualProps<T extends number> = ReturnType<__sveltets_Render<T>['props']>;
-export type SliderDualEvents<T extends number> = ReturnType<__sveltets_Render<T>['events']>;
-export type SliderDualSlots<T extends number> = ReturnType<__sveltets_Render<T>['slots']>;
-export default class SliderDual<T extends number> extends SvelteComponentTyped<SliderDualProps<T>, SliderDualEvents<T>, SliderDualSlots<T>> {
+interface $$IsomorphicComponent {
+    new <T extends number>(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 number>(internal: unknown, props: ReturnType<__sveltets_Render<T>['props']> & {}): ReturnType<__sveltets_Render<T>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
 }
-export {};
+declare const SliderDual: $$IsomorphicComponent;
+type SliderDual<T extends number> = InstanceType<typeof SliderDual<T>>;
+export default SliderDual;