onroute-policy-engine 2.1.1 → 2.2.0

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

@@ -1,10 +1,28 @@
+/**
+ * Permit Condition Types
+ *
+ * Defines the structure for permit conditions and requirements that must be met
+ * for permit approval and compliance.
+ */
 export type PermitConditionDefinition = {
+    /** Human-readable description of the condition */
     description: string;
+    /** Specific condition text that must be met */
     condition: string;
+    /** Link to detailed condition information */
     conditionLink: string;
 };
+/**
+ * Requirement for a permit condition including mandatory status
+ */
 export type ConditionRequirement = {
+    /** The condition text that must be satisfied */
     condition: string;
+    /** Whether this condition is mandatory for permit approval */
     mandatory?: boolean;
 };
+/**
+ * Complete permit condition combining definition and requirement
+ * Extends PermitConditionDefinition with requirement details
+ */
 export type ConditionForPermit = PermitConditionDefinition & ConditionRequirement;

package/dist/types/permit-condition.js

@@ -1,2 +1,8 @@
 "use strict";
+/**
+ * Permit Condition Types
+ *
+ * Defines the structure for permit conditions and requirements that must be met
+ * for permit approval and compliance.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,13 +1,31 @@
+/**
+ * Permit Type
+ *
+ * Defines the structure for permit types including requirements, allowed vehicles,
+ * commodities, rules, and conditions. Extends IdentifiedObject with permit-specific properties.
+ */
 import { RuleProperties } from 'json-rules-engine';
 import { CostRule, IdentifiedObject, ConditionRequirement } from 'onroute-policy-engine/types';
+/**
+ * Complete definition of a permit type with all requirements and configurations
+ */
 export type PermitType = IdentifiedObject & {
+    /** Whether routing information is required for this permit type */
     routingRequired: boolean;
+    /** Whether weight dimension information is required for this permit type */
     weightDimensionRequired: boolean;
+    /** Whether size dimension information is required for this permit type */
     sizeDimensionRequired: boolean;
+    /** Whether commodity information is required for this permit type */
     commodityRequired: boolean;
+    /** Array of allowed vehicle types for this permit (optional) */
     allowedVehicles?: Array<string>;
+    /** Array of allowed commodities for this permit (optional) */
     allowedCommodities?: Array<string>;
+    /** Array of validation rules for this permit type (optional) */
     rules?: Array<RuleProperties>;
+    /** Array of cost calculation rules for this permit type (optional) */
     costRules?: Array<CostRule>;
+    /** Array of conditions that must be met for this permit type (optional) */
     conditions?: Array<ConditionRequirement>;
 };

package/dist/types/permit-type.js

@@ -1,2 +1,8 @@
 "use strict";
+/**
+ * Permit Type
+ *
+ * Defines the structure for permit types including requirements, allowed vehicles,
+ * commodities, rules, and conditions. Extends IdentifiedObject with permit-specific properties.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,18 +1,42 @@
+/**
+ * Policy Definition Type
+ *
+ * Defines the complete structure for policy definitions including geographic regions,
+ * permit types, rules, defaults, and configurations. This is the main configuration
+ * type for the policy engine.
+ */
 import { GeographicRegion, PermitType, DefaultWeightDimensions, VehicleTypes, Commodity, SizeDimension, VehicleCategories, RangeMatrix, BridgeCalculationConstants, PermitConditionDefinition, StandardTireSize, VehicleDisplayCodeDefaults } from 'onroute-policy-engine/types';
 import { RuleProperties } from 'json-rules-engine';
+/**
+ * Complete policy definition containing all configuration data for the policy engine
+ */
 export type PolicyDefinition = {
+    /** Minimum required policy engine version for compatibility */
     minPEVersion: string;
+    /** Array of geographic regions having specific policy rules */
     geographicRegions: Array<GeographicRegion>;
+    /** Array of permit types available in this policy */
     permitTypes: Array<PermitType>;
+    /** Array of common rules that apply to all permits */
     commonRules: Array<RuleProperties>;
+    /** Global default weight dimensions for vehicles */
     globalWeightDefaults: DefaultWeightDimensions;
+    /** Global default size dimensions for vehicles */
     globalSizeDefaults: SizeDimension;
+    /** Vehicle categories configuration */
     vehicleCategories: VehicleCategories;
+    /** Vehicle types configuration */
     vehicleTypes: VehicleTypes;
+    /** Array of commodities that can be transported */
     commodities: Array<Commodity>;
+    /** Array of range matrices for cost calculations (optional) */
     rangeMatrices?: Array<RangeMatrix>;
+    /** Constants for bridge formula calculations */
     bridgeCalculationConstants: BridgeCalculationConstants;
+    /** Array of permit conditions (optional) */
     conditions?: Array<PermitConditionDefinition>;
+    /** Array of standard tire sizes (optional) */
     standardTireSizes?: Array<StandardTireSize>;
+    /** Default configuration for vehicle display codes (optional) */
     vehicleDisplayCodeDefaults?: VehicleDisplayCodeDefaults;
 };

