onroute-policy-engine 1.7.0 → 1.8.1

package/dist/helper/bridge-calculation.helper.js

@@ -40,8 +40,10 @@ function runBridgeFormula(axleConfig, policy) {
             }
             let totalWeight = axle.axleUnitWeight;
             // Spread may be zero or undefined if the axle unit
-            // is a single axle. Spacing to next will be zero or
-            // undefined for the final axle unit in the configuration.
+            // is a single axle. Interaxle spacing will be zero or
+            // undefined for the first axle unit in the configuration
+            // since it describes the spacing from the previous axle
+            // unit in the configuration.
             if (axle.numberOfAxles > 1 && (!axle.axleSpread || axle.axleSpread < 0)) {
                 throw new Error(`Invalid or missing axle spread for axle unit number ${firstAxle}`);
             }

package/dist/helper/dimensions.helper.d.ts

@@ -0,0 +1,89 @@
+import { Policy } from '../policy-engine';
+import { AxleConfiguration, PowerUnitWeightDimension, SizeDimension, TrailerWeightDimension, VehicleRelatives, WeightDimension } from '../types';
+import { SingleAxleDimension } from '../types/weight-dimension';
+/**
+ * Gets the maximum size dimensions for a given permit type, commodity,
+ * and vehicle configuration. A vehicle configuration's size dimension is
+ * dictated by the configuration on the trailer. For configurations that
+ * are just a power unit, a pseudo trailer type 'NONE' is used and the
+ * size dimension is configured on that. Accessory category trailers
+ * (e.g. jeeps and boosters) are not used for configuration since they
+ * do not impact the size dimension in policy.
+ * @param permitTypeId ID of the permit type to get size dimension for
+ * @param commodityId ID of the commodity to get size dimension for
+ * @param currentConfiguration Current vehicle configuration to get size dimension for
+ * @param regions List of regions the vehicle will be traveling in. If not
+ * supplied this defaults to the most restrictive size dimension (if multiple
+ * are configured).
+ * @returns SizeDimension for the given permit type, commodity, and configuration
+ */
+export declare function getSizeDimensionHelper(policy: Policy, permitTypeId: string, commodityId: string, configuration: Array<string>, regions?: Array<string>): SizeDimension | null;
+/**
+ * Selects the correct size dimension from a list of potential candidates, based
+ * on the modifier of each dimension. If none of the modifiers match, returns
+ * null.
+ * @param sizeDimensions Size dimension options to choose from
+ * @param configuration The full vehicle configuration
+ * @param sizeTrailer The last trailer in the configuration that can be used
+ * for size calculations (e.g. not a booster).
+ */
+export declare function selectCorrectSizeDimension(sizeDimensions: Array<SizeDimension>, configuration: Array<string>, sizeTrailer: string): SizeDimension | null;
+/**
+ * Gets the default legal and permittable weights for a
+ * given power unit type and number of axles. The number of
+ * axles is supplied as a 2-digit number, with the most
+ * significant digit representing the steer axle unit and the
+ * least significant digit representing the drive axle unit.
+ * @param policy The instantiated policy object with weight config
+ * @param subType Power unit subtype
+ * @param axles Number of axles in the power unit axle units
+ * @returns Array of power unit weights. Multiple power unit
+ * weights may be returned if there are different weights
+ * depending on prior / subsequent vehicles in the
+ * configuration (weight modifiers). Will return an empty array
+ * if the number of axles is not configured in policy.
+ */
+export declare function getDefaultPowerUnitWeightHelper(policy: Policy, subType: string, axles: number): Array<PowerUnitWeightDimension>;
+/**
+ * Gets the default legal and permittable weights for a
+ * given trailer type and number of axles in the trailer axle
+ * unit.
+ * @param policy The instantiated policy object with weight config
+ * @param subType Trailer subtype
+ * @param axles Number of axles in the trailer axle unit
+ * @returns Array of trailer weights. Multiple trailer
+ * weights may be returned if there are different weights
+ * depending on prior / subsequent vehicles in the
+ * configuration (weight modifiers). Will return an empty array
+ * if the number of axles is not configured in policy.
+ */
+export declare function getDefaultTrailerWeightHelper(policy: Policy, subType: string, axles: number): Array<TrailerWeightDimension>;
+/**
+ * Given a list of default weight dimensions and a vehicle
+ * configuration, select the correct weight dimensions for
+ * the axle unit at the supplied axleIndex. The weight dimensions
+ * may have modifiers (e.g. if a tandem booster follows a tridem
+ * semi trailer) - this method will select the correct weights
+ * to be used for policy checks.
+ * @param policy The instantiated policy object with weight config
+ * @param weightDimensions Default weight dimensions for the vehicle
+ * at the index indicated by axleIndex
+ * @param configuration Full vehicle configuration
+ * @param axleConfiguration Full axle weights of the vehicle configuration
+ * @param axleIndex Index of the axle unit for which weights are
+ * to be returned.
+ * @returns Single axle dimension representing the legal and permittable
+ * weights for the axle unit at the supplied axleIndex.
+ */
+export declare function selectCorrectWeightDimensionHelper(policy: Policy, weightDimensions: Array<WeightDimension>, configuration: Array<string>, axleConfiguration: Array<AxleConfiguration>, axleIndex: number): SingleAxleDimension | null;
+/**
+ * Convenience method to get the vehicles in the configuration relative
+ * to the axle unit at the indicated axleIndex, to be used when
+ * evaluating weight modifiers.
+ * @param policy The instantiated policy object with weight config
+ * @param configuration Full vehicle configuration
+ * @param axleIndex Index of the axle unit for which relatives are
+ * to be returned.
+ * @returns VehicleRelatives for the axle at the indicated axleIndex
+ */
+export declare function getVehicleRelatives(policy: Policy, configuration: Array<string>, axleIndex: number): VehicleRelatives;

package/dist/helper/dimensions.helper.js

