@cnamts/synapse 1.1.0 → 1.1.1

package/dist/components/Captcha/CaptchaForm.d.ts

@@ -4,13 +4,39 @@ interface Props {
     modelValue?: string | null;
     state?: string | null;
     loading?: boolean;
-    errors: string[] | undefined;
-    success: boolean;
     locales: typeof defaultLocales;
+    success?: boolean;
+    errorMessages?: string[];
+    warningMessages?: string[];
+    successMessages?: string[];
+    hasError?: boolean;
+    hasWarning?: boolean;
+    hasSuccess?: boolean;
+    showSuccessMessages?: boolean;
+    required?: boolean;
+    maxErrors?: number;
+    isClearable?: boolean;
 }
 declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    blur: (...args: any[]) => void;
+    focus: (...args: any[]) => void;
     "update:modelValue": (...args: any[]) => void;
 }, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onBlur?: ((...args: any[]) => any) | undefined;
+    onFocus?: ((...args: any[]) => any) | undefined;
     "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
-}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+}>, {
+    loading: boolean;
+    state: string | null;
+    modelValue: string | null;
+    required: boolean;
+    showSuccessMessages: boolean;
+    errorMessages: string[];
+    maxErrors: number;
+    hasError: boolean;
+    hasWarning: boolean;
+    hasSuccess: boolean;
+    successMessages: string[];
+    warningMessages: string[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 export default _default;

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

@@ -1,2 +1,16 @@
+import { FieldValidationProps } from '../../composables/unifyValidation/useValidation';
+import { locales as defaultLocales } from './locales';
 export type CaptchaType = 'image' | 'audio' | 'choice';
 export type StateType = 'idle' | 'pending' | 'resolved' | 'rejected';
+export type CaptchaProps = FieldValidationProps & {
+    modelValue?: string | undefined;
+    urlCreate: string;
+    urlGetImage: string;
+    urlGetAudio: string;
+    type?: CaptchaType;
+    tagTitle?: string;
+    helpDesk?: string | false;
+    isClearable?: boolean;
+    locale?: string;
+    locales?: typeof defaultLocales;
+};

package/dist/components/Captcha/useCaptchaValidation.d.ts

@@ -0,0 +1,37 @@
+import { Ref } from 'vue';
+import { VuetifyValidationRule } from '../../composables/unifyValidation/useValidation';
+import { ValidationRule as SyValidationRule } from '../../composables/validation/useValidation';
+import { locales as defaultLocales } from './locales';
+export declare function useCaptchaValidation(params: {
+    modelValue: Ref<string | null>;
+    readonly: Ref<boolean>;
+    disabled: Ref<boolean>;
+    required: Ref<boolean>;
+    isValidateOnBlur: Ref<boolean>;
+    showSuccessMessages: Ref<boolean>;
+    disableErrorHandling: Ref<boolean>;
+    useVuetifyValidation: Ref<boolean>;
+    label: Ref<string>;
+    rules: Ref<VuetifyValidationRule[] | undefined>;
+    customRules: Ref<SyValidationRule[] | undefined>;
+    customWarningRules: Ref<SyValidationRule[] | undefined>;
+    customSuccessRules: Ref<SyValidationRule[] | undefined>;
+    errorMessages: Ref<string[] | undefined | null>;
+    warningMessages: Ref<string[] | undefined | null>;
+    successMessages: Ref<string[] | undefined | null>;
+    hasErrorProp: Ref<boolean>;
+    hasWarningProp: Ref<boolean>;
+    hasSuccessProp: Ref<boolean>;
+    maxErrors: Ref<number | undefined>;
+    focused: Ref<boolean>;
+    locales: Ref<typeof defaultLocales>;
+}): {
+    validate: () => Promise<boolean>;
+    clearValidation: () => void;
+    errors: import('vue').ComputedRef<string[]>;
+    warnings: import('vue').ComputedRef<string[]>;
+    successes: import('vue').ComputedRef<string[]>;
+    hasError: import('vue').ComputedRef<boolean>;
+    hasWarning: import('vue').ComputedRef<boolean>;
+    hasSuccess: import('vue').ComputedRef<boolean>;
+};

package/dist/components/Customs/Selects/SelectBtnField/SelectBtnField.d.ts

@@ -1,3 +1,4 @@
+import { FieldValidationProps } from '../../../../composables/unifyValidation/useValidation';
 import { SelectBtnItem, SelectBtnValue } from './types';
 type __VLS_Props = {
     modelValue?: SelectBtnValue;
@@ -6,30 +7,49 @@ type __VLS_Props = {
     ariaLabelledby?: string | undefined;
     multiple?: boolean;
     inline?: boolean;
-    hint?: string;
-    error?: boolean;
-    errorMessages?: string[];
-    readonly?: boolean;
-};
-declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    helpText?: string;
+    hideDetails?: boolean;
+} & FieldValidationProps;
+declare const _default: import('vue').DefineComponent<__VLS_Props, {
+    validateOnSubmit: () => Promise<boolean>;
+    validate: () => Promise<boolean>;
+    clearValidation: () => void;
+    errors: import('vue').ComputedRef<string[]>;
+    warnings: import('vue').ComputedRef<string[]>;
+    successes: import('vue').ComputedRef<string[]>;
+    hasError: import('vue').ComputedRef<boolean>;
+    hasWarning: import('vue').ComputedRef<boolean>;
+    hasSuccess: import('vue').ComputedRef<boolean>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
     "update:modelValue": (value: SelectBtnValue) => any;
-    "update:error": (value: boolean) => any;
-    "update:error-messages": (value: string[] | undefined) => any;
 }, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
     "onUpdate:modelValue"?: ((value: SelectBtnValue) => any) | undefined;
-    "onUpdate:error"?: ((value: boolean) => any) | undefined;
-    "onUpdate:error-messages"?: ((value: string[] | undefined) => any) | undefined;
 }>, {
     label: string;
+    disabled: boolean;
     readonly: boolean;
-    error: boolean;
     items: SelectBtnItem[];
     modelValue: SelectBtnValue;
     multiple: boolean;
+    required: boolean;
     ariaLabelledby: string;
     inline: boolean;
-    errorMessages: string[];
-    hint: string;
+    showSuccessMessages: boolean;
+    disableErrorHandling: boolean;
+    errorMessages: string[] | null;
+    maxErrors: number;
+    hasError: boolean;
+    hasWarning: boolean;
+    hasSuccess: boolean;
+    useVuetifyValidation: boolean;
+    customRules: import('../../../../composables/unifyValidation/useValidation').ValidationRule[];
+    customWarningRules: import('../../../../composables/unifyValidation/useValidation').ValidationRule[];
+    customSuccessRules: import('../../../../composables/unifyValidation/useValidation').ValidationRule[];
+    helpText: string;
+    hideDetails: boolean;
+    isValidateOnBlur: boolean;
+    successMessages: string[] | null;
+    warningMessages: string[] | null;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
     listRef: HTMLUListElement;
     optionsRef: HTMLLIElement[];

package/dist/components/Customs/Selects/SelectBtnField/composables/useSelectBtnFieldValidation.d.ts

@@ -0,0 +1,23 @@
+import { FieldValidationProps } from '../../../../../composables/unifyValidation/useValidation';
+/**
+ * Composable de validation dédié au composant SelectBtnField.
+ * - règle `required` par défaut avec message personnalisé,
+ * - support des customRules / customWarningRules / customSuccessRules,
+ * - messages externes (errorMessages / warningMessages / successMessages),
+ * - validation immédiate à la sélection (isValidateOnBlur à `false` par défaut, comme un groupe de boutons),
+ * - intégration automatique au SyForm via le useValidatable interne à useValidation.
+ */
+export declare function useSelectBtnFieldValidation(props: FieldValidationProps & {
+    modelValue?: unknown;
+}): {
+    focused: import('vue').Ref<boolean, boolean>;
+    validate: () => Promise<boolean>;
+    clearValidation: () => void;
+    errors: import('vue').ComputedRef<string[]>;
+    warnings: import('vue').ComputedRef<string[]>;
+    successes: import('vue').ComputedRef<string[]>;
+    hasError: import('vue').ComputedRef<boolean>;
+    hasWarning: import('vue').ComputedRef<boolean>;
+    hasSuccess: import('vue').ComputedRef<boolean>;
+    validationIcon: import('vue').ComputedRef<string | null>;
+};

package/dist/components/Customs/Selects/SyAutocomplete/composables/useSyAutocompleteValidation.d.ts

@@ -11,8 +11,8 @@ export declare function useSyAutocompleteValidation(props: FieldValidationProps)
     displayErrors: import('vue').ComputedRef<string[]>;
     displayWarnings: import('vue').ComputedRef<string[]>;
     displaySuccesses: import('vue').ComputedRef<string[]>;
-    displayHasError: import('vue').ComputedRef<boolean | undefined>;
-    displayHasWarning: import('vue').ComputedRef<boolean | undefined>;
+    displayHasError: import('vue').ComputedRef<boolean>;
+    displayHasWarning: import('vue').ComputedRef<boolean>;
     displayHasSuccess: import('vue').ComputedRef<boolean>;
     validationIcon: import('vue').ComputedRef<string | null>;
 };

package/dist/components/Customs/Selects/SySelect/composables/useSySelectValidation.d.ts

@@ -8,8 +8,8 @@ export declare function useSySelectValidation(props: FieldValidationProps & {
     errors: import('vue').ComputedRef<string[]>;
     warnings: import('vue').ComputedRef<string[]>;
     successes: import('vue').ComputedRef<string[]>;
-    hasError: import('vue').ComputedRef<boolean | undefined>;
-    hasWarning: import('vue').ComputedRef<boolean | undefined>;
+    hasError: import('vue').ComputedRef<boolean>;
+    hasWarning: import('vue').ComputedRef<boolean>;
     hasSuccess: import('vue').ComputedRef<boolean>;
     validationIcon: import('vue').ComputedRef<string | null>;
 };

package/dist/components/Customs/SyCheckBoxGroup/SyCheckBoxGroup.d.ts

@@ -1,51 +1,14 @@
-import { ValidationRule } from '../../../composables/validation/useValidation';
-import { Option } from './types';
-type __VLS_Props = {
-    ariaLabel?: string;
-    ariaLabelledby?: string;
-    color?: string;
-    customRules?: ValidationRule[];
-    customSuccessRules?: ValidationRule[];
-    customWarningRules?: ValidationRule[];
-    density?: 'default' | 'comfortable' | 'compact';
-    disabled?: boolean;
-    disableErrorHandling?: boolean;
-    displayAsterisk?: boolean;
-    errorMessages?: string[] | null;
-    hideDetails?: boolean | 'auto';
-    id?: string;
-    isValidateOnBlur?: boolean;
-    label?: string;
-    modelValue?: (string | number) | (string | number)[] | null;
-    multiple?: boolean;
-    name?: string;
-    options?: Option[];
-    readonly?: boolean;
-    required?: boolean;
-    showSuccessMessages?: boolean;
-    successMessages?: string[] | null;
-    title?: string;
-    warningMessages?: string[] | null;
-};
-declare const _default: import('vue').DefineComponent<__VLS_Props, {
-    validation: {
-        errors: import('vue').Ref<string[], string[]>;
-        warnings: import('vue').Ref<string[], string[]>;
-        successes: import('vue').Ref<string[], string[]>;
-        displaySuccesses: import('vue').ComputedRef<string[]>;
-        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 | Promise<import('../../../composables/validation/useValidation').ValidationResult>;
-        validateOnSubmit: () => boolean;
-        clearValidation: () => void;
-    };
+import { SyCheckBoxGroupProps } from './types';
+declare const _default: import('vue').DefineComponent<SyCheckBoxGroupProps, {
     validateOnSubmit: () => Promise<boolean>;
-    checkErrorOnBlur: () => void;
+    clearValidation: () => void;
+    reset: () => void;
+    defaultRules: import('vue').ComputedRef<import('../../../composables/unifyValidation/useValidation').ValidationRule[]>;
+    checkErrorOnBlur: () => Promise<boolean>;
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     change: (...args: any[]) => void;
     "update:modelValue": (...args: any[]) => void;
-}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+}, string, import('vue').PublicProps, Readonly<SyCheckBoxGroupProps> & Readonly<{
     onChange?: ((...args: any[]) => any) | undefined;
     "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
 }>, {
@@ -58,7 +21,7 @@ declare const _default: import('vue').DefineComponent<__VLS_Props, {
     readonly: boolean;
     id: string;
     name: string;
-    options: Option[];
+    options: import('./types').Option[];
     modelValue: (string | number) | (string | number)[] | null;
     multiple: boolean;
     required: boolean;
@@ -66,10 +29,16 @@ declare const _default: import('vue').DefineComponent<__VLS_Props, {
     showSuccessMessages: boolean;
     disableErrorHandling: boolean;
     errorMessages: string[] | null;
-    customRules: ValidationRule[];
-    customWarningRules: ValidationRule[];
-    customSuccessRules: ValidationRule[];
+    maxErrors: number;
+    hasError: boolean;
+    hasWarning: boolean;
+    hasSuccess: boolean;
+    useVuetifyValidation: boolean;
+    customRules: import('../../../composables/unifyValidation/useValidation').ValidationRule[];
+    customWarningRules: import('../../../composables/unifyValidation/useValidation').ValidationRule[];
+    customSuccessRules: import('../../../composables/unifyValidation/useValidation').ValidationRule[];
     displayAsterisk: boolean;
+    helpText: string;
     hideDetails: boolean | "auto";
     isValidateOnBlur: boolean;
     successMessages: string[] | null;

package/dist/components/Customs/SyCheckBoxGroup/composables/useSyCheckBoxGroupValidation.d.ts

@@ -0,0 +1,29 @@
+import { ComputedRef, Ref } from 'vue';
+import { ValidationRule } from '../../../../composables/unifyValidation/useValidation';
+import { SyCheckBoxGroupValidationProps } from '../types';
+export interface UseSyCheckBoxGroupValidationReturn {
+    validate: () => Promise<boolean>;
+    validateOnSubmit: () => Promise<boolean>;
+    clearValidation: () => void;
+    errors: Ref<string[]>;
+    warnings: Ref<string[]>;
+    successes: Ref<string[]>;
+    hasError: ComputedRef<boolean | undefined>;
+    hasWarning: ComputedRef<boolean | undefined>;
+    hasSuccess: ComputedRef<boolean | undefined>;
+    defaultRules: ComputedRef<ValidationRule[]>;
+    focused: Ref<boolean>;
+}
+/**
+ * Composable pour gérer la validation du composant SyCheckBoxGroup
+ *
+ * Ce composable encapsule toute la logique de validation spécifique aux groupes de checkboxes :
+ * - Validation required avec message personnalisé (supporte les modes single et multiple)
+ * - Support des customRules, customWarningRules, customSuccessRules
+ * - Désactivation automatique des messages de succès en mode Vuetify
+ * - Intégration avec useValidation du design system
+ *
+ * @example
+ * const { validate, errors, hasError, defaultRules } = useSyCheckBoxGroupValidation(props, model)
+ */
+export declare function useSyCheckBoxGroupValidation(props: SyCheckBoxGroupValidationProps, model: Ref<(string | number) | (string | number)[] | null>, focused?: Ref<boolean>): UseSyCheckBoxGroupValidationReturn;

package/dist/components/Customs/SyCheckBoxGroup/types.d.ts

@@ -1,3 +1,4 @@
+import { FieldValidationProps, ValidationRule, VuetifyValidationRule } from '../../../composables/unifyValidation/useValidation';
 export type Option = {
     label: string;
     value: string | number;
@@ -8,3 +9,48 @@ export type Option = {
     ariaLabel?: string;
     title?: string;
 };
+/**
+ * Props du composant SyCheckBoxGroup
+ */
+export interface SyCheckBoxGroupProps extends FieldValidationProps {
+    ariaLabel?: string;
+    ariaLabelledby?: string;
+    color?: string;
+    density?: 'default' | 'comfortable' | 'compact';
+    displayAsterisk?: boolean;
+    helpText?: string;
+    hideDetails?: boolean | 'auto';
+    id?: string;
+    label?: string;
+    modelValue?: (string | number) | (string | number)[] | null;
+    multiple?: boolean;
+    name?: string;
+    options?: Option[];
+    title?: string;
+}
+/**
+ * Props de validation étendant FieldValidationProps du système unifié
+ */
+export interface SyCheckBoxGroupValidationProps extends FieldValidationProps {
+    modelValue?: (string | number) | (string | number)[] | null;
+    multiple?: boolean;
+    required?: boolean;
+    readonly?: boolean;
+    disabled?: boolean;
+    customRules?: ValidationRule[];
+    customWarningRules?: ValidationRule[];
+    customSuccessRules?: ValidationRule[];
+    isValidateOnBlur?: boolean;
+    showSuccessMessages?: boolean;
+    useVuetifyValidation?: boolean;
+    rules?: VuetifyValidationRule[];
+    errorMessages?: string[] | null;
+    warningMessages?: string[] | null;
+    successMessages?: string[] | null;
+    hasError?: boolean;
+    hasWarning?: boolean;
+    hasSuccess?: boolean;
+    maxErrors?: number;
+    disableErrorHandling?: boolean;
+    fieldIdentifier?: string;
+}

package/dist/components/Customs/SyCheckbox/SyCheckbox.d.ts

@@ -1,36 +1,5 @@
-import { nextTick } from 'vue';
-import { ValidationRule } from '../../../composables/validation/useValidation';
-type __VLS_Props = {
-    modelValue?: boolean | null;
-    indeterminate?: boolean;
-    label?: string;
-    ariaLabel?: string;
-    ariaLabelledby?: string;
-    title?: string;
-    color?: string;
-    disabled?: boolean;
-    readonly?: boolean;
-    required?: boolean;
-    hideDetails?: boolean | 'auto';
-    density?: 'default' | 'comfortable' | 'compact';
-    errorMessages?: string[] | null;
-    warningMessages?: string[] | null;
-    successMessages?: string[] | null;
-    customRules?: ValidationRule[];
-    customWarningRules?: ValidationRule[];
-    customSuccessRules?: ValidationRule[];
-    showSuccessMessages?: boolean;
-    isValidateOnBlur?: boolean;
-    disableErrorHandling?: boolean;
-    id?: string;
-    name?: string;
-    value?: unknown;
-    trueValue?: unknown;
-    falseValue?: unknown;
-    controlsIds?: string[];
-    displayAsterisk?: boolean;
-    decorative?: boolean;
-};
+import { nextTick, Ref } from 'vue';
+import { SyCheckboxProps } from './types';
 declare function __VLS_template(): {
     attrs: Partial<{}>;
     slots: {
@@ -634,27 +603,17 @@ declare function __VLS_template(): {
     rootEl: HTMLDivElement;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {
-    validation: {
-        errors: import('vue').Ref<string[], string[]>;
-        warnings: import('vue').Ref<string[], string[]>;
-        successes: import('vue').Ref<string[], string[]>;
-        displaySuccesses: import('vue').ComputedRef<string[]>;
-        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 | Promise<import('../../../composables/validation/useValidation').ValidationResult>;
-        validateOnSubmit: () => boolean;
-        clearValidation: () => void;
-    };
+declare const __VLS_component: import('vue').DefineComponent<SyCheckboxProps, {
     validateOnSubmit: () => Promise<boolean>;
-    checkErrorOnBlur: () => void;
+    clearValidation: () => void;
+    reset: () => void;
+    checkErrorOnBlur: () => Promise<boolean>;
     toggleMixed: () => void;
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     change: (...args: any[]) => void;
     "update:modelValue": (...args: any[]) => void;
     "update:indeterminate": (...args: any[]) => void;
-}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+}, string, import('vue').PublicProps, Readonly<SyCheckboxProps> & Readonly<{
     onChange?: ((...args: any[]) => any) | undefined;
     "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
     "onUpdate:indeterminate"?: ((...args: any[]) => any) | undefined;
@@ -677,10 +636,16 @@ declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {
     showSuccessMessages: boolean;
     disableErrorHandling: boolean;
     errorMessages: string[] | null;
-    customRules: ValidationRule[];
-    customWarningRules: ValidationRule[];
-    customSuccessRules: ValidationRule[];
+    maxErrors: number;
+    hasError: boolean;
+    hasWarning: boolean;
+    hasSuccess: boolean;
+    useVuetifyValidation: boolean;
+    customRules: import('../../../composables/unifyValidation/useValidation').ValidationRule[];
+    customWarningRules: import('../../../composables/unifyValidation/useValidation').ValidationRule[];
+    customSuccessRules: import('../../../composables/unifyValidation/useValidation').ValidationRule[];
     displayAsterisk: boolean;
+    helpText: string;
     hideDetails: boolean | "auto";
     isValidateOnBlur: boolean;
     successMessages: string[] | null;

package/dist/components/Customs/SyCheckbox/composables/useSyCheckboxValidation.d.ts

@@ -0,0 +1,27 @@
+import { ComputedRef, Ref } from 'vue';
+import { ValidationRule } from '../../../../composables/unifyValidation/useValidation';
+import { SyCheckboxValidationProps } from '../types';
+export interface UseSyCheckboxValidationReturn {
+    validate: () => Promise<boolean>;
+    validateOnSubmit: () => Promise<boolean>;
+    clearValidation: () => void;
+    errors: Ref<string[]>;
+    warnings: Ref<string[]>;
+    successes: Ref<string[]>;
+    hasError: ComputedRef<boolean | undefined>;
+    hasWarning: ComputedRef<boolean | undefined>;
+    hasSuccess: ComputedRef<boolean | undefined>;
+    defaultRules: ComputedRef<ValidationRule[]>;
+    focused: Ref<boolean>;
+}
+/**
+ * Composable de validation du composant SyCheckbox
+ *
+ * Version simplifiée du système unifié : pour une case à cocher, « required » signifie
+ * que la case doit être cochée (`value === true`). On utilise donc une règle `custom`
+ * plutôt que la règle `required` générique, qui considère `false` comme une valeur valide.
+ *
+ * @example
+ * const { validate, errors, hasError } = useSyCheckboxValidation(props, model, focused)
+ */
+export declare function useSyCheckboxValidation(props: SyCheckboxValidationProps, model: Ref<boolean | null>, focused?: Ref<boolean>): UseSyCheckboxValidationReturn;

package/dist/components/Customs/SyCheckbox/types.d.ts

@@ -0,0 +1,49 @@
+import { FieldValidationProps, ValidationRule, VuetifyValidationRule } from '../../../composables/unifyValidation/useValidation';
+/**
+ * Props du composant SyCheckbox
+ */
+export interface SyCheckboxProps extends FieldValidationProps {
+    modelValue?: boolean | null;
+    indeterminate?: boolean;
+    label?: string;
+    helpText?: string;
+    ariaLabel?: string;
+    ariaLabelledby?: string;
+    title?: string;
+    color?: string;
+    hideDetails?: boolean | 'auto';
+    density?: 'default' | 'comfortable' | 'compact';
+    id?: string;
+    name?: string;
+    value?: unknown;
+    trueValue?: unknown;
+    falseValue?: unknown;
+    controlsIds?: string[];
+    displayAsterisk?: boolean;
+    decorative?: boolean;
+}
+/**
+ * Props de validation passées au composable dédié
+ */
+export interface SyCheckboxValidationProps extends FieldValidationProps {
+    modelValue?: boolean | null;
+    required?: boolean;
+    readonly?: boolean;
+    disabled?: boolean;
+    label?: string;
+    customRules?: ValidationRule[];
+    customWarningRules?: ValidationRule[];
+    customSuccessRules?: ValidationRule[];
+    isValidateOnBlur?: boolean;
+    showSuccessMessages?: boolean;
+    useVuetifyValidation?: boolean;
+    rules?: VuetifyValidationRule[];
+    errorMessages?: string[] | null;
+    warningMessages?: string[] | null;
+    successMessages?: string[] | null;
+    hasError?: boolean;
+    hasWarning?: boolean;
+    hasSuccess?: boolean;
+    maxErrors?: number;
+    disableErrorHandling?: boolean;
+}

package/dist/components/Customs/SyTextField/FieldState.d.ts

@@ -0,0 +1,5 @@
+type __VLS_Props = {
+    state?: 'default' | 'error' | 'success' | 'warning';
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/Customs/SyTextField/useSyTextFieldValidation.d.ts

@@ -26,13 +26,13 @@ export declare function useSyTextFieldValidation(params: {
     errors: import('vue').ComputedRef<string[]>;
     warnings: import('vue').ComputedRef<string[]>;
     successes: import('vue').ComputedRef<string[]>;
-    hasError: import('vue').ComputedRef<boolean | undefined>;
-    hasWarning: import('vue').ComputedRef<boolean | undefined>;
+    hasError: import('vue').ComputedRef<boolean>;
+    hasWarning: import('vue').ComputedRef<boolean>;
     hasSuccess: import('vue').ComputedRef<boolean>;
     iconColor: import('vue').ComputedRef<"success" | "warning" | "error" | "rgba(0, 0, 0, 1)">;
     clearButtonColorClass: import('vue').ComputedRef<string>;
-    validationIcon: import('vue').ComputedRef<string | null>;
     hasMessages: import('vue').ComputedRef<boolean>;
+    state: import('vue').ComputedRef<"default" | "success" | "warning" | "error">;
     validate: () => Promise<boolean>;
     clearValidation: () => void;
 };

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

@@ -9,6 +9,7 @@ type __VLS_Props = {
     autofocusValidateBtn?: boolean;
     draggable?: boolean;
     headingLevel?: 1 | 2 | 3 | 4 | 5 | 6;
+    scrollable?: boolean;
 } & CustomizableOptions;
 type __VLS_PublicProps = {
     modelValue?: boolean;
@@ -504,6 +505,7 @@ declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps,
     width: string;
     headingLevel: 1 | 2 | 3 | 4 | 5 | 6;
     persistent: boolean;
+    scrollable: boolean;
     cancelBtnText: string;
     confirmBtnText: string;
     hideActions: boolean;

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

@@ -5,4 +5,5 @@ export declare const locales: {
     draggable: string;
     dragInstruction: string;
     dragInstructionLabel: string;
+    scrollableContent: string;
 };

package/dist/components/FilterSideBar/FilterSideBar.d.ts

@@ -5,6 +5,8 @@ type __VLS_Props = {
     modale?: boolean;
     locales?: typeof defaultLocales;
     zIndex?: number;
+    title?: string;
+    headingLevel?: 1 | 2 | 3 | 4 | 5 | 6;
 };
 declare function __VLS_template(): {
     attrs: Partial<{}>;
@@ -439,6 +441,8 @@ declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}
 }, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
     "onUpdate:modelValue"?: ((value: FilterProp) => any) | undefined;
 }>, {
+    title: string;
+    headingLevel: 1 | 2 | 3 | 4 | 5 | 6;
     locales: typeof defaultLocales;
     modelValue: FilterProp;
     zIndex: number;