onroute-policy-engine 2.1.1 → 2.2.1

package/dist/enum/custom-operator.d.ts

@@ -0,0 +1,6 @@
+export declare enum CustomOperator {
+    DateLessThan = "dateLessThan",
+    IsEmptyArray = "isEmptyArray",
+    Regex = "regex",
+    StringMinimumLength = "stringMinimumLength"
+}

package/dist/enum/custom-operator.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomOperator = void 0;
+var CustomOperator;
+(function (CustomOperator) {
+    CustomOperator["DateLessThan"] = "dateLessThan";
+    CustomOperator["IsEmptyArray"] = "isEmptyArray";
+    CustomOperator["Regex"] = "regex";
+    CustomOperator["StringMinimumLength"] = "stringMinimumLength";
+})(CustomOperator || (exports.CustomOperator = CustomOperator = {}));

package/dist/enum/facts.d.ts

@@ -1,15 +1,19 @@
 export declare enum PolicyFacts {
     AllowedVehicles = "allowedVehicles",
+    AxleCalcViolations = "axleCalcViolations",
+    ConfigurationIsValid = "configurationIsValid",
+    DaysBetween = "daysBetween",
     DaysInPermitYear = "daysInPermitYear",
     EndOfPermitQuarter = "endOfPermitQuarter",
+    GrossVehicleCombinationWeight = "gvcw",
+    PolicyCheckPassed = "policyCheckPassed",
     ValidationDate = "validationDate",
-    ConfigurationIsValid = "configurationIsValid",
-    DaysBetween = "daysBetween"
+    VehicleConfiguration = "vehicleConfiguration"
 }
 export declare enum CostFacts {
     ConditionalFixedCost = "conditionalFixedCost",
-    FixedCost = "fixedCost",
-    CostPerMonth = "costPerMonth",
     CostPerKilometre = "costPerKilometre",
+    CostPerMonth = "costPerMonth",
+    FixedCost = "fixedCost",
     RangeMatrixCostLookup = "rangeMatrixCostLookup"
 }

package/dist/enum/facts.js

@@ -4,17 +4,21 @@ exports.CostFacts = exports.PolicyFacts = void 0;
 var PolicyFacts;
 (function (PolicyFacts) {
     PolicyFacts["AllowedVehicles"] = "allowedVehicles";
+    PolicyFacts["AxleCalcViolations"] = "axleCalcViolations";
+    PolicyFacts["ConfigurationIsValid"] = "configurationIsValid";
+    PolicyFacts["DaysBetween"] = "daysBetween";
     PolicyFacts["DaysInPermitYear"] = "daysInPermitYear";
     PolicyFacts["EndOfPermitQuarter"] = "endOfPermitQuarter";
+    PolicyFacts["GrossVehicleCombinationWeight"] = "gvcw";
+    PolicyFacts["PolicyCheckPassed"] = "policyCheckPassed";
     PolicyFacts["ValidationDate"] = "validationDate";
-    PolicyFacts["ConfigurationIsValid"] = "configurationIsValid";
-    PolicyFacts["DaysBetween"] = "daysBetween";
+    PolicyFacts["VehicleConfiguration"] = "vehicleConfiguration";
 })(PolicyFacts || (exports.PolicyFacts = PolicyFacts = {}));
 var CostFacts;
 (function (CostFacts) {
     CostFacts["ConditionalFixedCost"] = "conditionalFixedCost";
-    CostFacts["FixedCost"] = "fixedCost";
-    CostFacts["CostPerMonth"] = "costPerMonth";
     CostFacts["CostPerKilometre"] = "costPerKilometre";
+    CostFacts["CostPerMonth"] = "costPerMonth";
+    CostFacts["FixedCost"] = "fixedCost";
     CostFacts["RangeMatrixCostLookup"] = "rangeMatrixCostLookup";
 })(CostFacts || (exports.CostFacts = CostFacts = {}));

package/dist/enum/index.d.ts

@@ -1,6 +1,8 @@
 export { AccessoryVehicleType } from './accessory-vehicle-type';
