@powfix/core-js 0.20.4 → 0.21.0

package/dist/esm/shared/utils/global/flat.mjs

@@ -0,0 +1,113 @@
+// flat.ts
+function isBuffer(obj) {
+    return !!(obj &&
+        obj.constructor &&
+        typeof obj.constructor.isBuffer === 'function' &&
+        obj.constructor.isBuffer(obj));
+}
+function keyIdentity(key) {
+    return key;
+}
+export function flatten(target, opts = {}) {
+    const delimiter = opts.delimiter || '.';
+    const maxDepth = opts.maxDepth;
+    const transformKey = opts.transformKey || keyIdentity;
+    const output = {};
+    function step(object, prev, currentDepth = 1) {
+        Object.keys(object).forEach((key) => {
+            const value = object[key];
+            const isarray = opts.safe && Array.isArray(value);
+            const type = Object.prototype.toString.call(value);
+            const isbuffer = isBuffer(value);
+            const isobject = type === '[object Object]' || type === '[object Array]';
+            const newKey = prev
+                ? `${prev}${delimiter}${transformKey(key)}`
+                : transformKey(key);
+            if (!isarray &&
+                !isbuffer &&
+                isobject &&
+                Object.keys(value).length &&
+                (!maxDepth || currentDepth < maxDepth)) {
+                return step(value, newKey, currentDepth + 1);
+            }
+            output[newKey] = value;
+        });
+    }
+    step(target);
+    return output;
+}
+export function unflatten(target, opts = {}) {
+    const delimiter = opts.delimiter || '.';
+    const overwrite = opts.overwrite || false;
+    const transformKey = opts.transformKey || keyIdentity;
+    const result = {};
+    if (isBuffer(target) ||
+        Object.prototype.toString.call(target) !== '[object Object]') {
+        return target;
+    }
+    function getkey(key) {
+        const parsedKey = Number(key);
+        return isNaN(parsedKey) || key.indexOf('.') !== -1 || opts.object
+            ? key
+            : parsedKey;
+    }
+    function addKeys(keyPrefix, recipient, target) {
+        return Object.keys(target).reduce((res, key) => {
+            res[`${keyPrefix}${delimiter}${key}`] = target[key];
+            return res;
+        }, recipient);
+    }
+    function isEmpty(val) {
+        const type = Object.prototype.toString.call(val);
+        const isArray = type === '[object Array]';
+        const isObject = type === '[object Object]';
+        if (!val) {
+            return true;
+        }
+        else if (isArray) {
+            return !val.length;
+        }
+        else if (isObject) {
+            return !Object.keys(val).length;
+        }
+        return false;
+    }
+    const target2 = Object.keys(target).reduce((res, key) => {
+        const value = target[key];
+        const type = Object.prototype.toString.call(value);
+        const isObject = type === '[object Object]' || type === '[object Array]';
+        if (!isObject || isEmpty(value)) {
+            res[key] = value;
+            return res;
+        }
+        else {
+            return addKeys(key, res, flatten(value, opts));
+        }
+    }, {});
+    Object.keys(target2).forEach((key) => {
+        const split = key.split(delimiter).map(transformKey);
+        let key1 = getkey(split.shift());
+        let key2 = getkey(split[0]);
+        let recipient = result;
+        while (key2 !== undefined) {
+            if (key1 === '__proto__')
+                return;
+            const type = Object.prototype.toString.call(recipient[key1]);
+            const isobject = type === '[object Object]' || type === '[object Array]';
+            if (!overwrite && !isobject && typeof recipient[key1] !== 'undefined') {
+                return;
+            }
+            if ((overwrite && !isobject) || (!overwrite && recipient[key1] == null)) {
+                recipient[key1] =
+                    typeof key2 === 'number' && !opts.object ? [] : {};
+            }
+            recipient = recipient[key1];
+            if (split.length > 0) {
+                key1 = getkey(split.shift());
+                key2 = getkey(split[0]);
+            }
+        }
+        recipient[key1] = unflatten(target2[key], opts);
+    });
+    return result;
+}

package/dist/esm/shared/utils/global/index.mjs

