stimulus-library 0.9.8 → 0.9.10

package/dist/controllers/toggle_class_controller.d.ts

@@ -0,0 +1,35 @@
+import { BaseController } from "../utilities/base_controller";
+export type ToggleClassMode = "on" | "off" | "toggle";
+export declare class ToggleClassController extends BaseController {
+    static targets: string[];
+    static values: {
+        class: StringConstructor;
+        mouseEnter: StringConstructor;
+        mouseLeave: StringConstructor;
+        clickAway: BooleanConstructor;
+        initial: StringConstructor;
+    };
+    readonly toggleTargets: HTMLElement[];
+    readonly classValue: string;
+    readonly hasClassValue: boolean;
+    readonly mouseEnterValue: ToggleClassMode;
+    readonly hasMouseEnterValue: boolean;
+    readonly mouseLeaveValue: ToggleClassMode;
+    readonly hasMouseLeaveValue: boolean;
+    readonly clickAwayValue: boolean;
+    readonly hasClickAwayValue: boolean;
+    readonly initialValue: "on" | "off";
+    readonly hasInitialValue: boolean;
+    connect(): void;
+    clickOutside(): void;
+    mouseEnter(): {};
+    mouseLeave(): {};
+    on(event?: Event): void;
+    off(event?: Event): void;
+    toggle(event?: Event): void;
+    private _elementWasToggled;
+    private _elementToggleStatus;
+    private _elementToggle;
+    private _elementOn;
+    private _elementOff;
+}

package/dist/controllers/trix_modifier_controller.d.ts

@@ -0,0 +1,87 @@
+import { BaseController } from "../utilities/base_controller";
+import { TrixElementsPayload } from "../mixins/use_trix_modifiers";
+interface TrixInstallable {
+    install: (elements: TrixElementsPayload) => void;
+    uninstall: (elements: TrixElementsPayload) => void;
+    pasteEvent?: (event: TrixPasteEvent) => void;
+}
+interface TrixPasteEventPayload {
+    dataTransfer: DataTransfer;
+    html: string;
+    range: [number, number];
+    type: string;
+}
+interface TrixPasteEvent extends CustomEvent {
+    paste: TrixPasteEventPayload;
+}
+export declare class TrixModifierController extends BaseController {
+    get enabledBehaviours(): TrixInstallable[];
+    get bold(): {
+        install: (elements: TrixElementsPayload) => void;
+        pasteEvent(pasteEvent: TrixPasteEvent): void;
+        uninstall: (elements: TrixElementsPayload) => void;
+    };
+    get bulletList(): {
+        install: (elements: TrixElementsPayload) => void;
+        pasteEvent(pasteEvent: TrixPasteEvent): void;
+        uninstall: (elements: TrixElementsPayload) => void;
+    };
+    get code(): {
+        install: (elements: TrixElementsPayload) => void;
+        pasteEvent(pasteEvent: TrixPasteEvent): void;
+        uninstall: (elements: TrixElementsPayload) => void;
+    };
+    get heading(): {
+        install: (elements: TrixElementsPayload) => void;
+        pasteEvent(pasteEvent: TrixPasteEvent): void;
+        uninstall: (elements: TrixElementsPayload) => void;
+    };
+    get italic(): {
+        install: (elements: TrixElementsPayload) => void;
+        pasteEvent(pasteEvent: TrixPasteEvent): void;
+        uninstall: (elements: TrixElementsPayload) => void;
+    };
+    get strikethrough(): {
+        install: (elements: TrixElementsPayload) => void;
+        pasteEvent(pasteEvent: TrixPasteEvent): void;
+        uninstall: (elements: TrixElementsPayload) => void;
+    };
+    get link(): {
+        install: (elements: TrixElementsPayload) => void;
+        pasteEvent(pasteEvent: TrixPasteEvent): void;
+        uninstall: (elements: TrixElementsPayload) => void;
+    };
+    get indents(): {
+        install: ({ toolbar }: TrixElementsPayload) => void;
+        uninstall: ({ toolbar }: TrixElementsPayload) => void;
+    };
+    get numberList(): {
+        install: ({ toolbar }: TrixElementsPayload) => void;
+        uninstall: ({ toolbar }: TrixElementsPayload) => void;
+    };
+    get quote(): {
+        install: ({ toolbar }: TrixElementsPayload) => void;
+        uninstall: ({ toolbar }: TrixElementsPayload) => void;
+    };
+    get fileUploads(): {
+        install(elements: TrixElementsPayload): void;
+        pasteEvent(event: TrixPasteEvent): void;
+        uninstall(elements: TrixElementsPayload): void;
+    };
+    connect(): void;
+    install(elements: TrixElementsPayload): void;
+    pasteEvent(event: TrixPasteEvent): void;
+    uninstall(elements: TrixElementsPayload): void;
+    simpleHideShowHandlers(selector: string): {
+        install: ({ toolbar }: TrixElementsPayload) => void;
+        uninstall: ({ toolbar }: TrixElementsPayload) => void;
+    };
+    formattingHandlers(selector: string, trixAttribute: string): {
+        install: (elements: TrixElementsPayload) => void;
+        pasteEvent(pasteEvent: TrixPasteEvent): void;
+        uninstall: (elements: TrixElementsPayload) => void;
+    };
+    showToolbarSelector(toolbar: HTMLElement, selector: string): void;
+    hideToolbarSelector(toolbar: HTMLElement, selector: string): void;
+}
+export {};

