onroute-policy-engine 2.1.0 → 2.2.0

package/dist/policy-engine.d.ts

@@ -1,4 +1,4 @@
-import { PolicyDefinition, PermitType, Commodity, VehicleType, SizeDimension, AxleConfiguration, BridgeCalculationResult, ConditionForPermit, TrailerType, PowerUnitType, TrailerWeightDimension, PowerUnitWeightDimension, WeightDimension, SingleAxleDimension, StandardTireSize, TrailerDimensions } from 'onroute-policy-engine/types';
+import { PolicyDefinition, PermitType, Commodity, VehicleType, SizeDimension, AxleConfiguration, BridgeCalculationResult, ConditionForPermit, TrailerType, PowerUnitType, TrailerWeightDimension, PowerUnitWeightDimension, WeightDimension, SingleAxleDimension, StandardTireSize, TrailerDimensions, AxleCalcResults, PermitVehicleDetails, VehicleConfiguration } from 'onroute-policy-engine/types';
 import { Engine } from 'json-rules-engine';
 import { ValidationResults } from './validation-results';
 import { SpecialAuthorizations } from './types/special-authorizations';
@@ -186,6 +186,42 @@ export declare class Policy {
      * axle group in the vehicle configuration
      */
     calculateBridge(axleConfig: Array<AxleConfiguration>): Array<BridgeCalculationResult>;
+    /**
+     * Runs all configured axle calculation policy checks against a vehicle configuration.
+     *
+     * This method iterates through all registered policy check functions (such as bridge formula
+     * calculations and tire count validations) and applies them to the provided vehicle and axle
+     * configurations. The results are aggregated into a single AxleCalcResults object containing
+     * all policy check outcomes and a total overload calculation.
+     *
+     * @param vehicleConfiguration Array of vehicle type identifiers representing the vehicle configuration.
+     *                            The first element should be a power unit type, followed by trailer types.
+     *                            Example: ['TRKTRAC', 'SEMITRL'] for a truck tractor with semi-trailer.
+     * @param axleConfiguration Array of axle configurations corresponding to each vehicle in the configuration.
+     *                          Each axle configuration contains details like number of axles, spacing, tire count, etc.
+     *                          The length should match the vehicleConfiguration array plus one (since the first
+     *                          vehicle in the configuration is a power unit with two axle units).
+     * @returns AxleCalcResults object containing:
+     *          - results: Array of PolicyCheckResult objects, each representing the outcome of a specific policy check
+     *          - totalOverload: Numeric value representing the total overload across all axle calculations
+     *
+     * @example
+     * // For a truck-tractor with 2-axle steer, 3-axle drive, and a 3-axle semi-trailer
+     * const results = policy.runAxleCalculation(
+     *   ['TRKTRAC', 'SEMITRL'],
+     *   [
+     *     { numberOfAxles: 2, axleSpread: 1.8, numberOfTires: 4 },
+     *     { numberOfAxles: 3, axleSpread: 4.2, numberOfTires: 12 },
+     *     { numberOfAxles: 3, axleSpread: 3.0, numberOfTires: 12 }
+     *   ]
+     * );
+     * // Returns results with bridge formula checks, tire count validations, etc.
+     *
+     * @see AxleCalcResults
+     * @see PolicyCheckResult
+     * @see AxleConfiguration
+     */
+    runAxleCalculation(vehicleConfiguration: Array<string>, axleConfiguration: Array<AxleConfiguration>): AxleCalcResults;
     /**
      * Gets the list of allowed vehicles separated into two maps, one
      * for trailers and one for power units. This will filter out LCV
@@ -245,5 +281,63 @@ export declare class Policy {
      * none are configured
      */
     getStandardTireSizes(): Array<StandardTireSize>;
+    /**
+     * Generates a vehicle display code based on the vehicle configuration and axle configuration.
+     *
+     * The display code is a string representation that describes the vehicle configuration
+     * in a standardized format. It can generate either a standard display code (for known
+     * vehicle types with configured display codes) or a universal display code (for complex
+     * or unknown configurations).
+     *
+     * @param configuration 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 corresponding to each vehicle in the configuration.
+     *                          Each axle configuration contains details like number of axles, spacing, etc.
+     * @returns A string representing the vehicle display code, or an empty string if the configuration is empty.
+     *
+     * @example
+     * // For a truck-tractor with 2-axle steer, 3-axle drive, and a 3-axle semi-trailer
+     * const code = policy.getVehicleDisplayCode(['TRKTRAC'], [
+     *   { numberOfAxles: 2, axleSpread: 1.8, ... },
+     *   { numberOfAxles: 3, axleSpread: 4.2, ... },
+     *   { numberOfAxles: 3, axleSpread: 3.0, ... }
+     * ]);
+     * // Returns something like "TT2S13D23T3"
+     *
+     * @throws {Error} If vehicleDisplayCodeDefaults is not configured in the policy definition.
+     */
     getVehicleDisplayCode(configuration: Array<string>, axleConfiguration: Array<AxleConfiguration>): string;
+    /**
+     * Converts detailed vehicle information into a simplified vehicle configuration array.
+     *
+     * This method takes the vehicle details (which contain the power unit information) and
+     * the vehicle configuration (which contains trailer information) and combines them into
+     * a single array of vehicle type identifiers. The resulting array represents the complete
+     * vehicle configuration in the order: [powerUnit, trailer1, trailer2, ...].
+     *
+     * @param vehicleDetails - The vehicle details containing power unit information including
+     *                        the vehicle subtype (e.g., 'TRKTRAC' for truck-tractor)
+     * @param vehicleConfiguration - The vehicle configuration containing trailer information
+     *                              and other vehicle configuration details
+     * @returns An array of vehicle type identifiers representing the complete vehicle configuration.
+     *          The first element is always the power unit type, followed by any attached trailer types.
+     *          Returns an empty array if no power unit type is found in vehicle details.
+     *
+     * @example
+     * // For a truck-tractor with a semi-trailer
+     * const config = policy.getSimplifiedVehicleConfiguration(
+     *   { vehicleSubType: 'TRKTRAC', ... },
+     *   { trailers: [{ vehicleSubType: 'SEMITRL' }] }
+     * );
+     * // Returns: ['TRKTRAC', 'SEMITRL']
+     *
+     * @example
+     * // For a single power unit with no trailers
+     * const config = policy.getSimplifiedVehicleConfiguration(
+     *   { vehicleSubType: 'TRKTRAC', ... },
+     *   { trailers: [] }
+     * );
+     * // Returns: ['TRKTRAC']
+     */
+    getSimplifiedVehicleConfiguration(vehicleDetails: PermitVehicleDetails, vehicleConfiguration: VehicleConfiguration): string[];
 }

