hcloud-sdk 0.0.16 → 15.0.0

package/lib/service/mothership/index.d.ts

@@ -0,0 +1,97 @@
+import Base from "../../Base";
+import { PaginatedResponse, SearchParams, Version } from "../../interfaces/global";
+import { Agent, TargetAgent } from "../../interfaces/mothership";
+type RecurrentInfo = Pick<Agent, "uptime" | "cpuUtilization" | "memoryUsed" | "status">;
+type HelloInfo = RecurrentInfo & {
+    nickname?: string;
+    bundleVersion: string;
+    installerVersion?: string;
+    ip?: string;
+};
+export default class MothershipService extends Base {
+    /**
+     * Requests the endpoint version
+     * @returns Version object
+     */
+    version(): Promise<Version>;
+    /**
+     * Say hello as an agent to the mothership
+     *
+     * @param uuid Agent's UUID
+     * @param uuidSignature HMAC-SHA256 hash of the Agent's UUID using the Agent's secret as the key
+     * @param info Information about the agent's uuid, hardware and nickname
+     * @return an Agent object
+     */
+    hello(uuid: string, uuidSignature: string, info: HelloInfo): Promise<{
+        agent: Agent;
+        token: string;
+    }>;
+    /**
+     * Say hello again as an agent to the mothership.
+     *
+     * This call should only be made after an initial hello.
+     *
+     * The session token obtained in the hello endpoint must be used here. Use the setAuthToken method to do so.
+     *
+     * @param info Information about the agent's system resources.
+     * @return an Agent object
+     */
+    helloAgain(info: RecurrentInfo): Promise<Agent>;
+    /**
+     * Register an agent to the mothership.
+     *
+     * This call should only be made once per agent, not once per agent session.
+     *
+     * @param uuid UUID of the Agent
+     * @param info Information about the agent's hardware and nickname.
+     * @param publicKey the public key of the agent that will be used for cryptography. The agent should remember its private key.
+     * @return an object holding a secret encrypted with the public key. The agent must decrypt it using its private key in order to use the /hello endpoint.
+     */
+    register(uuid: string, info: Pick<Agent, Exclude<keyof Agent, "uuid" | "createDate" | "modifyDate" | "_id" | "ip">>, publicKey: string | Buffer): Promise<{
+        secret: string;
+    }>;
+    /**
+     * Connect to an organization.
+     *
+     * This call should only be made after an initial hello.
+     *
+     * The session token obtained in the hello endpoint must be used here. Use the setAuthToken method to do so.
+     *
+     * @param orgName Name of the organization
+     * @param memberToken JWT assigned to a member of the organization
+     * @param email Email of the user owner of the JWT
+     */
+    connect(orgName: string, memberToken: string, email: string): Promise<void>;
+    /**
+     * Disconnect from an organization.
+     *
+     * This call should only be made after an initial hello.
+     *
+     * The session token obtained in the hello endpoint must be used here. Use the setAuthToken method to do so.
+     *
+     * @param orgName Name of the organization
+     * @param email Email of the user
+     */
+    disconnect(orgName: string, email: string): Promise<void>;
+    /**
+     * Disconnect as a target.
+     *
+     * This call should only be made after an initial hello.
+     *
+     * The session token obtained in the hello endpoint must be used here. Use the setAuthToken method to do so.
+     *
+     * @param email Email of the target
+     */
+    disconnectTarget(email: string): Promise<void>;
+    /**
+     * Search among the available targets for a given organization.
+     *
+     * @param orgName Name of the organization
+     * @returns Object containing an array of retrieved agents and the total number of available found in the database (independent of limit and page)
+     */
+    searchAvailableTargets({ orgName, filters, sorting, limit, page, }: SearchParams & {
+        orgName: string;
+    }): Promise<PaginatedResponse<TargetAgent>>;
+    protected getEndpoint(endpoint: string): string;
+}
+export {};

package/lib/service/mothership/index.js

