@nu-art/firebase-backend 0.400.5

package/ModuleBE_Firebase.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Created by tacb0ss on 25/08/2018.
+ */
+import { Module } from '@nu-art/ts-common';
+import { FirebaseSession_Admin } from './auth/FirebaseSession_Admin.js';
+import { TestResetListener } from '@nu-art/ts-common/testing/types';
+type ConfigType = {
+    isEmulator?: boolean;
+};
+export declare const FIREBASE_DEFAULT_PROJECT_ID = "local";
+export declare class ModuleBE_Firebase_Class extends Module<ConfigType> implements TestResetListener {
+    private readonly adminSessions;
+    constructor();
+    protected init(): void;
+    __resetForTests(): Promise<void>;
+    createAdminSession(authKey?: string): FirebaseSession_Admin;
+    createModuleStateFirebaseRef<T>(module: Module, _relativePath: string): import("./index.js").FirebaseRef<T>;
+}
+export declare const ModuleBE_Firebase: ModuleBE_Firebase_Class;
+export {};

package/ModuleBE_Firebase.js

@@ -0,0 +1,69 @@
+/*
+ * Firebase is a simpler Typescript wrapper to all of firebase services.
+ *
+ * Copyright (C) 2020 Adam van der Kruk aka TacB0sS
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Created by tacb0ss on 25/08/2018.
+ */
+import { Module } from '@nu-art/ts-common';
+import { FirebaseSession_Admin } from './auth/FirebaseSession_Admin.js';
+// import {FirebaseSession_UserPassword} from "./auth/FirebaseSession_UserPassword.js";
+import { readFileSync } from 'fs';
+import { ModuleBE_Auth } from '@nu-art/google-services-backend';
+import { deleteApp, getApps } from 'firebase-admin/app';
+export const FIREBASE_DEFAULT_PROJECT_ID = 'local';
+export class ModuleBE_Firebase_Class extends Module {
+    adminSessions = {};
+    constructor() {
+        super('firebase');
+    }
+    init() {
+    }
+    async __resetForTests() {
+        this.logWarning('__resetForTests');
+        for (const key in this.adminSessions)
+            delete this.adminSessions[key];
+        await Promise.all(getApps().map(app => deleteApp(app)));
+    }
+    createAdminSession(authKey = FIREBASE_DEFAULT_PROJECT_ID) {
+        const session = this.adminSessions[authKey];
+        if (session)
+            return session;
+        // try to fetch the service account from the auth serviceAccount by the authKey
+        let serviceAccount;
+        try {
+            serviceAccount = ModuleBE_Auth.getAuthConfig(authKey);
+        }
+        catch (e) {
+            if (authKey !== FIREBASE_DEFAULT_PROJECT_ID)
+                throw e;
+        }
+        // if we received a string we assume it is a path to the service account, and we load it into our serviceAccount
+        if (typeof serviceAccount === 'string')
+            serviceAccount = JSON.parse(readFileSync(serviceAccount, 'utf8'));
+        // define a unique key for the firebase session, and any following requests for this auth key
+        this.logInfo(`Creating Firebase session for auth key: ${authKey}`, serviceAccount);
+        return this.adminSessions[authKey] = new FirebaseSession_Admin(authKey, serviceAccount).connect();
+    }
+    createModuleStateFirebaseRef(module, _relativePath) {
+        let relativePath = _relativePath;
+        if (relativePath.startsWith('/'))
+            relativePath = relativePath.substring(1);
+        const path = `/state/${module.getName()}/${relativePath}`;
+        return ModuleBE_Firebase.createAdminSession().getDatabase().ref(path);
+    }
+}
+export const ModuleBE_Firebase = new ModuleBE_Firebase_Class();

package/auth/FirebaseBaseWrapper.d.ts

@@ -0,0 +1,19 @@
+import { FirebaseSession } from './firebase-session.js';
+import { Logger } from '@nu-art/ts-common';
+/**
+ * base wrapper
+ */
+export declare abstract class FirebaseBaseWrapper extends Logger {
+    readonly firebaseSession: FirebaseSession<any>;
+    /**
+     * Constructor that takes a FirebaseSession object and assigns it to this.firebaseSession.
+     * @param firebaseSession
+     * @protected
+     */
+    protected constructor(firebaseSession: FirebaseSession<any>);
+    /**
+     * Returns true if the user associated with this FirebaseSession is an admin, false otherwise.
+     */
+    isAdmin(): boolean;
+    abstract isEmulator(): boolean;
+}

package/auth/FirebaseBaseWrapper.js

