exnet-routing 1.2.1 → 1.2.3

package/dist/@test/routes/admin.test.js

@@ -212,8 +212,8 @@ describe("Admin Routes", () => {
                 isService: false,
                 customerId: 1,
                 address: "1 rue de Test",
-                submittedToFrenchVat: true,
-                actif: true,
+                isSubmittedToFrenchVat: true,
+                isActif: true,
             };
             const mockResponse = {
                 success: true,

package/dist/@test/routes/ops.test.js

@@ -63,7 +63,7 @@ describe("Ops Routes", () => {
     });
     describe("shipping dashboard", () => {
         const interfaces = ["paris", "medical", "service"];
-        const statuses = ["enAttente", "enCours", "livrer", "aArriver", "facturer", "annuler"];
+        const statuses = ["enAttente", "enCours", "livrer", "aArchiver", "facturer", "annuler"];
         interfaces.forEach((userInterface) => {
             statuses.forEach((status) => {
                 it(`should get ${status} shipping list for ${userInterface}`, async () => {

package/dist/core/api/_type.d.ts

@@ -0,0 +1,180 @@
+import { z } from "zod";
+import { index } from "../index";
+type ApiService = typeof index;
+export type IHttpMethod = "GET" | "POST" | "PUT" | "DELETE";
+export type IHttpMethodWithBody = "POST" | "PUT" | "DELETE";
+export type IHttpMethodWithoutBody = "GET";
+export declare const response: <R extends z.ZodObject<any> | z.ZodArray<any> | z.ZodNull>(data: R) => z.ZodUnion<[z.ZodObject<{
+    data: R;
+    message: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodNumber>;
+    error: z.ZodOptional<z.ZodNever>;
+    success: z.ZodLiteral<true>;
+}, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    data: R;
+    message: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodNumber>;
+    error: z.ZodOptional<z.ZodNever>;
+    success: z.ZodLiteral<true>;
+}>, any> extends infer T ? { [k in keyof T]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    data: R;
+    message: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodNumber>;
+    error: z.ZodOptional<z.ZodNever>;
+    success: z.ZodLiteral<true>;
+}>, any>[k]; } : never, z.baseObjectInputType<{
+    data: R;
+    message: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodNumber>;
+    error: z.ZodOptional<z.ZodNever>;
+    success: z.ZodLiteral<true>;
+}> extends infer T_1 ? { [k_1 in keyof T_1]: z.baseObjectInputType<{
+    data: R;
+    message: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodNumber>;
+    error: z.ZodOptional<z.ZodNever>;
+    success: z.ZodLiteral<true>;
+}>[k_1]; } : never>, z.ZodObject<{
+    data: z.ZodNever;
+    message: z.ZodString;
+    status: z.ZodOptional<z.ZodNumber>;
+    error: z.ZodObject<{
+        message: z.ZodString;
+        info: z.ZodObject<{
+            status: z.ZodNumber;
+            code: z.ZodString;
+            messages: z.ZodArray<z.ZodObject<{
+                message: z.ZodString;
+                rule: z.ZodOptional<z.ZodString>;
+                field: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                message: string;
+                rule?: string | undefined;
+                field?: string | undefined;
+            }, {
+                message: string;
+                rule?: string | undefined;
+                field?: string | undefined;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            status: number;
+            code: string;
+            messages: {
+                message: string;
+                rule?: string | undefined;
+                field?: string | undefined;
+            }[];
+        }, {
+            status: number;
+            code: string;
+            messages: {
+                message: string;
+                rule?: string | undefined;
+                field?: string | undefined;
+            }[];
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        info: {
+            status: number;
+            code: string;
+            messages: {
+                message: string;
+                rule?: string | undefined;
+                field?: string | undefined;
+            }[];
+        };
+    }, {
+        message: string;
+        info: {
+            status: number;
+            code: string;
+            messages: {
+                message: string;
+                rule?: string | undefined;
+                field?: string | undefined;
+            }[];
+        };
+    }>;
+    success: z.ZodNever;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    data: never;
+    error: {
+        message: string;
+        info: {
+            status: number;
+            code: string;
+            messages: {
+                message: string;
+                rule?: string | undefined;
+                field?: string | undefined;
+            }[];
+        };
+    };
+    success: never;
+    status?: number | undefined;
+}, {
+    message: string;
+    data: never;
+    error: {
+        message: string;
+        info: {
+            status: number;
+            code: string;
+            messages: {
+                message: string;
+                rule?: string | undefined;
+                field?: string | undefined;
+            }[];
+        };
+    };
+    success: never;
+    status?: number | undefined;
+}>]>;
+export type IBaseRoute = {
+    url: string;
+    searchParams?: z.ZodObject<any>;
+    params?: z.ZodObject<any>;
+    response: ReturnType<typeof response>;
+};
+export type IRoute = IBaseRoute & ({
+    method: IHttpMethodWithBody;
+    body?: z.ZodObject<any>;
+} | {
+    method: IHttpMethodWithoutBody;
+    body?: never;
+});
+export type NestedRoute = {
+    [K: string]: NestedRoute | IRoute;
+};
+export declare const IApiType: <T extends NestedRoute>(api: T) => T;
+export type TransformApi<T extends NestedRoute> = {
+    [K in keyof T]: T[K] extends NestedRoute ? TransformApi<T[K]> : T[K]["body"] extends z.ZodObject<any> ? T[K]["searchParams"] extends z.ZodObject<any> ? T[K]["params"] extends z.ZodObject<any> ? (params: {
+        body: z.infer<T[K]["body"]>;
+        searchParams: z.infer<T[K]["searchParams"]>;
+        queryParams: z.infer<T[K]["params"]>;
+    }) => Promise<z.infer<T[K]["response"]>> : (params: {
+        body: z.infer<T[K]["body"]>;
+        searchParams: z.infer<T[K]["searchParams"]>;
+    }) => Promise<z.infer<T[K]["response"]>> : T[K]["params"] extends z.ZodObject<any> ? (params: {
+        body: z.infer<T[K]["body"]>;
+        queryParams: z.infer<T[K]["params"]>;
+    }) => Promise<z.infer<T[K]["response"]>> : (params: {
+        body: z.infer<T[K]["body"]>;
+    }) => Promise<z.infer<T[K]["response"]>> : T[K]["searchParams"] extends z.ZodObject<any> ? T[K]["params"] extends z.ZodObject<any> ? (params: {
+        searchParams: z.infer<T[K]["searchParams"]>;
+        queryParams: z.infer<T[K]["params"]>;
+    }) => Promise<z.infer<T[K]["response"]>> : (params: {
+        searchParams: z.infer<T[K]["searchParams"]>;
+    }) => Promise<z.infer<T[K]["response"]>> : T[K]["params"] extends z.ZodObject<any> ? (params: {
+        queryParams: z.infer<T[K]["params"]>;
+    }) => Promise<z.infer<T[K]["response"]>> : () => Promise<z.infer<T[K]["response"]>>;
+};
+export type ApiRouteResponse<Route extends (...args: any) => Promise<any>> = Awaited<ReturnType<Route>>["data"];
+export type IRouterApi = TransformApi<ApiService>;
+export type IRouteFunction = (...params: any[]) => Promise<IRoute["response"]>;
+export type IRouteGroup = {
+    [name: string]: IRouteFunction | IRouteGroup;
+};
+export {};

package/dist/core/api/_type.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IApiType = exports.response = void 0;
+const zod_1 = require("zod");
+const response = (data) => {
+    return zod_1.z
+        .object({
+        data,
+        message: zod_1.z.string().optional(),
+        status: zod_1.z.number().optional(),
+        error: zod_1.z.never().optional(),
+        success: zod_1.z.literal(true),
+    })
+        .or(zod_1.z.object({
+        data: zod_1.z.never(),
+        message: zod_1.z.string(),
+        status: zod_1.z.number().optional(),
+        error: zod_1.z.object({
+            message: zod_1.z.string(),
+            info: zod_1.z.object({
+                status: zod_1.z.number(),
+                code: zod_1.z.string(),
+                messages: zod_1.z.array(zod_1.z.object({
+                    message: zod_1.z.string(),
+                    rule: zod_1.z.string().optional(),
+                    field: zod_1.z.string().optional(),
+                })),
+            }),
+        }),
+        success: zod_1.z.never(),
+    }));
+};
+exports.response = response;
+const IApiType = (api) => api;
+exports.IApiType = IApiType;

package/dist/core/api/_untils.d.ts

@@ -0,0 +1,16 @@
+import { AxiosHeaders } from "axios";
+import { IRoute, IRouteGroup, IRouterApi } from "./_type";
+import { NestedRoute } from "./_type";
+export declare const apiUrlBuilder: (segment?: string, baseUrl?: string, host?: string) => string;
+export declare const apiFetch: {
+    setHostApi: (h: string) => void;
+    setBaseUrl: (b: string) => void;
+    setHeaders: (h: AxiosHeaders | undefined) => void;
+    fetch: (urlInput: string, method?: RequestInit["method"] | undefined, body?: any, searchParams?: any, queryParams?: {
+        [key: string]: string;
+    }) => Promise<any>;
+};
+export declare const isRoute: (value: NestedRoute | IRoute) => value is IRoute;
+export declare const isSubRoute: (value: NestedRoute | IRoute) => value is NestedRoute;
+export declare const parseApiRoute: <T extends NestedRoute | IRoute, K extends IRouteGroup>(key: string | undefined, subRoute: T, result: K, hostApi: string, basePath: string, headers?: AxiosHeaders) => K;
+export declare const parseApiRoutes: <T extends NestedRoute>(api: T, hostApi: string, basePath: string, headers?: AxiosHeaders) => IRouterApi;

package/dist/core/api/_untils.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseApiRoutes = exports.parseApiRoute = exports.isSubRoute = exports.isRoute = exports.apiFetch = exports.apiUrlBuilder = void 0;
+const path_1 = require("path");
+const axios_1 = __importDefault(require("axios"));
+let host;
+let baseUrl;
+let headers;
+const apiUrlBuilder = (segment = "", baseUrl = "", host = "") => {
+    const path = (0, path_1.join)(baseUrl, segment);
+    return host + path;
+};
+exports.apiUrlBuilder = apiUrlBuilder;
+exports.apiFetch = {
+    setHostApi: (h) => {
+        host = h;
+    },
+    setBaseUrl: (b) => {
+        baseUrl = b;
+    },
+    setHeaders: (h) => {
+        headers = h;
+    },
+    fetch: async (urlInput, method, body, searchParams, queryParams) => {
+        try {
+            let url = (0, exports.apiUrlBuilder)(urlInput, baseUrl, host);
+            if (queryParams) {
+                Object.entries(queryParams).forEach(([key, value]) => {
+                    if (value !== undefined && value !== null) {
+                        url = url.replace(`:${key}`, encodeURIComponent(String(value)));
+                    }
+                });
+            }
+            if (searchParams) {
+                const searchParamsString = typeof searchParams === "string"
+                    ? searchParams
+                    : Object.entries(searchParams)
+                        .filter(([_, value]) => value !== undefined && value !== null)
+                        .map(([key, value]) => {
+                        const encodedKey = encodeURIComponent(key);
+                        const encodedValue = Array.isArray(value) || typeof value === "object"
+                            ? encodeURIComponent(JSON.stringify(value))
+                            : encodeURIComponent(String(value !== null && value !== void 0 ? value : ""));
+                        return `${encodedKey}=${encodedValue}`;
+                    })
+                        .join("&");
+                url += (url.includes("?") ? "&" : "?") + searchParamsString;
+            }
+            const res = await (0, axios_1.default)({
+                headers: {
+                    "Content-Type": "application/json",
+                    "Access-Control-Allow-Origin": "*",
+                    "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, PATCH, OPTIONS",
+                    "Access-Control-Allow-Headers": "Content-Type, Authorization",
+                    "Access-Control-Allow-Credentials": "true",
+                    "Access-Control-Allow-Private-Network": "true",
+                    Accept: "application/json",
+                    ...headers,
+                },
+                method,
+                url,
+                data: body,
+            });
+            return res.data;
+        }
+        catch (error) {
+            throw new Error(`Request failed: ${error}`);
+        }
+    },
+};
+const isRoute = (value) => {
+    return "method" in value;
+};
+exports.isRoute = isRoute;
+const isSubRoute = (value) => {
+    return !(0, exports.isRoute)(value);
+};
+exports.isSubRoute = isSubRoute;
+const createRouteFunction = (route, apiFetch) => {
+    const createFetchFunction = (paramTypes) => {
+        return async (...args) => {
+            const params = paramTypes.reduce((acc, type) => {
+                acc[type] = args[0][type] || null;
+                return acc;
+            }, {});
+            return await apiFetch.fetch(route.url, route.method, params.body, params.searchParams, params.queryParams);
+        };
+    };
+    if (route.body) {
+        if (route.searchParams) {
+            return route.params
+                ? createFetchFunction(["body", "searchParams", "queryParams"])
+                : createFetchFunction(["body", "searchParams"]);
+        }
+        return route.params ? createFetchFunction(["body", "queryParams"]) : createFetchFunction(["body"]);
+    }
+    if (route.searchParams) {
+        return route.params ? createFetchFunction(["searchParams", "queryParams"]) : createFetchFunction(["searchParams"]);
+    }
+    return route.params ? createFetchFunction(["queryParams"]) : createFetchFunction([]);
+};
+const parseApiRoute = (key, subRoute, result, hostApi, basePath, headers) => {
+    var _a;
+    exports.apiFetch.setHostApi(hostApi);
+    exports.apiFetch.setBaseUrl(basePath);
+    exports.apiFetch.setHeaders(headers);
+    if ((0, exports.isRoute)(subRoute) && key) {
+        ;
+        result = createRouteFunction(subRoute, exports.apiFetch);
+    }
+    else if ((0, exports.isSubRoute)(subRoute)) {
+        for (const [key, value] of Object.entries(subRoute)) {
+            ;
+            result[key] = (0, exports.parseApiRoute)(key, value, ((_a = result[key]) !== null && _a !== void 0 ? _a : {}), hostApi, basePath, headers);
+        }
+    }
+    return result;
+};
+exports.parseApiRoute = parseApiRoute;
+const parseApiRoutes = (api, hostApi, basePath, headers) => {
+    const result = {};
+    const response = (0, exports.parseApiRoute)(undefined, api, result, hostApi, basePath, headers);
+    return response;
+};
+exports.parseApiRoutes = parseApiRoutes;

package/dist/core/index.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.index = void 0;
 const public_1 = require("./../routes/public");
 const user_1 = require("./../routes/user");
-const _type_1 = require("./_type");
+const _type_1 = require("./api/_type");
 const driver_1 = require("./../routes/driver");
 const admin_1 = require("./../routes/admin");
 const ops_1 = require("./../routes/ops");

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { index } from "./core/index";
-import { TransformApi } from "./core/_type";
+import { TransformApi } from "./core/api/_type";
 import { AxiosHeaderValue } from "axios";
 type RecordHeaders = {
     [x: string]: AxiosHeaderValue | undefined;

package/dist/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.APIRouter = void 0;
-const _untils_1 = require("./core/_untils");
+const _untils_1 = require("./core/api/_untils");
 const index_1 = require("./core/index");
 const axios_1 = require("axios");
 class APIRouter {

package/dist/models/_billing_center.d.ts

@@ -20,16 +20,14 @@ export declare const BillingCenterSchema: z.ZodObject<{
     telephone: z.ZodNullable<z.ZodString>;
     email: z.ZodNullable<z.ZodString>;
     intraVatNumber: z.ZodNullable<z.ZodString>;
-    submittedToFrenchVat: z.ZodBoolean;
+    isSubmittedToFrenchVat: z.ZodBoolean;
     comments: z.ZodNullable<z.ZodString>;
     numCodeOne: z.ZodNullable<z.ZodString>;
     numCodeTwo: z.ZodNullable<z.ZodString>;
-    activeMailInstruction: z.ZodBoolean;
-    actif: z.ZodBoolean;
-    activeVariation: z.ZodBoolean;
-    valeurCustomer: z.ZodBoolean;
-    customerName: z.ZodBoolean;
-    mailing: z.ZodBoolean;
+    isActiveMailInstruction: z.ZodBoolean;
+    isActif: z.ZodBoolean;
+    isActiveVariation: z.ZodBoolean;
+    isMailing: z.ZodBoolean;
     isParis: z.ZodBoolean;
     isMedical: z.ZodBoolean;
     isService: z.ZodBoolean;
@@ -219,16 +217,14 @@ export declare const BillingCenterSchema: z.ZodObject<{
     telephone: string | null;
     email: string | null;
     intraVatNumber: string | null;
-    submittedToFrenchVat: boolean;
     numeroEori: string | null;
     comments: string | null;
     numCodeOne: string | null;
     numCodeTwo: string | null;
+    isActif: boolean;
     isParis: boolean;
     isMedical: boolean;
     isService: boolean;
-    actif: boolean;
-    valeurCustomer: boolean;
     dirigeant: string | null;
     dirigeantTel: string | null;
     dirigeantEmail: string | null;
@@ -251,10 +247,10 @@ export declare const BillingCenterSchema: z.ZodObject<{
     numeroSiren: string | null;
     invoiceMailOne: string;
     invoiceMailTwo: string | null;
-    activeMailInstruction: boolean;
-    activeVariation: boolean;
-    customerName: boolean;
-    mailing: boolean;
+    isSubmittedToFrenchVat: boolean;
+    isActiveMailInstruction: boolean;
+    isActiveVariation: boolean;
+    isMailing: boolean;
     deuxBordereaux: string | null;
     customerId: number | null;
     customer?: {
@@ -323,16 +319,14 @@ export declare const BillingCenterSchema: z.ZodObject<{
     telephone: string | null;
     email: string | null;
     intraVatNumber: string | null;
-    submittedToFrenchVat: boolean;
     numeroEori: string | null;
     comments: string | null;
     numCodeOne: string | null;
     numCodeTwo: string | null;
+    isActif: boolean;
     isParis: boolean;
     isMedical: boolean;
     isService: boolean;
-    actif: boolean;
-    valeurCustomer: boolean;
     dirigeant: string | null;
     dirigeantTel: string | null;
     dirigeantEmail: string | null;
@@ -355,10 +349,10 @@ export declare const BillingCenterSchema: z.ZodObject<{
     numeroSiren: string | null;
     invoiceMailOne: string;
     invoiceMailTwo: string | null;
-    activeMailInstruction: boolean;
-    activeVariation: boolean;
-    customerName: boolean;
-    mailing: boolean;
+    isSubmittedToFrenchVat: boolean;
+    isActiveMailInstruction: boolean;
+    isActiveVariation: boolean;
+    isMailing: boolean;
     deuxBordereaux: string | null;
     customerId: number | null;
     customer?: {
@@ -430,16 +424,15 @@ export declare const BillingCenterCreateSchema: z.ZodObject<{
     telephone: z.ZodOptional<z.ZodString>;
     email: z.ZodOptional<z.ZodString>;
     intraVatNumber: z.ZodOptional<z.ZodString>;
-    submittedToFrenchVat: z.ZodBoolean;
+    isSubmittedToFrenchVat: z.ZodBoolean;
     comments: z.ZodOptional<z.ZodString>;
     numCodeOne: z.ZodOptional<z.ZodString>;
     numCodeTwo: z.ZodOptional<z.ZodString>;
-    activeMailInstruction: z.ZodBoolean;
-    actif: z.ZodBoolean;
+    isActiveMailInstruction: z.ZodBoolean;
+    isActif: z.ZodBoolean;
     activeVariation: z.ZodBoolean;
-    valeurCustomer: z.ZodBoolean;
-    customerName: z.ZodBoolean;
-    mailing: z.ZodBoolean;
+    isActiveVariation: z.ZodBoolean;
+    isMailing: z.ZodBoolean;
     isParis: z.ZodBoolean;
     isMedical: z.ZodBoolean;
     isService: z.ZodBoolean;
@@ -469,19 +462,18 @@ export declare const BillingCenterCreateSchema: z.ZodObject<{
     postalCode: string;
     city: string;
     telephoneOne: string;
-    submittedToFrenchVat: boolean;
+    isActif: boolean;
     isParis: boolean;
     isMedical: boolean;
     isService: boolean;
-    actif: boolean;
-    valeurCustomer: boolean;
     billingCenterName: string;
     invoiceMailOne: string;
-    activeMailInstruction: boolean;
-    activeVariation: boolean;
-    customerName: boolean;
-    mailing: boolean;
+    isSubmittedToFrenchVat: boolean;
+    isActiveMailInstruction: boolean;
+    isActiveVariation: boolean;
+    isMailing: boolean;
     customerId: number;
+    activeVariation: boolean;
     addressTwo?: string | undefined;
     telephoneTwo?: string | undefined;
     dafResponsibleName?: string | undefined;
@@ -519,19 +511,18 @@ export declare const BillingCenterCreateSchema: z.ZodObject<{
     postalCode: string;
     city: string;
     telephoneOne: string;
-    submittedToFrenchVat: boolean;
+    isActif: boolean;
     isParis: boolean;
     isMedical: boolean;
     isService: boolean;
-    actif: boolean;
-    valeurCustomer: boolean;
     billingCenterName: string;
     invoiceMailOne: string;
-    activeMailInstruction: boolean;
-    activeVariation: boolean;
-    customerName: boolean;
-    mailing: boolean;
+    isSubmittedToFrenchVat: boolean;
+    isActiveMailInstruction: boolean;
+    isActiveVariation: boolean;
+    isMailing: boolean;
     customerId: number;
+    activeVariation: boolean;
     addressTwo?: string | undefined;
     telephoneTwo?: string | undefined;
     dafResponsibleName?: string | undefined;
@@ -581,16 +572,15 @@ export declare const BillingCenterUpdateSchema: z.ZodObject<{
     telephone: z.ZodOptional<z.ZodString>;
     email: z.ZodOptional<z.ZodString>;
     intraVatNumber: z.ZodOptional<z.ZodString>;
-    submittedToFrenchVat: z.ZodOptional<z.ZodBoolean>;
+    isSubmittedToFrenchVat: z.ZodOptional<z.ZodBoolean>;
     comments: z.ZodOptional<z.ZodString>;
     numCodeOne: z.ZodOptional<z.ZodString>;
     numCodeTwo: z.ZodOptional<z.ZodString>;
-    activeMailInstruction: z.ZodOptional<z.ZodBoolean>;
-    actif: z.ZodOptional<z.ZodBoolean>;
+    isActiveMailInstruction: z.ZodOptional<z.ZodBoolean>;
+    isActif: z.ZodOptional<z.ZodBoolean>;
     activeVariation: z.ZodOptional<z.ZodBoolean>;
-    valeurCustomer: z.ZodOptional<z.ZodBoolean>;
-    customerName: z.ZodOptional<z.ZodBoolean>;
-    mailing: z.ZodOptional<z.ZodBoolean>;
+    isActiveVariation: z.ZodOptional<z.ZodBoolean>;
+    isMailing: z.ZodOptional<z.ZodBoolean>;
     isParis: z.ZodOptional<z.ZodBoolean>;
     isMedical: z.ZodOptional<z.ZodBoolean>;
     isService: z.ZodOptional<z.ZodBoolean>;
@@ -626,16 +616,14 @@ export declare const BillingCenterUpdateSchema: z.ZodObject<{
     telephone?: string | undefined;
     email?: string | undefined;
     intraVatNumber?: string | undefined;
-    submittedToFrenchVat?: boolean | undefined;
     numeroEori?: string | undefined;
     comments?: string | undefined;
     numCodeOne?: string | undefined;
     numCodeTwo?: string | undefined;
+    isActif?: boolean | undefined;
     isParis?: boolean | undefined;
     isMedical?: boolean | undefined;
     isService?: boolean | undefined;
-    actif?: boolean | undefined;
-    valeurCustomer?: boolean | undefined;
     dirigeant?: string | undefined;
     dirigeantTel?: string | undefined;
     dirigeantEmail?: string | undefined;
@@ -658,12 +646,13 @@ export declare const BillingCenterUpdateSchema: z.ZodObject<{
     numeroSiren?: string | undefined;
     invoiceMailOne?: string | undefined;
     invoiceMailTwo?: string | undefined;
-    activeMailInstruction?: boolean | undefined;
-    activeVariation?: boolean | undefined;
-    customerName?: boolean | undefined;
-    mailing?: boolean | undefined;
+    isSubmittedToFrenchVat?: boolean | undefined;
+    isActiveMailInstruction?: boolean | undefined;
+    isActiveVariation?: boolean | undefined;
+    isMailing?: boolean | undefined;
     deuxBordereaux?: string | undefined;
     customerId?: number | undefined;
+    activeVariation?: boolean | undefined;
 }, {
     country?: string | undefined;
     address?: string | undefined;
@@ -676,16 +665,14 @@ export declare const BillingCenterUpdateSchema: z.ZodObject<{
     telephone?: string | undefined;
     email?: string | undefined;
     intraVatNumber?: string | undefined;
-    submittedToFrenchVat?: boolean | undefined;
     numeroEori?: string | undefined;
     comments?: string | undefined;
     numCodeOne?: string | undefined;
     numCodeTwo?: string | undefined;
+    isActif?: boolean | undefined;
     isParis?: boolean | undefined;
     isMedical?: boolean | undefined;
     isService?: boolean | undefined;
-    actif?: boolean | undefined;
-    valeurCustomer?: boolean | undefined;
     dirigeant?: string | undefined;
     dirigeantTel?: string | undefined;
     dirigeantEmail?: string | undefined;
@@ -708,12 +695,13 @@ export declare const BillingCenterUpdateSchema: z.ZodObject<{
     numeroSiren?: string | undefined;
     invoiceMailOne?: string | undefined;
     invoiceMailTwo?: string | undefined;
-    activeMailInstruction?: boolean | undefined;
-    activeVariation?: boolean | undefined;
-    customerName?: boolean | undefined;
-    mailing?: boolean | undefined;
+    isSubmittedToFrenchVat?: boolean | undefined;
+    isActiveMailInstruction?: boolean | undefined;
+    isActiveVariation?: boolean | undefined;
+    isMailing?: boolean | undefined;
     deuxBordereaux?: string | undefined;
     customerId?: number | undefined;
+    activeVariation?: boolean | undefined;
 }>;
 export type IBillingCenter = z.infer<typeof BillingCenterSchema>;
 export type IBillingCenterCreate = z.infer<typeof BillingCenterCreateSchema>;