@@ -0,0 +1,149 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Base_1 = require("../../Base");
+const paginatedResponseHelper_1 = require("../../helper/paginatedResponseHelper");
+const searchFilter_1 = require("../../helper/searchFilter");
+class MothershipService extends Base_1.default {
+    /**
+     * Requests the endpoint version
+     * @returns Version object
+     */
+    version() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.axios.get(this.getEndpoint("/v1/version"));
+            return resp.data;
+        });
+    }
+    /**
+     * Say hello as an agent to the mothership
+     *
+     * @param uuid Agent's UUID
+     * @param uuidSignature HMAC-SHA256 hash of the Agent's UUID using the Agent's secret as the key
+     * @param info Information about the agent's uuid, hardware and nickname
+     * @return an Agent object
+     */
+    hello(uuid, uuidSignature, info) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.axios.post(this.getEndpoint("/v1/hello"), info, {
+                headers: {
+                    Authorization: `Bearer ${uuid}.${uuidSignature}`,
+                },
+            });
+            return { agent: resp.data, token: resp.headers.authorization };
+        });
+    }
+    /**
+     * Say hello again as an agent to the mothership.
+     *
+     * This call should only be made after an initial hello.
+     *
+     * The session token obtained in the hello endpoint must be used here. Use the setAuthToken method to do so.
+     *
+     * @param info Information about the agent's system resources.
+     * @return an Agent object
+     */
+    helloAgain(info) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.axios.patch(this.getEndpoint("/v1/hello/again"), info);
+            return resp.data;
+        });
+    }
+    /**
+     * Register an agent to the mothership.
+     *
+     * This call should only be made once per agent, not once per agent session.
+     *
+     * @param uuid UUID of the Agent
+     * @param info Information about the agent's hardware and nickname.
+     * @param publicKey the public key of the agent that will be used for cryptography. The agent should remember its private key.
+     * @return an object holding a secret encrypted with the public key. The agent must decrypt it using its private key in order to use the /hello endpoint.
+     */
+    // eslint-disable-next-line complexity
+    register(uuid, info, publicKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeof publicKey !== "string") {
+                publicKey = publicKey.toString("hex");
+            }
+            const resp = yield this.axios.post(this.getEndpoint("/v1/register"), Object.assign({ uuid, publicKey }, info));
+            return resp.data;
+        });
+    }
+    /**
+     * Connect to an organization.
+     *
+     * This call should only be made after an initial hello.
+     *
+     * The session token obtained in the hello endpoint must be used here. Use the setAuthToken method to do so.
+     *
+     * @param orgName Name of the organization
+     * @param memberToken JWT assigned to a member of the organization
+     * @param email Email of the user owner of the JWT
+     */
+    connect(orgName, memberToken, email) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.axios.post(this.getEndpoint(`/v1/org/${orgName}/connect`), { memberToken, email });
+        });
+    }
+    /**
+     * Disconnect from an organization.
+     *
+     * This call should only be made after an initial hello.
+     *
+     * The session token obtained in the hello endpoint must be used here. Use the setAuthToken method to do so.
+     *
+     * @param orgName Name of the organization
+     * @param email Email of the user
+     */
+    disconnect(orgName, email) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.axios.delete(this.getEndpoint(`/v1/org/${orgName}/connect/${email}`));
+        });
+    }
+    /**
+     * Disconnect as a target.
+     *
+     * This call should only be made after an initial hello.
+     *
+     * The session token obtained in the hello endpoint must be used here. Use the setAuthToken method to do so.
+     *
+     * @param email Email of the target
+     */
+    disconnectTarget(email) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.axios.delete(this.getEndpoint(`/v1/connect/${email}`));
+        });
+    }
+    /**
+     * Search among the available targets for a given organization.
+     *
+     * @param orgName Name of the organization
+     * @returns Object containing an array of retrieved agents and the total number of available found in the database (independent of limit and page)
+     */
+    searchAvailableTargets(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ orgName, filters, sorting, limit = 25, page = 0, }) {
+            const filtersDTO = filters === null || filters === void 0 ? void 0 : filters.map((f) => {
+                return new searchFilter_1.SearchFilterDTO(f);
+            });
+            const resp = yield this.axios.post(this.getEndpoint(`/v1/org/${orgName}/connect/search`), {
+                filters: filtersDTO,
+                sorting,
+            }, {
+                params: { limit, page },
+            });
+            return (0, paginatedResponseHelper_1.createPaginatedResponse)(resp);
+        });
+    }
+    getEndpoint(endpoint) {
+        return `${this.options.server}/api/mothership${endpoint}`;
+    }
+}
+exports.default = MothershipService;