@@ -0,0 +1,39 @@
+/*
+ * Firebase is a simpler Typescript wrapper to all of firebase services.
+ *
+ * Copyright (C) 2020 Adam van der Kruk aka TacB0sS
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Logger } from '@nu-art/ts-common';
+/**
+ * base wrapper
+ */
+export class FirebaseBaseWrapper extends Logger {
+    firebaseSession;
+    /**
+     * Constructor that takes a FirebaseSession object and assigns it to this.firebaseSession.
+     * @param firebaseSession
+     * @protected
+     */
+    constructor(firebaseSession) {
+        super();
+        this.firebaseSession = firebaseSession;
+    }
+    /**
+     * Returns true if the user associated with this FirebaseSession is an admin, false otherwise.
+     */
+    isAdmin() {
+        return this.firebaseSession.isAdmin();
+    }
+}

package/auth/FirebaseSession_Admin.d.ts

@@ -0,0 +1,19 @@
+import { JWTInput } from 'google-auth-library';
+import { FirebaseSession } from './firebase-session.js';
+/**
+ Represents an admin session for interacting with Firebase services.
+ */
+export declare class FirebaseSession_Admin extends FirebaseSession<JWTInput & {
+    databaseURL?: string;
+    isEmulator?: boolean;
+} | undefined> {
+    constructor(firebaseAppName: string, config?: any);
+    /**
+     * Establishes a connection to the Firebase project using the configuration data and the project ID.
+     */
+    connect(): this;
+    /**
+     Returns an instance of the Firebase Authentication service.
+     */
+    getAuth(): import("firebase-admin/auth").Auth;
+}

package/auth/FirebaseSession_Admin.js

@@ -0,0 +1,45 @@
+/*
+ * Firebase is a simpler Typescript wrapper to all of firebase services.
+ *
+ * Copyright (C) 2020 Adam van der Kruk aka TacB0sS
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Created by tacb0ss on 19/09/2018.
+ */
+import { initializeApp } from 'firebase-admin/app';
+import { FirebaseSession } from './firebase-session.js';
+import { getAuth } from 'firebase-admin/auth';
+/**
+ Represents an admin session for interacting with Firebase services.
+ */
+export class FirebaseSession_Admin extends FirebaseSession {
+    constructor(firebaseAppName, config) {
+        super(config, firebaseAppName);
+    }
+    /**
+     * Establishes a connection to the Firebase project using the configuration data and the project ID.
+     */
+    connect() {
+        this.app = initializeApp(this.config, this.firebaseAppName);
+        this.logWarning(this.app.options);
+        return this;
+    }
+    /**
+     Returns an instance of the Firebase Authentication service.
+     */
+    getAuth() {
+        return getAuth(this.app);
+    }
+}

package/auth/firebase-session.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Created by tacb0ss on 25/08/2018.
+ */
+import { Logger, TypedMap } from '@nu-art/ts-common';
+import { DatabaseWrapperBE } from '../database/DatabaseWrapperBE.js';
+import { StorageWrapperBE } from '../storage/StorageWrapperBE.js';
+import { PushMessagesWrapperBE } from '../push/PushMessagesWrapperBE.js';
+import { App } from 'firebase-admin/app';
+import { FirestoreWrapperBEV3 } from '../firestore-v3/FirestoreWrapperBEV3.js';
+import { FirebaseConfig } from '@nu-art/firebase-shared';
+import { FirestoreWrapperBE } from '../firestore/FirestoreWrapperBE.js';
+/**
+ * Represents the credentials of a Firebase user.
+ */
+export type Firebase_UserCredential = {
+    config: FirebaseConfig;
+    credentials: {
+        user: string;
+        password: string;
+    };
+};
+/**
+ * An abstract class that serves as a base for Firebase session classes.
+ */
+export declare abstract class FirebaseSession<Config> extends Logger {
+    app: App;
+    protected databases: TypedMap<DatabaseWrapperBE>;
+    protected storage?: StorageWrapperBE;
+    protected firestoresV3: TypedMap<FirestoreWrapperBEV3>;
+    protected messaging?: PushMessagesWrapperBE;
+    protected firestores: TypedMap<FirestoreWrapperBE>;
+    protected config: Config;
+    protected firebaseAppName: string;
+    private readonly admin;
+    /**
+     * Initializes a new instance of the FirebaseSession class.
+     * @param config The configuration settings for the Firebase session.
+     * @param sessionName The name of the Firebase session.
+     * @param _admin A value indicating whether the session is an admin session.
+     */
+    protected constructor(config: Config, sessionName: string, _admin?: boolean);
+    isAdmin(): boolean;
+    abstract connect(): void;
+    /**
+     * Returns an instance of the DatabaseWrapperBE object, which provides access to a database.
+     */
+    getDatabase(dbName?: string): DatabaseWrapperBE;
+    /**
+     * Returns an instance of the StorageWrapperBE object, which provides access to a cloud storage service.
+     */
+    getStorage(): StorageWrapperBE;
+    /**
+     * Returns an instance of the FirestoreWrapperBE object, which provides access to the Firestore database service.
+     */
+    getFirestore(dbName?: string): FirestoreWrapperBE;
+    getFirestoreV3(dbName?: string): FirestoreWrapperBEV3;
+    /**
+     * Returns an instance of the PushMessagesWrapperBE object, which provides access to push messaging services.
+     */
+    getMessaging(): PushMessagesWrapperBE;
+}

