@m4l/gclick 0.0.2

package/contexts/RealTimeConsumerContext/store.js

@@ -0,0 +1,115 @@
+import { createStore } from "zustand";
+import { devtools } from "zustand/middleware";
+import { immer } from "zustand/middleware/immer";
+import merge from "lodash-es/merge";
+import { a as REALTIME_CONSUMER_SOTORE_ID, P as PROCCESS_MESSAGES_INTERVAL } from "./constants.js";
+import { O as ObjectQueue } from "../../utils/ObjectQueue.js";
+import { cloneDeep } from "lodash-es";
+const decoratedResourceOrMessage = (resourceSerialId, resourceOrMessage, decorators) => {
+  if (decorators && resourceOrMessage) {
+    return decorators.reduce((acc, decorator) => decorator(resourceSerialId, acc), resourceOrMessage);
+  }
+  return resourceOrMessage;
+};
+const decorateAllResourcesOfType = (resources, decorators) => {
+  return Object.entries(resources).reduce((acc, [resourceSerialId, resource]) => {
+    acc[resourceSerialId] = decoratedResourceOrMessage(resourceSerialId, resource, decorators);
+    return acc;
+  }, {});
+};
+const createDevtools = (immerMiddlewere, config) => {
+  const { enabled = false } = config;
+  if (enabled && process.env.NODE_ENV === "development") {
+    return devtools(immerMiddlewere, config);
+  }
+  return immerMiddlewere;
+};
+function createRealTimeStore(initProps, storeDevtoolsEnabled = false) {
+  const startProps = {
+    ...initProps,
+    hasResourcesTypes: {},
+    customData: {}
+  };
+  const hasResourcesTypesMessageManager = {};
+  return createStore(
+    createDevtools(
+      immer((set, get) => ({
+        ...startProps,
+        realTimeConsumerActions: {
+          /**
+           * Incializa el store con los recursos configurados, e inicia la captura de datos para cada tipo de recurso suscripto.
+           */
+          loadResourceType: (resourceTypeId, hasResources) => {
+            const decoratedResources = decorateAllResourcesOfType(hasResources, get().hasResourcesTypesDecorators?.[resourceTypeId]);
+            set((state) => {
+              state.hasResourcesTypes[resourceTypeId] = {
+                hasResources: decoratedResources || {}
+              };
+              hasResourcesTypesMessageManager[resourceTypeId] = {
+                messagesToProcces: [],
+                messagesQueue: new ObjectQueue(),
+                statusProccesing: false
+              };
+            });
+          },
+          /**
+           * Funcion que procesa los mensajes que llegan desde el servidor, indpendiente de donde llegue, sea por socket, simulados, etc.
+           */
+          onMessages: (resourceTypeId, messages) => {
+            messages.forEach((message) => {
+              hasResourcesTypesMessageManager[resourceTypeId].messagesQueue.enqueue(message);
+            });
+            get().realTimeConsumerActions.processMessages(resourceTypeId);
+          },
+          /**
+           * Procesa los mensajes en la cola de mensajes, se encarga de procesar los mensajes uno a uno en el orden que llegaron.
+           */
+          processMessages: (initialResourceTypeId) => {
+            if (hasResourcesTypesMessageManager[initialResourceTypeId].statusProccesing) {
+              return;
+            }
+            function processNext(resourceTypeId) {
+              let continueNext = true;
+              set((state) => {
+                const message = hasResourcesTypesMessageManager[resourceTypeId].messagesQueue.dequeue();
+                if (message) {
+                  const { resourceSerialId, payload } = message;
+                  const decoratedPayload = decoratedResourceOrMessage(resourceSerialId, payload, state.hasResourcesTypesDecorators?.[resourceTypeId]);
+                  if (!state.hasResourcesTypes[resourceTypeId].hasResources[resourceSerialId]) {
+                    state.hasResourcesTypes[resourceTypeId].hasResources[resourceSerialId] = { ...cloneDeep(decoratedPayload), resourceSerialId };
+                  } else {
+                    merge(state.hasResourcesTypes[resourceTypeId].hasResources[resourceSerialId], decoratedPayload);
+                  }
+                }
+                if (hasResourcesTypesMessageManager[resourceTypeId].messagesQueue.isEmpty()) {
+                  hasResourcesTypesMessageManager[resourceTypeId].statusProccesing = false;
+                  continueNext = false;
+                } else {
+                  hasResourcesTypesMessageManager[initialResourceTypeId].statusProccesing = true;
+                }
+              });
+              if (continueNext) {
+                setTimeout(() => {
+                  processNext(resourceTypeId);
+                }, PROCCESS_MESSAGES_INTERVAL);
+              }
+            }
+            processNext(initialResourceTypeId);
+          },
+          /**
+           * Modifica parcialmente el custom data.
+           */
+          setCustomData: (customData) => {
+            set((state) => {
+              merge(state.customData, customData);
+            });
+          }
+        }
+      })),
+      { name: `${REALTIME_CONSUMER_SOTORE_ID}: ${initProps.storeId}`, enabled: storeDevtoolsEnabled }
+    )
+  );
+}
+export {
+  createRealTimeStore as c
+};