@@ -0,0 +1,473 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSizeDimensionHelper = getSizeDimensionHelper;
+exports.selectCorrectSizeDimension = selectCorrectSizeDimension;
+exports.getDefaultPowerUnitWeightHelper = getDefaultPowerUnitWeightHelper;
+exports.getDefaultTrailerWeightHelper = getDefaultTrailerWeightHelper;
+exports.selectCorrectWeightDimensionHelper = selectCorrectWeightDimensionHelper;
+exports.getVehicleRelatives = getVehicleRelatives;
+const enum_1 = require("../enum");
+/**
+ * Gets the maximum size dimensions for a given permit type, commodity,
+ * and vehicle configuration. A vehicle configuration's size dimension is
+ * dictated by the configuration on the trailer. For configurations that
+ * are just a power unit, a pseudo trailer type 'NONE' is used and the
+ * size dimension is configured on that. Accessory category trailers
+ * (e.g. jeeps and boosters) are not used for configuration since they
+ * do not impact the size dimension in policy.
+ * @param permitTypeId ID of the permit type to get size dimension for
+ * @param commodityId ID of the commodity to get size dimension for
+ * @param currentConfiguration Current vehicle configuration to get size dimension for
+ * @param regions List of regions the vehicle will be traveling in. If not
+ * supplied this defaults to the most restrictive size dimension (if multiple
+ * are configured).
+ * @returns SizeDimension for the given permit type, commodity, and configuration
+ */
+function getSizeDimensionHelper(policy, permitTypeId, commodityId, configuration, regions) {
+    var _a, _b, _c;
+    // Initialize the sizeDimension with global defaults
+    let sizeDimension = null;
+    // Validate that the configuration is permittable
+    if (policy.isConfigurationValid(permitTypeId, commodityId, configuration)) {
+        // Get the power unit that has the size configuration
+        const commodity = policy.getCommodityDefinition(commodityId);
+        const powerUnit = (_b = (_a = commodity === null || commodity === void 0 ? void 0 : commodity.size) === null || _a === void 0 ? void 0 : _a.powerUnits) === null || _b === void 0 ? void 0 : _b.find((pu) => pu.type == configuration[0]);
+        if (!powerUnit) {
+            throw new Error(`Configuration error: could not find power unit '${configuration[0]}'`);
+        }
+        // Get the last trailer in the configuration that can be used for size calculations
+        const sizeTrailer = Array.from(configuration)
+            .reverse()
+            .find((vehicleId) => {
+            var _a;
+            const trailerType = (_a = policy.policyDefinition.vehicleTypes.trailerTypes) === null || _a === void 0 ? void 0 : _a.find((v) => v.id == vehicleId);
+            return !(trailerType === null || trailerType === void 0 ? void 0 : trailerType.ignoreForSizeDimensions);
+        });
+        if (sizeTrailer) {
+            // Get the trailer size dimension array for the commodity
+            const trailer = (_c = powerUnit.trailers) === null || _c === void 0 ? void 0 : _c.find((t) => t.type == sizeTrailer);
+            let sizeDimensions;
+            if (trailer &&
+                trailer.sizeDimensions &&
+                trailer.sizeDimensions.length > 0) {
+                sizeDimensions = trailer.sizeDimensions;
+            }
+            else {
+                sizeDimensions = new Array();
+            }
+            const sizeDimensionConfigured = selectCorrectSizeDimension(sizeDimensions, configuration, sizeTrailer);
+            if (sizeDimensionConfigured) {
+                // Adjust the size dimensions for the regions travelled, if needed
+                if (!regions) {
+                    // If we are not provided a list of regions, assume we are
+                    // traveling through all regions (will take the most restrictive
+                    // of all dimensions in all cases).
+                    console.log('Assuming all regions for size dimension lookup');
+                    regions = policy.policyDefinition.geographicRegions.map((g) => g.id);
+                }
+                else {
+                    console.log(`Using '${regions}' as regions for size lookup`);
+                }
+                const valueOverrides = [];
+                regions === null || regions === void 0 ? void 0 : regions.forEach((r) => {
+                    var _a, _b, _c, _d;
+                    let valueOverride;
+                    // Check to see if this region has specific size dimensions
+                    const regionOverride = (_a = sizeDimensionConfigured.regions) === null || _a === void 0 ? void 0 : _a.find((cr) => cr.region == r);
+                    if (!regionOverride) {
+                        // The region travelled does not have an override, so it assumes
+                        // the dimensions of the bc default.
+                        valueOverride = {
+                            region: r,
+                            h: sizeDimensionConfigured.h,
+                            w: sizeDimensionConfigured.w,
+                            l: sizeDimensionConfigured.l,
+                        };
+                    }
+                    else {
+                        // There is a region override with one or more dimensions. Use this
+                        // value preferentially, using default dimension if not supplied
+                        valueOverride = {
+                            region: r,
+                            h: (_b = regionOverride.h) !== null && _b !== void 0 ? _b : sizeDimensionConfigured.h,
+                            w: (_c = regionOverride.w) !== null && _c !== void 0 ? _c : sizeDimensionConfigured.w,
+                            l: (_d = regionOverride.l) !== null && _d !== void 0 ? _d : sizeDimensionConfigured.l,
+                        };
+                    }
+                    valueOverrides.push(valueOverride);
+                });
+                // At this point we have a complete set of size dimensions for each of
+                // the regions that will be traversed. Take the minimum value of each
+                // dimension for the final value.
+                const minimumOverrides = valueOverrides.reduce((accumulator, currentValue) => {
+                    if (typeof currentValue.h !== 'undefined') {
+                        if (typeof accumulator.h === 'undefined') {
+                            accumulator.h = currentValue.h;
+                        }
+                        else {
+                            accumulator.h = Math.min(accumulator.h, currentValue.h);
+                        }
+                    }
+                    if (typeof currentValue.w !== 'undefined') {
+                        if (typeof accumulator.w === 'undefined') {
+                            accumulator.w = currentValue.w;
+                        }
+                        else {
+                            accumulator.w = Math.min(accumulator.w, currentValue.w);
+                        }
+                    }
+                    if (typeof currentValue.l !== 'undefined') {
+                        if (typeof accumulator.l === 'undefined') {
+                            accumulator.l = currentValue.l;
+                        }
+                        else {
+                            accumulator.l = Math.min(accumulator.l, currentValue.l);
+                        }
+                    }
+                    return accumulator;
+                }, { region: '' });
+                sizeDimension = {
+                    rp: sizeDimensionConfigured.rp,
+                    fp: sizeDimensionConfigured.fp,
+                    h: minimumOverrides.h,
+                    w: minimumOverrides.w,
+                    l: minimumOverrides.l,
+                };
+            }
+            else {
+                console.log('Size dimension not configured for trailer');
+            }
+        }
+        else {
+            console.log('Could not locate trailer to use for size dimension');
+        }
+    }
+    else {
+        console.log('Configuration is invalid, returning null size dimension');
+    }
+    return sizeDimension;
+}
+/**
+ * Selects the correct size dimension from a list of potential candidates, based
+ * on the modifier of each dimension. If none of the modifiers match, returns
+ * null.
+ * @param sizeDimensions Size dimension options to choose from
+ * @param configuration The full vehicle configuration
+ * @param sizeTrailer The last trailer in the configuration that can be used
+ * for size calculations (e.g. not a booster).
+ */
+function selectCorrectSizeDimension(sizeDimensions, configuration, sizeTrailer) {
+    var _a;
+    let matchingDimension = null;
+    if ((sizeDimensions === null || sizeDimensions === void 0 ? void 0 : sizeDimensions.length) > 0 && (configuration === null || configuration === void 0 ? void 0 : configuration.length) > 0) {
+        for (const sizeDimension of sizeDimensions) {
+            if (!sizeDimension.modifiers) {
+                // This dimension has no modifiers, so it is the default if none of
+                // the other specific modifiers match.
+                matchingDimension = sizeDimension;
+                console.log('Using default size dimension, no modifiers specified');
+            }
+            else {
+                const sizeTrailerIndex = configuration.findIndex((c) => sizeTrailer == c);
+                const isMatch = (_a = sizeDimension.modifiers) === null || _a === void 0 ? void 0 : _a.every((m) => {
+                    if (!m.type) {
+                        return false;
+                    }
+                    switch (m.position) {
+                        case enum_1.RelativePosition.First.toString():
+                            return configuration[0] == m.type;
+                        case enum_1.RelativePosition.Last.toString():
+                            return configuration[configuration.length - 1] == m.type;
+                        case enum_1.RelativePosition.Before.toString():
+                            return configuration[sizeTrailerIndex - 1] == m.type;
+                        case enum_1.RelativePosition.After.toString():
+                            return configuration[sizeTrailerIndex + 1] == m.type;
+                        default:
+                            return false;
+                    }
+                });
+                // As soon as we find a dimension with matching modifiers,
+                // set it and return it.
+                if (isMatch) {
+                    matchingDimension = sizeDimension;
+                    break;
+                }
+            }
+        }
+    }
+    else {
+        console.log('Either size dimensions or configuration array is null, no matching dimension returned');
+    }
+    return matchingDimension;
+}
+/**
+ * Gets the default legal and permittable weights for a
+ * given power unit type and number of axles. The number of
+ * axles is supplied as a 2-digit number, with the most
+ * significant digit representing the steer axle unit and the
+ * least significant digit representing the drive axle unit.
+ * @param policy The instantiated policy object with weight config
+ * @param subType Power unit subtype
+ * @param axles Number of axles in the power unit axle units
+ * @returns Array of power unit weights. Multiple power unit
+ * weights may be returned if there are different weights
+ * depending on prior / subsequent vehicles in the
+ * configuration (weight modifiers). Will return an empty array
+ * if the number of axles is not configured in policy.
+ */
+function getDefaultPowerUnitWeightHelper(policy, subType, axles) {
+    return getDefaultVehicleWeightHelper(policy, subType, axles, true);
+}
+/**
+ * Gets the default legal and permittable weights for a
+ * given trailer type and number of axles in the trailer axle
+ * unit.
+ * @param policy The instantiated policy object with weight config
+ * @param subType Trailer subtype
+ * @param axles Number of axles in the trailer axle unit
+ * @returns Array of trailer weights. Multiple trailer
+ * weights may be returned if there are different weights
+ * depending on prior / subsequent vehicles in the
+ * configuration (weight modifiers). Will return an empty array
+ * if the number of axles is not configured in policy.
+ */
+function getDefaultTrailerWeightHelper(policy, subType, axles) {
+    return getDefaultVehicleWeightHelper(policy, subType, axles, false);
+}
+/**
+ * Helper function for getting the default vehicle weight,
+ * works for both power units and trailers based on the
+ * value of the isPowerUnit flag. Not exported so not intended
+ * to be used outside of this helper class.
+ * @param policy The instantiated policy object with weight config
+ * @param subType Trailer subtype
+ * @param axles Number of axles in the vehicle
+ * @param isPowerUnit Whether this vehicle is a power unit
+ * @returns Array of weight dimensions, either TrailerWeightDimension
+ * or PowerUnitWeightDimension based on the value of isPowerUnit
+ */
+function getDefaultVehicleWeightHelper(policy, subType, axles, isPowerUnit) {
+    var _a, _b, _c, _d, _e, _f;
+    const vehicleDefinition = isPowerUnit
+        ? policy.getPowerUnitDefinition(subType)
+        : policy.getTrailerDefinition(subType);
+    if (!vehicleDefinition) {
+        throw new Error(`No definition found for vehicle type '${subType}'`);
+    }
+    // Prefer specific subtype weight definition
+    const weights = (_a = vehicleDefinition.defaultWeightDimensions) === null || _a === void 0 ? void 0 : _a.filter((w) => w.axles === axles);
+    if (weights && weights.length > 0) {
+        return JSON.parse(JSON.stringify(weights));
+    }
+    // Second preference is category weight definition
+    const vehicleCategories = isPowerUnit
+        ? (_b = policy.policyDefinition.vehicleCategories) === null || _b === void 0 ? void 0 : _b.powerUnitCategories
+        : (_c = policy.policyDefinition.vehicleCategories) === null || _c === void 0 ? void 0 : _c.trailerCategories;
+    const vehicleCategory = vehicleCategories === null || vehicleCategories === void 0 ? void 0 : vehicleCategories.find((c) => c.id === vehicleDefinition.category);
+    if (vehicleCategory) {
+        const overridesForAxle = (_d = vehicleCategory.defaultWeightDimensions) === null || _d === void 0 ? void 0 : _d.filter((w) => w.axles === axles);
+        if (overridesForAxle) {
+            return JSON.parse(JSON.stringify(overridesForAxle));
+        }
+    }
+    // Final preference is global weight default
+    const globalDefaults = isPowerUnit
+        ? (_e = policy.policyDefinition.globalWeightDefaults) === null || _e === void 0 ? void 0 : _e.powerUnits
+        : (_f = policy.policyDefinition.globalWeightDefaults) === null || _f === void 0 ? void 0 : _f.trailers;
+    const vehicleDefaults = globalDefaults === null || globalDefaults === void 0 ? void 0 : globalDefaults.filter((w) => w.axles === axles);
+    if (vehicleDefaults) {
+        // Return a copy of the vehicle weights
+        return JSON.parse(JSON.stringify(vehicleDefaults));
+    }
+    else {
+        return new Array();
+    }
+}
+/**
+ * Given a list of default weight dimensions and a vehicle
+ * configuration, select the correct weight dimensions for
+ * the axle unit at the supplied axleIndex. The weight dimensions
+ * may have modifiers (e.g. if a tandem booster follows a tridem
+ * semi trailer) - this method will select the correct weights
+ * to be used for policy checks.
+ * @param policy The instantiated policy object with weight config
+ * @param weightDimensions Default weight dimensions for the vehicle
+ * at the index indicated by axleIndex
+ * @param configuration Full vehicle configuration
+ * @param axleConfiguration Full axle weights of the vehicle configuration
+ * @param axleIndex Index of the axle unit for which weights are
+ * to be returned.
+ * @returns Single axle dimension representing the legal and permittable
+ * weights for the axle unit at the supplied axleIndex.
+ */
+function selectCorrectWeightDimensionHelper(policy, weightDimensions, configuration, axleConfiguration, axleIndex) {
+    let matchingDimension = null;
+    if (!weightDimensions || weightDimensions.length === 0) {
+        throw new Error('Missing weight dimensions');
+    }
+    if (!configuration || configuration.length === 0) {
+        throw new Error('Missing configuration');
+    }
+    if (!axleConfiguration || axleConfiguration.length === 0) {
+        throw new Error('Missing axle configuration');
+    }
+    if (axleIndex > configuration.length) {
+        throw new Error('Invalid axle index value');
+    }
+    if (configuration.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
+        // axle units.
+        throw new Error('Wrong number of axles configured for vehicle configuration');
+    }
+    const relatives = getVehicleRelatives(policy, configuration, axleIndex);
+    for (const weightDimension of weightDimensions) {
+        // Just renaming this for conciseness
+        const m = weightDimension.modifier;
+        if (!m) {
+            // This dimension has no modifiers, so it is the default
+            if (axleIndex <= 1) {
+                const pwd = weightDimension;
+                matchingDimension = {
+                    legal: axleIndex === 0 ? pwd.saLegal : pwd.daLegal,
+                    permittable: axleIndex === 0 ? pwd.saPermittable : pwd.daPermittable,
+                };
+            }
+            else {
+                const twd = weightDimension;
+                const { legal, permittable } = twd;
+                matchingDimension = { legal, permittable };
+            }
+            console.log('Using default weight dimension, no modifiers specified');
+        }
+        else {
+            let isMatch = false;
+            // We can match by vehicle type or vehicle category
+            let matcher = m.type;
+            let isTypeMatch = true;
+            if (!matcher) {
+                matcher = m.category;
+                isTypeMatch = false;
+            }
+            if (matcher) {
+                switch (m.position) {
+                    case enum_1.RelativePosition.First.toString():
+                        isMatch =
+                            matcher ==
+                                (isTypeMatch ? relatives.firstType : relatives.firstCategory);
+                        break;
+                    case enum_1.RelativePosition.Last.toString():
+                        isMatch =
+                            matcher ==
+                                (isTypeMatch ? relatives.lastType : relatives.lastCategory);
+                        break;
+                    case enum_1.RelativePosition.Before.toString(): {
+                        isMatch =
+                            matcher ==
+                                (isTypeMatch ? relatives.prevType : relatives.prevCategory);
+                        if (isMatch && m.axles) {
+                            isMatch =
+                                m.axles == axleConfiguration[axleIndex - 1].numberOfAxles;
+                        }
+                        const spacingFromPrev = axleConfiguration[axleIndex].interaxleSpacing;
+                        if (!spacingFromPrev) {
+                            console.log(`Axle configuration incorrect, missing interaxle spacing`);
+                            isMatch = false;
+                            break;
+                        }
+                        else if (isMatch && m.minInterAxleSpacing) {
+                            isMatch = m.minInterAxleSpacing <= spacingFromPrev;
+                        }
+                        if (isMatch && m.maxInterAxleSpacing) {
+                            isMatch = m.maxInterAxleSpacing >= spacingFromPrev;
+                        }
+                        break;
+                    }
+                    case enum_1.RelativePosition.After.toString(): {
+                        isMatch =
+                            matcher ==
+                                (isTypeMatch ? relatives.nextType : relatives.nextCategory);
+                        if (isMatch && m.axles) {
+                            isMatch =
+                                m.axles == axleConfiguration[axleIndex + 1].numberOfAxles;
+                        }
+                        const spacingToNext = axleConfiguration[axleIndex + 1].interaxleSpacing;
+                        if (!spacingToNext) {
+                            console.log(`Axle configuration incorrect, missing interaxle spacing`);
+                            isMatch = false;
+                            break;
+                        }
+                        else if (isMatch && m.minInterAxleSpacing) {
+                            isMatch = m.minInterAxleSpacing <= spacingToNext;
+                        }
+                        if (isMatch && m.maxInterAxleSpacing) {
+                            isMatch = m.maxInterAxleSpacing >= spacingToNext;
+                        }
+                        break;
+                    }
+                    default:
+                        isMatch = false;
+                        break;
+                }
+            }
+            // As soon as we find a dimension with matching modifiers,
+            // set it and return it. The implication is that if there are
+            // multiple modifiers that match, the first one will be
+            // returned (so modifiers should be configured to be exclusive).
+            if (isMatch) {
+                const twd = weightDimension;
+                const { legal, permittable } = twd;
+                matchingDimension = { legal, permittable };
+                break;
+            }
+        }
+    }
+    return matchingDimension;
+}
+/**
+ * Convenience method to get the vehicles in the configuration relative
+ * to the axle unit at the indicated axleIndex, to be used when
+ * evaluating weight modifiers.
+ * @param policy The instantiated policy object with weight config
+ * @param configuration Full vehicle configuration
+ * @param axleIndex Index of the axle unit for which relatives are
+ * to be returned.
+ * @returns VehicleRelatives for the axle at the indicated axleIndex
+ */
+function getVehicleRelatives(policy, configuration, axleIndex) {
+    var _a, _b;
+    const firstType = configuration[0];
+    const lastType = configuration[configuration.length - 1];
+    const firstVehicle = policy.getVehicleDefinition(firstType);
+    const lastVehicle = policy.getVehicleDefinition(lastType);
+    // Get relevant nearby vehicle types for the target axle
+    const vehicleRelatives = {
+        firstType: firstType,
+        lastType: lastType,
+        firstCategory: firstVehicle === null || firstVehicle === void 0 ? void 0 : firstVehicle.category,
+        lastCategory: lastVehicle === null || lastVehicle === void 0 ? void 0 : lastVehicle.category,
+    };
+    if (axleIndex <= 1) {
+        // First two axles are for the power unit which has no
+        // previous type (it is first in the configuration always)
+        vehicleRelatives.prevType = null;
+        vehicleRelatives.prevCategory = null;
+    }
+    else {
+        // Subtract 2 from the configuration index to account for
+        // the fact that the power unit has two axles.
+        vehicleRelatives.prevType = configuration[axleIndex - 2];
+        vehicleRelatives.prevCategory = (_a = policy.getVehicleDefinition(vehicleRelatives.prevType)) === null || _a === void 0 ? void 0 : _a.category;
+    }
+    if (configuration.length === 1 || axleIndex === configuration.length) {
+        // The axleIndex is for the last vehicle in the configuration,
+        // so it has no next type.
+        vehicleRelatives.nextType = null;
+        vehicleRelatives.nextCategory = null;
+    }
+    else {
+        vehicleRelatives.nextType = configuration[axleIndex];
+        vehicleRelatives.nextCategory = (_b = policy.getVehicleDefinition(vehicleRelatives.nextType)) === null || _b === void 0 ? void 0 : _b.category;
+    }
+    return vehicleRelatives;
+}