package/dist/types/policy-definition.js

@@ -1,2 +1,9 @@
 "use strict";
+/**
+ * Policy Definition Type
+ *
+ * Defines the complete structure for policy definitions including geographic regions,
+ * permit types, rules, defaults, and configurations. This is the main configuration
+ * type for the policy engine.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/range-matrix.d.ts

@@ -1,9 +1,26 @@
+/**
+ * Range Matrix Types
+ *
+ * Defines structures for range-based calculations and lookups used in cost
+ * calculations and other policy determinations.
+ */
 import { IdentifiedObject } from 'onroute-policy-engine/types';
+/**
+ * A range matrix containing multiple matrix entries for lookups
+ * Extends IdentifiedObject with matrix data
+ */
 export type RangeMatrix = IdentifiedObject & {
+    /** Array of matrix entries for range-based lookups */
     matrix: Matrix[];
 };
+/**
+ * Individual matrix entry with range and value
+ */
 export type Matrix = {
+    /** Minimum value for the range (optional) */
     min?: number;
+    /** Maximum value for the range (optional) */
     max?: number;
+    /** Value associated with this range */
     value: number;
 };

package/dist/types/range-matrix.js

@@ -1,2 +1,8 @@
 "use strict";
+/**
+ * Range Matrix Types
+ *
+ * Defines structures for range-based calculations and lookups used in cost
+ * calculations and other policy determinations.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/region-size-override.d.ts

@@ -1,6 +1,16 @@
+/**
+ * Region Size Override Type
+ *
+ * Defines size dimension overrides for specific geographic regions.
+ * Used to apply region-specific size limits and requirements.
+ */
 export type RegionSizeOverride = {
+    /** Geographic region identifier */
     region: string;
+    /** Width override in meters (optional) */
     w?: number;
+    /** Height override in meters (optional) */
     h?: number;
+    /** Length override in meters (optional) */
     l?: number;
 };

package/dist/types/region-size-override.js

@@ -1,2 +1,8 @@
 "use strict";
+/**
+ * Region Size Override Type
+ *
+ * Defines size dimension overrides for specific geographic regions.
+ * Used to apply region-specific size limits and requirements.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/self-issuable.d.ts

@@ -1,3 +1,10 @@
+/**
+ * Self Issuable Type
+ *
+ * Defines the capability for self-issuance of permits or other documents.
+ * Used as a base type for objects that can be self-issued.
+ */
 export type SelfIssuable = {
+    /** Whether this object can be self-issued */
     selfIssue?: boolean;
 };

package/dist/types/self-issuable.js

@@ -1,2 +1,8 @@
 "use strict";
+/**
+ * Self Issuable Type
+ *
+ * Defines the capability for self-issuance of permits or other documents.
+ * Used as a base type for objects that can be self-issued.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,10 +1,27 @@
+/**
+ * Size Dimension Type
+ *
+ * Defines the structure for vehicle size dimensions including length, width, height,
+ * projections, and regional overrides. Extends SelfIssuable for self-issuance capability.
+ */
 import { DimensionModifier, RegionSizeOverride, SelfIssuable } from 'onroute-policy-engine/types';
+/**
+ * Complete size dimension configuration for vehicles
+ * Extends SelfIssuable to include self-issuance capability
+ */
 export type SizeDimension = SelfIssuable & {
+    /** Front projection in meters (optional) */
     fp?: number;
+    /** Rear projection in meters (optional) */
     rp?: number;
+    /** Width in meters (optional) */
     w?: number;
+    /** Height in meters (optional) */
     h?: number;
+    /** Length in meters (optional) */
     l?: number;
+    /** Array of dimension modifiers for special configurations (optional) */
     modifiers?: Array<DimensionModifier>;
+    /** Array of regional size overrides (optional) */
     regions?: Array<RegionSizeOverride>;
 };

