exnet-routing 1.2.9 → 1.2.11

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

@@ -537,4 +537,151 @@ describe("Ops Routes", () => {
             expect(response.data.action).toBe("create");
         });
     });
+    describe("manifest", () => {
+        it("should get manifest list", async () => {
+            const mockResponse = {
+                data: {
+                    data: [
+                        {
+                            id: 1,
+                            description: "Manifest Test",
+                            mawb: "MAWB123",
+                            dateManifest: new Date("2024-01-01"),
+                            isParis: true,
+                            isMedical: false,
+                            isService: false,
+                            isActif: true,
+                            destination: "Paris",
+                            origine: "London",
+                            compagnie: "Air France",
+                            numVol: "AF123",
+                            numLta: "LTA123",
+                            numCamion: "CAM123",
+                            numContainer: "CONT123",
+                            numPlomb: "PLB123",
+                            numDeclaration: "DEC123",
+                            numDossier: "DOS123",
+                        },
+                    ],
+                    meta: {
+                        currentPage: 1,
+                        totalPages: 1,
+                        totalCount: 1,
+                    },
+                },
+                message: "Manifest list retrieved successfully",
+            };
+            mockedAxios.mockResolvedValueOnce({ data: mockResponse });
+            const response = await api.routes().ops.manifest.liste({
+                searchParams: {},
+            });
+            expect(response.data.data).toHaveLength(1);
+            expect(response.data.data[0].description).toBe("Manifest Test");
+        });
+        it("should get manifest detail", async () => {
+            const mockResponse = {
+                data: {
+                    id: 1,
+                    description: "Manifest Test",
+                    mawb: "MAWB123",
+                    dateManifest: new Date("2024-01-01"),
+                    isParis: true,
+                    isMedical: false,
+                    isService: false,
+                    isActif: true,
+                    destination: "Paris",
+                    origine: "London",
+                    compagnie: "Air France",
+                    numVol: "AF123",
+                    numLta: "LTA123",
+                    numCamion: "CAM123",
+                    numContainer: "CONT123",
+                    numPlomb: "PLB123",
+                    numDeclaration: "DEC123",
+                    numDossier: "DOS123",
+                },
+                message: "Manifest detail retrieved successfully",
+            };
+            mockedAxios.mockResolvedValueOnce({ data: mockResponse });
+            const response = await api.routes().ops.manifest.detail({
+                queryParams: { id: "1" },
+            });
+            expect(response.data.description).toBe("Manifest Test");
+            expect(response.data.mawb).toBe("MAWB123");
+        });
+        it("should create manifest", async () => {
+            const mockResponse = {
+                data: {
+                    id: 1,
+                    description: "New Manifest",
+                    mawb: "MAWB456",
+                    dateManifest: new Date("2024-01-15"),
+                    isParis: true,
+                    isMedical: false,
+                    isService: false,
+                    isActif: true,
+                    destination: "Paris",
+                    origine: "London",
+                    compagnie: "Air France",
+                    numVol: "AF456",
+                    numLta: "LTA456",
+                    numCamion: "CAM456",
+                    numContainer: "CONT456",
+                    numPlomb: "PLB456",
+                    numDeclaration: "DEC456",
+                    numDossier: "DOS456",
+                },
+                message: "Manifest created successfully",
+            };
+            mockedAxios.mockResolvedValueOnce({ data: mockResponse });
+            const response = await api.routes().ops.manifest.create({
+                body: {
+                    description: "New Manifest",
+                    mawb: "MAWB456",
+                    dateManifest: new Date("2024-01-15"),
+                    isParis: true,
+                    isMedical: false,
+                    isService: false,
+                    isActif: true,
+                },
+            });
+            expect(response.data.description).toBe("New Manifest");
+            expect(response.data.mawb).toBe("MAWB456");
+        });
+        it("should update manifest", async () => {
+            const mockResponse = {
+                data: {
+                    id: 1,
+                    description: "Updated Manifest",
+                    mawb: "MAWB789",
+                    dateManifest: new Date("2024-01-20"),
+                    isParis: false,
+                    isMedical: true,
+                    isService: false,
+                    isActif: true,
+                    destination: "Lyon",
+                    origine: "Paris",
+                    compagnie: "Air France",
+                    numVol: "AF789",
+                    numLta: "LTA789",
+                    numCamion: "CAM789",
+                    numContainer: "CONT789",
+                    numPlomb: "PLB789",
+                    numDeclaration: "DEC789",
+                    numDossier: "DOS789",
+                },
+                message: "Manifest updated successfully",
+            };
+            mockedAxios.mockResolvedValueOnce({ data: mockResponse });
+            const response = await api.routes().ops.manifest.update({
+                queryParams: { id: "1" },
+                body: {
+                    description: "Updated Manifest",
+                    mawb: "MAWB789",
+                },
+            });
+            expect(response.data.description).toBe("Updated Manifest");
+            expect(response.data.mawb).toBe("MAWB789");
+        });
+    });
 });

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