package/lib/service/nats/index.d.ts

@@ -0,0 +1,49 @@
+import { Msg, NatsConnection, PublishOptions, RequestOptions, Subscription, SubscriptionOptions } from "nats";
+import Base from "../../Base";
+import { NatsCallback, NatsMessageType, NatsObject, NatsObjectType, RawMsg } from "../../interfaces/nats";
+/**
+ * Connect and authenticate using email and jwt
+ *
+ * to use websocket from within node, forceWebsocket can be used.
+ * A websocket library is required to be pre-installed and needs to be set as global:
+ * import WebSocket from "ws";
+ * Object.assign(global, { WebSocket: WebSocket });
+ */
+type ConnectParamsJwt = {
+    email: string;
+    jwt: string;
+    servers?: string[];
+    debug?: boolean;
+    forceWebsocket?: boolean;
+};
+/**
+ * Connect and authenticate using username and password
+ * Can only be used with the CUSTOM_AUTH admin!
+ *
+ * to use websocket from within node, forceWebsocket can be used.
+ * A websocket library is required to be pre-installed and needs to be set as global:
+ * import WebSocket from "ws";
+ * Object.assign(global, { WebSocket: WebSocket });
+ */
+type ConnectParamsPassword = {
+    username: string;
+    password: string;
+    servers?: string[];
+    debug?: boolean;
+    forceWebsocket?: boolean;
+};
+declare class Nats extends Base {
+    private natsConnection;
+    private subMap;
+    private connection;
+    connect(params: ConnectParamsJwt | ConnectParamsPassword): Promise<NatsConnection>;
+    getConnection: () => NatsConnection | undefined;
+    sub(subject: string, callback: NatsCallback, options?: SubscriptionOptions): Promise<Subscription>;
+    unsub(subject: string | Subscription): void;
+    publish(subject: string, type: NatsMessageType, objectType: NatsObjectType, object: NatsObject, options?: PublishOptions): void;
+    request(subject: string, type: NatsMessageType, objectType: NatsObjectType, object: unknown, options?: RequestOptions): void;
+    requestAndWaitForResponse(subject: string, type: NatsMessageType, objectType: NatsObjectType, object: unknown, options?: RequestOptions): Promise<Msg | undefined>;
+    respond(msg: Msg | RawMsg, data: unknown): void;
+    protected getEndpoint(endpoint: string): string;
+}
+export default Nats;

package/lib/service/nats/index.js

