sgerp-frontend-lib 0.1.1 → 0.1.3

package/dist/sgerp/constants/bulkoperations-enums.js

@@ -0,0 +1,99 @@
+"use strict";
+/**
+ * Bulk Operations Enums
+ * Ported from ~/dev/sgerp/bulkoperations/enums.py
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VehicleUseOptionLabels = exports.VehicleUseOption = exports.InvalidVehicleUploadInfoTypeLabels = exports.InvalidVehicleUploadInfoType = exports.BulkTaskTypeLabels = exports.BulkTaskType = exports.BulkTaskStatusLabels = exports.BulkTaskStatus = exports.BulkTaskExecutionModeLabels = exports.BulkTaskExecutionMode = void 0;
+/**
+ * Bulk task execution mode
+ * From bulkoperations.enums.BulkTaskExecutionMode
+ */
+exports.BulkTaskExecutionMode = {
+    SYNC: 'sync',
+    ASYNC: 'async',
+};
+exports.BulkTaskExecutionModeLabels = {
+    [exports.BulkTaskExecutionMode.SYNC]: 'enum.bulk_task_execution_mode.sync',
+    [exports.BulkTaskExecutionMode.ASYNC]: 'enum.bulk_task_execution_mode.async',
+};
+/**
+ * Bulk task status
+ * From bulkoperations.enums.BulkTaskStatus
+ */
+exports.BulkTaskStatus = {
+    PENDING: 'pending',
+    PROCESSING: 'processing',
+    COMPLETED: 'completed',
+    FAILED: 'failed',
+};
+exports.BulkTaskStatusLabels = {
+    [exports.BulkTaskStatus.PENDING]: 'enum.bulk_task_status.pending',
+    [exports.BulkTaskStatus.PROCESSING]: 'enum.bulk_task_status.processing',
+    [exports.BulkTaskStatus.COMPLETED]: 'enum.bulk_task_status.completed',
+    [exports.BulkTaskStatus.FAILED]: 'enum.bulk_task_status.failed',
+};
+/**
+ * Bulk task type
+ * From bulkoperations.enums.BulkTaskType
+ */
+exports.BulkTaskType = {
+    ADD: 'add',
+    PASSENGER_UPLOAD: 'passengers_upload',
+    VEHICLE_UPLOAD: 'vehicle_upload',
+    VEHICLE_COPY: 'vehicle_copy',
+    TRUCKR_EXPORT_VEHICLES: 'truckr_export_vehicles',
+    BOOKING_UPDATE: 'booking_update',
+    VEHICLE_UPDATE: 'vehicle_update',
+};
+exports.BulkTaskTypeLabels = {
+    [exports.BulkTaskType.ADD]: 'enum.bulk_task_type.add',
+    [exports.BulkTaskType.PASSENGER_UPLOAD]: 'enum.bulk_task_type.passenger_upload',
+    [exports.BulkTaskType.VEHICLE_UPLOAD]: 'enum.bulk_task_type.vehicle_upload',
+    [exports.BulkTaskType.VEHICLE_COPY]: 'enum.bulk_task_type.vehicle_copy',
+    [exports.BulkTaskType.TRUCKR_EXPORT_VEHICLES]: 'enum.bulk_task_type.truckr_export_vehicles',
+    [exports.BulkTaskType.BOOKING_UPDATE]: 'enum.bulk_task_type.booking_update',
+    [exports.BulkTaskType.VEHICLE_UPDATE]: 'enum.bulk_task_type.vehicle_update',
+};
+/**
+ * Invalid vehicle upload info types
+ * From messages.bulkoperations.InvalidVehicleUploadInfoType
+ */
+exports.InvalidVehicleUploadInfoType = {
+    INVALID_SIMULATION_TEMPLATE: 'invalid_simulation_template',
+    INVALID_SIMULATION_DATE: 'invalid_simulation_date',
+    INVALID_SIMULATION: 'invalid_simulation',
+    CONFLICTING_SIMULATIONS_FOR_TEMPLATE: 'conflicting_simulations_for_template',
+    VEHICLE_OVERLAP: 'vehicle_overlap',
+    INVALID_DRIVER_ID: 'invalid_driver_id',
+    INVALID_DRIVER_USERNAME: 'invalid_driver_username',
+    INVALID_VEHICLE_TYPE: 'invalid_vehicle_type',
+    INVALID_START_END_LOCATION_ID: 'invalid_start_and_end_location_id',
+    INVALID_DRIVER_ORGANIZATION: 'invalid_organization_for_driver',
+    INVALID_PERMISSIONS_DRIVER_ASSIGNMENT: 'invalid_permissions_organization_for_driver_assignment',
+};
+exports.InvalidVehicleUploadInfoTypeLabels = {
+    [exports.InvalidVehicleUploadInfoType.INVALID_SIMULATION_TEMPLATE]: 'enum.invalid_vehicle_upload_info_type.invalid_simulation_template',
+    [exports.InvalidVehicleUploadInfoType.INVALID_SIMULATION_DATE]: 'enum.invalid_vehicle_upload_info_type.invalid_simulation_date',
+    [exports.InvalidVehicleUploadInfoType.INVALID_SIMULATION]: 'enum.invalid_vehicle_upload_info_type.invalid_simulation',
+    [exports.InvalidVehicleUploadInfoType.CONFLICTING_SIMULATIONS_FOR_TEMPLATE]: 'enum.invalid_vehicle_upload_info_type.conflicting_simulations_for_template',
+    [exports.InvalidVehicleUploadInfoType.VEHICLE_OVERLAP]: 'enum.invalid_vehicle_upload_info_type.vehicle_overlap',
+    [exports.InvalidVehicleUploadInfoType.INVALID_DRIVER_ID]: 'enum.invalid_vehicle_upload_info_type.invalid_driver_id',
+    [exports.InvalidVehicleUploadInfoType.INVALID_DRIVER_USERNAME]: 'enum.invalid_vehicle_upload_info_type.invalid_driver_username',
+    [exports.InvalidVehicleUploadInfoType.INVALID_VEHICLE_TYPE]: 'enum.invalid_vehicle_upload_info_type.invalid_vehicle_type',
+    [exports.InvalidVehicleUploadInfoType.INVALID_START_END_LOCATION_ID]: 'enum.invalid_vehicle_upload_info_type.invalid_start_end_location_id',
+    [exports.InvalidVehicleUploadInfoType.INVALID_DRIVER_ORGANIZATION]: 'enum.invalid_vehicle_upload_info_type.invalid_driver_organization',
+    [exports.InvalidVehicleUploadInfoType.INVALID_PERMISSIONS_DRIVER_ASSIGNMENT]: 'enum.invalid_vehicle_upload_info_type.invalid_permissions_driver_assignment',
+};
+/**
+ * Vehicle use option
+ * From simulation.agents.enums.VehicleUseOption
+ */
+exports.VehicleUseOption = {
+    ENABLED: 'enabled',
+    DISABLED: 'disabled',
+};
+exports.VehicleUseOptionLabels = {
+    [exports.VehicleUseOption.ENABLED]: 'enum.vehicle_use_option.enabled',
+    [exports.VehicleUseOption.DISABLED]: 'enum.vehicle_use_option.disabled',
+};