package/dist/policy-engine.d.ts

@@ -1,4 +1,4 @@
-import { PolicyDefinition, PermitType, Commodity, VehicleType, SizeDimension, AxleConfiguration, BridgeCalculationResult, ConditionForPermit } from 'onroute-policy-engine/types';
+import { PolicyDefinition, PermitType, Commodity, VehicleType, SizeDimension, AxleConfiguration, BridgeCalculationResult, ConditionForPermit, TrailerType, PowerUnitType, TrailerWeightDimension, PowerUnitWeightDimension, WeightDimension, SingleAxleDimension, StandardTireSize } from 'onroute-policy-engine/types';
 import { Engine } from 'json-rules-engine';
 import { ValidationResults } from './validation-results';
 import { SpecialAuthorizations } from './types/special-authorizations';
@@ -101,46 +101,31 @@ export declare class Policy {
     getNextPermittableVehicles(permitTypeId: string, commodityId: string, currentConfiguration: Array<string>): Map<string, string>;
     /**
      * Returns whether the supplied configuration is valid for the given permit type
-     * and commodity. If the permit type does not require a commodity, this method
-     * will return false. This will not validate incomplete configurations - if the
-     * current configuration has only a power unit this will return false even if the
-     * power unit is acceptable because there is no trailer which is mandatory.
-     * If this is called for a permit type that does not require commodity, or with
-     * a commodity not permitted for the permit type, it will return false.
+     * and commodity. If the permit type does not require a commodity, or if this
+     * method is called with a commodity not permitted for the permit type, this method
+     * will return false.
      * @param permitTypeId ID of the permit type to validate the configuration against
      * @param commodityId ID of the commodity used for the configuration
      * @param currentConfiguration Current vehicle configuration to validate
      * @param validatePartial Whether to validate a partial configuration (e.g. one
      * that does not include a trailer). This will just return whether or not there
      * are any invalid vehicles in the configuration. If true, an empty current
-     * configuration will return true from this method.
+     * configuration will return true from this method provided the commodity is
+     * allowable for the permit type.
      */
     isConfigurationValid(permitTypeId: string, commodityId: string, currentConfiguration: Array<string>, validatePartial?: boolean): boolean;
     /**
      * Gets the maximum size dimensions for a given permit type, commodity,
-     * and vehicle configuration. A vehicle configuration's size dimension is
-     * dictated by the configuration on the trailer. For configurations that
-     * are just a power unit, a pseudo trailer type 'NONE' is used and the
-     * size dimension is configured on that. Accessory category trailers
-     * (e.g. jeeps and boosters) are not used for configuration since they
-     * do not impact the size dimension in policy.
+     * and vehicle configuration. Delegates to helper method.
      * @param permitTypeId ID of the permit type to get size dimension for
      * @param commodityId ID of the commodity to get size dimension for
-     * @param currentConfiguration Current vehicle configuration to get size dimension for
+     * @param configuration Current vehicle configuration to get size dimension for
      * @param regions List of regions the vehicle will be traveling in. If not
      * supplied this defaults to the most restrictive size dimension (if multiple
      * are configured).
      * @returns SizeDimension for the given permit type, commodity, and configuration
      */
     getSizeDimension(permitTypeId: string, commodityId: string, configuration: Array<string>, regions?: Array<string>): SizeDimension | null;
-    /**
-     * Selects the correct size dimension from a list of potential candidates, based
-     * on the modifier of each dimension. If none of the modifiers match, returns
-     * null.
-     * @param sizeDimensions Size dimension options to choose from
-     * @param currentConfiguration The full vehicle configuration
-     */
-    selectCorrectSizeDimension(sizeDimensions: Array<SizeDimension>, configuration: Array<string>, sizeTrailer: string): SizeDimension | null;
     /**
      * Gets a list of all configured power unit types in the policy definition.
      * @returns Map of power unit type IDs to power unit type names.
@@ -164,6 +149,18 @@ export declare class Policy {
      * @returns Vehicle Type (trailer or power unit), or null if none found
      */
     getVehicleDefinition(subType?: string): VehicleType | null;
+    /**
+     * Gets a full PowerUnitType definition by subtype
+     * @param subType string subtype of the power unit to return
+     * @returns PowerUnitType for the supplied subtype
+     */
+    getPowerUnitDefinition(subType?: string): PowerUnitType | null;
+    /**
+     * Gets a full TrailerType definition by subtype
+     * @param subType string subtype of the trailer to return
+     * @returns TrailerType for the supplied subtype
+     */
+    getTrailerDefinition(subType?: string): TrailerType | null;
     /**
      * Gets a full Commodity definition by ID
      * @param type Type ID of the commodity to return.
@@ -185,4 +182,56 @@ export declare class Policy {
      * @param permitType Permit type definition
      */
     getAllowedVehicles(permitType: PermitType): Map<string, Map<string, string>>;
+    /**
+     * Gets the default legal and permittable weights for a
+     * given trailer type and number of axles in the trailer axle
+     * unit.
+     * @param subType Trailer subtype
+     * @param axles Number of axles in the trailer axle unit
+     * @returns Array of trailer weights. Multiple trailer
+     * weights may be returned if there are different weights
+     * depending on prior / subsequent vehicles in the
+     * configuration (weight modifiers). Will return an empty array
+     * if the number of axles is not configured in policy.
+     */
+    getDefaultTrailerWeight(subType: string, axles: number): Array<TrailerWeightDimension>;
+    /**
+     * Gets the default legal and permittable weights for a
+     * given power unit type and number of axles. The number of
+     * axles is supplied as a 2-digit number, with the most
+     * significant digit representing the steer axle unit and the
+     * least significant digit representing the drive axle unit.
+     * @param subType Power unit subtype
+     * @param axles Number of axles in the power unit axle units
+     * @returns Array of power unit weights. Multiple power unit
+     * weights may be returned if there are different weights
+     * depending on prior / subsequent vehicles in the
+     * configuration (weight modifiers). Will return an empty array
+     * if the number of axles is not configured in policy.
+     */
+    getDefaultPowerUnitWeight(subType: string, axles: number): Array<PowerUnitWeightDimension>;
+    /**
+     * Given a list of default weight dimensions and a vehicle
+     * configuration, select the correct weight dimensions for
+     * the axle unit at the supplied axleIndex. The weight dimensions
+     * may have modifiers (e.g. if a tandem booster follows a tridem
+     * semi trailer) - this method will select the correct weights
+     * to be used for policy checks.
+     * @param weightDimensions Default weight dimensions for the vehicle
+     * at the index indicated by axleIndex
+     * @param configuration Full vehicle configuration
+     * @param axleConfiguration Full axle weights of the vehicle configuration
+     * @param axleIndex Index of the axle unit for which weights are
+     * to be returned.
+     * @returns Single axle dimension representing the legal and permittable
+     * weights for the axle unit at the supplied axleIndex.
+     */
+    selectCorrectWeightDimension(weightDimensions: Array<WeightDimension>, configuration: Array<string>, axleConfiguration: Array<AxleConfiguration>, axleIndex: number): SingleAxleDimension | null;
+    /**
+     * Get the list of known standard tire sizes, used to populate
+     * dropdown lists in front-end interfaces.
+     * @returns List of known standard tire sizes, or empty array if
+     * none are configured
+     */
+    getStandardTireSizes(): Array<StandardTireSize>;
 }