@@ -0,0 +1,123 @@
+import { z } from "zod";
+import { IRoute } from "./_type";
+/**
+ * Helper functions to simplify route definitions
+ */
+/**
+ * Common user interface types used across routes
+ */
+export declare const UserInterfaceEnum: z.ZodEnum<["paris", "medical", "service"]>;
+export type UserInterface = z.infer<typeof UserInterfaceEnum>;
+/**
+ * Common URL parameter schemas
+ */
+export declare const CommonParams: {
+    /** User interface parameter */
+    readonly userInterface: z.ZodObject<{
+        userInterface: z.ZodEnum<["paris", "medical", "service"]>;
+    }, "strip", z.ZodTypeAny, {
+        userInterface: "paris" | "medical" | "service";
+    }, {
+        userInterface: "paris" | "medical" | "service";
+    }>;
+    /** ID parameter */
+    readonly id: z.ZodObject<{
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+    }, {
+        id: string;
+    }>;
+    /** UUID parameter */
+    readonly uuid: z.ZodObject<{
+        uuid: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        uuid: string;
+    }, {
+        uuid: string;
+    }>;
+};
+/**
+ * Create a GET route definition
+ */
+export declare const createGetRoute: <TResponse extends z.ZodObject<any> | z.ZodArray<any> | z.ZodNull, TSearchParams extends z.ZodObject<any> | undefined = undefined, TParams extends z.ZodObject<any> | undefined = undefined>(config: {
+    url: string;
+    response: TResponse;
+    searchParams?: TSearchParams;
+    params?: TParams;
+}) => IRoute;
+/**
+ * Create a POST route definition
+ */
+export declare const createPostRoute: <TResponse extends z.ZodObject<any> | z.ZodArray<any> | z.ZodNull, TBody extends z.ZodObject<any> | undefined = undefined, TSearchParams extends z.ZodObject<any> | undefined = undefined, TParams extends z.ZodObject<any> | undefined = undefined>(config: {
+    url: string;
+    response: TResponse;
+    body?: TBody;
+    searchParams?: TSearchParams;
+    params?: TParams;
+}) => IRoute;
+/**
+ * Create a PUT route definition
+ */
+export declare const createPutRoute: <TResponse extends z.ZodObject<any> | z.ZodArray<any> | z.ZodNull, TBody extends z.ZodObject<any> | undefined = undefined, TSearchParams extends z.ZodObject<any> | undefined = undefined, TParams extends z.ZodObject<any> | undefined = undefined>(config: {
+    url: string;
+    response: TResponse;
+    body?: TBody;
+    searchParams?: TSearchParams;
+    params?: TParams;
+}) => IRoute;
+/**
+ * Create a DELETE route definition
+ */
+export declare const createDeleteRoute: <TResponse extends z.ZodObject<any> | z.ZodArray<any> | z.ZodNull, TBody extends z.ZodObject<any> | undefined = undefined, TSearchParams extends z.ZodObject<any> | undefined = undefined, TParams extends z.ZodObject<any> | undefined = undefined>(config: {
+    url: string;
+    response: TResponse;
+    body?: TBody;
+    searchParams?: TSearchParams;
+    params?: TParams;
+}) => IRoute;
+/**
+ * Create a PATCH route definition
+ */
+export declare const createPatchRoute: <TResponse extends z.ZodObject<any> | z.ZodArray<any> | z.ZodNull, TBody extends z.ZodObject<any> | undefined = undefined, TSearchParams extends z.ZodObject<any> | undefined = undefined, TParams extends z.ZodObject<any> | undefined = undefined>(config: {
+    url: string;
+    response: TResponse;
+    body?: TBody;
+    searchParams?: TSearchParams;
+    params?: TParams;
+}) => IRoute;
+/**
+ * Create a standard CRUD route group for a resource
+ * @param baseUrl - The base URL for the resource
+ * @param schema - The Zod schema for the resource
+ * @param createSchema - The Zod schema for creating the resource
+ * @param updateSchema - The Zod schema for updating the resource
+ * @param paginationSchema - The Zod schema for paginated list response
+ * @param searchParamsSchema - The Zod schema for search parameters
+ * @returns An object with liste, detail, create, update, and delete routes
+ */
+export declare const createCrudRoutes: <TSchema extends z.ZodObject<any>, TCreateSchema extends z.ZodObject<any>, TUpdateSchema extends z.ZodObject<any>, TPaginationSchema extends z.ZodObject<any> | z.ZodArray<any>, TSearchParamsSchema extends z.ZodObject<any>>(config: {
+    baseUrl: string;
+    schema: TSchema;
+    createSchema: TCreateSchema;
+    updateSchema: TUpdateSchema;
+    paginationSchema: TPaginationSchema;
+    searchParamsSchema: TSearchParamsSchema;
+}) => {
+    liste: IRoute;
+    detail: IRoute;
+    create: IRoute;
+    update: IRoute;
+    delete: IRoute;
+};
+/**
+ * Create routes with user interface parameter
+ * Useful for routes that require paris/medical/service interface selection
+ */
+export declare const createUserInterfaceRoute: <TResponse extends z.ZodObject<any> | z.ZodArray<any> | z.ZodNull, TMethod extends "GET" | "POST" | "PUT" | "DELETE" | "PATCH" = "GET">(config: {
+    method?: TMethod;
+    url: string;
+    response: TResponse;
+    body?: z.ZodObject<any>;
+    searchParams?: z.ZodObject<any>;
+}) => IRoute;