package/dist/sgerp/constants/messages-enums.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Messages Enums
+ * Ported from ~/dev/sgerp/messages/enums.py
+ */
+export declare const GeofenceDefinitionStrategy: {
+    readonly BY_DROPOFF: "by_dropoff";
+    readonly BY_PICKUP: "by_pickup";
+    readonly INDEPENDENT: "independent";
+    readonly MIXED: "mixed";
+};
+export type GeofenceDefinitionStrategyValue = typeof GeofenceDefinitionStrategy[keyof typeof GeofenceDefinitionStrategy];
+export declare const GeofenceDefinitionStrategyLabels: Record<GeofenceDefinitionStrategyValue, string>;
+export declare const GeofenceVehicleAllocationStrategy: {
+    readonly STRICT: "strict";
+    readonly FLEXIBLE: "flexible";
+};
+export type GeofenceVehicleAllocationStrategyValue = typeof GeofenceVehicleAllocationStrategy[keyof typeof GeofenceVehicleAllocationStrategy];
+export declare const GeofenceVehicleAllocationStrategyLabels: Record<GeofenceVehicleAllocationStrategyValue, string>;
+export declare const TruckBanStrategy: {
+    readonly DEFAULT: "default";
+    readonly DUPLICATE_NODES: "duplicate_nodes";
+};
+export type TruckBanStrategyValue = typeof TruckBanStrategy[keyof typeof TruckBanStrategy];
+export declare const TruckBanStrategyLabels: Record<TruckBanStrategyValue, string>;
+export declare const BookingOrderPrioritization: {
+    readonly DISABLED: "disabled";
+    readonly STRICT: "strict";
+    readonly NON_STRICT: "non_strict";
+};
+export type BookingOrderPrioritizationValue = typeof BookingOrderPrioritization[keyof typeof BookingOrderPrioritization];
+export declare const BookingOrderPrioritizationLabels: Record<BookingOrderPrioritizationValue, string>;
+export declare const NodeGroupingCapacityStrategy: {
+    readonly MIN: "min";
+    readonly MAX: "max";
+    readonly MEDIAN: "median";
+    readonly MEAN: "mean";
+    readonly IGNORE: "ignore";
+};
+export type NodeGroupingCapacityStrategyValue = typeof NodeGroupingCapacityStrategy[keyof typeof NodeGroupingCapacityStrategy];
+export declare const NodeGroupingCapacityStrategyLabels: Record<NodeGroupingCapacityStrategyValue, string>;
+export declare const ManualEditApiSolverKind: {
+    readonly LOCAL: "local";
+    readonly REMOTE: "remote";
+};
+export type ManualEditApiSolverKindValue = typeof ManualEditApiSolverKind[keyof typeof ManualEditApiSolverKind];
+export declare const ManualEditApiSolverKindLabels: Record<ManualEditApiSolverKindValue, string>;
+//# sourceMappingURL=messages-enums.d.ts.map

package/dist/sgerp/constants/messages-enums.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages-enums.d.ts","sourceRoot":"","sources":["../../../sgerplib/sgerp/constants/messages-enums.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,0BAA0B;;;;;CAK7B,CAAC;AAEX,MAAM,MAAM,+BAA+B,GAAG,OAAO,0BAA0B,CAAC,MAAM,OAAO,0BAA0B,CAAC,CAAC;AAEzH,eAAO,MAAM,gCAAgC,EAAE,MAAM,CAAC,+BAA+B,EAAE,MAAM,CAK5F,CAAC;AAEF,eAAO,MAAM,iCAAiC;;;CAGpC,CAAC;AAEX,MAAM,MAAM,sCAAsC,GAAG,OAAO,iCAAiC,CAAC,MAAM,OAAO,iCAAiC,CAAC,CAAC;AAE9I,eAAO,MAAM,uCAAuC,EAAE,MAAM,CAAC,sCAAsC,EAAE,MAAM,CAG1G,CAAC;AAEF,eAAO,MAAM,gBAAgB;;;CAGnB,CAAC;AAEX,MAAM,MAAM,qBAAqB,GAAG,OAAO,gBAAgB,CAAC,MAAM,OAAO,gBAAgB,CAAC,CAAC;AAE3F,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,qBAAqB,EAAE,MAAM,CAGxE,CAAC;AAEF,eAAO,MAAM,0BAA0B;;;;CAI7B,CAAC;AAEX,MAAM,MAAM,+BAA+B,GAAG,OAAO,0BAA0B,CAAC,MAAM,OAAO,0BAA0B,CAAC,CAAC;AAEzH,eAAO,MAAM,gCAAgC,EAAE,MAAM,CAAC,+BAA+B,EAAE,MAAM,CAI5F,CAAC;AAEF,eAAO,MAAM,4BAA4B;;;;;;CAM/B,CAAC;AAEX,MAAM,MAAM,iCAAiC,GAAG,OAAO,4BAA4B,CAAC,MAAM,OAAO,4BAA4B,CAAC,CAAC;AAE/H,eAAO,MAAM,kCAAkC,EAAE,MAAM,CAAC,iCAAiC,EAAE,MAAM,CAMhG,CAAC;AAEF,eAAO,MAAM,uBAAuB;;;CAG1B,CAAC;AAEX,MAAM,MAAM,4BAA4B,GAAG,OAAO,uBAAuB,CAAC,MAAM,OAAO,uBAAuB,CAAC,CAAC;AAEhH,eAAO,MAAM,6BAA6B,EAAE,MAAM,CAAC,4BAA4B,EAAE,MAAM,CAGtF,CAAC"}

