indas-ui 0.0.1 → 0.1.0

package/dist/cjs/lib/api/estimation/planning.js

@@ -0,0 +1,403 @@
+'use client';
+"use strict";
+// Planning APIs
+// Handles plan window and load operations for estimation
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlanWindowAPI = exports.LoadOperationsAPI = void 0;
+exports.getMachineAllocatedItemList = getMachineAllocatedItemList;
+exports.getProcessAllocatedItemList = getProcessAllocatedItemList;
+exports.getProcessWiseMaterials = getProcessWiseMaterials;
+exports.getWindingDirections = getWindingDirections;
+exports.getThicknessOptions = getThicknessOptions;
+exports.getLabelTypes = getLabelTypes;
+exports.getPouchStyles = getPouchStyles;
+exports.getPunchingTypes = getPunchingTypes;
+exports.getFinishedFormats = getFinishedFormats;
+exports.calculateFlapDimensions = calculateFlapDimensions;
+const client_1 = __importDefault(require("../core/client.js"));
+/**
+ * Load Operations API class
+ */
+class LoadOperationsAPI {
+    /**
+     * Load operations list for a given DomainType
+     * @param domainType - Domain type (e.g., 'Offset', 'Digital', 'Flexo')
+     * @param sessionData - Session data
+     */
+    static async loadOperations(domainType, sessionData) {
+        const endpoint = `api/planwindow/LoadOperations/${domainType}`;
+        try {
+            const response = await client_1.default.get(endpoint, sessionData);
+            return response;
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `LoadOperations API failed: ${error instanceof Error ? error.message : 'Unknown error'}`
+            };
+        }
+    }
+}
+exports.LoadOperationsAPI = LoadOperationsAPI;
+/**
+ * Plan Window API
+ * API calls for calculating operations based on machine planning data
+ */
+class PlanWindowAPI {
+    /**
+     * Calculate operation costs for selected processes
+     * @param requestBody - Request body containing planning data and process IDs
+     * @param isDefault - Whether to fetch default processes (true) or calculate for selected processes (false)
+     * @param category - Content domain type/category
+     * @param content - Content name
+     */
+    static async calculateOperation(requestBody, options, sessionData) {
+        // Build query parameters
+        const queryParams = [];
+        if (options?.isDefault !== undefined) {
+            queryParams.push(`Isdefault=${options.isDefault}`);
+        }
+        if (options?.category) {
+            queryParams.push(`category=${encodeURIComponent(options.category)}`);
+        }
+        if (options?.content) {
+            queryParams.push(`content=${encodeURIComponent(options.content)}`);
+        }
+        const queryString = queryParams.length > 0 ? `?${queryParams.join('&')}` : '';
+        const endpoint = `api/planwindow/CalculateOperation${queryString}`;
+        const response = await client_1.default.post(endpoint, requestBody, sessionData);
+        return response;
+    }
+    /**
+     * Get all machines
+     */
+    static async getAllMachines(sessionData) {
+        return client_1.default.get('api/planwindow/getallmachines', sessionData);
+    }
+    /**
+     * Get material group cost formula settings for a specific sub-item group and plant
+     * @param itemSubGroupID - The sub-item group ID
+     * @param plantID - The plant ID
+     */
+    static async getMaterialGroupCostFormulaSetting(itemSubGroupID, plantID, sessionData) {
+        const endpoint = `api/planwindow/GetMaterialGroupCostFormulaSetting/${itemSubGroupID}/${plantID}`;
+        return client_1.default.get(endpoint, sessionData);
+    }
+    /**
+     * Get keyline coordinates for die-cut patterns
+     * @param contentType - The orientation/product type (e.g., "StandardStraightTuckIn", "ReverseTuckAndTongue")
+     * @param grain - Grain direction (e.g., "With Grain", "Across Grain")
+     */
+    static async getKeylineCoordinates(contentType, grain, sessionData) {
+        // URL encode parameters to handle spaces and special characters
+        const encodedContentType = encodeURIComponent(contentType);
+        const encodedGrain = encodeURIComponent(grain);
+        return client_1.default.get(`api/planwindow/keylinecoordinates/${encodedContentType}/${encodedGrain}`, sessionData);
+    }
+    /**
+     * Get auto-generated quote number
+     * @param sessionData - Session data for authentication
+     * @returns Promise with quote number string (e.g., "10711")
+     */
+    static async getQuoteNo(sessionData) {
+        const endpoint = 'api/planwindow/getquoteno';
+        try {
+            const response = await client_1.default.get(endpoint, sessionData);
+            return response;
+        }
+        catch (error) {
+            console.error('❌ [QUOTE_NO] Error:', error);
+            return {
+                success: false,
+                error: `Get Quote No API failed: ${error instanceof Error ? error.message : 'Unknown error'}`
+            };
+        }
+    }
+    /**
+     * Get type of charges calculation formulas and operation slabs
+     * Called after LoadOperations to get formula definitions and rate slabs
+     * @param sessionData - Session data for authentication
+     * @returns Promise with TypeOfCharges array and LoadOperationSlabsDetails array
+     */
+    static async getTypeOfCharges(sessionData) {
+        const endpoint = 'api/planwindow/GetTypeOfCharges';
+        try {
+            const response = await client_1.default.get(endpoint, sessionData);
+            return response;
+        }
+        catch (error) {
+            console.error('❌ [GET_TYPE_OF_CHARGES] Error:', error);
+            return {
+                success: false,
+                error: `GetTypeOfCharges API failed: ${error instanceof Error ? error.message : 'Unknown error'}`
+            };
+        }
+    }
+    /**
+     * Get client list with credit days
+     * @param sessionData - Session data for authentication
+     * @returns Promise with array of clients including LedgerName, LedgerId, and CreditDays
+     */
+    static async getSbClient(sessionData) {
+        const endpoint = 'api/planwindow/GetSbClient';
+        try {
+            const response = await client_1.default.get(endpoint, sessionData);
+            return response;
+        }
+        catch (error) {
+            console.error('❌ [API ERROR] GetSbClient Error:', error);
+            return {
+                success: false,
+                error: `GetSbClient API failed: ${error instanceof Error ? error.message : 'Unknown error'}`
+            };
+        }
+    }
+    /**
+     * Shirin Job Master - Main planning calculation endpoint
+     * Generates machine plans with comprehensive planning data
+     *
+     * Legacy reference: plan.txt line 236-237
+     * Endpoint: POST /api/planwindow/ShirinJobMaster
+     *
+     * @param request - Job size, operations, and rates (PlateRate, PaperRate, MakeReadyRate, CoatingRate)
+     * @param sessionData - Session data for authentication
+     * @returns Promise with planning results (TblPlanning, TblOperations, TblBookForms)
+     */
+    static async shirinJobMaster(request, sessionData) {
+        const endpoint = 'api/planwindow/ShirinJobMaster';
+        try {
+            const response = await client_1.default.post(endpoint, request, sessionData);
+            return response;
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `ShirinJobMaster API failed: ${error instanceof Error ? error.message : 'Unknown error'}`
+            };
+        }
+    }
+}
+exports.PlanWindowAPI = PlanWindowAPI;
+/**
+ * Get machine allocated item list
+ * @param machineId - Machine ID
+ * @param sessionData - Session data
+ * @param filters - Optional filters: categoryID, processID, contentType, rateTier
+ */
+async function getMachineAllocatedItemList(machineId, sessionData, filters) {
+    try {
+        const params = new URLSearchParams();
+        if (filters?.categoryID)
+            params.append('categoryID', String(filters.categoryID));
+        if (filters?.processID)
+            params.append('processID', String(filters.processID));
+        if (filters?.contentType)
+            params.append('contentType', filters.contentType);
+        if (filters?.rateTier === 'L2')
+            params.append('rateTier', 'L2');
+        const qs = params.toString();
+        const endpoint = `api/planwindow/GetMachineAllocatedItemList/${machineId}${qs ? `?${qs}` : ''}`;
+        const response = await client_1.default.get(endpoint, sessionData);
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to fetch machine allocated items: ${error instanceof Error ? error.message : 'Unknown error'}`
+        };
+    }
+}
+/**
+ * Get process-allocated items (no machine involvement). Used by EnquiryMaterialModal
+ * where the user picks materials per (category, content, process) without ever
+ * selecting a machine. Backend joins across all machines allocated to the process
+ * and dedupes by ItemID; IsDefault is collapsed (true if any machine flags it).
+ */
+async function getProcessAllocatedItemList(filters, sessionData) {
+    try {
+        const params = new URLSearchParams();
+        params.append('CategoryID', String(filters.categoryID));
+        params.append('ContentID', String(filters.contentID));
+        params.append('ProcessID', String(filters.processID));
+        const endpoint = `api/planwindow/GetProcessAllocatedItemList?${params.toString()}`;
+        return await client_1.default.get(endpoint, sessionData);
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to fetch process allocated items: ${error instanceof Error ? error.message : 'Unknown error'}`
+        };
+    }
+}
+/**
+ * Get ALL materials/items allocated to one or more processes (by ProcessID only,
+ * no category/content/machine needed). Returns the actual allocated items — not
+ * just material sub-group names. `processIds` are joined comma-separated for the
+ * IN(...) clause, so one call covers every chosen process.
+ */
+async function getProcessWiseMaterials(processIds, sessionData) {
+    try {
+        const ids = processIds.filter(n => Number(n) > 0).join(',');
+        if (!ids)
+            return { success: true, data: [] };
+        const endpoint = `api/planwindow/processmaterials/${encodeURIComponent(ids)}`;
+        return await client_1.default.get(endpoint, sessionData);
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to fetch process-wise materials: ${error instanceof Error ? error.message : 'Unknown error'}`
+        };
+    }
+}
+/**
+ * Get Winding Directions by domain type
+ * @param contentDomainType - The content domain type (FLEXO, ROTOGRAVURE, etc.)
+ * @param sessionData - Session data for authentication
+ * @returns Promise with winding direction options
+ */
+async function getWindingDirections(contentDomainType, sessionData) {
+    try {
+        const endpoint = `api/planwindow/windingdirection/${contentDomainType}`;
+        const response = await client_1.default.get(endpoint, sessionData);
+        if (response.success && response.data) {
+            if (!Array.isArray(response.data)) {
+                const errorMessage = typeof response.data === 'string'
+                    ? response.data
+                    : 'API returned invalid data format';
+                return {
+                    success: false,
+                    error: errorMessage,
+                    data: []
+                };
+            }
+        }
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to fetch winding directions: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            data: []
+        };
+    }
+}
+/**
+ * Get Thickness options
+ * @param contentType - Content type (e.g., "FLEXO")
+ * @param quality - Item quality (e.g., "Shrink Sleeve")
+ * @param gsm - GSM value (e.g., "54")
+ * @param sessionData - Session data for authentication
+ * @returns Promise with thickness options
+ */
+async function getThicknessOptions(contentType, quality, gsm, sessionData) {
+    try {
+        const endpoint = `api/planwindow/thickness?contenttype=${encodeURIComponent(contentType)}&quality=${encodeURIComponent(quality)}&gsm=${encodeURIComponent(gsm)}`;
+        const response = await client_1.default.get(endpoint, sessionData);
+        if (response.success && response.data) {
+            if (!Array.isArray(response.data)) {
+                const errorMessage = typeof response.data === 'string'
+                    ? response.data
+                    : 'API returned invalid data format';
+                return {
+                    success: false,
+                    error: errorMessage,
+                    data: []
+                };
+            }
+        }
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to fetch thickness options: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            data: []
+        };
+    }
+}
+/**
+ * Get Label Type options (Static data for FLEXO)
+ * @returns Label type options
+ */
+function getLabelTypes() {
+    return [
+        { LabelType: "Front" },
+        { LabelType: "Back" },
+        { LabelType: "Top" },
+        { LabelType: "Bottom" },
+        { LabelType: "Neck" },
+        { LabelType: "Flat Label" },
+        { LabelType: "Single" },
+        { LabelType: "Set" }
+    ];
+}
+/**
+ * Get Pouch Style options (Static data for ROTOGRAVURE)
+ * @returns Pouch style options
+ */
+function getPouchStyles() {
+    return [
+        { LabelType: "Stand-Up Pouch", WtPerPieceGram: 0 },
+        { LabelType: "K-Seal Pouch", WtPerPieceGram: 0 },
+        { LabelType: "Three-Side Seal Pouch", WtPerPieceGram: 0 },
+        { LabelType: "Four-Side Seal Pouch", WtPerPieceGram: 0 },
+        { LabelType: "Single-Use Sachet", WtPerPieceGram: 0 },
+        { LabelType: "Side Gusset Pouch", WtPerPieceGram: 0 },
+        { LabelType: "Bottom Gusset Pouch", WtPerPieceGram: 0 },
+        { LabelType: "Spouted Pouch", WtPerPieceGram: 10 },
+        { LabelType: "Retort Pouch", WtPerPieceGram: 0 },
+        { LabelType: "Zipper Pouch", WtPerPieceGram: 5 },
+        { LabelType: "Pillow Pouch", WtPerPieceGram: 0 },
+        { LabelType: "Quad-Seal Pouch", WtPerPieceGram: 0 },
+        { LabelType: "Shaped Pouch", WtPerPieceGram: 0 },
+        { LabelType: "Flat-Bottom Pouch", WtPerPieceGram: 0 },
+        { LabelType: "Vacuum Pouch", WtPerPieceGram: 0 },
+        { LabelType: "Slider Pouch", WtPerPieceGram: 0 }
+    ];
+}
+/**
+ * Get Punching Type options (Static data)
+ * @returns Punching type options
+ */
+function getPunchingTypes() {
+    return [
+        { PunchingType: "None" },
+        { PunchingType: "Threding" },
+        { PunchingType: "Hole Punching" }
+    ];
+}
+/**
+ * Get Finished Format options (Static data for FLEXO)
+ * @returns Finished format options
+ */
+function getFinishedFormats() {
+    return [
+        "Sheet Form",
+        "Roll Form",
+        "Fan Fold",
+        "Cut Label",
+        "Pcs Or Unit"
+    ];
+}
+/**
+ * Calculate flap dimensions for 3D content types
+ * @param request - Dimensions and content info
+ * @param sessionData - Session data
+ */
+async function calculateFlapDimensions(request, sessionData) {
+    try {
+        const endpoint = 'api/planwindow/calculate-flap-dimensions';
+        const response = await client_1.default.post(endpoint, request, sessionData);
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to calculate flap dimensions: ${error instanceof Error ? error.message : 'Unknown error'}`
+        };
+    }
+}