package/dist/controllers/turbo/index.d.ts

@@ -0,0 +1,3 @@
+export * from './turbo_frame_history_controller';
+export * from './turbo_frame_refresh_controller';
+export * from './turbo_frame_rc_controller';

package/dist/controllers/turbo/turbo_frame_history_controller.d.ts

@@ -0,0 +1,7 @@
+import { BaseController } from "../../utilities";
+export default class TurboFrameHistoryController extends BaseController {
+    initialize(): void;
+    navigator: any;
+    connect(): void;
+    mutate(entries: MutationRecord[]): void;
+}

package/dist/controllers/turbo/turbo_frame_rc_controller.d.ts

@@ -0,0 +1,20 @@
+import { BaseController } from "../../utilities/base_controller";
+export declare class TurboFrameRCController extends BaseController {
+    static values: {
+        frameId: StringConstructor;
+        src: StringConstructor;
+        loadingMessage: StringConstructor;
+    };
+    readonly frameIdValue: string;
+    readonly srcValue: string;
+    readonly hasSrcValue: boolean;
+    readonly loadingMessageValue: string;
+    readonly hasLoadingMessageValue: boolean;
+    toggle(event?: Event): void;
+    setSrc(event?: Event): void;
+    clear(event?: Event): void;
+    private _setSrc;
+    private _clear;
+    private _getFrame;
+    private _getSrc;
+}

package/dist/controllers/turbo/turbo_frame_refresh_controller.d.ts

@@ -0,0 +1,13 @@
+import { BaseController } from "../../utilities/base_controller";
+export declare class TurboFrameRefreshController extends BaseController {
+    static values: {
+        interval: NumberConstructor;
+        poll: BooleanConstructor;
+    };
+    readonly intervalValue: number;
+    readonly pollValue: boolean;
+    readonly hasPollValue: boolean;
+    get _poll(): boolean;
+    connect(): void;
+    refresh(event?: Event): void;
+}

package/dist/controllers/utility/alert_controller.d.ts

@@ -0,0 +1,8 @@
+import { BaseController } from "../../utilities/base_controller";
+export declare class AlertController extends BaseController {
+    static values: {
+        message: StringConstructor;
+    };
+    messageValue: string;
+    alert(): void;
+}

package/dist/controllers/utility/fullscreen_controller.d.ts

@@ -0,0 +1,7 @@
+import { BaseController } from "../../utilities/base_controller";
+export declare class FullscreenController extends BaseController {
+    enter: () => void;
+    exit: () => void;
+    toggle: () => void;
+    connect(): void;
+}