package/contexts/RealTimeConsumerContext/types.d.ts

@@ -0,0 +1,64 @@
+import { ReactNode } from 'react';
+import { OnRealTimeConsumerMessageCallback, OnRealTimeConsumerSuscribeCallback, RealTimeMessagePayload, RealTimeResourceSerialId, RealTimeResourceTypeId } from '../RealTimeProducerContext/types';
+/**
+ * Decorador de los mensajes, solo se decora el payload
+ */
+export type RealTimeMessageDecorator = (resourceSerialId: RealTimeResourceSerialId, message: RealTimeMessagePayload) => RealTimeMessagePayload;
+/**
+ * Store del tiempo real, actualizado por sockets
+ */
+export interface RealTimeConsumer {
+    /**
+     * Datos del tiempo real
+     */
+    hasResources: Record<RealTimeResourceSerialId, Record<string, any>>;
+}
+/**
+ * Store del tiempo real, actualizado por sockets
+ */
+export interface RealTimeConsumerStoreState {
+    /**
+     * Id del store
+     */
+    storeId: string;
+    /**
+     * Tiempo de real de los recursos.
+     */
+    hasResourcesTypes: Record<RealTimeResourceTypeId, RealTimeConsumer>;
+    /**
+     * Decorados de los recursos y los mensajes.
+     */
+    hasResourcesTypesDecorators?: Record<RealTimeResourceTypeId, RealTimeMessageDecorator[]>;
+    /**
+     * Lugar para poner cualquier data que se requiera adicional al tiempo real
+     */
+    customData: Record<string, any>;
+}
+export interface RealTimeConsumerStoreStateWithActions extends RealTimeConsumerStoreState {
+    realTimeConsumerActions: {
+        /**
+         * Inicialización del resource type, con lo que el producer tenga en este momento
+         */
+        loadResourceType(resourceTypeId: RealTimeResourceTypeId, hasResources: Record<RealTimeResourceSerialId, any>): void;
+        /**
+         * Funcion que procesa los mensajes que llegan desde el servidor, indpendiente de donde llegue, sea por socket, simulados, etc.
+         * Los reparte a los clientes suscritos y al propio hasResources del store.
+         */
+        onMessages: OnRealTimeConsumerMessageCallback;
+        /**
+         * Funcion que procesa los mensajes utilizando la cola
+         */
+        processMessages: (resourceTypeId: RealTimeResourceTypeId) => void;
+        /**
+         * Modifica parcialmente el custom data.
+         */
+        setCustomData: (customData: Record<string, any>) => void;
+    };
+}
+export type InitialRealTimeStoreProps = Omit<RealTimeConsumerStoreState, 'hasResourcesTypes' | 'filteredDevicesIds' | 'customData'>;
+export interface RealTimeProviderProps extends Omit<InitialRealTimeStoreProps, 'storeId'> {
+    storeDevtoolsEnabled?: boolean;
+    onMessagesCallbacks?: OnRealTimeConsumerMessageCallback[];
+    onSuscribeCallbacks?: OnRealTimeConsumerSuscribeCallback[];
+    children: ReactNode;
+}

package/contexts/RealTimeProducerContext/RealTimeProducerContext.d.ts

@@ -0,0 +1,11 @@
+import { RealTimeProducerProviderProps } from './types';
+declare const RealTimeProducerContext: import('react').Context<import('zustand').StoreApi<import('./types').RealTimeProducerStoreStateWithActions> | null>;
+/**
+ * Provedor del contexto de los realTimeas
+ * @returns
+ */
+/**
+ * TODO: Documentar
+ */
+declare function RealTimeProducerProvider(props: RealTimeProducerProviderProps): import("react/jsx-runtime").JSX.Element;
+export { RealTimeProducerProvider, RealTimeProducerContext };

