@allxsmith/bestax-bulma 2.6.1 → 3.0.1

package/dist/types/form/TimeInput.d.ts

@@ -0,0 +1,26 @@
+import React from 'react';
+import { FieldProps } from './Field';
+import { ControlBaseProps } from './Control';
+import { TimeInputBaseProps } from './TimeInputBase';
+export interface TimeInputProps extends TimeInputBaseProps {
+    label?: React.ReactNode;
+    labelSize?: FieldProps['labelSize'];
+    labelProps?: FieldProps['labelProps'];
+    horizontal?: boolean;
+    iconLeft?: ControlBaseProps['iconLeft'];
+    iconRight?: ControlBaseProps['iconRight'];
+    iconRightName?: string;
+    iconLeftSize?: ControlBaseProps['iconLeftSize'];
+    iconRightSize?: ControlBaseProps['iconRightSize'];
+    hasIconsLeft?: boolean;
+    hasIconsRight?: boolean;
+    isLoading?: boolean;
+    isExpanded?: boolean;
+    controlSize?: ControlBaseProps['size'];
+    message?: React.ReactNode;
+    messageColor?: 'primary' | 'link' | 'info' | 'success' | 'warning' | 'danger';
+    fieldClassName?: string;
+    controlClassName?: string;
+}
+export declare const TimeInput: React.ForwardRefExoticComponent<TimeInputProps & React.RefAttributes<HTMLInputElement>>;
+export default TimeInput;

package/dist/types/form/TimeInputBase.d.ts

@@ -0,0 +1,44 @@
+import React from 'react';
+import { BulmaClassesProps } from '../helpers/useBulmaClasses';
+import { PickerPosition, HourFormat, PickerLabels } from './_pickerInternals/pickerTypes';
+import { DateFormatOption } from './_pickerInternals/formatters';
+export interface TimeInputBaseProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'value' | 'defaultValue' | 'onChange' | 'size' | 'color' | 'min' | 'max' | 'type' | 'popover'>, Omit<BulmaClassesProps, 'color'> {
+    value?: Date | null;
+    defaultValue?: Date | null;
+    onChange?: (d: Date | null) => void;
+    onOpen?: () => void;
+    onClose?: () => void;
+    min?: Date;
+    max?: Date;
+    disabled?: boolean;
+    readOnly?: boolean;
+    placeholder?: string;
+    format?: DateFormatOption;
+    parse?: (s: string) => Date | null;
+    locale?: string;
+    inline?: boolean;
+    mobileNative?: boolean | 'auto';
+    editable?: boolean;
+    popover?: boolean;
+    openOnFocus?: boolean;
+    closeOnSelect?: boolean;
+    position?: PickerPosition;
+    appendToBody?: boolean;
+    color?: 'primary' | 'link' | 'info' | 'success' | 'warning' | 'danger';
+    size?: 'small' | 'medium' | 'large';
+    isRounded?: boolean;
+    hourFormat?: HourFormat;
+    enableSeconds?: boolean;
+    incrementHours?: number;
+    incrementMinutes?: number;
+    incrementSeconds?: number;
+    unselectableTimes?: (d: Date) => boolean;
+    iconLeftName?: string;
+    triggerIcon?: boolean;
+    triggerIconName?: string;
+    labels?: PickerLabels;
+    audioTick?: boolean;
+    haptics?: boolean;
+}
+export declare const TimeInputBase: React.ForwardRefExoticComponent<TimeInputBaseProps & React.RefAttributes<HTMLInputElement>>;
+export default TimeInputBase;

package/dist/types/form/_pickerInternals/Calendar.d.ts