package/dist/policy-engine.js

@@ -20,6 +20,7 @@ const conditions_helper_1 = require("./helper/conditions.helper");
 const dimensions_helper_1 = require("./helper/dimensions.helper");
 const dimensions_helper_2 = require("./helper/dimensions.helper");
 const display_code_helper_1 = require("./helper/display-code-helper");
+const policy_check_helper_1 = require("./helper/policy-check.helper");
 /** Class representing commercial vehicle policy. */
 class Policy {
     /**
@@ -657,6 +658,48 @@ class Policy {
         }
         return bridgeResults;
     }
+    /**
+     * Runs all configured axle calculation policy checks against a vehicle configuration.
+     *
+     * This method iterates through all registered policy check functions (such as bridge formula
+     * calculations and tire count validations) and applies them to the provided vehicle and axle
+     * configurations. The results are aggregated into a single AxleCalcResults object containing
+     * all policy check outcomes and a total overload calculation.
+     *
+     * @param vehicleConfiguration Array of vehicle type identifiers representing the vehicle configuration.
+     *                            The first element should be a power unit type, followed by trailer types.
+     *                            Example: ['TRKTRAC', 'SEMITRL'] for a truck tractor with semi-trailer.
+     * @param axleConfiguration Array of axle configurations corresponding to each vehicle in the configuration.
+     *                          Each axle configuration contains details like number of axles, spacing, tire count, etc.
+     *                          The length should match the vehicleConfiguration array plus one (since the first
+     *                          vehicle in the configuration is a power unit with two axle units).
+     * @returns AxleCalcResults object containing:
+     *          - results: Array of PolicyCheckResult objects, each representing the outcome of a specific policy check
+     *          - totalOverload: Numeric value representing the total overload across all axle calculations
+     *
+     * @example
+     * // For a truck-tractor with 2-axle steer, 3-axle drive, and a 3-axle semi-trailer
+     * const results = policy.runAxleCalculation(
+     *   ['TRKTRAC', 'SEMITRL'],
+     *   [
+     *     { numberOfAxles: 2, axleSpread: 1.8, numberOfTires: 4 },
+     *     { numberOfAxles: 3, axleSpread: 4.2, numberOfTires: 12 },
+     *     { numberOfAxles: 3, axleSpread: 3.0, numberOfTires: 12 }
+     *   ]
+     * );
+     * // Returns results with bridge formula checks, tire count validations, etc.
+     *
+     * @see AxleCalcResults
+     * @see PolicyCheckResult
+     * @see AxleConfiguration
+     */
+    runAxleCalculation(vehicleConfiguration, axleConfiguration) {
+        const axleCalcResults = { results: [], totalOverload: 0 };
+        for (const [, func] of policy_check_helper_1.policyCheckMap) {
+            axleCalcResults.results.push(...func(this, vehicleConfiguration, axleConfiguration));
+        }
+        return axleCalcResults;
+    }
     /**
      * Gets the list of allowed vehicles separated into two maps, one
      * for trailers and one for power units. This will filter out LCV
@@ -749,8 +792,68 @@ class Policy {
             return new Array();
         }
     }
+    /**
+     * Generates a vehicle display code based on the vehicle configuration and axle configuration.
+     *
+     * The display code is a string representation that describes the vehicle configuration
+     * in a standardized format. It can generate either a standard display code (for known
+     * vehicle types with configured display codes) or a universal display code (for complex
+     * or unknown configurations).
+     *
+     * @param configuration 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 corresponding to each vehicle in the configuration.
+     *                          Each axle configuration contains details like number of axles, spacing, etc.
+     * @returns A string representing the vehicle display code, or an empty string if the configuration is empty.
+     *
+     * @example
+     * // For a truck-tractor with 2-axle steer, 3-axle drive, and a 3-axle semi-trailer
+     * const code = policy.getVehicleDisplayCode(['TRKTRAC'], [
+     *   { numberOfAxles: 2, axleSpread: 1.8, ... },
+     *   { numberOfAxles: 3, axleSpread: 4.2, ... },
+     *   { numberOfAxles: 3, axleSpread: 3.0, ... }
+     * ]);
+     * // Returns something like "TT2S13D23T3"
+     *
+     * @throws {Error} If vehicleDisplayCodeDefaults is not configured in the policy definition.
+     */
     getVehicleDisplayCode(configuration, axleConfiguration) {
         return (0, display_code_helper_1.getVehicleDisplayCodeHelper)(this, configuration, axleConfiguration);
     }
+    /**
+     * Converts detailed vehicle information into a simplified vehicle configuration array.
+     *
+     * This method takes the vehicle details (which contain the power unit information) and
+     * the vehicle configuration (which contains trailer information) and combines them into
+     * a single array of vehicle type identifiers. The resulting array represents the complete
+     * vehicle configuration in the order: [powerUnit, trailer1, trailer2, ...].
+     *
+     * @param vehicleDetails - The vehicle details containing power unit information including
+     *                        the vehicle subtype (e.g., 'TRKTRAC' for truck-tractor)
+     * @param vehicleConfiguration - The vehicle configuration containing trailer information
+     *                              and other vehicle configuration details
+     * @returns An array of vehicle type identifiers representing the complete vehicle configuration.
+     *          The first element is always the power unit type, followed by any attached trailer types.
+     *          Returns an empty array if no power unit type is found in vehicle details.
+     *
+     * @example
+     * // For a truck-tractor with a semi-trailer
+     * const config = policy.getSimplifiedVehicleConfiguration(
+     *   { vehicleSubType: 'TRKTRAC', ... },
+     *   { trailers: [{ vehicleSubType: 'SEMITRL' }] }
+     * );
+     * // Returns: ['TRKTRAC', 'SEMITRL']
+     *
+     * @example
+     * // For a single power unit with no trailers
+     * const config = policy.getSimplifiedVehicleConfiguration(
+     *   { vehicleSubType: 'TRKTRAC', ... },
+     *   { trailers: [] }
+     * );
+     * // Returns: ['TRKTRAC']
+     */
+    getSimplifiedVehicleConfiguration(vehicleDetails, vehicleConfiguration) {
+        return (0, vehicles_helper_1.getSimplifiedVehicleConfigurationHelper)(vehicleDetails, vehicleConfiguration);
+    }
 }
 exports.Policy = Policy;

