@signalk/server-api 2.6.1 → 2.7.0

package/dist/serverapi.d.ts

@@ -0,0 +1,369 @@
+import { SKVersion, AutopilotProviderRegistry, Features, PropertyValuesEmitter, ResourceProviderRegistry, Delta } from '.';
+import { CourseApi } from './course';
+import { StreamBundle } from './streambundle';
+import { SubscriptionManager } from './subscriptionmanager';
+/**
+ * SignalK server provides an interface to allow {@link Plugin | Plugins } to:
+ *
+ * - Discover Features.
+ * - Access / update the full data model
+ * - send / receive deltas (updates)
+ * - Interact with APIs
+ * - Expose HTTP endpoints
+ *
+ * These functions are available via the app object passed to the plugin when it is invoked.
+ *
+ * > [!WARNING]
+ * > Typing is incomplete. If you find a missing or inaccurate type, please [report it](https://github.com/SignalK/signalk-server/issues/1917).
+ */
+export interface ServerAPI extends PropertyValuesEmitter, ResourceProviderRegistry, AutopilotProviderRegistry, Features, CourseApi, SelfIdentity {
+    /**
+     * Returns the entry for the provided path starting from `vessels.self` in the full data model.
+     *
+     * @example
+     * ```ts
+     * let uuid = app.getSelfPath('uuid');
+     * // Note: This is synonymous with app.getPath('vessels.self.uuid')
+     *
+     * app.debug(uuid);
+     * // urn:mrn:signalk:uuid:a9d2c3b1-611b-4b00-8628-0b89d014ed60
+     * ```
+     *
+     * @category Data Model
+     */
+    getSelfPath(path: string): any;
+    /**
+     * Returns the entry for the provided path starting from the `root` of the full data model.
+     *
+     * @example
+     * ```javascript
+     * let baseStations = app.getPath('shore.basestations');
+     *
+     * // baseStations:
+     * {
+     *   'urn:mrn:imo:mmsi:2766140': {
+     *     url: 'basestations',
+     *     navigation: { position: {latitude: 45.2, longitude: 76.4} },
+     *     mmsi: '2766140'
+     *   },
+     *   'urn:mrn:imo:mmsi:2766160': {
+     *     url: 'basestations',
+     *     navigation: { position: {latitude: 46.9, longitude: 72.22} },
+     *     mmsi: '2766160'
+     *   }
+     * }
+     * ```
+     *
+     * @category Data Model
+     */
+    getPath(path: string): any;
+    /**
+     * @category Data Model
+     */
+    getMetadata(path: string): Metadata | undefined;
+    /**
+     * @category Data Model
+     */
+    putSelfPath(aPath: string, value: any, updateCb: () => void): Promise<any>;
+    /**
+     * @category Data Model
+     */
+    putPath(aPath: string, value: number | string | object | boolean, updateCb: (err?: Error) => void, source: string): Promise<any>;
+    /**
+     * @category Data Model
+     */
+    streambundle: StreamBundle;
+    /**
+     * @see [Processing data from the server](../../../docs/develop/plugins/deltas.md#subscribing-to-deltas)
+     * @category Data Model
+     */
+    subscriptionmanager: SubscriptionManager;
+    queryRequest(requestId: string): Promise<any>;
+    /**
+     * @category Status and Debugging
+     */
+    error(msg: string): void;
+    /**
+     * Log debug messages.
+     *
+     * This function exposes the `debug` method from the [debug module](https://www.npmjs.com/package/debug).
+     * The npm module name is used as the debug name.
+     *
+     * `app.debug()` can take any type and will serialize it before outputting.
+     *
+     * > [!note]
+     * > Do not use `debug` from the debug module directly! Using `app.debug()` provided by the server ensures that the plugin taps into the server's debug logging system, including the helper switches in Admin UI's Server Log page.
+     *
+     * @category Status and Debugging
+     */
+    debug(msg: string): void;
+    /**
+     * Register a function to intercept all delta messages _before_ they are processed by the server.
+     *
+     * The callback function should call `next(delta)` with either:
+     * - A modified delta (if it wants to alter the incoming delta)
+     * - With the original delta to process it normally.
+     *
+     * > [!important]
+     * > Not calling `next(delta)` will cause the incoming delta to be dropped and will only show in delta statistics.
+     *
+     * Other, non-delta messages produced by provider pipe elements are emitted normally.
+     *
+     * @example
+     * ```javascript
+     * app.registerDeltaInputHandler((delta, next) => {
+     *   delta.updates.forEach(update => {
+     *     update.values.forEach(pathValue => {
+     *       if(pathValue.startsWith("foo")) {
+     *         pathValue.path = "bar"
+     *       }
+     *     })
+     *   })
+     *   next(delta)
+     * });
+     * ```
+     *
+     * @category Data Model
+     */
+    registerDeltaInputHandler(handler: DeltaInputHandler): void;
+    /**
+     * Set the current status of the plugin that is displayed in the plugin configuration UI and the Dashboard.
+     *
+     * The `msg` parameter should be a short text message describing the current status of the plugin.
+     *
+     * @example
+     * ```javascript
+     * app.setPluginStatus('Initializing');
+     * // Do something
+     * app.setPluginStatus('Done initializing');
+     * ```
+     *
+     * _Note: Replaces deprecated `setProviderStatus()`_
+     *
+     * @category Status and Debugging
+     */
+    setPluginStatus(msg: string): void;
+    /**
+     * Set the current error status of the plugin that is displayed in the plugin configuration UI and the Dashboard.
+     *
+     * The `msg` parameter should be a short text message describing the current status of the plugin.
+     *
+     * @example
+     * ```javascript
+     * app.setPluginError('Error connecting to database');
+     * ```
+     *
+     * _Note: Replaces deprecated `setProviderError()`_
+     *
+     * @category Status and Debugging
+     */
+    setPluginError(msg: string): void;
+    /**
+     * Emit a delta message.
+     *
+     * _Note: These deltas are handled by the server in the same way as any other incoming deltas._
+     *
+     * @example
+     * ```javascript
+     * app.handleMessage('my-signalk-plugin', {
+     *   updates: [
+     *     {
+     *       values: [
+     *         {
+     *           path: 'navigation.courseOverGroundTrue',
+     *           value: 1.0476934
+     *         }
+     *       ]
+     *     }
+     *   ]
+     * });
+     * ```
+     *
+     * Plugins emitting deltas that use Signal K v2 paths (like the [Course API](http://localhost:3000/admin/openapi/?urls.primaryName=course) paths) should call `handleMessage` with the optional `skVersion` parameter set to `v2`. This prevents v2 API data getting mixed in v1 paths' data in full data model & the v1 http API.
+     *
+     * Omitting the `skVersion` parameter will cause the delta to be sent as `v1`.
+     *
+     * @param skVersion Optional parameter to specify the Signal K version of the delta.
+     * @category Data Model
+     */
+    handleMessage(id: string, msg: Partial<Delta>, skVersion?: SKVersion): void;
+    /**
+     * Save changes to the plugin's configuration options.
+     *
+     * @example
+     * ```javascript
+     * let options = {
+     *   myConfigValue = 'Something the plugin calculated'
+     * };
+     *
+     * app.savePluginOptions(options, () => {app.debug('Plugin options saved')});
+     * ```
+     *
+     * @category Configuration
+     */
+    savePluginOptions(configuration: object, cb: (err: NodeJS.ErrnoException | null) => void): void;
+    /**
+     * Read the stored plugin configuration options.
+     *
+     * @example
+     * ```javascript
+     * let options = app.readPluginOptions();
+     * ```
+     *
+     * @category Configuration
+     */
+    readPluginOptions(): object;
+    /**
+     * Returns the full path of the directory where the plugin can persist its internal data, e.g. data files, etc.
+     *
+     * @example
+     * ```javascript
+     * let myDataFile = require('path').join( app.getDataDirPath(), 'somedatafile.ext')
+     * ```
+     * @category Configuration
+     */
+    getDataDirPath(): string;
+    /**
+     * Register a handler to action [`PUT`](http://signalk.org/specification/1.3.0/doc/put.html) requests for a specific path.
+     *
+     * The action handler can handle the request synchronously or asynchronously.
+     *
+     * The `callback` parameter should be a function which accepts the following arguments:
+     * - `context`
+     * - `path`
+     * - `value`
+     * - `callback`
+     *
+     * For synchronous actions, the handler must return a value describing the response of the request:
+     *
+     * ```javascript
+     * {
+     *   state: 'COMPLETED',
+     *   statusCode: 200
+     * }
+     * ```
+     *
+     *  or
+     *
+     *  ```javascript
+     * {
+     *   state:'COMPLETED',
+     *   statusCode: 400,
+     *   message:'Some Error Message'
+     * }
+     *  ```
+     *
+     *  The `statusCode` value can be any valid HTTP response code.
+     *
+     * For asynchronous actions, that may take considerable time to complete and the requester should not be kept waiting for the result, the handler must return:
+     *
+     * ```javascript
+     * { state: 'PENDING' }
+     * ```
+     *
+     * When the action has completed the handler should call the `callback` function with the result:
+     *
+     * ```javascript
+     * callback({ state: 'COMPLETED', statusCode: 200 })
+     * ```
+     * or
+     *
+     * ```javascript
+     * callback({
+     *   state:'COMPLETED',
+     *   statusCode: 400,
+     *   message:'Some Error Message'
+     * })
+     * ```
+     *
+     * _Example: Synchronous response:_
+     * ```javascript
+     * function myActionHandler(context, path, value, callback) {
+     *   if(doSomething(context, path, value)){
+     *     return { state: 'COMPLETED', statusCode: 200 };
+     *   } else {
+     *     return { state: 'COMPLETED', statusCode: 400 };
+     *   }
+     * }
+     *
+     * plugin.start = (options) => {
+     *   app.registerPutHandler('vessels.self', 'some.path', myActionHandler, 'somesource.1');
+     * }
+     * ```
+     *
+     * _Example: Asynchronous response:_
+     * ```javascript
+     * function myActionHandler(context, path, value, callback) {
+     *
+     *   doSomethingAsync(context, path, value, (result) =>{
+     *     if(result) {
+     *       callback({ state: 'COMPLETED', result: 200 })
+     *     } else {
+     *       callback({ state: 'COMPLETED', result: 400 })
+     *     }
+     *   });
+     *
+     *   return { state: 'PENDING' };
+     * }
+     *
+     * plugin.start = (options) => {
+     *   app.registerPutHandler('vessels.self', 'some.path', myActionHandler);
+     * }
+     * ```
+     */
+    registerPutHandler(context: string, path: string, callback: () => void, source: string): void;
+    registerActionHandler(context: string, path: string, callback: () => void, source: string): void;
+    registerHistoryProvider(provider: {
+        hasAnydata: (options: object, cb: (hasResults: boolean) => void) => void;
+        getHistory: (date: Date, path: string, cb: (deltas: object[]) => void) => void;
+        streamHistory: (spark: any, options: object, onDelta: (delta: object) => void) => void;
+    }): void;
+    /**
+     * Returns Ports object which contains information about the serial ports available on the machine.
+     *
+     * @category Serial Ports
+     */
+    getSerialPorts(): Promise<Ports>;
+    /**
+     * Report to the server that the plugin has sent data to other hosts, which will update the output message rate and
+     * icon in the Dashboard.
+     *
+     * _Note: This function is for use when the plugin is sending data to hosts other than the Signal K server (e.g.
+     * network packets, http requests or messages sent to a broker)._
+     *
+     * _**This function should NOT be used for deltas that the plugin sends with `handleMessage()`!**_
+     *
+     * @example
+     * ```javascript
+     * app.reportOutputMessages(54);
+     * ```
+     *
+     * @param count - number of handled messages between the last
+     * call and this one. If omitted the call will count as one output
+     * message.
+     *
+     * @category Status and Debugging
+     */
+    reportOutputMessages(count?: number): void;
+}
+/**
+ * @deprecated Use {@link ServerAPI} instead.
+ */
+export type PluginServerApp = ServerAPI;
+export type DeltaInputHandler = (delta: Delta, next: (delta: Delta) => void) => void;
+export interface Ports {
+    byId: string[];
+    byPath: string[];
+    byOpenPlotter: string[];
+    serialports: any;
+}
+export interface SelfIdentity {
+    selfType: string;
+    selfId: string;
+    selfContext: string;
+}
+export interface Metadata {
+    units?: string;
+    description?: string;
+}
+//# sourceMappingURL=serverapi.d.ts.map