@@ -0,0 +1,26 @@
+import React from 'react';
+import { DayOfWeek, PickerLabels } from './pickerTypes';
+export interface CalendarProps {
+    value: Date | null;
+    focusedDate: Date;
+    onSelect: (d: Date) => void;
+    onFocusedDateChange: (d: Date) => void;
+    min?: Date;
+    max?: Date;
+    shouldDisableDate?: (d: Date) => boolean;
+    unselectableDates?: Date[];
+    firstDayOfWeek?: DayOfWeek;
+    locale?: string;
+    dayNames?: string[];
+    monthNames?: string[];
+    nearbyMonthDays?: boolean;
+    color?: 'primary' | 'link' | 'info' | 'success' | 'warning' | 'danger';
+    size?: 'small' | 'medium' | 'large';
+    className?: string;
+    id?: string;
+    autoFocusCell?: boolean;
+    labels?: PickerLabels;
+    yearsRange?: [number, number];
+}
+export declare const Calendar: React.FC<CalendarProps>;
+export default Calendar;

package/dist/types/form/_pickerInternals/PickerPopover.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import { PickerPosition } from './pickerTypes';
+export interface PickerPopoverProps {
+    isOpen: boolean;
+    onClose: () => void;
+    anchorRef: React.RefObject<HTMLElement | null>;
+    children: React.ReactNode;
+    position?: PickerPosition;
+    appendToBody?: boolean;
+    className?: string;
+    trapFocus?: boolean;
+    closeOnClickOutside?: boolean;
+    closeOnEscape?: boolean;
+    ariaLabel?: string;
+    ariaLabelledBy?: string;
+    role?: 'dialog' | 'group';
+    id?: string;
+}
+export declare const PickerPopover: React.FC<PickerPopoverProps>;
+export default PickerPopover;

package/dist/types/form/_pickerInternals/TimeWheels.d.ts

@@ -0,0 +1,29 @@
+import React from 'react';
+import { HourFormat, PickerLabels } from './pickerTypes';
+export interface TimeWheelsValue {
+    hours: number;
+    minutes: number;
+    seconds?: number;
+}
+export interface TimeWheelsProps {
+    value: TimeWheelsValue;
+    onChange: (v: TimeWheelsValue) => void;
+    hourFormat?: HourFormat;
+    enableSeconds?: boolean;
+    incrementHours?: number;
+    incrementMinutes?: number;
+    incrementSeconds?: number;
+    unselectableTimes?: (d: Date) => boolean;
+    size?: 'small' | 'medium' | 'large';
+    color?: 'primary' | 'link' | 'info' | 'success' | 'warning' | 'danger';
+    disabled?: boolean;
+    className?: string;
+    id?: string;
+    labels?: PickerLabels;
+    visibleCount?: number;
+    itemHeight?: number;
+    audioTick?: boolean;
+    onCommit?: () => void;
+}
+export declare const TimeWheels: React.FC<TimeWheelsProps>;
+export default TimeWheels;

package/dist/types/form/_pickerInternals/audioTick.d.ts

@@ -0,0 +1,3 @@
+export declare const unlockAudioTick: () => void;
+export declare const playAudioTick: () => void;
+export declare const __resetAudioTickForTest: () => void;

package/dist/types/form/_pickerInternals/dateUtils.d.ts

@@ -0,0 +1,39 @@
+import { DayOfWeek } from './pickerTypes';
+export interface CalendarCell {
+    date: Date;
+    inCurrentMonth: boolean;
+    isToday: boolean;
+}
+export declare function isSameDay(a: Date, b: Date): boolean;
+export declare function isSameMonth(a: Date, b: Date): boolean;
+export declare function isBefore(a: Date, b: Date): boolean;
+export declare function isAfter(a: Date, b: Date): boolean;
+export declare function isWithin(d: Date, min?: Date, max?: Date): boolean;
+export declare function startOfDay(d: Date): Date;
+export declare function endOfDay(d: Date): Date;
+export declare function startOfMonth(d: Date): Date;
+export declare function endOfMonth(d: Date): Date;
+export declare function addDays(d: Date, n: number): Date;
+export declare function addMonths(d: Date, n: number): Date;
+export declare function addYears(d: Date, n: number): Date;
+export declare function addHours(d: Date, n: number): Date;
+export declare function addMinutes(d: Date, n: number): Date;
+export declare function addSeconds(d: Date, n: number): Date;
+export declare function setTimeOfDay(d: Date, parts: {
+    hours?: number;
+    minutes?: number;
+    seconds?: number;
+}): Date;
+export declare function getTimeOfDay(d: Date): {
+    hours: number;
+    minutes: number;
+    seconds: number;
+};
+export declare function clampDate(d: Date, min?: Date, max?: Date): Date;
+export declare function snapTimeToIncrement(d: Date, opts?: {
+    incrementHours?: number;
+    incrementMinutes?: number;
+    incrementSeconds?: number;
+    enableSeconds?: boolean;
+}): Date;
+export declare function buildMonthGrid(monthAnchor: Date, firstDayOfWeek?: DayOfWeek): CalendarCell[];