package/dist/sgerp/constants/messages-enums.js

@@ -0,0 +1,67 @@
+"use strict";
+/**
+ * Messages Enums
+ * Ported from ~/dev/sgerp/messages/enums.py
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManualEditApiSolverKindLabels = exports.ManualEditApiSolverKind = exports.NodeGroupingCapacityStrategyLabels = exports.NodeGroupingCapacityStrategy = exports.BookingOrderPrioritizationLabels = exports.BookingOrderPrioritization = exports.TruckBanStrategyLabels = exports.TruckBanStrategy = exports.GeofenceVehicleAllocationStrategyLabels = exports.GeofenceVehicleAllocationStrategy = exports.GeofenceDefinitionStrategyLabels = exports.GeofenceDefinitionStrategy = void 0;
+exports.GeofenceDefinitionStrategy = {
+    BY_DROPOFF: 'by_dropoff',
+    BY_PICKUP: 'by_pickup',
+    INDEPENDENT: 'independent',
+    MIXED: 'mixed',
+};
+exports.GeofenceDefinitionStrategyLabels = {
+    [exports.GeofenceDefinitionStrategy.BY_DROPOFF]: 'enum.geofence_definition_strategy.by_dropoff',
+    [exports.GeofenceDefinitionStrategy.BY_PICKUP]: 'enum.geofence_definition_strategy.by_pickup',
+    [exports.GeofenceDefinitionStrategy.INDEPENDENT]: 'enum.geofence_definition_strategy.independent',
+    [exports.GeofenceDefinitionStrategy.MIXED]: 'enum.geofence_definition_strategy.mixed',
+};
+exports.GeofenceVehicleAllocationStrategy = {
+    STRICT: 'strict',
+    FLEXIBLE: 'flexible',
+};
+exports.GeofenceVehicleAllocationStrategyLabels = {
+    [exports.GeofenceVehicleAllocationStrategy.STRICT]: 'enum.geofence_vehicle_allocation_strategy.strict',
+    [exports.GeofenceVehicleAllocationStrategy.FLEXIBLE]: 'enum.geofence_vehicle_allocation_strategy.flexible',
+};
+exports.TruckBanStrategy = {
+    DEFAULT: 'default',
+    DUPLICATE_NODES: 'duplicate_nodes',
+};
+exports.TruckBanStrategyLabels = {
+    [exports.TruckBanStrategy.DEFAULT]: 'enum.truckban_strategy.default',
+    [exports.TruckBanStrategy.DUPLICATE_NODES]: 'enum.truckban_strategy.duplicate_nodes',
+};
+exports.BookingOrderPrioritization = {
+    DISABLED: 'disabled',
+    STRICT: 'strict',
+    NON_STRICT: 'non_strict',
+};
+exports.BookingOrderPrioritizationLabels = {
+    [exports.BookingOrderPrioritization.DISABLED]: 'enum.booking_order_prioritization.disabled',
+    [exports.BookingOrderPrioritization.STRICT]: 'enum.booking_order_prioritization.strict',
+    [exports.BookingOrderPrioritization.NON_STRICT]: 'enum.booking_order_prioritization.non_strict',
+};
+exports.NodeGroupingCapacityStrategy = {
+    MIN: 'min',
+    MAX: 'max',
+    MEDIAN: 'median',
+    MEAN: 'mean',
+    IGNORE: 'ignore',
+};
+exports.NodeGroupingCapacityStrategyLabels = {
+    [exports.NodeGroupingCapacityStrategy.MIN]: 'enum.node_grouping_capacity_strategy.min',
+    [exports.NodeGroupingCapacityStrategy.MAX]: 'enum.node_grouping_capacity_strategy.max',
+    [exports.NodeGroupingCapacityStrategy.MEDIAN]: 'enum.node_grouping_capacity_strategy.median',
+    [exports.NodeGroupingCapacityStrategy.MEAN]: 'enum.node_grouping_capacity_strategy.mean',
+    [exports.NodeGroupingCapacityStrategy.IGNORE]: 'enum.node_grouping_capacity_strategy.ignore',
+};
+exports.ManualEditApiSolverKind = {
+    LOCAL: 'local',
+    REMOTE: 'remote',
+};
+exports.ManualEditApiSolverKindLabels = {
+    [exports.ManualEditApiSolverKind.LOCAL]: 'enum.manual_edit_api_solver_kind.local',
+    [exports.ManualEditApiSolverKind.REMOTE]: 'enum.manual_edit_api_solver_kind.remote',
+};

package/dist/sgerp/constants/scheduling-enums.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Scheduling Enums
+ * Ported from ~/dev/sgerp/scheduling/enums.py
+ */
+export declare const AlgoType: {
+    readonly STATIC: "static";
+    readonly DYNAMIC: "dynamic";
+    readonly DYNAMIC_2_STAGES: "dynamic_2_stages";
+    readonly TIMELESS: "timeless";
+    readonly STATIC_OR_DYNAMIC: "static_or_dynamic";
+};
+export type AlgoTypeValue = typeof AlgoType[keyof typeof AlgoType];
+export declare const AlgoTypeLabels: Record<AlgoTypeValue, string>;
+export declare const AlgoOptimizeQuantity: {
+    readonly TOTAL_TIME: "total_time";
+    readonly TOTAL_DISTANCE: "total_distance";
+    readonly PASSENGER_OPTIMIZATION: "passenger_optimization";
+};
+export type AlgoOptimizeQuantityValue = typeof AlgoOptimizeQuantity[keyof typeof AlgoOptimizeQuantity];
+export declare const AlgoOptimizeQuantityLabels: Record<AlgoOptimizeQuantityValue, string>;
+export declare const GenericSchedulerMode: {
+    readonly PREBOOK: "prebook";
+    readonly REAL_TIME: "real_time";
+    readonly PREBOOK_CVRPTW: "prebook_cvrptw";
+    readonly LOGISTICS_REAL_TIME: "logistics_real_time";
+};
+export type GenericSchedulerModeValue = typeof GenericSchedulerMode[keyof typeof GenericSchedulerMode];
+export declare const GenericSchedulerModeLabels: Record<GenericSchedulerModeValue, string>;
+export declare const LocalSearchOperator: {
+    readonly EXTENDED_SWAP_ACTIVE: "extended_swap_active";
+    readonly LOGISTICS_RELOCATE_PAIR: "logistics_relocate_pair";
+    readonly DEFAULT_NO_OPERATORS: "default_no_operators";
+};
+export type LocalSearchOperatorValue = typeof LocalSearchOperator[keyof typeof LocalSearchOperator];
+export declare const LocalSearchOperatorLabels: Record<LocalSearchOperatorValue, string>;
+export declare const PathConstraintsMode: {
+    readonly LEGACY: "legacy";
+    readonly LOGISTICS: "logistics";
+};
+export type PathConstraintsModeValue = typeof PathConstraintsMode[keyof typeof PathConstraintsMode];
+export declare const PathConstraintsModeLabels: Record<PathConstraintsModeValue, string>;
+//# sourceMappingURL=scheduling-enums.d.ts.map