package/contexts/RealTimeProducerContext/RealTimeProducerContext.js

@@ -0,0 +1,20 @@
+import { jsx } from "react/jsx-runtime";
+import { createContext, useRef } from "react";
+import { c as createRealTimeStore } from "./store.js";
+const RealTimeProducerContext = createContext(null);
+function RealTimeProducerProvider(props) {
+  const { children, storeDevtoolsEnabled = false, ...other } = props;
+  const realTimeStoreRef = useRef();
+  if (!realTimeStoreRef.current) {
+    realTimeStoreRef.current = createRealTimeStore({
+      ...other,
+      storeId: "RealTimeProducer Host"
+    }, storeDevtoolsEnabled);
+    realTimeStoreRef.current.getState().realTimeProducerActions.init();
+  }
+  return /* @__PURE__ */ jsx(RealTimeProducerContext.Provider, { value: realTimeStoreRef.current, children });
+}
+export {
+  RealTimeProducerContext as R,
+  RealTimeProducerProvider as a
+};

package/contexts/RealTimeProducerContext/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const PROCCESS_MESSAGES_INTERVAL = 1;
+export declare const REALTIME_PRODUCER_SOTORE_ID = "M4LRealTimeProducerStore";
+export declare enum EnumResourceTypesIds {
+    devices = "rt_devices",
+    user = "rt_user"
+}

package/contexts/RealTimeProducerContext/constants.js

@@ -0,0 +1,12 @@
+const PROCCESS_MESSAGES_INTERVAL = 1;
+const REALTIME_PRODUCER_SOTORE_ID = "M4LRealTimeProducerStore";
+var EnumResourceTypesIds = /* @__PURE__ */ ((EnumResourceTypesIds2) => {
+  EnumResourceTypesIds2["devices"] = "rt_devices";
+  EnumResourceTypesIds2["user"] = "rt_user";
+  return EnumResourceTypesIds2;
+})(EnumResourceTypesIds || {});
+export {
+  EnumResourceTypesIds as E,
+  PROCCESS_MESSAGES_INTERVAL as P,
+  REALTIME_PRODUCER_SOTORE_ID as R
+};

package/contexts/RealTimeProducerContext/index.d.ts

@@ -0,0 +1,4 @@
+export * from './RealTimeProducerContext';
+export type { RealTimeResourceSourceMechanismConfig as RealTimeResourceTypeConfig, OnRealTimeConsumerMessageCallback, OnRealTimeConsumerSuscribeCallback, OnMessagesStoreCallback, RealTimeResourceSerialId as RealTimeResourceId, RealTimeMessage, RealTimeResourceTypeId, RealTimeMessagePayload, MessageQueueManager } from './types';
+export { EnumResourceTypesIds } from './constants';
+export { REAL_TIME_RT_DEVICES_DUMMMY_INITIAL } from './sourceDataMechanisms/dummy/constants';

package/contexts/RealTimeProducerContext/index.js

@@ -0,0 +1 @@
+

package/contexts/RealTimeProducerContext/sourceDataMechanisms/athmospherejs/index.d.ts

@@ -0,0 +1,33 @@
+import { OnMessagesStoreCallback, RealTimeResourceSourceMechanismConfigAtmosphere } from '../../types';
+import { SourceDataBase } from '../base';
+/**
+ *
+ */
+export declare class SourceDataAtmosphere extends SourceDataBase {
+    private subSocket;
+    private stopped;
+    private reconnectTimeout;
+    private lastMessageTime;
+    constructor(config: RealTimeResourceSourceMechanismConfigAtmosphere, onMessages: OnMessagesStoreCallback);
+    /**
+     * Inicia la conexión con el servidor de tiempo real.
+     */
+    start(): void;
+    /**
+     * Envia la suscripción al servidor de tiempo real.
+     */
+    private sendSuscribe;
+    /**
+     * Conecta al servidor de tiempo real.
+     */
+    private connect;
+    /**
+     * Intenta reconectar al servidor de tiempo real.
+     */
+    private tryReconnect;
+    /**
+     * Detiene la conexión con el servidor de tiempo real.
+     */
+    stop(): void;
+}
+export default SourceDataAtmosphere;