package/auth/firebase-session.js

@@ -0,0 +1,93 @@
+/*
+ * Firebase is a simpler Typescript wrapper to all of firebase services.
+ *
+ * Copyright (C) 2020 Adam van der Kruk aka TacB0sS
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Created by tacb0ss on 25/08/2018.
+ */
+import { Logger } from '@nu-art/ts-common';
+import { DatabaseWrapperBE } from '../database/DatabaseWrapperBE.js';
+import { StorageWrapperBE } from '../storage/StorageWrapperBE.js';
+import { PushMessagesWrapperBE } from '../push/PushMessagesWrapperBE.js';
+import { FirestoreWrapperBEV3 } from '../firestore-v3/FirestoreWrapperBEV3.js';
+import { FirestoreWrapperBE } from '../firestore/FirestoreWrapperBE.js';
+// export type FirebaseApp = admin.app.App | firebase.app.App
+/**
+ * An abstract class that serves as a base for Firebase session classes.
+ */
+export class FirebaseSession extends Logger {
+    app;
+    databases = {};
+    storage;
+    firestoresV3 = {};
+    messaging;
+    firestores = {};
+    config;
+    firebaseAppName;
+    admin;
+    /**
+     * Initializes a new instance of the FirebaseSession class.
+     * @param config The configuration settings for the Firebase session.
+     * @param sessionName The name of the Firebase session.
+     * @param _admin A value indicating whether the session is an admin session.
+     */
+    constructor(config, sessionName, _admin = true) {
+        super(`firebase: ${sessionName}`);
+        this.firebaseAppName = sessionName;
+        this.config = config;
+        this.admin = _admin;
+    }
+    isAdmin() {
+        return this.admin;
+    }
+    /**
+     * Returns an instance of the DatabaseWrapperBE object, which provides access to a database.
+     */
+    getDatabase(dbName) {
+        if (!this.databases[dbName ?? 'default'])
+            this.databases[dbName ?? 'default'] = new DatabaseWrapperBE(this, dbName);
+        return this.databases[dbName ?? 'default'];
+    }
+    /**
+     * Returns an instance of the StorageWrapperBE object, which provides access to a cloud storage service.
+     */
+    getStorage() {
+        if (this.storage)
+            return this.storage;
+        return this.storage = new StorageWrapperBE(this);
+    }
+    /**
+     * Returns an instance of the FirestoreWrapperBE object, which provides access to the Firestore database service.
+     */
+    getFirestore(dbName) {
+        if (!this.firestores[dbName ?? 'default'])
+            this.firestores[dbName ?? 'default'] = new FirestoreWrapperBE(this, dbName);
+        return this.firestores[dbName ?? 'default'];
+    }
+    getFirestoreV3(dbName) {
+        if (!this.firestoresV3[dbName ?? 'default'])
+            this.firestoresV3[dbName ?? 'default'] = new FirestoreWrapperBEV3(this, dbName);
+        return this.firestoresV3[dbName ?? 'default'];
+    }
+    /**
+     * Returns an instance of the PushMessagesWrapperBE object, which provides access to push messaging services.
+     */
+    getMessaging() {
+        if (this.messaging)
+            return this.messaging;
+        return this.messaging = new PushMessagesWrapperBE(this);
+    }
+}

package/database/DatabaseWrapperBE.d.ts