package/dist/types/form/_pickerInternals/formatters.d.ts

@@ -0,0 +1,13 @@
+export type DateFormatOption = Intl.DateTimeFormatOptions | string;
+export declare const DEFAULT_DATE_FORMAT = "YYYY-MM-DD";
+export declare const DEFAULT_TIME_FORMAT_24 = "HH:mm";
+export declare const DEFAULT_TIME_FORMAT_12 = "hh:mm A";
+export declare const DEFAULT_DATETIME_FORMAT = "YYYY-MM-DD HH:mm";
+export declare function formatDate(d: Date, fmt: DateFormatOption | undefined, locale?: string): string;
+export declare function formatTime(d: Date, fmt: DateFormatOption | undefined, locale?: string): string;
+export declare function formatDateTime(d: Date, fmt: DateFormatOption | undefined, locale?: string): string;
+export declare function hourCycleFromFormat(fmt: DateFormatOption | undefined): '12' | '24' | null;
+export declare function parseDate(s: string, fmt?: string, _locale?: string): Date | null;
+export declare function parseTime(s: string, fmt?: string): Date | null;
+export declare function getDayNames(locale: string | undefined, length?: 'narrow' | 'short' | 'long'): string[];
+export declare function getMonthNames(locale: string | undefined, length?: 'short' | 'long'): string[];

package/dist/types/form/_pickerInternals/haptics.d.ts

@@ -0,0 +1 @@
+export declare const tickHaptic: () => void;

package/dist/types/form/_pickerInternals/pickerTypes.d.ts

@@ -0,0 +1,31 @@
+export type PickerPosition = 'bottom-left' | 'bottom-right' | 'top-left' | 'top-right' | 'auto';
+export type HourFormat = '12' | '24';
+export type DayOfWeek = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+export interface PickerLabels {
+    prevMonth?: string;
+    nextMonth?: string;
+    chooseDate?: string;
+    hours?: string;
+    minutes?: string;
+    seconds?: string;
+    ampm?: string;
+    increaseHours?: string;
+    decreaseHours?: string;
+    increaseMinutes?: string;
+    decreaseMinutes?: string;
+    increaseSeconds?: string;
+    decreaseSeconds?: string;
+    toggleAmPm?: string;
+    chooseTime?: string;
+    chooseDateTime?: string;
+    now?: string;
+    today?: string;
+    clear?: string;
+    cancel?: string;
+    ok?: string;
+    reset?: string;
+    done?: string;
+    time?: string;
+}
+export declare const DEFAULT_PICKER_LABELS: Required<PickerLabels>;
+export declare const mergeLabels: (overrides?: PickerLabels) => Required<PickerLabels>;

package/dist/types/form/_pickerInternals/segmentMap.d.ts

@@ -0,0 +1,20 @@
+export type SegmentKind = 'year' | 'month' | 'day' | 'hours' | 'minutes' | 'seconds' | 'ampm' | 'literal';
+export interface Segment {
+    kind: SegmentKind;
+    token: string;
+    start: number;
+    end: number;
+    hourFormat?: '12' | '24';
+}
+export interface SegmentMap {
+    segments: Segment[];
+    editable: number[];
+}
+export declare function buildSegmentMap(format: string): SegmentMap | null;
+export declare function incrementSegmentValue(segment: Segment, currentDate: Date, delta: number, isPm: boolean): Date;
+export declare function setSegmentValue(segment: Segment, currentDate: Date, rawDigits: string, isPm: boolean): {
+    date: Date;
+    advance: boolean;
+};
+export declare function setAmPm(currentDate: Date, isPm: boolean): Date;
+export declare function segmentIndexAtCaret(map: SegmentMap, caret: number): number | null;