package/dist/policy-engine.js

@@ -17,6 +17,8 @@ const lt_1 = __importDefault(require("semver/functions/lt"));
 const major_1 = __importDefault(require("semver/functions/major"));
 const vehicles_helper_1 = require("./helper/vehicles.helper");
 const conditions_helper_1 = require("./helper/conditions.helper");
+const dimensions_helper_1 = require("./helper/dimensions.helper");
+const dimensions_helper_2 = require("./helper/dimensions.helper");
 /** Class representing commercial vehicle policy. */
 class Policy {
     /**
@@ -392,19 +394,17 @@ class Policy {
     }
     /**
      * Returns whether the supplied configuration is valid for the given permit type
-     * and commodity. If the permit type does not require a commodity, this method
-     * will return false. This will not validate incomplete configurations - if the
-     * current configuration has only a power unit this will return false even if the
-     * power unit is acceptable because there is no trailer which is mandatory.
-     * If this is called for a permit type that does not require commodity, or with
-     * a commodity not permitted for the permit type, it will return false.
+     * and commodity. If the permit type does not require a commodity, or if this
+     * method is called with a commodity not permitted for the permit type, this method
+     * will return false.
      * @param permitTypeId ID of the permit type to validate the configuration against
      * @param commodityId ID of the commodity used for the configuration
      * @param currentConfiguration Current vehicle configuration to validate
      * @param validatePartial Whether to validate a partial configuration (e.g. one
      * that does not include a trailer). This will just return whether or not there
      * are any invalid vehicles in the configuration. If true, an empty current
-     * configuration will return true from this method.
+     * configuration will return true from this method provided the commodity is
+     * allowable for the permit type.
      */
     isConfigurationValid(permitTypeId, commodityId, currentConfiguration, validatePartial = false) {
         var _a, _b;
@@ -488,194 +488,17 @@ class Policy {
     }
     /**
      * Gets the maximum size dimensions for a given permit type, commodity,
-     * and vehicle configuration. A vehicle configuration's size dimension is
-     * dictated by the configuration on the trailer. For configurations that
-     * are just a power unit, a pseudo trailer type 'NONE' is used and the
-     * size dimension is configured on that. Accessory category trailers
-     * (e.g. jeeps and boosters) are not used for configuration since they
-     * do not impact the size dimension in policy.
+     * and vehicle configuration. Delegates to helper method.
      * @param permitTypeId ID of the permit type to get size dimension for
      * @param commodityId ID of the commodity to get size dimension for
-     * @param currentConfiguration Current vehicle configuration to get size dimension for
+     * @param configuration Current vehicle configuration to get size dimension for
      * @param regions List of regions the vehicle will be traveling in. If not
      * supplied this defaults to the most restrictive size dimension (if multiple
      * are configured).
      * @returns SizeDimension for the given permit type, commodity, and configuration
      */
     getSizeDimension(permitTypeId, commodityId, configuration, regions) {
-        var _a, _b, _c;
-        // Initialize the sizeDimension with global defaults
-        let sizeDimension = null;
-        // Validate that the configuration is permittable
-        if (this.isConfigurationValid(permitTypeId, commodityId, configuration)) {
-            // Get the power unit that has the size configuration
-            const commodity = this.getCommodityDefinition(commodityId);
-            const powerUnit = (_b = (_a = commodity === null || commodity === void 0 ? void 0 : commodity.size) === null || _a === void 0 ? void 0 : _a.powerUnits) === null || _b === void 0 ? void 0 : _b.find((pu) => pu.type == configuration[0]);
-            if (!powerUnit) {
-                throw new Error(`Configuration error: could not find power unit '${configuration[0]}'`);
-            }
-            // Get the last trailer in the configuration that can be used for size calculations
-            const sizeTrailer = Array.from(configuration)
-                .reverse()
-                .find((vehicleId) => {
-                var _a;
-                const trailerType = (_a = this.policyDefinition.vehicleTypes.trailerTypes) === null || _a === void 0 ? void 0 : _a.find((v) => v.id == vehicleId);
-                return !(trailerType === null || trailerType === void 0 ? void 0 : trailerType.ignoreForSizeDimensions);
-            });
-            if (sizeTrailer) {
-                // Get the trailer size dimension array for the commodity
-                const trailer = (_c = powerUnit.trailers) === null || _c === void 0 ? void 0 : _c.find((t) => t.type == sizeTrailer);
-                let sizeDimensions;
-                if (trailer &&
-                    trailer.sizeDimensions &&
-                    trailer.sizeDimensions.length > 0) {
-                    sizeDimensions = trailer.sizeDimensions;
-                }
-                else {
-                    sizeDimensions = new Array();
-                }
-                const sizeDimensionConfigured = this.selectCorrectSizeDimension(sizeDimensions, configuration, sizeTrailer);
-                if (sizeDimensionConfigured) {
-                    // Adjust the size dimensions for the regions travelled, if needed
-                    if (!regions) {
-                        // If we are not provided a list of regions, assume we are
-                        // traveling through all regions (will take the most restrictive
-                        // of all dimensions in all cases).
-                        console.log('Assuming all regions for size dimension lookup');
-                        regions = this.policyDefinition.geographicRegions.map((g) => g.id);
-                    }
-                    else {
-                        console.log(`Using '${regions}' as regions for size lookup`);
-                    }
-                    const valueOverrides = [];
-                    regions === null || regions === void 0 ? void 0 : regions.forEach((r) => {
-                        var _a, _b, _c, _d;
-                        let valueOverride;
-                        // Check to see if this region has specific size dimensions
-                        const regionOverride = (_a = sizeDimensionConfigured.regions) === null || _a === void 0 ? void 0 : _a.find((cr) => cr.region == r);
-                        if (!regionOverride) {
-                            // The region travelled does not have an override, so it assumes
-                            // the dimensions of the bc default.
-                            valueOverride = {
-                                region: r,
-                                h: sizeDimensionConfigured.h,
-                                w: sizeDimensionConfigured.w,
-                                l: sizeDimensionConfigured.l,
-                            };
-                        }
-                        else {
-                            // There is a region override with one or more dimensions. Use this
-                            // value preferentially, using default dimension if not supplied
-                            valueOverride = {
-                                region: r,
-                                h: (_b = regionOverride.h) !== null && _b !== void 0 ? _b : sizeDimensionConfigured.h,
-                                w: (_c = regionOverride.w) !== null && _c !== void 0 ? _c : sizeDimensionConfigured.w,
-                                l: (_d = regionOverride.l) !== null && _d !== void 0 ? _d : sizeDimensionConfigured.l,
-                            };
-                        }
-                        valueOverrides.push(valueOverride);
-                    });
-                    // At this point we have a complete set of size dimensions for each of
-                    // the regions that will be traversed. Take the minimum value of each
-                    // dimension for the final value.
-                    const minimumOverrides = valueOverrides.reduce((accumulator, currentValue) => {
-                        if (typeof currentValue.h !== 'undefined') {
-                            if (typeof accumulator.h === 'undefined') {
-                                accumulator.h = currentValue.h;
-                            }
-                            else {
-                                accumulator.h = Math.min(accumulator.h, currentValue.h);
-                            }
-                        }
-                        if (typeof currentValue.w !== 'undefined') {
-                            if (typeof accumulator.w === 'undefined') {
-                                accumulator.w = currentValue.w;
-                            }
-                            else {
-                                accumulator.w = Math.min(accumulator.w, currentValue.w);
-                            }
-                        }
-                        if (typeof currentValue.l !== 'undefined') {
-                            if (typeof accumulator.l === 'undefined') {
-                                accumulator.l = currentValue.l;
-                            }
-                            else {
-                                accumulator.l = Math.min(accumulator.l, currentValue.l);
-                            }
-                        }
-                        return accumulator;
-                    }, { region: '' });
-                    sizeDimension = {
-                        rp: sizeDimensionConfigured.rp,
-                        fp: sizeDimensionConfigured.fp,
-                        h: minimumOverrides.h,
-                        w: minimumOverrides.w,
-                        l: minimumOverrides.l,
-                    };
-                }
-                else {
-                    console.log('Size dimension not configured for trailer');
-                }
-            }
-            else {
-                console.log('Could not locate trailer to use for size dimension');
-            }
-        }
-        else {
-            console.log('Configuration is invalid, returning null size dimension');
-        }
-        return sizeDimension;
-    }
-    /**
-     * Selects the correct size dimension from a list of potential candidates, based
-     * on the modifier of each dimension. If none of the modifiers match, returns
-     * null.
-     * @param sizeDimensions Size dimension options to choose from
-     * @param currentConfiguration The full vehicle configuration
-     */
-    selectCorrectSizeDimension(sizeDimensions, configuration, sizeTrailer) {
-        var _a;
-        let matchingDimension = null;
-        if ((sizeDimensions === null || sizeDimensions === void 0 ? void 0 : sizeDimensions.length) > 0 && (configuration === null || configuration === void 0 ? void 0 : configuration.length) > 0) {
-            for (const sizeDimension of sizeDimensions) {
-                if (!sizeDimension.modifiers) {
-                    // This dimension has no modifiers, so it is the default if none of
-                    // the other specific modifiers match.
-                    matchingDimension = sizeDimension;
-                    console.log('Using default size dimension, no modifiers specified');
-                }
-                else {
-                    const sizeTrailerIndex = configuration.findIndex((c) => sizeTrailer == c);
-                    const isMatch = (_a = sizeDimension.modifiers) === null || _a === void 0 ? void 0 : _a.every((m) => {
-                        if (!m.type) {
-                            return false;
-                        }
-                        switch (m.position) {
-                            case enum_1.RelativePosition.First.toString():
-                                return configuration[0] == m.type;
-                            case enum_1.RelativePosition.Last.toString():
-                                return configuration[configuration.length - 1] == m.type;
-                            case enum_1.RelativePosition.Before.toString():
-                                return configuration[sizeTrailerIndex - 1] == m.type;
-                            case enum_1.RelativePosition.After.toString():
-                                return configuration[sizeTrailerIndex + 1] == m.type;
-                            default:
-                                return false;
-                        }
-                    });
-                    // As soon as we find a dimension with matching modifiers,
-                    // set it and return it.
-                    if (isMatch) {
-                        matchingDimension = sizeDimension;
-                        break;
-                    }
-                }
-            }
-        }
-        else {
-            console.log('Either size dimensions or configuration array is null, no matching dimension returned');
-        }
-        return matchingDimension;
+        return (0, dimensions_helper_1.getSizeDimensionHelper)(this, permitTypeId, commodityId, configuration, regions);
     }
     /**
      * Gets a list of all configured power unit types in the policy definition.
@@ -718,15 +541,31 @@ class Policy {
      */
     getVehicleDefinition(subType) {
         var _a, _b;
-        if (this.policyDefinition.vehicleTypes) {
-            const puType = (_a = this.policyDefinition.vehicleTypes.powerUnitTypes) === null || _a === void 0 ? void 0 : _a.find((pu) => pu.id == subType);
-            if (puType) {
-                return puType;
-            }
-            const trType = (_b = this.policyDefinition.vehicleTypes.trailerTypes) === null || _b === void 0 ? void 0 : _b.find((tr) => tr.id == subType);
-            if (trType) {
-                return trType;
-            }
+        return ((_b = (_a = this.getPowerUnitDefinition(subType)) !== null && _a !== void 0 ? _a : this.getTrailerDefinition(subType)) !== null && _b !== void 0 ? _b : null);
+    }
+    /**
+     * Gets a full PowerUnitType definition by subtype
+     * @param subType string subtype of the power unit to return
+     * @returns PowerUnitType for the supplied subtype
+     */
+    getPowerUnitDefinition(subType) {
+        var _a, _b;
+        const puType = (_b = (_a = this.policyDefinition.vehicleTypes) === null || _a === void 0 ? void 0 : _a.powerUnitTypes) === null || _b === void 0 ? void 0 : _b.find((pu) => pu.id == subType);
+        if (puType) {
+            return puType;
+        }
+        return null;
+    }
+    /**
+     * Gets a full TrailerType definition by subtype
+     * @param subType string subtype of the trailer to return
+     * @returns TrailerType for the supplied subtype
+     */
+    getTrailerDefinition(subType) {
+        var _a, _b;
+        const trType = (_b = (_a = this.policyDefinition.vehicleTypes) === null || _a === void 0 ? void 0 : _a.trailerTypes) === null || _b === void 0 ? void 0 : _b.find((tr) => tr.id == subType);
+        if (trType) {
+            return trType;
         }
         return null;
     }
@@ -792,5 +631,70 @@ class Policy {
         allowedVehicleMap.set(enum_1.VehicleTypes.Trailers, (0, lists_helper_1.extractIdentifiedObjects)(this.policyDefinition.vehicleTypes.trailerTypes, trailerIds));
         return allowedVehicleMap;
     }
+    /**
+     * Gets the default legal and permittable weights for a
+     * given trailer type and number of axles in the trailer axle
+     * unit.
+     * @param subType Trailer subtype
+     * @param axles Number of axles in the trailer axle unit
+     * @returns Array of trailer weights. Multiple trailer
+     * weights may be returned if there are different weights
+     * depending on prior / subsequent vehicles in the
+     * configuration (weight modifiers). Will return an empty array
+     * if the number of axles is not configured in policy.
+     */
+    getDefaultTrailerWeight(subType, axles) {
+        return (0, dimensions_helper_2.getDefaultTrailerWeightHelper)(this, subType, axles);
+    }
+    /**
+     * Gets the default legal and permittable weights for a
+     * given power unit type and number of axles. The number of
+     * axles is supplied as a 2-digit number, with the most
+     * significant digit representing the steer axle unit and the
+     * least significant digit representing the drive axle unit.
+     * @param subType Power unit subtype
+     * @param axles Number of axles in the power unit axle units
+     * @returns Array of power unit weights. Multiple power unit
+     * weights may be returned if there are different weights
+     * depending on prior / subsequent vehicles in the
+     * configuration (weight modifiers). Will return an empty array
+     * if the number of axles is not configured in policy.
+     */
+    getDefaultPowerUnitWeight(subType, axles) {
+        return (0, dimensions_helper_2.getDefaultPowerUnitWeightHelper)(this, subType, axles);
+    }
+    /**
+     * Given a list of default weight dimensions and a vehicle
+     * configuration, select the correct weight dimensions for
+     * the axle unit at the supplied axleIndex. The weight dimensions
+     * may have modifiers (e.g. if a tandem booster follows a tridem
+     * semi trailer) - this method will select the correct weights
+     * to be used for policy checks.
+     * @param weightDimensions Default weight dimensions for the vehicle
+     * at the index indicated by axleIndex
+     * @param configuration Full vehicle configuration
+     * @param axleConfiguration Full axle weights of the vehicle configuration
+     * @param axleIndex Index of the axle unit for which weights are
+     * to be returned.
+     * @returns Single axle dimension representing the legal and permittable
+     * weights for the axle unit at the supplied axleIndex.
+     */
+    selectCorrectWeightDimension(weightDimensions, configuration, axleConfiguration, axleIndex) {
+        return (0, dimensions_helper_1.selectCorrectWeightDimensionHelper)(this, weightDimensions, configuration, axleConfiguration, axleIndex);
+    }
+    /**
+     * Get the list of known standard tire sizes, used to populate
+     * dropdown lists in front-end interfaces.
+     * @returns List of known standard tire sizes, or empty array if
+     * none are configured
+     */
+    getStandardTireSizes() {
+        if (this.policyDefinition.standardTireSizes) {
+            return this.policyDefinition.standardTireSizes;
+        }
+        else {
+            return new Array();
+        }
+    }
 }
 exports.Policy = Policy;

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

@@ -7,3 +7,13 @@ export type DimensionModifier = SelfIssuable & {
     minInterAxleSpacing?: number;
     maxInterAxleSpacing?: number;
 };
+export type VehicleRelatives = {
+    firstType: string;
+    lastType: string;
+    nextType?: string | null;
+    prevType?: string | null;
+    firstCategory?: string | null;
+    lastCategory?: string | null;
+    nextCategory?: string | null;
+    prevCategory?: string | null;
+};

package/dist/types/index.d.ts

@@ -3,10 +3,11 @@ export { BridgeCalculationConstants } from './bridge-calculation-constants';
 export { BridgeCalculationResult } from './bridge-calculation-result';
 export { Commodity, CommoditySize, CommodityWeight } from './commodity';
 export { CostRule } from './cost-rule';
-export { DimensionModifier } from './dimension-modifier';
+export { DimensionModifier, VehicleRelatives } from './dimension-modifier';
 export { PermitFacts } from './facts';
 export { GeographicRegion } from './geographic-region';
 export { IdentifiedObject } from './identified-object';
+export { PermitMailingAddress, PermitContactDetails, PermitVehicleDetails, PermitCommodity, PermitData, PermittedCommodity, VehicleInConfiguration, VehicleConfiguration, PermittedRoute, ManualRoute, PermitApplication, } from './permit-application';
 export { PermitConditionDefinition, ConditionRequirement, ConditionForPermit, } from './permit-condition';
 export { PermitType } from './permit-type';
 export { PolicyDefinition } from './policy-definition';
@@ -15,7 +16,8 @@ export { RegionSizeOverride } from './region-size-override';
 export { SelfIssuable } from './self-issuable';
 export { SizeDimension } from './size-dimension';
 export { SpecialAuthorizations } from './special-authorizations';
+export { StandardTireSize } from './standard-tire-size';
 export { VehicleCategory, PowerUnitCategory, TrailerCategory, VehicleCategories, } from './vehicle-category';
 export { VehicleType, PowerUnitType, TrailerType, VehicleTypes, } from './vehicle-type';
 export { Vehicle, VehicleSizeConfiguration, TrailerSize, PowerUnitWeight, TrailerWeight, } from './vehicle';
-export { WeightDimension, PowerUnitWeightDimension, TrailerWeightDimension, DefaultWeightDimensions, } from './weight-dimension';
+export { WeightDimension, PowerUnitWeightDimension, TrailerWeightDimension, DefaultWeightDimensions, SingleAxleDimension, } from './weight-dimension';

package/dist/types/permit-application.d.ts

@@ -0,0 +1,93 @@
+import { AxleConfiguration } from 'onroute-policy-engine/types';
+export type PermitMailingAddress = {
+    addressLine1: string;
+    addressLine2?: string | null;
+    city: string;
+    provinceCode: string;
+    countryCode: string;
+    postalCode: string;
+};
+export type PermitContactDetails = {
+    firstName: string;
+    lastName: string;
+    phone1: string;
+    phone1Extension?: string | null;
+    phone2?: string | null;
+    phone2Extension?: string | null;
+    email: string;
+    additionalEmail?: string | null;
+    fax?: string | null;
+};
+export type PermitVehicleDetails = {
+    vehicleId?: string | null;
+    unitNumber?: string | null;
+    vin: string;
+    plate: string;
+    make?: string | null;
+    year?: number | null;
+    countryCode: string;
+    provinceCode: string;
+    vehicleType: string;
+    vehicleSubType: string;
+    licensedGVW?: number | null;
+    saveVehicle?: boolean | null;
+};
+export type PermitCommodity = {
+    description: string;
+    condition: string;
+    conditionLink: string;
+    checked: boolean;
+    disabled: boolean;
+};
+export type PermitData = {
+    companyName: string;
+    doingBusinessAs?: string;
+    clientNumber: string;
+    permitDuration: number;
+    commodities: Array<PermitCommodity>;
+    contactDetails: PermitContactDetails;
+    mailingAddress: PermitMailingAddress;
+    vehicleDetails: PermitVehicleDetails;
+    feeSummary?: string | null;
+    startDate: string;
+    expiryDate?: string | null;
+    permittedCommodity?: PermittedCommodity | null;
+    vehicleConfiguration?: VehicleConfiguration | null;
+    permittedRoute?: PermittedRoute | null;
+    applicationNotes?: string | null;
+    thirdPartyLiability?: string | null;
+    conditionalLicensingFee?: string | null;
+};
+export type PermittedCommodity = {
+    commodityType: string;
+    loadDescription: string;
+};
+export type VehicleInConfiguration = {
+    vehicleSubType: string;
+};
+export type VehicleConfiguration = {
+    overallLength?: number;
+    overallWidth?: number;
+    overallHeight?: number;
+    frontProjection?: number;
+    rearProjection?: number;
+    trailers?: Array<VehicleInConfiguration> | null;
+    loadedGVW?: number;
+    netWeight?: number;
+    axleConfiguration?: Array<AxleConfiguration>;
+};
+export type PermittedRoute = {
+    manualRoute?: ManualRoute | null;
+    routeDetails?: string | null;
+};
+export type ManualRoute = {
+    highwaySequence: Array<string>;
+    origin: string;
+    destination: string;
+    exitPoint?: string;
+    totalDistance?: number;
+};
+export type PermitApplication = {
+    permitData: PermitData;
+    permitType: string;
+};

package/dist/types/permit-application.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/policy-definition.d.ts

@@ -1,4 +1,4 @@
-import { GeographicRegion, PermitType, DefaultWeightDimensions, VehicleTypes, Commodity, SizeDimension, VehicleCategories, RangeMatrix, BridgeCalculationConstants, PermitConditionDefinition } from 'onroute-policy-engine/types';
+import { GeographicRegion, PermitType, DefaultWeightDimensions, VehicleTypes, Commodity, SizeDimension, VehicleCategories, RangeMatrix, BridgeCalculationConstants, PermitConditionDefinition, StandardTireSize } from 'onroute-policy-engine/types';
 import { RuleProperties } from 'json-rules-engine';
 export type PolicyDefinition = {
     minPEVersion: string;
@@ -13,4 +13,5 @@ export type PolicyDefinition = {
     rangeMatrices?: Array<RangeMatrix>;
     bridgeCalculationConstants: BridgeCalculationConstants;
     conditions?: Array<PermitConditionDefinition>;
+    standardTireSizes?: Array<StandardTireSize>;
 };

package/dist/types/standard-tire-size.d.ts

@@ -0,0 +1,4 @@
+export type StandardTireSize = {
+    name: string;
+    size: number;
+};

package/dist/types/standard-tire-size.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/vehicle-category.d.ts

@@ -1,6 +1,7 @@
-import { IdentifiedObject, SizeDimension, PowerUnitWeightDimension, TrailerWeightDimension } from 'onroute-policy-engine/types';
+import { IdentifiedObject, SizeDimension, PowerUnitWeightDimension, TrailerWeightDimension, WeightDimension } from 'onroute-policy-engine/types';
 export type VehicleCategory = IdentifiedObject & {
     defaultSizeDimensions?: SizeDimension;
+    defaultWeightDimensions?: Array<WeightDimension>;
 };
 export type PowerUnitCategory = VehicleCategory & {
     defaultWeightDimensions?: Array<PowerUnitWeightDimension>;

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

@@ -1,7 +1,11 @@
 import { DimensionModifier, SelfIssuable } from 'onroute-policy-engine/types';
+export type SingleAxleDimension = {
+    legal?: number;
+    permittable?: number;
+};
 export type WeightDimension = SelfIssuable & {
     axles: number;
-    modifiers?: Array<DimensionModifier>;
+    modifier?: DimensionModifier;
 };
 export type PowerUnitWeightDimension = WeightDimension & {
     saLegal?: number;
@@ -9,10 +13,7 @@ export type PowerUnitWeightDimension = WeightDimension & {
     daLegal?: number;
     daPermittable?: number;
 };
-export type TrailerWeightDimension = WeightDimension & {
-    legal?: number;
-    permittable?: number;
-};
+export type TrailerWeightDimension = WeightDimension & SingleAxleDimension;
 export type DefaultWeightDimensions = {
     powerUnits: Array<PowerUnitWeightDimension>;
     trailers: Array<TrailerWeightDimension>;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "v1.7.0";
+export declare const version = "v1.8.1";

package/dist/version.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = void 0;
 // Generated by genversion.
-exports.version = 'v1.7.0';
+exports.version = 'v1.8.1';

package/package.json

@@ -89,5 +89,5 @@
     ],
     "testEnvironment": "node"
   },
-  "version": "v1.7.0"
+  "version": "v1.8.1"
 }