package/dist/sgerp/constants/scheduling-enums.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduling-enums.d.ts","sourceRoot":"","sources":["../../../sgerplib/sgerp/constants/scheduling-enums.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,QAAQ;;;;;;CAMX,CAAC;AAEX,MAAM,MAAM,aAAa,GAAG,OAAO,QAAQ,CAAC,MAAM,OAAO,QAAQ,CAAC,CAAC;AAEnE,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,aAAa,EAAE,MAAM,CAMxD,CAAC;AAEF,eAAO,MAAM,oBAAoB;;;;CAIvB,CAAC;AAEX,MAAM,MAAM,yBAAyB,GAAG,OAAO,oBAAoB,CAAC,MAAM,OAAO,oBAAoB,CAAC,CAAC;AAEvG,eAAO,MAAM,0BAA0B,EAAE,MAAM,CAAC,yBAAyB,EAAE,MAAM,CAIhF,CAAC;AAEF,eAAO,MAAM,oBAAoB;;;;;CAKvB,CAAC;AAEX,MAAM,MAAM,yBAAyB,GAAG,OAAO,oBAAoB,CAAC,MAAM,OAAO,oBAAoB,CAAC,CAAC;AAEvG,eAAO,MAAM,0BAA0B,EAAE,MAAM,CAAC,yBAAyB,EAAE,MAAM,CAKhF,CAAC;AAEF,eAAO,MAAM,mBAAmB;;;;CAItB,CAAC;AAEX,MAAM,MAAM,wBAAwB,GAAG,OAAO,mBAAmB,CAAC,MAAM,OAAO,mBAAmB,CAAC,CAAC;AAEpG,eAAO,MAAM,yBAAyB,EAAE,MAAM,CAAC,wBAAwB,EAAE,MAAM,CAI9E,CAAC;AAEF,eAAO,MAAM,mBAAmB;;;CAGtB,CAAC;AAEX,MAAM,MAAM,wBAAwB,GAAG,OAAO,mBAAmB,CAAC,MAAM,OAAO,mBAAmB,CAAC,CAAC;AAEpG,eAAO,MAAM,yBAAyB,EAAE,MAAM,CAAC,wBAAwB,EAAE,MAAM,CAG9E,CAAC"}