@@ -0,0 +1,71 @@
+import { TS_Object } from '@nu-art/ts-common';
+import { FirebaseSession } from '../auth/firebase-session.js';
+import { FirebaseBaseWrapper } from '../auth/FirebaseBaseWrapper.js';
+import { Reference } from 'firebase-admin/database';
+/**
+ * simplified interface for interacting with  Firebase
+ */
+export declare class DatabaseWrapperBE extends FirebaseBaseWrapper {
+    private readonly database;
+    constructor(firebaseSession: FirebaseSession<any>, url?: string);
+    getUrl(): string | undefined;
+    get<T>(path: string, fallbackValue?: T): Promise<T>;
+    private getRef;
+    listen<T>(path: string, callback: (value?: T) => void): (a: import("firebase-admin/database").DataSnapshot | null, b?: string | null) => any;
+    stopListening(path: string, listener: any): void;
+    set<T>(path: string, value: T): Promise<void>;
+    uploadByChunks(parentPath: string, data: TS_Object, maxSizeMB?: number, itemsToRef?: Promise<any>[]): Promise<void>;
+    update<T>(path: string, value: T): Promise<void>;
+    patch<T>(path: string, value: Partial<T>): Promise<void>;
+    remove(path: string, assertionRegexp?: string): Promise<void>;
+    delete(path: string, assertionRegexp?: string): Promise<void>;
+    transaction<T>(path: string, func: (currentValue: T) => T): ReturnType<Reference['transaction']>;
+    ref<T>(path: string): FirebaseRef<T>;
+    isEmulator(): boolean;
+}
+/**
+ * simplified interface for interacting with  Firebase
+ */
+export declare class FirebaseRef<T> {
+    private readonly db;
+    private readonly path;
+    constructor(db: DatabaseWrapperBE, path: string);
+    get(): Promise<T | undefined>;
+    get(fallbackValue: T): Promise<T>;
+    set(value: T): Promise<void>;
+    /**
+     * Updates the specified path in the database with the provided partial value.
+     * @param value
+     */
+    patch(value: Partial<T>): Promise<void>;
+    /**
+     * Deletes the specified path in the database, subject to the provided assertion regular expression.
+     * @param assertionRegexp
+     */
+    delete(assertionRegexp?: string): Promise<void>;
+    /**
+     * Listens for changes at the specified path in the database and invokes the provided callback with the new value.
+     * @param callback
+     */
+    listen(callback: (value?: T) => void): (a: import("firebase-admin/database").DataSnapshot | null, b?: string | null) => any;
+    /**
+     * Stops listening for changes at the specified path in the database with the provided listener.
+     * @param listener
+     */
+    stopListening(listener: any): void;
+    /**
+     * Executes a transaction at the specified path in the database, using the provided function to update the current value.
+     * @param func
+     */
+    transaction(func: (currentValue: T) => T): Promise<{
+        committed: boolean;
+        value: T;
+    }>;
+    /**
+     * Uploads a large object to the specified path in the database in chunks, with a maximum chunk size specified in MB.
+     * @param value
+     * @param maxSizeMB
+     * @param itemsToRef
+     */
+    uploadByChunks(value: TS_Object, maxSizeMB?: number, itemsToRef?: Promise<any>[]): Promise<void>;
+}

package/database/DatabaseWrapperBE.js

