@trackunit/filters-graphql-hook 2.1.28 → 2.1.33

package/index.cjs.js

@@ -2,11 +2,11 @@
 
 require('react/jsx-runtime');
 var i18nLibraryTranslation = require('@trackunit/i18n-library-translation');
+var react = require('react');
 var filtersFilterBar = require('@trackunit/filters-filter-bar');
-var sharedUtils = require('@trackunit/shared-utils');
 var zod = require('zod');
 var reactCoreHooks = require('@trackunit/react-core-hooks');
-var react = require('react');
+var sharedUtils = require('@trackunit/shared-utils');
 var irisAppRuntimeCoreApi = require('@trackunit/iris-app-runtime-core-api');
 
 var defaultTranslations = {
@@ -51,6 +51,249 @@ const setupLibraryTranslations = () => {
     i18nLibraryTranslation.registerTranslations(translations);
 };
 
+const accessManagementMode = {
+    LOCKED_FOR_ALL: "LOCKED_FOR_ALL",
+    UNKNOWN: "UNKNOWN",
+    UNLOCKED_FOR_ALL: "UNLOCKED_FOR_ALL",
+    UNLOCKED_FOR_KEY: "UNLOCKED_FOR_KEY",
+    UNSUPPORTED: "UNSUPPORTED",
+};
+const assetActivityState = {
+    IDLING: "IDLING",
+    STOPPED: "STOPPED",
+    UNKNOWN: "UNKNOWN",
+    WORKING: "WORKING",
+};
+const assetCriticalityState = {
+    CRITICAL: "CRITICAL",
+    LOW: "LOW",
+    NONE: "NONE",
+};
+const assetLastSeen = {
+    LAST_7_DAYS: "LAST_7_DAYS",
+    LAST_24_HOURS: "LAST_24_HOURS",
+    LAST_30_DAYS: "LAST_30_DAYS",
+    LAST_HOUR: "LAST_HOUR",
+    OLDER_THAN_30_DAYS: "OLDER_THAN_30_DAYS",
+};
+const assetType = {
+    ATTACHMENT: "ATTACHMENT",
+    EQUIPMENT: "EQUIPMENT",
+    GATEWAY: "GATEWAY",
+    MACHINE: "MACHINE",
+    OTHER: "OTHER",
+    TOOL: "TOOL",
+    VEHICLE: "VEHICLE",
+};
+const fleetDataHealthDeviceStatus = {
+    CRITICAL: "CRITICAL",
+    LOW: "LOW",
+};
+const fleetDataHealthIssueCategory = {
+    COVERAGE: "COVERAGE",
+    DEVICE_BATTERY: "DEVICE_BATTERY",
+    INSTALL_AND_CONFIGURATION: "INSTALL_AND_CONFIGURATION",
+    NON_REPORTING_DEVICE: "NON_REPORTING_DEVICE",
+};
+const fleetDataHealthIssueState = {
+    OPEN: "OPEN",
+    RESOLVED: "RESOLVED",
+};
+const fleetDataHealthIssueType = {
+    DATA_NOT_RECEIVED: "DATA_NOT_RECEIVED",
+    DEVICE_BATTERY_APPROACHING_END_OF_LIFE: "DEVICE_BATTERY_APPROACHING_END_OF_LIFE",
+    LOW_CELLULAR_COVERAGE: "LOW_CELLULAR_COVERAGE",
+    LOW_DEVICE_BATTERY: "LOW_DEVICE_BATTERY",
+    LOW_DEVICE_INPUT_VOLTAGE: "LOW_DEVICE_INPUT_VOLTAGE",
+    LOW_GPS_COVERAGE: "LOW_GPS_COVERAGE",
+    NO_CAN_DATA_CONFIGURATION: "NO_CAN_DATA_CONFIGURATION",
+    OPERATING_HOURS_FROM_CAN_MODIFIED: "OPERATING_HOURS_FROM_CAN_MODIFIED",
+    OPERATING_HOURS_REPORTING_0_HOURS_PER_DAY: "OPERATING_HOURS_REPORTING_0_HOURS_PER_DAY",
+    OPERATING_HOURS_REPORTING_24_HOURS_PER_DAY: "OPERATING_HOURS_REPORTING_24_HOURS_PER_DAY",
+    UNUSUAL_OPERATING_HOURS: "UNUSUAL_OPERATING_HOURS",
+};
+const metadataCompleteness = {
+    COMPLETE: "COMPLETE",
+    PARTIAL: "PARTIAL",
+};
+const rentalStatus = {
+    AVAILABLE: "AVAILABLE",
+    IN_REPAIR: "IN_REPAIR",
+    NOT_ON_CONTRACT: "NOT_ON_CONTRACT",
+    OFF_RENT: "OFF_RENT",
+    ON_RENT: "ON_RENT",
+    OTHER: "OTHER",
+    PICK_UP_READY: "PICK_UP_READY",
+    RESERVED: "RESERVED",
+    RETURNED: "RETURNED",
+    TRANSFER: "TRANSFER",
+};
+const servicePlanStatus = {
+    COMPLETE: "COMPLETE",
+    DRAFT: "DRAFT",
+    FULLY_CONFIGURED: "FULLY_CONFIGURED",
+    HAS_PLAN: "HAS_PLAN",
+    HAS_SERVICE_PROVIDER: "HAS_SERVICE_PROVIDER",
+    MISSING_PLAN: "MISSING_PLAN",
+    MISSING_PROVIDER: "MISSING_PROVIDER",
+    OVERDUE: "OVERDUE",
+    PLANNED: "PLANNED",
+    UNKNOWN: "UNKNOWN",
+    UPCOMING: "UPCOMING",
+};
+const siteTypeSFS = {
+    AREA: "AREA",
+    CLASSIC_POI: "CLASSIC_POI",
+    CLASSIC_ZONE: "CLASSIC_ZONE",
+    CONSTRUCTION_SITE: "CONSTRUCTION_SITE",
+    DEPOT: "DEPOT",
+    NOT_ON_SITE: "NOT_ON_SITE",
+    WORK_PLACE: "WORK_PLACE",
+};
+
+const numberRangeSchema = zod.z.object({
+    min: zod.z.number().optional(),
+    max: zod.z.number().optional(),
+});
+const aggregatedNumberRangeSchema = zod.z.object({
+    period: zod.z.literal("LIFETIME"),
+    range: numberRangeSchema,
+});
+const customFieldSchema = zod.z
+    .object({
+    booleanValue: zod.z.boolean().optional(),
+    dateRange: filtersFilterBar.dateRangeSchema.optional(),
+    definitionId: zod.z.string().optional(),
+    numberRange: zod.z
+        .object({
+        from: zod.z.number().optional(),
+        to: zod.z.number().optional(),
+    })
+        .optional(),
+    stringArrayValue: zod.z.array(zod.z.string()).optional(),
+    stringWildcardValue: zod.z.string().optional(),
+})
+    .strip();
+/**
+ * Drift guard: keying the supported subset to `keyof AssetFiltersInput` forces a
+ * compile error if the generated GraphQL schema renames or removes a field we map.
+ * Enum-value drift is already caught because every `z.nativeEnum(...)` references a
+ * generated GraphQL enum, so a removed enum breaks the import.
+ */
+const assetFiltersInputSchema = zod.z
+    .object({
+    accessManagementDesiredModes: zod.z.array(zod.z.nativeEnum(accessManagementMode)).optional(),
+    activeFilter: zod.z.boolean().optional(),
+    activities: zod.z.array(zod.z.nativeEnum(assetActivityState)).optional(),
+    area: filtersFilterBar.areaFilterGeoJsonGeometrySchema.optional(),
+    assetIds: zod.z.array(zod.z.string()).optional(),
+    assetTypes: zod.z.array(zod.z.nativeEnum(assetType)).optional(),
+    brands: zod.z.array(zod.z.string()).optional(),
+    criticalities: zod.z.array(zod.z.nativeEnum(assetCriticalityState)).optional(),
+    customerIds: zod.z.array(zod.z.string()).optional(),
+    deviceTypes: zod.z.array(zod.z.string()).optional(),
+    fleetHealthCategories: zod.z.array(zod.z.nativeEnum(fleetDataHealthIssueCategory)).optional(),
+    fleetHealthDeviceStatuses: zod.z.array(zod.z.nativeEnum(fleetDataHealthDeviceStatus)).optional(),
+    fleetHealthTypes: zod.z.array(zod.z.nativeEnum(fleetDataHealthIssueType)).optional(),
+    groups: zod.z.array(zod.z.string()).optional(),
+    customFields: zod.z.array(customFieldSchema).optional(),
+    insightsFilters: zod.z
+        .object({
+        afterTreatmentDieselExhaustFluidTankLevel: numberRangeSchema.optional(),
+        batteryChargerState: zod.z.array(zod.z.boolean()).optional(),
+        batteryPotential: numberRangeSchema.optional(),
+        batteryStateOfChargePercent: numberRangeSchema.optional(),
+        cumulativeIdleHours: aggregatedNumberRangeSchema.optional(),
+        cumulativeOperatingHours: aggregatedNumberRangeSchema.optional(),
+        fuelLevel: numberRangeSchema.optional(),
+    })
+        .strip()
+        .optional(),
+    lastSeen: zod.z.nativeEnum(assetLastSeen).optional(),
+    metadataCompleteness: zod.z.nativeEnum(metadataCompleteness).optional(),
+    models: zod.z.array(zod.z.string()).optional(),
+    ownerAccountIds: zod.z.array(zod.z.string()).optional(),
+    owningDepotSiteIds: zod.z.array(zod.z.string()).optional(),
+    partnerId: zod.z.string().optional(),
+    pendingTelematicsDevices: zod.z.array(zod.z.string()).optional(),
+    rentalActiveContractFilters: zod.z
+        .object({
+        customerExternalReferences: zod.z.array(zod.z.string()).optional(),
+        customerParentExternalReferences: zod.z.array(zod.z.string()).optional(),
+        customerParentNames: zod.z.array(zod.z.string()).optional(),
+        offRentDatesDateRange: filtersFilterBar.dateRangeSchema.optional(),
+        onRentDatesDateRange: filtersFilterBar.dateRangeSchema.optional(),
+    })
+        .optional(),
+    rentalContractOrderNumbers: zod.z.array(zod.z.string()).optional(),
+    rentalContractReferenceCodeDescriptionQuery: zod.z.string().optional(),
+    rentalContractReferenceCodes: zod.z.array(zod.z.string()).optional(),
+    rentalStatuses: zod.z.array(zod.z.nativeEnum(rentalStatus)).optional(),
+    searchQuery: zod.z.string().optional(),
+    serviceBooked: zod.z.array(zod.z.boolean()).optional(),
+    servicePlanAssignments: zod.z.array(zod.z.nativeEnum(servicePlanStatus)).optional(),
+    servicePlanIds: zod.z.array(zod.z.string()).optional(),
+    servicePlanStatuses: zod.z.array(zod.z.nativeEnum(servicePlanStatus)).optional(),
+    serviceProviderIds: zod.z.array(zod.z.string()).optional(),
+    siteIds: zod.z.array(zod.z.string()).optional(),
+    siteTypes: zod.z.array(zod.z.nativeEnum(siteTypeSFS)).optional(),
+    sustainabilityExcluded: zod.z.boolean().optional(),
+    telematicsDeviceIsConnected: zod.z.boolean().optional(),
+    types: zod.z.array(zod.z.string()).optional(),
+})
+    .strip();
+/**
+ * Type guard for plain (non-array) objects so unknown payloads can be traversed safely.
+ *
+ * @param value - Unknown value to test.
+ * @returns {boolean} True when the value is a non-null, non-array object.
+ */
+const isPlainObject = (value) => {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+/**
+ * Recursively strips properties whose value is `null` so they are treated as omitted.
+ *
+ * The generated `AssetFiltersInput` uses InputMaybe (`T | null | undefined`), and
+ * `useActiveAssetFilters` emits `null` for unset fields. The zod schema rejects `null`,
+ * so this deep-strips `null`-valued properties from plain objects, recursing into nested
+ * plain objects and arrays of plain objects. Non-null values are returned unchanged.
+ *
+ * @param value - Unknown payload to normalize.
+ * @returns {unknown} The payload with all `null`-valued properties removed.
+ */
+const stripNullProperties = (value) => {
+    if (Array.isArray(value)) {
+        return value.map(stripNullProperties);
+    }
+    if (isPlainObject(value)) {
+        const result = {};
+        for (const [key, propertyValue] of Object.entries(value)) {
+            if (propertyValue === null) {
+                continue;
+            }
+            result[key] = stripNullProperties(propertyValue);
+        }
+        return result;
+    }
+    return value;
+};
+/**
+ * Validates an unknown payload against the supported public GraphQL AssetFiltersInput subset.
+ *
+ * Unknown/unsupported keys are stripped; invalid values for supported fields produce an error.
+ *
+ * @param input - Unknown hash payload supplied to /goto/assets or /goto/map.
+ * @returns {ParseAssetFiltersInputResult} The stripped, validated subset or a validation error.
+ */
+const parseAssetFiltersInput = (input) => {
+    const parsed = assetFiltersInputSchema.safeParse(stripNullProperties(input));
+    if (!parsed.success) {
+        return { success: false, error: parsed.error.message };
+    }
+    return { success: true, data: parsed.data };
+};
+
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const isStringFilterValue = (value) => {
     return typeof value === "string";
@@ -285,106 +528,6 @@ value) => {
     return { period: "LIFETIME", range: { min, max } };
 };
 
-const accessManagementMode = {
-    LOCKED_FOR_ALL: "LOCKED_FOR_ALL",
-    UNKNOWN: "UNKNOWN",
-    UNLOCKED_FOR_ALL: "UNLOCKED_FOR_ALL",
-    UNLOCKED_FOR_KEY: "UNLOCKED_FOR_KEY",
-    UNSUPPORTED: "UNSUPPORTED",
-};
-const assetActivityState = {
-    IDLING: "IDLING",
-    STOPPED: "STOPPED",
-    UNKNOWN: "UNKNOWN",
-    WORKING: "WORKING",
-};
-const assetCriticalityState = {
-    CRITICAL: "CRITICAL",
-    LOW: "LOW",
-    NONE: "NONE",
-};
-const assetLastSeen = {
-    LAST_7_DAYS: "LAST_7_DAYS",
-    LAST_24_HOURS: "LAST_24_HOURS",
-    LAST_30_DAYS: "LAST_30_DAYS",
-    LAST_HOUR: "LAST_HOUR",
-    OLDER_THAN_30_DAYS: "OLDER_THAN_30_DAYS",
-};
-const assetType = {
-    ATTACHMENT: "ATTACHMENT",
-    EQUIPMENT: "EQUIPMENT",
-    GATEWAY: "GATEWAY",
-    MACHINE: "MACHINE",
-    OTHER: "OTHER",
-    TOOL: "TOOL",
-    VEHICLE: "VEHICLE",
-};
-const fleetDataHealthDeviceStatus = {
-    CRITICAL: "CRITICAL",
-    LOW: "LOW",
-};
-const fleetDataHealthIssueCategory = {
-    COVERAGE: "COVERAGE",
-    DEVICE_BATTERY: "DEVICE_BATTERY",
-    INSTALL_AND_CONFIGURATION: "INSTALL_AND_CONFIGURATION",
-    NON_REPORTING_DEVICE: "NON_REPORTING_DEVICE",
-};
-const fleetDataHealthIssueState = {
-    OPEN: "OPEN",
-    RESOLVED: "RESOLVED",
-};
-const fleetDataHealthIssueType = {
-    DATA_NOT_RECEIVED: "DATA_NOT_RECEIVED",
-    DEVICE_BATTERY_APPROACHING_END_OF_LIFE: "DEVICE_BATTERY_APPROACHING_END_OF_LIFE",
-    LOW_CELLULAR_COVERAGE: "LOW_CELLULAR_COVERAGE",
-    LOW_DEVICE_BATTERY: "LOW_DEVICE_BATTERY",
-    LOW_DEVICE_INPUT_VOLTAGE: "LOW_DEVICE_INPUT_VOLTAGE",
-    LOW_GPS_COVERAGE: "LOW_GPS_COVERAGE",
-    NO_CAN_DATA_CONFIGURATION: "NO_CAN_DATA_CONFIGURATION",
-    OPERATING_HOURS_FROM_CAN_MODIFIED: "OPERATING_HOURS_FROM_CAN_MODIFIED",
-    OPERATING_HOURS_REPORTING_0_HOURS_PER_DAY: "OPERATING_HOURS_REPORTING_0_HOURS_PER_DAY",
-    OPERATING_HOURS_REPORTING_24_HOURS_PER_DAY: "OPERATING_HOURS_REPORTING_24_HOURS_PER_DAY",
-    UNUSUAL_OPERATING_HOURS: "UNUSUAL_OPERATING_HOURS",
-};
-const metadataCompleteness = {
-    COMPLETE: "COMPLETE",
-    PARTIAL: "PARTIAL",
-};
-const rentalStatus = {
-    AVAILABLE: "AVAILABLE",
-    IN_REPAIR: "IN_REPAIR",
-    NOT_ON_CONTRACT: "NOT_ON_CONTRACT",
-    OFF_RENT: "OFF_RENT",
-    ON_RENT: "ON_RENT",
-    OTHER: "OTHER",
-    PICK_UP_READY: "PICK_UP_READY",
-    RESERVED: "RESERVED",
-    RETURNED: "RETURNED",
-    TRANSFER: "TRANSFER",
-};
-const servicePlanStatus = {
-    COMPLETE: "COMPLETE",
-    DRAFT: "DRAFT",
-    FULLY_CONFIGURED: "FULLY_CONFIGURED",
-    HAS_PLAN: "HAS_PLAN",
-    HAS_SERVICE_PROVIDER: "HAS_SERVICE_PROVIDER",
-    MISSING_PLAN: "MISSING_PLAN",
-    MISSING_PROVIDER: "MISSING_PROVIDER",
-    OVERDUE: "OVERDUE",
-    PLANNED: "PLANNED",
-    UNKNOWN: "UNKNOWN",
-    UPCOMING: "UPCOMING",
-};
-const siteTypeSFS = {
-    AREA: "AREA",
-    CLASSIC_POI: "CLASSIC_POI",
-    CLASSIC_ZONE: "CLASSIC_ZONE",
-    CONSTRUCTION_SITE: "CONSTRUCTION_SITE",
-    DEPOT: "DEPOT",
-    NOT_ON_SITE: "NOT_ON_SITE",
-    WORK_PLACE: "WORK_PLACE",
-};
-
 const CustomFieldPrefix$1 = "cf__";
 /**
  * Converts custom field filters to a format that can be used by the GraphQL API
@@ -562,6 +705,221 @@ const useActiveAssetFilters = (filters) => {
 };
 const booleanArraySchema = zod.z.array(zod.z.boolean());
 
+/**
+ * Map plain strings to ValueName objects (inverse of valueNameArrayOrUndefined).
+ */
+const toValueNameArray = (values) => {
+    return values.map(value => ({ name: value, value }));
+};
+/**
+ * Wrap a boolean in a boolean filter value (inverse of valueBooleanOrUndefined).
+ */
+const toBooleanFilterValue = (booleanValue) => {
+    return { booleanValue };
+};
+/**
+ * Map a number range to a min/max filter value (inverse of minMaxFilterValueToNumberRange).
+ */
+const toMinMaxFilterValue = (range) => {
+    return { min: range.min, max: range.max };
+};
+/**
+ * Converts a public GraphQL AssetFiltersInput-shaped object to Manager filter-bar values.
+ *
+ * @param input - Unknown hash payload supplied to /goto/assets or /goto/map.
+ * @returns {AssetFiltersInputToFilterBarValuesResult} A conversion result with stripped unsupported fields or validation errors for invalid supported fields.
+ */
+const convertAssetFiltersInputToFilterBarValues = (input) => {
+    const parsed = parseAssetFiltersInput(input);
+    if (!parsed.success) {
+        return { success: false, error: parsed.error };
+    }
+    const filterBarValues = {};
+    if (parsed.data.searchQuery !== undefined) {
+        filterBarValues.search = parsed.data.searchQuery;
+    }
+    if (parsed.data.assetIds !== undefined) {
+        filterBarValues.assetIds = parsed.data.assetIds;
+    }
+    if (parsed.data.siteIds !== undefined) {
+        filterBarValues.siteIds = toValueNameArray(parsed.data.siteIds);
+    }
+    if (parsed.data.groups !== undefined) {
+        filterBarValues.groups = toValueNameArray(parsed.data.groups);
+    }
+    if (parsed.data.ownerAccountIds !== undefined) {
+        filterBarValues.ownerAccountIds = toValueNameArray(parsed.data.ownerAccountIds);
+    }
+    if (parsed.data.customerIds !== undefined) {
+        filterBarValues.customerIds = toValueNameArray(parsed.data.customerIds);
+    }
+    if (parsed.data.owningDepotSiteIds !== undefined) {
+        filterBarValues.siteDepotOwnershipIds = toValueNameArray(parsed.data.owningDepotSiteIds);
+    }
+    if (parsed.data.brands !== undefined) {
+        filterBarValues.brands = parsed.data.brands;
+    }
+    if (parsed.data.types !== undefined) {
+        filterBarValues.types = parsed.data.types;
+    }
+    if (parsed.data.models !== undefined) {
+        filterBarValues.models = parsed.data.models;
+    }
+    if (parsed.data.pendingTelematicsDevices !== undefined) {
+        filterBarValues.pendingTelematicsDevices = parsed.data.pendingTelematicsDevices;
+    }
+    if (parsed.data.deviceTypes !== undefined) {
+        filterBarValues.deviceTypes = toValueNameArray(parsed.data.deviceTypes);
+    }
+    if (parsed.data.activities !== undefined) {
+        filterBarValues.activity = parsed.data.activities;
+    }
+    if (parsed.data.assetTypes !== undefined) {
+        filterBarValues.assetType = parsed.data.assetTypes;
+    }
+    if (parsed.data.criticalities !== undefined) {
+        filterBarValues.criticality = parsed.data.criticalities;
+    }
+    if (parsed.data.rentalStatuses !== undefined) {
+        filterBarValues.rentalStatuses = parsed.data.rentalStatuses;
+    }
+    if (parsed.data.siteTypes !== undefined) {
+        filterBarValues.siteType = parsed.data.siteTypes;
+    }
+    if (parsed.data.fleetHealthTypes !== undefined) {
+        filterBarValues.fleetHealthTypes = toValueNameArray(parsed.data.fleetHealthTypes);
+    }
+    if (parsed.data.fleetHealthCategories !== undefined) {
+        filterBarValues.fleetHealthCategories = toValueNameArray(parsed.data.fleetHealthCategories);
+    }
+    if (parsed.data.fleetHealthDeviceStatuses !== undefined) {
+        filterBarValues.fleetHealthStatus = toValueNameArray(parsed.data.fleetHealthDeviceStatuses);
+    }
+    if (parsed.data.accessManagementDesiredModes !== undefined) {
+        filterBarValues.accessManagementMode = parsed.data.accessManagementDesiredModes;
+    }
+    if (parsed.data.activeFilter !== undefined) {
+        filterBarValues.activeFilter = toBooleanFilterValue(parsed.data.activeFilter);
+    }
+    if (parsed.data.telematicsDeviceIsConnected !== undefined) {
+        filterBarValues.telematicsConnected = toBooleanFilterValue(parsed.data.telematicsDeviceIsConnected);
+    }
+    if (parsed.data.sustainabilityExcluded !== undefined) {
+        filterBarValues.assetVisibility = toBooleanFilterValue(parsed.data.sustainabilityExcluded);
+    }
+    if (parsed.data.area !== undefined) {
+        filterBarValues.area = parsed.data.area;
+    }
+    if (parsed.data.lastSeen !== undefined) {
+        filterBarValues.lastSeen = parsed.data.lastSeen;
+    }
+    if (parsed.data.metadataCompleteness !== undefined) {
+        filterBarValues.metadataCompleteness = { name: parsed.data.metadataCompleteness, value: parsed.data.metadataCompleteness };
+    }
+    if (parsed.data.serviceBooked !== undefined) {
+        filterBarValues.serviceBooked = parsed.data.serviceBooked;
+    }
+    if (parsed.data.servicePlanAssignments !== undefined) {
+        filterBarValues.servicePlanStatus = parsed.data.servicePlanAssignments;
+    }
+    if (parsed.data.servicePlanIds !== undefined) {
+        filterBarValues.servicePlan = toValueNameArray(parsed.data.servicePlanIds);
+    }
+    if (parsed.data.servicePlanStatuses !== undefined) {
+        filterBarValues.serviceStatus = parsed.data.servicePlanStatuses;
+    }
+    if (parsed.data.serviceProviderIds !== undefined) {
+        filterBarValues.serviceProvider = toValueNameArray(parsed.data.serviceProviderIds);
+    }
+    if (parsed.data.partnerId !== undefined) {
+        filterBarValues.partner = toValueNameArray([parsed.data.partnerId]);
+    }
+    if (parsed.data.rentalContractOrderNumbers !== undefined) {
+        filterBarValues.rentalContractOrderNumber = parsed.data.rentalContractOrderNumbers;
+    }
+    if (parsed.data.rentalContractReferenceCodes !== undefined) {
+        filterBarValues.rentalContractReferenceCode = parsed.data.rentalContractReferenceCodes;
+    }
+    if (parsed.data.rentalContractReferenceCodeDescriptionQuery !== undefined) {
+        filterBarValues.rentalContractReferenceCodeDescriptionQuery =
+            parsed.data.rentalContractReferenceCodeDescriptionQuery;
+    }
+    if (parsed.data.rentalActiveContractFilters?.onRentDatesDateRange !== undefined) {
+        filterBarValues.rentalActiveContractItemOnRentDatesDateRange =
+            parsed.data.rentalActiveContractFilters.onRentDatesDateRange;
+    }
+    if (parsed.data.rentalActiveContractFilters?.offRentDatesDateRange !== undefined) {
+        filterBarValues.rentalActiveContractItemOffRentDatesDateRange =
+            parsed.data.rentalActiveContractFilters.offRentDatesDateRange;
+    }
+    if (parsed.data.rentalActiveContractFilters?.customerExternalReferences !== undefined) {
+        filterBarValues.rentalContractCustomerExternalReference =
+            parsed.data.rentalActiveContractFilters.customerExternalReferences;
+    }
+    if (parsed.data.rentalActiveContractFilters?.customerParentExternalReferences !== undefined) {
+        filterBarValues.rentalContractCustomerParentExternalReference =
+            parsed.data.rentalActiveContractFilters.customerParentExternalReferences;
+    }
+    if (parsed.data.rentalActiveContractFilters?.customerParentNames !== undefined) {
+        filterBarValues.rentalContractCustomerParentName = parsed.data.rentalActiveContractFilters.customerParentNames;
+    }
+    if (parsed.data.insightsFilters?.fuelLevel !== undefined) {
+        filterBarValues.insightsFuelLevel = toMinMaxFilterValue(parsed.data.insightsFilters.fuelLevel);
+    }
+    if (parsed.data.insightsFilters?.afterTreatmentDieselExhaustFluidTankLevel !== undefined) {
+        filterBarValues.insightsAfterTreatmentDieselExhaustFluidTankLevel = toMinMaxFilterValue(parsed.data.insightsFilters.afterTreatmentDieselExhaustFluidTankLevel);
+    }
+    if (parsed.data.insightsFilters?.batteryPotential !== undefined) {
+        filterBarValues.insightsBatteryPotential = toMinMaxFilterValue(parsed.data.insightsFilters.batteryPotential);
+    }
+    if (parsed.data.insightsFilters?.batteryStateOfChargePercent !== undefined) {
+        filterBarValues.insightsBatteryStateOfChargePercent = toMinMaxFilterValue(parsed.data.insightsFilters.batteryStateOfChargePercent);
+    }
+    if (parsed.data.insightsFilters?.cumulativeIdleHours !== undefined) {
+        filterBarValues.insightsCumulativeIdleHours = toMinMaxFilterValue(parsed.data.insightsFilters.cumulativeIdleHours.range);
+    }
+    if (parsed.data.insightsFilters?.cumulativeOperatingHours !== undefined) {
+        filterBarValues.insightsCumulativeOperatingHours = toMinMaxFilterValue(parsed.data.insightsFilters.cumulativeOperatingHours.range);
+    }
+    if (parsed.data.insightsFilters?.batteryChargerState?.[0] !== undefined) {
+        const value = String(parsed.data.insightsFilters.batteryChargerState[0]);
+        filterBarValues.insightsBatteryChargerState = { name: value, value };
+    }
+    parsed.data.customFields?.forEach(customField => {
+        if (!customField.definitionId) {
+            return;
+        }
+        const key = `${CustomFieldPrefix}${customField.definitionId}`;
+        if (customField.stringWildcardValue !== undefined) {
+            filterBarValues[key] = customField.stringWildcardValue;
+        }
+        else if (customField.stringArrayValue !== undefined) {
+            filterBarValues[key] = customField.stringArrayValue;
+        }
+        else if (customField.numberRange !== undefined) {
+            filterBarValues[key] = { min: customField.numberRange.from, max: customField.numberRange.to };
+        }
+        else if (customField.dateRange !== undefined) {
+            filterBarValues[key] = customField.dateRange;
+        }
+        else if (customField.booleanValue !== undefined) {
+            filterBarValues[key] = toBooleanFilterValue(customField.booleanValue);
+        }
+    });
+    return { success: true, filterBarValues };
+};
+
+/**
+ * Exposes the AssetFiltersInput converter through a stable hook API.
+ *
+ * @returns {{ assetFiltersInputToFilterBarValues: (input: unknown) => AssetFiltersInputToFilterBarValuesResult }} Stable converter API.
+ */
+const useAssetFiltersInputToFilterBarValues = () => {
+    return react.useMemo(() => ({
+        assetFiltersInputToFilterBarValues: convertAssetFiltersInputToFilterBarValues,
+    }), []);
+};
+
 /**
  * Sort properties that require an aggregation period
  */
@@ -645,6 +1003,7 @@ exports.minMaxFilterValueToNumberRange = minMaxFilterValueToNumberRange;
 exports.positiveValueBooleanOrNull = positiveValueBooleanOrNull;
 exports.stringArrayOrUndefined = stringArrayOrUndefined;
 exports.useActiveAssetFilters = useActiveAssetFilters;
+exports.useAssetFiltersInputToFilterBarValues = useAssetFiltersInputToFilterBarValues;
 exports.useAssetQueryFilters = useAssetQueryFilters;
 exports.useAssetSortInput = useAssetSortInput;
 exports.useCustomFieldFilters = useCustomFieldFilters;