package/dist/core/api/_helpers.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUserInterfaceRoute = exports.createCrudRoutes = exports.createPatchRoute = exports.createDeleteRoute = exports.createPutRoute = exports.createPostRoute = exports.createGetRoute = exports.CommonParams = exports.UserInterfaceEnum = void 0;
+const zod_1 = require("zod");
+const _type_1 = require("./_type");
+/**
+ * Helper functions to simplify route definitions
+ */
+/**
+ * Common user interface types used across routes
+ */
+exports.UserInterfaceEnum = zod_1.z.enum(["paris", "medical", "service"]);
+/**
+ * Common URL parameter schemas
+ */
+exports.CommonParams = {
+    /** User interface parameter */
+    userInterface: zod_1.z.object({
+        userInterface: exports.UserInterfaceEnum,
+    }),
+    /** ID parameter */
+    id: zod_1.z.object({
+        id: zod_1.z.string(),
+    }),
+    /** UUID parameter */
+    uuid: zod_1.z.object({
+        uuid: zod_1.z.string(),
+    }),
+};
+/**
+ * Create a GET route definition
+ */
+const createGetRoute = (config) => ({
+    method: "GET",
+    url: config.url,
+    response: (0, _type_1.response)(config.response),
+    ...(config.searchParams && { searchParams: config.searchParams }),
+    ...(config.params && { params: config.params }),
+});
+exports.createGetRoute = createGetRoute;
+/**
+ * Create a POST route definition
+ */
+const createPostRoute = (config) => ({
+    method: "POST",
+    url: config.url,
+    response: (0, _type_1.response)(config.response),
+    ...(config.body && { body: config.body }),
+    ...(config.searchParams && { searchParams: config.searchParams }),
+    ...(config.params && { params: config.params }),
+});
+exports.createPostRoute = createPostRoute;
+/**
+ * Create a PUT route definition
+ */
+const createPutRoute = (config) => ({
+    method: "PUT",
+    url: config.url,
+    response: (0, _type_1.response)(config.response),
+    ...(config.body && { body: config.body }),
+    ...(config.searchParams && { searchParams: config.searchParams }),
+    ...(config.params && { params: config.params }),
+});
+exports.createPutRoute = createPutRoute;
+/**
+ * Create a DELETE route definition
+ */
+const createDeleteRoute = (config) => ({
+    method: "DELETE",
+    url: config.url,
+    response: (0, _type_1.response)(config.response),
+    ...(config.body && { body: config.body }),
+    ...(config.searchParams && { searchParams: config.searchParams }),
+    ...(config.params && { params: config.params }),
+});
+exports.createDeleteRoute = createDeleteRoute;
+/**
+ * Create a PATCH route definition
+ */
+const createPatchRoute = (config) => ({
+    method: "PATCH",
+    url: config.url,
+    response: (0, _type_1.response)(config.response),
+    ...(config.body && { body: config.body }),
+    ...(config.searchParams && { searchParams: config.searchParams }),
+    ...(config.params && { params: config.params }),
+});
+exports.createPatchRoute = createPatchRoute;
+/**
+ * Create a standard CRUD route group for a resource
+ * @param baseUrl - The base URL for the resource
+ * @param schema - The Zod schema for the resource
+ * @param createSchema - The Zod schema for creating the resource
+ * @param updateSchema - The Zod schema for updating the resource
+ * @param paginationSchema - The Zod schema for paginated list response
+ * @param searchParamsSchema - The Zod schema for search parameters
+ * @returns An object with liste, detail, create, update, and delete routes
+ */
+const createCrudRoutes = (config) => ({
+    liste: (0, exports.createGetRoute)({
+        url: `${config.baseUrl}/liste`,
+        response: config.paginationSchema,
+        searchParams: config.searchParamsSchema,
+    }),
+    detail: (0, exports.createGetRoute)({
+        url: `${config.baseUrl}/detail/:id`,
+        response: config.schema,
+        params: exports.CommonParams.id,
+    }),
+    create: (0, exports.createPostRoute)({
+        url: `${config.baseUrl}/create`,
+        response: config.schema,
+        body: config.createSchema,
+    }),
+    update: (0, exports.createPutRoute)({
+        url: `${config.baseUrl}/update/:id`,
+        response: config.schema,
+        body: config.updateSchema,
+        params: exports.CommonParams.id,
+    }),
+    delete: (0, exports.createDeleteRoute)({
+        url: `${config.baseUrl}/delete/:id`,
+        response: zod_1.z.null(),
+        params: exports.CommonParams.id,
+    }),
+});
+exports.createCrudRoutes = createCrudRoutes;
+/**
+ * Create routes with user interface parameter
+ * Useful for routes that require paris/medical/service interface selection
+ */
+const createUserInterfaceRoute = (config) => {
+    const baseConfig = {
+        url: config.url,
+        response: (0, _type_1.response)(config.response),
+        params: exports.CommonParams.userInterface,
+        ...(config.searchParams && { searchParams: config.searchParams }),
+    };
+    if (config.method === "POST" || config.method === "PUT" || config.method === "PATCH" || config.method === "DELETE") {
+        return {
+            ...baseConfig,
+            method: config.method,
+            ...(config.body && { body: config.body }),
+        };
+    }
+    return {
+        ...baseConfig,
+        method: "GET",
+    };
+};
+exports.createUserInterfaceRoute = createUserInterfaceRoute;

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

