@golemio/fcd 1.2.4 → 1.2.5-dev.1262829891

package/db/example/sql_dump.sql

@@ -7,3 +7,10 @@ VALUES('2021-09-21 01:36:59.000', 'TS10127T19629', '2021-09-21 01:36:01.000', 'T
 INSERT INTO fcd_traff_params_part
 (publication_time, source_identification, measurement_or_calculation_time, predefined_location, version_of_predefined_location, traffic_level, queue_exists, queue_length, from_point, to_point, data_quality, input_values, average_vehicle_speed, travel_time, free_flow_travel_time, free_flow_speed, create_batch_id, created_at, created_by, update_batch_id, updated_at, updated_by)
 VALUES('2021-09-21 01:36:59.000', 'TS10182T24828', '2021-09-21 01:36:01.000', 'TS10182T24828', 2, 'level1', false, NULL, NULL, NULL, 0.833, 3, 91, 87, 106, 76, NULL, '2021-10-18 11:01:16.534', NULL, NULL, '2021-10-18 11:01:16.534', NULL);
+
+
+DELETE from traffic.rsd_tmc_osm_mapping;
+
+INSERT INTO traffic.rsd_tmc_osm_mapping (lt_start,lt_end,osm_path) VALUES
+	 (10125,10123,'[1837041102, 8418051939, 7881860434, 1837022954, 1837022956, 1837022966, 977504781, 8404188228, 5216395186, 2674815365, 977504746, 8402974140, 1017997574, 1017997516, 1017997560, 1017997515, 8403075909, 8403127730, 8403075911, 8403075912, 8403127735]'),
+	 (10127,19629,'[29381030, 29403193, 338604070, 29381028, 338604072, 29403192, 2681371748, 1138616634, 2681371747, 308815174,1138624651, 29403191]');

package/db/migrations/postgresql/20240419120732-fcd-new-view.js

@@ -0,0 +1,53 @@
+'use strict';
+
+var dbm;
+var type;
+var seed;
+var fs = require('fs');
+var path = require('path');
+var Promise;
+
+/**
+  * We receive the dbmigrate dependency from dbmigrate initially.
+  * This enables us to not have to rely on NODE_PATH.
+  */
+exports.setup = function(options, seedLink) {
+  dbm = options.dbmigrate;
+  type = dbm.dataType;
+  seed = seedLink;
+  Promise = options.Promise;
+};
+
+exports.up = function(db) {
+  var filePath = path.join(__dirname, 'sqls', '20240419120732-fcd-new-view-up.sql');
+  return new Promise( function( resolve, reject ) {
+    fs.readFile(filePath, {encoding: 'utf-8'}, function(err,data){
+      if (err) return reject(err);
+      console.log('received data: ' + data);
+
+      resolve(data);
+    });
+  })
+  .then(function(data) {
+    return db.runSql(data);
+  });
+};
+
+exports.down = function(db) {
+  var filePath = path.join(__dirname, 'sqls', '20240419120732-fcd-new-view-down.sql');
+  return new Promise( function( resolve, reject ) {
+    fs.readFile(filePath, {encoding: 'utf-8'}, function(err,data){
+      if (err) return reject(err);
+      console.log('received data: ' + data);
+
+      resolve(data);
+    });
+  })
+  .then(function(data) {
+    return db.runSql(data);
+  });
+};
+
+exports._meta = {
+  "version": 1
+};

package/db/migrations/postgresql/sqls/20240419120732-fcd-new-view-down.sql

@@ -0,0 +1,2 @@
+drop view v_traffic_params_all_with_osm_path;
+drop view v_traffic_params_last_hour_osm_path; 

package/db/migrations/postgresql/sqls/20240419120732-fcd-new-view-up.sql

@@ -0,0 +1,78 @@
+CREATE OR REPLACE VIEW v_traffic_params_all_with_osm_path
+AS SELECT t.queue_exists,
+    t.queue_length,
+    t.from_point,
+    t.to_point,
+    rtom.osm_path,
+    t.source_identification,
+    t.data_quality,
+    t.input_values,
+    t.predefined_location,
+    t.average_vehicle_speed,
+    t.travel_time,
+    t.free_flow_travel_time,
+    t.free_flow_speed,
+    t.measurement_or_calculation_time,
+    t.publication_time,
+    t.version_of_predefined_location,
+    t.traffic_level
+   FROM ( SELECT v_traffic_params_all.publication_time,
+            v_traffic_params_all.source_identification,
+            v_traffic_params_all.measurement_or_calculation_time,
+            v_traffic_params_all.predefined_location,
+            v_traffic_params_all.version_of_predefined_location,
+            v_traffic_params_all.traffic_level,
+            v_traffic_params_all.queue_exists,
+            v_traffic_params_all.queue_length,
+            v_traffic_params_all.from_point,
+            v_traffic_params_all.to_point,
+            v_traffic_params_all.data_quality,
+            v_traffic_params_all.input_values,
+            v_traffic_params_all.average_vehicle_speed,
+            v_traffic_params_all.travel_time,
+            v_traffic_params_all.free_flow_travel_time,
+            v_traffic_params_all.free_flow_speed,
+            regexp_split_to_array(v_traffic_params_all.source_identification::text, '(TS|T)'::text) AS i
+           FROM v_traffic_params_all)t
+     LEFT JOIN traffic.rsd_tmc_osm_mapping rtom ON rtom.lt_start = t.i[2]::integer AND rtom.lt_end = t.i[3]::integer;
+
+
+
+
+CREATE OR REPLACE VIEW v_traffic_params_last_hour_osm_path
+AS SELECT t.queue_exists,
+    t.queue_length,
+    t.from_point,
+    t.to_point,
+    rtom.osm_path,
+    t.source_identification,
+    t.data_quality,
+    t.input_values,
+    t.predefined_location,
+    t.average_vehicle_speed,
+    t.travel_time,
+    t.free_flow_travel_time,
+    t.free_flow_speed,
+    t.measurement_or_calculation_time,
+    t.publication_time,
+    t.version_of_predefined_location,
+    t.traffic_level
+   FROM ( SELECT v_traffic_params_last_hour.publication_time,
+            v_traffic_params_last_hour.source_identification,
+            v_traffic_params_last_hour.measurement_or_calculation_time,
+            v_traffic_params_last_hour.predefined_location,
+            v_traffic_params_last_hour.version_of_predefined_location,
+            v_traffic_params_last_hour.traffic_level,
+            v_traffic_params_last_hour.queue_exists,
+            v_traffic_params_last_hour.queue_length,
+            v_traffic_params_last_hour.from_point,
+            v_traffic_params_last_hour.to_point,
+            v_traffic_params_last_hour.data_quality,
+            v_traffic_params_last_hour.input_values,
+            v_traffic_params_last_hour.average_vehicle_speed,
+            v_traffic_params_last_hour.travel_time,
+            v_traffic_params_last_hour.free_flow_travel_time,
+            v_traffic_params_last_hour.free_flow_speed,
+            regexp_split_to_array(v_traffic_params_last_hour.source_identification::text, '(TS|T)'::text) AS i
+           FROM v_traffic_params_last_hour)t
+     LEFT JOIN traffic.rsd_tmc_osm_mapping rtom ON rtom.lt_start = t.i[2]::integer AND rtom.lt_end = t.i[3]::integer;

package/dist/integration-engine/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./FCDWorker";
-export * from "./queueDefinitions";
+export * from "./workers";
+export * from "./transformations";

package/dist/integration-engine/index.js

@@ -1,4 +1,5 @@
 "use strict";
+/* ie/index.ts */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -14,7 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-/* ie/index.ts */
-__exportStar(require("./FCDWorker"), exports);
-__exportStar(require("./queueDefinitions"), exports);
+__exportStar(require("./workers"), exports);
+__exportStar(require("./transformations"), exports);
 //# sourceMappingURL=index.js.map

package/dist/integration-engine/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/integration-engine/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,iBAAiB;AACjB,8CAA4B;AAC5B,qDAAmC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/integration-engine/index.ts"],"names":[],"mappings":";AAAA,iBAAiB;;;;;;;;;;;;;;;;AAEjB,4CAA0B;AAC1B,oDAAkC"}

package/dist/integration-engine/ioc/Di.d.ts

@@ -0,0 +1,3 @@
+import { DependencyContainer } from "@golemio/core/dist/shared/tsyringe";
+declare const FCDContainer: DependencyContainer;
+export { FCDContainer };

package/dist/integration-engine/ioc/Di.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FCDContainer = void 0;
+const Di_1 = require("@golemio/core/dist/integration-engine/ioc/Di");
+const transformations_1 = require("../transformations");
+const LteCze90PointsChecker_1 = require("../helpers/LteCze90PointsChecker");
+const ModuleContainer_1 = require("./ModuleContainer");
+const FloatingCarDataRegionsRepository_1 = require("../repositories/fcd/FloatingCarDataRegionsRepository");
+const FloatingCarDataRepository_1 = require("../repositories/fcd/FloatingCarDataRepository");
+const tasks_1 = require("../workers/tasks");
+//#region Initialization
+const FCDContainer = Di_1.IntegrationEngineContainer.createChildContainer();
+exports.FCDContainer = FCDContainer;
+//#endregion
+//#region Repositories
+FCDContainer.register(ModuleContainer_1.ModuleContainerToken.FloatingCarDataRegionsRepository, FloatingCarDataRegionsRepository_1.FloatingCarDataRegionsRepository);
+FCDContainer.register(ModuleContainer_1.ModuleContainerToken.FloatingCarDataRepository, FloatingCarDataRepository_1.FloatingCarDataRepository);
+//#endregion
+//#region Transformations
+FCDContainer.register(ModuleContainer_1.ModuleContainerToken.FloatingCarDataTransformation, transformations_1.FloatingCarDataTransformation);
+//#endregion
+//#region Tasks
+FCDContainer.register(ModuleContainer_1.ModuleContainerToken.RegionsDataRetentionTask, tasks_1.RegionsDataRetentionTask);
+FCDContainer.register(ModuleContainer_1.ModuleContainerToken.SaveFloatingCarDataTask, tasks_1.SaveFloatingCarDataTask);
+FCDContainer.register(ModuleContainer_1.ModuleContainerToken.SaveRegionsDataTask, tasks_1.SaveRegionsDataTask);
+//#endregion
+//#region Helpers
+FCDContainer.register(ModuleContainer_1.ModuleContainerToken.lteCze90PointsChecker, LteCze90PointsChecker_1.LteCze90PointsChecker);
+//# sourceMappingURL=Di.js.map

package/dist/integration-engine/ioc/Di.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Di.js","sourceRoot":"","sources":["../../../src/integration-engine/ioc/Di.ts"],"names":[],"mappings":";;;AAAA,qEAA0F;AAE1F,wDAAoE;AACpE,4EAA0E;AAC1E,uDAAyD;AACzD,2GAAyG;AACzG,6FAA2F;AAC3F,4CAA2G;AAE3G,wBAAwB;AACxB,MAAM,YAAY,GAAwB,+BAA0B,CAAC,oBAAoB,EAAE,CAAC;AAsBnF,oCAAY;AArBrB,YAAY;AAEZ,sBAAsB;AACtB,YAAY,CAAC,QAAQ,CAAC,sCAAoB,CAAC,gCAAgC,EAAE,mEAAgC,CAAC,CAAC;AAC/G,YAAY,CAAC,QAAQ,CAAC,sCAAoB,CAAC,yBAAyB,EAAE,qDAAyB,CAAC,CAAC;AACjG,YAAY;AAEZ,yBAAyB;AACzB,YAAY,CAAC,QAAQ,CAAC,sCAAoB,CAAC,6BAA6B,EAAE,+CAA6B,CAAC,CAAC;AACzG,YAAY;AAEZ,eAAe;AACf,YAAY,CAAC,QAAQ,CAAC,sCAAoB,CAAC,wBAAwB,EAAE,gCAAwB,CAAC,CAAC;AAC/F,YAAY,CAAC,QAAQ,CAAC,sCAAoB,CAAC,uBAAuB,EAAE,+BAAuB,CAAC,CAAC;AAC7F,YAAY,CAAC,QAAQ,CAAC,sCAAoB,CAAC,mBAAmB,EAAE,2BAAmB,CAAC,CAAC;AACrF,YAAY;AAEZ,iBAAiB;AACjB,YAAY,CAAC,QAAQ,CAAC,sCAAoB,CAAC,qBAAqB,EAAE,6CAAqB,CAAC,CAAC"}

package/dist/integration-engine/ioc/ModuleContainer.d.ts

@@ -0,0 +1,10 @@
+declare const ModuleContainerToken: {
+    FloatingCarDataTransformation: symbol;
+    SaveFloatingCarDataTask: symbol;
+    SaveRegionsDataTask: symbol;
+    RegionsDataRetentionTask: symbol;
+    FloatingCarDataRegionsRepository: symbol;
+    FloatingCarDataRepository: symbol;
+    lteCze90PointsChecker: symbol;
+};
+export { ModuleContainerToken };

package/dist/integration-engine/ioc/ModuleContainer.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleContainerToken = void 0;
+const ModuleContainerToken = {
+    FloatingCarDataTransformation: Symbol(),
+    SaveFloatingCarDataTask: Symbol(),
+    SaveRegionsDataTask: Symbol(),
+    RegionsDataRetentionTask: Symbol(),
+    FloatingCarDataRegionsRepository: Symbol(),
+    FloatingCarDataRepository: Symbol(),
+    lteCze90PointsChecker: Symbol(),
+};
+exports.ModuleContainerToken = ModuleContainerToken;
+//# sourceMappingURL=ModuleContainer.js.map

package/dist/integration-engine/ioc/ModuleContainer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModuleContainer.js","sourceRoot":"","sources":["../../../src/integration-engine/ioc/ModuleContainer.ts"],"names":[],"mappings":";;;AAAA,MAAM,oBAAoB,GAAG;IACzB,6BAA6B,EAAE,MAAM,EAAE;IACvC,uBAAuB,EAAE,MAAM,EAAE;IACjC,mBAAmB,EAAE,MAAM,EAAE;IAC7B,wBAAwB,EAAE,MAAM,EAAE;IAClC,gCAAgC,EAAE,MAAM,EAAE;IAC1C,yBAAyB,EAAE,MAAM,EAAE;IACnC,qBAAqB,EAAE,MAAM,EAAE;CAClC,CAAC;AAEO,oDAAoB"}

package/dist/integration-engine/repositories/fcd/FloatingCarDataRegionsRepository.d.ts

@@ -0,0 +1,6 @@
+import { IDatabaseConnector } from "@golemio/core/dist/helpers/data-access/postgres/IDatabaseConnector";
+import { IModel, PostgresModel } from "@golemio/core/dist/integration-engine";
+export declare class FloatingCarDataRegionsRepository extends PostgresModel implements IModel {
+    private databaseConnector;
+    constructor(databaseConnector: IDatabaseConnector);
+}

package/dist/integration-engine/repositories/fcd/FloatingCarDataRegionsRepository.js

@@ -0,0 +1,37 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FloatingCarDataRegionsRepository = void 0;
+const _sch_1 = require("../../../schema-definitions");
+const CoreToken_1 = require("@golemio/core/dist/helpers/ioc/CoreToken");
+const integration_engine_1 = require("@golemio/core/dist/integration-engine");
+const golemio_validator_1 = require("@golemio/core/dist/shared/golemio-validator");
+const tsyringe_1 = require("@golemio/core/dist/shared/tsyringe");
+let FloatingCarDataRegionsRepository = exports.FloatingCarDataRegionsRepository = class FloatingCarDataRegionsRepository extends integration_engine_1.PostgresModel {
+    constructor(databaseConnector) {
+        super(_sch_1.FCD.fcd_info.name + "Model", {
+            outputSequelizeAttributes: _sch_1.FCD.fcd_info.outputSequelizeAttributes,
+            pgSchema: _sch_1.FCD.pgSchema,
+            pgTableName: "fcd_traff_params_regions",
+            savingType: "insertOnly",
+        }, new golemio_validator_1.JSONSchemaValidator(_sch_1.FCD.fcd_info.name + "PgModelValidator", _sch_1.FCD.fcd_info.outputSchema));
+        this.databaseConnector = databaseConnector;
+    }
+};
+exports.FloatingCarDataRegionsRepository = FloatingCarDataRegionsRepository = __decorate([
+    (0, tsyringe_1.injectable)(),
+    __param(0, (0, tsyringe_1.inject)(CoreToken_1.CoreToken.PostgresConnector)),
+    __metadata("design:paramtypes", [Object])
+], FloatingCarDataRegionsRepository);
+//# sourceMappingURL=FloatingCarDataRegionsRepository.js.map

package/dist/integration-engine/repositories/fcd/FloatingCarDataRegionsRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FloatingCarDataRegionsRepository.js","sourceRoot":"","sources":["../../../../src/integration-engine/repositories/fcd/FloatingCarDataRegionsRepository.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,sDAA2B;AAE3B,wEAAqE;AACrE,8EAA8E;AAC9E,mFAAkF;AAClF,iEAAwE;AAGjE,IAAM,gCAAgC,8CAAtC,MAAM,gCAAiC,SAAQ,kCAAa;IAC/D,YAAyD,iBAAqC;QAC1F,KAAK,CACD,UAAG,CAAC,QAAQ,CAAC,IAAI,GAAG,OAAO,EAC3B;YACI,yBAAyB,EAAE,UAAG,CAAC,QAAQ,CAAC,yBAAyB;YACjE,QAAQ,EAAE,UAAG,CAAC,QAAQ;YACtB,WAAW,EAAE,0BAA0B;YACvC,UAAU,EAAE,YAAY;SAC3B,EACD,IAAI,uCAAmB,CAAC,UAAG,CAAC,QAAQ,CAAC,IAAI,GAAG,kBAAkB,EAAE,UAAG,CAAC,QAAQ,CAAC,YAAY,CAAC,CAC7F,CAAC;QAVmD,sBAAiB,GAAjB,iBAAiB,CAAoB;IAW9F,CAAC;CACJ,CAAA;2CAbY,gCAAgC;IAD5C,IAAA,qBAAU,GAAE;IAEI,WAAA,IAAA,iBAAM,EAAC,qBAAS,CAAC,iBAAiB,CAAC,CAAA;;GADvC,gCAAgC,CAa5C"}

package/dist/integration-engine/repositories/fcd/FloatingCarDataRepository.d.ts

@@ -0,0 +1,6 @@
+import { IDatabaseConnector } from "@golemio/core/dist/helpers/data-access/postgres/IDatabaseConnector";
+import { IModel, PostgresModel } from "@golemio/core/dist/integration-engine";
+export declare class FloatingCarDataRepository extends PostgresModel implements IModel {
+    private databaseConnector;
+    constructor(databaseConnector: IDatabaseConnector);
+}

package/dist/integration-engine/repositories/fcd/FloatingCarDataRepository.js

@@ -0,0 +1,37 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FloatingCarDataRepository = void 0;
+const _sch_1 = require("../../../schema-definitions");
+const CoreToken_1 = require("@golemio/core/dist/helpers/ioc/CoreToken");
+const integration_engine_1 = require("@golemio/core/dist/integration-engine");
+const golemio_validator_1 = require("@golemio/core/dist/shared/golemio-validator");
+const tsyringe_1 = require("@golemio/core/dist/shared/tsyringe");
+let FloatingCarDataRepository = exports.FloatingCarDataRepository = class FloatingCarDataRepository extends integration_engine_1.PostgresModel {
+    constructor(databaseConnector) {
+        super(_sch_1.FCD.fcd_info.name + "Model", {
+            outputSequelizeAttributes: _sch_1.FCD.fcd_info.outputSequelizeAttributes,
+            pgSchema: _sch_1.FCD.pgSchema,
+            pgTableName: _sch_1.FCD.fcd_info.pgTableName,
+            savingType: "insertOnly",
+        }, new golemio_validator_1.JSONSchemaValidator(_sch_1.FCD.fcd_info.name + "PgModelValidator", _sch_1.FCD.fcd_info.outputSchema));
+        this.databaseConnector = databaseConnector;
+    }
+};
+exports.FloatingCarDataRepository = FloatingCarDataRepository = __decorate([
+    (0, tsyringe_1.injectable)(),
+    __param(0, (0, tsyringe_1.inject)(CoreToken_1.CoreToken.PostgresConnector)),
+    __metadata("design:paramtypes", [Object])
+], FloatingCarDataRepository);
+//# sourceMappingURL=FloatingCarDataRepository.js.map

package/dist/integration-engine/repositories/fcd/FloatingCarDataRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FloatingCarDataRepository.js","sourceRoot":"","sources":["../../../../src/integration-engine/repositories/fcd/FloatingCarDataRepository.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,sDAA2B;AAE3B,wEAAqE;AACrE,8EAA8E;AAC9E,mFAAkF;AAClF,iEAAwE;AAGjE,IAAM,yBAAyB,uCAA/B,MAAM,yBAA0B,SAAQ,kCAAa;IACxD,YAAyD,iBAAqC;QAC1F,KAAK,CACD,UAAG,CAAC,QAAQ,CAAC,IAAI,GAAG,OAAO,EAC3B;YACI,yBAAyB,EAAE,UAAG,CAAC,QAAQ,CAAC,yBAAyB;YACjE,QAAQ,EAAE,UAAG,CAAC,QAAQ;YACtB,WAAW,EAAE,UAAG,CAAC,QAAQ,CAAC,WAAW;YACrC,UAAU,EAAE,YAAY;SAC3B,EACD,IAAI,uCAAmB,CAAC,UAAG,CAAC,QAAQ,CAAC,IAAI,GAAG,kBAAkB,EAAE,UAAG,CAAC,QAAQ,CAAC,YAAY,CAAC,CAC7F,CAAC;QAVmD,sBAAiB,GAAjB,iBAAiB,CAAoB;IAW9F,CAAC;CACJ,CAAA;oCAbY,yBAAyB;IADrC,IAAA,qBAAU,GAAE;IAEI,WAAA,IAAA,iBAAM,EAAC,qBAAS,CAAC,iBAAiB,CAAC,CAAA;;GADvC,yBAAyB,CAarC"}

package/dist/integration-engine/schemas/floatingCarData.d.ts

@@ -0,0 +1,324 @@
+import { IFloatingCarData } from "../transformations";
+export declare const floatingCarDataJsonSchema: {
+    type: string;
+    properties: Record<keyof IFloatingCarData, any>;
+    required: string[];
+    additionalProperties: boolean;
+    definitions: {
+        Exchange: {
+            type: string;
+            properties: {
+                supplierIdentification: {
+                    $ref: string;
+                };
+                exchangeExtension: {
+                    $ref: string;
+                };
+            };
+            required: string[];
+        };
+        _ExtensionType: {
+            type: string;
+        };
+        InternationalIdentifier: {
+            type: string;
+            properties: {
+                country: {
+                    type: string;
+                };
+                nationalIdentifier: {
+                    type: string;
+                };
+                internationalIdentifierExtension: {
+                    $ref: string;
+                };
+            };
+            required: string[];
+            additionalProperties: boolean;
+        };
+        PayloadPublication: {
+            type: string;
+            properties: {
+                $: {
+                    type: string;
+                    properties: {
+                        "xsi:type": {
+                            type: string;
+                            enum: string[];
+                        };
+                        lang: {
+                            type: string;
+                        };
+                    };
+                    required: string[];
+                    additionalProperties: boolean;
+                };
+                publicationTime: {
+                    $ref: string;
+                };
+                publicationCreator: {
+                    $ref: string;
+                };
+                headerInformation: {
+                    $ref: string;
+                };
+                elaboratedData: {
+                    items: {
+                        $ref: string;
+                    };
+                    type: string;
+                };
+            };
+            required: string[];
+            additionalProperties: boolean;
+        };
+        DateTime: {
+            type: string;
+            format: string;
+        };
+        HeaderInformation: {
+            type: string;
+            properties: {
+                confidentiality: {
+                    type: string;
+                };
+                informationStatus: {
+                    type: string;
+                };
+            };
+        };
+        ElaboratedData: {
+            type: string;
+            properties: {
+                source: {
+                    type: string;
+                    properties: {
+                        sourceIdentification: {
+                            type: string;
+                        };
+                    };
+                };
+                basicData: {
+                    $ref: string;
+                };
+            };
+        };
+        BasicData: {
+            type: string;
+            properties: {
+                $: {
+                    type: string;
+                    properties: {
+                        "xsi:type": {
+                            type: string;
+                            enum: string[];
+                        };
+                    };
+                    required: string[];
+                    additionalProperties: boolean;
+                };
+                measurementOrCalculationTime: {
+                    type: string;
+                };
+                pertinentLocation: {
+                    $ref: string;
+                };
+                trafficStatusExtension: {
+                    $ref: string;
+                };
+                travelTime: {
+                    $ref: string;
+                };
+                freeFlowTravelTime: {
+                    $ref: string;
+                };
+                freeFlowSpeed: {
+                    $ref: string;
+                };
+                averageVehicleSpeed: {
+                    $ref: string;
+                };
+            };
+            required: string[];
+            additionalProperties: boolean;
+        };
+        PertinentLocation: {
+            type: string;
+            properties: {
+                $: {
+                    type: string;
+                    properties: {
+                        "xsi:type": {
+                            type: string;
+                            enum: string[];
+                        };
+                    };
+                    required: string[];
+                };
+                predefinedLocationReference: {
+                    type: string;
+                    properties: {
+                        $: {
+                            type: string;
+                            properties: {
+                                targetClass: {
+                                    type: string;
+                                };
+                                id: {
+                                    type: string;
+                                };
+                                version: {
+                                    type: string;
+                                };
+                            };
+                            required: string[];
+                        };
+                    };
+                    required: string[];
+                };
+            };
+            required: string[];
+        };
+        TrafficStatusExtension: {
+            type: string;
+            properties: {
+                ndicFcdExtension: {
+                    type: string;
+                    properties: {
+                        trafficLevel: {
+                            type: string;
+                            properties: {
+                                $: {
+                                    type: string;
+                                    properties: {
+                                        supplierCalculatedDataQuality: {
+                                            type: string;
+                                        };
+                                        numberOfInputValuesUsed: {
+                                            type: string;
+                                        };
+                                    };
+                                    required: string[];
+                                };
+                                trafficLevelValue: {
+                                    type: string;
+                                };
+                            };
+                            required: string[];
+                        };
+                    };
+                    required: string[];
+                };
+                queueInformation: {
+                    type: string;
+                    properties: {
+                        queueLength: {
+                            type: string;
+                        };
+                        fromPoint: {
+                            type: string;
+                        };
+                        toPoint: {
+                            type: string;
+                        };
+                    };
+                    required: string[];
+                };
+            };
+            required: string[];
+            additionalProperties: boolean;
+        };
+        TravelTime: {
+            type: string;
+            properties: {
+                $: {
+                    type: string;
+                    properties: {
+                        supplierCalculatedDataQuality: {
+                            type: string;
+                        };
+                        numberOfInputValuesUsed: {
+                            type: string;
+                        };
+                    };
+                    required: string[];
+                    additionalProperties: boolean;
+                };
+                duration: {
+                    type: string;
+                };
+            };
+            required: string[];
+            additionalProperties: boolean;
+        };
+        FreeFlowTravelTime: {
+            type: string;
+            properties: {
+                $: {
+                    type: string;
+                    properties: {
+                        supplierCalculatedDataQuality: {
+                            type: string;
+                        };
+                        numberOfInputValuesUsed: {
+                            type: string;
+                        };
+                    };
+                    required: string[];
+                    additionalProperties: boolean;
+                };
+                duration: {
+                    type: string;
+                };
+            };
+            required: string[];
+            additionalProperties: boolean;
+        };
+        FreeFlowSpeed: {
+            type: string;
+            properties: {
+                $: {
+                    type: string;
+                    properties: {
+                        supplierCalculatedDataQuality: {
+                            type: string;
+                        };
+                        numberOfInputValuesUsed: {
+                            type: string;
+                        };
+                    };
+                    required: string[];
+                    additionalProperties: boolean;
+                };
+                speed: {
+                    type: string;
+                };
+            };
+            required: string[];
+            additionalProperties: boolean;
+        };
+        AverageVehicleSpeed: {
+            type: string;
+            properties: {
+                $: {
+                    type: string;
+                    properties: {
+                        supplierCalculatedDataQuality: {
+                            type: string;
+                        };
+                        numberOfInputValuesUsed: {
+                            type: string;
+                        };
+                    };
+                    required: string[];
+                    additionalProperties: boolean;
+                };
+                speed: {
+                    type: string;
+                };
+            };
+            required: string[];
+            additionalProperties: boolean;
+        };
+    };
+};