package/dist/types/form/_pickerInternals/useFocusTrap.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+interface UseFocusTrapOptions {
+    initialFocusRef?: React.RefObject<HTMLElement>;
+    restoreFocus?: boolean;
+}
+export declare function useFocusTrap(containerRef: React.RefObject<HTMLElement>, active: boolean, options?: UseFocusTrapOptions): void;
+export {};

package/dist/types/form/_pickerInternals/useNativeMobilePicker.d.ts

@@ -0,0 +1,10 @@
+export interface NativeMobileDetect {
+    isCoarsePointer: boolean;
+    isSmallViewport: boolean;
+    shouldUseNative: boolean;
+}
+export interface UseNativeMobilePickerOptions {
+    smallViewportMaxPx?: number;
+    force?: boolean;
+}
+export declare function useNativeMobilePicker(options?: UseNativeMobilePickerOptions): NativeMobileDetect;

package/dist/types/form/_pickerInternals/useSegmentedEntry.d.ts

@@ -0,0 +1,45 @@
+import React from 'react';
+import { DateFormatOption } from './formatters';
+import { SegmentMap } from './segmentMap';
+export interface UseSegmentedEntryParams {
+    format: DateFormatOption;
+    value: Date | null;
+    commitValue: (next: Date | null) => void;
+    formatFn: (d: Date, fmt: DateFormatOption | undefined, locale?: string) => string;
+    tryParse: (s: string) => Date | null;
+    text: string;
+    setText: (s: string) => void;
+    makeBaseDate: () => Date;
+    locale?: string;
+    min?: Date;
+    max?: Date;
+    isBlocked?: (d: Date) => boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    editable?: boolean;
+    popover?: boolean;
+    openOnFocus?: boolean;
+    closeOnSelect?: boolean;
+    isOpen: boolean;
+    setOpen: (next: boolean) => void;
+    inputRef: React.RefObject<HTMLInputElement | null>;
+    containerRef: React.RefObject<HTMLElement | null>;
+    onFocus?: React.FocusEventHandler<HTMLInputElement>;
+    onClick?: React.MouseEventHandler<HTMLInputElement>;
+    onKeyDown?: React.KeyboardEventHandler<HTMLInputElement>;
+    onBlur?: React.FocusEventHandler<HTMLInputElement>;
+}
+export interface UseSegmentedEntryResult {
+    segmentMap: SegmentMap | null;
+    activeSegmentIdx: number | null;
+    segmentEditable: boolean;
+    inSegmentMode: boolean;
+    inputHandlers: {
+        onChange: React.ChangeEventHandler<HTMLInputElement>;
+        onFocus: React.FocusEventHandler<HTMLInputElement>;
+        onClick: React.MouseEventHandler<HTMLInputElement>;
+        onKeyDown: React.KeyboardEventHandler<HTMLInputElement>;
+        onBlur: React.FocusEventHandler<HTMLInputElement>;
+    };
+}
+export declare function useSegmentedEntry(params: UseSegmentedEntryParams): UseSegmentedEntryResult;

package/dist/types/form/fieldProps.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+export interface FormFieldProps {
+    label?: React.ReactNode;
+    labelSize?: 'small' | 'normal' | 'medium' | 'large';
+    labelProps?: React.LabelHTMLAttributes<HTMLLabelElement> & {
+        [key: string]: unknown;
+    };
+    horizontal?: boolean;
+    message?: React.ReactNode;
+    messageColor?: 'primary' | 'link' | 'info' | 'success' | 'warning' | 'danger';
+    fieldClassName?: string;
+}

package/dist/types/helpers/bulmaClassHelpers.d.ts