package/dist/rule-operator/custom-operators.d.ts

@@ -1,3 +1,10 @@
+/**
+ * Custom Operators for JSON Rules Engine
+ *
+ * This module defines custom operators that extend the functionality of the json-rules-engine
+ * library. These operators provide specialized validation and comparison logic for the
+ * onRouteBC policy engine.
+ */
 import { Operator } from 'json-rules-engine';
 declare const CustomOperators: Array<Operator>;
 export { CustomOperators };

package/dist/rule-operator/custom-operators.js

@@ -1,4 +1,11 @@
 "use strict";
+/**
+ * Custom Operators for JSON Rules Engine
+ *
+ * This module defines custom operators that extend the functionality of the json-rules-engine
+ * library. These operators provide specialized validation and comparison logic for the
+ * onRouteBC policy engine.
+ */
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -7,23 +14,70 @@ exports.CustomOperators = void 0;
 const json_rules_engine_1 = require("json-rules-engine");
 const enum_1 = require("onroute-policy-engine/enum");
 const dayjs_1 = __importDefault(require("dayjs"));
+/**
+ * Validates that the input is a string type
+ * @param a - The value to validate
+ * @returns True if the value is a string, false otherwise
+ */
 function stringValidator(a) {
     return typeof a === 'string';
 }
