@hahnpro/flow-sdk 4.14.4

package/dist/FlowLogger.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowLogger = exports.defaultLogger = void 0;
+const FlowEvent_1 = require("./FlowEvent");
+exports.defaultLogger = {
+    debug: (msg, metadata) => console.debug(msg),
+    error: (msg, metadata) => console.error(msg),
+    log: (msg, metadata) => console.log(msg),
+    warn: (msg, metadata) => console.warn(msg),
+    verbose: (msg, metadata) => console.log(msg, metadata),
+};
+class FlowLogger {
+    constructor(metadata, logger = exports.defaultLogger, publishEvent) {
+        this.metadata = metadata;
+        this.logger = logger;
+        this.publishEvent = publishEvent;
+        this.debug = (message) => this.publish(message, 'debug');
+        this.error = (message) => this.publish(message, 'error');
+        this.log = (message) => this.publish(message, 'info');
+        this.warn = (message) => this.publish(message, 'warn');
+        this.verbose = (message) => this.publish(message, 'verbose');
+    }
+    static getStackTrace() {
+        let stack;
+        try {
+            throw new Error('');
+        }
+        catch (error) {
+            stack = error.stack || '';
+        }
+        stack = stack
+            .split('\n')
+            .map((line) => line.trim())
+            .filter((value) => !value.includes('Logger'));
+        return stack.splice(1).join('\n');
+    }
+    publish(message, level) {
+        var _a;
+        if (this.publishEvent) {
+            const event = new FlowEvent_1.FlowEvent(this.metadata, message, `flow.log.${level}`);
+            (_a = this.publishEvent(event)) === null || _a === void 0 ? void 0 : _a.catch((err) => this.logger.error(err, this.metadata));
+        }
+        switch (level) {
+            case 'debug':
+                return this.logger.debug(message, this.metadata);
+            case 'error':
+                return this.logger.error(message, this.metadata);
+            case 'warn':
+                return this.logger.warn(message, this.metadata);
+            case 'verbose':
+                return this.logger.verbose(message, this.metadata);
+            default:
+                this.logger.log(message, this.metadata);
+        }
+    }
+}
+exports.FlowLogger = FlowLogger;

package/dist/FlowModule.d.ts

@@ -0,0 +1,7 @@
+import { FlowElement } from './FlowElement';
+export declare function FlowModule(metadata: {
+    name: string;
+    declarations: Array<ClassType<FlowElement>>;
+}): ClassDecorator;
+declare type ClassType<T> = new (...args: any[]) => T;
+export {};

package/dist/FlowModule.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowModule = void 0;
+function FlowModule(metadata) {
+    const fqnRegExp = new RegExp('^([a-zA-Z][a-zA-Z0-9]*[.-])*[a-zA-Z][a-zA-Z0-9]*$');
+    if (!fqnRegExp.test(metadata.name)) {
+        throw new Error(`Flow Module name (${metadata.name}) is not valid`);
+    }
+    return (target) => {
+        Reflect.defineMetadata('module:name', metadata.name, target);
+        Reflect.defineMetadata('module:declarations', metadata.declarations, target);
+    };
+}
+exports.FlowModule = FlowModule;

package/dist/RpcClient.d.ts

@@ -0,0 +1,11 @@
+import { AmqpConnectionManager } from 'amqp-connection-manager';
+export declare class RpcClient {
+    private channel;
+    private openRequests;
+    constructor(connection: AmqpConnectionManager);
+    private onMessage;
+    callFunction: (routingKey: string, functionName: string, ...args: any[]) => Promise<unknown>;
+    declareFunction: (routingKey: string, name: string) => (...args: any[]) => Promise<unknown>;
+    close(): Promise<void>;
+    static formatTrace(stack?: string): string;
+}