package/dist/controllers/utility/index.d.ts

@@ -0,0 +1,8 @@
+export * from './alert_controller';
+export * from './fullscreen_controller';
+export * from './intersection_controller';
+export * from './interval_controller';
+export * from './presence_controller';
+export * from './print_controller';
+export * from './timeout_controller';
+export * from './user_focus_controller';

package/dist/controllers/utility/intersection_controller.d.ts

@@ -0,0 +1,13 @@
+import { BaseController } from "../../utilities/base_controller";
+export declare class IntersectionController extends BaseController {
+    static values: {
+        threshold: StringConstructor;
+    };
+    readonly isVisible: boolean;
+    readonly thresholdValue: string;
+    readonly hasThresholdValue: boolean;
+    get _threshold(): number[];
+    connect(): void;
+    appear(entry: IntersectionObserverEntry): void;
+    disappear(entry: IntersectionObserverEntry): void;
+}

package/dist/controllers/utility/interval_controller.d.ts

@@ -0,0 +1,10 @@
+import { BaseController } from "../../utilities/base_controller";
+export declare class IntervalController extends BaseController {
+    static values: {
+        seconds: NumberConstructor;
+    };
+    readonly secondsValue: number;
+    readonly hasSecondsValue: boolean;
+    connect(): void;
+    _interval(): void;
+}

package/dist/controllers/utility/presence_controller.d.ts

@@ -0,0 +1,13 @@
+import { BaseController } from "../../utilities/base_controller";
+export declare class PresenceController extends BaseController {
+    static values: {
+        name: StringConstructor;
+    };
+    nameValue: string;
+    readonly hasNameValue: boolean;
+    get name(): string;
+    get _addedEventName(): string;
+    get _removedEventName(): string;
+    connect(): void;
+    disconnect(): void;
+}

package/dist/controllers/utility/print_controller.d.ts

@@ -0,0 +1,4 @@
+import { BaseController } from '../../utilities/base_controller';
+export declare class PrintController extends BaseController {
+    print(event?: Event): void;
+}

package/dist/controllers/utility/timeout_controller.d.ts

@@ -0,0 +1,9 @@
+import { BaseController } from "../../utilities/base_controller";
+export declare class TimeoutController extends BaseController {
+    static values: {
+        seconds: NumberConstructor;
+    };
+    readonly secondsValue: number;
+    connect(): void;
+    _timeout(): void;
+}

package/dist/controllers/utility/user_focus_controller.d.ts

@@ -0,0 +1,8 @@
+import { BaseController } from "../../utilities/base_controller";
+export declare class UserFocusController extends BaseController {
+    connect(): void;
+    appear(): void;
+    away(): void;
+    private _handleVisibility;
+    private _documentIsActive;
+}

package/dist/controllers/visual/clock_controller.d.ts

@@ -0,0 +1,15 @@
+import { BaseController } from "../../utilities/base_controller";
+export declare class ClockController extends BaseController {
+    static targets: string[];
+    readonly hasHoursTarget: boolean;
+    readonly hoursTarget: HTMLElement;
+    readonly hasMinutesTarget: boolean;
+    readonly minutesTarget: HTMLElement;
+    readonly hasSecondsTarget: boolean;
+    readonly secondsTarget: HTMLElement;
+    readonly hasMillisecondsTarget: boolean;
+    readonly millisecondsTarget: HTMLElement;
+    get _tickInterval(): 1 | 1000 | 15000 | 300000;
+    connect(): void;
+    _tick(): void;
+}

package/dist/controllers/visual/countdown_controller.d.ts