package/dist/types/size-dimension.js

@@ -1,2 +1,8 @@
 "use strict";
+/**
+ * Size Dimension Type
+ *
+ * Defines the structure for vehicle size dimensions including length, width, height,
+ * projections, and regional overrides. Extends SelfIssuable for self-issuance capability.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/special-authorizations.d.ts

@@ -1,5 +1,14 @@
+/**
+ * Special Authorizations Type
+ *
+ * Defines special authorizations and exemptions for companies including
+ * LCV (Long Combination Vehicle) allowances and fee exemptions.
+ */
 export type SpecialAuthorizations = {
+    /** Company identifier */
     companyId: number;
+    /** Whether LCV (Long Combination Vehicle) operations are allowed */
     isLcvAllowed: boolean;
+    /** Type of fee exemption if applicable, null if no exemption */
     noFeeType: string | null;
 };

package/dist/types/special-authorizations.js

@@ -1,2 +1,8 @@
 "use strict";
+/**
+ * Special Authorizations Type
+ *
+ * Defines special authorizations and exemptions for companies including
+ * LCV (Long Combination Vehicle) allowances and fee exemptions.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,4 +1,12 @@
+/**
+ * Standard Tire Size Type
+ *
+ * Defines the structure for standard tire sizes used in vehicle configurations
+ * and axle calculations.
+ */
 export type StandardTireSize = {
+    /** Name of the tire size (e.g., '11R22.5') */
     name: string;
+    /** Tire size in inches (e.g., 22.5 for 11R22.5) */
     size: number;
 };

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

@@ -1,2 +1,8 @@
 "use strict";
+/**
+ * Standard Tire Size Type
+ *
+ * Defines the structure for standard tire sizes used in vehicle configurations
+ * and axle calculations.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,15 +1,42 @@
+/**
+ * Vehicle Category Types
+ *
+ * Defines the structure for vehicle categories including power units and trailers.
+ * Extends IdentifiedObject with size and weight dimension defaults.
+ */
 import { IdentifiedObject, SizeDimension, PowerUnitWeightDimension, TrailerWeightDimension, WeightDimension } from 'onroute-policy-engine/types';
+/**
+ * Base vehicle category with identification and default dimensions
+ * Extends IdentifiedObject with dimension defaults
+ */
 export type VehicleCategory = IdentifiedObject & {
+    /** Default size dimensions for this vehicle category (optional) */
     defaultSizeDimensions?: SizeDimension;
+    /** Default weight dimensions for this vehicle category (optional) */
     defaultWeightDimensions?: Array<WeightDimension>;
 };
+/**
+ * Power unit category with power unit specific weight dimensions
+ * Extends VehicleCategory with power unit weight defaults
+ */
 export type PowerUnitCategory = VehicleCategory & {
+    /** Default weight dimensions specific to power units (optional) */
     defaultWeightDimensions?: Array<PowerUnitWeightDimension>;
 };
+/**
+ * Trailer category with trailer specific weight dimensions
+ * Extends VehicleCategory with trailer weight defaults
+ */
 export type TrailerCategory = VehicleCategory & {
+    /** Default weight dimensions specific to trailers (optional) */
     defaultWeightDimensions?: Array<TrailerWeightDimension>;
 };
+/**
+ * Complete vehicle categories configuration
+ */
 export type VehicleCategories = {
+    /** Array of power unit categories */
     powerUnitCategories: Array<PowerUnitCategory>;
+    /** Array of trailer categories */
     trailerCategories: Array<TrailerCategory>;
 };

package/dist/types/vehicle-category.js

@@ -1,2 +1,8 @@
 "use strict";
+/**
+ * Vehicle Category Types
+ *
+ * Defines the structure for vehicle categories including power units and trailers.
+ * Extends IdentifiedObject with size and weight dimension defaults.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,24 +1,60 @@
+/**
+ * Vehicle Type Types
+ *
+ * Defines the structure for vehicle types including power units and trailers.
+ * Extends IdentifiedObject with category, dimensions, and special configurations.
+ */
 import { ConditionRequirement, IdentifiedObject, SizeDimension, PowerUnitWeightDimension, TrailerWeightDimension } from 'onroute-policy-engine/types';