package/dist/RpcClient.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RpcClient = void 0;
+const uuid_1 = require("uuid");
+class RpcClient {
+    constructor(connection) {
+        this.openRequests = new Map();
+        this.onMessage = (msg) => {
+            if (this.openRequests.has(msg.properties.correlationId)) {
+                const { resolve, reject, trace } = this.openRequests.get(msg.properties.correlationId);
+                const response = JSON.parse(msg.content.toString());
+                switch (response.type) {
+                    case 'reply':
+                        resolve(response.value);
+                        break;
+                    case 'error': {
+                        const err = new Error(response.message);
+                        if (response.stack) {
+                            const stack = RpcClient.formatTrace(response.stack);
+                            err.stack = 'Remote Stack\n'.concat(stack, '\nLocal Stack\n', trace);
+                        }
+                        else {
+                            err.stack = trace;
+                        }
+                        reject(err);
+                        break;
+                    }
+                    default:
+                        reject(response);
+                        break;
+                }
+            }
+            else {
+                const message = `received unexpected response correlationID: ${msg.properties.correlationId}`;
+                console.warn(message);
+            }
+        };
+        this.callFunction = (routingKey, functionName, ...args) => {
+            const stack = new Error('test').stack;
+            return new Promise((resolve, reject) => {
+                const call = { functionName, arguments: args };
+                const correlationId = (0, uuid_1.v4)();
+                this.openRequests.set(correlationId, { resolve, reject, trace: RpcClient.formatTrace(stack) });
+                this.channel
+                    .publish('rpc_direct_exchange', routingKey, call, { correlationId, replyTo: 'amq.rabbitmq.reply-to' })
+                    .catch((err) => reject(err));
+            });
+        };
+        this.declareFunction = (routingKey, name) => {
+            return (...args) => this.callFunction(routingKey, name, ...args);
+        };
+        if (!connection) {
+            throw new Error('currently no amqp connection available');
+        }
+        this.channel = connection.createChannel({
+            json: true,
+            setup: (channel) => Promise.all([
+                channel.assertExchange('rpc_direct_exchange', 'direct', { durable: false }),
+                channel.consume('amq.rabbitmq.reply-to', this.onMessage, { noAck: true }),
+            ]),
+        });
+    }
+    close() {
+        return this.channel.close();
+    }
+    static formatTrace(stack = '') {
+        return stack.split('\n').splice(1).join('\n');
+    }
+}
+exports.RpcClient = RpcClient;

package/dist/TestModule.d.ts

@@ -0,0 +1,2 @@
+export declare class TestModule {
+}

package/dist/TestModule.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestModule = void 0;
+const tslib_1 = require("tslib");
+const FlowElement_1 = require("./FlowElement");
+const FlowEvent_1 = require("./FlowEvent");
+const FlowModule_1 = require("./FlowModule");
+let TestTrigger = class TestTrigger extends FlowElement_1.FlowTask {
+    async onDefault(event) {
+        return this.emitOutput(event.getData());
+    }
+};
+(0, tslib_1.__decorate)([
+    (0, FlowElement_1.InputStream)('default'),
+    (0, tslib_1.__metadata)("design:type", Function),
+    (0, tslib_1.__metadata)("design:paramtypes", [FlowEvent_1.FlowEvent]),
+    (0, tslib_1.__metadata)("design:returntype", Promise)
+], TestTrigger.prototype, "onDefault", null);
+TestTrigger = (0, tslib_1.__decorate)([
+    (0, FlowElement_1.FlowFunction)('test.task.Trigger')
+], TestTrigger);
+let TestModule = class TestModule {
+};
+TestModule = (0, tslib_1.__decorate)([
+    (0, FlowModule_1.FlowModule)({ name: 'test', declarations: [TestTrigger] })
+], TestModule);
+exports.TestModule = TestModule;

package/dist/amqp.d.ts

