create-du-app 0.1.2 → 0.1.4

package/templates/mobile/expo/src/core/utils/schema.util.tsx

@@ -0,0 +1,2713 @@
+import * as yup from 'yup';
+import type { StringSchema } from 'yup';
+import { FeeMode } from './enum.util';
+import { regexEmail, regexNumber } from './validate.util';
+import { Translator } from './translator.util';
+
+// ─── DPE/GES Schema Helpers ──────────────────────────────────────────────
+// Reusable conditional validators for the 7 DPE/GES fields that all depend
+// on subject_dpe === 'yes'.  Each property type schema uses these instead of
+// repeating the same .when('subject_dpe', { … }) block 7 times.
+
+type NullableStringSchema = StringSchema<
+    string | null | undefined,
+    Record<string, any>,
+    string | null | undefined
+>;
+
+const dpeWhenSubject = (
+    base: NullableStringSchema,
+    messageKey?: string,
+    extraTest?: (s: NullableStringSchema) => NullableStringSchema,
+) => {
+    let chain: NullableStringSchema = base;
+    if (extraTest) chain = extraTest(chain);
+    if (messageKey) {
+        return chain.when('subject_dpe', {
+            is: 'yes',
+            then: (s: NullableStringSchema) => s.required(Translator.translate(messageKey)),
+            otherwise: (s: NullableStringSchema) => s.nullable(),
+        });
+    }
+    return chain.when('subject_dpe', {
+        is: 'yes',
+        then: (s: NullableStringSchema) => s.required(),
+        otherwise: (s: NullableStringSchema) => s.nullable(),
+    });
+};
+
+const validNumberTest = (s: NullableStringSchema) =>
+    s.test('is-valid-number', '', v => !v || !isNaN(Number(v)));
+
+export const dpeGradeSchema = (messageKey: string) =>
+    dpeWhenSubject(yup.string().nullable(), messageKey);
+
+export const dpeDateSchema = (messageKey: string) =>
+    dpeWhenSubject(yup.string().nullable(), messageKey);
+
+export const dpeNumericSchema = (messageKey: string) =>
+    dpeWhenSubject(yup.string().nullable(), messageKey, validNumberTest);
+
+export const gesGradeSchema = (messageKey: string) =>
+    dpeWhenSubject(yup.string().nullable(), messageKey);
+
+export const gesDateSchema = (messageKey: string) =>
+    dpeWhenSubject(yup.string().nullable(), messageKey);
+
+export const gesNumericSchema = (messageKey: string) =>
+    dpeWhenSubject(yup.string().nullable(), messageKey, validNumberTest);
+
+export const dpeGradeSchemaSimple = () =>
+    dpeWhenSubject(yup.string().nullable());
+
+export const dpeDateSchemaSimple = () =>
+    dpeWhenSubject(yup.string().nullable());
+
+export const dpeNumericSchemaSimple = () =>
+    dpeWhenSubject(yup.string().nullable(), undefined, validNumberTest);
+
+export const gesGradeSchemaSimple = () =>
+    dpeWhenSubject(yup.string().nullable());
+
+export const gesDateSchemaSimple = () =>
+    dpeWhenSubject(yup.string().nullable());
+
+export const gesNumericSchemaSimple = () =>
+    dpeWhenSubject(yup.string().nullable(), undefined, validNumberTest);
+
+const regexPhone = /^[0-9+\s\-().]{7,}$/;
+
+export const contactSupportSchema = () => {
+    return yup.object().shape({
+        name: yup.string().nullable().trim(),
+        phone: yup
+            .string()
+            .nullable()
+            .trim()
+            .test('phone-format', Translator.translate('contactSupport.phoneInvalid'), v =>
+                !v || regexPhone.test(v),
+            ),
+        email: yup
+            .string()
+            .nullable()
+            .trim()
+            .test('email-format', Translator.translate('contactSupport.emailInvalid'), v =>
+                !v || regexEmail.test(v),
+            ),
+        message: yup.string().nullable().trim(),
+    });
+};
+
+export const loginSchema = () => {
+    return yup.object().shape({
+        email: yup
+            .string()
+            .nullable()
+            .trim()
+            .required(Translator.translate('signin.emailRequired'))
+            .email(Translator.translate('signin.emailInvalid'))
+            .matches(regexEmail, Translator.translate('signin.emailInvalid')),
+        password: yup
+            .string()
+            .nullable()
+            .required(Translator.translate('signin.passwordRequired'))
+            .min(8, Translator.translate('signin.passwordMin'))
+            .max(32, Translator.translate('signin.passwordMax')),
+    });
+};
+
+export const forgotPasswordSchema = () => {
+    return yup.object().shape({
+        email: yup
+            .string()
+            .nullable()
+            .trim()
+            .required(Translator.translate('forgotPassword.emailRequired'))
+            .email(Translator.translate('forgotPassword.emailInvalid'))
+            .matches(
+                regexEmail,
+                Translator.translate('forgotPassword.emailInvalid'),
+            ),
+    });
+};
+
+export const resetPasswordSchema = () => {
+    return yup.object().shape({
+        newPassword: yup
+            .string()
+            .nullable()
+            .required(Translator.translate('resetPassword.newPasswordRequired'))
+            .min(8, Translator.translate('resetPassword.newPasswordMin'))
+            .max(32, Translator.translate('resetPassword.newPasswordMax')),
+        confirmPassword: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate('resetPassword.confirmPasswordRequired'),
+            )
+            .min(8, Translator.translate('resetPassword.confirmPasswordMin'))
+            .max(32, Translator.translate('resetPassword.confirmPasswordMax'))
+            .oneOf(
+                [yup.ref('newPassword'), null],
+                Translator.translate('resetPassword.confirmPasswordMatch'),
+            ),
+    });
+};
+
+export const changePasswordSchema = () => {
+    return yup.object().shape({
+        currentPassword: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate('changePassword.currentPasswordRequired'),
+            ),
+        newPassword: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate('changePassword.newPasswordRequired'),
+            )
+            .min(8, Translator.translate('changePassword.newPasswordMin'))
+            .max(32, Translator.translate('changePassword.newPasswordMax')),
+        confirmPassword: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate('changePassword.confirmPasswordRequired'),
+            )
+            .min(8, Translator.translate('changePassword.confirmPasswordMin'))
+            .max(32, Translator.translate('changePassword.confirmPasswordMax'))
+            .oneOf(
+                [yup.ref('newPassword'), null],
+                Translator.translate('changePassword.confirmPasswordMatch'),
+            ),
+    });
+};
+
+export const signupSchema = () => {
+    return yup.object().shape({
+        full_name: yup
+            .string()
+            .nullable()
+            .required(Translator.translate('signup.nameRequired'))
+            .min(3, Translator.translate('signup.nameMin'))
+            .max(32, Translator.translate('signup.nameMax')),
+        email: yup
+            .string()
+            .nullable()
+            .trim()
+            .required(Translator.translate('signup.emailRequired'))
+            .email(Translator.translate('signup.emailInvalid'))
+            .matches(
+                regexEmail,
+                Translator.translate('signup.emailInvalid'),
+            ),
+        password: yup
+            .string()
+            .nullable()
+            .required(Translator.translate('signup.passwordRequired'))
+            .min(8, Translator.translate('signup.passwordMin'))
+            .max(32, Translator.translate('signup.passwordMax')),
+    });
+};
+
+export const buyerPersonalPropertySchema = () => {
+    return yup.object().shape({
+        property_type_id: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'buyerPersonalProperty.propertyTypeRequired',
+                ),
+            ),
+        search_description: yup.string().nullable(),
+    });
+};
+
+export const buyerDescribeProfileSchema = () => {
+    return yup.object().shape({
+        buying_status: yup.string().nullable(),
+        family_situation: yup.string().nullable(),
+        purchase_objective: yup.string().nullable(),
+        description: yup.string().nullable(),
+    });
+};
+
+export const buyerEditProfileSchema = () => {
+    return yup.object().shape({
+        full_name: yup
+            .string()
+            .nullable()
+            .required(Translator.translate('searchSettings.nameRequired'))
+            .min(2, Translator.translate('searchSettings.nameMin')),
+    });
+};
+
+export const sellerEditProfileSchema = () => {
+    return yup.object().shape({
+        full_name: yup
+            .string()
+            .nullable()
+            .required(Translator.translate('searchSettings.nameRequired'))
+            .min(2, Translator.translate('searchSettings.nameMin')),
+        seller_type: yup
+            .string()
+            .nullable()
+            .required(Translator.translate('searchSettings.typeRequired')),
+        phone: yup.string().nullable(),
+        location: yup.string().nullable(),
+    });
+};
+
+export const agentEditProfileSchema = () => {
+    return yup.object().shape({
+        full_name: yup
+            .string()
+            .nullable()
+            .trim()
+            .required(Translator.translate('agentSignup.lastNameRequired')),
+        siret_number: yup.string().nullable().trim(),
+        activity_start_date: yup.string().nullable(),
+        card_number: yup.string().nullable().trim(),
+        agency_website_url: yup
+            .string()
+            .nullable()
+            .trim()
+            .url(Translator.translate('agentSignup.websiteInvalid')),
+        phone: yup.string().nullable().trim(),
+    });
+};
+
+export const buyerBudgetSchema = () => {
+    return yup.object().shape({
+        budget_min: yup
+            .number()
+            .nullable()
+            .typeError(Translator.translate('buyerPersonalBudget.budgetMustBeNumber'))
+            .positive(Translator.translate('buyerPersonalBudget.budgetMinRequired'))
+            .required(Translator.translate('buyerPersonalBudget.budgetMinRequired')),
+        budget_max: yup
+            .number()
+            .nullable()
+            .typeError(Translator.translate('buyerPersonalBudget.budgetMustBeNumber'))
+            .positive(Translator.translate('buyerPersonalBudget.budgetMaxRequired'))
+            .required(Translator.translate('buyerPersonalBudget.budgetMaxRequired'))
+            .min(
+                yup.ref('budget_min'),
+                Translator.translate('buyerPersonalBudget.budgetMaxLessThanMin'),
+            ),
+        budget_global: yup
+            .number()
+            .nullable()
+            .transform((value, originalValue) =>
+                originalValue === '' || originalValue === null || originalValue === undefined
+                    ? null
+                    : value,
+            )
+            .typeError(Translator.translate('buyerPersonalBudget.budgetMustBeNumber'))
+            .positive(Translator.translate('buyerPersonalBudget.budgetGlobalRequired'))
+            .min(
+                yup.ref('budget_min'),
+                Translator.translate('buyerPersonalBudget.budgetGlobalLessThanMin'),
+            )
+            .optional(),
+        has_property_to_sell: yup
+            .boolean()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'buyerPersonalBudget.hasSellPropertyRequired',
+                ),
+            ),
+        property_city: yup
+            .string()
+            .nullable()
+            .when('has_property_to_sell', {
+                is: true,
+                then: schema => schema.required(Translator.translate('buyerPersonalBudget.cityRequired')),
+                otherwise: schema => schema.optional(),
+            }),
+    });
+};
+
+
+export const buyerInvestmentStrategySchema = () => {
+    return yup.object().shape({
+        budget_max: yup
+            .number()
+            .nullable()
+            .typeError(Translator.translate('buyerPersonalBudget.budgetMustBeNumber'))
+            .positive(Translator.translate('buyerPersonalBudget.budgetMaxRequired'))
+            .required(Translator.translate('buyerPersonalBudget.budgetMaxRequired')),
+        requires_renovation: yup
+            .string()
+            .required(Translator.translate('buyerInvestmentStrategy.requiresRenovationRequired')),
+        expected_return_rate: yup
+            .number()
+            .nullable()
+            .typeError(Translator.translate('validation.mustBeNumber'))
+            .required(Translator.translate('buyerInvestmentStrategy.expectedReturnRequired')),
+    });
+};
+
+export const buyerFinancialTermsSchema = () => {
+    return yup.object().shape({
+        financing_mode: yup
+            .string()
+            .nullable()
+            .required(Translator.translate('buyerFinancialTerms.financingModeRequired')),
+        description: yup
+            .string()
+            .nullable()
+            .optional(),
+    });
+};
+
+export const buyerHousePropertySchema = () => {
+    return yup.object().shape({
+        living_area_min: yup
+            .string()
+            .nullable()
+            .test(
+                'valid-number',
+                Translator.translate('buyerHouseProperty.livingAreaMinInvalid'),
+                value => !value || regexNumber.test(String(value)),
+            ),
+        living_area_max: yup
+            .string()
+            .nullable()
+            .test(
+                'valid-number',
+                Translator.translate('buyerHouseProperty.livingAreaMaxInvalid'),
+                value => !value || regexNumber.test(String(value)),
+            )
+            .test(
+                'min-max',
+                Translator.translate('buyerHouseProperty.livingAreaMaxLessThanMin'),
+                function (value) {
+                    const { living_area_min } = this.parent;
+                    if (!value || !living_area_min) return true;
+                    return Number(value) >= Number(living_area_min);
+                },
+            ),
+        garden_min: yup
+            .string()
+            .nullable()
+            .test(
+                'valid-number',
+                Translator.translate('buyerHouseProperty.gardenMinInvalid'),
+                value => !value || regexNumber.test(String(value)),
+            ),
+        garden_max: yup
+            .string()
+            .nullable()
+            .test(
+                'valid-number',
+                Translator.translate('buyerHouseProperty.gardenMaxInvalid'),
+                value => !value || regexNumber.test(String(value)),
+            )
+            .test(
+                'min-max',
+                Translator.translate('buyerHouseProperty.gardenMaxLessThanMin'),
+                function (value) {
+                    const { garden_min } = this.parent;
+                    if (!value || !garden_min) return true;
+                    return Number(value) >= Number(garden_min);
+                },
+            ),
+    });
+};
+
+export const buyerApartmentPropertySchema = () => {
+    return yup.object().shape({
+        living_area_min: yup
+            .string()
+            .nullable()
+            .test(
+                'valid-number',
+                Translator.translate('buyerHouseProperty.livingAreaMinInvalid'),
+                value => !value || regexNumber.test(String(value)),
+            ),
+        living_area_max: yup
+            .string()
+            .nullable()
+            .test(
+                'valid-number',
+                Translator.translate('buyerHouseProperty.livingAreaMaxInvalid'),
+                value => !value || regexNumber.test(String(value)),
+            )
+            .test(
+                'min-max',
+                Translator.translate('buyerHouseProperty.livingAreaMaxLessThanMin'),
+                function (value) {
+                    const { living_area_min } = this.parent;
+                    if (!value || !living_area_min) return true;
+                    return Number(value) >= Number(living_area_min);
+                },
+            ),
+    });
+};
+
+export const buyerGitePropertySchema = () => {
+    return yup.object().shape({
+        living_area_min: yup
+            .string()
+            .nullable()
+            .test(
+                'valid-number',
+                Translator.translate('buyerHouseProperty.livingAreaMinInvalid'),
+                value => !value || regexNumber.test(String(value)),
+            ),
+        living_area_max: yup
+            .string()
+            .nullable()
+            .test(
+                'valid-number',
+                Translator.translate('buyerHouseProperty.livingAreaMaxInvalid'),
+                value => !value || regexNumber.test(String(value)),
+            )
+            .test(
+                'min-max',
+                Translator.translate('buyerHouseProperty.livingAreaMaxLessThanMin'),
+                function (value) {
+                    const { living_area_min } = this.parent;
+                    if (!value || !living_area_min) return true;
+                    return Number(value) >= Number(living_area_min);
+                },
+            ),
+        garden_min: yup
+            .string()
+            .nullable()
+            .test(
+                'valid-number',
+                Translator.translate('buyerHouseProperty.gardenMinInvalid'),
+                value => !value || regexNumber.test(String(value)),
+            ),
+        garden_max: yup
+            .string()
+            .nullable()
+            .test(
+                'valid-number',
+                Translator.translate('buyerHouseProperty.gardenMaxInvalid'),
+                value => !value || regexNumber.test(String(value)),
+            )
+            .test(
+                'min-max',
+                Translator.translate('buyerHouseProperty.gardenMaxLessThanMin'),
+                function (value) {
+                    const { garden_min } = this.parent;
+                    if (!value || !garden_min) return true;
+                    return Number(value) >= Number(garden_min);
+                },
+            ),
+    });
+};
+
+export const buyerLandPropertySchema = () => {
+    return yup.object().shape({
+        garden_min: yup
+            .string()
+            .nullable()
+            .test(
+                'valid-number',
+                Translator.translate('buyerHouseProperty.gardenMinInvalid'),
+                value => !value || regexNumber.test(String(value)),
+            ),
+        garden_max: yup
+            .string()
+            .nullable()
+            .test(
+                'valid-number',
+                Translator.translate('buyerHouseProperty.gardenMaxInvalid'),
+                value => !value || regexNumber.test(String(value)),
+            )
+            .test(
+                'min-max',
+                Translator.translate('buyerHouseProperty.gardenMaxLessThanMin'),
+                function (value) {
+                    const { garden_min } = this.parent;
+                    if (!value || !garden_min) return true;
+                    return Number(value) >= Number(garden_min);
+                },
+            ),
+    });
+};
+
+export const buyerGarageParkingPropertySchema = () => {
+    return yup.object().shape({
+        living_area_min: yup
+            .string()
+            .nullable()
+            .test(
+                'valid-number',
+                Translator.translate('buyerHouseProperty.livingAreaMinInvalid'),
+                value => !value || regexNumber.test(String(value)),
+            ),
+    });
+};
+
+export const buyerBuildingPropertySchema = () => {
+    return yup.object().shape({
+        living_area_min: yup
+            .string()
+            .nullable()
+            .test(
+                'valid-number',
+                Translator.translate('buyerHouseProperty.livingAreaMinInvalid'),
+                value => !value || regexNumber.test(String(value)),
+            ),
+        living_area_max: yup
+            .string()
+            .nullable()
+            .test(
+                'valid-number',
+                Translator.translate('buyerHouseProperty.livingAreaMaxInvalid'),
+                value => !value || regexNumber.test(String(value)),
+            )
+            .test(
+                'min-max',
+                Translator.translate('buyerHouseProperty.livingAreaMaxLessThanMin'),
+                function (value) {
+                    const { living_area_min } = this.parent;
+                    if (!value || !living_area_min) return true;
+                    return Number(value) >= Number(living_area_min);
+                },
+            ),
+        rooms_min: yup.number().nullable().min(0).max(10),
+        rooms_max: yup
+            .number()
+            .nullable()
+            .min(0)
+            .max(10)
+            .test(
+                'min-max',
+                Translator.translate('buyerHouseProperty.roomsMaxLessThanMin'),
+                function (value) {
+                    const { rooms_min } = this.parent;
+                    if (value == null || rooms_min == null) return true;
+                    return value >= rooms_min;
+                },
+            ),
+    });
+};
+
+export const buyerOfficePropertySchema = () => {
+    return yup.object().shape({
+        living_area_min: yup
+            .string()
+            .nullable()
+            .test(
+                'valid-number',
+                Translator.translate('buyerHouseProperty.livingAreaMinInvalid'),
+                value => !value || regexNumber.test(String(value)),
+            ),
+        living_area_max: yup
+            .string()
+            .nullable()
+            .test(
+                'valid-number',
+                Translator.translate('buyerHouseProperty.livingAreaMaxInvalid'),
+                value => !value || regexNumber.test(String(value)),
+            )
+            .test(
+                'min-max',
+                Translator.translate('buyerHouseProperty.livingAreaMaxLessThanMin'),
+                function (value) {
+                    const { living_area_min } = this.parent;
+                    if (!value || !living_area_min) return true;
+                    return Number(value) >= Number(living_area_min);
+                },
+            ),
+        rooms_min: yup.number().nullable().min(0).max(20),
+    });
+};
+
+export const buyerCommercialPropertySchema = () => {
+    return yup.object().shape({
+        living_area_min: yup
+            .string()
+            .nullable()
+            .test(
+                'valid-number',
+                Translator.translate('buyerHouseProperty.livingAreaMinInvalid'),
+                value => !value || regexNumber.test(String(value)),
+            ),
+        living_area_max: yup
+            .string()
+            .nullable()
+            .test(
+                'valid-number',
+                Translator.translate('buyerHouseProperty.livingAreaMaxInvalid'),
+                value => !value || regexNumber.test(String(value)),
+            )
+            .test(
+                'min-max',
+                Translator.translate('buyerHouseProperty.livingAreaMaxLessThanMin'),
+                function (value) {
+                    const { living_area_min } = this.parent;
+                    if (!value || !living_area_min) return true;
+                    return Number(value) >= Number(living_area_min);
+                },
+            ),
+        window_surface_min: yup
+            .string()
+            .nullable()
+            .test(
+                'valid-number',
+                Translator.translate('buyerHouseProperty.livingAreaMinInvalid'),
+                value => !value || regexNumber.test(String(value)),
+            ),
+        window_surface_max: yup
+            .string()
+            .nullable()
+            .test(
+                'valid-number',
+                Translator.translate('buyerHouseProperty.livingAreaMaxInvalid'),
+                value => !value || regexNumber.test(String(value)),
+            )
+            .test(
+                'min-max',
+                Translator.translate('buyerHouseProperty.windowSurfaceMaxLessThanMin'),
+                function (value) {
+                    const { window_surface_min } = this.parent;
+                    if (!value || !window_surface_min) return true;
+                    return Number(value) >= Number(window_surface_min);
+                },
+            ),
+    });
+};
+
+export const buyerViagerPropertySchema = () => {
+    return yup.object().shape({
+        living_area_min: yup
+            .string()
+            .nullable()
+            .test(
+                'valid-number',
+                Translator.translate('buyerHouseProperty.livingAreaMinInvalid'),
+                value => !value || regexNumber.test(String(value)),
+            ),
+        living_area_max: yup
+            .string()
+            .nullable()
+            .test(
+                'valid-number',
+                Translator.translate('buyerHouseProperty.livingAreaMaxInvalid'),
+                value => !value || regexNumber.test(String(value)),
+            )
+            .test(
+                'min-max',
+                Translator.translate('buyerHouseProperty.livingAreaMaxLessThanMin'),
+                function (value) {
+                    const { living_area_min } = this.parent;
+                    if (!value || !living_area_min) return true;
+                    return Number(value) >= Number(living_area_min);
+                },
+            ),
+        rooms_min: yup.number().nullable().min(0).max(10),
+        max_bouquet: yup
+            .string()
+            .nullable()
+            .test(
+                'valid-number',
+                Translator.translate('buyerHouseProperty.livingAreaMinInvalid'),
+                value => !value || regexNumber.test(String(value)),
+            ),
+    });
+};
+
+export const sellerDateSellSchema = () => {
+    return yup.object().shape({
+        published_at: yup
+            .string()
+            .nullable()
+            .required(Translator.translate('sellerDateSell.dateRequired')),
+    });
+};
+
+export const sellerPricePositionSchema = () => {
+    return yup.object().shape({
+        price_initial: yup
+            .number()
+            .nullable()
+            .typeError(Translator.translate('buyerPersonalBudget.budgetMustBeNumber'))
+            .required(
+                Translator.translate(
+                    'sellerPricePosition.initialPriceRequired',
+                ),
+            ),
+    });
+};
+
+export const sellerResalePricePositionSchema = () => {
+    return yup.object().shape({
+        price_initial: yup
+            .number()
+            .nullable()
+            .typeError(Translator.translate('buyerPersonalBudget.budgetMustBeNumber'))
+            .required(
+                Translator.translate(
+                    'sellerPricePosition.initialPriceRequired',
+                ),
+            ),
+        adjusted_price: yup
+            .boolean()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerPricePosition.hasAdjustedPriceRequired',
+                ),
+            ),
+        price_current: yup
+            .number()
+            .nullable()
+            .typeError(Translator.translate('buyerPersonalBudget.budgetMustBeNumber'))
+            .when('adjusted_price', {
+                is: true,
+                then: schema =>
+                    schema.required(
+                        Translator.translate(
+                            'sellerPricePosition.currentPriceRequired',
+                        ),
+                    ),
+                otherwise: schema => schema.nullable(),
+            }),
+    });
+};
+
+export const agentRegisterPriceAndFeeSchema = () => {
+    return yup.object().shape({
+        net_selling_price: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'agentRegisterPriceAndFee.netSellingPriceRequired',
+                ),
+            ),
+        fee_mode: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'agentRegisterPriceAndFee.feeModeRequired',
+                ),
+            )
+            .oneOf(
+                [FeeMode.BUYER_PAYS, FeeMode.SELLER_PAYS],
+                Translator.translate(
+                    'agentRegisterPriceAndFee.feeModeRequired',
+                ),
+            ),
+        total_fees_ttc: yup
+            .string()
+            .nullable()
+            .when('fee_mode', {
+                is: (value: string) => value !== '' && value !== null && value !== undefined,
+                then: schema =>
+                    schema.required(
+                        Translator.translate(
+                            'agentRegisterPriceAndFee.totalFeesTTCRequired',
+                        ),
+                    ),
+                otherwise: schema => schema.nullable(),
+            }),
+        fee_rate: yup
+            .string()
+            .nullable()
+            .notRequired(),
+        price_current: yup
+            .string()
+            .nullable()
+            .notRequired(),
+        selling_price: yup
+            .string()
+            .nullable()
+            .notRequired(),
+    });
+};
+
+export const agentTypeOfMandateSchema = () => {
+    return yup.object().shape({
+        has_sales_mandate: yup
+            .boolean()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'agentTypeOfMandate.hasSalesMandateRequired',
+                ),
+            ),
+        mandate_type: yup
+            .string()
+            .nullable()
+            .when('has_sales_mandate', {
+                is: true,
+                then: schema =>
+                    schema.required(
+                        Translator.translate(
+                            'agentTypeOfMandate.mandateTypeRequired',
+                        ),
+                    ),
+                otherwise: schema => schema.nullable(),
+            }),
+    });
+};
+
+export const agentHousePropertySchema = () => {
+    return yup.object().shape({
+        living_area: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate('agentHouseProperty.livingAreaRequired'),
+            )
+            .test('is-valid-number', '', v => !v || !isNaN(Number(v)))
+            .test(
+                'living-area-lte-total-surface',
+                Translator.translate('agentHouseProperty.livingAreaGreaterThanTotalArea'),
+                function (value) {
+                    const { total_surface } = this.parent;
+                    if (!value || !total_surface) return true;
+                    return Number(value) <= Number(total_surface);
+                },
+            ),
+        total_surface: yup
+            .string()
+            .nullable()
+            .test('is-valid-number', '', v => !v || !isNaN(Number(v)))
+            .test(
+                'total-surface-gte-living-area',
+                Translator.translate('agentHouseProperty.totalAreaLessThanLivingArea'),
+                function (value) {
+                    const { living_area } = this.parent;
+                    if (!value || !living_area) return true;
+                    return Number(value) >= Number(living_area);
+                },
+            ),
+        rooms_count: yup
+            .number()
+            .nullable()
+            .required(
+                Translator.translate('agentHouseProperty.bedroomsRequired'),
+            )
+            .min(0),
+        shower_rooms: yup.number().nullable().min(0),
+        bathrooms: yup.number().nullable().min(0),
+        ground_floor: yup.mixed().nullable(),
+        has_garage: yup.mixed().nullable(),
+        pool: yup.mixed().nullable(),
+        heating_system: yup.string().nullable(),
+        property_condition: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'agentHouseProperty.propertyConditionRequired',
+                ),
+            ),
+        freeOrRented: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate('agentHouseProperty.freeOrRentedRequired'),
+            ),
+        monthly_rent: yup
+            .string()
+            .nullable()
+            .when('freeOrRented', {
+                is: 'rented',
+                then: schema =>
+                    schema.required(
+                        Translator.translate(
+                            'agentHouseProperty.monthlyRentRequired',
+                        ),
+                    ),
+                otherwise: schema => schema.notRequired().nullable(),
+            }),
+        annual_tax: yup
+            .string()
+            .nullable()
+            .when('freeOrRented', {
+                is: 'rented',
+                then: schema =>
+                    schema.required(
+                        Translator.translate(
+                            'agentHouseProperty.annualPropertyTaxRequired',
+                        ),
+                    ),
+                otherwise: schema => schema.notRequired().nullable(),
+            }),
+        subject_dpe: yup
+            .string()
+            .nullable()
+            .oneOf(
+                ['yes', 'no'],
+                Translator.translate('agentHouseProperty.subjectToDPERequired'),
+            )
+            .required(
+                Translator.translate('agentHouseProperty.subjectToDPERequired'),
+            ),
+        is_dpe_blank: yup
+            .string()
+            .nullable()
+            .oneOf(
+                ['yes', 'no'],
+                Translator.translate('agentHouseProperty.virginDPERequired'),
+            )
+            .required(
+                Translator.translate('agentHouseProperty.virginDPERequired'),
+            ),
+        dpe_grade: dpeGradeSchema('common.dpeClassRequired'),
+        dpe_date: dpeDateSchema('common.dpeDateRequired'),
+        primary_energy_consumption: dpeNumericSchema('common.primaryEnergyConsumptionRequired'),
+        estimated_annual_energy_cost: dpeNumericSchema('common.estimatedAnnualCostsRequired'),
+        ges_grade: gesGradeSchema('common.gesClassRequired'),
+        ges_date: gesDateSchema('common.gesDateRequired'),
+        greenhouse_gas_emissions: gesNumericSchema('common.greenhouseGasEmissionRequired'),
+        construction_year: yup.string().nullable(),
+        is_land_divisible: yup.mixed().nullable(),
+        sanitation: yup.string().nullable(),
+        available_at: yup.string().nullable(),
+    });
+};
+
+export const sellerPropertyTypeSchema = () => {
+    return yup.object().shape({
+        propertyType: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate('sellerPropertyType.propertyTypeRequired'),
+            ),
+    });
+};
+
+export const sellerResalePropertyTypeSchema = () => {
+    return yup.object().shape({
+        property_type_id: yup
+            .string()
+            .required(
+                Translator.translate('sellerPropertyType.propertyTypeRequired'),
+            ),
+    });
+};
+
+export const sellerViagerPropertyTypeSchema = () => {
+    return yup.object().shape({
+        property_type_id: yup
+            .string()
+            .required(
+                Translator.translate('sellerPropertyType.propertyTypeRequired'),
+            ),
+    });
+};
+
+export const sellerViagerPropertyDescriptionSchema = () => {
+    return yup.object().shape({
+        sale_type: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerPropertyDescription.saleTypeRequired',
+                ),
+            ),
+        address: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerPropertyDescription.fullAddressRequired',
+                ),
+            ),
+        street: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerPropertyDescription.streetRequired',
+                ),
+            ),
+        postal_code: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerPropertyDescription.postalCodeRequired',
+                ),
+            )
+            .matches(
+                regexNumber,
+                Translator.translate(
+                    'sellerPropertyDescription.postalCodeInvalid',
+                ),
+            ),
+        city: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate('sellerPropertyDescription.cityRequired'),
+            ),
+    });
+};
+
+export const sellerPropertyDescriptionSchema = () => {
+    return yup.object().shape({
+        sale_type: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerPropertyDescription.saleTypeRequired',
+                ),
+            ),
+        address: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerPropertyDescription.fullAddressRequired',
+                ),
+            ),
+        street: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerPropertyDescription.streetRequired',
+                ),
+            ),
+        postal_code: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerPropertyDescription.postalCodeRequired',
+                ),
+            )
+            .matches(
+                regexNumber,
+                Translator.translate(
+                    'sellerPropertyDescription.postalCodeInvalid',
+                ),
+            ),
+        city: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate('sellerPropertyDescription.cityRequired'),
+            ),
+        exact_address: yup
+            .boolean()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerPropertyDescription.geolocationRequired',
+                ),
+            ),
+        scope_selection: yup
+            .string()
+            .nullable()
+            .when('exact_address', {
+                is: false,
+                then: schema =>
+                    schema.required(
+                        Translator.translate(
+                            'sellerPropertyDescription.perimeterRequired',
+                        ),
+                    ),
+                otherwise: schema => schema.nullable(),
+            }),
+    });
+};
+
+export const sellerPropertyPhotosSchema = () => {
+    return yup.object().shape({
+        short_description: yup
+            .string()
+            .nullable()
+        // .required(
+        //     Translator.translate(
+        //         'sellerPropertyPhotos.descriptionRequired',
+        //     ),
+        // ),
+    });
+};
+
+export const sellerVisitSlotsSchema = () => {
+    return yup.object().shape({
+        // Schema is minimal since days and time slots are managed in component state
+        // Validation is handled in the component's isButtonEnabled logic
+    });
+};
+
+export const sellerHousePropertySchema = () => {
+    return yup.object().shape({
+        living_area: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate('sellerHouseProperty.livingAreaRequired'),
+            )
+            .test('is-valid-number', '', v => !v || !isNaN(Number(v)))
+            .test(
+                'living-area-lte-total-surface',
+                Translator.translate('sellerHouseProperty.livingAreaGreaterThanTotalArea'),
+                function (value) {
+                    const { total_surface } = this.parent;
+                    if (!value || !total_surface) return true;
+                    return Number(value) <= Number(total_surface);
+                },
+            ),
+        total_surface: yup
+            .string()
+            .nullable()
+            .test('is-valid-number', '', v => !v || !isNaN(Number(v)))
+            .test(
+                'total-surface-gte-living-area',
+                Translator.translate('sellerHouseProperty.totalAreaLessThanLivingArea'),
+                function (value) {
+                    const { living_area } = this.parent;
+                    if (!value || !living_area) return true;
+                    return Number(value) >= Number(living_area);
+                },
+            ),
+        rooms_count: yup
+            .number()
+            .nullable()
+            .required(
+                Translator.translate('sellerHouseProperty.bedroomsRequired'),
+            )
+            .min(0),
+        shower_rooms: yup.number().nullable().min(0),
+        bathrooms: yup.number().nullable().min(0),
+        ground_floor: yup.mixed().nullable(),
+        has_garage: yup.mixed().nullable(),
+        pool: yup.mixed().nullable(),
+        heating_system: yup.string().nullable(),
+        property_condition: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerHouseProperty.propertyConditionRequired',
+                ),
+            ),
+        freeOrRented: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerHouseProperty.freeOrRentedRequired',
+                ),
+            ),
+        monthly_rent: yup
+            .string()
+            .nullable()
+            .when('freeOrRented', {
+                is: 'rented',
+                then: schema =>
+                    schema.required(
+                        Translator.translate(
+                            'sellerHouseProperty.monthlyRentRequired',
+                        ),
+                    ),
+                otherwise: schema => schema.notRequired().nullable(),
+            }),
+        annual_tax: yup
+            .string()
+            .nullable()
+            .when('freeOrRented', {
+                is: 'rented',
+                then: schema =>
+                    schema.required(
+                        Translator.translate(
+                            'sellerHouseProperty.annualPropertyTaxRequired',
+                        ),
+                    ),
+                otherwise: schema => schema.notRequired().nullable(),
+            }),
+        subject_dpe: yup
+            .mixed()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerHouseProperty.subjectToDPERequired',
+                ),
+            ),
+        is_dpe_blank: yup
+            .mixed()
+            .nullable()
+            .required(
+                Translator.translate('sellerHouseProperty.virginDPERequired'),
+            ),
+        dpe_grade: dpeGradeSchema('common.dpeClassRequired'),
+        dpe_date: dpeDateSchema('common.dpeDateRequired'),
+        primary_energy_consumption: dpeNumericSchema('common.primaryEnergyConsumptionRequired'),
+        estimated_annual_energy_cost: dpeNumericSchema('common.estimatedAnnualCostsRequired'),
+        ges_grade: gesGradeSchema('common.gesClassRequired'),
+        ges_date: gesDateSchema('common.gesDateRequired'),
+        greenhouse_gas_emissions: gesNumericSchema('common.greenhouseGasEmissionRequired'),
+        construction_year: yup.string().nullable(),
+        is_land_divisible: yup.mixed().nullable(),
+        sanitation: yup.string().nullable(),
+        available_at: yup.string().nullable(),
+    });
+};
+
+export const sellerViagerHousePropertySchema = () => {
+    return sellerHousePropertySchema()
+        .shape({
+            is_dpe_blank: yup
+                .mixed()
+                .nullable()
+                .when('subject_dpe', {
+                    is: 'yes',
+                    then: schema =>
+                        schema.required(
+                            Translator.translate(
+                                'sellerHouseProperty.virginDPERequired',
+                            ),
+                        ),
+                    otherwise: schema => schema.nullable(),
+                }),
+            bouquet_price: yup
+                .string()
+                .nullable()
+                .required(
+                    Translator.translate(
+                        'sellerHouseProperty.bouquetPriceRequired',
+                    ),
+                )
+                .test('is-valid-number', '', v => !v || !isNaN(Number(v))),
+            desired_annuity: yup
+                .string()
+                .nullable()
+                .required(
+                    Translator.translate(
+                        'sellerHouseProperty.desiredAnnuityRequired',
+                    ),
+                )
+                .test('is-valid-number', '', v => !v || !isNaN(Number(v))),
+            annuitant_gender: yup
+                .string()
+                .nullable()
+                .required(
+                    Translator.translate('sellerHouseProperty.viagerHeadRequired'),
+                ),
+            annuitant_male_age: yup
+                .string()
+                .nullable()
+                .when('annuitant_gender', {
+                    is: (val: string) =>
+                        val === 'male' ||
+                        val === 'couple' ||
+                        val === 'man' ||
+                        val === 'both',
+                    then: schema =>
+                        schema.required(
+                            Translator.translate(
+                                'sellerHouseProperty.manAgeRequired',
+                            ),
+                        ),
+                    otherwise: schema => schema.nullable(),
+                })
+                .test('is-valid-number', '', v => !v || !isNaN(Number(v))),
+            annuitant_female_age: yup
+                .string()
+                .nullable()
+                .when('annuitant_gender', {
+                    is: (val: string) =>
+                        val === 'female' ||
+                        val === 'couple' ||
+                        val === 'woman' ||
+                        val === 'both',
+                    then: schema =>
+                        schema.required(
+                            Translator.translate(
+                                'sellerHouseProperty.womanAgeRequired',
+                            ),
+                        ),
+                    otherwise: schema => schema.nullable(),
+                })
+                .test('is-valid-number', '', v => !v || !isNaN(Number(v))),
+        });
+};
+
+export const sellerApartmentPropertySchema = () => {
+    return yup.object().shape({
+        living_area: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerApartmentProperty.livingAreaRequired',
+                ),
+            )
+            .test('is-valid-number', '', v => !v || !isNaN(Number(v))),
+        rooms: yup.number().nullable().min(0),
+        rooms_count: yup
+            .number()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerApartmentProperty.bedroomsRequired',
+                ),
+            )
+            .min(0),
+        shower_rooms: yup.number().nullable().min(0),
+        bathrooms: yup.number().nullable().min(0),
+        building_floors_count: yup.number().nullable().min(0),
+        property_condition: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerApartmentProperty.propertyConditionRequired',
+                ),
+            ),
+        has_parking: yup.mixed().nullable(),
+        has_garage: yup.mixed().nullable(),
+        orientation: yup.string().nullable(),
+        heating_system: yup.string().nullable(),
+        is_copropriety: yup.mixed().nullable(),
+        co_owned_lots_count: yup.string().nullable(),
+        annual_service_charges: yup.string().nullable(),
+        freeOrRented: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerApartmentProperty.freeOrRentedRequired',
+                ),
+            ),
+        monthly_rent: yup
+            .string()
+            .nullable()
+            .when('freeOrRented', {
+                is: 'rented',
+                then: schema =>
+                    schema.required(
+                        Translator.translate(
+                            'sellerApartmentProperty.monthlyRentRequired',
+                        ),
+                    ),
+                otherwise: schema => schema.notRequired().nullable(),
+            }),
+        annual_tax: yup
+            .string()
+            .nullable()
+            .when('freeOrRented', {
+                is: 'rented',
+                then: schema =>
+                    schema.required(
+                        Translator.translate(
+                            'sellerApartmentProperty.annualPropertyTaxRequired',
+                        ),
+                    ),
+                otherwise: schema => schema.notRequired().nullable(),
+            }),
+        subject_dpe: yup
+            .mixed()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerApartmentProperty.subjectToDPERequired',
+                ),
+            ),
+        is_dpe_blank: yup
+            .mixed()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerApartmentProperty.virginDPERequired',
+                ),
+            ),
+        dpe_grade: dpeGradeSchema('common.dpeClassRequired'),
+        dpe_date: dpeDateSchema('common.dpeDateRequired'),
+        primary_energy_consumption: dpeNumericSchema('common.primaryEnergyConsumptionRequired'),
+        estimated_annual_energy_cost: dpeNumericSchema('common.estimatedAnnualCostsRequired'),
+        ges_grade: gesGradeSchema('common.gesClassRequired'),
+        ges_date: gesDateSchema('common.gesDateRequired'),
+        greenhouse_gas_emissions: gesNumericSchema('common.greenhouseGasEmissionRequired'),
+        available_at: yup.string().nullable(),
+        construction_year: yup.string().nullable(),
+        is_extension_possible: yup.mixed().nullable(),
+        sanitation: yup.string().nullable(),
+    });
+};
+
+export const sellerViagerApartmentPropertySchema = () => {
+    return sellerApartmentPropertySchema()
+        .shape({
+            is_dpe_blank: yup
+                .mixed()
+                .nullable()
+                .when('subject_dpe', {
+                    is: 'yes',
+                    then: schema =>
+                        schema.required(
+                            Translator.translate(
+                                'sellerApartmentProperty.virginDPERequired',
+                            ),
+                        ),
+                    otherwise: schema => schema.nullable(),
+                }),
+            bouquet_price: yup
+                .string()
+                .nullable()
+                .required(
+                    Translator.translate(
+                        'sellerHouseProperty.bouquetPriceRequired',
+                    ),
+                )
+                .test('is-valid-number', '', v => !v || !isNaN(Number(v))),
+            desired_annuity: yup
+                .string()
+                .nullable()
+                .required(
+                    Translator.translate(
+                        'sellerHouseProperty.desiredAnnuityRequired',
+                    ),
+                )
+                .test('is-valid-number', '', v => !v || !isNaN(Number(v))),
+            annuitant_gender: yup
+                .string()
+                .nullable()
+                .required(
+                    Translator.translate(
+                        'sellerHouseProperty.viagerHeadRequired',
+                    ),
+                ),
+            annuitant_male_age: yup
+                .string()
+                .nullable()
+                .test('is-valid-number', '', v => !v || !isNaN(Number(v))),
+            annuitant_female_age: yup
+                .string()
+                .nullable()
+                .test('is-valid-number', '', v => !v || !isNaN(Number(v))),
+        });
+};
+
+export const sellerResaleApartmentPropertySchema = () => {
+    return yup.object().shape({
+        livingArea: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerApartmentProperty.livingAreaRequired',
+                ),
+            ),
+        bedrooms: yup
+            .number()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerApartmentProperty.bedroomsRequired',
+                ),
+            )
+            .min(0),
+        showerRooms: yup.number().nullable().min(0),
+        bathrooms: yup.number().nullable().min(0),
+        buildingFloors: yup.number().nullable().min(0),
+        propertyCondition: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerApartmentProperty.propertyConditionRequired',
+                ),
+            ),
+        parkingSpace: yup.string().nullable(),
+        garage: yup.string().nullable(),
+        exposure: yup.string().nullable(),
+        heatingSystem: yup.string().nullable(),
+        coOwnership: yup.string().nullable(),
+        numberOfLots: yup.string().nullable(),
+        annualCoOwnershipCharges: yup.string().nullable(),
+        freeOrRented: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerApartmentProperty.freeOrRentedRequired',
+                ),
+            ),
+        monthly_rent: yup
+            .string()
+            .nullable()
+            .when('freeOrRented', {
+                is: 'rented',
+                then: schema =>
+                    schema.required(
+                        Translator.translate(
+                            'sellerHouseProperty.monthlyRentRequired',
+                        ),
+                    ),
+                otherwise: schema => schema.nullable(),
+            }),
+        annual_tax: yup
+            .string()
+            .nullable()
+            .when('freeOrRented', {
+                is: 'rented',
+                then: schema =>
+                    schema.required(
+                        Translator.translate(
+                            'sellerApartmentProperty.annualPropertyTaxRequired',
+                        ),
+                    ),
+                otherwise: schema => schema.nullable(),
+            }),
+        subjectToDPE: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerApartmentProperty.subjectToDPERequired',
+                ),
+            ),
+        virginDPE: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerApartmentProperty.virginDPERequired',
+                ),
+            ),
+        dpeClass: yup.string().nullable(),
+        dpeDate: yup.string().nullable(),
+        primaryEnergyConsumption: yup.string().nullable(),
+        estimatedAnnualCosts: yup.string().nullable(),
+        gesClass: yup.string().nullable(),
+        gesDate: yup.string().nullable(),
+        greenhouseGasEmission: yup.string().nullable(),
+        propertyAvailability: yup.string().nullable(),
+        constructionYear: yup.string().nullable(),
+        possibleExtensions: yup.string().nullable(),
+        sanitationType: yup.string().nullable(),
+        bouquetPrice: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerHouseProperty.bouquetPriceRequired',
+                ),
+            ),
+        desiredAnnuity: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerHouseProperty.desiredAnnuityRequired',
+                ),
+            ),
+        viagerHead: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate('sellerHouseProperty.viagerHeadRequired'),
+            ),
+        manAge: yup
+            .string()
+            .nullable()
+            .when('viagerHead', {
+                is: (val: string) => val === 'man' || val === 'both',
+                then: schema =>
+                    schema.required(
+                        Translator.translate(
+                            'sellerHouseProperty.manAgeRequired',
+                        ),
+                    ),
+                otherwise: schema => schema.nullable(),
+            }),
+        womanAge: yup
+            .string()
+            .nullable()
+            .when('viagerHead', {
+                is: (val: string) => val === 'woman' || val === 'both',
+                then: schema =>
+                    schema.required(
+                        Translator.translate(
+                            'sellerHouseProperty.womanAgeRequired',
+                        ),
+                    ),
+                otherwise: schema => schema.nullable(),
+            }),
+    });
+};
+
+export const sellerLandPropertySchema = () => {
+    return yup.object().shape({
+        land_type: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate('sellerLandProperty.landTypeRequired'),
+            ),
+        land_area: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate('sellerLandProperty.landSurfaceRequired'),
+            )
+            .test('is-valid-number', '', v => !v || !isNaN(Number(v))),
+        is_builder_free: yup
+            .mixed()
+            .nullable()
+            .required(
+                Translator.translate('sellerLandProperty.freeBuilderRequired'),
+            ),
+        is_serviced: yup
+            .mixed()
+            .nullable()
+            .required(
+                Translator.translate('sellerLandProperty.servicedRequired'),
+            ),
+        plu_zone: yup.string().nullable(),
+        is_demarcated: yup
+            .mixed()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerLandProperty.boundaryDemarcationRequired',
+                ),
+            ),
+        annual_tax: yup.string().nullable().test('is-valid-number', '', v => !v || !isNaN(Number(v))),
+        available_at: yup.string().nullable(),
+    });
+};
+
+export const sellerBuildingPropertySchema = () => {
+    return yup.object().shape({
+        units_count: yup
+            .number()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerBuildingProperty.numberOfDwellingsRequired',
+                ),
+            )
+            .min(0),
+        total_surface: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerBuildingProperty.totalBuildingAreaRequired',
+                ),
+            )
+            .test('is-valid-number', '', v => !v || !isNaN(Number(v))),
+        is_copropriety: yup.mixed().nullable(),
+        co_owned_lots_count: yup.string().nullable(),
+        annual_service_charges: yup
+            .string()
+            .nullable()
+            .test('is-valid-number', '', v => !v || !isNaN(Number(v))),
+        has_garage: yup.mixed().nullable(),
+        has_parking: yup.mixed().nullable(),
+        orientation: yup.string().nullable(),
+        heating_system: yup.string().nullable(),
+        property_condition: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerBuildingProperty.propertyConditionRequired',
+                ),
+            ),
+        occupancy_status: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerBuildingProperty.freeOrRentedRequired',
+                ),
+            ),
+        annual_revenue: yup
+            .string()
+            .nullable()
+            .when('occupancy_status', {
+                is: 'rented',
+                then: schema =>
+                    schema.required(
+                        Translator.translate(
+                            'sellerBuildingProperty.annualIncomeRequired',
+                        ),
+                    ),
+                otherwise: schema => schema.notRequired().nullable(),
+            }),
+        annual_tax: yup
+            .string()
+            .nullable()
+            .when('occupancy_status', {
+                is: 'rented',
+                then: schema =>
+                    schema.required(
+                        Translator.translate(
+                            'sellerBuildingProperty.annualPropertyTaxRequired',
+                        ),
+                    ),
+                otherwise: schema => schema.notRequired().nullable(),
+            }),
+        subject_dpe: yup
+            .string()
+            .nullable()
+            .oneOf(['yes', 'no'])
+            .required(
+                Translator.translate(
+                    'sellerBuildingProperty.subjectToDPERequired',
+                ),
+            ),
+        is_dpe_blank: yup
+            .string()
+            .nullable()
+            .oneOf(['yes', 'no'])
+            .required(
+                Translator.translate(
+                    'sellerBuildingProperty.virginDPERequired',
+                ),
+            ),
+        dpe_grade: dpeGradeSchema('common.dpeClassRequired'),
+        dpe_date: dpeDateSchema('common.dpeDateRequired'),
+        primary_energy_consumption: dpeNumericSchema('common.primaryEnergyConsumptionRequired'),
+        estimated_annual_energy_cost: dpeNumericSchema('common.estimatedAnnualCostsRequired'),
+        ges_grade: gesGradeSchema('common.gesClassRequired'),
+        ges_date: gesDateSchema('common.gesDateRequired'),
+        greenhouse_gas_emissions: gesNumericSchema('common.greenhouseGasEmissionRequired'),
+        is_extension_possible: yup.mixed().nullable(),
+        available_at: yup.string().nullable(),
+        sanitation: yup.string().nullable(),
+    });
+};
+
+export const sellerOfficePropertySchema = () => {
+    return yup.object().shape({
+        total_surface: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerOfficeProperty.totalOfficeAreaRequired',
+                ),
+            )
+            .test('is-valid-number', '', v => !v || !isNaN(Number(v))),
+        separated_offices_count: yup
+            .number()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerOfficeProperty.numberOfOfficesRequired',
+                ),
+            )
+            .min(0),
+        is_open_space: yup.mixed().nullable(),
+        floor_level: yup.string().nullable(),
+        has_elevator: yup.mixed().nullable(),
+        has_sanitary_facilities: yup.mixed().nullable(),
+        has_parking: yup.mixed().nullable(),
+        has_garage: yup.mixed().nullable(),
+        property_condition: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerOfficeProperty.propertyConditionRequired',
+                ),
+            ),
+        is_disabled_accessible: yup.mixed().nullable(),
+        heating_system: yup.string().nullable(),
+        occupancy_status: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerOfficeProperty.freeOrRentedRequired',
+                ),
+            ),
+        annual_revenue: yup
+            .string()
+            .nullable()
+            .when('occupancy_status', {
+                is: 'rented',
+                then: (schema) =>
+                    schema.required(
+                        Translator.translate(
+                            'sellerOfficeProperty.annualIncomeRequired',
+                        ),
+                    ),
+                otherwise: (schema) => schema.nullable(),
+            }),
+        annual_tax: yup
+            .string()
+            .nullable()
+            .when('occupancy_status', {
+                is: 'rented',
+                then: (schema) =>
+                    schema.required(
+                        Translator.translate(
+                            'sellerOfficeProperty.annualPropertyTaxRequired',
+                        ),
+                    ),
+                otherwise: (schema) => schema.nullable(),
+            }),
+        subject_dpe: yup
+            .string()
+            .nullable()
+            .oneOf(['yes', 'no'])
+            .required(
+                Translator.translate(
+                    'sellerOfficeProperty.subjectToDPERequired',
+                ),
+            ),
+        is_dpe_blank: yup
+            .string()
+            .nullable()
+            .oneOf(['yes', 'no'])
+            .required(
+                Translator.translate('sellerOfficeProperty.virginDPERequired'),
+            ),
+        dpe_grade: dpeGradeSchema('common.dpeClassRequired'),
+        dpe_date: dpeDateSchema('common.dpeDateRequired'),
+        primary_energy_consumption: dpeNumericSchema('common.primaryEnergyConsumptionRequired'),
+        estimated_annual_energy_cost: dpeNumericSchema('common.estimatedAnnualCostsRequired'),
+        ges_grade: gesGradeSchema('common.gesClassRequired'),
+        ges_date: gesDateSchema('common.gesDateRequired'),
+        greenhouse_gas_emissions: gesNumericSchema('common.greenhouseGasEmissionRequired'),
+        is_copropriety: yup.mixed().nullable(),
+        co_owned_lots_count: yup.string().nullable(),
+        annual_service_charges: yup
+            .string()
+            .nullable()
+            .test('is-valid-number', '', v => !v || !isNaN(Number(v))),
+        construction_year: yup.string().nullable(),
+        available_at: yup.string().nullable(),
+        sanitation: yup.string().nullable(),
+    });
+};
+
+export const sellerCottagePropertySchema = () => {
+    return yup.object().shape({
+        gite_type: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerCottageProperty.propertyTypeRequired',
+                ),
+            ),
+        gites_count: yup.number().nullable().min(1),
+        living_area: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerCottageProperty.totalLivingAreaRequired',
+                ),
+            )
+            .test('is-valid-number', '', v => !v || !isNaN(Number(v)))
+            .test(
+                'living-area-lt-land-area',
+                Translator.translate('sellerCottageProperty.livingAreaGreaterThanLandArea'),
+                function (value) {
+                    const { land_area } = this.parent;
+                    if (!value || !land_area) return true;
+                    return Number(value) < Number(land_area);
+                },
+            ),
+        land_area: yup
+            .string()
+            .nullable()
+            .test('is-valid-number', '', v => !v || !isNaN(Number(v)))
+            .test(
+                'land-area-gt-living-area',
+                Translator.translate('sellerCottageProperty.landAreaLessThanLivingArea'),
+                function (value) {
+                    const { living_area } = this.parent;
+                    if (!value || !living_area) return true;
+                    return Number(value) > Number(living_area);
+                },
+            ),
+        rooms_count: yup.number().nullable().min(0),
+        shower_rooms: yup.number().nullable().min(0),
+        bathrooms: yup.number().nullable().min(0),
+        ground_floor: yup.mixed().nullable(),
+        has_garage: yup.mixed().nullable(),
+        pool: yup.mixed().nullable(),
+        heating_system: yup.string().nullable(),
+        property_condition: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerCottageProperty.propertyConditionRequired',
+                ),
+            ),
+        annual_revenue: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerCottageProperty.annualIncomeRequired',
+                ),
+            )
+            .test('is-valid-number', '', v => !v || !isNaN(Number(v))),
+        has_private_housing: yup.mixed().nullable(),
+        occupancy_status: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerCottageProperty.freeOrRentedRequired',
+                ),
+            ),
+        monthly_rent: yup
+            .string()
+            .nullable()
+            .when('occupancy_status', {
+                is: 'rented',
+                then: schema =>
+                    schema.required(
+                        Translator.translate(
+                            'sellerCottageProperty.monthlyRentRequired',
+                        ),
+                    ),
+                otherwise: schema => schema.notRequired().nullable(),
+            }),
+
+        annual_tax: yup
+            .string()
+            .nullable()
+            .when('occupancy_status', {
+                is: 'rented',
+                then: schema =>
+                    schema.required(
+                        Translator.translate(
+                            'sellerCottageProperty.annualPropertyTaxRequired',
+                        ),
+                    ),
+                otherwise: schema => schema.notRequired().nullable(),
+            }),
+        subject_dpe: yup
+            .mixed()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerCottageProperty.subjectToDPERequired',
+                ),
+            ),
+        is_dpe_blank: yup
+            .mixed()
+            .nullable()
+            .required(
+                Translator.translate('sellerCottageProperty.virginDPERequired'),
+            ),
+        dpe_grade: dpeGradeSchema('common.dpeClassRequired'),
+        dpe_date: dpeDateSchema('common.dpeDateRequired'),
+        primary_energy_consumption: dpeNumericSchema('common.primaryEnergyConsumptionRequired'),
+        estimated_annual_energy_cost: dpeNumericSchema('common.estimatedAnnualCostsRequired'),
+        ges_grade: gesGradeSchema('common.gesClassRequired'),
+        ges_date: gesDateSchema('common.gesDateRequired'),
+        greenhouse_gas_emissions: gesNumericSchema('common.greenhouseGasEmissionRequired'),
+        available_at: yup.string().nullable(),
+        construction_year: yup.string().nullable(),
+        is_extension_possible: yup.mixed().nullable(),
+        sanitation: yup.string().nullable(),
+    });
+};
+
+export const sellerGarageParkingPropertySchema = () => {
+    return yup.object().shape({
+        parking_type: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerGarageParkingProperty.parkingTypeRequired',
+                ),
+            ),
+        intended_use: yup.string().nullable(),
+        parking_surface: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerGarageParkingProperty.totalAreaRequired',
+                ),
+            )
+            .test('is-valid-number', '', v => !v || !isNaN(Number(v))),
+        occupancy_status: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerGarageParkingProperty.freeOrRentedRequired',
+                ),
+            ),
+        monthly_rent: yup
+            .string()
+            .nullable()
+            .when('occupancy_status', {
+                is: 'rented',
+                then: schema =>
+                    schema.required(
+                        Translator.translate(
+                            'sellerGarageParkingProperty.monthlyRentRequired',
+                        ),
+                    ),
+                otherwise: schema => schema.nullable(),
+            }),
+        annual_tax: yup
+            .string()
+            .nullable()
+            .when('occupancy_status', {
+                is: 'rented',
+                then: schema =>
+                    schema.required(
+                        Translator.translate(
+                            'sellerGarageParkingProperty.annualPropertyTaxRequired',
+                        ),
+                    ),
+                otherwise: schema => schema.nullable(),
+            }),
+        available_at: yup.string().nullable(),
+        construction_year: yup.string().nullable(),
+    });
+};
+
+export const sellerCommercialPropertySchema = () => {
+    return yup.object().shape({
+        total_surface: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerCommercialProperty.totalSurfaceRequired',
+                ),
+            )
+            .test('is-valid-number', '', v => !v || !isNaN(Number(v))),
+        shop_front_length: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerCommercialProperty.windowSurfaceRequired',
+                ),
+            )
+            .test('is-valid-number', '', v => !v || !isNaN(Number(v))),
+        is_prime_location: yup.mixed().nullable(),
+        parking_surface: yup
+            .string()
+            .nullable()
+            .test('is-valid-number', '', v => !v || !isNaN(Number(v))),
+        property_condition: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerCommercialProperty.propertyConditionRequired',
+                ),
+            ),
+        occupancy_status: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerCommercialProperty.freeOrRentedRequired',
+                ),
+            ),
+        monthly_rent: yup
+            .string()
+            .nullable()
+            .when('occupancy_status', {
+                is: 'rented',
+                then: schema =>
+                    schema.required(
+                        Translator.translate(
+                            'sellerCommercialProperty.monthlyRentRequired',
+                        ),
+                    ),
+                otherwise: schema => schema.notRequired().nullable(),
+            }),
+        annual_tax: yup
+            .string()
+            .nullable()
+            .when('occupancy_status', {
+                is: 'rented',
+                then: schema =>
+                    schema.required(
+                        Translator.translate(
+                            'sellerCommercialProperty.annualPropertyTaxRequired',
+                        ),
+                    ),
+                otherwise: schema => schema.notRequired().nullable(),
+            }),
+        is_disabled_accessible: yup.mixed().nullable(),
+        is_copropriety: yup.mixed().nullable(),
+        construction_year: yup.string().nullable(),
+        co_owned_lots_count: yup.string().nullable(),
+        annual_service_charges: yup.string().nullable(),
+    });
+};
+
+export const agentImmobilierSignUpSchema = () => {
+    return yup.object().shape({
+        email: yup
+            .string()
+            .nullable()
+            .trim()
+            .required(Translator.translate('signup.emailRequired'))
+            .email(Translator.translate('signup.emailInvalid'))
+            .matches(
+                regexEmail,
+                Translator.translate('signup.emailInvalid'),
+            ),
+        siret_number: yup
+            .string()
+            .nullable()
+            .trim()
+            .required(
+                Translator.translate('agentImmobilierInfo.siretSirenRequired'),
+            )
+            .length(14, Translator.translate('agentSignup.siretLength')),
+        card_number: yup
+            .string()
+            .nullable()
+            .trim()
+            .required(
+                Translator.translate(
+                    'agentImmobilierInfo.professionalCardNumberRequired',
+                ),
+            ),
+        last_name: yup
+            .string()
+            .nullable()
+            .trim()
+            .required(Translator.translate('agentSignup.lastNameRequired')),
+        first_name: yup
+            .string()
+            .nullable()
+            .trim()
+            .required(Translator.translate('agentSignup.firstNameRequired')),
+        agency_website_url: yup
+            .string()
+            .nullable()
+            .trim()
+            .url(Translator.translate('agentSignup.websiteInvalid')),
+        brand_name: yup
+            .string()
+            .nullable()
+            .trim()
+            .required(
+                Translator.translate('agentImmobilierInfo.brandNameRequired'),
+            ),
+        property_prefix: yup
+            .string()
+            .nullable()
+            .trim()
+            .max(2, Translator.translate('agentSignup.prefixMax')),
+        password: yup
+            .string()
+            .nullable()
+            .required(Translator.translate('signup.passwordRequired'))
+            .min(8, Translator.translate('signup.passwordMin'))
+            .max(32, Translator.translate('signup.passwordMax'))
+            .matches(
+                /^(?=.*[A-Za-z])(?=.*\d).+$/,
+                Translator.translate('agentSignup.passwordAlphaNumeric'),
+            ),
+    });
+};
+
+
+export const agentCommercialSignUpSchema = () => {
+    return yup.object().shape({
+        email: yup
+            .string()
+            .nullable()
+            .trim()
+            .required(Translator.translate('signup.emailRequired'))
+            .email(Translator.translate('signup.emailInvalid'))
+            .matches(
+                regexEmail,
+                Translator.translate('signup.emailInvalid'),
+            ),
+        siret_number: yup
+            .string()
+            .nullable()
+            .trim()
+            .test(
+                'is-valid-siret',
+                Translator.translate('agentSignup.siretLength'),
+                value => !value || /^\d{14}$/.test(value),
+            ),
+        last_name: yup
+            .string()
+            .nullable()
+            .trim()
+            .required(Translator.translate('agentSignup.lastNameRequired')),
+        first_name: yup
+            .string()
+            .nullable()
+            .trim()
+            .required(Translator.translate('agentSignup.firstNameRequired')),
+        agency_website_url: yup
+            .string()
+            .nullable()
+            .trim()
+            .url(Translator.translate('agentSignup.websiteInvalid')),
+        brand_name: yup
+            .string()
+            .nullable()
+            .trim()
+            .required(
+                Translator.translate('agentImmobilierInfo.brandNameRequired'),
+            ),
+        property_prefix: yup
+            .string()
+            .nullable()
+            .trim()
+            .max(2, Translator.translate('agentSignup.prefixMax')),
+        password: yup
+            .string()
+            .nullable()
+            .required(Translator.translate('signup.passwordRequired'))
+            .min(8, Translator.translate('signup.passwordMin'))
+            .max(32, Translator.translate('signup.passwordMax'))
+            .matches(
+                /^(?=.*[A-Za-z])(?=.*\d).+$/,
+                Translator.translate('agentSignup.passwordAlphaNumeric'),
+            ),
+    });
+};
+
+export const agentAgencySetupSchema = () => {
+    return yup.object().shape({
+        brand_name: yup
+            .string()
+            .nullable()
+            .trim()
+            .required(Translator.translate('agentAgencySetup.brandNameRequired')),
+        agency_website_url: yup
+            .string()
+            .nullable()
+            .trim()
+            .url(Translator.translate('agentSignup.websiteInvalid')),
+        property_prefix: yup
+            .string()
+            .nullable()
+            .trim()
+            .required(Translator.translate('agentAgencySetup.prefixRequired'))
+            .max(2, Translator.translate('agentSignup.prefixMax')),
+    });
+};
+
+export const agentImmobilierInfoSchema = () => {
+    return yup.object().shape({
+        agencyName: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate('agentImmobilierInfo.agencyNameRequired'),
+            ),
+        siretSiren: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate('agentImmobilierInfo.siretSirenRequired'),
+            ),
+        phoneNumber: yup.string().nullable(),
+        professionalCardNumber: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'agentImmobilierInfo.professionalCardNumberRequired',
+                ),
+            ),
+        brandName: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate('agentImmobilierInfo.brandNameRequired'),
+            ),
+    });
+};
+
+export const agentApartmentPropertySchema = () =>
+    yup.object().shape({
+        living_area: yup.string().required(),
+        rooms: yup.number().required(),
+        rooms_count: yup.number().required(),
+        shower_rooms: yup.number().nullable(),
+        bathrooms: yup.number().nullable(),
+        building_floors_count: yup.number().nullable(),
+
+        property_condition: yup.string().required(),
+        has_parking: yup.string().nullable(),
+        has_garage: yup.string().nullable(),
+        orientation: yup.string().nullable(),
+        heating_system: yup.string().nullable(),
+
+        is_copropriety: yup.string().nullable(),
+        co_owned_lots_count: yup.string().when('is_copropriety', {
+            is: 'yes',
+            then: schema => schema.required(),
+            otherwise: schema => schema.nullable(),
+        }),
+        annual_service_charges: yup.string().when('is_copropriety', {
+            is: 'yes',
+            then: schema => schema.required(),
+            otherwise: schema => schema.nullable(),
+        }),
+        no_ongoing_proceedings: yup.string().when('is_copropriety', {
+            is: 'yes',
+            then: schema => schema.required(),
+            otherwise: schema => schema.nullable(),
+        }),
+
+        freeOrRented: yup.string().required(),
+        monthly_rent: yup.string().when('freeOrRented', {
+            is: 'rented',
+            then: schema => schema.required(),
+            otherwise: schema => schema.nullable(),
+        }),
+        annual_tax: yup.string().when('freeOrRented', {
+            is: 'rented',
+            then: schema => schema.required(),
+            otherwise: schema => schema.nullable(),
+        }),
+
+        subject_dpe: yup
+            .string()
+            .nullable()
+            .oneOf(['yes', 'no'])
+            .required(),
+        is_dpe_blank: yup
+            .string()
+            .nullable()
+            .oneOf(['yes', 'no'])
+            .required(),
+
+        dpe_grade: dpeGradeSchemaSimple(),
+        dpe_date: dpeDateSchemaSimple(),
+        primary_energy_consumption: dpeNumericSchemaSimple(),
+        estimated_annual_energy_cost: dpeNumericSchemaSimple(),
+        ges_grade: gesGradeSchemaSimple(),
+        ges_date: gesDateSchemaSimple(),
+        greenhouse_gas_emissions: gesNumericSchemaSimple(),
+
+        available_at: yup.string().nullable(),
+        construction_year: yup.string().nullable(),
+        is_extension_possible: yup.string().nullable(),
+        sanitation: yup.string().nullable(),
+    });
+
+export const agentLandPropertySchema = () => {
+    return yup.object().shape({
+        land_type: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate('sellerLandProperty.landTypeRequired'),
+            ),
+        land_area: yup
+            .string()
+            .nullable()
+            .required(
+                Translator.translate('sellerLandProperty.landSurfaceRequired'),
+            )
+            .test('is-valid-number', '', v => !v || !isNaN(Number(v))),
+        is_builder_free: yup
+            .mixed()
+            .nullable()
+            .required(
+                Translator.translate('sellerLandProperty.freeBuilderRequired'),
+            ),
+        is_serviced: yup
+            .mixed()
+            .nullable()
+            .required(
+                Translator.translate('sellerLandProperty.servicedRequired'),
+            ),
+        plu_zone: yup.string().nullable(),
+        is_demarcated: yup
+            .mixed()
+            .nullable()
+            .required(
+                Translator.translate(
+                    'sellerLandProperty.boundaryDemarcationRequired',
+                ),
+            ),
+        annual_tax: yup.string().nullable().test('is-valid-number', '', v => !v || !isNaN(Number(v))),
+        available_at: yup.string().nullable(),
+    });
+};
+
+export const agentBuildingPropertySchema = () =>
+    yup.object().shape({
+        units_count: yup.number().required(),
+        total_surface: yup.string().required(),
+
+        is_copropriety: yup.string().nullable(),
+        co_owned_lots_count: yup.string().when('is_copropriety', {
+            is: 'yes',
+            then: schema => schema.required(),
+            otherwise: schema => schema.nullable(),
+        }),
+        annual_service_charges: yup.string().when('is_copropriety', {
+            is: 'yes',
+            then: schema => schema.required(),
+            otherwise: schema => schema.nullable(),
+        }),
+        no_ongoing_proceedings: yup.string().when('is_copropriety', {
+            is: 'yes',
+            then: schema => schema.required(),
+            otherwise: schema => schema.nullable(),
+        }),
+
+        has_garage: yup.string().nullable(),
+        has_parking: yup.string().nullable(),
+        orientation: yup.string().nullable(),
+        heating_system: yup.string().nullable(),
+        property_condition: yup.string().required(),
+
+        occupancy_status: yup.string().required(),
+        monthly_rent: yup.string().when('occupancy_status', {
+            is: 'rented',
+            then: schema => schema.required(),
+            otherwise: schema => schema.nullable(),
+        }),
+        annual_tax: yup.string().when('occupancy_status', {
+            is: 'rented',
+            then: schema => schema.required(),
+            otherwise: schema => schema.nullable(),
+        }),
+
+        subject_dpe: yup
+            .string()
+            .nullable()
+            .oneOf(['yes', 'no'])
+            .required(),
+        is_dpe_blank: yup
+            .string()
+            .nullable()
+            .oneOf(['yes', 'no'])
+            .required(),
+        dpe_grade: dpeGradeSchemaSimple(),
+        dpe_date: dpeDateSchemaSimple(),
+        primary_energy_consumption: dpeNumericSchemaSimple(),
+        estimated_annual_energy_cost: dpeNumericSchemaSimple(),
+        ges_grade: gesGradeSchemaSimple(),
+        ges_date: gesDateSchemaSimple(),
+        greenhouse_gas_emissions: gesNumericSchemaSimple(),
+
+        is_extension_possible: yup.string().nullable(),
+        available_at: yup.string().nullable(),
+        sanitation: yup.string().nullable(),
+    });
+
+export const agentCommercialPropertySchema = () =>
+    yup.object().shape({
+        total_surface: yup.string().required(),
+        shop_front_length: yup.string().required(),
+        is_prime_location: yup.string().nullable(),
+        parking_surface: yup.string().nullable(),
+        property_condition: yup.string().required(),
+
+        occupancy_status: yup.string().required(),
+        monthly_rent: yup.string().when('occupancy_status', {
+            is: 'rented',
+            then: schema => schema.required(),
+            otherwise: schema => schema.nullable(),
+        }),
+        annual_tax: yup.string().when('occupancy_status', {
+            is: 'rented',
+            then: schema => schema.required(),
+            otherwise: schema => schema.nullable(),
+        }),
+
+        is_disabled_accessible: yup.string().nullable(),
+        is_copropriety: yup.string().nullable(),
+        co_owned_lots_count: yup.string().when('is_copropriety', {
+            is: 'yes',
+            then: schema => schema.required(),
+            otherwise: schema => schema.nullable(),
+        }),
+        annual_service_charges: yup.string().when('is_copropriety', {
+            is: 'yes',
+            then: schema => schema.required(),
+            otherwise: schema => schema.nullable(),
+        }),
+        no_ongoing_proceedings: yup.string().when('is_copropriety', {
+            is: 'yes',
+            then: schema => schema.required(),
+            otherwise: schema => schema.nullable(),
+        }),
+
+        construction_year: yup.string().nullable(),
+    });
+
+export const agentParkingPropertySchema = () =>
+    yup.object().shape({
+        parking_type: yup.string().required(),
+        intended_use: yup.string().nullable(),
+        parking_surface: yup.string().required(),
+        occupancy_status: yup.string().required(),
+        monthly_rent: yup.string().when('occupancy_status', {
+            is: 'rented',
+            then: schema => schema.required(),
+            otherwise: schema => schema.nullable(),
+        }),
+        annual_tax: yup.string().when('occupancy_status', {
+            is: 'rented',
+            then: schema => schema.required(),
+            otherwise: schema => schema.nullable(),
+        }),
+        available_at: yup.string().nullable(),
+        construction_year: yup.string().nullable(),
+    });
+
+export const agentGitePropertySchema = () =>
+    yup.object().shape({
+        gite_type: yup.string().required(),
+        gites_count: yup.number().required(),
+        living_area: yup
+            .string()
+            .required()
+            .test(
+                'living-area-lt-land-area',
+                Translator.translate('agentGiteProperty.livingAreaGreaterThanLandArea'),
+                function (value) {
+                    const { land_area } = this.parent;
+                    if (!value || !land_area) return true;
+                    if (isNaN(Number(value)) || isNaN(Number(land_area))) {
+                        return true;
+                    }
+                    return Number(value) < Number(land_area);
+                },
+            ),
+        land_area: yup
+            .string()
+            .nullable()
+            .test(
+                'land-area-gt-living-area',
+                Translator.translate('agentGiteProperty.landAreaLessThanLivingArea'),
+                function (value) {
+                    const { living_area } = this.parent;
+                    if (!value || !living_area) return true;
+                    if (isNaN(Number(value)) || isNaN(Number(living_area))) {
+                        return true;
+                    }
+                    return Number(value) > Number(living_area);
+                },
+            ),
+        rooms_count: yup.number().nullable(),
+        shower_rooms: yup.number().nullable(),
+        bathrooms: yup.number().nullable(),
+        ground_floor: yup.string().nullable(),
+        has_garage: yup.string().nullable(),
+        pool: yup.string().nullable(),
+        heating_system: yup.string().nullable(),
+        property_condition: yup.string().required(),
+        annual_revenue: yup.string().required(),
+        has_private_housing: yup.string().nullable(),
+        occupancy_status: yup.string().required(),
+        monthly_rent: yup.string().when('occupancy_status', {
+            is: 'rented',
+            then: schema => schema.required(),
+            otherwise: schema => schema.nullable(),
+        }),
+        annual_tax: yup.string().when('occupancy_status', {
+            is: 'rented',
+            then: schema => schema.required(),
+            otherwise: schema => schema.nullable(),
+        }),
+        subject_dpe: yup
+            .string()
+            .nullable()
+            .oneOf(['yes', 'no'])
+            .required(),
+        is_dpe_blank: yup
+            .string()
+            .nullable()
+            .oneOf(['yes', 'no'])
+            .required(),
+        dpe_grade: dpeGradeSchemaSimple(),
+        dpe_date: dpeDateSchemaSimple(),
+        primary_energy_consumption: dpeNumericSchemaSimple(),
+        estimated_annual_energy_cost: dpeNumericSchemaSimple(),
+        ges_grade: gesGradeSchemaSimple(),
+        ges_date: gesDateSchemaSimple(),
+        greenhouse_gas_emissions: gesNumericSchemaSimple(),
+        available_at: yup.string().nullable(),
+        construction_year: yup.string().nullable(),
+        is_extension_possible: yup.string().nullable(),
+        sanitation: yup.string().nullable(),
+    });
+
+export const agentOfficePropertySchema = () =>
+    yup.object().shape({
+        total_surface: yup.string().required(),
+        separated_offices_count: yup.number().required(),
+        is_open_space: yup.string().nullable(),
+        floor_level: yup.string().nullable(),
+        has_elevator: yup.string().nullable(),
+        has_sanitary_facilities: yup.string().nullable(),
+        has_parking: yup.string().nullable(),
+        has_garage: yup.string().nullable(),
+        property_condition: yup.string().required(),
+        disabled_accessibility_preference: yup.string().nullable(),
+        heating_system: yup.string().nullable(),
+        occupancy_status: yup.string().required(),
+        monthly_rent: yup.string().when('occupancy_status', {
+            is: 'rented',
+            then: schema => schema.required(),
+            otherwise: schema => schema.nullable(),
+        }),
+        annual_tax: yup.string().when('occupancy_status', {
+            is: 'rented',
+            then: schema => schema.required(),
+            otherwise: schema => schema.nullable(),
+        }),
+        subject_dpe: yup
+            .string()
+            .nullable()
+            .oneOf(['yes', 'no'])
+            .required(),
+        is_dpe_blank: yup
+            .string()
+            .nullable()
+            .oneOf(['yes', 'no'])
+            .required(),
+        dpe_grade: dpeGradeSchemaSimple(),
+        dpe_date: dpeDateSchemaSimple(),
+        primary_energy_consumption: dpeNumericSchemaSimple(),
+        estimated_annual_energy_cost: dpeNumericSchemaSimple(),
+        ges_grade: gesGradeSchemaSimple(),
+        ges_date: gesDateSchemaSimple(),
+        greenhouse_gas_emissions: gesNumericSchemaSimple(),
+        is_copropriety: yup.string().nullable(),
+        co_owned_lots_count: yup.string().when('is_copropriety', {
+            is: 'yes',
+            then: schema => schema.required(),
+            otherwise: schema => schema.nullable(),
+        }),
+        annual_service_charges: yup.string().when('is_copropriety', {
+            is: 'yes',
+            then: schema => schema.required(),
+            otherwise: schema => schema.nullable(),
+        }),
+        no_ongoing_proceedings: yup.string().when('is_copropriety', {
+            is: 'yes',
+            then: schema => schema.required(),
+            otherwise: schema => schema.nullable(),
+        }),
+        construction_year: yup.string().nullable(),
+        available_at: yup.string().nullable(),
+        sanitation: yup.string().nullable(),
+    });