package/dist/serverapi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serverapi.d.ts","sourceRoot":"","sources":["../src/serverapi.ts"],"names":[],"mappings":"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"}

package/dist/serverapi.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=serverapi.js.map

package/dist/serverapi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"serverapi.js","sourceRoot":"","sources":["../src/serverapi.ts"],"names":[],"mappings":""}

package/dist/streambundle.d.ts

@@ -0,0 +1,148 @@
+import { NormalizedDelta, Path, Value } from './deltas';
+export interface StreamBundle {
+    /**
+     * Get a [Bacon JS 1.0](https://baconjs.github.io/api.html) stream for a Signal K path that will stream values from any context.
+     *
+     * Stream values are objects with the following structure:
+     * ```javascript
+     *   {
+     *     path: ...,
+     *     value: ...,
+     *     context: ...,
+     *     source: ...,
+     *     $source: ...,
+     *     timestamp: ...
+     *   }
+     * ```
+     *
+     * @example
+     * ```javascript
+     * app.streambundle
+     *   .getBus('navigation.position')
+     *   .onValue(pos => app.debug(pos));
+     *
+     * /* output
+     * {
+     *   path: 'navigation.position',
+     *   value: { longitude: 24.7366117, latitude: 59.72493 },
+     *   context: 'vessels.urn:mrn:imo:mmsi:2766160',
+     *   source: {
+     *     label: 'n2k-sample-data',
+     *     type: 'NMEA2000',
+     *     pgn: 129039,
+     *     src: '43'
+     *   },
+     *   '$source': 'n2k-sample-data.43',
+     *   timestamp: '2014-08-15T19:00:02.392Z'
+     * }
+     * {
+     *   path: 'navigation.position',
+     *   value: { longitude: 24.82365, latitude: 58.159598 },
+     *   context: 'vessels.urn:mrn:imo:mmsi:2766140',
+     *   source: {
+     *     label: 'n2k-sample-data',
+     *     type: 'NMEA2000',
+     *     pgn: 129025,
+     *     src: '160'
+     *   },
+     *   '$source': 'n2k-sample-data.160',
+     *   timestamp: '2014-08-15T19:00:02.544Z'
+     * }
+     * *\/
+     * ```
+     *
+     * @param path - If it is not provided the returned stream produces values for all paths.
+     */
+    getBus(path?: Path): Bacon.Bus<unknown, NormalizedDelta>;
+    /**
+     * Get a [Bacon JS](https://baconjs.github.io/) stream for path from the `vessels.self` context.
+     *
+     * @example
+     * ```javascript
+     *  app.streambundle
+     *    .getSelfBus('navigation.position')
+     *    .onValue(pos => app.debug(pos));
+     * ```
+     * Output:
+     * ```
+     * {
+     *   path: 'navigation.position',
+     *   value: { longitude: 24.7366117, latitude: 59.72493 },
+     *   context: 'vessels.urn:mrn:signalk:uuid:a9d2c3b1-611b-4b00-8628-0b89d014ed60',
+     *   source: {
+     *     label: 'n2k-sample-data',
+     *     type: 'NMEA2000',
+     *     pgn: 129039,
+     *     src: '43'
+     *   },
+     *   '$source': 'n2k-sample-data.43',
+     *   timestamp: '2014-08-15T19:00:02.392Z'
+     * }
+     * {
+     *   path: 'navigation.position',
+     *   value: { longitude: 24.7366208, latitude: 59.7249198 },
+     *   context: 'vessels.urn:mrn:signalk:uuid:a9d2c3b1-611b-4b00-8628-0b89d014ed60',
+     *   source: {
+     *     label: 'n2k-sample-data',
+     *     type: 'NMEA2000',
+     *     pgn: 129025,
+     *     src: '160'
+     *   },
+     *   '$source': 'n2k-sample-data.160',
+     *   timestamp: '2014-08-15T19:00:02.544Z'
+     * }
+     * ```
+     *
+     * @param path - If it is not provided the returned stream produces values for all paths.
+     */
+    getSelfBus(path: Path): Bacon.Bus<unknown, NormalizedDelta>;
+    /**
+     * Get a [Bacon JS](https://baconjs.github.io/) stream for a path in the `vessels.self` context.
+     *
+     * > [!NOTE]
+     * > This is similar to {@link getSelfBus}, except that the stream values contain only the `value` property from the incoming deltas.
+     *
+     * @example
+     * ```javascript
+     * app.streambundle
+     *   .getSelfStream('navigation.position')
+     *   .onValue(pos => app.debug(pos));
+     * ```
+     * Output:
+     * ```
+     *   my-signalk-plugin { longitude: 24.736677, latitude: 59.7250108 } +600ms
+     *   my-signalk-plugin { longitude: 24.736645, latitude: 59.7249883 } +321ms
+     *   my-signalk-plugin { longitude: 24.7366563, latitude: 59.7249807 } +174ms
+     *   my-signalk-plugin { longitude: 24.7366563, latitude: 59.724980699999996 } +503ms
+     *
+     * @param path - If it is not provided the returned stream produces values for all paths.
+     */
+    getSelfStream(path?: Path): Bacon.Bus<unknown, Value>;
+    /**
+     * Get a list of available full data model paths maintained by the server.
+     *
+     * @example
+     * ```javascript
+     * app.streambundle.getAvailablePaths();
+     * ```
+     * Returns
+     * ```json
+     * [
+     *   "navigation.speedOverGround",
+     *   "navigation.courseOverGroundTrue",
+     *   "navigation.courseGreatCircle.nextPoint.position",
+     *   "navigation.position",
+     *   "navigation.gnss.antennaAltitude",
+     *   "navigation.gnss.satellites",
+     *   "navigation.gnss.horizontalDilution",
+     *   "navigation.gnss.positionDilution",
+     *   "navigation.gnss.geoidalSeparation",
+     *   "navigation.gnss.type","navigation.gnss.methodQuality",
+     *   "navigation.gnss.integrity",
+     *   "navigation.magneticVariation",
+     * ]
+     * ```
+     */
+    getAvailablePaths(): Path[];
+}
+//# sourceMappingURL=streambundle.d.ts.map