@@ -0,0 +1,33 @@
+import type { AmqpConnectionManager, ChannelWrapper } from 'amqp-connection-manager';
+import type { Channel, Connection, ConsumeMessage, Options } from 'amqplib';
+export interface AmqpConnection {
+    channel: Channel;
+    connection: Connection;
+    managedChannel: ChannelWrapper;
+    managedConnection: AmqpConnectionManager;
+    createSubscriber<T>(handler: (msg: T | undefined, rawMessage?: ConsumeMessage) => Promise<any | undefined>, msgOptions: MessageHandlerOptions): Promise<void>;
+    publish(exchange: string, routingKey: string, message: any, options?: Options.Publish): Promise<void>;
+}
+export declare class Nack {
+    private readonly _requeue;
+    constructor(_requeue?: boolean);
+    get requeue(): boolean;
+}
+export interface MessageHandlerOptions {
+    exchange: string;
+    routingKey: string | string[];
+    queue?: string;
+    queueOptions?: QueueOptions;
+}
+export interface QueueOptions {
+    durable?: boolean;
+    exclusive?: boolean;
+    autoDelete?: boolean;
+    arguments?: any;
+    messageTtl?: number;
+    expires?: number;
+    deadLetterExchange?: string;
+    deadLetterRoutingKey?: string;
+    maxLength?: number;
+    maxPriority?: number;
+}

package/dist/amqp.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Nack = void 0;
+class Nack {
+    constructor(_requeue = false) {
+        this._requeue = _requeue;
+    }
+    get requeue() {
+        return this._requeue;
+    }
+}
+exports.Nack = Nack;

package/dist/api/Queue.d.ts

@@ -0,0 +1,15 @@
+import PQueue from 'p-queue';
+export declare class Queue extends PQueue {
+    private peak;
+    private total;
+    constructor(options?: QueueOptions);
+    getStats(): {
+        peak: number;
+        pending: number;
+        size: number;
+        total: number;
+    };
+}
+export interface QueueOptions {
+    concurrent?: number;
+}

package/dist/api/Queue.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Queue = void 0;
+const tslib_1 = require("tslib");
+const p_queue_1 = (0, tslib_1.__importDefault)(require("p-queue"));
+class Queue extends p_queue_1.default {
+    constructor(options = { concurrent: 1 }) {
+        super({ concurrency: options.concurrent || 1 });
+        this.peak = 0;
+        this.total = 0;
+        this.on('add', () => {
+            this.peak = Math.max(this.peak, this.size);
+        });
+        this.on('active', () => {
+            this.total++;
+        });
+    }
+    getStats() {
+        return {
+            peak: this.peak,
+            pending: this.pending,
+            size: this.size,
+            total: this.total,
+        };
+    }
+}
+exports.Queue = Queue;

package/dist/api/api.d.ts

@@ -0,0 +1,62 @@
+import { AssetService } from './asset.service';
+import { AssetTypesService } from './assettypes.service';
+import { ContentService } from './content.service';
+import { EndpointService } from './endpoint.service';
+import { EventsService } from './events.service';
+import { HttpClient } from './http.service';
+import { ProxyService } from './proxy.service';
+import { SecretService } from './secret.service';
+import { SiDriveIqService } from './sidriveiq.service';
+import { TaskService } from './task.service';
+import { TimeSeriesService } from './timeseries.service';
+import { UserService } from './user.service';
+export declare class API {
+    httpClient: HttpClient;
+    assets: AssetService;
+    assetTypes: AssetTypesService;
+    contents: ContentService;
+    endpoints: EndpointService;
+    events: EventsService;
+    proxy: ProxyService;
+    secrets: SecretService;
+    tasks: TaskService;
+    timeSeries: TimeSeriesService;
+    users: UserService;
+    /**
+     * @deprecated use "assets" instead
+     */
+    assetManager: AssetService;
+    /**
+     * @deprecated use "contents" instead
+     */
+    contentManager: ContentService;
+    /**
+     * @deprecated use "endpoints" instead
+     */
+    endpointManager: EndpointService;
+    /**
+     * @deprecated use "events" instead
+     */
+    eventsManager: EventsService;
+    /**
+     * @deprecated use "secrets" instead
+     */
+    secretsManager: SecretService;
+    /**
+     * @deprecated use proxy service instead
+     */
+    siDrive: SiDriveIqService;
+    /**
+     * @deprecated use "tasks" instead
+     */
+    taskManager: TaskService;
+    /**
+     * @deprecated use "timeSeries" instead
+     */
+    timeSeriesManager: TimeSeriesService;
+    /**
+     * @deprecated use "users" instead
+     */
+    userManager: UserService;
+    constructor();
+}