+/**
+ * Base vehicle type with identification and configuration options
+ * Extends IdentifiedObject with vehicle-specific properties
+ */
 export type VehicleType = IdentifiedObject & {
+    /** Category identifier for this vehicle type */
     category: string;
+    /** Default size dimensions for this vehicle type (optional) */
     defaultSizeDimensions?: SizeDimension;
+    /** Whether to ignore this vehicle type for size dimension calculations (optional) */
     ignoreForSizeDimensions?: boolean;
+    /** Whether to ignore this vehicle type for axle calculations (optional) */
     ignoreForAxleCalculation?: boolean;
+    /** Whether this vehicle type is an LCV (Long Combination Vehicle) (optional) */
     isLcv?: boolean;
+    /** Array of conditions required for this vehicle type (optional) */
     conditions?: Array<ConditionRequirement>;
+    /** Additional axle subtype identifier (optional) */
     additionalAxleSubType?: string;
 };
+/**
+ * Power unit type with power unit specific configurations
+ * Extends VehicleType with power unit specific properties
+ */
 export type PowerUnitType = VehicleType & {
+    /** Default weight dimensions specific to power units (optional) */
     defaultWeightDimensions?: Array<PowerUnitWeightDimension>;
+    /** Display code prefix for this power unit type (optional) */
     displayCodePrefix?: string;
+    /** Display code for steer axle (optional) */
     displayCodeSteerAxle?: string;
+    /** Display code for drive axle (optional) */
     displayCodeDriveAxle?: string;
 };
+/**
+ * Trailer type with trailer specific configurations
+ * Extends VehicleType with trailer specific properties
+ */
 export type TrailerType = VehicleType & {
+    /** Default weight dimensions specific to trailers (optional) */
     defaultWeightDimensions?: Array<TrailerWeightDimension>;
+    /** Display code for this trailer type (optional) */
     displayCode?: string;
 };
+/**
+ * Complete vehicle types configuration
+ */
 export type VehicleTypes = {
+    /** Array of power unit types */
     powerUnitTypes: Array<PowerUnitType>;
+    /** Array of trailer types */
     trailerTypes: Array<TrailerType>;
 };

package/dist/types/vehicle-type.js

@@ -1,2 +1,8 @@
 "use strict";
+/**
+ * Vehicle Type Types
+ *
+ * Defines the structure for vehicle types including power units and trailers.
+ * Extends IdentifiedObject with category, dimensions, and special configurations.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/vehicle.d.ts

@@ -1,16 +1,43 @@
+/**
+ * Vehicle Types
+ *
+ * Defines the structure for vehicles including power units and trailers.
+ * Extends SelfIssuable for self-issuance capability and includes dimension configurations.
+ */
 import { SelfIssuable, SizeDimension, PowerUnitWeightDimension, TrailerWeightDimension } from 'onroute-policy-engine/types';
+/**
+ * Base vehicle with type identification and self-issuance capability
+ * Extends SelfIssuable to include self-issuance capability
+ */
 export type Vehicle = SelfIssuable & {
+    /** Type identifier for this vehicle */
     type: string;
 };
+/**
+ * Power unit with trailer configuration and weight dimensions
+ * Extends Vehicle with trailer and weight dimension arrays
+ */
 export type VehicleDimensions = Vehicle & {
+    /** Array of trailers attached to this power unit */
     trailers: Array<TrailerDimensions>;
+    /** Array of weight dimensions for this power unit (optional) */
     weightDimensions?: Array<PowerUnitWeightDimension>;
 };
+/**
+ * Trailer with booster/jeep configuration and dimension capabilities
+ * Extends Vehicle with trailer-specific properties
+ */
 export type TrailerDimensions = Vehicle & {
+    /** Whether this trailer is allowed a booster */
     booster: boolean;
+    /** Whether this trailer is allowed a jeep */
     jeep: boolean;
+    /** Array of size dimensions for this trailer (optional) */
     sizeDimensions?: Array<SizeDimension>;
+    /** Whether size is permittable for this trailer (optional) */
     sizePermittable?: boolean;
+    /** Array of weight dimensions for this trailer (optional) */
     weightDimensions?: Array<TrailerWeightDimension>;
+    /** Whether weight is permittable for this trailer (optional) */
     weightPermittable?: boolean;
 };

package/dist/types/vehicle.js

@@ -1,2 +1,8 @@
 "use strict";