package/dist/streambundle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streambundle.d.ts","sourceRoot":"","sources":["../src/streambundle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,UAAU,CAAA;AAEvD,MAAM,WAAW,YAAY;IAC3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoDG;IACH,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,GAAG,KAAK,CAAC,GAAG,CAAC,OAAO,EAAE,eAAe,CAAC,CAAA;IAExD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwCG;IACH,UAAU,CAAC,IAAI,EAAE,IAAI,GAAG,KAAK,CAAC,GAAG,CAAC,OAAO,EAAE,eAAe,CAAC,CAAA;IAE3D;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,aAAa,CAAC,IAAI,CAAC,EAAE,IAAI,GAAG,KAAK,CAAC,GAAG,CAAC,OAAO,EAAE,KAAK,CAAC,CAAA;IAErD;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,iBAAiB,IAAI,IAAI,EAAE,CAAA;CAC5B"}

package/dist/streambundle.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=streambundle.js.map

package/dist/streambundle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"streambundle.js","sourceRoot":"","sources":["../src/streambundle.ts"],"names":[],"mappings":""}

package/dist/subscriptionmanager.d.ts

@@ -0,0 +1,84 @@
+import { RelativePositionOrigin } from '.';
+import { Context, Delta, Path } from './deltas';
+export interface SubscriptionManager {
+    subscribe(command: SubscribeMessage, unsubscribes: Unsubscribes, errorCallback: (err: unknown) => void, callback: SubscribeCallback, user?: string): void;
+    unsubscribe(msg: UnsubscribeMessage, unsubscribes: Unsubscribes): void;
+}
+export type SubscribeCallback = (delta: Delta) => void;
+export type Unsubscribes = Array<() => void>;
+/**
+ * A message to allow a client to subscribe for data updates from a signalk server
+ *
+ * @see [SignalK Specification: Subscription Protocol](https://signalk.org/specification/1.7.0/doc/subscription_protocol.html?highlight=subscribe#introduction)
+ */
+export interface SubscribeMessage {
+    /**
+     * The context path for all subsequent paths, usually a vessel's path.
+     */
+    context: Context | RelativePositionOrigin;
+    /**
+     * An array of paths to subscribe to, with optional criteria
+     */
+    subscribe: SubscriptionOptions[];
+}
+/** @inline */
+type FixedPolicyOptions = {
+    /**
+     * - `fixed` - Send the last known values every `period`.
+     * - `inline` - Send all changes as fast as they are received, but no faster than `minPeriod`. With this policy the client has an immediate copy of the current state of the server.
+     */
+    policy?: 'fixed';
+    /**
+     * The subscription will be sent every period millisecs.
+     */
+    period?: number;
+    /**
+     * If policy=immediate or ideal, consecutive messages will be buffered until minPeriod has expired so the receiver is not swamped.
+     */
+    minPeriod?: never;
+};
+/** @inline docs inherited from above */
+type InstantPolicyOptions = {
+    policy?: 'instant';
+    minPeriod?: number;
+    period?: never;
+};
+/**
+ * A path object with optional criteria to control output
+ * @inline
+ */
+export type SubscriptionOptions = (FixedPolicyOptions | InstantPolicyOptions) & {
+    /**
+     * The path to subscribe to.
+     */
+    path?: Path;
+    /**
+     * The signal K format to use for the message. Only `delta` is currently supported. See [Signal K Data Model](https://signalk.org/specification/1.7.0/doc/data_model.html)
+     */
+    format?: 'delta';
+};
+/**
+ * A message to allow a client to unsubscribe from data updates from a signalk server
+ */
+export interface UnsubscribeMessage {
+    /**
+     * The root path for all subsequent paths, usually a vessel's path.
+     *
+     * > [!NOTE]
+     * > Currently only `*` is supported for the context.
+     */
+    context: '*';
+    /**
+     * An array of paths to unsubscribe from.
+  
+    * > [!NOTE]
+     * > Currently only one entry is supported, and it must have `"path": "*"`.
+     */
+    unsubscribe: [
+        {
+            path: '*';
+        }
+    ];
+}
+export {};
+//# sourceMappingURL=subscriptionmanager.d.ts.map