+export { CustomOperator } from './custom-operator';
 export { PolicyFacts, CostFacts } from './facts';
 export { PermitAppInfo } from './permit-app-info';
+export { PolicyCheckResultType, PolicyCheckId } from './policy-check';
 export { RelativePosition } from './relative-position';
 export { ValidationResultCode } from './validation-result-code';
 export { ValidationResultType } from './validation-result-type';

package/dist/enum/index.js

@@ -1,13 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VehicleTypes = exports.VehicleCategory = exports.ValidationResultType = exports.ValidationResultCode = exports.RelativePosition = exports.PermitAppInfo = exports.CostFacts = exports.PolicyFacts = exports.AccessoryVehicleType = void 0;
+exports.VehicleTypes = exports.VehicleCategory = exports.ValidationResultType = exports.ValidationResultCode = exports.RelativePosition = exports.PolicyCheckId = exports.PolicyCheckResultType = exports.PermitAppInfo = exports.CostFacts = exports.PolicyFacts = exports.CustomOperator = exports.AccessoryVehicleType = void 0;
 var accessory_vehicle_type_1 = require("./accessory-vehicle-type");
 Object.defineProperty(exports, "AccessoryVehicleType", { enumerable: true, get: function () { return accessory_vehicle_type_1.AccessoryVehicleType; } });
+var custom_operator_1 = require("./custom-operator");
+Object.defineProperty(exports, "CustomOperator", { enumerable: true, get: function () { return custom_operator_1.CustomOperator; } });
 var facts_1 = require("./facts");
 Object.defineProperty(exports, "PolicyFacts", { enumerable: true, get: function () { return facts_1.PolicyFacts; } });
 Object.defineProperty(exports, "CostFacts", { enumerable: true, get: function () { return facts_1.CostFacts; } });
 var permit_app_info_1 = require("./permit-app-info");
 Object.defineProperty(exports, "PermitAppInfo", { enumerable: true, get: function () { return permit_app_info_1.PermitAppInfo; } });
+var policy_check_1 = require("./policy-check");
+Object.defineProperty(exports, "PolicyCheckResultType", { enumerable: true, get: function () { return policy_check_1.PolicyCheckResultType; } });
+Object.defineProperty(exports, "PolicyCheckId", { enumerable: true, get: function () { return policy_check_1.PolicyCheckId; } });
 var relative_position_1 = require("./relative-position");
 Object.defineProperty(exports, "RelativePosition", { enumerable: true, get: function () { return relative_position_1.RelativePosition; } });
 var validation_result_code_1 = require("./validation-result-code");

package/dist/enum/permit-app-info.d.ts

@@ -4,14 +4,17 @@
  * referenced from within source code.
  */
 export declare enum PermitAppInfo {
-    PermitType = "permitType",
+    AxleConfiguration = "$.vehicleConfiguration.axleConfiguration",
+    CompanyName = "$.companyName",
+    Commodity = "$.permittedCommodity.commodityType",
     PermitData = "permitData",
-    PermitStartDate = "$.startDate",
     PermitDateFormat = "YYYY-MM-DD",
-    CompanyName = "$.companyName",
     PermitDuration = "$.permitDuration",
+    PermitStartDate = "$.startDate",
+    PermitType = "permitType",
     PowerUnitType = "$.vehicleDetails.vehicleSubType",
+    TotalDistance = "$.permittedRoute.manualRoute.totalDistance",
     TrailerList = "$.vehicleConfiguration.trailers",
-    Commodity = "$.permittedCommodity.commodityType",
-    TotalDistance = "$.permittedRoute.manualRoute.totalDistance"
+    VehicleConfiguration = "$.vehicleConfiguration",
+    VehicleDetails = "$.vehicleDetails"
 }

package/dist/enum/permit-app-info.js