@@ -0,0 +1,15 @@
+export * from './atob.mjs';
+export * from './base64.mjs';
+export * from './between.mjs';
+export * from './btoa.mjs';
+export * from './castArray.mjs';
+export * from './circularDistance.mjs';
+export * from './sleep.mjs';
+export * from './fallbackIfMatch.mjs';
+export * from './fallbackIfNull.mjs';
+export * from './fallbackIfNullish.mjs';
+export * from './fallbackIfUndefined.mjs';
+export * from './firstNonNullish.mjs';
+export * from './flat.mjs';
+export * from './processFirstNonNullish.mjs';
+export * from './pureEnum.mjs';

package/dist/esm/shared/utils/global/processFirstNonNullish.mjs

@@ -0,0 +1,8 @@
+import { firstNonNullish } from "./firstNonNullish.mjs";
+export function processFirstNonNullish(processor, ...args) {
+    const fallback = firstNonNullish(...args);
+    if (fallback == null) {
+        return undefined;
+    }
+    return processor(fallback);
+}

package/dist/esm/shared/utils/global/pureEnum.mjs

@@ -0,0 +1,18 @@
+/**
+ * @deprecated Use Enum instead.
+ */
+export function pureEnum(e) {
+    return Object.entries(e).filter(([key, value]) => !/^-?\d+$/g.test(key) && typeof value !== 'function');
+}
+/**
+ * @deprecated Use Enum instead.
+ */
+export function pureEnumKeys(e) {
+    return pureEnum(e).map(([key]) => key);
+}
+/**
+ * @deprecated Use Enum instead.
+ */
+export function pureEnumValues(e) {
+    return pureEnum(e).map(([, value]) => value);
+}

package/dist/esm/shared/utils/global/sleep.mjs

@@ -0,0 +1 @@
+export const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));

package/dist/esm/shared/utils/index.mjs

@@ -0,0 +1,23 @@
+export * from './global/index.mjs';
+export * from './ArrayUtils.mjs';
+export * from './AxiosUtils.mjs';
+export * from './StringUtils.mjs';
+export * from './Uint8ArrayUtils.mjs';
+export * from './UUID.mjs';
+export * from './UUID.types.mjs';
+export * from './UuidUtils.mjs';
+export * from './BooleanUtils.mjs';
+export * from './Calc.mjs';
+export * from './CoordinateUtils.mjs';
+export * from './DateUtils.mjs';
+export * from './Enum.mjs';
+export * from './Enum.types.mjs';
+export * from './I18nUtils.mjs';
+export * from './NumberUtils.mjs';
+export * from './ObjectIdUtils.mjs';
+export * from './Point3Utils.mjs';
+export * from './RandomUtils.mjs';
+export * from './Validator.mjs';
+export * from './JuminNumberUtils.mjs';
+export * from './Sequencer.mjs';
+export * from './try-catch/index.mjs';

package/dist/esm/shared/utils/try-catch/TryCatch.mjs

@@ -0,0 +1,74 @@
+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());
+    });
+};
+/**
+ * Provides a utility class for handling synchronous and asynchronous operations with a consistent try-catch pattern.
+ * It returns a tuple where the first element is the error (or null on success) and the second element is the result (or undefined on error).
+ */
+export class TryCatch {
+    /**
+     * Executes a synchronous function within a try-catch block.
+     * @template T The return type of the function.
+     * @template E The type of the error that might be thrown (defaults to Error).
+     * @param fn The synchronous function to execute.
+     *@param disableLogging console.error is default way of logging on error. You can disable it by setting it true
+     * @returns A tuple containing the result of the function and an error (null if successful).
+     */
+    static function(fn, disableLogging) {
+        try {
+            return [
+                null,
+                fn(),
+            ];
+        }
+        catch (e) {
+            if (!disableLogging) {
+                console.error("ERROR in TryCatch: ", e);
+            }
+            if (e == null) {
+                e = new Error("Unknown error");
+            }
+            return [
+                e,
+                undefined,
+            ];
+        }
+    }
+    /**
+     * Executes an asynchronous function (Promise) within a try-catch block.
+     * @template T The resolved value type of the Promise.
+     * @template E The type of the error that might be rejected (defaults to Error).
+     * @param fn The Promise to await.
+     * @param disableLogging console.error is default way of logging on error. You can disable it by setting it true
+     * @returns A tuple containing the resolved value of the Promise and an error (null if successful).
+     */
+    static asyncFunction(fn, disableLogging) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const data = yield fn;
+                return [
+                    null,
+                    data,
+                ];
+            }
+            catch (e) {
+                if (!disableLogging) {
+                    console.error("ERROR in TryCatch: ", e);
+                }
+                if (e == null) {
+                    e = new Error("Unknown error");
+                }
+                return [
+                    e,
+                    undefined,
+                ];
+            }
+        });
+    }
+}

