diff --git a/package.json b/package.json
index 03e8b20c4..c30e221a8 100755
--- a/package.json
+++ b/package.json
@@ -106,6 +106,7 @@
     "@testing-library/react": "^12.1.5",
     "@types/node": "^18.11.9",
     "@types/react": "^18.0.1",
+    "@types/validator": "^13.9.0",
     "@typescript-eslint/eslint-plugin": "^5.44.0",
     "@typescript-eslint/parser": "^5.44.0",
     "babel-loader": "^8.2.5",
diff --git a/src/components/forms/FormSchema/FormSchema.types.ts b/src/components/forms/FormSchema/FormSchema.types.ts
index 3630e3238..ead364861 100644
--- a/src/components/forms/FormSchema/FormSchema.types.ts
+++ b/src/components/forms/FormSchema/FormSchema.types.ts
@@ -2,100 +2,211 @@ import { RadioTypes } from 'src/components/utils/Inputs/Radio/Radio.types';
 import { FilterConstant } from 'src/constants';
 import { AnyCantFix, AnyToFix } from 'src/utils/Types';
 
-export const InputComponents = [
-  'datepicker',
-  'text-input',
-  'tel-input',
-  'textarea',
-  'checkbox',
+const FormComponents = {
+  DATEPICKER: 'datepicker',
+  TEXT_INPUT: 'text-input',
+  TEL_INPUT: 'tel-input',
+  TEXTAREA: 'textarea',
+  CHECKBOX: 'checkbox',
+  SELECT_SIMPLE: 'select-simple',
+  SELECT: 'select',
+  SELECT_CREATABLE: 'select-creatable',
+  SELECT_ASYNC: 'select-async',
+  RADIO: 'radio',
+  RADIO_ASYNC: 'radio-async',
+  HEADING: 'heading',
+  TEXT: 'text',
+  FIELDGROUP: 'fieldgroup',
+  MULTIPLE_FIELDS: 'multiple-fields',
+} as const;
+
+export type FormComponent =
+  (typeof FormComponents)[keyof typeof FormComponents];
+
+export type FieldValue =
+  | string
+  | boolean
+  | number
+  | FilterConstant
+  | FilterConstant[];
+
+type MultiFilterConstant<M extends boolean> = M extends true
+  ? FilterConstant[]
+  : FilterConstant;
+
+interface FormComponentValues<M extends boolean>
+  extends Record<FormComponent, FieldValue> {
+  [FormComponents.DATEPICKER]: string;
+  [FormComponents.TEXT_INPUT]: string;
+  [FormComponents.TEL_INPUT]: string;
+  [FormComponents.TEXTAREA]: string;
+  [FormComponents.CHECKBOX]: boolean;
+  [FormComponents.SELECT_SIMPLE]: string | number;
+  [FormComponents.SELECT]: MultiFilterConstant<M>;
+  [FormComponents.SELECT_CREATABLE]: MultiFilterConstant<M>;
+  [FormComponents.SELECT_ASYNC]: MultiFilterConstant<M>;
+  [FormComponents.RADIO]: string | number;
+  [FormComponents.RADIO_ASYNC]: string | number;
+}
+
+export const TextInputComponents = [
+  FormComponents.DATEPICKER,
+  FormComponents.TEXT_INPUT,
+  FormComponents.TEL_INPUT,
+  FormComponents.TEXTAREA,
+] as const;
+
+export type TextInputComponent = (typeof TextInputComponents)[number];
+
+export const CheckBoxComponents = [FormComponents.CHECKBOX] as const;
+
+export type CheckBoxComponent = (typeof CheckBoxComponents)[number];
+export const SelectRequestComponents = [
+  FormComponents.SELECT,
+  FormComponents.SELECT_CREATABLE,
+  FormComponents.SELECT_ASYNC,
 ] as const;
 
-export type InputComponent = (typeof InputComponents)[number];
+export type SelectRequestComponent = (typeof SelectRequestComponents)[number];
 
 export const SelectComponents = [
-  'select-simple',
-  'select',
-  'select-creatable',
-  'select-async',
-  'radio',
-  'radio-async',
+  FormComponents.SELECT_SIMPLE,
+  FormComponents.RADIO,
+  FormComponents.RADIO_ASYNC,
 ] as const;
+
 export type SelectComponent = (typeof SelectComponents)[number];
 
-export const TextComponents = ['heading', 'text'] as const;
+export const TextComponents = [
+  FormComponents.HEADING,
+  FormComponents.TEXT,
+] as const;
 export type TextComponent = (typeof TextComponents)[number];
 
-export const GroupComponents = ['fieldgroup'] as const;
+export const GroupComponents = [FormComponents.FIELDGROUP] as const;
 export type GroupComponent = (typeof GroupComponents)[number];
 
-export const MultipleComponents = ['multiple-fields'] as const;
+export const MultipleComponents = [FormComponents.MULTIPLE_FIELDS] as const;
 
 export type MultipleComponent = (typeof MultipleComponents)[number];
 
-export type FormComponent =
-  | InputComponent
+type InputComponent =
+  | TextInputComponent
+  | CheckBoxComponent
   | SelectComponent
-  | TextComponent
-  | GroupComponent
-  | MultipleComponent;
+  | SelectRequestComponent;
 
 interface FormFieldCommonProperties {
   id: string;
   name: string;
 }
 
-interface FormFieldInputCommonProperties extends FormFieldCommonProperties {
+interface FormTypes {
+  test: string;
+}
+
+export type FormType = keyof FormTypes;
+
+// export type GetValueType<K extends FormType> = (name: K) => FormTypes[K];
+export type GetValueType = (name: string) => AnyToFix;
+
+interface Rule<T extends InputComponent, M extends boolean> {
+  method: (
+    fieldValue: FormComponentValues<M>[T],
+    fieldValues: { [K in FormType]: FormTypes[K] }
+  ) => boolean;
+  args?: AnyToFix[];
+  message: string;
+}
+
+interface FormFieldInputCommonProperties<
+  T extends InputComponent,
+  M extends boolean = false
+> extends FormFieldCommonProperties {
   isRequired?: boolean;
-  title:
-    | string
-    | JSX.Element
-    | ((getValue: (name: string) => AnyToFix) => string);
+  rules?: Rule<T, M>[];
+  title: string | JSX.Element | ((getValue: GetValueType) => string);
   disabled?: boolean;
-  disable?: (getValue: (name: string) => AnyToFix) => boolean;
+  disable?: (getValue: GetValueType) => boolean;
   hidden?: boolean;
-  hide?: (
-    getValue: (name: string) => AnyToFix,
-    fieldOptions?: AnyToFix
-  ) => boolean;
+  hide?: (getValue: GetValueType, fieldOptions?: AnyToFix) => boolean;
   placeholder?: string;
   showLabel?: boolean;
 }
 
-export interface FormFieldInput extends FormFieldInputCommonProperties {
-  component: InputComponent;
+export interface FormFieldTextInput
+  extends FormFieldInputCommonProperties<TextInputComponent> {
+  component: TextInputComponent;
   type?: 'text' | 'email' | 'password';
   rows?: number;
   maxLines?: { lines: number; width: number };
+  maxLength?: number;
   min?: string;
   max?: string;
 }
 
-export interface FormFieldSelect<T extends FilterConstant[] = AnyCantFix>
-  extends FormFieldInputCommonProperties {
+export interface FormFieldCheckBox
+  extends FormFieldInputCommonProperties<CheckBoxComponent> {
+  component: CheckBoxComponent;
+}
+
+export interface FormFieldSelect<K extends FilterConstant[] = AnyToFix>
+  extends FormFieldInputCommonProperties<SelectComponent> {
   component: SelectComponent;
-  dynamicFilter?: (getValue: (name: string) => AnyToFix) => string;
+  dynamicFilter?: (getValue: GetValueType) => string;
   fieldsToReset?: string[];
-  options?: T;
+  options?: K;
   loadOptions?: (
     callback: (options: FilterConstant[] | RadioTypes[]) => void,
     inputValue?: string,
-    getValue?: (name: string) => AnyToFix
+    getValue?: GetValueType
   ) => Promise<void> | void;
-  isMulti?: boolean | ((getValue: (name: string) => AnyToFix) => boolean);
-  openMenuOnClick?: boolean;
   errorMessage?: string;
   limit?: number;
 }
+export interface FormFieldSelectRequestCommon<
+  K extends FilterConstant[],
+  M extends boolean
+> extends FormFieldInputCommonProperties<SelectRequestComponent, M> {
+  component: SelectRequestComponent;
+  fieldsToReset?: string[];
+  options?: K;
+  loadOptions?: (
+    callback: (options: FilterConstant[] | RadioTypes[]) => void,
+    inputValue?: string,
+    getValue?: GetValueType
+  ) => Promise<void> | void;
+  openMenuOnClick?: boolean;
+  isMulti?: boolean | ((getValue: (name: string) => AnyToFix) => boolean);
+}
+
+// TODO fix type depending on is Multi
+interface FormFieldSelectRequestMulti<K extends FilterConstant[]>
+  extends FormFieldSelectRequestCommon<K, true> {
+  isMulti?: true;
+}
+
+interface FormFieldSelectRequestSingle<K extends FilterConstant[]>
+  extends FormFieldSelectRequestCommon<K, false> {
+  isMulti?: false;
+}
+
+export type FormFieldSelectRequest<K extends FilterConstant[] = AnyToFix> =
+  | FormFieldSelectRequestMulti<K>
+  | FormFieldSelectRequestSingle<K>
+
+export type FormFieldInput =
+  | FormFieldTextInput
+  | FormFieldCheckBox
+  | FormFieldSelect
+  | FormFieldSelectRequest;
 
 export interface FormFieldText extends FormFieldCommonProperties {
   id: string;
   name: string;
-  title: string | ((getValue: (name: string) => AnyToFix) => string);
+  title: string | ((getValue: GetValueType) => string);
   component: TextComponent;
-  hide?: (
-    getValue: (name: string) => AnyToFix,
-    fieldOptions?: AnyToFix
-  ) => boolean;
+  hide?: (getValue: GetValueType, fieldOptions?: AnyToFix) => boolean;
   hidden?: boolean;
 }
 
@@ -104,29 +215,42 @@ export interface FormFieldMultiple extends FormFieldCommonProperties {
   name: string;
   action: string;
   component: MultipleComponent;
-  fields: (FormFieldInput | FormFieldSelect)[];
-  hide?: (getValue: (name: string) => AnyToFix) => boolean;
+  fields: FormFieldInput[];
+  hide?: (getValue: GetValueType) => boolean;
   hidden?: boolean;
 }
 
 export interface FormFieldGroup extends FormFieldCommonProperties {
   component: GroupComponent;
-  fields: (FormFieldInput | FormFieldSelect | FormFieldText)[];
-  hide?: (getValue: (name: string) => AnyToFix) => boolean;
+  fields: (FormFieldInput | FormFieldText)[];
+  hide?: (getValue: GetValueType) => boolean;
   hidden?: boolean;
 }
 
 export type FormField =
   | FormFieldInput
-  | FormFieldSelect
   | FormFieldText
   | FormFieldMultiple
   | FormFieldGroup;
 
-interface FormRule {}
-
 export interface FormSchema {
   id: string;
   fields: FormField[];
-  rules: AnyToFix; // to be typed
 }
+
+const test: FormFieldSelectRequest = {
+  component: undefined,
+  id: '',
+  name: '',
+  options: undefined,
+  title: undefined,
+  isMulti: true,
+  rules: [
+    {
+      method: (fieldValue) => {
+        return true;
+      },
+      message: 'oui',
+    },
+  ],
+};
diff --git a/src/components/forms/FormSchema/FormSchema.utils.ts b/src/components/forms/FormSchema/FormSchema.utils.ts
index b2837f342..7883bb649 100644
--- a/src/components/forms/FormSchema/FormSchema.utils.ts
+++ b/src/components/forms/FormSchema/FormSchema.utils.ts
@@ -1,31 +1,52 @@
 import {
+  CheckBoxComponent,
+  CheckBoxComponents,
   FormComponent,
   FormField,
+  FormFieldCheckBox,
   FormFieldGroup,
-  FormFieldInput,
   FormFieldMultiple,
-  FormFieldSelect,
+  FormFieldSelect, FormFieldSelectRequest,
   FormFieldText,
+  FormFieldTextInput,
   GroupComponent,
   GroupComponents,
-  InputComponent,
-  InputComponents,
   MultipleComponent,
   MultipleComponents,
   SelectComponent,
   SelectComponents,
+  SelectRequestComponent,
+  SelectRequestComponents,
   TextComponent,
   TextComponents,
-} from './FormSchema.types';
+  TextInputComponent,
+  TextInputComponents
+} from "./FormSchema.types";
 
-export function isFormFieldInput(field: FormField): field is FormFieldInput {
-  return InputComponents.includes(field.component as InputComponent);
+export function isFormFieldTextInput(
+  field: FormField
+): field is FormFieldTextInput {
+  return TextInputComponents.includes(field.component as TextInputComponent);
+}
+
+export function isFormFieldCheckbox(
+  field: FormField
+): field is FormFieldCheckBox {
+  return CheckBoxComponents.includes(field.component as CheckBoxComponent);
 }
 
 export function isFormFieldSelect(field: FormField): field is FormFieldSelect {
   return SelectComponents.includes(field.component as SelectComponent);
 }
 
+export function isFormFieldSelectRequest(
+  field: FormField
+): field is FormFieldSelectRequest {
+  return SelectRequestComponents.includes(
+    field.component as SelectRequestComponent
+  );
+}
+
 export function isFormFieldText(field: FormField): field is FormFieldText {
   return TextComponents.includes(field.component as TextComponent);
 }
diff --git a/src/components/forms/FormWithValidation.tsx b/src/components/forms/FormWithValidation.tsx
index 663650a36..77f5b013f 100644
--- a/src/components/forms/FormWithValidation.tsx
+++ b/src/components/forms/FormWithValidation.tsx
@@ -17,13 +17,12 @@ import {
   ComponentException,
   FormSchema,
   isFormFieldGroup,
-  isFormFieldInput,
+  isFormFieldTextInput,
   isFormFieldMultiple,
   isFormFieldSelect,
   isFormFieldText,
 } from './FormSchema';
 import { StyledForm } from './Forms.styles';
-import { reformat } from './schemas/script';
 
 interface FormWithValidationProps {
   defaultValues?: AnyToFix; // to be typed
@@ -53,8 +52,8 @@ export const FormWithValidation = forwardRef<
     },
     ref
   ) => {
-    reformat(formSchema);
-    const { id: formId, rules, fields } = formSchema;
+    const { id: formId, fields } = formSchema;
+
     const [error, setError] = useState<string>();
     const [fieldOptions, setFieldOptions] = useState({});
 
@@ -167,6 +166,7 @@ export const FormWithValidation = forwardRef<
                                 typeof childrenField.title === 'function'
                                   ? childrenField.title(getValues)
                                   : childrenField.title;
+
                               if (childrenField.component === 'text') {
                                 return (
                                   <Text
@@ -230,7 +230,7 @@ export const FormWithValidation = forwardRef<
                 }
               }
 
-              if (isFormFieldInput(field) || isFormFieldSelect(field)) {
+              if (isFormFieldTextInput(field) || isFormFieldSelect(field)) {
                 return (
                   <li key={i}>
                     <GenericField
diff --git a/src/components/forms/fields/GenericField.tsx b/src/components/forms/fields/GenericField.tsx
index a66de85e7..7d7dd6637 100644
--- a/src/components/forms/fields/GenericField.tsx
+++ b/src/components/forms/fields/GenericField.tsx
@@ -6,39 +6,35 @@ import {
   UseFormWatch,
 } from 'react-hook-form';
 
-import {
-  FormFieldInput,
-  FormFieldSelect,
-} from '../FormSchema/FormSchema.types';
 import {
   ComponentException,
-  isFormFieldInput,
+  FormFieldInput,
+  GetValueType,
   isFormFieldSelect,
-} from '../FormSchema/FormSchema.utils';
+  isFormFieldSelectRequest,
+  isFormFieldTextInput,
+} from '../FormSchema';
 import {
   CheckBox,
   DatePicker,
   PhoneInput,
   Radio,
   RadioAsync,
-  SelectSimple,
   Select,
   SelectAsync,
-  TextArea,
   SelectCreatable,
+  SelectSimple,
+  TextArea,
   TextInput,
 } from 'src/components/utils/Inputs';
 import { CommonInputProps } from 'src/components/utils/Inputs/Inputs.types';
 
-import { FilterConstant } from 'src/constants';
 import { AnyToFix } from 'src/utils/Types';
 
 interface GenericFieldProps {
-  field: FormFieldInput | FormFieldSelect;
+  field: FormFieldInput;
   formId: string;
-  getValue: (
-    name: string
-  ) => FilterConstant | FilterConstant[] | string | boolean;
+  getValue: GetValueType;
   fieldOptions?: AnyToFix;
   updateFieldOptions?: (newFieldOption?: { [K in string]: AnyToFix }) => void;
   control: Control;
@@ -56,20 +52,33 @@ export const GenericField = ({
   resetField,
   watch,
 }: GenericFieldProps) => {
+  const rules = field.rules?.reduce((acc, curr, index) => {
+    return {
+      ...acc,
+      [`rule${index}`]: curr.method,
+    };
+  }, {});
+
   const {
     field: { onChange, onBlur, value, name, ref },
     fieldState: { error },
   } = useController({
     name: field.name,
     control,
-    rules: { required: !field.isRequired ? 'Obligatoire' : false },
+    rules: {
+      required: field.isRequired ? 'Obligatoire' : false,
+      ...(isFormFieldTextInput(field) && field.maxLength
+        ? { maxLength: field.maxLength }
+        : {}),
+      validate: rules || {},
+    },
   });
 
   watch();
 
   const onChangeCustom = useCallback(
     (updatedValue) => {
-      if (isFormFieldSelect(field)) {
+      if (isFormFieldSelect(field) || isFormFieldSelectRequest(field)) {
         if (field.fieldsToReset) {
           for (let i = 0; i < field.fieldsToReset.length; i += 1) {
             resetField(field.fieldsToReset[i]);
@@ -113,29 +122,33 @@ export const GenericField = ({
     return null;
   }
 
-  if (isFormFieldInput(field)) {
-    if (field.component === 'datepicker') {
-      return <DatePicker {...commonProps} min={field.min} max={field.max} />;
-    }
+  if (field.component === 'datepicker') {
+    return <DatePicker {...commonProps} min={field.min} max={field.max} />;
+  }
 
-    if (field.component === 'text-input') {
-      return <TextInput {...commonProps} type={field.type} />;
-    }
+  if (field.component === 'text-input') {
+    return <TextInput {...commonProps} type={field.type} />;
+  }
 
-    if (field.component === 'tel-input') {
-      return <PhoneInput {...commonProps} />;
-    }
+  if (field.component === 'tel-input') {
+    return <PhoneInput {...commonProps} />;
+  }
 
-    if (field.component === 'textarea') {
-      return <TextArea {...commonProps} maxLines={field.maxLines} />;
-    }
+  if (field.component === 'textarea') {
+    return <TextArea {...commonProps} maxLines={field.maxLines} />;
+  }
 
-    if (field.component === 'checkbox') {
-      return <CheckBox {...commonProps} value={value} />;
-    }
+  if (field.component === 'checkbox') {
+    return <CheckBox {...commonProps} value={value} />;
   }
 
-  if (isFormFieldSelect(field)) {
+  if (field.component === 'select-simple') {
+    const { options } = field;
+
+    return <SelectSimple {...commonProps} options={options} />;
+  }
+
+  if (isFormFieldSelectRequest(field)) {
     const isMultiDefined = field.isMulti || false;
 
     const isMulti =
@@ -143,12 +156,6 @@ export const GenericField = ({
         ? isMultiDefined(getValue)
         : isMultiDefined;
 
-    if (field.component === 'select-simple') {
-      const { options } = field;
-
-      return <SelectSimple {...commonProps} options={options} />;
-    }
-
     if (field.component === 'select') {
       return (
         <Select
@@ -183,36 +190,32 @@ export const GenericField = ({
         />
       );
     }
+  }
 
-    if (field.component === 'radio') {
-      return (
-        <Radio
-          {...commonProps}
-          options={field.options}
-          filter={field.dynamicFilter(getValue)}
-          hidden={
-            field.hide ? field.hide(getValue, fieldOptions) : field.hidden
-          }
-        />
-      );
-    }
+  if (field.component === 'radio') {
+    return (
+      <Radio
+        {...commonProps}
+        options={field.options}
+        filter={field.dynamicFilter(getValue)}
+        hidden={field.hide ? field.hide(getValue, fieldOptions) : field.hidden}
+      />
+    );
+  }
 
-    if (field.component === 'radio-async') {
-      return (
-        <RadioAsync
-          {...commonProps}
-          loadOptions={async (callback) => {
-            const radioOptions = await field.loadOptions(callback);
-            updateFieldOptions({ [field.id]: radioOptions });
-            return radioOptions;
-          }}
-          filter={field.dynamicFilter(getValue)}
-          hidden={
-            field.hide ? field.hide(getValue, fieldOptions) : field.hidden
-          }
-        />
-      );
-    }
+  if (field.component === 'radio-async') {
+    return (
+      <RadioAsync
+        {...commonProps}
+        loadOptions={async (callback) => {
+          const radioOptions = await field.loadOptions(callback);
+          updateFieldOptions({ [field.id]: radioOptions });
+          return radioOptions;
+        }}
+        filter={field.dynamicFilter(getValue)}
+        hidden={field.hide ? field.hide(getValue, fieldOptions) : field.hidden}
+      />
+    );
   }
 
   throw new ComponentException(field.component);
diff --git a/src/components/forms/fields/MultipleFields/MultipleFields.tsx b/src/components/forms/fields/MultipleFields/MultipleFields.tsx
index 0b763e317..cb6412df3 100644
--- a/src/components/forms/fields/MultipleFields/MultipleFields.tsx
+++ b/src/components/forms/fields/MultipleFields/MultipleFields.tsx
@@ -10,6 +10,7 @@ import { InputsContainer } from '../InputsContainer';
 import {
   FormFieldInput,
   FormFieldSelect,
+  GetValueType,
 } from 'src/components/forms/FormSchema/FormSchema.types';
 import { Button, ButtonIcon, Icon } from 'src/components/utils';
 import { useMount } from 'src/hooks/utils';
@@ -26,7 +27,7 @@ interface MultipleFieldsProps {
   action?: string;
   fields: (FormFieldInput | FormFieldSelect)[];
   name: string;
-  getValue: (name: string) => AnyToFix;
+  getValue: GetValueType;
   control: Control;
   resetField: UseFormResetField<AnyToFix>;
   watch: UseFormWatch<AnyToFix>;
diff --git a/src/components/forms/schemas/formAddExternalOpportunity.ts b/src/components/forms/schemas/formAddExternalOpportunity.ts
index 32ec77533..272d5813b 100644
--- a/src/components/forms/schemas/formAddExternalOpportunity.ts
+++ b/src/components/forms/schemas/formAddExternalOpportunity.ts
@@ -1,4 +1,4 @@
-import { FormSchema } from '../FormSchema/FormSchema.types';
+import { FormSchema } from '../FormSchema';
 import { CONTRACTS } from 'src/constants';
 import { DEPARTMENTS_FILTERS } from 'src/constants/departements';
 
@@ -108,5 +108,4 @@ export const formAddExternalOpportunityCandidate: FormSchema = {
       title: "Envoyer un mail à votre coach pour l'informer",
     },
   ],
-  rules: [],
 };
diff --git a/src/components/forms/schemas/formAddOrganization.ts b/src/components/forms/schemas/formAddOrganization.ts
index 79fd000f7..65d039cba 100644
--- a/src/components/forms/schemas/formAddOrganization.ts
+++ b/src/components/forms/schemas/formAddOrganization.ts
@@ -1,6 +1,7 @@
 import { isValidPhoneNumber } from 'react-phone-number-input/mobile';
-import { FormSchema } from "../FormSchema";
+import { FormSchema } from '../FormSchema';
 import { ADMIN_ZONES_FILTERS } from 'src/constants/departements';
+import validator from "validator";
 
 export const formAddOrganization: FormSchema = {
   id: 'form-add-organization',
@@ -71,8 +72,7 @@ export const formAddOrganization: FormSchema = {
           method: (fieldValue) => {
             return fieldValue && isValidPhoneNumber(fieldValue, 'FR');
           },
-          args: [],
-          validWhen: true,
+
           message: 'Numéro de téléphone invalide',
         },
       ],
@@ -86,13 +86,10 @@ export const formAddOrganization: FormSchema = {
       isRequired: true,
       rules: [
         {
-          method: 'isEmail',
-          validWhen: true,
+          method: (fieldValue) => validator.isEmail(fieldValue),
           message: 'Adresse e-mail invalide',
         },
       ],
     },
   ],
-  rules: [],
 };
-
diff --git a/src/components/forms/schemas/formAddUser.tsx b/src/components/forms/schemas/formAddUser.tsx
index 731add5c0..69c587dbc 100644
--- a/src/components/forms/schemas/formAddUser.tsx
+++ b/src/components/forms/schemas/formAddUser.tsx
@@ -1,8 +1,10 @@
 import React from 'react';
 import { isValidPhoneNumber } from 'react-phone-number-input/mobile';
+import validator from 'validator';
 import PlusFilledIcon from 'assets/custom/icons/plus-filled.svg';
-import { FormSchema } from '../FormSchema/FormSchema.types';
+import { FormField, FormSchema } from '../FormSchema';
 import { Api } from 'src/api';
+import { FilterConstant } from 'src/constants';
 import { ADMIN_ZONES_FILTERS } from 'src/constants/departements';
 import { COLORS } from 'src/constants/styles';
 import {
@@ -11,6 +13,7 @@ import {
   USER_ROLES_FILTERS,
   RELATED_ROLES,
   EXTERNAL_USER_ROLES,
+  UserRole,
 } from 'src/constants/users';
 import { isRoleIncluded } from 'src/utils/Finding';
 import { formAddOrganization } from './formAddOrganization';
@@ -54,17 +57,10 @@ const addHideMethodAndSuffixToAllFields = (field) => {
   return fieldToReturn;
 };
 
-const mutatedAddOrganizationForm = {
-  fields: formAddOrganization.fields.map(addHideMethodAndSuffixToAllFields),
-  rules: formAddOrganization.rules.map((rule) => {
-    return {
-      ...rule,
-      field: `${rule.field}Organization`,
-    };
-  }),
-};
+const mutatedAddOrganizationFormFields: FormField[] =
+  formAddOrganization.fields.map(addHideMethodAndSuffixToAllFields);
 
-const organizationFieldsNames = mutatedAddOrganizationForm.fields.map(
+const organizationFieldsNames = mutatedAddOrganizationFormFields.map(
   ({ name }) => name
 );
 
@@ -73,10 +69,13 @@ export const formAddUser: FormSchema = {
   fields: [
     {
       id: 'memberInformation',
+      name: 'memberInformation',
       title: 'Information du membre',
       component: 'heading',
     },
     {
+      id: 'userNames',
+      name: 'userNames',
       component: 'fieldgroup',
       fields: [
         {
@@ -84,16 +83,22 @@ export const formAddUser: FormSchema = {
           name: 'firstName',
           component: 'text-input',
           title: 'Prénom *',
+          isRequired: true,
+          maxLength: 80,
         },
         {
           id: 'lastName',
           name: 'lastName',
           component: 'text-input',
           title: 'Nom *',
+          isRequired: true,
+          maxLength: 80,
         },
       ],
     },
     {
+      id: 'userInfo',
+      name: 'userInfo',
       component: 'fieldgroup',
       fields: [
         {
@@ -105,6 +110,7 @@ export const formAddUser: FormSchema = {
             { value: 0, label: 'Homme' },
             { value: 1, label: 'Femme' },
           ],
+          isRequired: true,
         },
         {
           id: 'zone',
@@ -112,10 +118,13 @@ export const formAddUser: FormSchema = {
           title: 'Zone *',
           component: 'select-simple',
           options: ADMIN_ZONES_FILTERS,
+          isRequired: true,
         },
       ],
     },
     {
+      id: 'userPhoneRole',
+      name: 'userPhoneRole',
       component: 'fieldgroup',
       fields: [
         {
@@ -123,6 +132,13 @@ export const formAddUser: FormSchema = {
           name: 'phone',
           component: 'tel-input',
           title: 'Numéro *',
+          isRequired: true,
+          rules: [
+            {
+              method: (fieldValue) => isValidPhoneNumber(fieldValue, 'FR'),
+              message: 'Numéro de téléphone invalide',
+            },
+          ],
         },
         {
           id: 'role',
@@ -131,6 +147,7 @@ export const formAddUser: FormSchema = {
           component: 'select-simple',
           options: USER_ROLES_FILTERS,
           fieldsToReset: ['adminRole', 'userToLinkId', 'organizationId'],
+          isRequired: true,
         },
       ],
     },
@@ -139,8 +156,18 @@ export const formAddUser: FormSchema = {
       name: 'email',
       component: 'text-input',
       title: 'Adresse mail *',
+      isRequired: true,
+      rules: [
+        {
+          method: (fieldValue) => validator.isEmail(fieldValue),
+
+          message: 'Adresse e-mail invalide',
+        },
+      ],
     },
     {
+      id: 'userOrganization',
+      name: 'userOrganization',
       component: 'fieldgroup',
       hide: (getValue) => {
         const role = getValue('role');
@@ -152,7 +179,10 @@ export const formAddUser: FormSchema = {
           name: 'organizationId',
           component: 'select-async',
           hide: (getValue) => {
-            return !isRoleIncluded(EXTERNAL_USER_ROLES, getValue('role'));
+            return !isRoleIncluded(
+              EXTERNAL_USER_ROLES,
+              getValue('role') as UserRole
+            );
           },
           loadOptions: async (callback, inputValue) => {
             const { data: organizations } = await Api.getAllOrganizations({
@@ -175,18 +205,21 @@ export const formAddUser: FormSchema = {
           },
           title: 'Structure partenaire *',
           fieldsToReset: ['userToLinkId', ...organizationFieldsNames],
+          isRequired: true,
         },
         {
           id: 'userToLinkId',
           name: 'userToLinkId',
           component: 'select-async',
-          isMulti: (getValue) => {
+          /* isMulti: (getValue) => {
             const role = getValue('role');
             return role === USER_ROLES.COACH_EXTERNAL;
-          },
+          }, */
           hide: (getValue) => {
-            const role = getValue('role');
-            const organizationId = getValue('organizationId')?.value;
+            const role = getValue('role') as UserRole;
+            const organizationId = (
+              getValue('organizationId') as FilterConstant
+            )?.value;
             return (
               role === USER_ROLES.ADMIN ||
               (isRoleIncluded(EXTERNAL_USER_ROLES, role) && !organizationId) ||
@@ -194,9 +227,11 @@ export const formAddUser: FormSchema = {
             );
           },
           loadOptions: async (callback, inputValue, getValue) => {
-            const role = RELATED_ROLES[getValue('role')];
+            const role = RELATED_ROLES[getValue('role') as string];
 
-            const organizationId = getValue('organizationId')?.value;
+            const organizationId = (
+              getValue('organizationId') as FilterConstant
+            )?.value;
 
             const { data: users } = await Api.getUsersSearch({
               params: {
@@ -216,10 +251,20 @@ export const formAddUser: FormSchema = {
             );
           },
           title: 'Nom du coach ou candidat lié',
+          rules: [
+            {
+              method: (fieldValue) => {
+                return !!fieldValue;
+              },
+              message: 'error',
+            },
+          ],
         },
       ],
     },
     {
+      id: 'adminRoleGroup',
+      name: 'adminRoleGroup',
       component: 'fieldgroup',
       hide: (getValue) => {
         const role = getValue('role');
@@ -235,67 +280,10 @@ export const formAddUser: FormSchema = {
             { value: ADMIN_ROLES.CANDIDATES, label: ADMIN_ROLES.CANDIDATES },
             { value: ADMIN_ROLES.COMPANIES, label: ADMIN_ROLES.COMPANIES },
           ],
+          isRequired: true,
         },
       ],
     },
-    ...mutatedAddOrganizationForm.fields,
-  ],
-  rules: [
-    {
-      field: 'firstName',
-      isRequired: true,
-    },
-    {
-      field: 'lastName',
-      isRequired: true,
-    },
-    {
-      field: 'gender',
-      isRequired: true,
-    },
-    {
-      field: 'role',
-      isRequired: true,
-    },
-    {
-      field: 'email',
-      method: 'isEmail',
-      validWhen: true,
-      message: 'Adresse e-mail invalide',
-    },
-    {
-      field: 'phone',
-      method: (fieldValue) => {
-        return fieldValue && isValidPhoneNumber(fieldValue, 'FR');
-      },
-      args: [],
-      validWhen: true,
-      message: 'Numéro de téléphone invalide',
-    },
-    {
-      field: 'zone',
-      isRequired: true,
-    },
-    {
-      field: 'adminRole',
-      method: (fieldValue, fieldValues) => {
-        return !fieldValue && fieldValues.role === USER_ROLES.ADMIN;
-      },
-      args: [],
-      validWhen: false,
-      message: 'Obligatoire',
-    },
-    {
-      field: 'organizationId',
-      method: (fieldValue, fieldValues) => {
-        return (
-          !fieldValue && isRoleIncluded(EXTERNAL_USER_ROLES, fieldValues.role)
-        );
-      },
-      args: [],
-      validWhen: false,
-      message: 'Obligatoire',
-    },
-    ...mutatedAddOrganizationForm.rules,
+    ...mutatedAddOrganizationFormFields,
   ],
 };
diff --git a/src/components/forms/schemas/formCandidateContact.ts b/src/components/forms/schemas/formCandidateContact.ts
index f9b6014c7..1bc7fa05e 100644
--- a/src/components/forms/schemas/formCandidateContact.ts
+++ b/src/components/forms/schemas/formCandidateContact.ts
@@ -1,6 +1,6 @@
 import { isValidPhoneNumber } from 'react-phone-number-input/mobile';
-import { isEmail } from 'validator';
-import { FormSchema } from '../FormSchema/FormSchema.types';
+import validator from 'validator';
+import { FormSchema } from '../FormSchema';
 import {
   BUSINESS_LINES,
   CANDIDATE_ACCOMMODATIONS_FILTERS,
@@ -21,18 +21,24 @@ export const formCandidateContact: FormSchema = {
       name: 'workerFirstName',
       component: 'text-input',
       title: 'Votre prénom*',
+      isRequired: true,
+      maxLength: 80,
     },
     {
       id: 'workerLastName',
       name: 'workerLastName',
       component: 'text-input',
       title: 'Votre nom*',
+      isRequired: true,
+      maxLength: 80,
     },
     {
       id: 'structure',
       name: 'structure',
       component: 'text-input',
       title: 'Votre structure* (Association, CCAS, EDAS, etc.)',
+      isRequired: true,
+      maxLength: 60,
     },
     {
       id: 'workerPosition',
@@ -46,24 +52,44 @@ export const formCandidateContact: FormSchema = {
       type: 'email',
       component: 'text-input',
       title: 'Votre adresse mail*',
+      isRequired: true,
+      rules: [
+        {
+          method: (fieldValue) => validator.isEmail(fieldValue),
+
+          message: 'Adresse e-mail invalide',
+        },
+      ],
     },
     {
       id: 'workerPhone',
       name: 'workerPhone',
       component: 'tel-input',
       title: 'Votre numéro de téléphone portable*',
+      isRequired: true,
+      rules: [
+        {
+          method: (fieldValue) => isValidPhoneNumber(fieldValue, 'FR'),
+          message: 'Numéro de téléphone invalide',
+        },
+      ],
     },
     {
       id: 'firstName',
       name: 'firstName',
       component: 'text-input',
       title: 'Prénom de la personne que vous souhaitez orienter*',
+      isRequired: true,
+      maxLength: 80,
+
     },
     {
       id: 'lastName',
       name: 'lastName',
       component: 'text-input',
       title: 'Son nom*',
+      isRequired: true,
+      maxLength: 80,
     },
     {
       id: 'helpWith',
@@ -72,6 +98,7 @@ export const formCandidateContact: FormSchema = {
       isMulti: true,
       options: CANDIDATE_HELP_WITH_FILTERS,
       title: "Dans quel(s) domaine(s) l'accompagnez-vous ?*",
+      isRequired: true,
     },
     {
       id: 'gender',
@@ -79,6 +106,7 @@ export const formCandidateContact: FormSchema = {
       component: 'select-simple',
       options: CANDIDATE_GENDERS_FILTERS,
       title: 'Son sexe*',
+      isRequired: true,
     },
     {
       id: 'birthDate',
@@ -100,12 +128,21 @@ export const formCandidateContact: FormSchema = {
       placeholder:
         'La personne doit résider dans les départements 75, 93, 92, 56, 35, 69 ou 59.',
       title: 'Son code postal*',
+      isRequired: true,
+      rules: [
+        {
+          method: (fieldValue) =>
+            validator.isPostalCode(fieldValue, 'FR'),
+          message: 'Code postal non valide',
+        },
+      ],
     },
     {
       id: 'city',
       name: 'city',
       component: 'text-input',
       title: 'Sa ville*',
+      isRequired: true,
     },
     {
       id: 'phone',
@@ -113,6 +150,13 @@ export const formCandidateContact: FormSchema = {
       component: 'tel-input',
       title:
         "Son téléphone portable (nous inviterons la personne à une réunion d'information)*",
+      isRequired: true,
+      rules: [
+        {
+          method: (fieldValue) => isValidPhoneNumber(fieldValue, 'FR'),
+          message: 'Numéro de téléphone invalide',
+        },
+      ],
     },
     {
       id: 'email',
@@ -120,15 +164,28 @@ export const formCandidateContact: FormSchema = {
       type: 'email',
       component: 'text-input',
       title: 'Son adresse mail',
+      rules: [
+        {
+          method: (fieldValue) => {
+            return (
+              !fieldValue ||
+              fieldValue.length === 0 ||
+              validator.isEmail(fieldValue)
+            );
+          },
+
+          message: 'Adresse e-mail invalide',
+        },
+      ],
     },
     {
       id: 'registeredUnemploymentOffice',
       name: 'registeredUnemploymentOffice',
       component: 'select-simple',
       options: CANDIDATE_YES_NO_FILTERS,
-
       title:
         'La personne que vous souhaitez orienter est-elle inscrite au Pôle Emploi ?*',
+      isRequired: true,
     },
     {
       id: 'administrativeSituation',
@@ -144,6 +201,7 @@ export const formCandidateContact: FormSchema = {
       options: CANDIDATE_YES_NO_FILTERS,
       title:
         "A-t-elle l'autorisation de travailler sur le territoire Français ?*",
+      isRequired: true,
     },
     {
       id: 'accommodation',
@@ -151,6 +209,7 @@ export const formCandidateContact: FormSchema = {
       component: 'select-simple',
       options: CANDIDATE_ACCOMMODATIONS_FILTERS,
       title: "Quelle est sa situation d'hébergement ?*",
+      isRequired: true,
     },
     {
       id: 'professionalSituation',
@@ -158,6 +217,7 @@ export const formCandidateContact: FormSchema = {
       component: 'select-simple',
       options: CANDIDATE_PROFESSIONAL_SITUATIONS_FILTERS,
       title: 'Quelle est sa situation professionnelle ?*',
+      isRequired: true,
     },
     {
       id: 'resources',
@@ -173,6 +233,7 @@ export const formCandidateContact: FormSchema = {
       options: CANDIDATE_YES_NO_FILTERS,
       title:
         'A-t-elle une adresse de domiciliation ? Si c\'est la même que celle de son logement, choisir "Oui"*',
+      isRequired: true,
     },
     {
       id: 'socialSecurity',
@@ -181,6 +242,7 @@ export const formCandidateContact: FormSchema = {
       options: CANDIDATE_YES_NO_FILTERS,
       title:
         'A-t-elle des droits ouverts à la sécurité sociale ? (régime général, CSS, CMU, AME, etc.)*',
+      isRequired: true,
     },
     {
       id: 'handicapped',
@@ -196,6 +258,7 @@ export const formCandidateContact: FormSchema = {
       component: 'select-simple',
       options: CANDIDATE_YES_NO_FILTERS,
       title: 'A-t-elle un compte bancaire ?*',
+      isRequired: true,
     },
     {
       id: 'businessLines',
@@ -217,6 +280,7 @@ export const formCandidateContact: FormSchema = {
       name: 'description',
       component: 'textarea',
       title: 'Présentation*',
+      isRequired: true,
     },
     {
       id: 'heardAbout',
@@ -224,6 +288,7 @@ export const formCandidateContact: FormSchema = {
       component: 'select-simple',
       options: HEARD_ABOUT_FILTERS,
       title: 'Comment avez-vous connu LinkedOut ?*',
+      isRequired: true,
     },
     {
       id: 'diagnosticLabel',
@@ -246,192 +311,4 @@ export const formCandidateContact: FormSchema = {
         'Souhaitez-vous être mis en relation avec le/la Coach LinkedOut si besoin et avec l’accord de la personne ?',
     },
   ],
-  rules: [
-    {
-      field: 'workerFirstName',
-      isRequired: true,
-    },
-    {
-      field: 'workerFirstName',
-      method: 'isLength',
-      args: [
-        {
-          max: 80,
-        },
-      ],
-      validWhen: true,
-      message: '80 caractères maximum',
-    },
-    {
-      field: 'workerLastName',
-      isRequired: true,
-    },
-    {
-      field: 'workerLastName',
-      method: 'isLength',
-      args: [
-        {
-          max: 80,
-        },
-      ],
-      validWhen: true,
-      message: '80 caractères maximum',
-    },
-    {
-      field: 'structure',
-      method: 'isLength',
-      args: [
-        {
-          max: 60,
-        },
-      ],
-      validWhen: true,
-      message: '60 caractères maximum',
-    },
-    {
-      field: 'structure',
-      isRequired: true,
-    },
-    {
-      field: 'workerEmail',
-      isRequired: true,
-    },
-    {
-      field: 'workerEmail',
-      method: 'isEmail',
-      validWhen: true,
-      message: 'Adresse e-mail invalide',
-    },
-    {
-      field: 'workerPhone',
-      isRequired: true,
-    },
-    {
-      field: 'workerPhone',
-      method: (fieldValue) => {
-        return (
-          !fieldValue ||
-          fieldValue.length === 0 ||
-          isValidPhoneNumber(fieldValue, 'FR')
-        );
-      },
-      args: [],
-      validWhen: true,
-      message: 'Numéro de téléphone invalide',
-    },
-    {
-      field: 'firstName',
-      isRequired: true,
-    },
-    {
-      field: 'firstName',
-      method: 'isLength',
-      args: [
-        {
-          max: 80,
-        },
-      ],
-      validWhen: true,
-      message: '80 caractères maximum',
-    },
-    {
-      field: 'lastName',
-      isRequired: true,
-    },
-    {
-      field: 'lastName',
-      method: 'isLength',
-      args: [
-        {
-          max: 80,
-        },
-      ],
-      validWhen: true,
-      message: '80 caractères maximum',
-    },
-    {
-      field: 'helpWith',
-      isRequired: true,
-    },
-    {
-      field: 'gender',
-      isRequired: true,
-    },
-    {
-      field: 'postalCode',
-      method: 'isPostalCode',
-      args: ['FR'],
-      validWhen: true,
-      message: 'Obligatoire',
-    },
-    {
-      field: 'postalCode',
-      isRequired: true,
-    },
-    {
-      field: 'city',
-      isRequired: true,
-    },
-    {
-      field: 'phone',
-      isRequired: true,
-    },
-    {
-      field: 'phone',
-      method: (fieldValue) => {
-        return (
-          !fieldValue ||
-          fieldValue.length === 0 ||
-          isValidPhoneNumber(fieldValue, 'FR')
-        );
-      },
-      args: [],
-      validWhen: true,
-      message: 'Numéro de téléphone invalide',
-    },
-    {
-      field: 'email',
-      method: (fieldValue) => {
-        return !fieldValue || fieldValue.length === 0 || isEmail(fieldValue);
-      },
-      validWhen: true,
-      message: 'Adresse e-mail invalide',
-    },
-    {
-      field: 'registeredUnemploymentOffice',
-      isRequired: true,
-    },
-    {
-      field: 'workingRight',
-      isRequired: true,
-    },
-    {
-      field: 'accommodation',
-      isRequired: true,
-    },
-    {
-      field: 'professionalSituation',
-      isRequired: true,
-    },
-    {
-      field: 'domiciliation',
-      isRequired: true,
-    },
-    {
-      field: 'socialSecurity',
-      isRequired: true,
-    },
-    {
-      field: 'bankAccount',
-      isRequired: true,
-    },
-    {
-      field: 'description',
-      isRequired: true,
-    },
-    {
-      field: 'heardAbout',
-      isRequired: true,
-    },
-  ],
 };
diff --git a/src/components/forms/schemas/formCandidateInscription.ts b/src/components/forms/schemas/formCandidateInscription.ts
index 75b32ed92..cfbc005ab 100644
--- a/src/components/forms/schemas/formCandidateInscription.ts
+++ b/src/components/forms/schemas/formCandidateInscription.ts
@@ -3,8 +3,14 @@ import moment from 'moment';
 import { isValidPhoneNumber } from 'react-phone-number-input/mobile';
 import { Api } from 'src/api';
 import 'moment/locale/fr';
-import { ANTENNE_INFO } from 'src/constants';
+import {
+  ANTENNE_INFO,
+  CANDIDATE_YES_NO,
+  CANDIDATE_YES_NO_FILTERS,
+  HEARD_ABOUT_FILTERS,
+} from 'src/constants';
 import { FormSchema } from '../FormSchema';
+import validator from 'validator';
 
 export const formCandidateInscription: FormSchema = {
   id: 'form-candidate-inscription',
@@ -20,6 +26,7 @@ export const formCandidateInscription: FormSchema = {
       name: 'location',
       component: 'select-simple',
       showLabel: true,
+      isRequired: true,
       title:
         'Êtes-vous domicilié dans l’une des villes / départements suivants? *',
       options: [
@@ -57,6 +64,14 @@ export const formCandidateInscription: FormSchema = {
         },
       ],
       fieldsToReset: ['infoCo'],
+      rules: [
+        {
+          method: (value) => value !== CANDIDATE_YES_NO.NO,
+
+          message:
+            'Vous devez avoir le droit de travailler en France pour participer au programme LinkedOut',
+        },
+      ],
     },
     {
       id: 'birthdateWorkingRight',
@@ -68,6 +83,29 @@ export const formCandidateInscription: FormSchema = {
           name: 'birthdate',
           component: 'datepicker',
           title: 'Quelle est votre date de naissance? *',
+          isRequired: true,
+          rules: [
+            {
+              method: (value: string) => {
+                const minBirthdate = new Date();
+                minBirthdate.setFullYear(minBirthdate.getFullYear() - 18);
+                const realBirthdate = new Date(value);
+                return minBirthdate > realBirthdate;
+              },
+
+              message:
+                'Vous devez être majeur pour participer au programme. En attendant, vous pouvez contacter la Mission locale dont dépend votre commune.',
+            },
+            {
+              method: (value: string) => {
+                const maxBirthdate = new Date('1900-01-01');
+                const realBirthdate = new Date(value);
+                return maxBirthdate < realBirthdate;
+              },
+
+              message: 'Veuillez entrer une date valide.',
+            },
+          ],
         },
         {
           id: 'workingRight',
@@ -75,20 +113,22 @@ export const formCandidateInscription: FormSchema = {
           title: 'Avez-vous le droit de travailler en France? *',
           component: 'select-simple',
           showLabel: true,
+          isRequired: true,
           options: [
-            {
-              label: 'Oui',
-              value: 'yes',
-            },
-            {
-              label: 'Non',
-              value: 'no',
-            },
+            ...CANDIDATE_YES_NO_FILTERS,
             {
               label: 'Je ne sais pas',
               value: 'dont_know',
             },
           ],
+          rules: [
+            {
+              method: (value) => value !== CANDIDATE_YES_NO.NO,
+
+              message:
+                'Vous devez avoir le droit de travailler en France pour participer au programme LinkedOut',
+            },
+          ],
         },
       ],
     },
@@ -110,6 +150,8 @@ export const formCandidateInscription: FormSchema = {
           title: 'Votre prénom *',
           placeholder: 'Ecrivez votre prénom',
           showLabel: true,
+          isRequired: true,
+                    maxLength: 80,
         },
         {
           id: 'lastName',
@@ -118,6 +160,8 @@ export const formCandidateInscription: FormSchema = {
           component: 'text-input',
           placeholder: 'Ecrivez votre nom',
           showLabel: true,
+          isRequired: true,
+                    maxLength: 80,
         },
       ],
     },
@@ -133,6 +177,14 @@ export const formCandidateInscription: FormSchema = {
           component: 'tel-input',
           placeholder: 'Ecrivez votre numéro de téléphone',
           showLabel: true,
+          isRequired: true,
+          rules: [
+            {
+              method: (fieldValue) =>
+                isValidPhoneNumber(fieldValue, 'FR'),
+              message: 'Numéro de téléphone invalide',
+            },
+          ],
         },
         {
           id: 'email',
@@ -141,6 +193,13 @@ export const formCandidateInscription: FormSchema = {
           component: 'text-input',
           placeholder: 'Ecrivez votre adresse email',
           showLabel: true,
+          isRequired: true,
+          rules: [
+            {
+              method: (fieldValue) => validator.isEmail(fieldValue),
+              message: 'Adresse e-mail invalide',
+            },
+          ],
         },
       ],
     },
@@ -150,37 +209,8 @@ export const formCandidateInscription: FormSchema = {
       title: 'Comment avez-vous connu LinkedOut ? *',
       component: 'select-simple',
       showLabel: true,
-      // TODO use already existing heard about
-      options: [
-        {
-          label: 'LinkedIn',
-          value: 'LinkedIn',
-        },
-        {
-          label: 'Autres réseaux (facebook, twitter, instagram...)',
-          value: 'socialNetworks',
-        },
-        {
-          label: 'Association / travailleur social',
-          value: 'association',
-        },
-        {
-          label: 'Pôle emploi',
-          value: 'poleEmploi',
-        },
-        {
-          label: 'Le bouche à oreille',
-          value: 'boucheAOreille',
-        },
-        {
-          label: 'Télévision / radio',
-          value: 'medias',
-        },
-        {
-          label: 'Autre',
-          value: 'other',
-        },
-      ],
+      isRequired: true,
+      options: HEARD_ABOUT_FILTERS,
     },
     {
       id: 'infoCoTitle',
@@ -273,121 +303,4 @@ export const formCandidateInscription: FormSchema = {
         'Il n’y a pas de réunion d’information organisée dans les prochains temps dans votre ville, nous allons vous recontacter rapidement',
     },
   ],
-  rules: [
-    {
-      field: 'firstName',
-      isRequired: true,
-    },
-    {
-      field: 'firstName',
-      method: 'isLength',
-      args: [
-        {
-          max: 80,
-        },
-      ],
-      validWhen: true,
-      message: '80 caractères maximum',
-    },
-    {
-      field: 'lastName',
-      isRequired: true,
-    },
-    {
-      field: 'lastName',
-      method: 'isLength',
-      args: [
-        {
-          max: 80,
-        },
-      ],
-      validWhen: true,
-      message: '80 caractères maximum',
-    },
-    {
-      field: 'email',
-      isRequired: true,
-    },
-    {
-      field: 'email',
-      method: 'isEmail',
-      validWhen: true,
-      message: 'Adresse e-mail invalide',
-    },
-    {
-      field: 'phone',
-      isRequired: true,
-    },
-    {
-      field: 'phone',
-      method: (fieldValue) => {
-        return (
-          !fieldValue ||
-          fieldValue.length === 0 ||
-          isValidPhoneNumber(fieldValue, 'FR')
-        );
-      },
-      args: [],
-      validWhen: true,
-      message: 'Numéro de téléphone invalide',
-    },
-    {
-      field: 'workingRight',
-      isRequired: true,
-    },
-    {
-      field: 'workingRight',
-      method: (value) => {
-        return value !== 'no';
-      },
-      args: [],
-      validWhen: true,
-      message:
-        'Vous devez avoir le droit de travailler en France pour participer au programme LinkedOut',
-    },
-    {
-      field: 'heardAbout',
-      isRequired: true,
-    },
-    {
-      field: 'location',
-      isRequired: true,
-    },
-    {
-      field: 'location',
-      method: (value) => {
-        return value !== 'other';
-      },
-      args: [],
-      validWhen: true,
-      message:
-        'Nous sommes désolée, le programme est disponible uniquement dans les villes /départements indiqués dans la liste.',
-    },
-    {
-      field: 'birthdate',
-      isRequired: true,
-    },
-    {
-      field: 'birthdate',
-      method: (value) => {
-        const minBirtdate = new Date();
-        minBirtdate.setFullYear(minBirtdate.getFullYear() - 18);
-        const realBirthdate = new Date(value);
-        return minBirtdate > realBirthdate;
-      },
-      validWhen: true,
-      message:
-        'Vous devez être majeur pour participer au programme. En attendant, vous pouvez contacter la Mission locale dont dépend votre commune.',
-    },
-    {
-      field: 'birthdate',
-      method: (value) => {
-        const maxBirtdate = new Date('1900-01-01');
-        const realBirthdate = new Date(value);
-        return maxBirtdate < realBirthdate;
-      },
-      validWhen: true,
-      message: 'Veuillez entrer une date valide.',
-    },
-  ],
 };
diff --git a/src/components/forms/schemas/formChangePassword.ts b/src/components/forms/schemas/formChangePassword.ts
index ed1413430..69e0c0ec8 100644
--- a/src/components/forms/schemas/formChangePassword.ts
+++ b/src/components/forms/schemas/formChangePassword.ts
@@ -1,5 +1,5 @@
 import { passwordStrength } from 'check-password-strength';
-import { FormSchema } from '../FormSchema/FormSchema.types';
+import { FormSchema } from '../FormSchema';
 
 export const formChangePassword: FormSchema = {
   id: 'form-change-pwd',
@@ -10,6 +10,7 @@ export const formChangePassword: FormSchema = {
       type: 'password',
       component: 'text-input',
       title: 'Ancien mot de passe*',
+      isRequired: true,
     },
     {
       id: 'newPassword',
@@ -17,6 +18,14 @@ export const formChangePassword: FormSchema = {
       type: 'password',
       component: 'text-input',
       title: 'Nouveau mot de passe*',
+      isRequired: true,
+      rules: [
+        {
+          method: (fieldValue) => passwordStrength(fieldValue).id >= 2,
+
+          message: 'Doit répondre aux critères ci-dessus',
+        },
+      ],
     },
     {
       id: 'confirmPassword',
@@ -24,35 +33,18 @@ export const formChangePassword: FormSchema = {
       type: 'password',
       component: 'text-input',
       title: 'Confirmation du mot de passe*',
-    },
-  ],
-  rules: [
-    {
-      field: 'newPassword',
-      method: (fieldValue) => {
-        return passwordStrength(fieldValue).id >= 2;
-      },
-      args: [],
-      validWhen: true,
-      message: 'Doit répondre aux critères ci-dessus',
-    },
-    {
-      field: 'confirmPassword',
-      method: (fieldValue) => {
-        return passwordStrength(fieldValue).id >= 2;
-      },
-      args: [],
-      validWhen: true,
-      message: 'Doit répondre aux critères ci-dessus',
-    },
-    {
-      field: 'confirmPassword',
-      method: (fieldValue, state) => {
-        return state.newPassword === fieldValue;
-      },
-      args: [],
-      validWhen: true,
-      message: 'Les deux mots de passe ne correspondent pas',
+      isRequired: true,
+      rules: [
+        {
+          method: (fieldValue) => passwordStrength(fieldValue).id >= 2,
+          message: 'Doit répondre aux critères ci-dessus',
+        },
+        {
+          method: (fieldValue, fieldValues) =>
+            fieldValues.newPassword === fieldValue,
+          message: 'Les deux mots de passe ne correspondent pas',
+        },
+      ],
     },
   ],
 };
diff --git a/src/components/forms/schemas/formCompanyContact.ts b/src/components/forms/schemas/formCompanyContact.ts
index 6a1bd9a14..9e68f97e4 100644
--- a/src/components/forms/schemas/formCompanyContact.ts
+++ b/src/components/forms/schemas/formCompanyContact.ts
@@ -1,10 +1,11 @@
 import { isValidPhoneNumber } from 'react-phone-number-input/mobile';
-import { FormSchema } from '../FormSchema/FormSchema.types';
+import { FormSchema } from '../FormSchema';
 import {
   COMPANY_APPROACHES_FILTERS,
   COMPANY_CONTACT_ZONES_FILTERS,
   HEARD_ABOUT_FILTERS,
 } from 'src/constants';
+import validator from "validator";
 
 export const formCompanyContact: FormSchema = {
   id: 'form-company-contact',
@@ -14,12 +15,17 @@ export const formCompanyContact: FormSchema = {
       name: 'firstName',
       component: 'text-input',
       title: 'Votre prénom*',
+      isRequired: true,
+      maxLength: 80,
+
     },
     {
       id: 'lastName',
       name: 'lastName',
       component: 'text-input',
       title: 'Votre nom*',
+      isRequired: true,
+      maxLength: 80,
     },
     {
       id: 'approach',
@@ -27,6 +33,7 @@ export const formCompanyContact: FormSchema = {
       component: 'select-simple',
       options: COMPANY_APPROACHES_FILTERS,
       title: 'Quelle est votre démarche ?*',
+      isRequired: true,
     },
     {
       id: 'email',
@@ -34,24 +41,41 @@ export const formCompanyContact: FormSchema = {
       type: 'email',
       component: 'text-input',
       title: 'Votre adresse mail*',
+      isRequired: true,
+      rules: [
+        {
+          method: (fieldValue) => validator.isEmail(fieldValue),
+
+          message: 'Adresse e-mail invalide',
+        },
+      ],
     },
     {
       id: 'phone',
       name: 'phone',
       component: 'tel-input',
       title: 'Votre numéro de téléphone portable*',
+      isRequired: true,
+      rules: [
+        {
+          method: (fieldValue) => isValidPhoneNumber(fieldValue, 'FR'),
+          message: 'Numéro de téléphone invalide',
+        },
+      ],
     },
     {
       id: 'company',
       name: 'company',
       component: 'text-input',
       title: 'Nom de votre entreprise*',
+      isRequired: true,
     },
     {
       id: 'position',
       name: 'position',
       component: 'text-input',
       title: 'Votre poste*',
+      isRequired: true,
     },
     {
       id: 'zone',
@@ -59,6 +83,7 @@ export const formCompanyContact: FormSchema = {
       component: 'select-simple',
       options: COMPANY_CONTACT_ZONES_FILTERS,
       title: 'Dans quelle région êtes-vous présent ?*',
+      isRequired: true,
     },
     {
       id: 'heardAbout',
@@ -68,75 +93,4 @@ export const formCompanyContact: FormSchema = {
       title: 'Comment avez-vous connu LinkedOut ?',
     },
   ],
-  rules: [
-    {
-      field: 'lastName',
-      isRequired: true,
-    },
-    {
-      field: 'lastName',
-      method: 'isLength',
-      args: [
-        {
-          max: 80,
-        },
-      ],
-      validWhen: true,
-      message: '80 caractères maximum',
-    },
-    {
-      field: 'firstName',
-      isRequired: true,
-    },
-    {
-      field: 'firstName',
-      method: 'isLength',
-      args: [
-        {
-          max: 80,
-        },
-      ],
-      validWhen: true,
-      message: '80 caractères maximum',
-    },
-    {
-      field: 'email',
-      isRequired: true,
-    },
-    {
-      field: 'email',
-      method: 'isEmail',
-      validWhen: true,
-      message: 'Adresse e-mail invalide',
-    },
-    {
-      field: 'phone',
-      method: (fieldValue) => {
-        return (
-          !fieldValue ||
-          fieldValue.length === 0 ||
-          isValidPhoneNumber(fieldValue, 'FR')
-        );
-      },
-      args: [],
-      validWhen: true,
-      message: 'Numéro de téléphone invalide',
-    },
-    {
-      field: 'company',
-      isRequired: true,
-    },
-    {
-      field: 'position',
-      isRequired: true,
-    },
-    {
-      field: 'approach',
-      isRequired: true,
-    },
-    {
-      field: 'zone',
-      isRequired: true,
-    },
-  ],
 };
diff --git a/src/components/forms/schemas/formContactUs.ts b/src/components/forms/schemas/formContactUs.ts
deleted file mode 100644
index 495d90bfb..000000000
--- a/src/components/forms/schemas/formContactUs.ts
+++ /dev/null
@@ -1,58 +0,0 @@
-export const formContactUs = {
-  id: 'form-contactus',
-  fields: [
-    {
-      id: 'email',
-      name: 'email',
-      component: 'text-input',
-      type: 'email',
-      title: 'Adresse mail*',
-    },
-    {
-      id: 'text',
-      name: 'text',
-      component: 'textarea',
-      title: 'Message*',
-      rows: 7,
-    },
-    {
-      id: 'cgu',
-      name: 'cgu',
-      component: 'cgu',
-    },
-  ],
-  rules: [
-    {
-      field: 'email',
-      isRequired: true,
-    },
-    {
-      field: 'email',
-      method: 'isEmail',
-      validWhen: true,
-      message: 'Adresse e-mail invalide',
-    },
-    {
-      field: 'text',
-      isRequired: true,
-    },
-    {
-      field: 'text',
-      method: 'isLength',
-      args: [
-        {
-          max: 4000,
-        },
-      ],
-      validWhen: true,
-      message: '4000 caractères maximum',
-    },
-    {
-      field: 'cgu',
-      method: 'equals',
-      args: ['true'],
-      validWhen: true,
-      message: 'Obligatoire',
-    },
-  ],
-};
diff --git a/src/components/forms/schemas/formDeleteUser.ts b/src/components/forms/schemas/formDeleteUser.ts
index 80d727f33..2a4a7dbab 100644
--- a/src/components/forms/schemas/formDeleteUser.ts
+++ b/src/components/forms/schemas/formDeleteUser.ts
@@ -1,4 +1,7 @@
-export const formDeleteUser = {
+import validator from 'validator';
+import { FormSchema } from '../FormSchema';
+
+export const formDeleteUser: FormSchema = {
   id: 'form-delete-user',
   fields: [
     {
@@ -8,16 +11,13 @@ export const formDeleteUser = {
       title:
         'Tapez le mot "SUPPRIMER" pour confirmer la suppression de l\'utilisateur*',
       placeholder: 'Tapez le mot "SUPPRIMER"',
-      autocomplete: 'off',
-    },
-  ],
-  rules: [
-    {
-      field: 'confirmation',
-      method: 'equals',
-      args: ['SUPPRIMER'],
-      validWhen: true,
-      message: 'Obligatoire',
+      isRequired: true,
+      rules: [
+        {
+          method: (fieldValue) => validator.equals(fieldValue, 'SUPPRIMER'),
+          message: 'Confirmation non valide',
+        },
+      ],
     },
   ],
 };
diff --git a/src/components/forms/schemas/formEditCareerPath.ts b/src/components/forms/schemas/formEditCareerPath.ts
index c500b4436..50c4271a1 100644
--- a/src/components/forms/schemas/formEditCareerPath.ts
+++ b/src/components/forms/schemas/formEditCareerPath.ts
@@ -1,4 +1,4 @@
-import { FormSchema } from '../FormSchema/FormSchema.types';
+import { FormSchema } from '../FormSchema';
 import { BUSINESS_LINES } from 'src/constants';
 
 export const formEditCareerPath: FormSchema = {
@@ -15,6 +15,7 @@ export const formEditCareerPath: FormSchema = {
           title: 'Famille de métier 1*',
           component: 'select',
           options: BUSINESS_LINES,
+          isRequired: true,
         },
         {
           id: 'linkWord0',
@@ -41,6 +42,14 @@ export const formEditCareerPath: FormSchema = {
           title: 'Famille de métier 2',
           component: 'select',
           options: BUSINESS_LINES,
+          rules: [
+            {
+              method: (fieldValue, fieldValues) => {
+                return !(!fieldValue && !!fieldValues.ambition1);
+              },
+              message: 'Obligatoire',
+            },
+          ],
         },
         {
           id: 'linkWord1',
@@ -57,19 +66,4 @@ export const formEditCareerPath: FormSchema = {
       ],
     },
   ],
-  rules: [
-    {
-      field: 'businessLine0',
-      isRequired: true,
-    },
-    {
-      field: 'businessLine1',
-      method: (fieldValue, state) => {
-        return !fieldValue && !!state.ambition1;
-      },
-      args: [],
-      validWhen: false,
-      message: 'Obligatoire',
-    },
-  ],
 };
diff --git a/src/components/forms/schemas/formEditCatchphrase.ts b/src/components/forms/schemas/formEditCatchphrase.ts
index 2186f1561..16dab6184 100644
--- a/src/components/forms/schemas/formEditCatchphrase.ts
+++ b/src/components/forms/schemas/formEditCatchphrase.ts
@@ -1,4 +1,4 @@
-import { FormSchema } from '../FormSchema/FormSchema.types';
+import { FormSchema } from '../FormSchema';
 
 export const formEditCatchphrase: FormSchema = {
   id: 'form-catchphrase',
@@ -8,19 +8,7 @@ export const formEditCatchphrase: FormSchema = {
       name: 'catchphrase',
       component: 'text-input',
       title: 'Ce que vous pouvez apporter*',
-    },
-  ],
-  rules: [
-    {
-      field: 'catchphrase',
-      method: 'isLength',
-      args: [
-        {
-          max: 80,
-        },
-      ],
-      validWhen: true,
-      message: '80 caractères maximum',
+      maxLength: 80,
     },
   ],
 };
diff --git a/src/components/forms/schemas/formEditEmployed.ts b/src/components/forms/schemas/formEditEmployed.ts
index 4855a3180..97c16683a 100644
--- a/src/components/forms/schemas/formEditEmployed.ts
+++ b/src/components/forms/schemas/formEditEmployed.ts
@@ -1,5 +1,6 @@
 import moment from 'moment';
-import { FormSchema } from '../FormSchema/FormSchema.types';
+import validator from 'validator';
+import { FormSchema } from '../FormSchema';
 import { CONTRACTS } from 'src/constants';
 import { findConstantFromValue } from 'src/utils';
 
@@ -13,6 +14,7 @@ export const formEditEmployed: FormSchema = {
       component: 'select-simple',
       options: CONTRACTS,
       fieldsToReset: ['endOfContract'],
+      isRequired: true,
     },
     {
       id: 'endOfContract',
@@ -21,22 +23,19 @@ export const formEditEmployed: FormSchema = {
       component: 'datepicker',
       min: moment().format('YYYY-MM-DD'),
       disable: (getValue) => {
-        const contract = findConstantFromValue(getValue('contract'), CONTRACTS);
+        const contract = findConstantFromValue(
+          getValue('contract') as string,
+          CONTRACTS
+        );
         return !contract || !contract.end;
       },
-    },
-  ],
-  rules: [
-    {
-      field: 'contract',
-      isRequired: true,
-    },
-    {
-      field: 'endOfContract',
-      method: 'isBefore',
-      args: [moment().format('YYYY-MM-DD')],
-      validWhen: false,
-      message: "Date antérieure à aujourd'hui",
+      rules: [
+        {
+          method: (fieldValue) =>
+            validator.isAfter(fieldValue, moment().format('YYYY-MM-DD')),
+          message: "Date antérieure à aujourd'hui",
+        },
+      ],
     },
   ],
 };
diff --git a/src/components/forms/schemas/formEditExperience.ts b/src/components/forms/schemas/formEditExperience.ts
index a257b35ab..a04479ae6 100644
--- a/src/components/forms/schemas/formEditExperience.ts
+++ b/src/components/forms/schemas/formEditExperience.ts
@@ -1,4 +1,4 @@
-import { FormSchema } from '../FormSchema/FormSchema.types';
+import { FormSchema } from '../FormSchema';
 
 export const formEditExperience: FormSchema = {
   id: 'form-experience',
@@ -8,6 +8,7 @@ export const formEditExperience: FormSchema = {
       name: 'description',
       component: 'textarea',
       title: 'Description',
+      maxLength: 2000,
     },
     {
       id: 'skills',
@@ -17,17 +18,4 @@ export const formEditExperience: FormSchema = {
       isMulti: true,
     },
   ],
-  rules: [
-    {
-      field: 'description',
-      method: 'isLength',
-      args: [
-        {
-          max: 2000,
-        },
-      ],
-      validWhen: true,
-      message: '2000 caractères maximum',
-    },
-  ],
 };
diff --git a/src/components/forms/schemas/formEditExternalOpportunity.ts b/src/components/forms/schemas/formEditExternalOpportunity.ts
index bf8624635..b9c6e5987 100644
--- a/src/components/forms/schemas/formEditExternalOpportunity.ts
+++ b/src/components/forms/schemas/formEditExternalOpportunity.ts
@@ -1,6 +1,6 @@
 import moment from 'moment';
 
-import { FormSchema } from '../FormSchema/FormSchema.types';
+import { FormSchema } from '../FormSchema';
 import { Api } from 'src/api';
 import {
   BUSINESS_LINES,
@@ -31,6 +31,7 @@ export const formEditExternalOpportunity: FormSchema = {
           loadOptions: (callback) => {
             callback([]);
           },
+          isRequired: true,
         },
         {
           id: 'status',
@@ -46,12 +47,14 @@ export const formEditExternalOpportunity: FormSchema = {
       name: 'title',
       component: 'text-input',
       title: "Titre de l'offre*",
+      isRequired: true,
     },
     {
       id: 'company',
       name: 'company',
       component: 'text-input',
       title: "Nom de l'entreprise*",
+      isRequired: true,
     },
     {
       id: 'contract',
@@ -60,6 +63,7 @@ export const formEditExternalOpportunity: FormSchema = {
       options: CONTRACTS,
       title: 'Type de contrat*',
       fieldsToReset: ['endOfContract'],
+      isRequired: true,
     },
     {
       id: 'startEndContract',
@@ -79,11 +83,25 @@ export const formEditExternalOpportunity: FormSchema = {
           component: 'datepicker',
           disable: (getValue) => {
             const contract = findConstantFromValue(
-              getValue('contract'),
+              getValue('contract') as string,
               CONTRACTS
             );
             return !contract || !contract.end;
           },
+          rules: [
+            {
+              method: (fieldValue, fieldValues) => {
+                return !(
+                  !!fieldValue &&
+                  !!fieldValues.startOfContract &&
+                  moment(fieldValue, 'YYYY-MM-DD').isBefore(
+                    moment(fieldValues.startOfContract as string, 'YYYY-MM-DD')
+                  )
+                );
+              },
+              message: 'Date antérieure à la date de début',
+            },
+          ],
         },
         {
           id: 'isPartTime',
@@ -109,6 +127,7 @@ export const formEditExternalOpportunity: FormSchema = {
       title: 'Département*',
       component: 'select',
       options: DEPARTMENTS_FILTERS,
+      isRequired: true,
     },
     {
       id: 'link',
@@ -121,6 +140,8 @@ export const formEditExternalOpportunity: FormSchema = {
       name: 'description',
       component: 'textarea',
       title: "Description de l'offre",
+      maxLength: 2000,
+
     },
     {
       id: 'externalOrigin',
@@ -130,43 +151,6 @@ export const formEditExternalOpportunity: FormSchema = {
       title: 'Offre venant de',
     },
   ],
-  rules: [
-    {
-      field: 'candidateId',
-      isRequired: true,
-    },
-    {
-      field: 'title',
-      isRequired: true,
-    },
-    {
-      field: 'company',
-      isRequired: true,
-    },
-    {
-      field: 'department',
-      isRequired: true,
-    },
-    {
-      field: 'contract',
-      isRequired: true,
-    },
-    {
-      field: 'endOfContract',
-      method: (fieldValue, state) => {
-        return (
-          !!fieldValue &&
-          !!state.startOfContract &&
-          moment(fieldValue, 'YYYY-MM-DD').isBefore(
-            moment(state.startOfContract, 'YYYY-MM-DD')
-          )
-        );
-      },
-      args: [],
-      validWhen: false,
-      message: 'Date antérieure à la date de début',
-    },
-  ],
 };
 
 export const adminMutations = [
diff --git a/src/components/forms/schemas/formEditOpportunity.ts b/src/components/forms/schemas/formEditOpportunity.ts
index 7d2ad3989..84effac29 100644
--- a/src/components/forms/schemas/formEditOpportunity.ts
+++ b/src/components/forms/schemas/formEditOpportunity.ts
@@ -1,12 +1,12 @@
-import moment from 'moment';
 import { isValidPhoneNumber } from 'react-phone-number-input/mobile';
-import { isEmail } from 'validator';
-import { FormSchema } from '../FormSchema/FormSchema.types';
+import isEmail from 'validator/lib/isEmail';
+import { FormSchema } from '../FormSchema';
 import { Api } from 'src/api';
-import { BUSINESS_LINES, CONTRACTS } from 'src/constants';
+import { BUSINESS_LINES, CONTRACTS, FilterConstant } from 'src/constants';
 import { DEPARTMENTS_FILTERS } from 'src/constants/departements';
 import { USER_ROLES } from 'src/constants/users';
-import { findConstantFromValue, getValueFromFormField } from 'src/utils';
+import { findConstantFromValue } from 'src/utils';
+import validator from "validator";
 
 export const formEditOpportunity: FormSchema = {
   id: 'form-offer',
@@ -55,6 +55,16 @@ export const formEditOpportunity: FormSchema = {
           })
           .then(callback);
       },
+      rules: [
+        {
+          method: (fieldValue, fieldValues) => {
+            return (
+              !!fieldValues.isPublic || (fieldValue && fieldValue.length > 0)
+            );
+          },
+          message: 'Obligatoire si offre privée',
+        },
+      ],
     },
     {
       id: 'shouldSendNotifications',
@@ -81,12 +91,14 @@ export const formEditOpportunity: FormSchema = {
       name: 'title',
       component: 'text-input',
       title: 'Intitulé du poste proposé*',
+      isRequired: true,
     },
     {
       id: 'company',
       name: 'company',
       component: 'text-input',
       title: 'Nom de votre entreprise*',
+      isRequired: true,
     },
     {
       id: 'companyDescription',
@@ -106,12 +118,14 @@ export const formEditOpportunity: FormSchema = {
           title: 'Département du lieu de travail*',
           component: 'select',
           options: DEPARTMENTS_FILTERS,
+          isRequired: true,
         },
         {
           id: 'address',
           name: 'address',
           title: 'Adresse du lieu de travail*',
           component: 'text-input',
+          isRequired: true,
         },
       ],
     },
@@ -126,18 +140,21 @@ export const formEditOpportunity: FormSchema = {
       name: 'recruiterFirstName',
       component: 'text-input',
       title: 'Votre prénom*',
+      isRequired: true,
     },
     {
       id: 'recruiterName',
       name: 'recruiterName',
       component: 'text-input',
       title: 'Votre nom*',
+      isRequired: true,
     },
     {
       id: 'recruiterPosition',
       name: 'recruiterPosition',
       component: 'text-input',
       title: 'Votre fonction*',
+      isRequired: true,
     },
     {
       id: 'recruiterMail',
@@ -145,12 +162,33 @@ export const formEditOpportunity: FormSchema = {
       component: 'text-input',
       type: 'email',
       title: 'Votre adresse mail*',
+      isRequired: true,
+      rules: [
+        {
+          method: (fieldValue) => validator.isEmail(fieldValue),
+
+          message: 'Invalide',
+        },
+      ],
     },
     {
       id: 'recruiterPhone',
       name: 'recruiterPhone',
       component: 'tel-input',
       title: 'Votre téléphone portable',
+      rules: [
+        {
+          method: (fieldValue) => {
+            return (
+              !fieldValue ||
+              fieldValue.length === 0 ||
+              isValidPhoneNumber(fieldValue, 'FR')
+            );
+          },
+
+          message: 'Numéro de téléphone invalide',
+        },
+      ],
     },
     {
       id: 'contactMail',
@@ -160,6 +198,15 @@ export const formEditOpportunity: FormSchema = {
       component: 'text-input',
       type: 'email',
       title: 'Adresse mail du recruteur si intermédiaire',
+      rules: [
+        {
+          // TODO Put trim on all fields
+          method: (fieldValue) => {
+            return !fieldValue.trim() || isEmail(fieldValue);
+          },
+          message: 'Invalide',
+        },
+      ],
     },
     {
       id: 'businessLines',
@@ -182,6 +229,7 @@ export const formEditOpportunity: FormSchema = {
       name: 'description',
       component: 'textarea',
       title: 'Descriptif des missions proposées*',
+      isRequired: true,
     },
     {
       id: 'contract',
@@ -190,6 +238,7 @@ export const formEditOpportunity: FormSchema = {
       options: CONTRACTS,
       title: 'Type de contrat*',
       fieldsToReset: ['endOfContract'],
+      isRequired: true,
     },
     {
       id: 'startEndContract',
@@ -210,7 +259,7 @@ export const formEditOpportunity: FormSchema = {
           component: 'datepicker',
           disable: (getValue) => {
             const contract = findConstantFromValue(
-              getValue('contract'),
+              getValue('contract') as string,
               CONTRACTS
             );
             return !contract || !contract.end;
@@ -294,143 +343,6 @@ export const formEditOpportunity: FormSchema = {
         'Vous avez un autre poste à proposer ? Dupliquez cette offre pour la publier plus rapidement',
     },
   ],
-  rules: [
-    {
-      field: 'candidatesIds',
-      args: [],
-      method: (fieldValue, state) => {
-        return (
-          (!fieldValue || fieldValue.length === 0) && state.isPublic === false
-        );
-      },
-      validWhen: false,
-      message: 'Obligatoire si offre privée',
-    },
-    {
-      field: 'title',
-      isRequired: true,
-    },
-    {
-      field: 'company',
-      isRequired: true,
-    },
-    {
-      field: 'recruiterFirstName',
-      isRequired: true,
-    },
-    {
-      field: 'recruiterName',
-      isRequired: true,
-    },
-    {
-      field: 'recruiterPosition',
-      isRequired: true,
-    },
-    {
-      field: 'recruiterMail',
-      isRequired: true,
-    },
-    {
-      field: 'recruiterMail',
-      method: 'isEmail',
-      validWhen: true,
-      message: 'Invalide',
-    },
-    {
-      field: 'contactMail',
-      method: (fieldValue) => {
-        return !fieldValue.trim() || isEmail(fieldValue);
-      },
-      validWhen: true,
-      args: [],
-      message: 'Invalide',
-    },
-    {
-      field: 'recruiterPhone',
-      method: (fieldValue) => {
-        return (
-          !fieldValue ||
-          fieldValue.length === 0 ||
-          isValidPhoneNumber(fieldValue, 'FR')
-        );
-      },
-      args: [],
-      validWhen: true,
-      message: 'Numéro de téléphone invalide',
-    },
-    /*
-    {
-      field: 'businessLines',
-      isRequired: true,
-    }, */
-    {
-      field: 'locations',
-      method: (fieldValue, state) => {
-        const keys = ['department', 'address'];
-        return (
-          !keys.every((key) => {
-            return state[key];
-          }) &&
-          (fieldValue.length === 0 ||
-            fieldValue.some((fields) => {
-              return (
-                !keys.every((key) => {
-                  return Object.keys(fields).includes(key);
-                }) ||
-                Object.keys(fields).some((key) => {
-                  const value = getValueFromFormField(fields[key]);
-                  return !(value as string)?.trim();
-                })
-              );
-            }))
-        );
-      },
-      args: [],
-      validWhen: false,
-      message: 'Obligatoire',
-    },
-    {
-      field: 'department',
-      method: (fieldValue, state) => {
-        return !state.locations && !fieldValue?.trim();
-      },
-      args: [],
-      validWhen: false,
-      message: 'Obligatoire',
-    },
-    {
-      field: 'address',
-      method: (fieldValue, state) => {
-        return !state.locations && !fieldValue?.trim();
-      },
-      args: [],
-      validWhen: false,
-      message: 'Obligatoire',
-    },
-    {
-      field: 'description',
-      isRequired: true,
-    },
-    {
-      field: 'contract',
-      isRequired: true,
-    },
-    {
-      field: 'endOfContract',
-      method: (fieldValue, state) => {
-        return (
-          !!fieldValue &&
-          !!state.startOfContract &&
-          moment(fieldValue, 'YYYY-MM-DD').isBefore(
-            moment(state.startOfContract, 'YYYY-MM-DD')
-          )
-        );
-      },
-      args: [],
-      validWhen: false,
-      message: 'Date antérieure à la date de début',
-    },
-  ],
 };
 
 export const adminMutations = [
diff --git a/src/components/forms/schemas/formEditPassions.ts b/src/components/forms/schemas/formEditPassions.ts
index 26e8e5fa8..c2d7eab08 100644
--- a/src/components/forms/schemas/formEditPassions.ts
+++ b/src/components/forms/schemas/formEditPassions.ts
@@ -1,4 +1,4 @@
-import { FormSchema } from '../FormSchema/FormSchema.types';
+import { FormSchema } from '../FormSchema';
 
 export const formEditPassions: FormSchema = {
   id: 'form-passions',
@@ -8,104 +8,42 @@ export const formEditPassions: FormSchema = {
       name: 'passion1',
       component: 'text-input',
       title: 'Passion 1',
+                maxLength: 40,
     },
     {
       id: 'passion2',
       name: 'passion2',
       component: 'text-input',
       title: 'Passion 2',
+                maxLength: 40,
     },
     {
       id: 'passion3',
       name: 'passion3',
       component: 'text-input',
       title: 'Passion 3',
+                maxLength: 40,
     },
     {
       id: 'passion4',
       name: 'passion4',
       component: 'text-input',
       title: 'Passion 4',
+                maxLength: 40,
     },
     {
       id: 'passion5',
       name: 'passion5',
       component: 'text-input',
       title: 'Passion 5',
+                maxLength: 40,
     },
     {
       id: 'passion6',
       name: 'passion6',
       component: 'text-input',
       title: 'Passion 6',
-    },
-  ],
-  rules: [
-    {
-      field: 'passion1',
-      method: 'isLength',
-      args: [
-        {
-          max: 40,
-        },
-      ],
-      validWhen: true,
-      message: '40 caractères maximum',
-    },
-    {
-      field: 'passion2',
-      method: 'isLength',
-      args: [
-        {
-          max: 40,
-        },
-      ],
-      validWhen: true,
-      message: '40 caractères maximum',
-    },
-    {
-      field: 'passion3',
-      method: 'isLength',
-      args: [
-        {
-          max: 40,
-        },
-      ],
-      validWhen: true,
-      message: '40 caractères maximum',
-    },
-    {
-      field: 'passion4',
-      method: 'isLength',
-      args: [
-        {
-          max: 40,
-        },
-      ],
-      validWhen: true,
-      message: '40 caractères maximum',
-    },
-    {
-      field: 'passion5',
-      method: 'isLength',
-      args: [
-        {
-          max: 40,
-        },
-      ],
-      validWhen: true,
-      message: '40 caractères maximum',
-    },
-    {
-      field: 'passion6',
-      method: 'isLength',
-      args: [
-        {
-          max: 40,
-        },
-      ],
-      validWhen: true,
-      message: '40 caractères maximum',
+                maxLength: 40,
     },
   ],
 };
diff --git a/src/components/forms/schemas/formEditSkills.ts b/src/components/forms/schemas/formEditSkills.ts
index a34f5a406..2fa83ffa0 100644
--- a/src/components/forms/schemas/formEditSkills.ts
+++ b/src/components/forms/schemas/formEditSkills.ts
@@ -1,4 +1,4 @@
-import { FormSchema } from '../FormSchema/FormSchema.types';
+import { FormSchema } from '../FormSchema';
 
 export const formEditSkills: FormSchema = {
   id: 'form-skills',
@@ -8,104 +8,42 @@ export const formEditSkills: FormSchema = {
       name: 'skill1',
       component: 'text-input',
       title: 'Atout 1',
+      maxLength: 40,
     },
     {
       id: 'skill2',
       name: 'skill2',
       component: 'text-input',
       title: 'Atout 2',
+      maxLength: 40,
     },
     {
       id: 'skill3',
       name: 'skill3',
       component: 'text-input',
       title: 'Atout 3',
+      maxLength: 40,
     },
     {
       id: 'skill4',
       name: 'skill4',
       component: 'text-input',
       title: 'Atout 4',
+      maxLength: 40,
     },
     {
       id: 'skill5',
       name: 'skill5',
       component: 'text-input',
       title: 'Atout 5',
+      maxLength: 40,
     },
     {
       id: 'skill6',
       name: 'skill6',
       component: 'text-input',
       title: 'Atout 6',
-    },
-  ],
-  rules: [
-    {
-      field: 'skill1',
-      method: 'isLength',
-      args: [
-        {
-          max: 40,
-        },
-      ],
-      validWhen: true,
-      message: '40 caractères maximum',
-    },
-    {
-      field: 'skill2',
-      method: 'isLength',
-      args: [
-        {
-          max: 40,
-        },
-      ],
-      validWhen: true,
-      message: '40 caractères maximum',
-    },
-    {
-      field: 'skill3',
-      method: 'isLength',
-      args: [
-        {
-          max: 40,
-        },
-      ],
-      validWhen: true,
-      message: '40 caractères maximum',
-    },
-    {
-      field: 'skill4',
-      method: 'isLength',
-      args: [
-        {
-          max: 40,
-        },
-      ],
-      validWhen: true,
-      message: '40 caractères maximum',
-    },
-    {
-      field: 'skill5',
-      method: 'isLength',
-      args: [
-        {
-          max: 40,
-        },
-      ],
-      validWhen: true,
-      message: '40 caractères maximum',
-    },
-    {
-      field: 'skill6',
-      method: 'isLength',
-      args: [
-        {
-          max: 40,
-        },
-      ],
-      validWhen: true,
-      message: '40 caractères maximum',
+      maxLength: 40,
     },
   ],
 };
diff --git a/src/components/forms/schemas/formEditStory.ts b/src/components/forms/schemas/formEditStory.ts
index d8cf97e72..5f64d4f1d 100644
--- a/src/components/forms/schemas/formEditStory.ts
+++ b/src/components/forms/schemas/formEditStory.ts
@@ -1,4 +1,4 @@
-import { FormSchema } from '../FormSchema/FormSchema.types';
+import { FormSchema } from '../FormSchema';
 
 export const formEditStory: FormSchema = {
   id: 'form-story',
@@ -9,19 +9,7 @@ export const formEditStory: FormSchema = {
       component: 'textarea',
       title: 'Mon histoire',
       rows: 14,
-    },
-  ],
-  rules: [
-    {
-      field: 'story',
-      method: 'isLength',
-      args: [
-        {
-          max: 1500,
-        },
-      ],
-      validWhen: true,
-      message: '1500 caractères maximum',
+      maxLength: 1500,
     },
   ],
 };
diff --git a/src/components/forms/schemas/formEditTestimonial.ts b/src/components/forms/schemas/formEditTestimonial.ts
index 19c232389..d7f0e806b 100644
--- a/src/components/forms/schemas/formEditTestimonial.ts
+++ b/src/components/forms/schemas/formEditTestimonial.ts
@@ -1,4 +1,4 @@
-import { FormSchema } from '../FormSchema/FormSchema.types';
+import { FormSchema } from '../FormSchema';
 
 export const formEditTestimonial: FormSchema = {
   id: 'form-testimonial',
@@ -8,65 +8,26 @@ export const formEditTestimonial: FormSchema = {
       name: 'name',
       component: 'text-input',
       title: 'Nom *',
+      isRequired: true,
+                maxLength: 40,
     },
     {
       id: 'status',
       name: 'status',
       component: 'text-input',
       title: 'Statut *',
+      isRequired: true,
+      maxLength: 4000,
+
     },
     {
       id: 'text',
       name: 'text',
       component: 'textarea',
       title: 'Votre recommandation*',
-    },
-  ],
-  rules: [
-    {
-      field: 'name',
       isRequired: true,
-    },
-    {
-      field: 'name',
-      method: 'isLength',
-      args: [
-        {
-          max: 40,
-        },
-      ],
-      validWhen: true,
-      message: '40 caractères maximum',
-    },
-    {
-      field: 'status',
-      isRequired: true,
-    },
-    {
-      field: 'status',
-      method: 'isLength',
-      args: [
-        {
-          max: 100,
-        },
-      ],
-      validWhen: true,
-      message: '100 caractères maximum',
-    },
-    {
-      field: 'text',
-      isRequired: true,
-    },
-    {
-      field: 'text',
-      method: 'isLength',
-      args: [
-        {
-          max: 4000,
-        },
-      ],
-      validWhen: true,
-      message: '4000 caractères maximum',
+      maxLength: 80,
+
     },
   ],
 };
diff --git a/src/components/forms/schemas/formEditUsefulInformation.ts b/src/components/forms/schemas/formEditUsefulInformation.ts
index d7fd43663..4ffbbaaa9 100644
--- a/src/components/forms/schemas/formEditUsefulInformation.ts
+++ b/src/components/forms/schemas/formEditUsefulInformation.ts
@@ -1,7 +1,8 @@
 import { isValidPhoneNumber } from 'react-phone-number-input/mobile';
-import { FormSchema } from '../FormSchema/FormSchema.types';
+import { FormSchema } from '../FormSchema';
 import { CONTRACTS } from 'src/constants';
 import { DEPARTMENTS_FILTERS } from 'src/constants/departements';
+import validator from "validator";
 
 export const formEditUsefulInformation: FormSchema = {
   id: 'form-usefullinformation',
@@ -12,12 +13,29 @@ export const formEditUsefulInformation: FormSchema = {
       type: 'email',
       component: 'text-input',
       title: 'Adresse mail',
+      rules: [
+        {
+          method: (fieldValue) => validator.isEmail(fieldValue),
+
+          message: 'Adresse e-mail invalide',
+        },
+      ],
     },
     {
       id: 'phone',
       name: 'phone',
       component: 'tel-input',
       title: 'Numéro de téléphone portable*',
+      isRequired: true,
+      rules: [
+        {
+          method: (fieldValue) => {
+            return fieldValue && isValidPhoneNumber(fieldValue, 'FR');
+          },
+
+          message: 'Numéro de téléphone invalide',
+        },
+      ],
     },
     {
       id: 'address',
@@ -53,6 +71,7 @@ export const formEditUsefulInformation: FormSchema = {
       name: 'availability',
       component: 'text-input',
       title: 'Disponibilités de travail possibles',
+      maxLength: 40,
     },
     {
       id: 'languages',
@@ -66,67 +85,8 @@ export const formEditUsefulInformation: FormSchema = {
       name: 'transport',
       component: 'text-input',
       title: 'Permis de conduire',
-    },
-  ],
-  rules: [
-    {
-      field: 'contracts',
-      method: 'isLength',
-      args: [
-        {
-          max: 120,
-        },
-      ],
-      validWhen: true,
-      message: '120 caractères maximum',
-    },
-    {
-      field: 'availability',
-      method: 'isLength',
-      args: [
-        {
-          max: 40,
-        },
-      ],
-      validWhen: true,
-      message: '40 caractères maximum',
-    },
-    {
-      field: 'languages',
-      method: 'isLength',
-      args: [
-        {
-          max: 100,
-        },
-      ],
-      validWhen: true,
-      message: '100 caractères maximum',
-    },
-    {
-      field: 'transport',
-      method: 'isLength',
-      args: [
-        {
-          max: 100,
-        },
-      ],
-      validWhen: true,
-      message: '100 caractères maximum',
-    },
-    {
-      field: 'email',
-      method: 'isEmail',
-      validWhen: true,
-      message: 'Adresse e-mail invalide',
-    },
-    {
-      field: 'phone',
-      method: (fieldValue) => {
-        return fieldValue && isValidPhoneNumber(fieldValue, 'FR');
-      },
-      args: [],
-      validWhen: true,
-      message: 'Numéro de téléphone invalide',
+      maxLength: 100,
+
     },
   ],
 };
diff --git a/src/components/forms/schemas/formGetEmail.tsx b/src/components/forms/schemas/formGetEmail.tsx
index 0e50647ae..7c89d1490 100644
--- a/src/components/forms/schemas/formGetEmail.tsx
+++ b/src/components/forms/schemas/formGetEmail.tsx
@@ -1,7 +1,8 @@
 import React from 'react';
-import { EXTERNAL_LINKS } from '../../../constants';
-import { SimpleLink } from '../../utils';
-import { FormSchema } from '../FormSchema/FormSchema.types';
+import { FormSchema } from '../FormSchema';
+import { SimpleLink } from 'src/components/utils';
+import { EXTERNAL_LINKS } from 'src/constants';
+import validator from "validator";
 
 export const formGetEmail: FormSchema = {
   id: 'form-get-email',
@@ -13,6 +14,13 @@ export const formGetEmail: FormSchema = {
       type: 'email',
       placeholder: 'Tapez votre adresse mail',
       title: 'Adresse mail*',
+      isRequired: true,
+      rules: [
+        {
+          method: (fieldValue) => validator.isEmail(fieldValue),
+          message: 'Adresse e-mail invalide',
+        },
+      ],
     },
     {
       id: 'cgu',
@@ -30,25 +38,7 @@ export const formGetEmail: FormSchema = {
           </SimpleLink>
         </span>
       ),
-    },
-  ],
-  rules: [
-    {
-      field: 'email',
       isRequired: true,
     },
-    {
-      field: 'email',
-      method: 'isEmail',
-      validWhen: true,
-      message: 'Adresse e-mail invalide',
-    },
-    {
-      field: 'cgu',
-      method: 'equals',
-      args: ['true'],
-      validWhen: true,
-      message: 'Obligatoire',
-    },
   ],
 };
diff --git a/src/components/forms/schemas/formInterestLinkedOut.tsx b/src/components/forms/schemas/formInterestLinkedOut.tsx
index c1b2d1315..b3b753b79 100644
--- a/src/components/forms/schemas/formInterestLinkedOut.tsx
+++ b/src/components/forms/schemas/formInterestLinkedOut.tsx
@@ -3,6 +3,7 @@ import { isValidPhoneNumber } from 'react-phone-number-input/mobile';
 import { FormSchema } from '../FormSchema';
 import { SimpleLink } from 'src/components/utils';
 import { EXTERNAL_LINKS, HEARD_ABOUT_FILTERS } from 'src/constants';
+import validator from "validator";
 
 export const formInterestLinkedOut: FormSchema = {
   id: 'form-interest',
@@ -13,18 +14,8 @@ export const formInterestLinkedOut: FormSchema = {
       component: 'text-input',
       title: 'Nom*',
       isRequired: true,
-      rules: [
-        {
-          method: 'isLength',
-          args: [
-            {
-              max: 80,
-            },
-          ],
-          validWhen: true,
-          message: '80 caractères maximum',
-        },
-      ],
+      maxLength: 80,
+
     },
     {
       id: 'firstName',
@@ -32,18 +23,8 @@ export const formInterestLinkedOut: FormSchema = {
       component: 'text-input',
       title: 'Prénom*',
       isRequired: true,
-      rules: [
-        {
-          method: 'isLength',
-          args: [
-            {
-              max: 80,
-            },
-          ],
-          validWhen: true,
-          message: '80 caractères maximum',
-        },
-      ],
+      maxLength: 80,
+
     },
     {
       id: 'email',
@@ -54,8 +35,8 @@ export const formInterestLinkedOut: FormSchema = {
       isRequired: true,
       rules: [
         {
-          method: 'isEmail',
-          validWhen: true,
+          method: (fieldValue) => validator.isEmail(fieldValue),
+
           message: 'Adresse e-mail invalide',
         },
       ],
@@ -74,8 +55,6 @@ export const formInterestLinkedOut: FormSchema = {
               isValidPhoneNumber(fieldValue, 'FR')
             );
           },
-          args: [],
-          validWhen: true,
           message: 'Numéro de téléphone invalide',
         },
       ],
@@ -85,18 +64,7 @@ export const formInterestLinkedOut: FormSchema = {
       name: 'structure',
       component: 'text-input',
       title: 'Structure',
-      rules: [
-        {
-          method: 'isLength',
-          args: [
-            {
-              max: 60,
-            },
-          ],
-          validWhen: true,
-          message: '60 caractères maximum',
-        },
-      ],
+      maxLength: 60,
     },
     {
       id: 'message',
@@ -105,18 +73,8 @@ export const formInterestLinkedOut: FormSchema = {
       title: 'Votre message*',
       rows: 7,
       isRequired: true,
-      rules: [
-        {
-          method: 'isLength',
-          args: [
-            {
-              max: 4000,
-            },
-          ],
-          validWhen: true,
-          message: '4000 caractères maximum',
-        },
-      ],
+      maxLength: 4000,
+
     },
     {
       id: 'heardAbout',
@@ -142,17 +100,6 @@ export const formInterestLinkedOut: FormSchema = {
         </span>
       ),
       isRequired: true,
-      rules: [
-        {
-          method: 'equals',
-          args: ['true'],
-          validWhen: true,
-          message: 'Obligatoire',
-        },
-      ],
     },
   ],
-  rules: [
-    // The "rules" array no longer contains "field" properties.
-  ],
 };
diff --git a/src/components/forms/schemas/formLogin.ts b/src/components/forms/schemas/formLogin.ts
index 85c756400..ded1bc0c0 100644
--- a/src/components/forms/schemas/formLogin.ts
+++ b/src/components/forms/schemas/formLogin.ts
@@ -1,4 +1,5 @@
-import { FormSchema } from '../FormSchema/FormSchema.types';
+import { FormSchema } from '../FormSchema';
+import validator from "validator";
 
 export const formLogin: FormSchema = {
   id: 'form-login',
@@ -11,6 +12,13 @@ export const formLogin: FormSchema = {
       placeholder: 'Tapez votre adresse mail',
       title: 'Adresse mail*',
       showLabel: true,
+      isRequired: true,
+      rules: [
+        {
+          method: (fieldValue) => validator.isEmail(fieldValue),
+          message: 'Adresse e-mail invalide',
+        },
+      ],
     },
     {
       id: 'password',
@@ -20,21 +28,6 @@ export const formLogin: FormSchema = {
       placeholder: 'Tapez votre mot de passe',
       title: 'Mot de passe*',
       showLabel: true,
-    },
-  ],
-  rules: [
-    {
-      field: 'email',
-      isRequired: true,
-    },
-    {
-      field: 'email',
-      method: 'isEmail',
-      validWhen: true,
-      message: 'Adresse e-mail invalide',
-    },
-    {
-      field: 'password',
       isRequired: true,
     },
   ],
diff --git a/src/components/forms/schemas/formLostPwd.ts b/src/components/forms/schemas/formLostPwd.ts
index 900625f62..df5903b39 100644
--- a/src/components/forms/schemas/formLostPwd.ts
+++ b/src/components/forms/schemas/formLostPwd.ts
@@ -1,4 +1,5 @@
-import { FormSchema } from '../FormSchema/FormSchema.types';
+import { FormSchema } from '../FormSchema';
+import validator from "validator";
 
 export const formLostPwd: FormSchema = {
   id: 'form-lost-pwd',
@@ -11,18 +12,14 @@ export const formLostPwd: FormSchema = {
       placeholder: 'Tapez votre adresse mail',
       title: 'Adresse mail*',
       showLabel: true,
-    },
-  ],
-  rules: [
-    {
-      field: 'email',
       isRequired: true,
-    },
-    {
-      field: 'email',
-      method: 'isEmail',
-      validWhen: true,
-      message: 'Adresse e-mail invalide',
+      rules: [
+        {
+          method: (fieldValue) => validator.isEmail(fieldValue),
+
+          message: 'Adresse e-mail invalide',
+        },
+      ],
     },
   ],
 };
diff --git a/src/components/forms/schemas/formPersonalData.ts b/src/components/forms/schemas/formPersonalData.ts
index b6f639c0c..c58914a52 100644
--- a/src/components/forms/schemas/formPersonalData.ts
+++ b/src/components/forms/schemas/formPersonalData.ts
@@ -1,5 +1,5 @@
 import { isValidPhoneNumber } from 'react-phone-number-input/mobile';
-import { FormSchema } from '../FormSchema/FormSchema.types';
+import { FormSchema } from '../FormSchema';
 import { ADMIN_ZONES_FILTERS } from 'src/constants/departements';
 import { ADMIN_ROLES } from 'src/constants/users';
 
@@ -11,12 +11,14 @@ export const formPersonalData: FormSchema = {
       name: 'firstName',
       component: 'text-input',
       title: 'Prénom*',
+      isRequired: true,
     },
     {
       id: 'lastName',
       name: 'lastName',
       component: 'text-input',
       title: 'Nom*',
+      isRequired: true,
     },
     {
       id: 'zone',
@@ -24,6 +26,7 @@ export const formPersonalData: FormSchema = {
       name: 'zone',
       component: 'select-simple',
       options: ADMIN_ZONES_FILTERS,
+      isRequired: true,
     },
     {
       id: 'adminRole',
@@ -44,6 +47,7 @@ export const formPersonalData: FormSchema = {
         { value: 0, label: 'Homme' },
         { value: 1, label: 'Femme' },
       ],
+      isRequired: true,
     },
     {
       id: 'mailLabel',
@@ -83,6 +87,16 @@ export const formPersonalData: FormSchema = {
       name: 'phone',
       component: 'tel-input',
       title: 'Numéro de telephone portable*',
+      isRequired: true,
+      rules: [
+        {
+          method: (fieldValue) => {
+            return fieldValue && isValidPhoneNumber(fieldValue, 'FR');
+          },
+
+          message: 'Numéro de téléphone invalide',
+        },
+      ],
     },
     {
       id: 'addressLabel',
@@ -97,31 +111,4 @@ export const formPersonalData: FormSchema = {
       title: 'Tapez votre adresse postale',
     },
   ],
-  rules: [
-    {
-      field: 'firstName',
-      isRequired: true,
-    },
-    {
-      field: 'lastName',
-      isRequired: true,
-    },
-    {
-      field: 'gender',
-      isRequired: true,
-    },
-    {
-      field: 'phone',
-      method: (fieldValue) => {
-        return fieldValue && isValidPhoneNumber(fieldValue, 'FR');
-      },
-      args: [],
-      validWhen: true,
-      message: 'Numéro de téléphone invalide',
-    },
-    {
-      field: 'zone',
-      isRequired: true,
-    },
-  ],
 };
diff --git a/src/components/forms/schemas/formResetPassword.ts b/src/components/forms/schemas/formResetPassword.ts
index 176294831..fbf78bead 100644
--- a/src/components/forms/schemas/formResetPassword.ts
+++ b/src/components/forms/schemas/formResetPassword.ts
@@ -1,5 +1,5 @@
 import { passwordStrength } from 'check-password-strength';
-import { FormSchema } from '../FormSchema/FormSchema.types';
+import { FormSchema } from '../FormSchema';
 
 export const formResetPassword: FormSchema = {
   id: 'form-reset-pwd',
@@ -10,6 +10,16 @@ export const formResetPassword: FormSchema = {
       type: 'password',
       component: 'text-input',
       title: 'Nouveau mot de passe*',
+      isRequired: true,
+      rules: [
+        {
+          method: (fieldValue) => {
+            return passwordStrength(fieldValue).id >= 2;
+          },
+
+          message: 'Doit répondre aux critères ci-dessus',
+        },
+      ],
     },
     {
       id: 'confirmPassword',
@@ -17,35 +27,21 @@ export const formResetPassword: FormSchema = {
       type: 'password',
       component: 'text-input',
       title: 'Confirmation du mot de passe*',
-    },
-  ],
-  rules: [
-    {
-      field: 'newPassword',
-      method: (fieldValue) => {
-        return passwordStrength(fieldValue).id >= 2;
-      },
-      args: [],
-      validWhen: true,
-      message: 'Doit répondre aux critères ci-dessus',
-    },
-    {
-      field: 'confirmPassword',
-      method: (fieldValue) => {
-        return passwordStrength(fieldValue).id >= 2;
-      },
-      args: [],
-      validWhen: true,
-      message: 'Doit répondre aux critères ci-dessus',
-    },
-    {
-      field: 'confirmPassword',
-      method: (fieldValue, state) => {
-        return state.newPassword === fieldValue;
-      },
-      args: [],
-      validWhen: true,
-      message: 'Les deux mots de passe ne correspondent pas',
+      isRequired: true,
+      rules: [
+        {
+          method: (fieldValue) =>
+            passwordStrength(fieldValue).id >= 2,
+          message: 'Doit répondre aux critères ci-dessus',
+        },
+        {
+          method: (fieldValue, fieldValues) => {
+            return fieldValues.newPassword === fieldValue;
+          },
+
+          message: 'Les deux mots de passe ne correspondent pas',
+        },
+      ],
     },
   ],
 };
diff --git a/src/components/forms/schemas/formSendExternalMessage.ts b/src/components/forms/schemas/formSendExternalMessage.ts
index 2ec63519b..f368da2de 100644
--- a/src/components/forms/schemas/formSendExternalMessage.ts
+++ b/src/components/forms/schemas/formSendExternalMessage.ts
@@ -1,9 +1,10 @@
 import { isValidPhoneNumber } from 'react-phone-number-input/mobile';
-import { FormSchema } from '../FormSchema/FormSchema.types';
+import { FormSchema } from '../FormSchema';
 import {
   EXTERNAL_MESSAGE_SUBJECT_FILTERS,
   EXTERNAL_MESSAGE_CONTACT_TYPE_FILTERS,
 } from 'src/constants';
+import validator from "validator";
 
 export const formSendExternalMessage: FormSchema = {
   id: 'form-send-external-message',
@@ -18,12 +19,14 @@ export const formSendExternalMessage: FormSchema = {
           name: 'senderFirstName',
           component: 'text-input',
           title: 'Prénom *',
+          isRequired: true,
         },
         {
           id: 'senderLastName',
           name: 'senderLastName',
           component: 'text-input',
           title: 'Nom *',
+          isRequired: true,
         },
       ],
     },
@@ -33,6 +36,14 @@ export const formSendExternalMessage: FormSchema = {
       type: 'email',
       component: 'text-input',
       title: 'Adresse mail *',
+      isRequired: true,
+      rules: [
+        {
+          method: (fieldValue) => validator.isEmail(fieldValue),
+
+          message: 'Adresse e-mail invalide',
+        },
+      ],
     },
     {
       id: 'senderPhoneType',
@@ -44,6 +55,13 @@ export const formSendExternalMessage: FormSchema = {
           name: 'senderPhone',
           component: 'tel-input',
           title: 'Numéro de téléphone',
+          rules: [
+            {
+              method: (fieldValue) =>
+                isValidPhoneNumber(fieldValue, 'FR'),
+              message: 'Numéro de téléphone invalide',
+            },
+          ],
         },
         {
           id: 'type',
@@ -60,12 +78,14 @@ export const formSendExternalMessage: FormSchema = {
       component: 'select-simple',
       title: 'Objet *',
       options: EXTERNAL_MESSAGE_SUBJECT_FILTERS,
+      isRequired: true,
     },
     {
       id: 'message',
       name: 'message',
       component: 'textarea',
       title: 'Écrire votre message *',
+      isRequired: true,
     },
     {
       id: 'optInContact',
@@ -73,6 +93,7 @@ export const formSendExternalMessage: FormSchema = {
       component: 'checkbox',
       title:
         "En cochant cette case, vous acceptez qu'un membre de l'équipe vous recontacte *",
+      isRequired: true,
     },
     {
       id: 'optInNewsletter',
@@ -81,52 +102,4 @@ export const formSendExternalMessage: FormSchema = {
       title: 'Je souhaite être tenu au courant des actualités du projet',
     },
   ],
-  rules: [
-    {
-      field: 'senderFirstName',
-      isRequired: true,
-    },
-    {
-      field: 'senderLastName',
-      isRequired: true,
-    },
-    {
-      field: 'senderEmail',
-      isRequired: true,
-    },
-    {
-      field: 'senderPhone',
-      method: (fieldValue) => {
-        return (
-          !fieldValue ||
-          fieldValue.length === 0 ||
-          isValidPhoneNumber(fieldValue, 'FR')
-        );
-      },
-      args: [],
-      validWhen: true,
-      message: 'Numéro de téléphone invalide',
-    },
-    {
-      field: 'subject',
-      isRequired: true,
-    },
-    {
-      field: 'message',
-      isRequired: true,
-    },
-    {
-      field: 'senderEmail',
-      isRequired: true,
-    },
-    {
-      field: 'optInContact',
-      method: (fieldValue) => {
-        return !!fieldValue;
-      },
-      args: [],
-      validWhen: true,
-      message: 'Obligatoire',
-    },
-  ],
 };
diff --git a/src/components/forms/schemas/formSimpleDatePicker.ts b/src/components/forms/schemas/formSimpleDatePicker.ts
index f3a12da73..6d0bcd0c0 100644
--- a/src/components/forms/schemas/formSimpleDatePicker.ts
+++ b/src/components/forms/schemas/formSimpleDatePicker.ts
@@ -1,4 +1,4 @@
-import { FormSchema } from '../FormSchema/FormSchema.types';
+import { FormSchema } from '../FormSchema';
 
 export function renderSimpleDatePickerField(formId, title): FormSchema {
   return {
@@ -9,19 +9,7 @@ export function renderSimpleDatePickerField(formId, title): FormSchema {
         name: 'datepicker',
         component: 'datepicker',
         title,
-      },
-    ],
-    rules: [
-      {
-        field: 'datepicker',
-        method: 'isEmpty',
-        args: [
-          {
-            ignore_whitespace: true,
-          },
-        ],
-        validWhen: false,
-        message: 'Obligatoire',
+        isRequired: true,
       },
     ],
   };
diff --git a/src/components/forms/schemas/formSimpleSelectField.ts b/src/components/forms/schemas/formSimpleSelectField.ts
index 685e072b1..05b0c12d8 100644
--- a/src/components/forms/schemas/formSimpleSelectField.ts
+++ b/src/components/forms/schemas/formSimpleSelectField.ts
@@ -1,4 +1,4 @@
-import { FormSchema } from '../FormSchema/FormSchema.types';
+import { FormSchema } from '../FormSchema';
 
 export function renderSimpleSelectField(
   formId,
@@ -15,7 +15,6 @@ export function renderSimpleSelectField(
   }
   return {
     id: formId,
-    rules: [],
     fields: [
       {
         id: inputId,
diff --git a/src/components/forms/schemas/script.ts b/src/components/forms/schemas/script.ts
deleted file mode 100644
index 469e4c934..000000000
--- a/src/components/forms/schemas/script.ts
+++ /dev/null
@@ -1,31 +0,0 @@
-import { FormSchema } from '../FormSchema';
-
-export function reformat(formSchema: FormSchema) {
-  const mutatedFormSchema: FormSchema = {
-    id: formSchema.id,
-    fields: formSchema.fields.reduce((acc, curr) => {
-      const isRequiredRule = formSchema.rules.find((singleRule) => {
-        return singleRule.field === curr.name && singleRule.isRequired;
-      });
-      const rules = formSchema.rules
-        .filter((singleRule) => {
-          return singleRule.field === curr.name && !singleRule.isRequired;
-        })
-        .map((singleRule) => {
-          const { field, ...singleRuleWithoutField } = singleRule;
-          return singleRuleWithoutField;
-        });
-      return [
-        ...acc,
-        {
-          ...curr,
-          ...(isRequiredRule ? { isRequired: isRequiredRule.isRequired } : {}),
-          ...(rules ? { rules } : {}),
-        },
-      ];
-    }, []),
-    rules: [],
-  };
-
-  console.log(mutatedFormSchema);
-}
diff --git a/src/components/utils/Inputs/TextArea/TextArea.tsx b/src/components/utils/Inputs/TextArea/TextArea.tsx
index d31bd4c9f..1c3745d1f 100644
--- a/src/components/utils/Inputs/TextArea/TextArea.tsx
+++ b/src/components/utils/Inputs/TextArea/TextArea.tsx
@@ -1,6 +1,7 @@
 import React, { ChangeEvent, MutableRefObject } from 'react';
 import { StyledInputLabel } from '../Inputs.styles';
 import { CommonInputProps } from '../Inputs.types';
+import { StyledLengthLimit } from '../TextInput/TextInput.styles';
 import { FieldErrorMessage } from 'src/components/forms/fields/FieldErrorMessage/FieldErrorMessage';
 import { useIsMobile } from 'src/hooks/utils';
 import {
@@ -14,6 +15,7 @@ import { useLineLimit } from './useLineLimit';
 
 interface TextAreaProps extends CommonInputProps<string, HTMLTextAreaElement> {
   maxLines?: { lines: number; width: number };
+  maxLength?: number;
   rows?: number;
 }
 
@@ -29,6 +31,7 @@ export function TextArea({
   disabled = false,
   error,
   maxLines,
+  maxLength,
   showLabel,
   inputRef,
   rows,
@@ -49,6 +52,8 @@ export function TextArea({
 
   const maxLinesWidth = maxLines?.width || 655;
 
+  const remainingCharacters = (maxLength || 0) - value.length;
+
   return (
     <StyledTextAreaContainer>
       {showLabel && (
@@ -76,6 +81,7 @@ export function TextArea({
           }
           disabled={disabled}
           onBlur={onBlur}
+          maxLength={!maxLines ? maxLength : null}
           value={value || ''}
         />
       </StyledTextAreaScrollContainer>
@@ -88,6 +94,11 @@ export function TextArea({
             {remainingLines} ligne(s) restante(s)
           </StyledLineLimit>
         )}
+        {!maxLines && maxLength && (
+          <StyledLengthLimit warning={remainingCharacters === 0}>
+            {remainingCharacters} caractère(s) restant(s)
+          </StyledLengthLimit>
+        )}
       </StyledAnnotations>
     </StyledTextAreaContainer>
   );
diff --git a/src/components/utils/Inputs/TextInput/TextInput.styles.ts b/src/components/utils/Inputs/TextInput/TextInput.styles.ts
index ab2e73ad2..3cbffb193 100644
--- a/src/components/utils/Inputs/TextInput/TextInput.styles.ts
+++ b/src/components/utils/Inputs/TextInput/TextInput.styles.ts
@@ -26,3 +26,18 @@ export const StyledTextInputContainer = styled.div`
     }
   }
 `;
+
+export const StyledAnnotations = styled.div`
+  display: flex;
+  justify-content: space-between;
+`;
+
+export const StyledLengthLimit = styled.div`
+  color: ${({ warning }) => {
+    return warning ? COLORS.noRed : COLORS.darkGray;
+  }};
+  font-size: 12px;
+  text-align: right;
+  align-self: flex-end;
+  transform: translate(0, -30px);
+`;
diff --git a/src/components/utils/Inputs/TextInput/TextInput.tsx b/src/components/utils/Inputs/TextInput/TextInput.tsx
index 48a65362f..977790965 100644
--- a/src/components/utils/Inputs/TextInput/TextInput.tsx
+++ b/src/components/utils/Inputs/TextInput/TextInput.tsx
@@ -2,9 +2,14 @@ import React, { ChangeEvent } from 'react';
 import { StyledInputLabel } from '../Inputs.styles';
 import { CommonInputProps } from '../Inputs.types';
 import { FieldErrorMessage } from 'src/components/forms/fields/FieldErrorMessage/FieldErrorMessage';
-import { StyledTextInputContainer } from './TextInput.styles';
+import {
+  StyledAnnotations,
+  StyledLengthLimit,
+  StyledTextInputContainer,
+} from './TextInput.styles';
 
 interface TextInputProps extends CommonInputProps<string, HTMLInputElement> {
+  maxLength?: number;
   type?: string;
   style?: 'secondary';
 }
@@ -19,6 +24,7 @@ export function TextInput({
   onBlur,
   type = 'text',
   style,
+  maxLength,
   showLabel = false,
   hidden = false,
   disabled = false,
@@ -29,6 +35,8 @@ export function TextInput({
     return null;
   }
 
+  const remainingCharacters = maxLength - value.length;
+
   return (
     <StyledTextInputContainer>
       {showLabel && (
@@ -48,10 +56,20 @@ export function TextInput({
         type={type || 'text'}
         placeholder={placeholder || (title as string)}
         name={name}
+        maxLength={maxLength}
         id={id}
         data-testid={id}
       />
-      <FieldErrorMessage error={error} />
+      <StyledAnnotations>
+        <div>
+          <FieldErrorMessage error={error} />
+        </div>
+        {maxLength && (
+          <StyledLengthLimit warning={remainingCharacters === 0}>
+            {remainingCharacters} caractère(s) restant(s)
+          </StyledLengthLimit>
+        )}
+      </StyledAnnotations>
     </StyledTextInputContainer>
   );
 }
diff --git a/yarn.lock b/yarn.lock
index 57393761d..c27f2a046 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -3626,6 +3626,11 @@
   resolved "https://registry.yarnpkg.com/@types/unist/-/unist-2.0.6.tgz#250a7b16c3b91f672a24552ec64678eeb1d3a08d"
   integrity sha512-PBjIUxZHOuj0R15/xuwJYjFi+KZdNFrehocChv4g5hu6aFroHue8m0lBP0POdK2nKzbw0cgV1mws8+V/JAcEkQ==
 
+"@types/validator@^13.9.0":
+  version "13.9.0"
+  resolved "https://registry.yarnpkg.com/@types/validator/-/validator-13.9.0.tgz#e7a96da3ea6a936222c6e76bb54abdd3dc4c9e4a"
+  integrity sha512-NclP0IbzHj/4tJZKFqKh8E7kZdgss+MCUYV9G+TLltFfDA4lFgE4PKPpDIyS2FlcdANIfSx273emkupvChigbw==
+
 "@types/webpack-env@^1.16.0", "@types/webpack-env@^1.17.0":
   version "1.18.0"
   resolved "https://registry.yarnpkg.com/@types/webpack-env/-/webpack-env-1.18.0.tgz#ed6ecaa8e5ed5dfe8b2b3d00181702c9925f13fb"