@@ -0,0 +1,54 @@
+import { AxiosHeaders } from "axios";
+import { IRoute, IRouteFunction, IRouteGroup, IRouterApi } from "./_type";
+import { NestedRoute } from "./_type";
+/**
+ * Build a complete API URL from host, base path and segment
+ * @param segment - The API endpoint segment
+ * @param baseUrl - The base path (e.g., "/api/v1")
+ * @param host - The host URL (e.g., "http://localhost:3000")
+ * @returns The complete URL
+ */
+export declare const apiUrlBuilder: (segment?: string, baseUrl?: string, host?: string) => string;
+/**
+ * API fetch utility with configurable host, base URL and headers
+ */
+export declare const createApiFetch: (host: string, baseUrl: string, headers?: AxiosHeaders) => {
+    /**
+     * Perform an HTTP request to the API
+     * @param urlInput - The endpoint path
+     * @param method - HTTP method
+     * @param body - Request body
+     * @param searchParams - Search/query parameters
+     * @param queryParams - URL path parameters to replace
+     * @returns Response data
+     */
+    fetch: (urlInput: string, method?: RequestInit["method"] | undefined, body?: any, searchParams?: any, queryParams?: Record<string, string>) => Promise<any>;
+};
+/**
+ * Type guard to check if a value is a route definition
+ */
+export declare const isRoute: (value: NestedRoute | IRoute) => value is IRoute;
+/**
+ * Type guard to check if a value is a nested route
+ */
+export declare const isSubRoute: (value: NestedRoute | IRoute) => value is NestedRoute;
+/**
+ * Recursively parse API route definitions and create executable functions
+ * @param key - The current route key
+ * @param subRoute - The route or nested routes definition
+ * @param result - The result object to populate
+ * @param hostApi - The API host URL
+ * @param basePath - The API base path
+ * @param headers - Optional headers to include in requests
+ * @returns The populated result object
+ */
+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 | IRouteFunction;
+/**
+ * Parse the entire API route structure and create an executable API client
+ * @param api - The API route definitions
+ * @param hostApi - The API host URL
+ * @param basePath - The API base path
+ * @param headers - Optional headers to include in requests
+ * @returns The parsed API router with executable methods
+ */
+export declare const parseApiRoutes: <T extends NestedRoute>(api: T, hostApi: string, basePath: string, headers?: AxiosHeaders) => IRouterApi;