package/dist/sgerp/constants/scheduling-enums.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * Scheduling Enums
+ * Ported from ~/dev/sgerp/scheduling/enums.py
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathConstraintsModeLabels = exports.PathConstraintsMode = exports.LocalSearchOperatorLabels = exports.LocalSearchOperator = exports.GenericSchedulerModeLabels = exports.GenericSchedulerMode = exports.AlgoOptimizeQuantityLabels = exports.AlgoOptimizeQuantity = exports.AlgoTypeLabels = exports.AlgoType = void 0;
+exports.AlgoType = {
+    STATIC: 'static',
+    DYNAMIC: 'dynamic',
+    DYNAMIC_2_STAGES: 'dynamic_2_stages',
+    TIMELESS: 'timeless',
+    STATIC_OR_DYNAMIC: 'static_or_dynamic',
+};
+exports.AlgoTypeLabels = {
+    [exports.AlgoType.STATIC]: 'enum.algo_type.static',
+    [exports.AlgoType.DYNAMIC]: 'enum.algo_type.dynamic',
+    [exports.AlgoType.DYNAMIC_2_STAGES]: 'enum.algo_type.dynamic_2_stages',
+    [exports.AlgoType.TIMELESS]: 'enum.algo_type.timeless',
+    [exports.AlgoType.STATIC_OR_DYNAMIC]: 'enum.algo_type.static_or_dynamic',
+};
+exports.AlgoOptimizeQuantity = {
+    TOTAL_TIME: 'total_time',
+    TOTAL_DISTANCE: 'total_distance',
+    PASSENGER_OPTIMIZATION: 'passenger_optimization',
+};
+exports.AlgoOptimizeQuantityLabels = {
+    [exports.AlgoOptimizeQuantity.TOTAL_TIME]: 'enum.algo_optimize_quantity.total_time',
+    [exports.AlgoOptimizeQuantity.TOTAL_DISTANCE]: 'enum.algo_optimize_quantity.total_distance',
+    [exports.AlgoOptimizeQuantity.PASSENGER_OPTIMIZATION]: 'enum.algo_optimize_quantity.passenger_optimization',
+};
+exports.GenericSchedulerMode = {
+    PREBOOK: 'prebook',
+    REAL_TIME: 'real_time',
+    PREBOOK_CVRPTW: 'prebook_cvrptw',
+    LOGISTICS_REAL_TIME: 'logistics_real_time',
+};
+exports.GenericSchedulerModeLabels = {
+    [exports.GenericSchedulerMode.PREBOOK]: 'enum.generic_scheduler_mode.prebook',
+    [exports.GenericSchedulerMode.REAL_TIME]: 'enum.generic_scheduler_mode.real_time',
+    [exports.GenericSchedulerMode.PREBOOK_CVRPTW]: 'enum.generic_scheduler_mode.prebook_cvrptw',
+    [exports.GenericSchedulerMode.LOGISTICS_REAL_TIME]: 'enum.generic_scheduler_mode.logistics_real_time',
+};
+exports.LocalSearchOperator = {
+    EXTENDED_SWAP_ACTIVE: 'extended_swap_active',
+    LOGISTICS_RELOCATE_PAIR: 'logistics_relocate_pair',
+    DEFAULT_NO_OPERATORS: 'default_no_operators',
+};
+exports.LocalSearchOperatorLabels = {
+    [exports.LocalSearchOperator.EXTENDED_SWAP_ACTIVE]: 'enum.local_search_operator.extended_swap_active',
+    [exports.LocalSearchOperator.LOGISTICS_RELOCATE_PAIR]: 'enum.local_search_operator.logistics_relocate_pair',
+    [exports.LocalSearchOperator.DEFAULT_NO_OPERATORS]: 'enum.local_search_operator.default_no_operators',
+};
+exports.PathConstraintsMode = {
+    LEGACY: 'legacy',
+    LOGISTICS: 'logistics',
+};
+exports.PathConstraintsModeLabels = {
+    [exports.PathConstraintsMode.LEGACY]: 'enum.path_constraints_mode.legacy',
+    [exports.PathConstraintsMode.LOGISTICS]: 'enum.path_constraints_mode.logistics',
+};

package/dist/sgerp/constants/simulation-enums.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Simulation Enums
+ * Ported from ~/dev/sgerp/simulation/agents/enums.py
+ */
+export declare const LogisticsPipelineType: {
+    readonly SIMPLE_ONE_STAGE: "simple_one_stage";
+    readonly TWO_STAGES: "two_stages";
+};
+export type LogisticsPipelineTypeValue = typeof LogisticsPipelineType[keyof typeof LogisticsPipelineType];
+export declare const LogisticsPipelineTypeLabels: Record<LogisticsPipelineTypeValue, string>;
+export declare const FinalizationType: {
+    readonly MIN: "min";
+    readonly MAX: "max";
+};
+export type FinalizationTypeValue = typeof FinalizationType[keyof typeof FinalizationType];
+export declare const FinalizationTypeLabels: Record<FinalizationTypeValue, string>;
+export declare const BookingStatus: {
+    readonly NEW: "new";
+    readonly PREPARED: "prepared";
+    readonly QUEUED: "queued";
+    readonly CALCULATION: "calculation";
+    readonly CANCELLED_IN_CALC: "cancelled_in_calc";
+    readonly ASSIGNED: "assigned";
+    readonly REJECTED_BY_SYSTEM: "rejected_by_system";
+    readonly ENROUTE: "enroute";
+    readonly COMPLETED: "completed";
+    readonly SENT_OFFER: "sent_offer";
+    readonly CANCELLED_BY_USER: "cancelled_by_user";
+    readonly POOLING: "pooling";
+    readonly FAIL_TO_BOARD: "fail_to_board";
+    readonly FAIL_TO_DELIVER: "fail_to_deliver";
+    readonly LINKED: "linked";
+};
+export type BookingStatusValue = typeof BookingStatus[keyof typeof BookingStatus];
+export declare const BookingStatusLabels: Record<BookingStatusValue, string>;
+export declare const NodeStatus: {
+    readonly NEW: "new";
+    readonly ASSIGNED: "assigned";
+    readonly IN_SERVICE: "in_service";
+    readonly COMPLETED: "completed";
+    readonly CANCELLED_BY_USER: "cancelled_by_user";
+    readonly DROPPED_BY_ALGO: "dropped_by_algo";
+    readonly FAIL_TO_BOARD: "fail_to_board";
+    readonly FAIL_TO_DELIVER: "fail_to_deliver";
+};
+export type NodeStatusValue = typeof NodeStatus[keyof typeof NodeStatus];
+export declare const NodeStatusLabels: Record<NodeStatusValue, string>;
+export declare const NodeType: {
+    readonly POINT: "point";
+    readonly PICKUP: "pickup";
+    readonly DROPOFF: "dropoff";
+    readonly DEPOT: "depot";
+    readonly VEHICLE_POSITION: "vehicle_position";
+};
+export type NodeTypeValue = typeof NodeType[keyof typeof NodeType];
+export declare const NodeTypeLabels: Record<NodeTypeValue, string>;
+export declare const SimulationStatus: {
+    readonly CREATED: "created";
+    readonly QUEUED: "queued";
+    readonly RUNNING: "running";
+    readonly COMPLETED: "completed";
+    readonly FAILED: "failed";
+    readonly TERMINATED: "terminated";
+};
+export type SimulationStatusValue = typeof SimulationStatus[keyof typeof SimulationStatus];
+export declare const SimulationStatusLabels: Record<SimulationStatusValue, string>;
+export declare const SimulationMode: {
+    readonly REAL_TIME: "real_time";
+    readonly FAST: "fast_simulation";
+    readonly PREBOOK: "prebook";
+    readonly REAL_OPERATIONS: "real_operations";
+    readonly TEMPLATE: "template";
+};
+export type SimulationModeValue = typeof SimulationMode[keyof typeof SimulationMode];
+export declare const SimulationModeLabels: Record<SimulationModeValue, string>;
+export declare const BookingType: {
+    readonly CUSTOMER: "customer";
+    readonly BREAK: "break";
+    readonly POOLING: "pooling";
+    readonly ESTIMATE: "estimate";
+};
+export type BookingTypeValue = typeof BookingType[keyof typeof BookingType];
+export declare const BookingTypeLabels: Record<BookingTypeValue, string>;
+export declare const SimulationProcessorState: {
+    readonly NEW: "new";
+    readonly CALCULATING: "calculating";
+    readonly CALCULATED: "calculated";
+    readonly COMPLETED: "completed";
+    readonly FAILED: "failed";
+};
+export type SimulationProcessorStateValue = typeof SimulationProcessorState[keyof typeof SimulationProcessorState];
+export declare const SimulationProcessorStateLabels: Record<SimulationProcessorStateValue, string>;
+//# sourceMappingURL=simulation-enums.d.ts.map