package/dist/api/api.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.API = void 0;
+const asset_service_1 = require("./asset.service");
+const assettypes_service_1 = require("./assettypes.service");
+const content_service_1 = require("./content.service");
+const endpoint_service_1 = require("./endpoint.service");
+const events_service_1 = require("./events.service");
+const http_service_1 = require("./http.service");
+const proxy_service_1 = require("./proxy.service");
+const secret_service_1 = require("./secret.service");
+const sidriveiq_service_1 = require("./sidriveiq.service");
+const task_service_1 = require("./task.service");
+const timeseries_service_1 = require("./timeseries.service");
+const user_service_1 = require("./user.service");
+class API {
+    constructor() {
+        let apiBaseUrl = process.env.API_BASE_URL || 'https://testing.hahnpro.com';
+        if (!apiBaseUrl.startsWith('https') && !apiBaseUrl.startsWith('http')) {
+            console.info('no protocol specified - using HTTPS');
+            apiBaseUrl = `https://${apiBaseUrl}`;
+        }
+        const authBaseUrl = process.env.AUTH_BASE_URL || apiBaseUrl;
+        const realm = process.env.AUTH_REALM || 'hpc';
+        const client = process.env.API_USER || 'flow-executor-service';
+        const secret = process.env.AUTH_SECRET;
+        if (!secret) {
+            throw new Error('"API_BASE_URL", "API_USER", "AUTH_REALM" and "AUTH_SECRET" environment variables must be set');
+        }
+        this.httpClient = new http_service_1.HttpClient(apiBaseUrl, authBaseUrl, realm, client, secret);
+        this.assets = new asset_service_1.AssetService(this.httpClient);
+        this.assetTypes = new assettypes_service_1.AssetTypesService(this.httpClient);
+        this.contents = new content_service_1.ContentService(this.httpClient);
+        this.endpoints = new endpoint_service_1.EndpointService(this.httpClient);
+        this.events = new events_service_1.EventsService(this.httpClient);
+        this.proxy = new proxy_service_1.ProxyService(this.httpClient);
+        this.secrets = new secret_service_1.SecretService(this.httpClient);
+        this.tasks = new task_service_1.TaskService(this.httpClient);
+        this.timeSeries = new timeseries_service_1.TimeSeriesService(this.httpClient);
+        this.users = new user_service_1.UserService(this.httpClient);
+        this.assetManager = this.assets;
+        this.contentManager = this.contents;
+        this.endpointManager = this.endpoints;
+        this.eventsManager = this.events;
+        this.secretsManager = this.secrets;
+        this.siDrive = new sidriveiq_service_1.SiDriveIqService(this.httpClient);
+        this.taskManager = this.tasks;
+        this.timeSeriesManager = this.timeSeries;
+        this.userManager = this.users;
+    }
+}
+exports.API = API;

package/dist/api/asset.interface.d.ts

@@ -0,0 +1,54 @@
+export interface Asset {
+    id?: string;
+    name: string;
+    type: string | AssetType;
+    type$name?: string;
+    readPermissions: string[];
+    readWritePermissions: string[];
+    tags?: string[];
+    parent?: any | Asset;
+    parent$name?: string;
+    data?: any;
+    attachments?: string[];
+    image?: string;
+    actions?: string[];
+    notificationEndpoints?: string[];
+    createdAt?: string;
+    updatedAt?: string;
+}
+export interface AssetType {
+    id?: string;
+    name: string;
+    allowedParent?: string;
+    allowedParent$name?: string;
+    readPermissions: string[];
+    readWritePermissions: string[];
+    typeSchema: any;
+    supertype?: string;
+    supertype$name?: string;
+    uiSchema: any;
+    actions?: string[];
+    createdAt?: string;
+    updatedAt?: string;
+}
+export interface Attachment {
+    id?: string;
+    filename: string;
+    metadata: {
+        mimetype: string;
+    };
+}
+export interface Action {
+    id?: string;
+    name?: string;
+    description?: string;
+    type?: string;
+    method?: string;
+    authToken?: string;
+    isAuthFromAsset?: boolean;
+    url?: string;
+    data?: string;
+    responseType?: string;
+    readPermissions: string[];
+    readWritePermissions: string[];
+}