@@ -0,0 +1,138 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const nats_1 = require("nats");
+const nats_ws_1 = require("nats.ws");
+const Base_1 = require("../../Base");
+const isBrowser = typeof window !== "undefined";
+class Nats extends Base_1.default {
+    constructor() {
+        super(...arguments);
+        this.subMap = [];
+        this.connection = isBrowser ? nats_ws_1.connect : nats_1.connect;
+        this.getConnection = () => {
+            return this.natsConnection;
+        };
+    }
+    // eslint-disable-next-line complexity
+    connect(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (params.forceWebsocket) {
+                this.connection = nats_ws_1.connect;
+            }
+            if (!params.servers) {
+                // set defaults if servers array is empty
+                if (isBrowser) {
+                    // default via traefik exposed servers
+                    params.servers = [this.getEndpoint("/v1/0"), this.getEndpoint("/v1/1"), this.getEndpoint("/v1/2")];
+                }
+                else {
+                    // default kubernetes internal servers
+                    params.servers = ["hcloud-nats-0.hcloud-nats:4222", "hcloud-nats-1.hcloud-nats:4222", "hcloud-nats-2.hcloud-nats:4222"];
+                }
+            }
+            this.natsConnection = yield this.connection({
+                debug: params.debug,
+                maxReconnectAttempts: -1,
+                servers: params.servers,
+                pingInterval: 55 * 1000, //ping every 55 seconds
+                user: params.email !== undefined ? params.email : params.username,
+                pass: params.jwt !== undefined ? params.jwt : params.password,
+            });
+            return this.natsConnection;
+        });
+    }
+    sub(subject, callback, options) {
+        var _a;
+        let delay = 0;
+        if (!this.getConnection() || ((_a = this.getConnection()) === null || _a === void 0 ? void 0 : _a.isClosed())) {
+            delay = 3000;
+        }
+        // add delay just in case the connection has not been established yet
+        return new Promise((resolve, reject) => {
+            const newOptions = Object.assign(Object.assign({}, options), { callback: (err, msg) => {
+                    if (err !== null) {
+                        try {
+                            callback(err);
+                        }
+                        catch (ignored) {
+                            // ignore callback errors
+                        }
+                        return;
+                    }
+                    let parsedData;
+                    try {
+                        const data = new TextDecoder("utf-8").decode(msg.data);
+                        parsedData = JSON.parse(data);
+                    }
+                    catch (e) {
+                        callback(e);
+                        return;
+                    }
+                    try {
+                        callback(null, parsedData, msg);
+                    }
+                    catch (ignored) {
+                        // ignore callback errors
+                    }
+                } });
+            setTimeout(() => {
+                var _a, _b;
+                if (!this.getConnection() || !((_a = this.getConnection()) === null || _a === void 0 ? void 0 : _a.isClosed)) {
+                    reject(new Error("connection not established, can not subscribe"));
+                }
+                const sub = (_b = this.getConnection()) === null || _b === void 0 ? void 0 : _b.subscribe(subject, newOptions);
+                if (sub) {
+                    this.subMap.push({ subject, sub: sub });
+                    return resolve(sub);
+                }
+                return reject(new Error("could not subscribe"));
+            }, delay);
+        });
+    }
+    unsub(subject) {
+        if (typeof subject === "string") {
+            this.subMap.forEach((s) => {
+                if (s.subject === subject) {
+                    s.sub.unsubscribe();
+                }
+            });
+        }
+        else {
+            subject === null || subject === void 0 ? void 0 : subject.unsubscribe();
+        }
+    }
+    publish(subject, type, objectType, object, options) {
+        var _a;
+        const data = new TextEncoder().encode(JSON.stringify({ type: type, objectType: objectType, object: object }));
+        (_a = this.getConnection()) === null || _a === void 0 ? void 0 : _a.publish(subject, data, options);
+    }
+    request(subject, type, objectType, object, options) {
+        var _a;
+        const data = new TextEncoder().encode(JSON.stringify({ type: type, objectType: objectType, object: object }));
+        (_a = this.getConnection()) === null || _a === void 0 ? void 0 : _a.request(subject, data, options);
+    }
+    requestAndWaitForResponse(subject, type, objectType, object, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const data = new TextEncoder().encode(JSON.stringify({ type: type, objectType: objectType, object: object }));
+            return ((_a = this.getConnection()) === null || _a === void 0 ? void 0 : _a.request(subject, data, options)) || undefined;
+        });
+    }
+    respond(msg, data) {
+        const encodedData = new TextEncoder().encode(JSON.stringify(data));
+        msg.respond(encodedData);
+    }
+    getEndpoint(endpoint) {
+        return `${this.options.server}/ws/nats${endpoint}`;
+    }
+}
+exports.default = Nats;

package/lib/utils/Types.d.ts

@@ -0,0 +1 @@
+export type Select<T, Mandatory extends keyof T, Optional extends keyof T> = Pick<T, Mandatory> & Partial<Pick<T, Optional>>;

package/lib/utils/Types.js

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

package/lib/utils/bouncer/features/Provider.d.ts

@@ -0,0 +1,19 @@
+import { BouncerContext, HcloudFeature } from "../../../interfaces/bouncer";
+export type BouncerProviderLogger = (featureName: string, defaultValue: boolean, result: boolean, context?: BouncerContext, feature?: HcloudFeature) => void;
+export declare class BouncerProvider {
+    private features;
+    private context?;
+    private logger?;
+    private refs;
+    constructor(features: HcloudFeature[], context?: BouncerContext, logger?: BouncerProviderLogger);
+    isEnabled(featureName: string, defaultValue: boolean, context?: BouncerContext): boolean;
+    isEnabledFn(featureName: string, defaultValue: boolean, fn: (val: boolean) => void, context?: BouncerContext): boolean;
+    processRefs(): void;
+    addFeature(feature: HcloudFeature): void;
+    setFeatures(features: HcloudFeature[]): void;
+    setContext(context: BouncerContext): void;
+    updateContext({ region, email, organization }: BouncerContext): void;
+    private doesMatchRegion;
+    private doesMatchUser;
+    private doesMatchOrganization;
+}