@@ -0,0 +1,35 @@
+export declare const validColors: readonly ["primary", "link", "info", "success", "warning", "danger", "black", "black-bis", "black-ter", "grey-darker", "grey-dark", "grey", "grey-light", "grey-lighter", "white", "light", "dark"];
+export declare const validColorShades: readonly ["00", "05", "10", "15", "20", "25", "30", "35", "40", "45", "50", "55", "60", "65", "70", "75", "80", "85", "90", "95", "invert", "light", "dark", "soft", "bold", "on-scheme"];
+export declare const validSizes: readonly ["0", "1", "2", "3", "4", "5", "6", "auto"];
+export declare const validTextSizes: readonly ["1", "2", "3", "4", "5", "6", "7"];
+export declare const validAlignments: readonly ["centered", "justified", "left", "right"];
+export declare const validTextTransforms: readonly ["capitalized", "lowercase", "uppercase", "italic"];
+export declare const validTextWeights: readonly ["light", "normal", "medium", "semibold", "bold"];
+export declare const validFontFamilies: readonly ["sans-serif", "monospace", "primary", "secondary", "code"];
+export declare const validDisplays: readonly ["block", "flex", "inline", "inline-block", "inline-flex"];
+export declare const validVisibilities: readonly ["hidden", "sr-only", "invisible"];
+export declare const validFlexDirections: readonly ["row", "row-reverse", "column", "column-reverse"];
+export declare const validFlexWraps: readonly ["nowrap", "wrap", "wrap-reverse"];
+export declare const validJustifyContents: readonly ["flex-start", "flex-end", "center", "space-between", "space-around", "space-evenly", "start", "end", "left", "right"];
+export declare const validAlignContents: readonly ["flex-start", "flex-end", "center", "space-between", "space-around", "space-evenly", "stretch"];
+export declare const validAlignItems: readonly ["stretch", "flex-start", "flex-end", "center", "baseline", "start", "end"];
+export declare const validAlignSelfs: readonly ["auto", "flex-start", "flex-end", "center", "baseline", "stretch"];
+export declare const validFlexGrowShrink: readonly ["0", "1", "2", "3", "4", "5"];
+export declare const validViewports: readonly ["mobile", "tablet", "desktop", "widescreen", "fullhd"];
+export interface BulmaViewportProps {
+    viewport?: (typeof validViewports)[number];
+}
+export interface BulmaDisplayProps {
+    display?: (typeof validDisplays)[number] | 'none';
+    displayMobile?: (typeof validDisplays)[number] | 'none';
+    displayTablet?: (typeof validDisplays)[number] | 'none';
+    displayDesktop?: (typeof validDisplays)[number] | 'none';
+    displayWidescreen?: (typeof validDisplays)[number] | 'none';
+    displayFullhd?: (typeof validDisplays)[number] | 'none';
+}
+export declare const createBulmaClassHelpers: (classPrefix?: string, viewport?: (typeof validViewports)[number]) => {
+    classes: string[];
+    addPrefixedClass: (className: string) => void;
+    addClass: (prefix: string, value: string | undefined, validValues: readonly string[], supportsViewport?: boolean) => void;
+    addClassNoViewport: (prefix: string, value: string | undefined, validValues: readonly string[]) => void;
+};

package/dist/types/helpers/useBulmaClasses.d.ts