@@ -0,0 +1,46 @@
+import { type Duration } from "date-fns";
+import { BaseController } from "../../utilities/base_controller";
+export declare class CountdownController extends BaseController {
+    static values: {
+        deadline: StringConstructor;
+        removeUnused: BooleanConstructor;
+    };
+    static targets: string[];
+    static classes: string[];
+    readonly deadlineValue: string;
+    readonly removeUnusedValue: boolean;
+    readonly hasRemoveUnusedValue: boolean;
+    readonly hasYearsTarget: boolean;
+    readonly yearsTarget: HTMLElement;
+    readonly hasMonthsTarget: boolean;
+    readonly monthsTarget: HTMLElement;
+    readonly hasDaysTarget: boolean;
+    readonly daysTarget: HTMLElement;
+    readonly hasHoursTarget: boolean;
+    readonly hoursTarget: HTMLElement;
+    readonly hasMinutesTarget: boolean;
+    readonly minutesTarget: HTMLElement;
+    readonly hasSecondsTarget: boolean;
+    readonly secondsTarget: HTMLElement;
+    addEndedClasses: (el?: HTMLElement) => void;
+    removeEndedClasses: (el?: HTMLElement) => void;
+    addCountingDownClasses: (el?: HTMLElement) => void;
+    removeCountingDownClasses: (el?: HTMLElement) => void;
+    _timeout: null | ReturnType<typeof window.setTimeout>;
+    get _removeUnused(): boolean;
+    get _deadlineDate(): Date;
+    initialize(): void;
+    connect(): void;
+    disconnect(): void;
+    deadlineValueChanged(): void;
+    _tick(): void;
+    _clearTick(): void;
+    _updateTarget(target: HTMLElement, value: number): void;
+    _removeTargetIfUnused(target: HTMLElement, value: number): void;
+    _years(duration: Duration): number;
+    _months(duration: Duration): number;
+    _days(duration: Duration): number;
+    _hours(duration: Duration): number;
+    _minutes(duration: Duration): number;
+    _seconds(duration: Duration): number;
+}

package/dist/controllers/visual/duration_controller.d.ts

@@ -0,0 +1,25 @@
+import { type Duration } from "date-fns";
+import { BaseController } from "../../utilities/base_controller";
+export declare class DurationController extends BaseController {
+    static values: {
+        timestamp: NumberConstructor;
+        minutes: BooleanConstructor;
+        seconds: BooleanConstructor;
+    };
+    readonly minutesValue: boolean;
+    readonly hasMinutesValue: boolean;
+    readonly secondsValue: boolean;
+    readonly hasSecondsValue: boolean;
+    timestampValue: number;
+    readonly hasTimestampValue: boolean;
+    _clearInterval: () => void;
+    get _format(): string[];
+    get _output(): string;
+    get _seconds(): boolean;
+    get _minutes(): boolean;
+    get _timestamp(): Date;
+    get _duration(): Duration;
+    get _tickInterval(): 1000 | 15000 | 120000;
+    connect(): void;
+    _update(): void;
+}

package/dist/controllers/visual/index.d.ts

@@ -0,0 +1,7 @@
+export * from './clock_controller';
+export * from './countdown_controller';
+export * from './duration_controller';
+export * from './tabs_controller';
+export * from './time_distance_controller';
+export * from './tree_view_controller';
+export * from './tween_number_controller';

package/dist/controllers/visual/tabs_controller.d.ts

@@ -0,0 +1,29 @@
+import { BaseController } from "../../utilities/base_controller";
+export declare class TabsController extends BaseController {
+    static values: {
+        currentTab: NumberConstructor;
+        equalize: BooleanConstructor;
+    };
+    static targets: string[];
+    static classes: string[];
+    currentTabValue: number;
+    hasCurrentTabValue: boolean;
+    equalizeValue: boolean;
+    hasEqualizeValue: boolean;
+    readonly linkTargets: HTMLElement[];
+    readonly contentTargets: HTMLElement[];
+    addHideClasses: (el?: HTMLElement) => void;
+    removeHideClasses: (el?: HTMLElement) => void;
+    addActiveClasses: (el?: HTMLElement) => void;
+    removeActiveClasses: (el?: HTMLElement) => void;
+    get defaultHideClasses(): string[];
+    get defaultActiveClasses(): string[];
+    get _currentTab(): number;
+    get _equalize(): boolean;
+    connect(): void;
+    switchTabs(event: Event): void;
+    currentTabValueChanged(): void;
+    _selectTab(index: number): void;
+    _clampIndex(index: number): number;
+    _setMinHeight(): void;
+}