package/dist/core/api/_utils.js

@@ -0,0 +1,203 @@
+"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.createApiFetch = exports.apiUrlBuilder = void 0;
+const path_1 = require("path");
+const axios_1 = __importDefault(require("axios"));
+/**
+ * Build a complete API URL from host, base path and segment
+ * @param segment - The API endpoint segment
+ * @param baseUrl - The base path (e.g., "/api/v1")
+ * @param host - The host URL (e.g., "http://localhost:3000")
+ * @returns The complete URL
+ */
+const apiUrlBuilder = (segment = "", baseUrl = "", host = "") => {
+    const path = (0, path_1.join)(baseUrl, segment);
+    return host + path;
+};
+exports.apiUrlBuilder = apiUrlBuilder;
+/**
+ * Default headers applied to all requests
+ */
+const DEFAULT_HEADERS = {
+    "Content-Type": "application/json",
+    Accept: "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",
+};
+/**
+ * Build query parameters string from object
+ * @param queryParams - Object containing query parameters to replace in URL
+ * @param url - The URL with placeholders (e.g., "/user/:id")
+ * @returns URL with replaced parameters
+ */
+const replaceQueryParams = (url, queryParams) => {
+    if (!queryParams)
+        return url;
+    let result = url;
+    Object.entries(queryParams).forEach(([key, value]) => {
+        if (value !== undefined && value !== null) {
+            result = result.replace(`:${key}`, encodeURIComponent(String(value)));
+        }
+    });
+    return result;
+};
+/**
+ * Build search parameters string from object
+ * @param searchParams - Object or string of search parameters
+ * @returns Query string to append to URL
+ */
+const buildSearchParams = (searchParams) => {
+    if (!searchParams)
+        return "";
+    if (typeof searchParams === "string")
+        return searchParams;
+    const params = 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("&");
+    return params;
+};
+/**
+ * API fetch utility with configurable host, base URL and headers
+ */
+const createApiFetch = (host, baseUrl, headers) => {
+    return {
+        /**
+         * Perform an HTTP request to the API
+         * @param urlInput - The endpoint path
+         * @param method - HTTP method
+         * @param body - Request body
+         * @param searchParams - Search/query parameters
+         * @param queryParams - URL path parameters to replace
+         * @returns Response data
+         */
+        fetch: async (urlInput, method, body, searchParams, queryParams) => {
+            var _a, _b;
+            try {
+                let url = (0, exports.apiUrlBuilder)(urlInput, baseUrl, host);
+                // Replace path parameters (e.g., :id)
+                url = replaceQueryParams(url, queryParams);
+                // Add search parameters
+                const searchParamsString = buildSearchParams(searchParams);
+                if (searchParamsString) {
+                    url += (url.includes("?") ? "&" : "?") + searchParamsString;
+                }
+                const res = await (0, axios_1.default)({
+                    headers: {
+                        ...DEFAULT_HEADERS,
+                        ...headers,
+                    },
+                    method,
+                    url,
+                    data: body,
+                });
+                return res.data;
+            }
+            catch (error) {
+                // Enhanced error handling
+                if (axios_1.default.isAxiosError(error)) {
+                    const axiosError = error;
+                    const errorMessage = ((_a = axiosError.response) === null || _a === void 0 ? void 0 : _a.data) ? JSON.stringify(axiosError.response.data) : axiosError.message;
+                    throw new Error(`API request failed [${((_b = axiosError.response) === null || _b === void 0 ? void 0 : _b.status) || "UNKNOWN"}]: ${errorMessage}`);
+                }
+                throw new Error(`Request failed: ${error}`);
+            }
+        },
+    };
+};
+exports.createApiFetch = createApiFetch;
+/**
+ * Type guard to check if a value is a route definition
+ */
+const isRoute = (value) => {
+    return "method" in value;
+};
+exports.isRoute = isRoute;
+/**
+ * Type guard to check if a value is a nested route
+ */
+const isSubRoute = (value) => {
+    return !(0, exports.isRoute)(value);
+};
+exports.isSubRoute = isSubRoute;
+/**
+ * Create a function that executes the API call for a given route
+ * @param route - The route definition
+ * @param apiFetch - The fetch utility
+ * @returns A function that can be called to execute the API request
+ */
+const createRouteFunction = (route, apiFetch) => {
+    const createFetchFunction = (paramTypes) => {
+        return async (...args) => {
+            const params = paramTypes.reduce((acc, type) => {
+                var _a;
+                acc[type] = ((_a = args[0]) === null || _a === void 0 ? void 0 : _a[type]) || null;
+                return acc;
+            }, {});
+            return await apiFetch.fetch(route.url, route.method, params.body, params.searchParams, params.queryParams);
+        };
+    };
+    // Determine which parameters are needed based on route definition
+    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([]);
+};
+/**
+ * Recursively parse API route definitions and create executable functions
+ * @param key - The current route key
+ * @param subRoute - The route or nested routes definition
+ * @param result - The result object to populate
+ * @param hostApi - The API host URL
+ * @param basePath - The API base path
+ * @param headers - Optional headers to include in requests
+ * @returns The populated result object
+ */
+const parseApiRoute = (key, subRoute, result, hostApi, basePath, headers) => {
+    var _a;
+    const apiFetch = (0, exports.createApiFetch)(hostApi, basePath, headers);
+    if ((0, exports.isRoute)(subRoute) && key) {
+        return createRouteFunction(subRoute, 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;
+/**
+ * Parse the entire API route structure and create an executable API client
+ * @param api - The API route definitions
+ * @param hostApi - The API host URL
+ * @param basePath - The API base path
+ * @param headers - Optional headers to include in requests
+ * @returns The parsed API router with executable methods
+ */
+const parseApiRoutes = (api, hostApi, basePath, headers) => {
+    const result = {};
+    return (0, exports.parseApiRoute)(undefined, api, result, hostApi, basePath, headers);
+};
+exports.parseApiRoutes = parseApiRoutes;