@@ -1,88 +1,21 @@
-export declare const validColors: readonly ["primary", "link", "info", "success", "warning", "danger", "black", "black-bis", "black-ter", "grey-darker", "grey-dark", "grey", "grey-light", "grey-lighter", "white", "light", "dark"];
-export declare const validColorShades: readonly ["00", "05", "10", "15", "20", "25", "30", "35", "40", "45", "50", "55", "60", "65", "70", "75", "80", "85", "90", "95", "invert", "light", "dark", "soft", "bold", "on-scheme"];
-export declare const validSizes: readonly ["0", "1", "2", "3", "4", "5", "6", "auto"];
-export declare const validTextSizes: readonly ["1", "2", "3", "4", "5", "6", "7"];
-export declare const validAlignments: readonly ["centered", "justified", "left", "right"];
-export declare const validTextTransforms: readonly ["capitalized", "lowercase", "uppercase", "italic"];
-export declare const validTextWeights: readonly ["light", "normal", "medium", "semibold", "bold"];
-export declare const validFontFamilies: readonly ["sans-serif", "monospace", "primary", "secondary", "code"];
-export declare const validDisplays: readonly ["block", "flex", "inline", "inline-block", "inline-flex"];
-export declare const validVisibilities: readonly ["hidden", "sr-only", "invisible"];
-export declare const validFlexDirections: readonly ["row", "row-reverse", "column", "column-reverse"];
-export declare const validFlexWraps: readonly ["nowrap", "wrap", "wrap-reverse"];
-export declare const validJustifyContents: readonly ["flex-start", "flex-end", "center", "space-between", "space-around", "space-evenly", "start", "end", "left", "right"];
-export declare const validAlignContents: readonly ["flex-start", "flex-end", "center", "space-between", "space-around", "space-evenly", "stretch"];
-export declare const validAlignItems: readonly ["stretch", "flex-start", "flex-end", "center", "baseline", "start", "end"];
-export declare const validAlignSelfs: readonly ["auto", "flex-start", "flex-end", "center", "baseline", "stretch"];
-export declare const validFlexGrowShrink: readonly ["0", "1", "2", "3", "4", "5"];
-export declare const validViewports: readonly ["mobile", "tablet", "desktop", "widescreen", "fullhd"];
-export interface BulmaClassesProps {
-    color?: (typeof validColors)[number] | 'inherit' | 'current';
-    backgroundColor?: (typeof validColors)[number] | 'inherit' | 'current';
-    colorShade?: (typeof validColorShades)[number];
-    backgroundColorShade?: (typeof validColorShades)[number];
-    m?: (typeof validSizes)[number];
-    mt?: (typeof validSizes)[number];
-    mr?: (typeof validSizes)[number];
-    mb?: (typeof validSizes)[number];
-    ml?: (typeof validSizes)[number];
-    mx?: (typeof validSizes)[number];
-    my?: (typeof validSizes)[number];
-    p?: (typeof validSizes)[number];
-    pt?: (typeof validSizes)[number];
-    pr?: (typeof validSizes)[number];
-    pb?: (typeof validSizes)[number];
-    pl?: (typeof validSizes)[number];
-    px?: (typeof validSizes)[number];
-    py?: (typeof validSizes)[number];
-    textSize?: (typeof validTextSizes)[number];
-    textAlign?: (typeof validAlignments)[number];
-    textTransform?: (typeof validTextTransforms)[number];
-    textWeight?: (typeof validTextWeights)[number];
-    fontFamily?: (typeof validFontFamilies)[number];
-    display?: (typeof validDisplays)[number] | 'none';
-    visibility?: (typeof validVisibilities)[number];
-    flexDirection?: (typeof validFlexDirections)[number];
-    flexWrap?: (typeof validFlexWraps)[number];
-    justifyContent?: (typeof validJustifyContents)[number];
-    alignContent?: (typeof validAlignContents)[number];
-    alignItems?: (typeof validAlignItems)[number];
-    alignSelf?: (typeof validAlignSelfs)[number];
-    flexGrow?: (typeof validFlexGrowShrink)[number];
-    flexShrink?: (typeof validFlexGrowShrink)[number];
-    float?: 'left' | 'right';
-    overflow?: 'clipped';
-    overlay?: boolean;
-    interaction?: 'unselectable' | 'clickable';
-    radius?: 'radiusless';
-    shadow?: 'shadowless';
-    responsive?: 'mobile' | 'narrow';
-    viewport?: (typeof validViewports)[number];
-    displayMobile?: (typeof validDisplays)[number] | 'none';
-    displayTablet?: (typeof validDisplays)[number] | 'none';
-    displayDesktop?: (typeof validDisplays)[number] | 'none';
-    displayWidescreen?: (typeof validDisplays)[number] | 'none';
-    displayFullhd?: (typeof validDisplays)[number] | 'none';
-    textSizeMobile?: (typeof validTextSizes)[number];
-    textSizeTablet?: (typeof validTextSizes)[number];
-    textSizeDesktop?: (typeof validTextSizes)[number];
-    textSizeWidescreen?: (typeof validTextSizes)[number];
-    textSizeFullhd?: (typeof validTextSizes)[number];
-    textAlignMobile?: (typeof validAlignments)[number];
-    textAlignTablet?: (typeof validAlignments)[number];
-    textAlignDesktop?: (typeof validAlignments)[number];
-    textAlignWidescreen?: (typeof validAlignments)[number];
-    textAlignFullhd?: (typeof validAlignments)[number];
-    visibilityMobile?: (typeof validVisibilities)[number];
-    visibilityTablet?: (typeof validVisibilities)[number];
-    visibilityDesktop?: (typeof validVisibilities)[number];
-    visibilityWidescreen?: (typeof validVisibilities)[number];
-    visibilityFullhd?: (typeof validVisibilities)[number];
-    skeleton?: boolean;
-    clearfix?: boolean;
-    relative?: boolean;
+import { BulmaDisplayProps, BulmaViewportProps } from './bulmaClassHelpers';
+import { BulmaColorProps } from './useColorClasses';
+import { BulmaSpacingProps } from './useSpacingClasses';
+import { BulmaTypographyProps } from './useTypographyClasses';
+import { BulmaVisibilityProps } from './useVisibilityClasses';
+import { BulmaFlexboxProps } from './useFlexboxClasses';
+import { BulmaOtherProps } from './useOtherClasses';
+export interface BulmaClassesProps extends BulmaColorProps, BulmaSpacingProps, BulmaTypographyProps, BulmaVisibilityProps, BulmaFlexboxProps, BulmaOtherProps {
 }
 export declare const useBulmaClasses: <T extends Record<string, unknown>>(props: BulmaClassesProps & T) => {
     bulmaHelperClasses: string;
     rest: Omit<T, keyof BulmaClassesProps>;
 };
+export { validColors, validColorShades, validSizes, validTextSizes, validAlignments, validTextTransforms, validTextWeights, validFontFamilies, validDisplays, validVisibilities, validFlexDirections, validFlexWraps, validJustifyContents, validAlignContents, validAlignItems, validAlignSelfs, validFlexGrowShrink, validViewports, } from './bulmaClassHelpers';
+export type { BulmaViewportProps, BulmaDisplayProps };
+export * from './useColorClasses';
+export * from './useSpacingClasses';
+export * from './useTypographyClasses';
+export * from './useVisibilityClasses';
+export * from './useFlexboxClasses';
+export * from './useOtherClasses';

package/dist/types/helpers/useColorClasses.d.ts

@@ -0,0 +1,8 @@
+import { validColors, validColorShades } from './bulmaClassHelpers';
+export interface BulmaColorProps {
+    color?: (typeof validColors)[number] | 'inherit' | 'current';
+    colorShade?: (typeof validColorShades)[number];
+    backgroundColor?: (typeof validColors)[number] | 'inherit' | 'current';
+    backgroundColorShade?: (typeof validColorShades)[number];
+}
+export declare const useColorClasses: (props: BulmaColorProps) => string;

package/dist/types/helpers/useFlexboxClasses.d.ts

@@ -0,0 +1,12 @@
+import { validFlexDirections, validFlexWraps, validJustifyContents, validAlignContents, validAlignItems, validAlignSelfs, validFlexGrowShrink, BulmaDisplayProps } from './bulmaClassHelpers';
+export interface BulmaFlexboxProps extends BulmaDisplayProps {
+    flexDirection?: (typeof validFlexDirections)[number];
+    flexWrap?: (typeof validFlexWraps)[number];
+    justifyContent?: (typeof validJustifyContents)[number];
+    alignContent?: (typeof validAlignContents)[number];
+    alignItems?: (typeof validAlignItems)[number];
+    alignSelf?: (typeof validAlignSelfs)[number];
+    flexGrow?: (typeof validFlexGrowShrink)[number];
+    flexShrink?: (typeof validFlexGrowShrink)[number];
+}
+export declare const useFlexboxClasses: (props: BulmaFlexboxProps) => string;

package/dist/types/helpers/useOtherClasses.d.ts

@@ -0,0 +1,15 @@
+export interface BulmaOtherProps {
+    float?: 'left' | 'right';
+    overflow?: 'clipped';
+    overlay?: boolean;
+    interaction?: 'unselectable' | 'clickable';
+    cursor?: 'pointer' | 'help';
+    radius?: 'radiusless';
+    shadow?: 'shadowless';
+    responsive?: 'mobile' | 'narrow';
+    skeleton?: boolean;
+    clearfix?: boolean;
+    relative?: boolean;
+    fullHeight?: boolean;
+}
+export declare const useOtherClasses: (props: BulmaOtherProps) => string;

package/dist/types/helpers/useSpacingClasses.d.ts

@@ -0,0 +1,18 @@
+import { validSizes } from './bulmaClassHelpers';
+export interface BulmaSpacingProps {
+    m?: (typeof validSizes)[number];
+    mt?: (typeof validSizes)[number];
+    mr?: (typeof validSizes)[number];
+    mb?: (typeof validSizes)[number];
+    ml?: (typeof validSizes)[number];
+    mx?: (typeof validSizes)[number];
+    my?: (typeof validSizes)[number];
+    p?: (typeof validSizes)[number];
+    pt?: (typeof validSizes)[number];
+    pr?: (typeof validSizes)[number];
+    pb?: (typeof validSizes)[number];
+    pl?: (typeof validSizes)[number];
+    px?: (typeof validSizes)[number];
+    py?: (typeof validSizes)[number];
+}
+export declare const useSpacingClasses: (props: BulmaSpacingProps) => string;

package/dist/types/helpers/useTypographyClasses.d.ts

@@ -0,0 +1,19 @@
+import { validTextSizes, validAlignments, validTextTransforms, validTextWeights, validFontFamilies, BulmaViewportProps } from './bulmaClassHelpers';
+export interface BulmaTypographyProps extends BulmaViewportProps {
+    textSize?: (typeof validTextSizes)[number];
+    textAlign?: (typeof validAlignments)[number];
+    textTransform?: (typeof validTextTransforms)[number];
+    textWeight?: (typeof validTextWeights)[number];
+    fontFamily?: (typeof validFontFamilies)[number];
+    textSizeMobile?: (typeof validTextSizes)[number];
+    textSizeTablet?: (typeof validTextSizes)[number];
+    textSizeDesktop?: (typeof validTextSizes)[number];
+    textSizeWidescreen?: (typeof validTextSizes)[number];
+    textSizeFullhd?: (typeof validTextSizes)[number];
+    textAlignMobile?: (typeof validAlignments)[number];
+    textAlignTablet?: (typeof validAlignments)[number];
+    textAlignDesktop?: (typeof validAlignments)[number];
+    textAlignWidescreen?: (typeof validAlignments)[number];
+    textAlignFullhd?: (typeof validAlignments)[number];
+}
+export declare const useTypographyClasses: (props: BulmaTypographyProps) => string;

package/dist/types/helpers/useVisibilityClasses.d.ts

@@ -0,0 +1,10 @@
+import { validVisibilities, BulmaViewportProps, BulmaDisplayProps } from './bulmaClassHelpers';
+export interface BulmaVisibilityProps extends BulmaViewportProps, BulmaDisplayProps {
+    visibility?: (typeof validVisibilities)[number];
+    visibilityMobile?: (typeof validVisibilities)[number];
+    visibilityTablet?: (typeof validVisibilities)[number];
+    visibilityDesktop?: (typeof validVisibilities)[number];
+    visibilityWidescreen?: (typeof validVisibilities)[number];
+    visibilityFullhd?: (typeof validVisibilities)[number];
+}
+export declare const useVisibilityClasses: (props: BulmaVisibilityProps) => string;