package/dist/controllers/visual/time_distance_controller.d.ts

@@ -0,0 +1,15 @@
+import { type Duration } from "date-fns";
+import { BaseController } from "../../utilities/base_controller";
+export declare class TimeDistanceController extends BaseController {
+    static values: {
+        timestamp: NumberConstructor;
+    };
+    timestampValue: number;
+    readonly hasTimestampValue: boolean;
+    _timestamp: Date;
+    get _duration(): Duration;
+    get _nextUpdate(): number | null;
+    timestampValueChanged(): void;
+    connect(): void;
+    _update(): void;
+}

package/dist/controllers/visual/tree_view_controller.d.ts

@@ -0,0 +1,25 @@
+import { BaseController } from "../../utilities/base_controller";
+export declare class TreeViewController extends BaseController {
+    static classes: string[];
+    activeClasses: string[];
+    activeClassesPresent: (el?: HTMLElement) => boolean;
+    addActiveClasses: (el?: HTMLElement) => void;
+    removeActiveClasses: (el?: HTMLElement) => void;
+    addCollapsedClasses: (el?: HTMLElement) => void;
+    removeCollapsedClasses: (el?: HTMLElement) => void;
+    get defaultActiveClasses(): string[];
+    get defaultCollapsedClasses(): string[];
+    initialize(): void;
+    connect(): void;
+    disconnect(): void;
+    _setup(): void;
+    _setupNode(el: HTMLElement): void;
+    _teardown(): void;
+    _teardownNode(el: HTMLElement): void;
+    _nodeClicked(event: MouseEvent): void;
+    _nodeActive(el: HTMLElement): boolean;
+    _showNode(el: HTMLElement): void;
+    _hideNode(el: HTMLElement): void;
+    _hasNested(el: HTMLElement): boolean;
+    mutate(entries: MutationRecord[]): void;
+}

package/dist/controllers/visual/tween_number_controller.d.ts