package/lib/utils/bouncer/features/Provider.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BouncerProvider = void 0;
+class BouncerProvider {
+    constructor(features, context, logger) {
+        // refs holds a list of previous isEnabledFn requests
+        // with their according callback function (fn)
+        // that is being called whenever features or the context has changed
+        this.refs = [];
+        this.features = features;
+        this.context = context;
+        this.logger = logger;
+    }
+    /* eslint-disable complexity */
+    isEnabled(featureName, defaultValue, context) {
+        const feature = this.features.find(f => f.name === featureName);
+        let result = defaultValue;
+        if (feature) {
+            result =
+                feature.enabled &&
+                    this.doesMatchOrganization(feature, context !== null && context !== void 0 ? context : this.context) &&
+                    this.doesMatchUser(feature, context !== null && context !== void 0 ? context : this.context) &&
+                    this.doesMatchRegion(feature, context !== null && context !== void 0 ? context : this.context);
+        }
+        if (this.logger) {
+            this.logger(featureName, defaultValue, result, context !== null && context !== void 0 ? context : this.context, feature);
+        }
+        return result;
+    }
+    isEnabledFn(featureName, defaultValue, fn, context) {
+        this.refs.push({ featureName, defaultValue, fn, context });
+        return this.isEnabled(featureName, defaultValue, context);
+    }
+    // processRefs iterates over all refs and calls their callback function with the result of isEnabled
+    processRefs() {
+        this.refs.forEach(ref => {
+            ref.fn(this.isEnabled(ref.featureName, ref.defaultValue, ref.context));
+        });
+    }
+    addFeature(feature) {
+        this.features.push(feature);
+        this.processRefs();
+    }
+    setFeatures(features) {
+        this.features = features;
+        this.processRefs();
+    }
+    setContext(context) {
+        this.context = context;
+        this.processRefs();
+    }
+    updateContext({ region, email, organization }) {
+        if (!this.context) {
+            this.context = {
+                email,
+                organization,
+                region,
+            };
+        }
+        else {
+            this.context.email = email !== null && email !== void 0 ? email : this.context.email;
+            this.context.organization = organization !== null && organization !== void 0 ? organization : this.context.organization;
+            this.context.region = region !== null && region !== void 0 ? region : this.context.region;
+        }
+        this.processRefs();
+    }
+    /* eslint-disable @typescript-eslint/no-non-null-assertion*/
+    doesMatchRegion(feature, context) {
+        if (feature.regions.length) {
+            if (context === null || context === void 0 ? void 0 : context.region) {
+                return (feature.regions.map(r => r.replace("*", "(.+)")).find(r => r === (context === null || context === void 0 ? void 0 : context.region) || new RegExp(r).test(context.region)) !==
+                    undefined);
+            }
+            return false;
+        }
+        return true;
+    }
+    /* eslint-disable @typescript-eslint/no-non-null-assertion*/
+    doesMatchUser(feature, context) {
+        if (feature.users.length) {
+            if (context === null || context === void 0 ? void 0 : context.email) {
+                return (feature.users.map(u => u.replace("*", "(.+)")).find(u => u === context.email || new RegExp(u).test(context.email)) !== undefined);
+            }
+            return false;
+        }
+        return true;
+    }
+    /* eslint-disable @typescript-eslint/no-non-null-assertion*/
+    doesMatchOrganization(feature, context) {
+        if (feature.organizations.length) {
+            if (context === null || context === void 0 ? void 0 : context.organization) {
+                return (feature.organizations
+                    .map(o => o.replace("*", "(.+)"))
+                    .find(o => o === context.organization || new RegExp(o).test(context.organization)) !== undefined);
+            }
+            return false;
+        }
+        return true;
+    }
+}
+exports.BouncerProvider = BouncerProvider;