@@ -8,14 +8,17 @@ exports.PermitAppInfo = void 0;
  */
 var PermitAppInfo;
 (function (PermitAppInfo) {
-    PermitAppInfo["PermitType"] = "permitType";
+    PermitAppInfo["AxleConfiguration"] = "$.vehicleConfiguration.axleConfiguration";
+    PermitAppInfo["CompanyName"] = "$.companyName";
+    PermitAppInfo["Commodity"] = "$.permittedCommodity.commodityType";
     PermitAppInfo["PermitData"] = "permitData";
-    PermitAppInfo["PermitStartDate"] = "$.startDate";
     PermitAppInfo["PermitDateFormat"] = "YYYY-MM-DD";
-    PermitAppInfo["CompanyName"] = "$.companyName";
     PermitAppInfo["PermitDuration"] = "$.permitDuration";
+    PermitAppInfo["PermitStartDate"] = "$.startDate";
+    PermitAppInfo["PermitType"] = "permitType";
     PermitAppInfo["PowerUnitType"] = "$.vehicleDetails.vehicleSubType";
-    PermitAppInfo["TrailerList"] = "$.vehicleConfiguration.trailers";
-    PermitAppInfo["Commodity"] = "$.permittedCommodity.commodityType";
     PermitAppInfo["TotalDistance"] = "$.permittedRoute.manualRoute.totalDistance";
+    PermitAppInfo["TrailerList"] = "$.vehicleConfiguration.trailers";
+    PermitAppInfo["VehicleConfiguration"] = "$.vehicleConfiguration";
+    PermitAppInfo["VehicleDetails"] = "$.vehicleDetails";
 })(PermitAppInfo || (exports.PermitAppInfo = PermitAppInfo = {}));

package/dist/enum/policy-check.d.ts

@@ -0,0 +1,11 @@
+export declare enum PolicyCheckResultType {
+    Pass = "pass",
+    Fail = "fail"
+}
+export declare enum PolicyCheckId {
+    BridgeFormula = "bridge-formula",
+    CheckPermittableWeight = "check-permittable-weight",
+    MinDriveAxleWeight = "minimum-drive-axle-weight",
+    MinSteerAxleWeight = "minimum-steer-axle-weight",
+    NumberOfWheelsPerAxle = "number-of-wheels"
+}

package/dist/enum/policy-check.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolicyCheckId = exports.PolicyCheckResultType = void 0;
+var PolicyCheckResultType;
+(function (PolicyCheckResultType) {
+    PolicyCheckResultType["Pass"] = "pass";
+    PolicyCheckResultType["Fail"] = "fail";
+})(PolicyCheckResultType || (exports.PolicyCheckResultType = PolicyCheckResultType = {}));
+var PolicyCheckId;
+(function (PolicyCheckId) {
+    PolicyCheckId["BridgeFormula"] = "bridge-formula";
+    PolicyCheckId["CheckPermittableWeight"] = "check-permittable-weight";
+    PolicyCheckId["MinDriveAxleWeight"] = "minimum-drive-axle-weight";
+    PolicyCheckId["MinSteerAxleWeight"] = "minimum-steer-axle-weight";
+    PolicyCheckId["NumberOfWheelsPerAxle"] = "number-of-wheels";
+})(PolicyCheckId || (exports.PolicyCheckId = PolicyCheckId = {}));

package/dist/enum/validation-result-code.d.ts