package/dist/subscriptionmanager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscriptionmanager.d.ts","sourceRoot":"","sources":["../src/subscriptionmanager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,GAAG,CAAA;AAC1C,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,UAAU,CAAA;AAE/C,MAAM,WAAW,mBAAmB;IAClC,SAAS,CACP,OAAO,EAAE,gBAAgB,EACzB,YAAY,EAAE,YAAY,EAC1B,aAAa,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,EACrC,QAAQ,EAAE,iBAAiB,EAC3B,IAAI,CAAC,EAAE,MAAM,GACZ,IAAI,CAAA;IAEP,WAAW,CAAC,GAAG,EAAE,kBAAkB,EAAE,YAAY,EAAE,YAAY,GAAG,IAAI,CAAA;CACvE;AAED,MAAM,MAAM,iBAAiB,GAAG,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAA;AAEtD,MAAM,MAAM,YAAY,GAAG,KAAK,CAAC,MAAM,IAAI,CAAC,CAAA;AAE5C;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,OAAO,EAAE,OAAO,GAAG,sBAAsB,CAAA;IAEzC;;OAEG;IACH,SAAS,EAAE,mBAAmB,EAAE,CAAA;CACjC;AAED,cAAc;AACd,KAAK,kBAAkB,GAAG;IACxB;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAA;IAEhB;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;IAEf;;OAEG;IACH,SAAS,CAAC,EAAE,KAAK,CAAA;CAClB,CAAA;AAED,wCAAwC;AACxC,KAAK,oBAAoB,GAAG;IAC1B,MAAM,CAAC,EAAE,SAAS,CAAA;IAClB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,MAAM,CAAC,EAAE,KAAK,CAAA;CACf,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAC9B,kBAAkB,GAClB,oBAAoB,CACvB,GAAG;IACF;;OAEG;IACH,IAAI,CAAC,EAAE,IAAI,CAAA;IAEX;;OAEG;IACH,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB,CAAA;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;;;OAKG;IACH,OAAO,EAAE,GAAG,CAAA;IAEZ;;;;;OAKG;IACH,WAAW,EAAE;QACX;YACE,IAAI,EAAE,GAAG,CAAA;SACV;KACF,CAAA;CACF"}

package/dist/subscriptionmanager.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=subscriptionmanager.js.map

package/dist/subscriptionmanager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscriptionmanager.js","sourceRoot":"","sources":["../src/subscriptionmanager.ts"],"names":[],"mappings":""}