package/package.json

@@ -1,9 +1,18 @@
 {
   "name": "hcloud-sdk",
-  "version": "0.0.16",
+  "version": "15.0.0",
   "description": "hcloud platform sdk",
   "main": "index.js",
   "types": "index.d.ts",
+  "scripts": {
+    "test": "mocha -r ts-node/register tests/**/*.test.ts",
+    "format": "prettier --write \"src/**/*.ts\" \"tests/**/*.test.ts\"",
+    "lint": "eslint --max-warnings=0 --fix src/ tests/ --ext .ts",
+    "doc:build": "vuepress build _docs/src",
+    "doc:dev": "vuepress dev _docs/src",
+    "doc:export": "vuepress export _docs/src",
+    "build": "tsc"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/moovit-sp-gmbh/hcloud-sdk-js.git"
@@ -19,33 +28,32 @@
   "author": "moovit-sp-gmbh",
   "homepage": "https://github.com/moovit-sp-gmbh/hcloud-sdk-js#readme",
   "devDependencies": {
-    "@types/chai": "^4.3.1",
-    "@types/mocha": "^9.1.1",
-    "@types/uuid": "^8.3.4",
-    "@types/node": "^18.0.0",
-    "chai": "^4.3.6",
-    "dayjs": "^1.11.3",
-    "mocha": "^10.0.0",
-    "prettier": "^2.6.2",
-    "ts-node": "^10.8.0",
-    "tslint": "^6.1.3",
-    "tslint-config-prettier": "^1.18.0",
-    "typescript": "^4.7.2",
-    "uuid": "^8.3.2",
-    "vuepress": "^1.9.7",
-    "vuepress-theme-default-prefers-color-scheme": "^2.0.0"
+    "@commitlint/cli": "^18.6.1",
+    "@commitlint/config-conventional": "^18.6.3",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@trivago/prettier-plugin-sort-imports": "^4.3.0",
+    "@types/chai": "^4.3.17",
+    "@types/mocha": "^10.0.7",
+    "@types/node": "^20.14.8",
+    "@typescript-eslint/eslint-plugin": "^7.0.2",
+    "@typescript-eslint/parser": "^7.0.2",
+    "chai": "^4.5.0",
+    "conventional-changelog-conventionalcommits": "^8.0.0",
+    "dayjs": "^1.11.12",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^8.10.0",
+    "eslint-plugin-import": "^2.29.1",
+    "mocha": "^10.7.3",
+    "prettier": "^3.3.3",
+    "semantic-release": "^23.1.1",
+    "semantic-release-telegram": "^1.6.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.5.4"
   },
   "dependencies": {
-    "axios": "^0.27.2"
-  },
-  "scripts": {
-    "test": "mocha -r ts-node/register tests/**/*.test.ts",
-    "format": "prettier --write \"src/**/*.ts\" \"tests/**/*.test.ts\"",
-    "lint": "tslint -p tsconfig.json",
-    "doc:build": "vuepress build _docs/src",
-    "doc:dev": "vuepress dev _docs/src",
-    "doc:export": "vuepress export _docs/src",
-    "build": "tsc"
-  },
-  "readme": "# hcloud-sdk\n[![MIT License](https://img.shields.io/badge/license-MIT-yellow.svg)](https://opensource.org/licenses/MIT)\n[![Latest Release](https://img.shields.io/npm/v/hcloud-sdk.svg)](https://www.npmjs.com/package/hcloud-sdk)\n"
-}
+    "axios": "^1.7.3",
+    "nats": "^2.28.2",
+    "nats.ws": "^1.29.2"
+  }
+}

package/lib/base.d.ts

@@ -1,12 +0,0 @@
-export interface Options {
-    api: string;
-    auditor?: {
-        queue?: {
-            executionInterval?: number;
-        };
-    };
-}
-export default abstract class Base {
-    protected opts: Options;
-    constructor(opts: Options);
-}

package/lib/base.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class Base {
-    constructor(opts) {
-        this.opts = opts;
-    }
-}
-exports.default = Base;