@@ -1,6 +1,7 @@
 export declare enum ValidationResultCode {
     PermitTypeUnknown = "permit-type-unknown",
     FieldValidationError = "field-validation-error",
+    PolicyValidationError = "policy-validation-error",
     ConfigurationInvalid = "configuration-invalid",
     GeneralResult = "general-result",
     CostValue = "cost-value",

package/dist/enum/validation-result-code.js

@@ -5,6 +5,7 @@ var ValidationResultCode;
 (function (ValidationResultCode) {
     ValidationResultCode["PermitTypeUnknown"] = "permit-type-unknown";
     ValidationResultCode["FieldValidationError"] = "field-validation-error";
+    ValidationResultCode["PolicyValidationError"] = "policy-validation-error";
     ValidationResultCode["ConfigurationInvalid"] = "configuration-invalid";
     ValidationResultCode["GeneralResult"] = "general-result";
     ValidationResultCode["CostValue"] = "cost-value";

package/dist/helper/dimensions.helper.js

@@ -308,12 +308,16 @@ function selectCorrectWeightDimensionHelper(policy, weightDimensions, configurat
     if (!axleConfiguration || axleConfiguration.length === 0) {
         throw new Error('Missing axle configuration');
     }
-    if (axleIndex > configuration.length) {
+    if (axleIndex >= axleConfiguration.length) {
         throw new Error('Invalid axle index value');
     }
-    if (configuration.length !== axleConfiguration.length - 1) {
+    const realVehicleConfig = configuration.filter((v) => {
+        const vehicleDef = policy.getVehicleDefinition(v);
+        return !(vehicleDef === null || vehicleDef === void 0 ? void 0 : vehicleDef.ignoreForAxleCalculation);
+    });
+    if (realVehicleConfig.length !== axleConfiguration.length - 1) {
         // We expect the axle configuration array length to be one more
-        // than the configuration length because the power unit has two
+        // than the real configuration length because the power unit has two
         // axle units.
         throw new Error('Wrong number of axles configured for vehicle configuration');
     }

package/dist/helper/facts.helper.js

@@ -7,6 +7,7 @@ exports.addRuntimeFacts = addRuntimeFacts;
 const dayjs_1 = __importDefault(require("dayjs"));
 const quarterOfYear_1 = __importDefault(require("dayjs/plugin/quarterOfYear"));
 const enum_1 = require("onroute-policy-engine/enum");
+const policy_check_helper_1 = require("./policy-check.helper");
 dayjs_1.default.extend(quarterOfYear_1.default);
 /**
  * Adds runtime facts for the validation. For example, adds the
@@ -83,6 +84,69 @@ function addRuntimeFacts(engine, policy) {
         }
         return allowedVehicles;
     });
+    /**
+     * Add runtime fact to calculate the complete vehicle configuration
+     * by combining the power unit type with any attached trailers.
+     * Returns an array of vehicle types representing the full configuration.
+     */
+    engine.addFact(enum_1.PolicyFacts.VehicleConfiguration.toString(), async function (params, almanac) {
+        // Retrieve the vehicle details from permit data
+        const vehicleDetails = await almanac.factValue(enum_1.PermitAppInfo.PermitData, {}, enum_1.PermitAppInfo.VehicleDetails);
+        // Retrieve the vehicle configuration from permit data
+        const vehicleConfiguration = await almanac.factValue(enum_1.PermitAppInfo.PermitData, {}, enum_1.PermitAppInfo.VehicleConfiguration);
+        return policy.getSimplifiedVehicleConfiguration(vehicleDetails, vehicleConfiguration);
+    });
+    /**
+     * Add runtime fact to calculate the gross vehicle combination
+     * weight by summing the weights of the individual axle units.
+     */
+    engine.addFact(enum_1.PolicyFacts.GrossVehicleCombinationWeight, async function (params, almanac) {
+        // Retrieve the axle configuration from permit data
+        const axleConfiguration = await almanac.factValue(enum_1.PermitAppInfo.PermitData, {}, enum_1.PermitAppInfo.AxleConfiguration);
+        return axleConfiguration.reduce((w, curr) => w + curr.axleUnitWeight, 0);
+    });
+    /**
+     * Add runtime fact to evaluate whether a specific policy check passes
+     * based on the vehicle configuration and axle configuration.
+     * Returns true if all policy check results are 'pass', false otherwise.
+     */
+    engine.addFact(enum_1.PolicyFacts.PolicyCheckPassed.toString(), async function (params, almanac) {
+        // Retrieve the complete vehicle configuration (power unit + trailers)
+        const vehicleConfiguration = await almanac.factValue(enum_1.PolicyFacts.VehicleConfiguration);
+        // Retrieve the axle configuration from permit data
+        const axleConfiguration = await almanac.factValue(enum_1.PermitAppInfo.PermitData, {}, enum_1.PermitAppInfo.AxleConfiguration);
+        // Get the specific policy check ID from parameters
+        const policyCheckId = params.policyId;
+        // Look up the policy check function from the policy check map
+        const func = policy_check_helper_1.policyCheckMap.get(policyCheckId);
+        if (!func) {
+            return false;
+        }
+        // Execute the policy check function with vehicle and axle configurations
+        const policyCheckResults = func(policy, vehicleConfiguration, axleConfiguration);
+        if (!policyCheckResults || policyCheckResults.length === 0) {
+            // We did not get any policy check results returned which is an error
+            // condition - all policy checks must return at least one result
+            return false;
+        }
+        // Return true only if all policy check results are 'pass'
+        return policyCheckResults.every((r) => r.result === enum_1.PolicyCheckResultType.Pass);
+    });
+    /**
+     * Add runtime fact to return an array of all messages that result from
+     * all combined policy checks for axle calculation. This is used in
+     * permit validation, returned in the details param for that rule for
+     * overweight permit types.
+     */
+    engine.addFact(enum_1.PolicyFacts.AxleCalcViolations, async function (params, almanac) {
+        // Retrieve the complete vehicle configuration (power unit + trailers)
+        const vehicleConfiguration = await almanac.factValue(enum_1.PolicyFacts.VehicleConfiguration);
+        // Retrieve the axle configuration from permit data
+        const axleConfiguration = await almanac.factValue(enum_1.PermitAppInfo.PermitData, {}, enum_1.PermitAppInfo.AxleConfiguration);
+        const results = policy.runAxleCalculation(vehicleConfiguration, axleConfiguration);
+        const violations = results.results.filter((r) => r.result === enum_1.PolicyCheckResultType.Fail);
+        return violations.map((v) => v.message);
+    });
     /**
      * Add runtime fact to calculate the number of days between a from
      * and to date supplied in parameters. Will be positive for a dateTo

package/dist/helper/policy-check.helper.d.ts

@@ -0,0 +1,183 @@
+import { PolicyCheckResult, AxleConfiguration } from 'onroute-policy-engine/types';
+import { Policy } from 'onroute-policy-engine';
+/**
+ * Type definition for policy check functions.
+ *
+ * Each policy check function takes a policy instance, vehicle configuration,
+ * and axle configuration, then returns an array of policy check results.
+ * These functions are used by the runAxleCalculation method to perform
+ * various validation checks on vehicle configurations.
+ *
+ * @param policy - The policy instance containing configuration and validation rules
+ * @param vehicleConfiguration - Array of vehicle type identifiers representing the vehicle configuration
+ * @param axleConfiguration - Array of axle configurations corresponding to each vehicle
+ * @returns Array of PolicyCheckResult objects representing the outcomes of the policy check
+ */
+type PolicyCheck = (policy: Policy, vehicleConfiguration: Array<string>, axleConfiguration: Array<AxleConfiguration>) => Array<PolicyCheckResult>;
+/**
+ * Performs bridge formula calculations on axle groups and returns policy check results.
+ *
+ * This function calculates the bridge formula for each axle group in the vehicle configuration
+ * and determines whether each group passes or fails the bridge formula requirements. The bridge
+ * formula is a provincial regulation that limits the weight that can be carried on a group of axles
+ * based on the distance between the first and last axles in the group.
+ *
+ * @param policy - The policy instance containing bridge calculation configuration
+ * @param _vehicleConfiguration - Vehicle configuration (unused in this check, but required by PolicyCheck type)
+ * @param axleConfiguration - Array of axle configurations containing spacing and weight information
+ * @returns Array of AxleGroupPolicyCheckResult objects, one for each axle group tested
+ *
+ * @example
+ * // For a vehicle with 3 axle groups
+ * const results = CheckBridgeFormula(policy, ['TRKTRAC', 'SEMITRL'], [
+ *   { numberOfAxles: 2, axleSpread: 1.8, weight: 12000 },
+ *   { numberOfAxles: 3, axleSpread: 4.2, weight: 34000 },
+ *   { numberOfAxles: 3, axleSpread: 3.0, weight: 34000 }
+ * ]);
+ * // Returns results for each axle group (e.g., axles 1-2, 1-3, 2-3)
+ *
+ * @see PolicyCheck
+ * @see AxleGroupPolicyCheckResult
+ * @see BridgeCalculationResult
+ */
+export declare function CheckBridgeFormula(policy: Policy, _vehicleConfiguration: Array<string>, axleConfiguration: Array<AxleConfiguration>): Array<PolicyCheckResult>;
+/**
+ * Validates the number of tires per axle unit against regulatory requirements.
+ *
+ * This function checks that each axle unit has a valid number of tires based on
+ * the number of axles in that unit. The validation allows for 2, 4, or 8 tires
+ * per axle (2, 4, or 8 * number of axles). This ensures compliance with tire
+ * count regulations for commercial vehicles.
+ *
+ * @param _policy - The policy instance (unused in this check, but required by PolicyCheck type)
+ * @param _vehicleConfiguration - Vehicle configuration (unused in this check, but required by PolicyCheck type)
+ * @param axleConfiguration - Array of axle configurations containing tire count and axle count information
+ * @returns Array of AxleUnitPolicyCheckResult objects, one for each axle unit tested
+ *
+ * @example
+ * // For a vehicle with 2 axle units
+ * const results = CheckNumTiresPerAxle(policy, ['TRKTRAC'], [
+ *   { numberOfAxles: 2, numberOfTires: 4 },  // 2 axles × 2 tires = 4 (valid)
+ *   { numberOfAxles: 3, numberOfTires: 12 }  // 3 axles × 4 tires = 12 (valid)
+ * ]);
+ * // Returns pass results for both axle units
+ *
+ * @example
+ * // Invalid tire count example
+ * const results = CheckNumTiresPerAxle(policy, ['TRKTRAC'], [
+ *   { numberOfAxles: 2, numberOfTires: 6 }  // 2 axles × 3 tires = 6 (invalid - not 2, 4, or 8 per axle)
+ * ]);
+ * // Returns fail result for the axle unit
+ *
+ * @see PolicyCheck
+ * @see AxleUnitPolicyCheckResult
+ * @see AxleConfiguration
+ */
+export declare function CheckNumTiresPerAxle(_policy: Policy, _vehicleConfiguration: Array<string>, axleConfiguration: Array<AxleConfiguration>): Array<PolicyCheckResult>;
+/**
+ * Validates that each axle unit's weight does not exceed the permittable weight limits.
+ *
+ * This function performs weight validation for each axle unit in a vehicle configuration.
+ * It retrieves the default weight dimensions for power units and trailers based on their
+ * vehicle types and axle counts, then compares the actual axle unit weights against the
+ * permittable weight limits. The function handles both power units (with steer and drive
+ * axles) and trailers, ensuring compliance with weight regulations.
+ *
+ * @param policy - The policy instance containing weight dimension configurations and validation rules
+ * @param vehicleConfiguration - Array of vehicle type identifiers representing the vehicle configuration.
+ *                              The first element should be a power unit type, followed by trailer types.
+ * @param axleConfiguration - Array of axle configurations containing weight and axle count information.
+ *                           For power units, this includes both steer and drive axle configurations.
+ * @returns Array of AxleUnitPolicyCheckResult objects, one for each axle unit tested.
+ *          Each result indicates whether the axle unit's weight is within permittable limits.
+ *
+ * @example
+ * // For a truck-tractor with 2-axle steer, 3-axle drive, and a 3-axle semi-trailer
+ * const results = CheckPermittableWeight(policy, ['TRKTRAC', 'SEMITRL'], [
+ *   { numberOfAxles: 2, axleUnitWeight: 12000 },  // Steer axle unit
+ *   { numberOfAxles: 3, axleUnitWeight: 34000 },  // Drive axle unit
+ *   { numberOfAxles: 3, axleUnitWeight: 34000 }   // Trailer axle unit
+ * ]);
+ * // Returns results for each axle unit indicating pass/fail status
+ *
+ * @example
+ * // For a single power unit with no trailers
+ * const results = CheckPermittableWeight(policy, ['TRKTRAC'], [
+ *   { numberOfAxles: 2, axleUnitWeight: 12000 },  // Steer axle unit
+ *   { numberOfAxles: 3, axleUnitWeight: 34000 }   // Drive axle unit
+ * ]);
+ * // Returns results for steer and drive axle units only
+ *
+ * @see PolicyCheck
+ * @see AxleUnitPolicyCheckResult
+ * @see WeightDimension
+ * @see SingleAxleDimension
+ */
+export declare function CheckPermittableWeight(policy: Policy, vehicleConfiguration: Array<string>, axleConfiguration: Array<AxleConfiguration>): Array<PolicyCheckResult>;
+/**
+ * Validates minimum steer axle weight requirements for single steer, tridem drive power units.
+ *
+ * This function checks that the steer axle meets minimum weight requirements when the vehicle
+ * configuration consists of a single steer axle followed by a tridem drive axle. The steer axle
+ * must carry at least 27% of the tridem drive axle weight.
+ *
+ * @param _policy - The policy instance (unused in this check, but required by PolicyCheck type)
+ * @param _vehicleConfiguration - Vehicle configuration (unused in this check, but required by PolicyCheck type)
+ * @param axleConfiguration - Array of axle configurations containing weight and axle count information
+ * @returns Array of AxleGroupPolicyCheckResult objects with validation results
+ *
+ * @example
+ * // For a single steer, tridem drive configuration
+ * const results = CheckMinSteerAxleWeight(policy, ['TRKTRAC'], [
+ *   { numberOfAxles: 1, axleUnitWeight: 8000 },  // Steer axle
+ *   { numberOfAxles: 3, axleUnitWeight: 30000 }  // Tridem drive axle
+ * ]);
+ * // Returns pass if steer axle weight >= 27% of drive axle weight (8100 kgs)
+ *
+ * @see PolicyCheck
+ * @see AxleGroupPolicyCheckResult
+ */
+export declare function CheckMinSteerAxleWeight(_policy: Policy, _vehicleConfiguration: Array<string>, axleConfiguration: Array<AxleConfiguration>): Array<PolicyCheckResult>;
+/**
+ * Validates minimum drive axle weight requirements for tandem and tridem drive power units.
+ *
+ * This function checks that the drive axle meets minimum weight requirements based on the
+ * Gross Vehicle Combination Weight (GVCW). For tandem drive axles, the minimum is 20% of GVCW
+ * or 23,000 lbs (whichever is smaller). For tridem drive axles, the minimum is 20% of GVCW
+ * or 28,000 lbs (whichever is smaller).
+ *
+ * @param _policy - The policy instance (unused in this check, but required by PolicyCheck type)
+ * @param _vehicleConfiguration - Vehicle configuration (unused in this check, but required by PolicyCheck type)
+ * @param axleConfiguration - Array of axle configurations containing weight and axle count information
+ * @returns Array of AxleGroupPolicyCheckResult objects with validation results
+ *
+ * @example
+ * // For a tandem drive configuration with GVCW of 120,000 kgs
+ * const results = CheckMinDriveAxleWeight(policy, ['TRKTRAC'], [
+ *   { numberOfAxles: 1, axleUnitWeight: 12000 },  // Steer axle
+ *   { numberOfAxles: 2, axleUnitWeight: 24000 }   // Tandem drive axle
+ * ]);
+ * // Returns pass if drive axle weight >= min(20% of GVCW, 23,000 kgs)
+ *
+ * @see PolicyCheck
+ * @see AxleGroupPolicyCheckResult
+ */
+export declare function CheckMinDriveAxleWeight(_policy: Policy, _vehicleConfiguration: Array<string>, axleConfiguration: Array<AxleConfiguration>): Array<PolicyCheckResult>;
+/**
+ * Map of policy check functions keyed by their corresponding PolicyCheckId.
+ *
+ * This map contains all the registered policy check functions that are executed
+ * by the runAxleCalculation method. Each entry maps a PolicyCheckId to its
+ * corresponding validation function. New policy checks can be added by extending
+ * this map with additional entries.
+ *
+ * Currently includes:
+ * - BridgeFormula: Validates axle groups against bridge formula requirements
+ * - NumberOfWheelsPerAxle: Validates tire count per axle unit
+ *
+ * @see PolicyCheck
+ * @see PolicyCheckId
+ * @see runAxleCalculation
+ */
+export declare const policyCheckMap: Map<string, PolicyCheck>;
+export {};