@@ -0,0 +1,29 @@
+import { BaseController } from "../../utilities/base_controller";
+import { EasingFunction, EasingFunctions } from "../../utilities/easingFunctions";
+export declare class TweenNumberController extends BaseController {
+    static values: {
+        start: NumberConstructor;
+        end: NumberConstructor;
+        duration: NumberConstructor;
+        easing: StringConstructor;
+    };
+    startValue: number;
+    readonly hasStartValue: boolean;
+    endValue: number;
+    readonly hasEndValue: boolean;
+    durationValue: number;
+    readonly hasDurationValue: boolean;
+    easingValue: keyof typeof EasingFunctions;
+    readonly hasEasingValue: boolean;
+    private observer?;
+    private observe?;
+    private unobserve?;
+    private teardownObserver?;
+    get start(): number;
+    get end(): number;
+    get durationMs(): number;
+    get easingFunction(): EasingFunction;
+    connect(): void;
+    appear(_entry: IntersectionObserverEntry): void;
+    tween(): void;
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./utilities";
+export * from "./mixins";
+export * from "./controllers";

package/dist/mixins/create_mixin.d.ts

@@ -0,0 +1,2 @@
+import { Controller } from "@hotwired/stimulus";
+export declare function useMixin(controller: Controller, setup: () => void, teardown: () => void): () => void;

package/dist/mixins/index.d.ts

@@ -0,0 +1,11 @@
+export * from './use_event_listener';
+export * from './use_fullscreen';
+export * from './use_geolocation';
+export * from './use_injected_html';
+export * from './use_intersection';
+export * from './use_interval';
+export * from './use_localstorage';
+export * from './use_mutation_observer';
+export * from './use_resize_observer';
+export * from './use_temporary_content';
+export * from './use_timeout';

package/dist/mixins/install_class_methods.d.ts

@@ -0,0 +1,5 @@
+import { Controller } from "@hotwired/stimulus";
+export declare class InstallClassMethodComposableController extends Controller {
+    [index: string]: any;
+}
+export declare function installClassMethods(controller: InstallClassMethodComposableController): void;

package/dist/mixins/use_click_outside.d.ts

@@ -0,0 +1,4 @@
+import { Controller } from "@hotwired/stimulus";
+export declare function useClickOutside(controller: Controller, element: HTMLElement, callback: (event: Event) => void): {
+    teardown: () => void;
+};

package/dist/mixins/use_event_bus.d.ts

@@ -0,0 +1,7 @@
+import { Controller } from "@hotwired/stimulus";
+export declare function useEventBus(controller: Controller, eventNameOrNames: string | string[], handler: (...args: any[]) => void, opts?: {
+    debounce?: number;
+}): {
+    setup: () => void;
+    teardown: () => void;
+};

package/dist/mixins/use_event_listener.d.ts

@@ -0,0 +1,19 @@
+import { Controller } from "@hotwired/stimulus";
+export declare function useEventListener(controller: Controller, element: Document | Window | HTMLElement, eventNameOrNames: string | string[], handler: (...args: any[]) => void, opts?: AddEventListenerOptions & {
+    debounce?: number;
+}): {
+    setup: () => void;
+    teardown: () => void;
+};
+export declare function useEventListeners(controller: Controller, element: Document | Window | HTMLElement, eventNameOrNames: string | string[], handler: (...args: any[]) => void, opts?: AddEventListenerOptions & {
+    debounce?: number;
+}): {
+    setup: () => void;
+    teardown: () => void;
+};
+export declare function useCollectionEventListener(controller: Controller, elements: Array<Document | Window | HTMLElement>, eventNameOrNames: string | string[], handler: (...args: any[]) => void, opts?: AddEventListenerOptions & {
+    debounce?: number;
+}): (() => void)[];
+export declare function useCollectionEventListeners(controller: Controller, elements: Array<Document | Window | HTMLElement>, eventNameOrNames: string | string[], handler: (...args: any[]) => void, opts?: AddEventListenerOptions & {
+    debounce?: number;
+}): (() => void)[];

package/dist/mixins/use_fullscreen.d.ts

@@ -0,0 +1,8 @@
+import { Controller } from "@hotwired/stimulus";
+export declare function useFullscreen(controller: Controller, el?: Element): {
+    isFullscreen: () => boolean;
+    enter: () => Promise<void>;
+    exit: () => Promise<void>;
+    toggle: () => Promise<void>;
+    teardown: () => void;
+};

package/dist/mixins/use_geolocation.d.ts

@@ -0,0 +1,18 @@
+import { Controller } from "@hotwired/stimulus";
+export interface GeolocationOptions extends Partial<PositionOptions> {
+}
+export interface GeolocationData {
+    locatedAt: number | null;
+    error: GeolocationPositionError | null;
+    coords: {
+        accuracy: number;
+        latitude: number;
+        longitude: number;
+        altitude: number | null;
+        altitudeAccuracy: number | null;
+        heading: number | null;
+        speed: number | null;
+    };
+    teardown: () => void;
+}
+export declare function useGeolocation(controller: Controller, options?: GeolocationOptions, update?: (...args: any[]) => void, error?: (...args: any[]) => void): GeolocationData;

package/dist/mixins/use_hover.d.ts

@@ -0,0 +1,4 @@
+import { Controller } from "@hotwired/stimulus";
+export declare function useHover(controller: Controller, element: HTMLElement, enter?: ((event: Event) => void) | null, leave?: ((event: Event) => void) | null): {
+    teardown: () => void;
+};

package/dist/mixins/use_injected_html.d.ts

@@ -0,0 +1,10 @@
+import { Controller } from "@hotwired/stimulus";
+export declare function useInjectedFragment(controller: Controller, targetElement: HTMLElement, insertPosition: InsertPosition, fragment: DocumentFragment, options?: {
+    cleanup?: boolean;
+}): [ChildNode[], () => void];
+export declare function useInjectedHTML(controller: Controller, targetElement: HTMLElement, insertPosition: InsertPosition, html: string, options?: {
+    cleanup?: boolean;
+}): [ChildNode[], () => void];
+export declare function useInjectedElement(controller: Controller, targetElement: HTMLElement, insertPosition: InsertPosition, element: HTMLElement, options?: {
+    cleanup?: boolean;
+}): [ChildNode, () => void];

package/dist/mixins/use_intersection.d.ts

@@ -0,0 +1,13 @@
+import { Controller } from "@hotwired/stimulus";
+export declare function useIntersectionObserver(controller: Controller, handler: IntersectionObserverCallback, options?: IntersectionObserverInit): {
+    observer: IntersectionObserver;
+    teardown: () => void;
+    observe: (element: HTMLElement) => void | undefined;
+    unobserve: (element: HTMLElement) => void | undefined;
+};
+export declare function useIntersection(controller: Controller, element: HTMLElement, appear?: null | ((entry: IntersectionObserverEntry) => void), disappear?: null | ((entry: IntersectionObserverEntry) => void), options?: IntersectionObserverInit): {
+    observer: IntersectionObserver;
+    observe: () => void | undefined;
+    unobserve: () => void | undefined;
+    teardown: () => void;
+};

package/dist/mixins/use_interval.d.ts

@@ -0,0 +1,2 @@
+import { Controller } from "@hotwired/stimulus";
+export declare function useInterval(controller: Controller, handler: (...args: any[]) => void, interval: number): () => void;

package/dist/mixins/use_localstorage.d.ts

@@ -0,0 +1,20 @@
+import { Controller } from "@hotwired/stimulus";
+export type Serializer<T> = {
+    deserialize(raw: string): T;
+    serialize(value: T): string;
+    isEmpty(value: T): boolean;
+};
+export interface LocalStorageProxy<T> {
+    get value(): T;
+    set value(value: T);
+    read(): T;
+    write(value: T): void;
+    clear(): void;
+    isEmpty(): boolean;
+}
+export declare const StorageSerializers: Record<'boolean' | 'object' | 'number' | 'any' | 'string' | 'map' | 'set', Serializer<any>> & {
+    [idx: string]: Serializer<any>;
+};
+export declare function useLocalStorage<T>(controller: Controller, key: string, defaultValue: T, opts?: {
+    writeDefaults: boolean;
+}): LocalStorageProxy<T>;

package/dist/mixins/use_mutation_observer.d.ts

@@ -0,0 +1,2 @@
+import { Controller } from "@hotwired/stimulus";
+export declare function useMutationObserver(controller: Controller, element: HTMLElement, handler: (entries: MutationRecord[]) => void, options: MutationObserverInit): () => void;

package/dist/mixins/use_resize_observer.d.ts

@@ -0,0 +1,2 @@
+import { Controller } from "@hotwired/stimulus";
+export declare function useResizeObserver(controller: Controller, element: HTMLElement, handler: (entries: ResizeObserverEntry[]) => void, options: ResizeObserverOptions): () => void;

package/dist/mixins/use_temporary_content.d.ts

@@ -0,0 +1,5 @@
+import { Controller } from "@hotwired/stimulus";
+export declare function useTemporaryContent(controller: Controller, target: HTMLElement, content: string, timeout?: number, teardownCallback?: () => void): {
+    teardown: () => void;
+    update(newContent: string): void;
+};

package/dist/mixins/use_timeout.d.ts

@@ -0,0 +1,2 @@
+import { Controller } from "@hotwired/stimulus";
+export declare function useTimeout(controller: Controller, handler: (...args: any[]) => void, timeout: number): () => void;