package/dist/api/asset.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/api/asset.service.d.ts

@@ -0,0 +1,10 @@
+import FormData from 'form-data';
+import { Asset } from './asset.interface';
+import { Paginated, RequestParameter } from './data.interface';
+import { DataService } from './data.service';
+import { HttpClient } from './http.service';
+export declare class AssetService extends DataService<Asset> {
+    constructor(httpClient: HttpClient);
+    addAttachment: (id: string, form: FormData) => Promise<Asset>;
+    getChildren(assetId: string, params?: RequestParameter): Promise<Paginated<Asset[]>>;
+}

package/dist/api/asset.service.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetService = void 0;
+const data_service_1 = require("./data.service");
+class AssetService extends data_service_1.DataService {
+    constructor(httpClient) {
+        super(httpClient, process.env.DEBUG_ASSET_URL || 'api/assets');
+        this.addAttachment = (id, form) => {
+            const headers = Object.assign({}, form.getHeaders());
+            return this.httpClient.post(`${this.basePath}/${id}/attachment`, form, {
+                headers,
+                maxBodyLength: Infinity,
+                maxContentLength: Infinity,
+            });
+        };
+    }
+    getChildren(assetId, params = {}) {
+        return this.getManyFiltered({ parent: assetId }, params);
+    }
+}
+exports.AssetService = AssetService;

package/dist/api/assettypes.service.d.ts

@@ -0,0 +1,6 @@
+import { AssetType } from './asset.interface';
+import { DataService } from './data.service';
+import { HttpClient } from './http.service';
+export declare class AssetTypesService extends DataService<AssetType> {
+    constructor(httpClient: HttpClient);
+}

package/dist/api/assettypes.service.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetTypesService = void 0;
+const data_service_1 = require("./data.service");
+class AssetTypesService extends data_service_1.DataService {
+    constructor(httpClient) {
+        super(httpClient, 'api/assettypes');
+    }
+}
+exports.AssetTypesService = AssetTypesService;

package/dist/api/content.interface.d.ts

@@ -0,0 +1,35 @@
+declare type FileType = 'original' | 'preview-sm' | 'preview-md' | 'preview-lg';
+declare type StorageProvider = 's3' | 'mongo';
+export interface Storage {
+    id: string;
+    filename: string;
+    mimetype: string;
+    size: number;
+    createdAt: string;
+    provider?: StorageProvider;
+    type?: FileType;
+    md5?: string;
+}
+export interface Content {
+    id?: string;
+    fileId: string;
+    filename: string;
+    mimetype: string;
+    size: number;
+    readPermissions: string[];
+    readWritePermissions: string[];
+    tags?: string[];
+    assets?: string[];
+    files?: Storage[];
+    createdAt?: string;
+    updatedAt?: string;
+}
+export declare enum ReturnType {
+    TEXT = 0,
+    JSON = 1,
+    NODEBUFFER = 2,
+    BLOB = 3,
+    ARRAYBUFFER = 4,
+    NODESTREAM = 5
+}
+export {};

package/dist/api/content.interface.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReturnType = void 0;
+var ReturnType;
+(function (ReturnType) {
+    ReturnType[ReturnType["TEXT"] = 0] = "TEXT";
+    ReturnType[ReturnType["JSON"] = 1] = "JSON";
+    ReturnType[ReturnType["NODEBUFFER"] = 2] = "NODEBUFFER";
+    ReturnType[ReturnType["BLOB"] = 3] = "BLOB";
+    ReturnType[ReturnType["ARRAYBUFFER"] = 4] = "ARRAYBUFFER";
+    ReturnType[ReturnType["NODESTREAM"] = 5] = "NODESTREAM";
+})(ReturnType = exports.ReturnType || (exports.ReturnType = {}));

package/dist/api/content.service.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+import FormData from 'form-data';
+import { Content, ReturnType } from './content.interface';
+import { DataService } from './data.service';
+import { HttpClient } from './http.service';
+import { Readable } from 'stream';
+export declare class ContentService extends DataService<Content> {
+    constructor(httpClient: HttpClient);
+    upload: (form: FormData) => Promise<Content>;
+    download(id: string, raw?: boolean): Promise<Blob | ArrayBuffer>;
+    download(id: string, returnType: ReturnType.TEXT): Promise<string>;
+    download(id: string, returnType: ReturnType.JSON): Promise<Record<string, unknown>>;
+    download(id: string, returnType: ReturnType.NODEBUFFER): Promise<Buffer>;
+    download(id: string, returnType: ReturnType.BLOB): Promise<Blob>;
+    download(id: string, returnType: ReturnType.ARRAYBUFFER): Promise<ArrayBuffer>;
+    download(id: string, returnType: ReturnType.NODESTREAM): Promise<Readable>;
+}

package/dist/api/content.service.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentService = void 0;
+const content_interface_1 = require("./content.interface");
+const data_service_1 = require("./data.service");
+class ContentService extends data_service_1.DataService {
+    constructor(httpClient) {
+        super(httpClient, process.env.DEBUG_CONTENT_URL || 'api/contents');
+        this.upload = (form) => {
+            const headers = Object.assign({}, form.getHeaders());
+            return this.httpClient.post(`${this.basePath}`, form, { headers, maxBodyLength: Infinity, maxContentLength: Infinity });
+        };
+    }
+    async download(id, second) {
+        let returnType;
+        if (typeof second === 'boolean' || !second) {
+            returnType = second ? content_interface_1.ReturnType.ARRAYBUFFER : content_interface_1.ReturnType.BLOB;
+        }
+        else {
+            returnType = second;
+        }
+        const url = `${this.basePath}/${id}/download`;
+        switch (returnType) {
+            case content_interface_1.ReturnType.TEXT:
+                return this.httpClient.get(url, { responseType: 'text' });
+            case content_interface_1.ReturnType.JSON:
+                return this.httpClient.get(url, { responseType: 'json' });
+            case content_interface_1.ReturnType.NODEBUFFER:
+                return Buffer.from(new Uint8Array(await this.httpClient.get(url, { responseType: 'arraybuffer' })));
+            case content_interface_1.ReturnType.BLOB:
+                return this.httpClient.get(url, { responseType: 'blob' });
+            case content_interface_1.ReturnType.ARRAYBUFFER:
+                return this.httpClient.get(url, { responseType: 'arraybuffer' });
+            case content_interface_1.ReturnType.NODESTREAM:
+                return this.httpClient.get(url, { responseType: 'stream' });
+        }
+    }
+}
+exports.ContentService = ContentService;

package/dist/api/data.interface.d.ts

@@ -0,0 +1,29 @@
+export interface Paginated<T> {
+    docs: T;
+    total: number;
+    limit: number;
+    page?: number;
+    pages?: number;
+    offset?: number;
+}
+export interface RequestParameter {
+    filter?: string;
+    limit?: number;
+    page?: number;
+    populate?: string;
+    sort?: string;
+}
+export interface Filter {
+    tags?: string[];
+    type?: string;
+    parent?: string;
+}
+export interface DataInterface<T> {
+    addOne(dto: any): Promise<T>;
+    addMany(dto: any[]): Promise<T[]>;
+    getOne(id: string, options?: any): Promise<T>;
+    getMany(params?: RequestParameter, parentId?: string): Promise<Paginated<T[]>>;
+    getManyFiltered(filter: Filter, params?: RequestParameter, parentId?: string): Promise<Paginated<T[]>>;
+    updateOne(id: string, dto: any): Promise<T>;
+    deleteOne(id: string): Promise<any>;
+}

package/dist/api/data.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });