@hahnpro/hpc-api 2.0.0 → 2.2.0

package/dist/Queue.js

@@ -2,7 +2,7 @@
 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"));
+const p_queue_1 = tslib_1.__importDefault(require("p-queue"));
 class Queue extends p_queue_1.default {
     constructor(options) {
         super(options);

package/dist/api.d.ts

@@ -10,6 +10,10 @@ import { SiDriveIqService } from './sidriveiq.service';
 import { TaskService } from './task.service';
 import { TimeSeriesService } from './timeseries.service';
 import { UserService } from './user.service';
+import { FlowService } from './flow.service';
+import { FlowFunctionService } from './flow-function.service';
+import { FlowModuleService } from './flow-module.service';
+import { FlowDeploymentService } from './flow-deployment.service';
 export declare class API {
     httpClient: HttpClient;
     assets: AssetService;
@@ -17,6 +21,10 @@ export declare class API {
     contents: ContentService;
     endpoints: EndpointService;
     events: EventsService;
+    flows: FlowService;
+    flowDeployments: FlowDeploymentService;
+    flowFunctions: FlowFunctionService;
+    flowModules: FlowModuleService;
     proxy: ProxyService;
     secrets: SecretService;
     tasks: TaskService;

package/dist/api.js

@@ -13,6 +13,10 @@ 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");
+const flow_service_1 = require("./flow.service");
+const flow_function_service_1 = require("./flow-function.service");
+const flow_module_service_1 = require("./flow-module.service");
+const flow_deployment_service_1 = require("./flow-deployment.service");
 class API {
     constructor() {
         const normalizePath = (value = '', defaultValue = '') => value.replace(/^\/+|\/+$/g, '') || defaultValue;
@@ -36,6 +40,10 @@ class API {
         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.flows = new flow_service_1.FlowService(this.httpClient);
+        this.flowDeployments = new flow_deployment_service_1.FlowDeploymentService(this.httpClient);
+        this.flowFunctions = new flow_function_service_1.FlowFunctionService(this.httpClient);
+        this.flowModules = new flow_module_service_1.FlowModuleService(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);

package/dist/asset.interface.d.ts

@@ -14,15 +14,13 @@ export interface AssetType {
     createdAt?: string;
     updatedAt?: string;
 }
-export interface Asset {
+export interface AssetParent {
     id?: string;
     name: string;
     type: string | AssetType;
-    type$name?: string;
     readPermissions: string[];
     readWritePermissions: string[];
     parent?: any | Asset;
-    parent$name?: string;
     ancestors?: string[];
     tags?: string[];
     relations?: any[];
@@ -30,9 +28,16 @@ export interface Asset {
     image?: string;
     author?: string;
     revision?: number;
+}
+export interface Asset extends AssetParent {
+    type$name?: string;
+    parent$name?: string;
     attachments?: string[];
     notificationEndpoints?: string[];
     actions?: string[];
+}
+export interface AssetRevision extends AssetParent {
+    originalId?: string;
     createdAt?: string;
     updatedAt?: string;
 }

package/dist/asset.service.d.ts

@@ -1,5 +1,5 @@
 import FormData from 'form-data';
-import { Asset } from './asset.interface';
+import { Asset, AssetRevision } from './asset.interface';
 import { Paginated, RequestParameter } from './data.interface';
 import { DataService } from './data.service';
 import { HttpClient } from './http.service';
@@ -7,4 +7,5 @@ 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[]>>;
+    findRevisions(assetId: string): Promise<Paginated<AssetRevision[]>>;
 }

package/dist/asset.service.js

@@ -17,5 +17,8 @@ class AssetService extends data_service_1.DataService {
     getChildren(assetId, params = {}) {
         return this.getManyFiltered({ parent: assetId }, params);
     }
+    findRevisions(assetId) {
+        return this.httpClient.get(`${this.basePath}/${assetId}/revisions`);
+    }
 }
 exports.AssetService = AssetService;

package/dist/content.interface.d.ts

@@ -1,15 +1,4 @@
-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;
-}
+import { Storage } from './storage.interface';
 export interface Content {
     id?: string;
     fileId: string;
@@ -32,4 +21,3 @@ export declare enum ReturnType {
     ARRAYBUFFER = 4,
     NODESTREAM = 5
 }
-export {};

package/dist/flow-deployment.interface.d.ts

@@ -0,0 +1,76 @@
+import { Resource } from './resource.interface';
+import { FlowDiagram, FlowDto } from './flow.interface';
+import { Storage } from './storage.interface';
+export interface FlowDeployment extends Resource {
+    flow: string | FlowDto;
+    diagram: string | FlowDiagram;
+    artifact: Storage;
+    flowModel: FlowModel;
+    desiredStatus: string;
+    actualStatus: string;
+    target: string;
+    statistic?: FlowDeploymentStatistic;
+}
+export interface FlowDeploymentStatistic {
+    totalErrorCount: number;
+    errorCountWeek: number;
+    eventCountWeek: number;
+    errorCounts: {
+        timestamp: number;
+        error: number;
+    }[];
+    metrics?: Record<string, any>;
+}
+export interface FlowModel {
+    elements: FlowModelElement[];
+    connections: FlowConnection[];
+    modules?: string[];
+    properties?: Record<string, any>;
+}
+export interface FlowModelElement {
+    id: string;
+    name?: string;
+    properties?: Record<string, any>;
+    module: string;
+    functionFqn: string;
+}
+export interface FlowConnection {
+    id: string;
+    name?: string;
+    source: string;
+    target: string;
+    sourceStream?: string;
+    targetStream?: string;
+}
+export interface FlowDeploymentMetrics {
+    metrics: Metrics[];
+    stats?: Stats;
+}
+export interface Metrics {
+    timestamp: number;
+    cpu: number;
+    memory: number;
+}
+export interface Stats {
+    cpu: StatsValues;
+    memory: StatsValues;
+}
+export interface StatsValues {
+    count: number;
+    min: number;
+    max: number;
+    avg: number;
+    sum: number;
+}
+export interface FlowLog {
+    data?: any;
+    datacontenttype?: string;
+    deploymentId?: string;
+    elementId?: string;
+    eventId?: string;
+    flowId?: string;
+    subject: string;
+    source?: string;
+    time: string;
+    type: string;
+}

package/dist/flow-deployment.interface.js

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

package/dist/flow-deployment.service.d.ts

@@ -0,0 +1,26 @@
+import { DataService } from './data.service';
+import { FlowDeployment, FlowDeploymentMetrics, FlowDeploymentStatistic, FlowLog } from './flow-deployment.interface';
+import { HttpClient } from './http.service';
+import { ResourceReference } from './resource.interface';
+export declare class FlowDeploymentService extends DataService<FlowDeployment> {
+    constructor(httpClient: HttpClient);
+    addMany(dto: any[]): Promise<FlowDeployment[]>;
+    updateOne(id: string, dto: any, force?: boolean): Promise<FlowDeployment>;
+    getDeploymentStatistics(id: string): Promise<FlowDeploymentStatistic>;
+    getDeploymentMetrics(id: string, range?: string, interval?: string): Promise<FlowDeploymentMetrics>;
+    getDeploymentLogs(id: string): Promise<FlowLog[]>;
+    resolveReferences(id: string, recursive?: boolean, types?: string[]): Promise<ResourceReference[]>;
+    updateStatus(id: string, desiredStatus: 'running' | 'stopped' | 'deleted'): Promise<FlowDeployment>;
+    deleteOne(id: string): Promise<FlowDeployment>;
+    waitForRunningStatus(id: string): Promise<void>;
+    addOne(dto: {
+        diagramId: string;
+        name: string;
+        properties?: Record<string, any>;
+        readPermissions?: string[];
+        readWritePermissions?: string[];
+        tags?: string[];
+    }): Promise<FlowDeployment>;
+    subscribeToStatus(id: string, listener: (event: MessageEvent<any>) => void, errorListener?: (event: MessageEvent) => void): Promise<string>;
+    subscribeToLogs(id: string, listener: (event: MessageEvent<any>) => void, errorListener?: (event: MessageEvent) => void): Promise<string>;
+}

package/dist/flow-deployment.service.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowDeploymentService = void 0;
+const data_service_1 = require("./data.service");
+class FlowDeploymentService extends data_service_1.DataService {
+    constructor(httpClient) {
+        super(httpClient, '/flow/deployments');
+    }
+    addMany(dto) {
+        const reqs = dto.map((v) => this.addOne(v));
+        return Promise.all(reqs);
+    }
+    updateOne(id, dto, force = false) {
+        return this.httpClient.put(`${this.basePath}/${id}`, dto, { params: { force } });
+    }
+    getDeploymentStatistics(id) {
+        return this.httpClient.get(`${this.basePath}/${id}/statistics`);
+    }
+    getDeploymentMetrics(id, range = '12h', interval = '5m') {
+        const params = { range, interval };
+        return this.httpClient.get(`${this.basePath}/${id}/metrics`, { params });
+    }
+    getDeploymentLogs(id) {
+        return this.httpClient.get(`${this.basePath}/${id}/logs`);
+    }
+    resolveReferences(id, recursive = true, types) {
+        var _a;
+        const params = { recursive, types: (_a = types === null || types === void 0 ? void 0 : types.join(',')) !== null && _a !== void 0 ? _a : undefined };
+        return this.httpClient.get(`${this.basePath}/${id}/references`, { params });
+    }
+    updateStatus(id, desiredStatus) {
+        return this.httpClient.put(`${this.basePath}/${id}/status`, { desiredStatus });
+    }
+    deleteOne(id) {
+        return this.updateStatus(id, 'deleted');
+    }
+    async waitForRunningStatus(id) {
+        return new Promise(async (resolve, reject) => {
+            const esId = await this.subscribeToStatus(id, (event) => {
+                if (event.type === 'message' &&
+                    ['running', 'deployment failed', 'deleted', 'generating failed', 'updating failed', 'upgrading failed'].includes(event.data)) {
+                    this.httpClient.destroyEventSource(esId);
+                    event.data === 'running' ? resolve() : reject(`Deployment in failed status: ${event.data}`);
+                }
+            });
+        });
+    }
+    addOne(dto) {
+        return super.addOne(dto);
+    }
+    subscribeToStatus(id, listener, errorListener) {
+        return this.httpClient.addEventSource(`${this.basePath}/${id}/status`, listener, errorListener);
+    }
+    subscribeToLogs(id, listener, errorListener) {
+        return this.httpClient.addEventSource(`${this.basePath}/${id}/logs/subscribe`, listener, errorListener);
+    }
+}
+exports.FlowDeploymentService = FlowDeploymentService;

package/dist/flow-function.interface.d.ts

@@ -0,0 +1,47 @@
+export interface FlowFunctionDto {
+    fqn: string;
+    category: string;
+    readPermissions: string[];
+    readWritePermissions: string[];
+    author: string;
+    current: string;
+    history: string[] | HistoryEntry[];
+    name?: string;
+    description?: string;
+    icon?: string;
+    isAbstract?: boolean;
+    supertype?: string;
+    propertiesSchema?: Schema;
+    inputStreams?: Stream[];
+    outputStreams?: Stream[];
+    tags?: string[];
+    createdAt?: string;
+    updatedAt?: string;
+}
+export interface HistoryEntry {
+    author: string;
+    createdAt: string;
+    id: string;
+}
+interface Stream {
+    name: string;
+}
+interface Schema {
+    schema: {
+        type: string;
+        properties?: {
+            [key: string]: SchemaProperty;
+        };
+    };
+    layout?: any[];
+    data?: any;
+}
+declare type SchemaPropertyType = 'array' | 'boolean' | 'number' | 'string';
+interface SchemaProperty {
+    type: SchemaPropertyType;
+    title?: string;
+    description?: string;
+    default?: any;
+    [key: string]: any;
+}
+export {};

package/dist/flow-function.interface.js

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

package/dist/flow-function.service.d.ts

@@ -0,0 +1,9 @@
+import { DataService } from './data.service';
+import { FlowFunctionDto } from './flow-function.interface';
+import { HttpClient } from './http.service';
+export declare class FlowFunctionService extends DataService<FlowFunctionDto> {
+    constructor(httpClient: HttpClient);
+    addMany(dto: any[]): Promise<FlowFunctionDto[]>;
+    getOneWithHistory(fqn: string): Promise<FlowFunctionDto>;
+    rollback(fqn: string, historyId: string): Promise<FlowFunctionDto>;
+}

package/dist/flow-function.service.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowFunctionService = void 0;
+const data_service_1 = require("./data.service");
+class FlowFunctionService extends data_service_1.DataService {
+    constructor(httpClient) {
+        super(httpClient, '/flow/functions');
+    }
+    addMany(dto) {
+        const reqs = dto.map((v) => this.addOne(v));
+        return Promise.all(reqs);
+    }
+    getOneWithHistory(fqn) {
+        return this.httpClient.get(`${this.basePath}/${fqn}/history`);
+    }
+    rollback(fqn, historyId) {
+        return this.httpClient.put(`${this.basePath}/${fqn}/rollback/${historyId}`, {});
+    }
+}
+exports.FlowFunctionService = FlowFunctionService;

package/dist/flow-module.interface.d.ts

@@ -0,0 +1,13 @@
+import { Artifact } from './storage.interface';
+export interface FlowModule {
+    name: string;
+    description?: string;
+    artifacts: Artifact[];
+    author: string;
+    tags?: string[];
+    functions: string[];
+    readPermissions: string[];
+    readWritePermissions: string[];
+    createdAt?: string;
+    updatedAt?: string;
+}

package/dist/flow-module.interface.js

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

package/dist/flow-module.service.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { DataService } from './data.service';
+import { FlowModule } from './flow-module.interface';
+import { HttpClient } from './http.service';
+import { ReadStream } from 'fs';
+export declare class FlowModuleService extends DataService<FlowModule> {
+    constructor(httpClient: HttpClient);
+    deleteArtifact(name: string, version: string): Promise<FlowModule>;
+    download(name: string, filePath: string, version?: string): Promise<void>;
+    publish(file: ReadStream): Promise<unknown>;
+    addOne(dto: any): Promise<FlowModule>;
+    addMany(dto: any[]): Promise<FlowModule[]>;
+}

package/dist/flow-module.service.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowModuleService = void 0;
+const tslib_1 = require("tslib");
+const data_service_1 = require("./data.service");
+const fs_1 = require("fs");
+const form_data_1 = tslib_1.__importDefault(require("form-data"));
+const promises_1 = require("stream/promises");
+class FlowModuleService extends data_service_1.DataService {
+    constructor(httpClient) {
+        super(httpClient, '/flow/modules');
+    }
+    deleteArtifact(name, version) {
+        return this.httpClient.delete(`${this.basePath}/${name}/${version}`);
+    }
+    async download(name, filePath, version = 'latest') {
+        const writer = (0, fs_1.createWriteStream)(filePath);
+        return this.httpClient.get(`${this.basePath}/${name}/${version}`, { responseType: 'stream' }).then(async (response) => {
+            response.pipe(writer);
+            return (0, promises_1.finished)(writer);
+        });
+    }
+    publish(file) {
+        const form = new form_data_1.default();
+        form.append('file', file);
+        const config = {
+            headers: Object.assign({}, form.getHeaders()),
+            maxBodyLength: Infinity,
+            maxContentLength: Infinity,
+        };
+        return this.httpClient.post(`${this.basePath}`, form, config);
+    }
+    addOne(dto) {
+        throw new Error('not allowed: use publish instead');
+    }
+    addMany(dto) {
+        throw new Error('not allowed: use publish instead');
+    }
+}
+exports.FlowModuleService = FlowModuleService;

package/dist/flow.interface.d.ts

@@ -0,0 +1,25 @@
+import { Resource } from './resource.interface';
+import { JsonSchemaForm } from './schema.interface';
+import { FlowDeployment } from './flow-deployment.interface';
+export interface FlowDto extends Resource {
+    diagram: string | FlowDiagram;
+    deployments?: string[] | FlowDeployment[];
+    dashboard?: DashboardItem[];
+    propertiesSchema?: JsonSchemaForm;
+}
+export interface DashboardItem {
+    id: string;
+    cols: number;
+    rows: number;
+    x: number;
+    y: number;
+}
+export interface FlowDiagram {
+    id: string;
+    flow: string | FlowDto;
+    json: string;
+    author: string;
+    createdAt?: Date | string;
+    updatedAt?: Date | string;
+    deleteddAt?: Date | string;
+}

package/dist/flow.interface.js

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

package/dist/flow.service.d.ts

@@ -0,0 +1,11 @@
+import { DataService } from './data.service';
+import { FlowDto } from './flow.interface';
+import { HttpClient } from './http.service';
+import { Paginated, RequestParameter } from './data.interface';
+export declare class FlowService extends DataService<FlowDto> {
+    constructor(httpClient: HttpClient);
+    addMany(dto: any[]): Promise<FlowDto[]>;
+    getMany(params?: RequestParameter): Promise<Paginated<FlowDto[]>>;
+    getOne(id: string, options?: any): Promise<FlowDto>;
+    getFlowWithDiagram(diagramId: string): Promise<FlowDto>;
+}

package/dist/flow.service.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowService = void 0;
+const data_service_1 = require("./data.service");
+class FlowService extends data_service_1.DataService {
+    constructor(httpClient) {
+        super(httpClient, '/flows');
+    }
+    addMany(dto) {
+        const reqs = dto.map((v) => this.addOne(v));
+        return Promise.all(reqs);
+    }
+    getMany(params = {}) {
+        params.populate = params.populate ? params.populate : 'none';
+        return super.getMany(params);
+    }
+    getOne(id, options = {}) {
+        options.populate = options.populate ? options.populate : 'none';
+        return super.getOne(id, options);
+    }
+    getFlowWithDiagram(diagramId) {
+        return this.httpClient.get(`${this.basePath}/diagram/${diagramId}`);
+    }
+}
+exports.FlowService = FlowService;

package/dist/http.service.d.ts

@@ -1,5 +1,7 @@
 import { AxiosRequestConfig } from 'axios';
+import EventSource from 'eventsource';
 export declare class HttpClient {
+    private baseURL;
     private readonly realm;
     private readonly client;
     private readonly secret;
@@ -8,6 +10,7 @@ export declare class HttpClient {
     private readonly requestQueue;
     private accessToken;
     private accessTokenExpiration;
+    eventSourcesMap: Map<string, EventSource>;
     constructor(baseURL: string, authbaseURL: string, realm: string, client: string, secret: string);
     getQueueStats: () => {
         peak: number;
@@ -20,6 +23,9 @@ export declare class HttpClient {
     post: <T>(url: string, data: any, config?: AxiosRequestConfig) => Promise<T>;
     put: <T>(url: string, data: any, config?: AxiosRequestConfig) => Promise<T>;
     private request;
+    addEventSource(url: string, listener: (event: MessageEvent) => void, errorListener?: (event: MessageEvent) => void): Promise<string>;
+    destroyEventSource(id: string): void;
+    destroyAllEventSources(): void;
     getAccessToken: () => Promise<string>;
     private isTokenValid;
     private getToken;

package/dist/http.service.js

@@ -2,15 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpClient = void 0;
 const tslib_1 = require("tslib");
-const axios_1 = (0, tslib_1.__importDefault)(require("axios"));
+const axios_1 = tslib_1.__importDefault(require("axios"));
+const eventsource_1 = tslib_1.__importDefault(require("eventsource"));
 const Queue_1 = require("./Queue");
+const crypto_1 = require("crypto");
 const EXPIRATION_BUFFER = 30 * 1000;
 class HttpClient {
     constructor(baseURL, authbaseURL, realm, client, secret) {
+        this.baseURL = baseURL;
         this.realm = realm;
         this.client = client;
         this.secret = secret;
         this.accessTokenExpiration = 0;
+        this.eventSourcesMap = new Map();
         this.getQueueStats = () => { var _a; return (_a = this.requestQueue) === null || _a === void 0 ? void 0 : _a.getStats(); };
         this.delete = (url, config) => this.request('DELETE', url, config);
         this.get = (url, config) => this.request('GET', url, config);
@@ -69,5 +73,34 @@ class HttpClient {
         this.authAxiosInstance = axios_1.default.create({ baseURL: authbaseURL || baseURL, timeout: 10000 });
         this.requestQueue = new Queue_1.Queue({ concurrency: 1, timeout: 70000, throwOnTimeout: true });
     }
+    async addEventSource(url, listener, errorListener) {
+        const id = (0, crypto_1.randomUUID)();
+        const es = new eventsource_1.default(`${this.baseURL}${url}`, {
+            headers: { authorization: 'Bearer ' + (await this.getAccessToken()) },
+        });
+        es.addEventListener('message', listener);
+        es.addEventListener('error', errorListener
+            ? errorListener
+            : (event) => {
+                throw new Error(JSON.stringify(event, null, 2));
+            });
+        this.eventSourcesMap.set(id, es);
+        return id;
+    }
+    destroyEventSource(id) {
+        if (!this.eventSourcesMap.has(id)) {
+            return;
+        }
+        const es = this.eventSourcesMap.get(id);
+        es.close();
+        es.removeEventListener('message', () => { });
+        es.removeEventListener('error', () => { });
+        this.eventSourcesMap.delete(id);
+    }
+    destroyAllEventSources() {
+        for (const key of this.eventSourcesMap.keys()) {
+            this.destroyEventSource(key);
+        }
+    }
 }
 exports.HttpClient = HttpClient;

package/dist/index.d.ts

@@ -10,4 +10,9 @@ export * from './timeseries.interface';
 export * from './task.interface';
 export * from './events.interface';
 export * from './mock';
+export * from './flow-deployment.interface';
+export * from './flow-function.interface';
+export * from './flow.interface';
+export * from './resource.interface';
+export * from './schema.interface';
 export * as SiDrive from './sidriveiq.interface';

package/dist/index.js

@@ -2,16 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SiDrive = void 0;
 const tslib_1 = require("tslib");
-(0, tslib_1.__exportStar)(require("./api"), exports);
-(0, tslib_1.__exportStar)(require("./asset.interface"), exports);
-(0, tslib_1.__exportStar)(require("./content.interface"), exports);
-(0, tslib_1.__exportStar)(require("./data.interface"), exports);
-(0, tslib_1.__exportStar)(require("./data.service"), exports);
-(0, tslib_1.__exportStar)(require("./endpoint.interface"), exports);
-(0, tslib_1.__exportStar)(require("./http.service"), exports);
-(0, tslib_1.__exportStar)(require("./secret.interface"), exports);
-(0, tslib_1.__exportStar)(require("./timeseries.interface"), exports);
-(0, tslib_1.__exportStar)(require("./task.interface"), exports);
-(0, tslib_1.__exportStar)(require("./events.interface"), exports);
-(0, tslib_1.__exportStar)(require("./mock"), exports);
-exports.SiDrive = (0, tslib_1.__importStar)(require("./sidriveiq.interface"));
+tslib_1.__exportStar(require("./api"), exports);
+tslib_1.__exportStar(require("./asset.interface"), exports);
+tslib_1.__exportStar(require("./content.interface"), exports);
+tslib_1.__exportStar(require("./data.interface"), exports);
+tslib_1.__exportStar(require("./data.service"), exports);
+tslib_1.__exportStar(require("./endpoint.interface"), exports);
+tslib_1.__exportStar(require("./http.service"), exports);
+tslib_1.__exportStar(require("./secret.interface"), exports);
+tslib_1.__exportStar(require("./timeseries.interface"), exports);
+tslib_1.__exportStar(require("./task.interface"), exports);
+tslib_1.__exportStar(require("./events.interface"), exports);
+tslib_1.__exportStar(require("./mock"), exports);
+tslib_1.__exportStar(require("./flow-deployment.interface"), exports);
+tslib_1.__exportStar(require("./flow-function.interface"), exports);
+tslib_1.__exportStar(require("./flow.interface"), exports);
+tslib_1.__exportStar(require("./resource.interface"), exports);
+tslib_1.__exportStar(require("./schema.interface"), exports);
+exports.SiDrive = tslib_1.__importStar(require("./sidriveiq.interface"));