package/contexts/RealTimeProducerContext/sourceDataMechanisms/athmospherejs/index.js

@@ -0,0 +1,140 @@
+import { S as SourceDataBase } from "../base.js";
+import * as atmosphere from "atmosphere.js";
+import { c as camelcaseKeys } from "../../../../not_recognized/index.js";
+class SourceDataAtmosphere extends SourceDataBase {
+  subSocket = null;
+  stopped = false;
+  reconnectTimeout = null;
+  lastMessageTime = performance.now();
+  constructor(config, onMessages) {
+    super(config, onMessages);
+  }
+  /**
+   * Inicia la conexión con el servidor de tiempo real.
+   */
+  start() {
+    this.stopped = false;
+    this.connect();
+  }
+  /**
+   * Envia la suscripción al servidor de tiempo real.
+   */
+  sendSuscribe() {
+    this.lastMessageTime = performance.now();
+    const { sessionId } = this.config;
+    this.subSocket?.push?.(JSON.stringify({
+      "action": "subscribe",
+      "session_id": sessionId,
+      "version": "1.0.0",
+      "resource_type_id": "rt_devices",
+      "database": "operative",
+      "consumer_type": "batch",
+      "rate_limit": 3,
+      "resources_id": ["all"],
+      "projections": []
+    }));
+  }
+  /**
+   * Conecta al servidor de tiempo real.
+   */
+  connect() {
+    if (this.stopped) {
+      return;
+    }
+    const { host, path, topic } = this.config;
+    const request = {
+      url: `wss://${host}${path}${topic}`,
+      contentType: "application/json",
+      logLevel: "debug",
+      transport: "websocket",
+      fallbackTransport: "long-polling",
+      reconnectInterval: 2e3,
+      /**
+       * Cuando se abre la conexión.
+       */
+      onOpen: (_response) => {
+        this.lastMessageTime = performance.now();
+        this.sendSuscribe();
+      },
+      /**
+       * Cuando se reabre la conexión.
+       */
+      onReopen: (_response) => {
+        this.sendSuscribe();
+      },
+      /**
+       * Cuando se recibe un mensaje.
+       */
+      onMessage: (response) => {
+        try {
+          const message = camelcaseKeys(JSON.parse(response.responseBody), { deep: true });
+          if (message.type === "event") {
+            const { messages } = message.data;
+            this.onMessages(this.config.resourceTypeId, messages);
+          } else if (message.type === "success") {
+          } else {
+            console.error(`Atmosphere: Error de suscripción ${performance.now() - this.lastMessageTime}ms`, message);
+          }
+          this.lastMessageTime = performance.now();
+        } catch (e) {
+          console.error("Atmosphere: JSON inválido", e);
+        }
+      },
+      /**
+       * Cuando se cierra la conexión.
+       */
+      onClose: () => {
+        this.tryReconnect();
+      },
+      /**
+       * Cuando ocurre un error.
+       */
+      onError: () => {
+        this.tryReconnect();
+      }
+    };
+    if (this.subSocket) {
+      try {
+        this.subSocket.close?.();
+      } catch {
+      }
+      this.subSocket = null;
+    }
+    if (atmosphere.subscribe) {
+      this.lastMessageTime = performance.now();
+      this.subSocket = atmosphere.subscribe(request);
+    }
+  }
+  /**
+   * Intenta reconectar al servidor de tiempo real.
+   */
+  tryReconnect() {
+    if (this.stopped) {
+      return;
+    }
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+    }
+    this.reconnectTimeout = setTimeout(() => this.connect(), 2e3);
+  }
+  /**
+   * Detiene la conexión con el servidor de tiempo real.
+   */
+  stop() {
+    this.stopped = true;
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+    if (this.subSocket) {
+      try {
+        this.subSocket.close?.();
+      } catch {
+      }
+      this.subSocket = null;
+    }
+  }
+}
+export {
+  SourceDataAtmosphere as S
+};

package/contexts/RealTimeProducerContext/sourceDataMechanisms/athmospherejs/types.d.ts