+/**
+ * Validates that the input is a valid date string in the permit application format
+ * @param a - The date string to validate
+ * @returns True if the date string is valid, false otherwise
+ */
 function dateStringValidator(a) {
     const d = (0, dayjs_1.default)(a, enum_1.PermitAppInfo.PermitDateFormat.toString());
     return d.isValid();
 }
+/**
+ * Validates that the input is an array
+ * @param a - The value to validate
+ * @returns True if the value is an array, false otherwise
+ */
+function arrayValidator(a) {
+    return Array.isArray(a);
+}
+// Array to store all custom operators
 const CustomOperators = [];
 exports.CustomOperators = CustomOperators;
-CustomOperators.push(new json_rules_engine_1.Operator('stringMinimumLength', (a, b) => {
+/**
+ * String Minimum Length Operator
+ *
+ * Checks if a string has a minimum length after trimming whitespace.
+ * Returns false if the input is falsy (null, undefined, empty string).
+ */
+CustomOperators.push(new json_rules_engine_1.Operator(enum_1.CustomOperator.StringMinimumLength, (a, b) => {
+    // Return false for falsy values
     if (!a)
         return false;
+    // Check if trimmed string length meets minimum requirement
     return a.trim().length >= b;
 }, stringValidator));
-CustomOperators.push(new json_rules_engine_1.Operator('dateLessThan', (a, b) => {
+/**
+ * Date Less Than Operator
+ *
+ * Compares two date strings in permit application format.
+ * Returns true if the first date is before the second date.
+ */
+CustomOperators.push(new json_rules_engine_1.Operator(enum_1.CustomOperator.DateLessThan, (a, b) => {
+    // Parse both dates using the permit application date format
     const firstDate = (0, dayjs_1.default)(a, enum_1.PermitAppInfo.PermitDateFormat.toString());
     const secondDate = (0, dayjs_1.default)(b, enum_1.PermitAppInfo.PermitDateFormat.toString());
+    // Return true if first date is before second date (difference is negative)
     return firstDate.diff(secondDate) < 0;
 }, dateStringValidator));
-CustomOperators.push(new json_rules_engine_1.Operator('regex', (a, b) => RegExp(b).exec(a) !== null, stringValidator));
+/**
+ * Regular Expression Operator
+ *
+ * Tests if a string matches a regular expression pattern.
+ * Uses RegExp.exec() to check for matches.
+ */
+CustomOperators.push(new json_rules_engine_1.Operator(enum_1.CustomOperator.Regex, (a, b) => RegExp(b).exec(a) !== null, stringValidator));
+/**
+ * Is Empty Array Operator
+ *
+ * Checks if an array is empty (has length 0).
+ */
+CustomOperators.push(new json_rules_engine_1.Operator(enum_1.CustomOperator.IsEmptyArray, (arr) => arr.length === 0, arrayValidator));

package/dist/types/axle-calculation-results.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Axle Calculation Results Types
+ *
+ * These types define the structure for axle calculation results and policy check outcomes.
+ * Used for validating vehicle configurations against weight and axle requirements.
+ */
+import { PolicyCheckResultType } from 'onroute-policy-engine/enum';
+/**
+ * Complete results from axle calculations including all policy checks and total overload
+ */
+export type AxleCalcResults = {
+    /** Array of individual policy check results */
+    results: Array<PolicyCheckResult>;
+    /** Total weight overload across all axles in kilograms */
+    totalOverload: number;
+};
+/**
+ * Individual policy check result for a specific validation rule
+ */
+export type PolicyCheckResult = {
+    /** Actual weight measured/calculated in kilograms */
+    actualWeight?: number;
+    /** Maximum allowed weight threshold in kilograms */
+    thresholdWeight?: number;
+    /** Unique identifier for the policy check */
+    id: string;
+    /** Result of the policy check (pass/fail) */
+    result: PolicyCheckResultType;
+    /** Human-readable message describing the check result */
+    message: string;
+};
+/**
+ * Policy check result for a single axle unit
+ * Extends PolicyCheckResult with axle unit identification
+ */
+export type AxleUnitPolicyCheckResult = PolicyCheckResult & {
+    /** The axle unit number being checked */
+    axleUnit: number;
+};
+/**
+ * Policy check result for a group of axles
+ * Extends PolicyCheckResult with axle group range
+ */
+export type AxleGroupPolicyCheckResult = PolicyCheckResult & {
+    /** Starting axle unit number in the group */
+    startAxleUnit: number;
+    /** Ending axle unit number in the group */
+    endAxleUnit: number;
+};

package/dist/types/axle-calculation-results.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Axle Calculation Results Types
+ *
+ * These types define the structure for axle calculation results and policy check outcomes.
+ * Used for validating vehicle configurations against weight and axle requirements.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/axle-configuration.d.ts

@@ -1,8 +1,20 @@
+/**
+ * Axle Configuration Type
+ *
+ * Defines the structure for individual axle configurations within a vehicle.
+ * Used for weight calculations, spacing requirements, and compliance validation.
+ */
 export type AxleConfiguration = {
+    /** Number of axles in this configuration (1 for single, 2+ for groups) */
     numberOfAxles: number;
+    /** Total spread between first and last axle in centimeters */
     axleSpread?: number;
+    /** Spacing from the previous axle unit in centimeters */
     interaxleSpacing?: number;
+    /** Weight carried by this axle unit in kilograms */
     axleUnitWeight: number;
+    /** Number of tires on this axle unit */
     numberOfTires?: number;
+    /** Tire size in inches */
     tireSize?: number;
 };

package/dist/types/axle-configuration.js

@@ -1,2 +1,8 @@
 "use strict";
+/**
+ * Axle Configuration Type
+ *
+ * Defines the structure for individual axle configurations within a vehicle.
+ * Used for weight calculations, spacing requirements, and compliance validation.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/bridge-calculation-constants.d.ts

@@ -1,4 +1,12 @@
+/**
+ * Bridge Calculation Constants Type
+ *
+ * Defines constants used in bridge formula calculations for determining
+ * maximum allowable weights based on axle spacing and configuration.
+ */
 export type BridgeCalculationConstants = {
+    /** Multiplier factor for bridge formula calculations */
     multiplier: number;
+    /** Minimum weight threshold in kilograms */
     minWeight: number;
 };

package/dist/types/bridge-calculation-result.d.ts

@@ -1,7 +1,18 @@
+/**
+ * Bridge Calculation Result Type
+ *
+ * Defines the result structure for bridge formula calculations.
+ * Used to determine if a vehicle configuration meets bridge weight requirements.
+ */
 export type BridgeCalculationResult = {
+    /** Starting axle unit number in the calculation */
     startAxleUnit: number;
+    /** Ending axle unit number in the calculation */
     endAxleUnit: number;
+    /** Maximum allowable weight according to bridge formula in kilograms */
     maxBridge: number;
+    /** Actual weight being carried in kilograms */
     actualWeight: number;
+    /** Whether the configuration passes bridge formula requirements */
     success: boolean;
 };

package/dist/types/commodity.d.ts

@@ -1,4 +1,14 @@
+/**
+ * Commodity Type
+ *
+ * Defines the structure for permitted commodities that can be transported.
+ * Extends IdentifiedObject with vehicle dimension requirements.
+ */
 import { IdentifiedObject, VehicleDimensions } from 'onroute-policy-engine/types';
+/**
+ * A permitted commodity that can be transported with specific vehicle requirements
+ */
 export type Commodity = IdentifiedObject & {
+    /** Array of power unit dimensions required for this commodity */
     powerUnits: Array<VehicleDimensions>;
 };

package/dist/types/commodity.js

@@ -1,2 +1,8 @@
 "use strict";
+/**
+ * Commodity Type
+ *
+ * Defines the structure for permitted commodities that can be transported.
+ * Extends IdentifiedObject with vehicle dimension requirements.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/cost-rule.d.ts

@@ -1,4 +1,12 @@
+/**
+ * Cost Rule Type
+ *
+ * Defines the structure for cost calculation rules used in permit pricing.
+ * Maps facts to parameters for dynamic cost calculations.
+ */
 export type CostRule = {
+    /** The fact identifier used in the cost calculation */
     fact: string;
+    /** Parameters passed to the cost calculation function */
     params: Record<string, any>;
 };

package/dist/types/cost-rule.js

@@ -1,2 +1,8 @@
 "use strict";
+/**
+ * Cost Rule Type
+ *
+ * Defines the structure for cost calculation rules used in permit pricing.
+ * Maps facts to parameters for dynamic cost calculations.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/dimension-modifier.d.ts

@@ -1,19 +1,46 @@
+/**
+ * Dimension Modifier Types
+ *
+ * Defines structures for modifying vehicle dimensions based on configuration
+ * and relationships between vehicle components.
+ */
 import { SelfIssuable } from 'onroute-policy-engine/types';
+/**
+ * Modifier for adjusting vehicle dimensions based on configuration
+ * Extends SelfIssuable to include self-issuance capability
+ */
 export type DimensionModifier = SelfIssuable & {
+    /** Position identifier for the modifier (e.g., 'first', 'last', 'next') */
     position: string;
+    /** Type of vehicle component being modified */
     type?: string;
+    /** Category of vehicle component being modified */
     category?: string;
+    /** Number of axles in the axle unit affected by this modifier */
     axles?: number;
+    /** Minimum interaxle spacing in millimeters */
     minInterAxleSpacing?: number;
+    /** Maximum interaxle spacing in millimeters */
     maxInterAxleSpacing?: number;
 };
+/**
+ * Defines relationships between vehicle components for dimension calculations
+ */
 export type VehicleRelatives = {
+    /** First vehicle type in the configuration */
     firstType: string;
+    /** Last vehicle type in the configuration */
     lastType?: string;
+    /** Next vehicle type in sequence */
     nextType?: string | null;
+    /** Previous vehicle type in sequence */
     prevType?: string | null;
+    /** First vehicle category in the configuration */
     firstCategory?: string | null;
+    /** Last vehicle category in the configuration */
     lastCategory?: string | null;
+    /** Next vehicle category in sequence */
     nextCategory?: string | null;
+    /** Previous vehicle category in sequence */
     prevCategory?: string | null;
 };

package/dist/types/dimension-modifier.js

@@ -1,2 +1,8 @@
 "use strict";
+/**
+ * Dimension Modifier Types
+ *
+ * Defines structures for modifying vehicle dimensions based on configuration
+ * and relationships between vehicle components.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/display-code-defaults.d.ts

@@ -1,18 +1,40 @@
+/**
+ * Vehicle Display Code Defaults Type
+ *
+ * Defines default values and formatting rules for generating vehicle display codes.
+ * Used for creating standardized vehicle identification codes across the system.
+ */
 export type VehicleDisplayCodeDefaults = {
+    /** Standard prefix for display codes */
     prefixStandard: string;
+    /** Universal prefix for display codes */
     prefixUniversal: string;
+    /** Standard padding character for display codes */
     paddingStandard: string;
+    /** Universal padding character for display codes */
     paddingUniversal: string;
+    /** Default spacing for universal display codes */
     spacingUniversalDefault: string;
+    /** Spacing for small universal display codes */
     spacingUniversalSmall: string;
+    /** Spacing for large universal display codes */
     spacingUniversalLarge: string;
+    /** Maximum threshold for small universal spacing */
     spacingUniversalSmallMax: number;
+    /** Minimum threshold for large universal spacing */
     spacingUniversalLargeMin: number;
+    /** Code for extra axles in universal format */
     extraAxleUniversal: string;
+    /** Code for end axles in universal format */
     endAxleUniversal: string;
+    /** Maximum number of axles for standard format */
     maxAxlesStandard: number;
+    /** Threshold number of axles for universal format */
     thresholdAxlesUniversal: number;
+    /** Code for over-threshold axles in universal format */
     overAxlesCodeUniversal: string;
+    /** Universal axle code format */
     universalAxleCode: string;
+    /** Prefix for multi-digit axle codes */
     multiDigitPrefix: string;
 };

package/dist/types/display-code-defaults.js

@@ -1,2 +1,8 @@
 "use strict";
+/**
+ * Vehicle Display Code Defaults Type
+ *
+ * Defines default values and formatting rules for generating vehicle display codes.
+ * Used for creating standardized vehicle identification codes across the system.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/facts.d.ts

@@ -1,10 +1,24 @@
+/**
+ * Permit Facts Type
+ *
+ * Defines the structure for permit application facts used in policy validation.
+ * Contains essential information about the permit application and vehicle.
+ */
 export type PermitFacts = {
+    /** Company name applying for the permit */
     companyName?: string;
+    /** Duration of the permit in days */
     duration?: number;
+    /** Type of permit being applied for */
     permitType?: string;
+    /** Start date of the permit (YYYY-MM-DD format) */
     startDate?: string;
+    /** Vehicle Identification Number */
     vehicleIdentificationNumber?: string;
+    /** Vehicle license plate number */
     vehiclePlate?: string;
+    /** Type of vehicle permitted (primary vehicle) (e.g., 'TRKTRAC') */
     vehicleType?: string;
+    /** Additional application data as a generic object */
     app?: object;
 };

package/dist/types/facts.js

@@ -1,2 +1,8 @@
 "use strict";
+/**
+ * Permit Facts Type
+ *
+ * Defines the structure for permit application facts used in policy validation.
+ * Contains essential information about the permit application and vehicle.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });