sheer-ui 0.4.2 → 0.5.0

package/dist/blocks/Appearance.svelte.d.ts

@@ -0,0 +1,6 @@
+type $$ComponentProps = {
+    description?: string;
+};
+declare const Appearance: import("svelte").Component<$$ComponentProps, {}, "">;
+type Appearance = ReturnType<typeof Appearance>;
+export default Appearance;

package/dist/blocks/BoundaryFailed.svelte.d.ts

@@ -0,0 +1,9 @@
+import type { ClassValue } from 'svelte/elements';
+type $$ComponentProps = {
+    error: unknown;
+    reset: () => void;
+    class?: ClassValue;
+};
+declare const BoundaryFailed: import("svelte").Component<$$ComponentProps, {}, "">;
+type BoundaryFailed = ReturnType<typeof BoundaryFailed>;
+export default BoundaryFailed;

package/dist/blocks/ErrorPage.svelte.d.ts

@@ -0,0 +1,15 @@
+import type { Component } from 'svelte';
+import type { ClassValue } from 'svelte/elements';
+type $$ComponentProps = {
+    status: number;
+    message?: string | null;
+    class?: ClassValue;
+    homeHref?: string;
+    homeLabel?: string;
+    showBack?: boolean;
+    showRetry?: boolean;
+    showHome?: boolean;
+};
+declare const ErrorPage: Component<$$ComponentProps, {}, "">;
+type ErrorPage = ReturnType<typeof ErrorPage>;
+export default ErrorPage;

package/dist/blocks/Footer.svelte.d.ts

@@ -0,0 +1,22 @@
+import type { Component } from 'svelte';
+type NavLink = {
+    href: string;
+    label: string;
+};
+type SocialLink = {
+    href: string;
+    label: string;
+    icon: Component<{
+        class?: string;
+    }>;
+};
+type Props = {
+    brandHref?: string;
+    copyright?: string;
+    navLinks?: NavLink[];
+    legalLinks?: NavLink[];
+    socialLinks?: SocialLink[];
+};
+declare const Footer: Component<Props, {}, "">;
+type Footer = ReturnType<typeof Footer>;
+export default Footer;

package/dist/blocks/Header.svelte.d.ts

@@ -0,0 +1,21 @@
+type NavLink = {
+    href: string;
+    label: string;
+};
+type ActionButton = {
+    href: string;
+    label: string;
+    variant?: 'default' | 'outline' | 'ghost' | 'card' | 'secondary';
+};
+interface Props {
+    brand: string;
+    brandHref?: string;
+    navLinks?: NavLink[];
+    actions?: ActionButton[];
+    mobileActions?: ActionButton[];
+    showBorder?: boolean;
+    mobileId?: string;
+}
+declare const Header: import("svelte").Component<Props, {}, "">;
+type Header = ReturnType<typeof Header>;
+export default Header;

package/dist/blocks/Heading.svelte.d.ts

@@ -0,0 +1,38 @@
+import type { Component } from 'svelte';
+import type { ClassValue } from 'svelte/elements';
+declare function $$render<T extends string>(): {
+    props: {
+        title?: string;
+        tabs?: readonly {
+            id: T;
+            label: string;
+            href?: string;
+            icon?: Component<{
+                class?: string;
+            }>;
+        }[];
+        activeTab?: T;
+        class?: ClassValue;
+    };
+    exports: {};
+    bindings: "";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<T extends string> {
+    props(): ReturnType<typeof $$render<T>>['props'];
+    events(): ReturnType<typeof $$render<T>>['events'];
+    slots(): ReturnType<typeof $$render<T>>['slots'];
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <T extends string>(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 string>(internal: unknown, props: ReturnType<__sveltets_Render<T>['props']> & {}): ReturnType<__sveltets_Render<T>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const Heading: $$IsomorphicComponent;
+type Heading<T extends string> = InstanceType<typeof Heading<T>>;
+export default Heading;

package/dist/blocks/MobileNav.svelte.d.ts

@@ -0,0 +1,30 @@
+import { OpenCell } from '../internal/open-cell.svelte.js';
+import type { ClassValue } from 'svelte/elements';
+interface Props {
+    navLinks: {
+        href: string;
+        label: string;
+        children?: {
+            href: string;
+            label: string;
+        }[];
+    }[];
+    /** Action buttons rendered at the bottom of the panel (e.g. login / book). */
+    actions?: {
+        href: string;
+        label: string;
+        variant?: 'default' | 'outline' | 'ghost' | 'card' | 'secondary';
+        size?: 'default' | 'sm' | 'lg' | 'icon';
+    }[];
+    /** Derivation source for the menu's open state. Not bindable. */
+    open?: boolean;
+    /** A caller-constructed cell used instead of building one from `open`. */
+    state?: OpenCell;
+    /** Unique id for the popover. Override if mounting multiple instances. */
+    id?: string;
+    /** Optional extra classes on the trigger button. */
+    class?: ClassValue;
+}
+declare const MobileNav: import("svelte").Component<Props, {}, "">;
+type MobileNav = ReturnType<typeof MobileNav>;
+export default MobileNav;

package/dist/blocks/PhoneInput.svelte.d.ts

@@ -0,0 +1,11 @@
+type $$ComponentProps = {
+    id?: string;
+    name?: string;
+    value?: string;
+    error?: string;
+    placeholder?: string;
+    disabled?: boolean;
+};
+declare const PhoneInput: import("svelte").Component<$$ComponentProps, {}, "value">;
+type PhoneInput = ReturnType<typeof PhoneInput>;
+export default PhoneInput;

package/dist/blocks/Section.svelte.d.ts

@@ -0,0 +1,12 @@
+import type { Snippet } from 'svelte';
+import type { HTMLAttributes } from 'svelte/elements';
+type $$ComponentProps = HTMLAttributes<HTMLElement> & {
+    children?: Snippet;
+    badge?: string;
+    title?: string;
+    subtitle?: string;
+    center?: boolean;
+};
+declare const Section: import("svelte").Component<$$ComponentProps, {}, "">;
+type Section = ReturnType<typeof Section>;
+export default Section;

package/dist/blocks/alert-modal/AlertModal.svelte.d.ts

@@ -0,0 +1,3 @@
+declare const AlertModal: import("svelte").Component<Record<string, never>, {}, "">;
+type AlertModal = ReturnType<typeof AlertModal>;
+export default AlertModal;

package/dist/blocks/alert-modal/alert-modal.svelte.d.ts

@@ -0,0 +1,30 @@
+import type { Snippet } from 'svelte';
+export type AlertModalVariant = 'destructive' | 'warning' | 'default';
+export interface AlertModalOptions {
+    title: string;
+    description: string;
+    actionLabel?: string;
+    cancelLabel?: string;
+    variant?: AlertModalVariant;
+    /** If set, user must type this text to enable the action button */
+    confirmText?: string;
+    /** Action handler. Omit for a plain acknowledgement dialog — confirming just closes it. */
+    onConfirm?: () => Promise<void> | void;
+    /** Optional snippet for custom body content between description and footer */
+    content?: Snippet;
+}
+export declare const VARIANT_DEFAULTS: Record<AlertModalVariant, string>;
+export declare class AlertModalState {
+    open: boolean;
+    loading: boolean;
+    options: AlertModalOptions | null;
+    confirmInput: string;
+    get canConfirm(): boolean;
+    get actionLabel(): string;
+    show(options: AlertModalOptions): void;
+    destructive(options: Omit<AlertModalOptions, 'variant'>): void;
+    warning(options: Omit<AlertModalOptions, 'variant'>): void;
+    handleConfirm(): Promise<void>;
+    close(): void;
+}
+export declare const alertModal: AlertModalState;

package/dist/blocks/alert-modal/alert-modal.svelte.js

@@ -0,0 +1,57 @@
+export const VARIANT_DEFAULTS = {
+    destructive: 'Remove',
+    warning: 'Continue',
+    default: 'OK',
+};
+export class AlertModalState {
+    open = $state(false);
+    loading = $state(false);
+    // raw: replaced wholesale by show()/close(), never mutated, and it carries a Snippet,
+    // which has no business inside a deep proxy
+    options = $state.raw(null);
+    confirmInput = $state('');
+    get canConfirm() {
+        if (!this.options)
+            return false;
+        if (this.options.confirmText && this.confirmInput !== this.options.confirmText)
+            return false;
+        return !this.loading;
+    }
+    get actionLabel() {
+        return this.options?.actionLabel ?? VARIANT_DEFAULTS[this.options?.variant ?? 'default'];
+    }
+    show(options) {
+        this.options = options;
+        this.confirmInput = '';
+        this.loading = false;
+        this.open = true;
+    }
+    destructive(options) {
+        this.show({ ...options, variant: 'destructive' });
+    }
+    warning(options) {
+        this.show({ ...options, variant: 'warning' });
+    }
+    async handleConfirm() {
+        if (!this.options || !this.canConfirm)
+            return;
+        this.loading = true;
+        try {
+            await this.options.onConfirm?.();
+            this.close();
+        }
+        catch {
+            this.loading = false;
+        }
+    }
+    close() {
+        this.open = false;
+        this.loading = false;
+        this.options = null;
+        this.confirmInput = '';
+    }
+}
+export const alertModal = new AlertModalState();
+// Session-expiry recovery used to live here (isSessionExpired / recoverSession / watchSessionRejections). It's gone:
+// the server gate (@polumeyv/kit idpSessionGate) now redirects dead-session requests — navigations and remote
+// calls alike — straight to the IdP, so a logged-out user never surfaces a session error inside the app.

package/dist/blocks/alert-modal/index.js

@@ -0,0 +1,2 @@
+export { default as AlertModal } from './AlertModal.svelte';
+export * from './alert-modal.svelte';

package/dist/blocks/calendar.svelte.d.ts

@@ -0,0 +1,25 @@
+import { Calendar } from '../components/calendar';
+import type { CalendarRootProps, CalendarMonthSelectProps, CalendarYearSelectProps } from '../components/calendar/types.js';
+import type { WithoutChildrenOrChild } from '../internal/utils.js';
+import type { ButtonVariant } from '../components/button';
+import type { DateValue } from '@internationalized/date';
+import type { Snippet } from 'svelte';
+type SingleRootProps = Extract<CalendarRootProps, {
+    type: 'single';
+}>;
+type $$ComponentProps = Omit<WithoutChildrenOrChild<SingleRootProps>, 'type' | 'onValueChange' | 'onPlaceholderChange'> & {
+    type: 'single';
+    buttonVariant?: ButtonVariant;
+    captionLayout?: 'dropdown' | 'label';
+    months?: CalendarMonthSelectProps['months'];
+    years?: CalendarYearSelectProps['years'];
+    monthFormat?: CalendarMonthSelectProps['monthFormat'];
+    yearFormat?: CalendarYearSelectProps['yearFormat'];
+    day?: Snippet<[{
+        day: DateValue;
+        outsideMonth: boolean;
+    }]>;
+};
+declare const Calendar: import("svelte").Component<$$ComponentProps, {}, "ref" | "placeholder" | "value">;
+type Calendar = ReturnType<typeof Calendar>;
+export default Calendar;

package/dist/blocks/copy-button/copy-button.svelte.d.ts

@@ -0,0 +1,8 @@
+import { Button } from '../../components/button';
+import type { ComponentProps } from 'svelte';
+type $$ComponentProps = ComponentProps<typeof Button> & {
+    text: string;
+};
+declare const CopyButton: import("svelte").Component<$$ComponentProps, {}, "">;
+type CopyButton = ReturnType<typeof CopyButton>;
+export default CopyButton;

package/dist/blocks/copy-button/copy.svelte.d.ts

@@ -0,0 +1,15 @@
+/** Copy text to the clipboard with a temporary copied/failed feedback window. */
+export declare class UseClipboard {
+    #private;
+    /** Time in ms the copied/failed status holds before returning to idle. */
+    delay: number;
+    constructor(delay?: number);
+    /** `'idle'` until a copy settles, then `'copied'` or `'failed'` for {@link delay} ms. */
+    get status(): "idle" | "copied" | "failed";
+    /** Whether the copied feedback window is active. */
+    get copied(): boolean;
+    /** The last successfully copied text. */
+    get lastCopied(): string | undefined;
+    /** Copies the given text to the user's clipboard. Resolves `true` on success. */
+    copy(text: string | number): Promise<boolean>;
+}

package/dist/blocks/copy-button/copy.svelte.js

@@ -0,0 +1,46 @@
+/** Copy text to the clipboard with a temporary copied/failed feedback window. */
+export class UseClipboard {
+    #status = $state('idle');
+    #lastCopied = $state();
+    #timeout;
+    /** Each copy takes a ticket; a late resolution or stale reset timer checks it before touching state. */
+    #ticket = 0;
+    /** Time in ms the copied/failed status holds before returning to idle. */
+    delay;
+    constructor(delay = 2000) {
+        this.delay = delay;
+    }
+    /** `'idle'` until a copy settles, then `'copied'` or `'failed'` for {@link delay} ms. */
+    get status() {
+        return this.#status;
+    }
+    /** Whether the copied feedback window is active. */
+    get copied() {
+        return this.#status === 'copied';
+    }
+    /** The last successfully copied text. */
+    get lastCopied() {
+        return this.#lastCopied;
+    }
+    /** Copies the given text to the user's clipboard. Resolves `true` on success. */
+    async copy(text) {
+        const ticket = ++this.#ticket;
+        clearTimeout(this.#timeout);
+        this.#status = 'idle';
+        let ok = true;
+        try {
+            await navigator.clipboard.writeText(text.toString());
+        }
+        catch {
+            ok = false;
+        }
+        // A newer copy started while this one was in flight — it owns the feedback window.
+        if (ticket !== this.#ticket)
+            return ok;
+        if (ok)
+            this.#lastCopied = text.toString();
+        this.#status = ok ? 'copied' : 'failed';
+        this.#timeout = setTimeout(() => ticket === this.#ticket && (this.#status = 'idle'), this.delay);
+        return ok;
+    }
+}

package/dist/blocks/copy-button/index.js

@@ -0,0 +1,2 @@
+export { default as CopyButton } from './copy-button.svelte';
+export { UseClipboard } from './copy.svelte';

package/dist/blocks/date-picker/date-picker-with-presets.svelte.d.ts

@@ -0,0 +1,32 @@
+import type { ClassValue } from 'svelte/elements';
+import { type DateValue } from '@internationalized/date';
+type PresetItem = {
+    value: number;
+    label: string;
+};
+interface Props {
+    /** Selected date as an `@internationalized/date` `DateValue` — every date prop and callback speaks the same type. */
+    value?: DateValue;
+    placeholder?: string;
+    dateFormat?: Intl.DateTimeFormatOptions['dateStyle'];
+    locale?: string;
+    disabled?: boolean;
+    class?: ClassValue;
+    triggerClass?: ClassValue;
+    contentClass?: ClassValue;
+    align?: 'start' | 'center' | 'end';
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    presets?: PresetItem[];
+    presetsPlaceholder?: string;
+    captionLayout?: 'dropdown' | 'label';
+    minValue?: DateValue;
+    maxValue?: DateValue;
+    weekdayFormat?: 'short' | 'long' | 'narrow';
+    calendarLabel?: string;
+    fixedWeeks?: boolean;
+    isDateDisabled?: (date: DateValue) => boolean;
+    isDateUnavailable?: (date: DateValue) => boolean;
+}
+declare const DatePickerWithPresets: import("svelte").Component<Props, {}, "value">;
+type DatePickerWithPresets = ReturnType<typeof DatePickerWithPresets>;
+export default DatePickerWithPresets;

package/dist/blocks/date-picker/date-picker.svelte.d.ts

@@ -0,0 +1,29 @@
+import { type DateValue } from '@internationalized/date';
+import type { ClassValue } from 'svelte/elements';
+import type { Snippet } from 'svelte';
+interface Props {
+    /** Selected date as an `@internationalized/date` `DateValue` — every date prop and callback speaks the same type. */
+    value?: DateValue;
+    placeholder?: string;
+    dateFormat?: Intl.DateTimeFormatOptions['dateStyle'];
+    locale?: string;
+    disabled?: boolean;
+    class?: ClassValue;
+    triggerClass?: ClassValue;
+    contentClass?: ClassValue;
+    align?: 'start' | 'center' | 'end';
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    captionLayout?: 'dropdown' | 'label';
+    minValue?: DateValue;
+    maxValue?: DateValue;
+    weekdayFormat?: 'short' | 'long' | 'narrow';
+    calendarLabel?: string;
+    fixedWeeks?: boolean;
+    isDateDisabled?: (date: DateValue) => boolean;
+    isDateUnavailable?: (date: DateValue) => boolean;
+    /** Internal composition seam used by the presets adapter. */
+    contentHeader?: Snippet;
+}
+declare const DatePicker: import("svelte").Component<Props, {}, "value">;
+type DatePicker = ReturnType<typeof DatePicker>;
+export default DatePicker;

package/dist/blocks/date-picker/index.d.ts

@@ -0,0 +1,5 @@
+import DatePicker from './date-picker.svelte';
+import DatePickerWithPresets from './date-picker-with-presets.svelte';
+import RangeDatePicker from './range-date-picker.svelte';
+export { DatePicker, DatePickerWithPresets, RangeDatePicker, DatePicker as Root, DatePickerWithPresets as WithPresets, RangeDatePicker as Range, };
+export type { DateRange } from '../../internal/index.js';

package/dist/blocks/date-picker/index.js

@@ -0,0 +1,6 @@
+import DatePicker from './date-picker.svelte';
+import DatePickerWithPresets from './date-picker-with-presets.svelte';
+import RangeDatePicker from './range-date-picker.svelte';
+export { DatePicker, DatePickerWithPresets, RangeDatePicker, 
+//
+DatePicker as Root, DatePickerWithPresets as WithPresets, RangeDatePicker as Range, };

package/dist/blocks/date-picker/range-date-picker.svelte.d.ts

@@ -0,0 +1,23 @@
+import { type DateValue } from '@internationalized/date';
+import type { DateRange } from '../../internal/index.js';
+import type { ClassValue } from 'svelte/elements';
+interface Props {
+    /** Selected range as `@internationalized/date` `DateValue`s — every date prop and callback speaks the same type. */
+    value?: DateRange;
+    placeholder?: string;
+    dateFormat?: Intl.DateTimeFormatOptions['dateStyle'];
+    locale?: string;
+    disabled?: boolean;
+    class?: ClassValue;
+    triggerClass?: ClassValue;
+    contentClass?: ClassValue;
+    align?: 'start' | 'center' | 'end';
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    numberOfMonths?: number;
+    weekdayFormat?: 'short' | 'long' | 'narrow';
+    minValue?: DateValue;
+    maxValue?: DateValue;
+}
+declare const RangeDatePicker: import("svelte").Component<Props, {}, "value">;
+type RangeDatePicker = ReturnType<typeof RangeDatePicker>;
+export default RangeDatePicker;

package/dist/blocks/index.js

@@ -0,0 +1,12 @@
+export * from './copy-button';
+export * from './user-avatar';
+export { default as PhoneInput } from './PhoneInput.svelte';
+export { default as Calendar } from './calendar.svelte';
+export { default as Appearance } from './Appearance.svelte';
+export { default as BoundaryFailed } from './BoundaryFailed.svelte';
+export { default as ErrorPage } from './ErrorPage.svelte';
+export { default as Footer } from './Footer.svelte';
+export { default as Header } from './Header.svelte';
+export { default as Heading } from './Heading.svelte';
+export { default as MobileNav } from './MobileNav.svelte';
+export { default as Section } from './Section.svelte';

package/dist/blocks/mockups/Browser.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { Snippet } from 'svelte';
+type $$ComponentProps = {
+    title?: string;
+    children: Snippet;
+};
+declare const Browser: import("svelte").Component<$$ComponentProps, {}, "">;
+type Browser = ReturnType<typeof Browser>;
+export default Browser;

package/dist/blocks/mockups/Phone.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { Snippet } from 'svelte';
+type $$ComponentProps = {
+    children?: Snippet;
+    nav?: Snippet;
+};
+declare const Phone: import("svelte").Component<$$ComponentProps, {}, "">;
+type Phone = ReturnType<typeof Phone>;
+export default Phone;

package/dist/blocks/mockups/index.js

@@ -0,0 +1,2 @@
+export { default as Browser } from './Browser.svelte';
+export { default as Phone } from './Phone.svelte';

package/dist/blocks/tab-nav/index.js

@@ -0,0 +1 @@
+export { default as TabNav } from './tab-nav.svelte';

package/dist/blocks/tab-nav/tab-nav.svelte.d.ts

@@ -0,0 +1,14 @@
+import type { ClassValue } from 'svelte/elements';
+type Tab = {
+    id: string;
+    label: string;
+    href: string;
+};
+type $$ComponentProps = {
+    tabs: Tab[];
+    activeTab: string;
+    class?: ClassValue;
+};
+declare const TabNav: import("svelte").Component<$$ComponentProps, {}, "">;
+type TabNav = ReturnType<typeof TabNav>;
+export default TabNav;

package/dist/blocks/time-picker/index.d.ts

@@ -0,0 +1,5 @@
+import TimeInput from './time-input.svelte';
+import TimePicker from './time-picker.svelte';
+import TimeRangeInput from './time-range-input.svelte';
+import TimeRangePicker from './time-range-picker.svelte';
+export { TimePicker, TimeRangePicker, TimeInput, TimeRangeInput, TimePicker as Root, TimeRangePicker as Range, TimeInput as Input, TimeRangeInput as RangeInput, };

package/dist/blocks/time-picker/index.js

@@ -0,0 +1,7 @@
+import TimeInput from './time-input.svelte';
+import TimePicker from './time-picker.svelte';
+import TimeRangeInput from './time-range-input.svelte';
+import TimeRangePicker from './time-range-picker.svelte';
+export { TimePicker, TimeRangePicker, TimeInput, TimeRangeInput, 
+//
+TimePicker as Root, TimeRangePicker as Range, TimeInput as Input, TimeRangeInput as RangeInput, };

package/dist/blocks/time-picker/time-input.svelte.d.ts

@@ -0,0 +1,13 @@
+import type { ClassValue } from 'svelte/elements';
+interface Props {
+    value?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    class?: ClassValue;
+    triggerClass?: ClassValue;
+    interval?: 15 | 30 | 60;
+    use24Hour?: boolean;
+}
+declare const TimeInput: import("svelte").Component<Props, {}, "value">;
+type TimeInput = ReturnType<typeof TimeInput>;
+export default TimeInput;

package/dist/blocks/time-picker/time-picker.svelte.d.ts

@@ -0,0 +1,23 @@
+import type { ClassValue } from 'svelte/elements';
+import { type TimeSlot, type TimeSlotPreset } from './time-slots';
+interface Props {
+    value?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    class?: ClassValue;
+    triggerClass?: ClassValue;
+    align?: 'start' | 'center' | 'end';
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    preset?: TimeSlotPreset;
+    slots?: TimeSlot[];
+    interval?: number;
+    startHour?: number;
+    endHour?: number;
+    minTime?: string;
+    maxTime?: string;
+    isTimeDisabled?: (time: string) => boolean;
+    use24Hour?: boolean;
+}
+declare const TimePicker: import("svelte").Component<Props, {}, "value">;
+type TimePicker = ReturnType<typeof TimePicker>;
+export default TimePicker;

package/dist/blocks/time-picker/time-range-input.svelte.d.ts

@@ -0,0 +1,15 @@
+import type { ClassValue } from 'svelte/elements';
+interface Props {
+    value?: {
+        start: string;
+        end: string;
+    };
+    disabled?: boolean;
+    class?: ClassValue;
+    triggerClass?: ClassValue;
+    interval?: 15 | 30 | 60;
+    use24Hour?: boolean;
+}
+declare const TimeRangeInput: import("svelte").Component<Props, {}, "value">;
+type TimeRangeInput = ReturnType<typeof TimeRangeInput>;
+export default TimeRangeInput;

package/dist/blocks/time-picker/time-range-picker.svelte.d.ts

@@ -0,0 +1,27 @@
+import type { ClassValue } from 'svelte/elements';
+import { type TimeSlot, type SlotRange, type TimeSlotPreset } from './time-slots';
+interface Props {
+    value?: SlotRange;
+    placeholder?: string;
+    disabled?: boolean;
+    class?: ClassValue;
+    triggerClass?: ClassValue;
+    contentClass?: ClassValue;
+    align?: 'start' | 'center' | 'end';
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    preset?: TimeSlotPreset;
+    slots?: TimeSlot[];
+    interval?: number;
+    startHour?: number;
+    endHour?: number;
+    minTime?: string;
+    maxTime?: string;
+    minDuration?: number;
+    maxDuration?: number;
+    isTimeDisabled?: (time: string) => boolean;
+    showDuration?: boolean;
+    use24Hour?: boolean;
+}
+declare const TimeRangePicker: import("svelte").Component<Props, {}, "value">;
+type TimeRangePicker = ReturnType<typeof TimeRangePicker>;
+export default TimeRangePicker;