@@ -0,0 +1,182 @@
+/*
+ * Firebase is a simpler Typescript wrapper to all of firebase services.
+ *
+ * Copyright (C) 2020 Adam van der Kruk aka TacB0sS
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { BadImplementationException, calculateJsonSizeMb } from '@nu-art/ts-common';
+import { FirebaseBaseWrapper } from '../auth/FirebaseBaseWrapper.js';
+import { getDatabase, getDatabaseWithUrl } from 'firebase-admin/database';
+/**
+ * simplified interface for interacting with  Firebase
+ */
+export class DatabaseWrapperBE extends FirebaseBaseWrapper {
+    database;
+    constructor(firebaseSession, url) {
+        super(firebaseSession);
+        if (url)
+            this.database = getDatabaseWithUrl(url, firebaseSession.app);
+        else
+            this.database = getDatabase(firebaseSession.app);
+    }
+    getUrl() {
+        return this.database.app.options.databaseURL;
+    }
+    async get(path, fallbackValue) {
+        const snapshot = await this.getRef(path).once('value');
+        let toRet = fallbackValue;
+        if (snapshot)
+            toRet = snapshot.val();
+        if (!toRet)
+            toRet = fallbackValue;
+        return toRet;
+    }
+    getRef(path) {
+        // @ts-ignore
+        return this.database.ref(path);
+    }
+    listen(path, callback) {
+        try {
+            return this.database.ref(path).on('value', (snapshot) => callback(snapshot ? snapshot.val() : undefined));
+        }
+        catch (e) {
+            throw new BadImplementationException(`Error while getting value from path: ${path}`, e);
+        }
+    }
+    stopListening(path, listener) {
+        try {
+            this.database.ref(path).off('value', listener);
+        }
+        catch (e) {
+            throw new BadImplementationException(`Error while getting value from path: ${path}`, e);
+        }
+    }
+    async set(path, value) {
+        try {
+            return await this.database.ref(path).set(value);
+        }
+        catch (e) {
+            throw new BadImplementationException(`Error while setting value to path: ${path}`, e);
+        }
+    }
+    async uploadByChunks(parentPath, data, maxSizeMB = 3, itemsToRef = []) {
+        for (const key in data) {
+            const node = `${parentPath}/${key}`;
+            if (calculateJsonSizeMb(data[key]) < maxSizeMB)
+                await this.set(node, data[key]);
+            else
+                await this.uploadByChunks(node, data[key], maxSizeMB, itemsToRef);
+        }
+    }
+    async update(path, value) {
+        this.logWarning('update will be deprecated!! please use patch');
+        return this.patch(path, value);
+    }
+    async patch(path, value) {
+        try {
+            return await this.database.ref(path).update(value);
+        }
+        catch (e) {
+            this.logError(e);
+            throw new BadImplementationException(`Error while updating value to path: ${path}`, e);
+        }
+    }
+    async remove(path, assertionRegexp = '^/.*?/.*') {
+        this.logWarning('remove will be deprecated!! please use delete');
+        return this.delete(path, assertionRegexp);
+    }
+    async delete(path, assertionRegexp = '^/.*?/.*') {
+        if (!path)
+            throw new BadImplementationException(`Falsy value, path: '${path}'`);
+        if (!path.match(new RegExp(assertionRegexp)))
+            throw new BadImplementationException(`path: '${path}'  does not match assertion: '${assertionRegexp}'`);
+        try {
+            return await this.database.ref(path).remove();
+        }
+        catch (e) {
+            throw new BadImplementationException(`Error while removing path: ${path}`, e);
+        }
+    }
+    async transaction(path, func) {
+        return this.database.ref(path).transaction(func);
+    }
+    ref(path) {
+        return new FirebaseRef(this, path);
+    }
+    isEmulator() {
+        return !!process.env.FIREBASE_DATABASE_EMULATOR_HOST || false;
+    }
+}
+/**
+ * simplified interface for interacting with  Firebase
+ */
+export class FirebaseRef {
+    db;
+    path;
+    constructor(db, path) {
+        this.db = db;
+        this.path = path;
+    }
+    get(fallbackValue) {
+        return this.db.get(this.path, fallbackValue);
+    }
+    set(value) {
+        return this.db.set(this.path, value);
+    }
+    /**
+     * Updates the specified path in the database with the provided partial value.
+     * @param value
+     */
+    patch(value) {
+        return this.db.patch(this.path, value);
+    }
+    /**
+     * Deletes the specified path in the database, subject to the provided assertion regular expression.
+     * @param assertionRegexp
+     */
+    delete(assertionRegexp = '^/.*?/.*') {
+        return this.db.delete(this.path, assertionRegexp);
+    }
+    /**
+     * Listens for changes at the specified path in the database and invokes the provided callback with the new value.
+     * @param callback
+     */
+    listen(callback) {
+        return this.db.listen(this.path, callback);
+    }
+    /**
+     * Stops listening for changes at the specified path in the database with the provided listener.
+     * @param listener
+     */
+    stopListening(listener) {
+        return this.db.stopListening(this.path, listener);
+    }
+    /**
+     * Executes a transaction at the specified path in the database, using the provided function to update the current value.
+     * @param func
+     */
+    async transaction(func) {
+        const result = (await this.db.transaction(this.path, func));
+        return { committed: result.committed, value: result.snapshot.val() };
+    }
+    /**
+     * Uploads a large object to the specified path in the database in chunks, with a maximum chunk size specified in MB.
+     * @param value
+     * @param maxSizeMB
+     * @param itemsToRef
+     */
+    async uploadByChunks(value, maxSizeMB = 3, itemsToRef = []) {
+        return this.db.uploadByChunks(this.path, value, maxSizeMB, itemsToRef);
+    }
+}

package/database/types.d.ts

@@ -0,0 +1,4 @@
+import { Database, Reference } from 'firebase-admin/database';
+export type Firebase_DB = Database & {
+    ref(path?: string): Reference;
+};

package/database/types.js

@@ -0,0 +1,18 @@
+/*
+ * Firebase is a simpler Typescript wrapper to all of firebase services.
+ *
+ * Copyright (C) 2020 Adam van der Kruk aka TacB0sS
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};