package/dist/sgerp/constants/simulation-enums.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simulation-enums.d.ts","sourceRoot":"","sources":["../../../sgerplib/sgerp/constants/simulation-enums.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,qBAAqB;;;CAGxB,CAAC;AAEX,MAAM,MAAM,0BAA0B,GAAG,OAAO,qBAAqB,CAAC,MAAM,OAAO,qBAAqB,CAAC,CAAC;AAE1G,eAAO,MAAM,2BAA2B,EAAE,MAAM,CAAC,0BAA0B,EAAE,MAAM,CAGlF,CAAC;AAEF,eAAO,MAAM,gBAAgB;;;CAGnB,CAAC;AAEX,MAAM,MAAM,qBAAqB,GAAG,OAAO,gBAAgB,CAAC,MAAM,OAAO,gBAAgB,CAAC,CAAC;AAE3F,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,qBAAqB,EAAE,MAAM,CAGxE,CAAC;AAEF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;CAgBhB,CAAC;AAEX,MAAM,MAAM,kBAAkB,GAAG,OAAO,aAAa,CAAC,MAAM,OAAO,aAAa,CAAC,CAAC;AAElF,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,kBAAkB,EAAE,MAAM,CAgBlE,CAAC;AAEF,eAAO,MAAM,UAAU;;;;;;;;;CASb,CAAC;AAEX,MAAM,MAAM,eAAe,GAAG,OAAO,UAAU,CAAC,MAAM,OAAO,UAAU,CAAC,CAAC;AAEzE,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,eAAe,EAAE,MAAM,CAS5D,CAAC;AAEF,eAAO,MAAM,QAAQ;;;;;;CAMX,CAAC;AAEX,MAAM,MAAM,aAAa,GAAG,OAAO,QAAQ,CAAC,MAAM,OAAO,QAAQ,CAAC,CAAC;AAEnE,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,aAAa,EAAE,MAAM,CAMxD,CAAC;AAEF,eAAO,MAAM,gBAAgB;;;;;;;CAOnB,CAAC;AAEX,MAAM,MAAM,qBAAqB,GAAG,OAAO,gBAAgB,CAAC,MAAM,OAAO,gBAAgB,CAAC,CAAC;AAE3F,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,qBAAqB,EAAE,MAAM,CAOxE,CAAC;AAEF,eAAO,MAAM,cAAc;;;;;;CAMjB,CAAC;AAEX,MAAM,MAAM,mBAAmB,GAAG,OAAO,cAAc,CAAC,MAAM,OAAO,cAAc,CAAC,CAAC;AAErF,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,mBAAmB,EAAE,MAAM,CAMpE,CAAC;AAEF,eAAO,MAAM,WAAW;;;;;CAKd,CAAC;AAEX,MAAM,MAAM,gBAAgB,GAAG,OAAO,WAAW,CAAC,MAAM,OAAO,WAAW,CAAC,CAAC;AAE5E,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,gBAAgB,EAAE,MAAM,CAK9D,CAAC;AAEF,eAAO,MAAM,wBAAwB;;;;;;CAM3B,CAAC;AAEX,MAAM,MAAM,6BAA6B,GAAG,OAAO,wBAAwB,CAAC,MAAM,OAAO,wBAAwB,CAAC,CAAC;AAEnH,eAAO,MAAM,8BAA8B,EAAE,MAAM,CAAC,6BAA6B,EAAE,MAAM,CAMxF,CAAC"}

package/dist/sgerp/constants/simulation-enums.js