package/dist/cjs/lib/api/estimation/qualities.js

@@ -0,0 +1,245 @@
+'use client';
+"use strict";
+// Estimation Qualities API
+// Handles quality, GSM, mill, finish, and coating data for estimation
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMaterialRateAPI = getMaterialRateAPI;
+exports.getQualitiesAPI = getQualitiesAPI;
+exports.getGSMAPI = getGSMAPI;
+exports.getMillAPI = getMillAPI;
+exports.getFinishAPI = getFinishAPI;
+exports.getPaperCombinationsAPI = getPaperCombinationsAPI;
+exports.getCoatingAPI = getCoatingAPI;
+exports.getBFAPI = getBFAPI;
+exports.getCertificationTypesAPI = getCertificationTypesAPI;
+exports.getQuoteDefaultsAPI = getQuoteDefaultsAPI;
+exports.getBoardBrandAPI = getBoardBrandAPI;
+const client_1 = __importDefault(require("../core/client.js"));
+/**
+ * Get qualities by content type
+ * @param contentType - The content type to filter by
+ * @param sessionData - Session data containing user and company info
+ * @returns Promise with qualities array
+ */
+/**
+ * Get matched raw-material rate (L1 + L2) for the Raw Material card.
+ * Backend resolves the item group dynamically from contentType (Paper/Reel/Board/etc),
+ * so this works for any group. Returns matched item rows.
+ */
+async function getMaterialRateAPI(filters, sessionData) {
+    const p = new URLSearchParams({
+        contenttype: filters.contentType || '',
+        quality: filters.quality || '',
+        gsm: filters.gsm || '',
+        mill: filters.mill || '',
+        bf: filters.bf || '',
+        boardbrand: filters.boardBrand || '',
+        finish: filters.finish || '',
+        plant: filters.plant || '',
+    });
+    return client_1.default.get(`api/planwindow/material-rate?${p.toString()}`, sessionData);
+}
+async function getQualitiesAPI(contentType, sessionData) {
+    try {
+        const endpoint = `api/planwindow/quality/${encodeURIComponent(contentType)}`;
+        const response = await client_1.default.get(endpoint, sessionData);
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to fetch qualities: ${error instanceof Error ? error.message : 'Unknown error'}`
+        };
+    }
+}
+/**
+ * Get GSM (Grams per Square Meter) options
+ * @param contentType - The content type
+ * @param quality - The quality name
+ * @param thickness - Optional thickness value (defaults to '0')
+ * @param sessionData - Session data containing user and company info
+ * @returns Promise with GSM data array
+ */
+async function getGSMAPI(contentType, quality, thickness, sessionData) {
+    try {
+        // Only use "0" when no thickness value is provided (undefined/null/empty)
+        // If thickness has an actual value (including "0"), use that value
+        const thicknessValue = (thickness !== undefined && thickness !== null && thickness.trim() !== '') ? thickness : '0';
+        // Query string, not path segments: qualities like "Polycoated (335+15) Gsm"
+        // encode to %2B, which IIS rejects as double-escaping in a path.
+        const endpoint = `api/planwindow/gsm?contenttype=${encodeURIComponent(contentType)}&quality=${encodeURIComponent(quality)}&thickness=${encodeURIComponent(thicknessValue)}`;
+        const response = await client_1.default.get(endpoint, sessionData);
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to fetch GSM data: ${error instanceof Error ? error.message : 'Unknown error'}`
+        };
+    }
+}
+/**
+ * Get Mill options
+ * @param contentType - The content type
+ * @param quality - The quality name
+ * @param gsm - The GSM value
+ * @param thickness - Optional thickness value (defaults to '0')
+ * @param sessionData - Session data containing user and company info
+ * @returns Promise with mill data array
+ */
+async function getMillAPI(contentType, quality, gsm, thickness, sessionData) {
+    try {
+        // Only use "0" when no thickness value is provided (undefined/null/empty)
+        // If thickness has an actual value (including "0"), use that value
+        const thicknessValue = (thickness !== undefined && thickness !== null && thickness.trim() !== '') ? thickness : '0';
+        const endpoint = `api/planwindow/mill?contenttype=${encodeURIComponent(contentType)}&quality=${encodeURIComponent(quality)}&gsm=${encodeURIComponent(gsm)}&thickness=${encodeURIComponent(thicknessValue)}`;
+        const response = await client_1.default.get(endpoint, sessionData);
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to fetch mill data: ${error instanceof Error ? error.message : 'Unknown error'}`
+        };
+    }
+}
+/**
+ * Get Finish options
+ * @param quality - The quality name
+ * @param gsm - The GSM value
+ * @param mill - The mill name
+ * @param sessionData - Session data containing user and company info
+ * @returns Promise with finish data array
+ */
+async function getFinishAPI(quality, gsm, mill, sessionData) {
+    try {
+        const endpoint = `api/planwindow/finish?quality=${encodeURIComponent(quality)}&gsm=${encodeURIComponent(gsm)}&mill=${encodeURIComponent(mill)}`;
+        const response = await client_1.default.get(endpoint, sessionData);
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to fetch finish data: ${error instanceof Error ? error.message : 'Unknown error'}`
+        };
+    }
+}
+/**
+ * Get the FULL flat paper combination table in one call (Quality / GSM / Mill /
+ * Finish / Brand). Used to build the Grid Costing import template's dependent
+ * paper dropdowns without thousands of per-combination requests.
+ */
+async function getPaperCombinationsAPI(sessionData) {
+    try {
+        return await client_1.default.get('api/planwindow/papercombinations', sessionData);
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to fetch paper combinations: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        };
+    }
+}
+/**
+ * Get Coating options
+ * @param sessionData - Session data containing user and company info
+ * @returns Promise with coating data array
+ */
+async function getCoatingAPI(sessionData) {
+    try {
+        const endpoint = 'api/planwindow/GetCoating';
+        const response = await client_1.default.get(endpoint, sessionData);
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to fetch coating data: ${error instanceof Error ? error.message : 'Unknown error'}`
+        };
+    }
+}
+/**
+ * Get BF (Burst Factor) options
+ * @param quality - The quality name
+ * @param gsm - The GSM value
+ * @param mill - Optional mill name
+ * @param sessionData - Session data containing user and company info
+ * @returns Promise with BF data array
+ */
+async function getBFAPI(quality, gsm, mill, sessionData) {
+    try {
+        let endpoint = `api/planwindow/getbf?quality=${encodeURIComponent(quality)}&gsm=${encodeURIComponent(gsm)}`;
+        if (mill) {
+            endpoint += `&mill=${encodeURIComponent(mill)}`;
+        }
+        const response = await client_1.default.get(endpoint, sessionData);
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to fetch BF data: ${error instanceof Error ? error.message : 'Unknown error'}`
+        };
+    }
+}
+/**
+ * Get Certification Types (FSC, PEFC, NONE, etc.)
+ * @param sessionData - Session data containing user and company info
+ * @returns Promise with certification types array
+ */
+async function getCertificationTypesAPI(sessionData) {
+    try {
+        const response = await client_1.default.get('api/othermaster/GetCertificationType', sessionData);
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to fetch certification types: ${error instanceof Error ? error.message : 'Unknown error'}`
+        };
+    }
+}
+/**
+ * Get default values for cost-table fields (Overhead/Profit/Packing/etc.)
+ * Endpoint returns an object keyed by ParameterName with parsed decimal values (or null).
+ */
+async function getQuoteDefaultsAPI(sessionData) {
+    try {
+        const response = await client_1.default.get('api/planwindow/particulars-defaults', sessionData);
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to fetch quote defaults: ${error instanceof Error ? error.message : 'Unknown error'}`
+        };
+    }
+}
+/**
+ * Get Board Brand options filtered by content type, quality, GSM, mill, and finish
+ * Pass "all" for any param to skip that filter
+ * Route: boardbrand/{contenttype}/{quality}/{gsm}/{mill}/{finish}
+ */
+async function getBoardBrandAPI(contentType, quality, gsm, mill, finish, sessionData) {
+    try {
+        // Default every segment to 'all' so a missing ContentDomainType doesn't produce a
+        // broken `boardbrand//all/...` URL — Board Brand must still load without a content type.
+        const ct = contentType || 'all';
+        const q = quality || 'all';
+        const g = gsm || 'all';
+        const m = mill || 'all';
+        const f = finish || 'all';
+        const endpoint = `api/planwindow/boardbrand?contenttype=${encodeURIComponent(ct)}&quality=${encodeURIComponent(q)}&gsm=${encodeURIComponent(g)}&mill=${encodeURIComponent(m)}&finish=${encodeURIComponent(f)}`;
+        const response = await client_1.default.get(endpoint, sessionData);
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to fetch board brand data: ${error instanceof Error ? error.message : 'Unknown error'}`
+        };
+    }
+}