@cnamts/synapse 1.0.0 → 1.0.2

package/dist/components/DatePicker/{DateTextInput.d.ts → DateTextInput/DateTextInput.d.ts}

@@ -1,6 +1,6 @@
 import { nextTick } from 'vue';
-import { ValidationRule } from '../../composables/validation/useValidation';
-type DateValue = string | null;
+import { ValidationRule, ValidationResult } from '../../../composables/validation/useValidation';
+import { DateValue } from '../../../composables/date/useDateInitializationDayjs';
 type __VLS_Props = {
     modelValue?: DateValue;
     placeholder?: string;
@@ -20,6 +20,8 @@ type __VLS_Props = {
     disableErrorHandling?: boolean;
     showSuccessMessages?: boolean;
     bgColor?: string;
+    displayRange?: boolean;
+    autoClamp?: boolean;
 };
 declare const _default: import('vue').DefineComponent<__VLS_Props, {
     validateOnSubmit: () => Promise<boolean>;
@@ -28,11 +30,15 @@ declare const _default: import('vue').DefineComponent<__VLS_Props, {
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
     blur: () => any;
     focus: () => any;
+    input: (value: string) => any;
     "update:model-value": (value: DateValue) => any;
+    "date-selected": (value: DateValue) => any;
 }, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
     onBlur?: (() => any) | undefined;
     onFocus?: (() => any) | undefined;
+    onInput?: ((value: string) => any) | undefined;
     "onUpdate:model-value"?: ((value: DateValue) => any) | undefined;
+    "onDate-selected"?: ((value: DateValue) => any) | undefined;
 }>, {
     required: boolean;
     modelValue: DateValue;
@@ -47,26 +53,28 @@ declare const _default: import('vue').DefineComponent<__VLS_Props, {
     showSuccessMessages: boolean;
     disableErrorHandling: boolean;
     format: string;
+    displayRange: boolean;
     dateFormatReturn: string;
     isOutlined: boolean;
     displayIcon: boolean;
     displayAppendIcon: boolean;
     displayPrependIcon: boolean;
+    autoClamp: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
     inputRef: ({
         $: import('vue').ComponentInternalInstance;
         $data: {};
         $props: {
             readonly modelValue?: string | number | null | undefined;
-            readonly prependIcon?: import('../Customs/SyTextField/types').IconType;
-            readonly appendIcon?: import('../Customs/SyTextField/types').IconType;
-            readonly prependInnerIcon?: import('../Customs/SyTextField/types').IconType;
-            readonly appendInnerIcon?: import('../Customs/SyTextField/types').IconType;
+            readonly prependIcon?: import('../../Customs/SyTextField/types').IconType;
+            readonly appendIcon?: import('../../Customs/SyTextField/types').IconType;
+            readonly prependInnerIcon?: import('../../Customs/SyTextField/types').IconType;
+            readonly appendInnerIcon?: import('../../Customs/SyTextField/types').IconType;
             readonly prependTooltip?: string | undefined;
             readonly appendTooltip?: string | undefined;
             readonly tooltipLocation?: "top" | "bottom" | "start" | "end" | undefined;
-            readonly variantStyle?: import('../Customs/SyTextField/types').VariantStyle | undefined;
-            readonly color?: import('../Customs/SyTextField/types').ColorType | undefined;
+            readonly variantStyle?: import('../../Customs/SyTextField/types').VariantStyle | undefined;
+            readonly color?: import('../../Customs/SyTextField/types').ColorType | undefined;
             readonly isClearable?: boolean | undefined;
             readonly showDivider?: boolean | undefined;
             readonly label?: string | undefined;
@@ -1499,7 +1507,7 @@ declare const _default: import('vue').DefineComponent<__VLS_Props, {
                 disabled: boolean;
                 readonly: boolean | null;
                 messages: string | readonly string[];
-                rules: readonly (string | boolean | PromiseLike<import('vuetify/lib/composables/validation.mjs').ValidationResult> | [string, any, (string | undefined)?] | ((value: any) => import('vuetify/lib/composables/validation.mjs').ValidationResult) | ((value: any) => PromiseLike<import('vuetify/lib/composables/validation.mjs').ValidationResult>))[];
+                rules: readonly (string | boolean | PromiseLike<import('vuetify/lib/composables/validation.mjs').ValidationResult> | ((value: any) => import('vuetify/lib/composables/validation.mjs').ValidationResult) | ((value: any) => PromiseLike<import('vuetify/lib/composables/validation.mjs').ValidationResult>) | [string, any, (string | undefined)?])[];
                 focused: boolean;
                 errorMessages: string | readonly string[] | null;
                 maxErrors: string | number;
@@ -1529,15 +1537,15 @@ declare const _default: import('vue').DefineComponent<__VLS_Props, {
         $el: any;
         $options: import('vue').ComponentOptionsBase<Readonly<{
             modelValue?: string | number | null | undefined;
-            prependIcon?: import('../Customs/SyTextField/types').IconType;
-            appendIcon?: import('../Customs/SyTextField/types').IconType;
-            prependInnerIcon?: import('../Customs/SyTextField/types').IconType;
-            appendInnerIcon?: import('../Customs/SyTextField/types').IconType;
+            prependIcon?: import('../../Customs/SyTextField/types').IconType;
+            appendIcon?: import('../../Customs/SyTextField/types').IconType;
+            prependInnerIcon?: import('../../Customs/SyTextField/types').IconType;
+            appendInnerIcon?: import('../../Customs/SyTextField/types').IconType;
             prependTooltip?: string | undefined;
             appendTooltip?: string | undefined;
             tooltipLocation?: "top" | "bottom" | "start" | "end" | undefined;
-            variantStyle?: import('../Customs/SyTextField/types').VariantStyle | undefined;
-            color?: import('../Customs/SyTextField/types').ColorType | undefined;
+            variantStyle?: import('../../Customs/SyTextField/types').VariantStyle | undefined;
+            color?: import('../../Customs/SyTextField/types').ColorType | undefined;
             isClearable?: boolean | undefined;
             showDivider?: boolean | undefined;
             label?: string | undefined;
@@ -1607,7 +1615,7 @@ declare const _default: import('vue').DefineComponent<__VLS_Props, {
                 hasError: import('vue').ComputedRef<boolean>;
                 hasWarning: import('vue').ComputedRef<boolean>;
                 hasSuccess: import('vue').ComputedRef<boolean>;
-                validateField: (value: unknown, rules?: ValidationRule[], warningRules?: ValidationRule[], successRules?: ValidationRule[]) => import('../../composables/validation/useValidation').ValidationResult;
+                validateField: (value: unknown, rules?: ValidationRule[], warningRules?: ValidationRule[], successRules?: ValidationRule[]) => ValidationResult;
                 validateOnSubmit: () => Promise<boolean>;
                 clearValidation: () => void;
             };
@@ -1627,8 +1635,8 @@ declare const _default: import('vue').DefineComponent<__VLS_Props, {
             prependTooltip: string;
             appendTooltip: string;
             tooltipLocation: "top" | "bottom" | "start" | "end";
-            variantStyle: import('../Customs/SyTextField/types').VariantStyle;
-            color: import('../Customs/SyTextField/types').ColorType;
+            variantStyle: import('../../Customs/SyTextField/types').VariantStyle;
+            color: import('../../Customs/SyTextField/types').ColorType;
             isClearable: boolean;
             label: string;
             errorMessages: string[] | null;
@@ -1712,8 +1720,8 @@ declare const _default: import('vue').DefineComponent<__VLS_Props, {
         prependTooltip: string;
         appendTooltip: string;
         tooltipLocation: "top" | "bottom" | "start" | "end";
-        variantStyle: import('../Customs/SyTextField/types').VariantStyle;
-        color: import('../Customs/SyTextField/types').ColorType;
+        variantStyle: import('../../Customs/SyTextField/types').VariantStyle;
+        color: import('../../Customs/SyTextField/types').ColorType;
         isClearable: boolean;
         label: string;
         errorMessages: string[] | null;
@@ -1770,15 +1778,15 @@ declare const _default: import('vue').DefineComponent<__VLS_Props, {
         autocomplete: string;
     }> & Omit<Readonly<{
         modelValue?: string | number | null | undefined;
-        prependIcon?: import('../Customs/SyTextField/types').IconType;
-        appendIcon?: import('../Customs/SyTextField/types').IconType;
-        prependInnerIcon?: import('../Customs/SyTextField/types').IconType;
-        appendInnerIcon?: import('../Customs/SyTextField/types').IconType;
+        prependIcon?: import('../../Customs/SyTextField/types').IconType;
+        appendIcon?: import('../../Customs/SyTextField/types').IconType;
+        prependInnerIcon?: import('../../Customs/SyTextField/types').IconType;
+        appendInnerIcon?: import('../../Customs/SyTextField/types').IconType;
         prependTooltip?: string | undefined;
         appendTooltip?: string | undefined;
         tooltipLocation?: "top" | "bottom" | "start" | "end" | undefined;
-        variantStyle?: import('../Customs/SyTextField/types').VariantStyle | undefined;
-        color?: import('../Customs/SyTextField/types').ColorType | undefined;
+        variantStyle?: import('../../Customs/SyTextField/types').VariantStyle | undefined;
+        color?: import('../../Customs/SyTextField/types').ColorType | undefined;
         isClearable?: boolean | undefined;
         showDivider?: boolean | undefined;
         label?: string | undefined;
@@ -1848,7 +1856,7 @@ declare const _default: import('vue').DefineComponent<__VLS_Props, {
             hasError: import('vue').ComputedRef<boolean>;
             hasWarning: import('vue').ComputedRef<boolean>;
             hasSuccess: import('vue').ComputedRef<boolean>;
-            validateField: (value: unknown, rules?: ValidationRule[], warningRules?: ValidationRule[], successRules?: ValidationRule[]) => import('../../composables/validation/useValidation').ValidationResult;
+            validateField: (value: unknown, rules?: ValidationRule[], warningRules?: ValidationRule[], successRules?: ValidationRule[]) => ValidationResult;
             validateOnSubmit: () => Promise<boolean>;
             clearValidation: () => void;
         };

package/dist/components/DatePicker/composables/index.d.ts

@@ -0,0 +1,17 @@
+export { useDateInputEditing } from './useDateInputEditing';
+export { useDateRangeInput } from './useDateRangeInput';
+export { useDateAutoClamp } from './useDateAutoClamp';
+export { useDateSelection } from './useDateSelection';
+export { useDateValidation } from './useDateValidation';
+export { useDateFormatValidation } from './useDateFormatValidation';
+export { useDateRangeValidation } from './useDateRangeValidation';
+export { useManualDateValidation } from './useManualDateValidation';
+export { useDatePickerViewMode } from './useDatePickerViewMode';
+export { useDatePickerVisibility } from './useDatePickerVisibility';
+export { useDisplayedDateString } from './useDisplayedDateString';
+export { useIconState } from './useIconState';
+export { useInputBlurHandler } from './useInputBlurHandler';
+export { useTodayButton } from './useTodayButton';
+export { useWeekendDays } from './useWeekendDays';
+export { useMonthButtonCustomization } from './useMonthButtonCustomization';
+export { useAsteriskDisplay } from './useAsteriskDisplay';

package/dist/components/DatePicker/composables/useAsteriskDisplay.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Composable pour gérer l'affichage d'un astérisque à côté du label
+ * @param props - Les propriétés du composant contenant displayAsterisk et required
+ * @param labelProp - Le nom de la propriété contenant le label (par défaut: 'label')
+ * @returns Un objet contenant isShouldDisplayAsterisk et labelWithAsterisk
+ */
+export declare const useAsteriskDisplay: (props: {
+    [key: string]: unknown;
+    displayAsterisk?: boolean | undefined;
+    required?: boolean | undefined;
+}, labelProp?: string) => {
+    isShouldDisplayAsterisk: import('vue').ComputedRef<boolean | undefined>;
+    labelWithAsterisk: import('vue').ComputedRef<string | undefined>;
+};

package/dist/components/DatePicker/composables/useDateAutoClamp.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Composable pour gérer l'auto-clamping des dates invalides
+ * Cette fonctionnalité permet de ramener automatiquement les dates invalides
+ * (comme le 29/02 sur une année non bissextile ou 33/12) au dernier jour valide du mois
+ */
+export declare const useDateAutoClamp: () => {
+    autoClampDate: (dateStr: string, format: string) => {
+        clampedDate: string;
+        adjusted: boolean;
+    };
+    clampDayToValidDate: (day: number, month: number, year: number) => {
+        day: number;
+        adjusted: boolean;
+    };
+};
+export default useDateAutoClamp;

package/dist/components/DatePicker/composables/useDateFormatValidation.d.ts

@@ -0,0 +1,25 @@
+import { Ref } from 'vue';
+/**
+ * Composable pour la validation du format des dates
+ *
+ * @param options - Options de configuration
+ * @param options.format - Format d'affichage de la date (ex: 'DD/MM/YYYY')
+ * @param options.dateFormatReturn - Format de retour de la date (optionnel)
+ * @param options.required - Indique si le champ est requis
+ * @param options.hasInteracted - Ref indiquant si l'utilisateur a interagi avec le champ
+ * @param options.disableErrorHandling - Désactive la gestion des erreurs
+ * @returns Fonctions et propriétés pour la validation du format des dates
+ */
+export declare const useDateFormatValidation: (options: {
+    format: string;
+    dateFormatReturn?: string;
+    required?: boolean;
+    hasInteracted: Ref<boolean>;
+    disableErrorHandling?: boolean;
+}) => {
+    validateDateFormat: (dateStr: string) => {
+        isValid: boolean;
+        message: string;
+    };
+    isDateComplete: import('vue').ComputedRef<(dateStr: string) => boolean>;
+};

package/dist/components/DatePicker/composables/useDateInputEditing.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Options pour le composable useDateInputEditing
+ */
+export interface DateInputEditingOptions {
+    format: string;
+    updateDisplayValue: (value: string) => void;
+    updateAriaLabel?: (value: string) => void;
+    placeholderChar?: string;
+    accessiblePlaceholders?: boolean;
+}
+/**
+ * Résultat du formatage d'une date
+ */
+export interface FormatDateInputResult {
+    formatted: string;
+    cursorPos: number;
+}
+/**
+ * Composable pour gérer l'édition manuelle des dates
+ * Ce composable fournit des fonctions pour formater les dates pendant la saisie
+ * et gérer les touches spéciales comme Backspace et les flèches
+ *
+ * @param options - Options de configuration
+ * @returns Fonctions pour gérer l'édition manuelle des dates
+ */
+export declare const useDateInputEditing: (options: DateInputEditingOptions) => {
+    formatDateInput: (input: string, cursorPosition?: number) => FormatDateInputResult;
+    handleKeydown: (event: KeyboardEvent & {
+        target: HTMLInputElement;
+    }) => void;
+    handlePaste: (event: ClipboardEvent) => void;
+    getDateDescription: (dateStr: string, format: string) => string;
+};

package/dist/components/DatePicker/composables/useDatePickerViewMode.d.ts

@@ -0,0 +1,16 @@
+import { Ref } from 'vue';
+export type ViewMode = 'month' | 'year' | 'months' | undefined;
+export interface ViewModeReturn {
+    currentViewMode: Ref<ViewMode>;
+    handleViewModeUpdate: (newMode: ViewMode) => void;
+    handleYearUpdate: () => void;
+    handleMonthUpdate: () => void;
+    resetViewMode: () => void;
+}
+/**
+ * Composable pour gérer le mode d'affichage du DatePicker (année, mois, jour)
+ * Utilisé pour contrôler le comportement du DatePicker, notamment pour les dates de naissance
+ *
+ * @param isBirthDateGetter - Une fonction qui retourne la valeur actuelle de isBirthDate
+ */
+export declare function useDatePickerViewMode(isBirthDateGetter: () => boolean): ViewModeReturn;

package/dist/components/DatePicker/composables/useDatePickerVisibility.d.ts

@@ -0,0 +1,27 @@
+import { Ref } from 'vue';
+/**
+ * Composable pour gérer la visibilité et les interactions avec le DatePicker
+ *
+ * @param options - Options de configuration
+ * @returns Fonctions pour gérer la visibilité du DatePicker
+ */
+export declare const useDatePickerVisibility: (options: {
+    disabled?: boolean;
+    readonly?: boolean;
+    textFieldActivator?: boolean;
+    isDatePickerVisible: Ref<boolean>;
+    isManualInputActive: Ref<boolean>;
+    hasInteracted: Ref<boolean>;
+    updateAccessibility: () => void;
+    validateDates: () => void;
+    emitClosed: () => void;
+    emitFocus: () => void;
+}) => {
+    toggleDatePicker: () => void;
+    openDatePicker: () => void;
+    openDatePickerOnClick: () => void;
+    openDatePickerOnFocus: () => void;
+    openDatePickerOnIconClick: () => void;
+    handleClickOutside: (event: MouseEvent) => void;
+    handleKeyboardNavigation: (event: KeyboardEvent) => boolean;
+};

package/dist/components/DatePicker/composables/useDateRangeInput.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Composable pour gérer la saisie manuelle des plages de dates
+ * Permet de saisir et formater correctement une plage de dates au format "date1 - date2"
+ */
+export declare function useDateRangeInput(format: string, isRangeMode: boolean, parseDate: (dateStr: string, format: string) => Date | null, formatDate: (date: Date, format: string) => string): {
+    isEditingSecondDate: import('vue').Ref<boolean, boolean>;
+    firstDate: import('vue').Ref<Date | null, Date | null>;
+    secondDate: import('vue').Ref<Date | null, Date | null>;
+    rangeSeparator: string;
+    hasRangeSeparator: (value: string) => boolean;
+    extractRangeParts: (value: string) => [string, string];
+    formatRangeForDisplay: (startDate: Date | null, endDate: Date | null) => string;
+    parseRangeInput: (value: string) => [Date | null, Date | null];
+    handleRangeInput: (inputValue: string | unknown, newValue: string | unknown, cursorPosition?: number) => {
+        formattedValue: string;
+        dates: [Date | null, Date | null];
+        isComplete: boolean;
+        justCompletedFirstDate?: boolean | undefined;
+        cursorPosition?: number | undefined;
+    };
+    initializeWithDates: (startDate: Date | null, endDate: Date | null) => void;
+    resetState: () => void;
+    isValidRange: (startDate: Date | null, endDate: Date | null) => boolean;
+    currentRangeIsValid: import('vue').ComputedRef<boolean>;
+    handleKeydown: (event: KeyboardEvent & {
+        target: HTMLInputElement;
+    }) => void;
+    handlePaste: (event: ClipboardEvent) => void;
+};

package/dist/components/DatePicker/composables/useDateRangeValidation.d.ts

@@ -0,0 +1,11 @@
+import { Ref } from 'vue';
+import { DateObjectValue } from '../types';
+/**
+ * Composable pour gérer la validation des plages de dates
+ * Permet de vérifier si une plage de dates est valide (date de début avant date de fin)
+ */
+export declare function useDateRangeValidation(selectedDates: Ref<DateObjectValue>, displayRange: boolean): {
+    isRangeValid: (startDate: Date | null, endDate: Date | null) => boolean;
+    currentRangeIsValid: import('vue').ComputedRef<boolean>;
+    getRangeValidationError: import('vue').ComputedRef<string>;
+};

package/dist/components/DatePicker/composables/useDateSelection.d.ts

@@ -0,0 +1,10 @@
+import { Ref } from 'vue';
+/**
+ * Composable pour gérer la sélection de dates dans les composants DatePicker
+ * Gère les plages de dates et la génération des dates intermédiaires
+ */
+export declare function useDateSelection(parseDate: (dateStr: string, format: string) => Date | null, selectedDates: Ref<Date | (Date | null)[] | null>, format: string, displayRange: boolean): {
+    updateSelectedDates: (input: Date | Date[] | string | string[] | null | undefined) => void;
+    rangeBoundaryDates: Ref<[Date | null, Date | null] | null, [Date | null, Date | null] | null>;
+    generateDateRange: (start: Date, end: Date) => Date[];
+};

package/dist/components/DatePicker/composables/useDateValidation.d.ts

@@ -0,0 +1,35 @@
+import { Ref } from 'vue';
+import { ValidationResult } from '../../../composables/validation/useValidation';
+import { DateObjectValue } from '../types';
+/**
+ * Composable pour la validation des dates
+ *
+ * @param options - Options de configuration
+ * @returns Fonctions pour la validation des dates
+ */
+export declare const useDateValidation: (options: {
+    noCalendar?: boolean | undefined;
+    required?: boolean | undefined;
+    displayRange?: boolean | undefined;
+    disableErrorHandling?: boolean | undefined;
+    customRules?: {
+        type: string;
+        options: any;
+    }[] | undefined;
+    customWarningRules?: {
+        type: string;
+        options: any;
+    }[] | undefined;
+    selectedDates: Ref<DateObjectValue>;
+    isUpdatingFromInternal: Ref<boolean>;
+    currentRangeIsValid: Ref<boolean>;
+    getRangeValidationError: Ref<string>;
+    clearValidation: () => void;
+    validateField: (value: any, rules?: any[], warningRules?: any[]) => ValidationResult;
+    errors: Ref<string[]>;
+    warnings: Ref<string[]>;
+    successes: Ref<string[]>;
+}) => {
+    validateDates: (forceValidation?: boolean) => ValidationResult;
+    validateOnSubmit: () => ValidationResult;
+};

package/dist/components/DatePicker/composables/useDisplayedDateString.d.ts

@@ -0,0 +1,19 @@
+import { ComputedRef } from 'vue';
+import { DateObjectValue } from '../types';
+export interface DisplayedDateStringProps {
+    selectedDates: {
+        value: DateObjectValue;
+    };
+    rangeBoundaryDates?: {
+        value: [Date | null, Date | null] | null;
+    };
+    todayInString: ComputedRef<string>;
+}
+export interface DisplayedDateStringReturn {
+    displayedDateString: ComputedRef<string>;
+}
+/**
+ * Composable pour formater l'affichage des dates sélectionnées
+ * Gère à la fois les dates uniques et les plages de dates
+ */
+export declare function useDisplayedDateString(props: DisplayedDateStringProps): DisplayedDateStringReturn;

package/dist/components/DatePicker/composables/useIconState.d.ts

@@ -0,0 +1,17 @@
+import { Ref } from 'vue';
+/**
+ * Composable pour déterminer l'icône à afficher en fonction de l'état de validation
+ *
+ * @param options - Options de configuration
+ * @returns Fonction pour obtenir l'icône appropriée
+ */
+export declare const useIconState: (options: {
+    noCalendar?: boolean;
+    disableErrorHandling?: boolean;
+    errorMessages: Ref<string[]>;
+    warningMessages: Ref<string[]>;
+    successMessages: Ref<string[]>;
+}) => {
+    getIcon: import('vue').ComputedRef<"success" | "warning" | "error" | undefined>;
+    getIconValue: import('vue').ComputedRef<"success" | "warning" | "error" | undefined>;
+};

package/dist/components/DatePicker/composables/useInputBlurHandler.d.ts

@@ -0,0 +1,31 @@
+import { Ref } from 'vue';
+import { DateValue } from '../../../composables/date/useDateInitializationDayjs';
+import { DateObjectValue } from '../types';
+/**
+ * Composable pour gérer le comportement lors de la perte de focus d'un champ de date
+ *
+ * @param options - Options de configuration
+ * @returns Fonction pour gérer la perte de focus
+ */
+export declare const useInputBlurHandler: (options: {
+    format: string;
+    dateFormatReturn?: string | undefined;
+    required?: boolean | undefined;
+    displayFormattedDate: Ref<string>;
+    hasInteracted: Ref<boolean>;
+    isManualInputActive: Ref<boolean>;
+    isUpdatingFromInternal: Ref<boolean>;
+    selectedDates: Ref<DateObjectValue>;
+    errors?: Ref<string[], string[]> | undefined;
+    validateDateFormat: (dateStr: string) => {
+        isValid: boolean;
+        message: string;
+    };
+    parseDate: (dateStr: string, format: string) => Date | null;
+    formatDate: (date: Date, format: string) => string;
+    updateModel: (value: DateValue) => void;
+    validateManualInput: (value: string) => boolean;
+    emitBlur: () => void;
+}) => {
+    handleInputBlur: () => void;
+};

package/dist/components/DatePicker/composables/useInputHandler.d.ts

@@ -0,0 +1,32 @@
+import { Ref, ComponentPublicInstance } from 'vue';
+import { DateObjectValue } from '../types';
+export interface InputHandlerOptions {
+    format: string;
+    displayRange: boolean;
+    dateFormatReturn?: string;
+    disableErrorHandling?: boolean;
+    parseDate: (dateStr: string, format: string) => Date | null;
+    formatDate: (date: Date, format: string) => string;
+    generateDateRange: (startDate: Date, endDate: Date) => Date[];
+    isDateComplete: (value: string) => boolean;
+    displayFormattedDate: Ref<string>;
+    selectedDates: Ref<DateObjectValue>;
+    isFormatting: Ref<boolean>;
+    isManualInputActive: Ref<boolean>;
+    isUpdatingFromInternal: Ref<boolean>;
+    clearValidation: () => void;
+    validateField: (value: unknown, rules?: unknown[], warningRules?: unknown[]) => unknown;
+    updateModel: (value: unknown) => void;
+    emitInput: (value: string) => void;
+    inputRef: Ref<ComponentPublicInstance | null>;
+}
+export declare function useInputHandler(options: InputHandlerOptions): {
+    handleInput: (event: Event) => void;
+    updateModelFromSelectedDates: () => void;
+    updateCursorPosition: (inputElement: HTMLInputElement | null, position: number) => void;
+    formatRangeInput: (value: string, cursorPos: number) => {
+        formattedInput: string;
+        newCursorPos: number;
+    };
+    updateSelectedDatesFromFormattedValue: (formattedInput: string) => void;
+};

package/dist/components/DatePicker/composables/useManualDateValidation.d.ts

@@ -0,0 +1,33 @@
+import { Ref } from 'vue';
+import { ValidationResult } from '../../../composables/validation/useValidation';
+/**
+ * Composable pour la validation manuelle des dates saisies
+ *
+ * @param options - Options de configuration
+ * @returns Fonction pour valider la saisie manuelle de date
+ */
+export declare const useManualDateValidation: (options: {
+    format: string;
+    required?: boolean | undefined;
+    disableErrorHandling?: boolean | undefined;
+    customRules?: {
+        type: string;
+        options: any;
+    }[] | undefined;
+    customWarningRules?: {
+        type: string;
+        options: any;
+    }[] | undefined;
+    hasInteracted: Ref<boolean>;
+    errors: Ref<string[]>;
+    clearValidation: () => void;
+    validateDateFormat: (dateStr: string) => {
+        isValid: boolean;
+        message: string;
+    };
+    isDateComplete: (value: string) => boolean;
+    parseDate: (dateStr: string, format: string) => Date | null;
+    validateField: (value: any, rules?: any[], warningRules?: any[]) => ValidationResult;
+}) => {
+    validateManualInput: (value: string) => boolean;
+};

package/dist/components/DatePicker/composables/useMonthButtonCustomization.d.ts

@@ -0,0 +1,12 @@
+import { Ref } from 'vue';
+/**
+ * Composable pour personnaliser les boutons du mois et de l'année dans les composants DatePicker
+ * @param isPickerVisibleGetter - Fonction qui retourne l'état de visibilité du DatePicker
+ * @param monthName - Référence au nom du mois à utiliser
+ * @param yearName - Référence au nom de l'année à utiliser
+ */
+export declare function useMonthButtonCustomization(isPickerVisibleGetter: () => boolean, monthName?: Ref<string | null>, yearName?: Ref<string | null>): {
+    monthButtonText: Ref<string, string>;
+    customizeMonthButton: () => void;
+    setupMonthButtonObserver: () => void;
+};

package/dist/components/DatePicker/composables/useTodayButton.d.ts

@@ -0,0 +1,16 @@
+import { ComputedRef } from 'vue';
+import { DateObjectValue } from '../types';
+export interface TodayButtonProps {
+    displayTodayButton?: boolean;
+    displayRange?: boolean;
+}
+export interface TodayButtonReturn {
+    todayInString: ComputedRef<string>;
+    selectToday: (selectedDates: {
+        value: DateObjectValue;
+    }) => void;
+}
+/**
+ * Composable pour gérer le bouton "Aujourd'hui" dans le DatePicker
+ */
+export declare function useTodayButton(props: TodayButtonProps): TodayButtonReturn;

package/dist/components/DatePicker/composables/useWeekendDays.d.ts

@@ -0,0 +1,11 @@
+import { ComputedRef } from 'vue';
+export interface WeekendDaysProps {
+    displayWeekendDays?: boolean;
+}
+export interface WeekendDaysReturn {
+    displayWeekendDays: ComputedRef<boolean>;
+}
+/**
+ * Composable pour gérer l'affichage des jours de weekend dans le DatePicker
+ */
+export declare function useWeekendDays(props: WeekendDaysProps): WeekendDaysReturn;

package/dist/components/DatePicker/constants/messages.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Fichier contenant toutes les constantes de textes utilisées dans les composants/composables DatePicker
+ */
+export declare const DATE_PICKER_MESSAGES: {
+    LABEL_DEFAULT: string;
+    PLACEHOLDER_DEFAULT: string;
+    ERROR_REQUIRED: string;
+    ERROR_INVALID_FORMAT: string;
+    ERROR_INVALID_DATE: string;
+    ERROR_INCOMPLETE_DATE: string;
+    ERROR_INVALID_RANGE: string;
+    ERROR_START_DATE_MISSING: string;
+    ERROR_END_DATE_MISSING: string;
+    ERROR_END_BEFORE_START: string;
+    ERROR_INVALID_FORMAT_START: string;
+    ERROR_INVALID_FORMAT_END: string;
+    SUCCESS_VALID_DATE: string;
+    ARIA_DATE_INPUT: string;
+    ARIA_CALENDAR_BUTTON: string;
+    ARIA_TODAY_BUTTON: string;
+    BUTTON_TODAY: string;
+    BUTTON_CLEAR: string;
+    BUTTON_CLOSE: string;
+    FORMAT_DEFAULT: string;
+    MONTH_NAMES: string[];
+    DAY_NAMES: string[];
+    DATE_SEPARATOR: string;
+    RANGE_SEPARATOR: string;
+};

package/dist/components/DatePicker/types.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Types pour les composants DatePicker
+ */
+/**
+ * Type représentant une valeur de date qui peut être une Date, un tableau de Dates ou null
+ * Utilisé pour les opérations internes du DatePicker avec des objets Date
+ */
+export type DateObjectValue = Date | (Date | null)[] | null;
+/**
+ * Alias pour maintenir la compatibilité avec le code existant
+ * @deprecated Utilisez DateObjectValue pour les objets Date ou importez DateValue depuis useDateInitializationDayjs pour les chaînes
+ */
+export type DateValue = DateObjectValue;

package/dist/components/DialogBox/AccessibiliteItems.d.ts

@@ -1,4 +1,4 @@
-import { ExpertiseLevelEnum } from './constants/ExpertiseLevelEnum';
+import { ExpertiseLevelEnum } from '../../common/constants/ExpertiseLevelEnum';
 export declare const AccessibiliteItemsIndeterminate: ({
     title: string;
     subtitle: string;