+/**
+ * Vehicle Types
+ *
+ * Defines the structure for vehicles including power units and trailers.
+ * Extends SelfIssuable for self-issuance capability and includes dimension configurations.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,20 +1,54 @@
+/**
+ * Weight Dimension Types
+ *
+ * Defines the structure for weight dimensions including single axles, power units,
+ * and trailers. Extends SelfIssuable for self-issuance capability.
+ */
 import { DimensionModifier, SelfIssuable } from 'onroute-policy-engine/types';
+/**
+ * Weight limits for a single axle unit
+ */
 export type SingleAxleDimension = {
+    /** Legal weight limit in kilograms (optional) */
     legal?: number;
+    /** Permittable weight limit in kilograms (optional) */
     permittable?: number;
 };
+/**
+ * Base weight dimension with axle count and modifier
+ * Extends SelfIssuable to include self-issuance capability
+ */
 export type WeightDimension = SelfIssuable & {
+    /** Number of axles applicable to this weight dimension */
     axles: number;
+    /** Dimension modifier for special configurations (optional) */
     modifier?: DimensionModifier;
 };
+/**
+ * Weight dimension specific to power units with steer and drive axle limits
+ * Extends WeightDimension with power unit specific weight limits
+ */
 export type PowerUnitWeightDimension = WeightDimension & {
+    /** Single axle legal weight limit in kilograms (optional) */
     saLegal?: number;
+    /** Single axle permittable weight limit in kilograms (optional) */
     saPermittable?: number;
+    /** Drive axle legal weight limit in kilograms (optional) */
     daLegal?: number;
+    /** Drive axle permittable weight limit in kilograms (optional) */
     daPermittable?: number;
 };
+/**
+ * Weight dimension specific to trailers
+ * Extends WeightDimension with single axle dimension limits
+ */
 export type TrailerWeightDimension = WeightDimension & SingleAxleDimension;
+/**
+ * Default weight dimensions for all vehicle types
+ */
 export type DefaultWeightDimensions = {
+    /** Array of power unit weight dimensions */
     powerUnits: Array<PowerUnitWeightDimension>;
+    /** Array of trailer weight dimensions */
     trailers: Array<TrailerWeightDimension>;
 };

package/dist/types/weight-dimension.js

@@ -1,2 +1,8 @@
 "use strict";
+/**
+ * Weight Dimension Types
+ *
+ * Defines the structure for weight dimensions including single axles, power units,
+ * and trailers. Extends SelfIssuable for self-issuance capability.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/validation-result.d.ts

@@ -17,4 +17,5 @@ export declare class ValidationResult {
     message: string;
     fieldReference?: string;
     cost?: number;
+    details?: Array<string>;
 }

package/dist/validation-results.js

@@ -36,13 +36,14 @@ class ValidationResults {
         this.cost = [];
         if (engineResult) {
             engineResult.events.forEach((e) => {
-                var _a, _b, _c, _d, _e, _f, _g;
+                var _a, _b, _c, _d, _e, _f, _g, _h;
                 const message = (_b = (_a = e.params) === null || _a === void 0 ? void 0 : _a.message) !== null && _b !== void 0 ? _b : `Unknown message: params=${JSON.stringify(e.params)}`;
                 const code = (_d = (_c = e.params) === null || _c === void 0 ? void 0 : _c.code) !== null && _d !== void 0 ? _d : validation_result_code_1.ValidationResultCode.GeneralResult;
                 const type = (_e = e.type) !== null && _e !== void 0 ? _e : validation_result_type_1.ValidationResultType.Violation.toString();
                 const result = new validation_result_1.ValidationResult(type, code, message);
                 result.fieldReference = (_f = e.params) === null || _f === void 0 ? void 0 : _f.fieldReference;
                 result.cost = (_g = e.params) === null || _g === void 0 ? void 0 : _g.cost;
+                result.details = (_h = e.params) === null || _h === void 0 ? void 0 : _h.details;
                 switch (type) {
                     case validation_result_type_1.ValidationResultType.Violation:
                         this.violations.push(result);

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "v2.1.1";
+export declare const version = "v2.2.0";

package/dist/version.js

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

package/package.json

@@ -84,11 +84,12 @@
     "coveragePathIgnorePatterns": [
       "/node_modules/",
       "/src/_test/",
+      "/src/_examples/",
       ".enum.ts",
       ".interface.ts",
       "index.ts"
     ],
     "testEnvironment": "node"
   },
-  "version": "v2.1.1"
+  "version": "v2.2.0"
 }