@@ -0,0 +1,28 @@
+import { RealTimeMessage, RealTimeResourceTypeId } from '../../types';
+export type AtmosphereMessageType = 'success' | 'event' | 'error';
+export type AtmosphereMessageAction = 'subscribe' | 'unsuscribe' | 'event';
+/**
+ * Mensajes que llegan desde atmosphere
+ */
+export interface AtmosphereMessageResponseSucces {
+    type: 'success';
+    action: 'subscribe' | 'unsuscribe';
+}
+export interface AtmosphereMessageResponseError {
+    type: 'error';
+    action: 'subscribe' | 'unsuscribe';
+    data: {
+        status: number;
+        message: string;
+    };
+}
+export interface AtmosphereMessageEvent {
+    type: 'event';
+    action: 'event';
+    data: {
+        version: string;
+        resource_type_id: RealTimeResourceTypeId;
+        messages: RealTimeMessage[];
+    };
+}
+export type AtmosphereMessage = AtmosphereMessageResponseSucces | AtmosphereMessageEvent | AtmosphereMessageResponseError;

package/contexts/RealTimeProducerContext/sourceDataMechanisms/base.d.ts

@@ -0,0 +1,15 @@
+import { OnMessagesStoreCallback, RealTimeResourceSourceMechanismConfig } from '../types';
+/**
+ *
+ */
+export declare abstract class SourceDataBase {
+    protected onMessages: OnMessagesStoreCallback;
+    protected config: RealTimeResourceSourceMechanismConfig;
+    /**
+     * Constructor
+     */
+    constructor(config: RealTimeResourceSourceMechanismConfig, onMessages: OnMessagesStoreCallback);
+    abstract start(): void;
+    abstract stop(): void;
+}
+export default SourceDataBase;

package/contexts/RealTimeProducerContext/sourceDataMechanisms/base.js

@@ -0,0 +1,14 @@
+class SourceDataBase {
+  onMessages;
+  config;
+  /**
+   * Constructor
+   */
+  constructor(config, onMessages) {
+    this.onMessages = onMessages;
+    this.config = config;
+  }
+}
+export {
+  SourceDataBase as S
+};

package/contexts/RealTimeProducerContext/sourceDataMechanisms/dummy/constants.d.ts

@@ -0,0 +1,23 @@
+import { DeviceDataType } from '../../../../@types';
+export declare const devicesIds: number[];
+export declare const devicesStatusIds: number[];
+export declare const devicesColors: string[];
+/**
+ * Pendientes de diseno
+ * Crear el Modulo Mi GPS Device
+ */
+export declare const INITIAL_DATA: DeviceDataType;
+export declare const INITIAL_DATA_10000: DeviceDataType;
+export declare const INITIAL_DATA_10001: DeviceDataType;
+export declare const INITIAL_DATA_10002: DeviceDataType;
+export declare const INITIAL_DATA_10003: DeviceDataType;
+export declare const INITIAL_DATA_10004: DeviceDataType;
+export declare const INITIAL_DATA_10005: DeviceDataType;
+export declare const REAL_TIME_RT_DEVICES_DUMMMY_INITIAL: {
+    10000: DeviceDataType;
+    10001: DeviceDataType;
+    10002: DeviceDataType;
+    10003: DeviceDataType;
+    10004: DeviceDataType;
+    10005: DeviceDataType;
+};

package/contexts/RealTimeProducerContext/sourceDataMechanisms/dummy/constants.js