@@ -0,0 +1,147 @@
+"use strict";
+/**
+ * Simulation Enums
+ * Ported from ~/dev/sgerp/simulation/agents/enums.py
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimulationProcessorStateLabels = exports.SimulationProcessorState = exports.BookingTypeLabels = exports.BookingType = exports.SimulationModeLabels = exports.SimulationMode = exports.SimulationStatusLabels = exports.SimulationStatus = exports.NodeTypeLabels = exports.NodeType = exports.NodeStatusLabels = exports.NodeStatus = exports.BookingStatusLabels = exports.BookingStatus = exports.FinalizationTypeLabels = exports.FinalizationType = exports.LogisticsPipelineTypeLabels = exports.LogisticsPipelineType = void 0;
+exports.LogisticsPipelineType = {
+    SIMPLE_ONE_STAGE: 'simple_one_stage',
+    TWO_STAGES: 'two_stages',
+};
+exports.LogisticsPipelineTypeLabels = {
+    [exports.LogisticsPipelineType.SIMPLE_ONE_STAGE]: 'enum.logistics_pipeline_type.simple_one_stage',
+    [exports.LogisticsPipelineType.TWO_STAGES]: 'enum.logistics_pipeline_type.two_stages',
+};
+exports.FinalizationType = {
+    MIN: 'min',
+    MAX: 'max',
+};
+exports.FinalizationTypeLabels = {
+    [exports.FinalizationType.MIN]: 'enum.finalization_type.min',
+    [exports.FinalizationType.MAX]: 'enum.finalization_type.max',
+};
+exports.BookingStatus = {
+    NEW: 'new',
+    PREPARED: 'prepared',
+    QUEUED: 'queued',
+    CALCULATION: 'calculation',
+    CANCELLED_IN_CALC: 'cancelled_in_calc',
+    ASSIGNED: 'assigned',
+    REJECTED_BY_SYSTEM: 'rejected_by_system',
+    ENROUTE: 'enroute',
+    COMPLETED: 'completed',
+    SENT_OFFER: 'sent_offer',
+    CANCELLED_BY_USER: 'cancelled_by_user',
+    POOLING: 'pooling',
+    FAIL_TO_BOARD: 'fail_to_board',
+    FAIL_TO_DELIVER: 'fail_to_deliver',
+    LINKED: 'linked',
+};
+exports.BookingStatusLabels = {
+    [exports.BookingStatus.NEW]: 'enum.booking_status.new',
+    [exports.BookingStatus.PREPARED]: 'enum.booking_status.prepared',
+    [exports.BookingStatus.QUEUED]: 'enum.booking_status.queued',
+    [exports.BookingStatus.CALCULATION]: 'enum.booking_status.calculation',
+    [exports.BookingStatus.CANCELLED_IN_CALC]: 'enum.booking_status.cancelled_in_calc',
+    [exports.BookingStatus.ASSIGNED]: 'enum.booking_status.assigned',
+    [exports.BookingStatus.REJECTED_BY_SYSTEM]: 'enum.booking_status.rejected_by_system',
+    [exports.BookingStatus.ENROUTE]: 'enum.booking_status.enroute',
+    [exports.BookingStatus.COMPLETED]: 'enum.booking_status.completed',
+    [exports.BookingStatus.SENT_OFFER]: 'enum.booking_status.sent_offer',
+    [exports.BookingStatus.CANCELLED_BY_USER]: 'enum.booking_status.cancelled_by_user',
+    [exports.BookingStatus.POOLING]: 'enum.booking_status.pooling',
+    [exports.BookingStatus.FAIL_TO_BOARD]: 'enum.booking_status.fail_to_board',
+    [exports.BookingStatus.FAIL_TO_DELIVER]: 'enum.booking_status.fail_to_deliver',
+    [exports.BookingStatus.LINKED]: 'enum.booking_status.linked',
+};
+exports.NodeStatus = {
+    NEW: 'new',
+    ASSIGNED: 'assigned',
+    IN_SERVICE: 'in_service',
+    COMPLETED: 'completed',
+    CANCELLED_BY_USER: 'cancelled_by_user',
+    DROPPED_BY_ALGO: 'dropped_by_algo',
+    FAIL_TO_BOARD: 'fail_to_board',
+    FAIL_TO_DELIVER: 'fail_to_deliver',
+};
+exports.NodeStatusLabels = {
+    [exports.NodeStatus.NEW]: 'enum.node_status.new',
+    [exports.NodeStatus.ASSIGNED]: 'enum.node_status.assigned',
+    [exports.NodeStatus.IN_SERVICE]: 'enum.node_status.in_service',
+    [exports.NodeStatus.COMPLETED]: 'enum.node_status.completed',
+    [exports.NodeStatus.CANCELLED_BY_USER]: 'enum.node_status.cancelled_by_user',
+    [exports.NodeStatus.DROPPED_BY_ALGO]: 'enum.node_status.dropped_by_algo',
+    [exports.NodeStatus.FAIL_TO_BOARD]: 'enum.node_status.fail_to_board',
+    [exports.NodeStatus.FAIL_TO_DELIVER]: 'enum.node_status.fail_to_deliver',
+};
+exports.NodeType = {
+    POINT: 'point',
+    PICKUP: 'pickup',
+    DROPOFF: 'dropoff',
+    DEPOT: 'depot',
+    VEHICLE_POSITION: 'vehicle_position',
+};
+exports.NodeTypeLabels = {
+    [exports.NodeType.POINT]: 'enum.node_type.point',
+    [exports.NodeType.PICKUP]: 'enum.node_type.pickup',
+    [exports.NodeType.DROPOFF]: 'enum.node_type.dropoff',
+    [exports.NodeType.DEPOT]: 'enum.node_type.depot',
+    [exports.NodeType.VEHICLE_POSITION]: 'enum.node_type.vehicle_position',
+};
+exports.SimulationStatus = {
+    CREATED: 'created',
+    QUEUED: 'queued',
+    RUNNING: 'running',
+    COMPLETED: 'completed',
+    FAILED: 'failed',
+    TERMINATED: 'terminated',
+};
+exports.SimulationStatusLabels = {
+    [exports.SimulationStatus.CREATED]: 'enum.simulation_status.created',
+    [exports.SimulationStatus.QUEUED]: 'enum.simulation_status.queued',
+    [exports.SimulationStatus.RUNNING]: 'enum.simulation_status.running',
+    [exports.SimulationStatus.COMPLETED]: 'enum.simulation_status.completed',
+    [exports.SimulationStatus.FAILED]: 'enum.simulation_status.failed',
+    [exports.SimulationStatus.TERMINATED]: 'enum.simulation_status.terminated',
+};
+exports.SimulationMode = {
+    REAL_TIME: 'real_time',
+    FAST: 'fast_simulation',
+    PREBOOK: 'prebook',
+    REAL_OPERATIONS: 'real_operations',
+    TEMPLATE: 'template',
+};
+exports.SimulationModeLabels = {
+    [exports.SimulationMode.REAL_TIME]: 'enum.simulation_mode.real_time',
+    [exports.SimulationMode.FAST]: 'enum.simulation_mode.fast',
+    [exports.SimulationMode.PREBOOK]: 'enum.simulation_mode.prebook',
+    [exports.SimulationMode.REAL_OPERATIONS]: 'enum.simulation_mode.real_operations',
+    [exports.SimulationMode.TEMPLATE]: 'enum.simulation_mode.template',
+};
+exports.BookingType = {
+    CUSTOMER: 'customer',
+    BREAK: 'break',
+    POOLING: 'pooling',
+    ESTIMATE: 'estimate',
+};
+exports.BookingTypeLabels = {
+    [exports.BookingType.CUSTOMER]: 'enum.booking_type.customer',
+    [exports.BookingType.BREAK]: 'enum.booking_type.break',
+    [exports.BookingType.POOLING]: 'enum.booking_type.pooling',
+    [exports.BookingType.ESTIMATE]: 'enum.booking_type.estimate',
+};
+exports.SimulationProcessorState = {
+    NEW: 'new',
+    CALCULATING: 'calculating',
+    CALCULATED: 'calculated',
+    COMPLETED: 'completed',
+    FAILED: 'failed',
+};
+exports.SimulationProcessorStateLabels = {
+    [exports.SimulationProcessorState.NEW]: 'enum.simulation_processor_state.new',
+    [exports.SimulationProcessorState.CALCULATING]: 'enum.simulation_processor_state.calculating',
+    [exports.SimulationProcessorState.CALCULATED]: 'enum.simulation_processor_state.calculated',
+    [exports.SimulationProcessorState.COMPLETED]: 'enum.simulation_processor_state.completed',
+    [exports.SimulationProcessorState.FAILED]: 'enum.simulation_processor_state.failed',
+};

package/dist/sgerp/constants/solver-strategies.d.ts

@@ -0,0 +1,75 @@
+/**
+ * First Solution Strategies for OR-Tools solver
+ * Used in both JIT mode and Logistics API settings
+ */
+export declare const FIRST_SOLUTION_STRATEGIES: readonly [{
+    readonly value: 0;
+    readonly key: "automatic";
+    readonly label: "Automatic";
+}, {
+    readonly value: 1;
+    readonly key: "global_cheapest_arc";
+    readonly label: "Global Cheapest Arc";
+}, {
+    readonly value: 2;
+    readonly key: "local_cheapest_arc";
+    readonly label: "Local Cheapest Arc";
+}, {
+    readonly value: 3;
+    readonly key: "path_cheapest_arc";
+    readonly label: "Path Cheapest Arc";
+}, {
+    readonly value: 4;
+    readonly key: "path_most_constrained_arc";
+    readonly label: "Path Most Constrained Arc";
+}, {
+    readonly value: 5;
+    readonly key: "evaluator_strategy";
+    readonly label: "Evaluator Strategy";
+}, {
+    readonly value: 6;
+    readonly key: "all_unperformed";
+    readonly label: "All Unperformed";
+}, {
+    readonly value: 7;
+    readonly key: "best_insertion";
+    readonly label: "Best Insertion";
+}, {
+    readonly value: 8;
+    readonly key: "parallel_cheapest_insertion";
+    readonly label: "Parallel Cheapest Insertion";
+}, {
+    readonly value: 9;
+    readonly key: "local_cheapest_insertion";
+    readonly label: "Local Cheapest Insertion";
+}, {
+    readonly value: 10;
+    readonly key: "savings";
+    readonly label: "Savings";
+}, {
+    readonly value: 11;
+    readonly key: "sweep";
+    readonly label: "Sweep";
+}, {
+    readonly value: 12;
+    readonly key: "first_unbound_min_value";
+    readonly label: "First Unbound Min Value";
+}, {
+    readonly value: 13;
+    readonly key: "christofides";
+    readonly label: "Christofides";
+}, {
+    readonly value: 14;
+    readonly key: "sequential_cheapest_insertion";
+    readonly label: "Sequential Cheapest Insertion";
+}, {
+    readonly value: 16;
+    readonly key: "adjustable_parallel_cheapest_insertion";
+    readonly label: "Adjustable Parallel Cheapest Insertion";
+}, {
+    readonly value: 17;
+    readonly key: "logistics_parallel_cheapest_insertion";
+    readonly label: "Logistics Parallel Cheapest Insertion";
+}];
+export type FirstSolutionStrategy = typeof FIRST_SOLUTION_STRATEGIES[number];
+//# sourceMappingURL=solver-strategies.d.ts.map

package/dist/sgerp/constants/solver-strategies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solver-strategies.d.ts","sourceRoot":"","sources":["../../../sgerplib/sgerp/constants/solver-strategies.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkB5B,CAAC;AAEX,MAAM,MAAM,qBAAqB,GAAG,OAAO,yBAAyB,CAAC,MAAM,CAAC,CAAC"}