package/dist/esm/shared/utils/try-catch/index.mjs

@@ -0,0 +1 @@
+export * from "./TryCatch.mjs";

package/dist/node/cjs/index.nodejs.js

@@ -14,5 +14,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.UUID = void 0;
 __exportStar(require("./shared"), exports);
 __exportStar(require("./nodejs"), exports);
+var nodejs_1 = require("./nodejs");
+Object.defineProperty(exports, "UUID", { enumerable: true, get: function () { return nodejs_1.UUID; } });

package/dist/node/cjs/shared/utils/UUID.js

@@ -215,17 +215,17 @@ class UUID {
      * -------------------------------------------------------------------- */
     /**
      * Compares multiple UUIDs for strict equality.
-     * @param uuids - The UUIDs to compare (at least two required).
+     * @param inputs - The UUIDs to compare (at least two required).
      * @returns true if all provided UUIDs are identical.
      */
-    static equals(...uuids) {
-        const n = uuids.length;
+    static equals(...inputs) {
+        const n = inputs.length;
         if (n < 2) {
             throw new Error('At least two UUIDs required for comparison');
         }
-        const ref = uuids[0].bytes;
+        const ref = this.parse(inputs[0]);
         for (let i = 1; i < n; ++i) {
-            const b = uuids[i].bytes;
+            const b = this.parse(inputs[i]);
             for (let j = 0; j < UUID.BYTE_LENGTH; ++j) {
                 if (ref[j] !== b[j])
                     return false;
@@ -240,8 +240,8 @@ class UUID {
      * @returns -1 if uuid1 < uuid2, 1 if uuid1 > uuid2, 0 otherwise.
      */
     static compare(uuid1, uuid2) {
-        const a = uuid1.bytes;
-        const b = uuid2.bytes;
+        const a = this.parse(uuid1);
+        const b = this.parse(uuid2);
         for (let i = 0; i < UUID.BYTE_LENGTH; i++) {
             if (a[i] !== b[i])
                 return a[i] < b[i] ? -1 : 1;
@@ -256,8 +256,8 @@ class UUID {
         this.bytes = UUID.parse(input);
     }
     /** Instance wrapper for {@link equals}. */
-    equals(...uuids) {
-        return UUID.equals(this, ...uuids);
+    equals(...inputs) {
+        return UUID.equals(this, ...inputs);
     }
     /** Instance wrapper for {@link compare}. */
     compare(other) {

package/dist/node/cjs/shared/utils/index.js

@@ -19,7 +19,7 @@ __exportStar(require("./ArrayUtils"), exports);
 __exportStar(require("./AxiosUtils"), exports);
 __exportStar(require("./StringUtils"), exports);
 __exportStar(require("./Uint8ArrayUtils"), exports);
-// export * from './UUID';
+__exportStar(require("./UUID"), exports);
 __exportStar(require("./UUID.types"), exports);
 __exportStar(require("./UuidUtils"), exports);
 __exportStar(require("./BooleanUtils"), exports);

package/dist/node/esm/index.nodejs.mjs

@@ -1,2 +1,3 @@
 export * from './shared/index.mjs';
 export * from './nodejs/index.mjs';
+export { UUID } from "./nodejs/index.mjs";

package/dist/node/esm/shared/utils/UUID.mjs

@@ -212,17 +212,17 @@ export class UUID {
      * -------------------------------------------------------------------- */
     /**
      * Compares multiple UUIDs for strict equality.
-     * @param uuids - The UUIDs to compare (at least two required).
+     * @param inputs - The UUIDs to compare (at least two required).
      * @returns true if all provided UUIDs are identical.
      */
-    static equals(...uuids) {
-        const n = uuids.length;
+    static equals(...inputs) {
+        const n = inputs.length;
         if (n < 2) {
             throw new Error('At least two UUIDs required for comparison');
         }
-        const ref = uuids[0].bytes;
+        const ref = this.parse(inputs[0]);
         for (let i = 1; i < n; ++i) {
-            const b = uuids[i].bytes;
+            const b = this.parse(inputs[i]);
             for (let j = 0; j < UUID.BYTE_LENGTH; ++j) {
                 if (ref[j] !== b[j])
                     return false;
@@ -237,8 +237,8 @@ export class UUID {
      * @returns -1 if uuid1 < uuid2, 1 if uuid1 > uuid2, 0 otherwise.
      */
     static compare(uuid1, uuid2) {
-        const a = uuid1.bytes;
-        const b = uuid2.bytes;
+        const a = this.parse(uuid1);
+        const b = this.parse(uuid2);
         for (let i = 0; i < UUID.BYTE_LENGTH; i++) {
             if (a[i] !== b[i])
                 return a[i] < b[i] ? -1 : 1;
@@ -253,8 +253,8 @@ export class UUID {
         this.bytes = UUID.parse(input);
     }
     /** Instance wrapper for {@link equals}. */
-    equals(...uuids) {
-        return UUID.equals(this, ...uuids);
+    equals(...inputs) {
+        return UUID.equals(this, ...inputs);
     }
     /** Instance wrapper for {@link compare}. */
     compare(other) {

package/dist/node/esm/shared/utils/index.mjs

@@ -3,7 +3,7 @@ export * from './ArrayUtils.mjs';
 export * from './AxiosUtils.mjs';
 export * from './StringUtils.mjs';
 export * from './Uint8ArrayUtils.mjs';
-// export * from './UUID';
+export * from './UUID.mjs';
 export * from './UUID.types.mjs';
 export * from './UuidUtils.mjs';
 export * from './BooleanUtils.mjs';

package/dist/node/types/index.nodejs.d.ts

@@ -1,2 +1,3 @@
 export * from './shared';
 export * from './nodejs';
+export { UUID } from "./nodejs";

package/dist/node/types/shared/utils/UUID.d.ts

@@ -102,17 +102,17 @@ export declare class UUID {
     static max<T extends typeof UUID>(this: T): InstanceType<T>;
     /**
      * Compares multiple UUIDs for strict equality.
-     * @param uuids - The UUIDs to compare (at least two required).
+     * @param inputs - The UUIDs to compare (at least two required).
      * @returns true if all provided UUIDs are identical.
      */
-    static equals(...uuids: UUID[]): boolean;
+    static equals(...inputs: UuidInput[]): boolean;
     /**
      * Lexicographically compares two UUIDs.
      * @param uuid1 - The first UUID.
      * @param uuid2 - The second UUID.
      * @returns -1 if uuid1 < uuid2, 1 if uuid1 > uuid2, 0 otherwise.
      */
-    static compare(uuid1: UUID, uuid2: UUID): number;
+    static compare(uuid1: UuidInput, uuid2: UuidInput): number;
     /** Raw byte representation of the UUID. */
     protected readonly bytes: Uint8Array;
     private _str?;
@@ -123,9 +123,9 @@ export declare class UUID {
      */
     constructor(input: UuidInput);
     /** Instance wrapper for {@link equals}. */
-    equals(...uuids: UUID[]): boolean;
+    equals(...inputs: UuidInput[]): boolean;
     /** Instance wrapper for {@link compare}. */
-    compare(other: UUID): number;
+    compare(other: UuidInput): number;
     version(): number;
     /**
      * Returns the RFC 4122 string representation of this UUID.

package/dist/node/types/shared/utils/index.d.ts

@@ -3,6 +3,7 @@ export * from './ArrayUtils';
 export * from './AxiosUtils';
 export * from './StringUtils';
 export * from './Uint8ArrayUtils';
+export * from './UUID';
 export * from './UUID.types';
 export * from './UuidUtils';
 export * from './BooleanUtils';

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export * from './shared';

package/dist/types/shared/constants/COORDINATE.d.ts

@@ -0,0 +1,7 @@
+export declare class COORDINATE {
+    static LATITUDE_MIN_LENGTH: number;
+    static LATITUDE_MAX_LENGTH: number;
+    static LONGITUDE_MIN_LENGTH: number;
+    static LONGITUDE_MAX_LENGTH: number;
+}
+export declare namespace COORDINATE { }

package/dist/types/shared/constants/CRUD.d.ts

@@ -0,0 +1,9 @@
+export declare enum CRUD {
+    CREATE = 1,
+    READ = 2,
+    UPDATE = 3,
+    DELETE = 4
+}
+export declare namespace CRUD {
+    function toString(crud: CRUD): string;
+}

package/dist/types/shared/constants/DATE.d.ts

@@ -0,0 +1,13 @@
+export declare class DATE {
+}
+export declare namespace DATE {
+    enum FORMAT {
+        UNIX = 1,
+        SECONDS = 2,
+        MILLISECONDS = 3,
+        ISO_8601 = 4
+    }
+    namespace FORMAT {
+        function toString(format: FORMAT): string;
+    }
+}

package/dist/types/shared/constants/DISTANCE.d.ts

@@ -0,0 +1,13 @@
+export declare class DISTANCE {
+}
+export declare namespace DISTANCE {
+    enum UNIT {
+        FEET = "FEET",
+        KILOMETERS = "KILOMETERS",
+        MILLIMETERS = "MILLIMETERS",
+        CENTIMETERS = "CENTIMETERS",
+        METERS = "METERS",
+        MILES = "MILES",
+        YARDS = "YARDS"
+    }
+}

package/dist/types/shared/constants/DURATION.d.ts

@@ -0,0 +1,16 @@
+export declare class DURATION {
+}
+export declare namespace DURATION {
+    enum UNIT {
+        NANOSECONDS = "NANOSECONDS",
+        MICROSECONDS = "MICROSECONDS",
+        MILLISECONDS = "MILLISECONDS",
+        SECONDS = "SECONDS",
+        MINUTES = "MINUTES",
+        HOURS = "HOURS",
+        DAYS = "DAYS",
+        YEARS = "YEARS",
+        DECADES = "DECADES",
+        CENTURIES = "CENTURIES"
+    }
+}

package/dist/types/shared/constants/NOT_NULL.d.ts

@@ -0,0 +1 @@
+export declare const NOT_NULL: unique symbol;

package/dist/types/shared/constants/index.d.ts

@@ -0,0 +1,6 @@
+export * from './COORDINATE';
+export * from './CRUD';
+export * from './DATE';
+export * from './DISTANCE';
+export * from './DURATION';
+export * from './NOT_NULL';

package/dist/types/shared/index.d.ts

@@ -0,0 +1,7 @@
+export * from './constants';
+export * from './interfaces';
+export * from './managers';
+export * from './scripts';
+export * from './services';
+export * from './types';
+export * from './utils';

package/dist/types/shared/interfaces/Coordinate.d.ts

@@ -0,0 +1,8 @@
+export interface Coordinate {
+    latitude: number;
+    longitude: number;
+}
+export interface CoordinateM {
+    lat: number;
+    lon: number;
+}

package/dist/types/shared/interfaces/Point2.d.ts

@@ -0,0 +1,4 @@
+export interface Point2 {
+    x: number;
+    y: number;
+}

package/dist/types/shared/interfaces/Point3.d.ts

@@ -0,0 +1,4 @@
+import { Point2 } from "./Point2";
+export interface Point3 extends Point2 {
+    z: number;
+}

package/dist/types/shared/interfaces/StorageProvider.d.ts

@@ -0,0 +1,7 @@
+export interface StorageProvider {
+    key?: () => string;
+    set: (key: string, value: string) => Promise<void> | void;
+    get: (key: string) => Promise<string | null> | (string | null);
+    remove: (key: string) => Promise<void> | void;
+    clear?: () => Promise<void> | void;
+}

package/dist/types/shared/interfaces/index.d.ts

@@ -0,0 +1,4 @@
+export * from './Coordinate';
+export * from './Point2';
+export * from './Point3';
+export * from './StorageProvider';

package/dist/types/shared/managers/SessionManager.d.ts

@@ -0,0 +1,15 @@
+import { AxiosInstance } from "axios";
+import { StorageProvider } from "../interfaces/StorageProvider";
+import EventEmitter from 'eventemitter3';
+import { SessionManagerEvent, SessionManagerOptions } from "./SessionManager.type";
+export declare class SessionManager extends EventEmitter<SessionManagerEvent> {
+    private static readonly DEFAULT_AUTHORIZATION_STORAGE_KEY;
+    protected api: AxiosInstance;
+    protected storageProvider: StorageProvider;
+    constructor(options: SessionManagerOptions);
+    private get key();
+    hasAuthorization(): Promise<boolean>;
+    getAuthorization(): Promise<string | null>;
+    setAuthorization(authorization?: string | null): Promise<string | null>;
+    removeAuthorization(): Promise<void>;
+}

package/dist/types/shared/managers/SessionManager.type.d.ts

@@ -0,0 +1,9 @@
+import { AxiosInstance } from "axios";
+import { StorageProvider } from "../interfaces/StorageProvider";
+export interface SessionManagerOptions {
+    api: AxiosInstance;
+    storageProvider: StorageProvider;
+}
+export type SessionManagerEvent = {
+    AUTHORIZATION_CHANGED: (authorization: string | null) => void;
+};

package/dist/types/shared/managers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './SessionManager';
+export * from './SessionManager.type';

package/dist/types/shared/scripts/base64Polyfill.d.ts

@@ -0,0 +1 @@
+export declare const base64Polyfill: () => void;

package/dist/types/shared/scripts/index.d.ts

@@ -0,0 +1 @@
+export * from './base64Polyfill';

package/dist/types/shared/services/index.d.ts

@@ -0,0 +1 @@
+export * from './time';

package/dist/types/shared/services/time/TimeService.d.ts

@@ -0,0 +1,31 @@
+import EventEmitter from 'eventemitter3';
+import type { TimeServiceClientTimeProvider, TimeServiceEvent, TimeServiceNtpResult, TimeServiceOffset, TimeServiceOptions, TimeServiceServerTimeProvider, TimeServiceTimeStamp } from "./TimeService.type";
+export declare class TimeService extends EventEmitter<TimeServiceEvent> {
+    private syncHandler?;
+    private offset?;
+    private syncedAt?;
+    protected syncInterval?: number | null;
+    protected clientTimeProvider?: TimeServiceClientTimeProvider;
+    protected serverTimeProvider?: TimeServiceServerTimeProvider;
+    static calculateNTPResultOffset(ntpResult: TimeServiceNtpResult): TimeServiceOffset;
+    constructor(options?: TimeServiceOptions);
+    getOffset(defaultValue: TimeServiceOffset): TimeServiceOffset;
+    getOffset(): TimeServiceOffset | undefined;
+    setOffset(offset: TimeServiceOffset): TimeServiceOffset;
+    setOffset(offset: TimeServiceOffset | undefined): TimeServiceOffset;
+    getSyncedAt(): TimeServiceTimeStamp | undefined;
+    private setSyncedAt;
+    getSyncInterval(): number | null | undefined;
+    setSyncInterval(interval: TimeServiceOptions['syncInterval']): void;
+    getClientTimeProvider(): TimeServiceClientTimeProvider | undefined;
+    setClientTimeProvider(provider: TimeServiceClientTimeProvider | null | undefined): void;
+    getClientTime(): number | undefined;
+    getServerTimeProvider(): TimeServiceServerTimeProvider | undefined;
+    setServerTimeProvider(provider: TimeServiceServerTimeProvider | null | undefined): void;
+    getServerTime(): number | undefined;
+    getTime(): number;
+    private fetchServerNTPResult;
+    sync(): Promise<TimeServiceOffset | null>;
+    startSync(): void;
+    stopSync(): void;
+}