@@ -0,0 +1,136 @@
+import { a as GNSSEnumSignal } from "../../../../@types/constants.js";
+import { g as group5, a as group4, b as group3, c as group2, d as group1, e as group0 } from "./group.js";
+import { g as getDummyRandomCoordinates } from "./helpers.js";
+const devicesIds = [1e4, 10001, 10002, 10003, 10004, 10005];
+const devicesStatusIds = [2, 1, 2, 3, 4, 5];
+const INITIAL_DATA = {
+  resourceSerialId: 0,
+  current: {
+    vpts: {
+      vptGnss: {
+        gnssAddress: "Vía Sabanalarga - Barranquilla, Km 2.42 Sabanalarga - Campeche Sabanalarga, Atlántico",
+        gnssSpeed: Math.random() * 120,
+        gnssMotionStatus: { value: devicesStatusIds[0], udaptedAt: (/* @__PURE__ */ new Date()).toISOString() },
+        gnssCourse: Math.random() * 360,
+        ...getDummyRandomCoordinates(),
+        geofences: [],
+        pois: [],
+        gnssSignal: {
+          value: GNSSEnumSignal.reliable,
+          udaptedAt: void 0
+        },
+        gnssHdop: 0,
+        gnssSatelliteQuantity: 0,
+        gnssAltitude: 0,
+        gnssLatitude: 0,
+        gnssLongitude: 0,
+        gnssOdometer: 0
+      },
+      vptModem: {
+        lastConnection: (/* @__PURE__ */ new Date()).toISOString(),
+        lastEvent: (/* @__PURE__ */ new Date()).toISOString(),
+        modemCsq: 31,
+        callActive: false
+      }
+    },
+    reportProfiles: {
+      trackerEvents: {
+        lastEvent: {
+          date: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      }
+    }
+  },
+  settings: {
+    active: true,
+    imageUrl: "carga.png",
+    name: "N10000",
+    properties: {
+      internal_name: {
+        value: "222",
+        type: "string"
+      }
+    },
+    inTechinalOrder: false,
+    adminStatus: ""
+  }
+};
+const INITIAL_DATA_10000 = {
+  ...INITIAL_DATA,
+  resourceSerialId: 1e4,
+  settings: {
+    ...INITIAL_DATA.settings,
+    active: false,
+    name: "N10000A",
+    imageUrl: "sedan.png",
+    group: group0
+  }
+};
+const INITIAL_DATA_10001 = {
+  ...INITIAL_DATA,
+  resourceSerialId: 10001,
+  settings: {
+    ...INITIAL_DATA.settings,
+    active: true,
+    name: "N10001B",
+    imageUrl: "sedan.png",
+    group: group1
+  }
+};
+const INITIAL_DATA_10002 = {
+  ...INITIAL_DATA,
+  resourceSerialId: 10002,
+  settings: {
+    ...INITIAL_DATA.settings,
+    active: true,
+    name: "N10002C",
+    imageUrl: "minivan.png",
+    group: group2
+  }
+};
+const INITIAL_DATA_10003 = {
+  ...INITIAL_DATA,
+  resourceSerialId: 10003,
+  settings: {
+    ...INITIAL_DATA.settings,
+    active: true,
+    name: "N10003D",
+    imageUrl: "truck_car.png",
+    group: group3
+  }
+};
+const INITIAL_DATA_10004 = {
+  ...INITIAL_DATA,
+  resourceSerialId: 10004,
+  settings: {
+    ...INITIAL_DATA.settings,
+    active: true,
+    name: "N10004E",
+    imageUrl: "truck.png",
+    group: group4
+  }
+};
+const INITIAL_DATA_10005 = {
+  ...INITIAL_DATA,
+  resourceSerialId: 10005,
+  settings: {
+    ...INITIAL_DATA.settings,
+    active: true,
+    name: "N10005F",
+    imageUrl: "truck.png",
+    group: group5
+  }
+};
+const REAL_TIME_RT_DEVICES_DUMMMY_INITIAL = {
+  [1e4]: INITIAL_DATA_10000,
+  [10001]: INITIAL_DATA_10001,
+  [10002]: INITIAL_DATA_10002,
+  [10003]: INITIAL_DATA_10003,
+  [10004]: INITIAL_DATA_10004,
+  [10005]: INITIAL_DATA_10005
+};
+export {
+  REAL_TIME_RT_DEVICES_DUMMMY_INITIAL as R,
+  devicesIds as a,
+  devicesStatusIds as d
+};

package/contexts/RealTimeProducerContext/sourceDataMechanisms/dummy/dummy.d.ts

@@ -0,0 +1,23 @@
+import { DeviceDataType } from '../../../../@types';
+import { OnMessagesStoreCallback, RealTimeResourceSerialId, RealTimeResourceSourceMechanismConfig } from '../../types';
+import { SourceDataBase } from '../base';
+export type DumyData = {
+    readonly resourceSerialId: RealTimeResourceSerialId;
+    readonly payload: Pick<DeviceDataType, 'current'>;
+};
+/**
+ * Dummy source data mechanism
+ */
+declare class SourceDataDummy extends SourceDataBase {
+    private intervalId;
+    constructor(config: RealTimeResourceSourceMechanismConfig, onMessages: OnMessagesStoreCallback);
+    /**
+     * Start the source data
+     */
+    start(): void;
+    /**
+     * Stop the source data
+     */
+    stop(): void;
+}
+export default SourceDataDummy;