@lossless.org/client 0.1.0

package/dist_ts/nosqldb/classes.db.d.ts

@@ -0,0 +1,98 @@
+import * as plugins from './plugins.js';
+import { SmartdataCollection } from './classes.collection.js';
+import { EasyStore } from './classes.easystore.js';
+import { SmartdataMongoAdministration } from './classes.mongoadministration.js';
+import { SmartdataSession } from './classes.session.js';
+import { collectionTopologyDbInspectionSymbol } from './classes.collectiontopology.js';
+import { type ISmartdataNamespaceInspectionOptions, type ISmartdataNamespaceInspection } from './classes.namespaceinspection.js';
+export { SmartdataSession } from './classes.session.js';
+export type { TSmartdataOrdinarySession } from './classes.session.js';
+/**
+ * interface - indicates the connection status of the db
+ */
+export type TConnectionStatus = 'initial' | 'disconnected' | 'connected' | 'failed';
+export interface ISmartdataReadinessOptions {
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+export interface ISmartdataInitOptions {
+    /** Bounds connection setup; cleanup is always joined before the call settles. */
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+export interface ISmartdataCloseOptions {
+    /** Total deadline for removal, including preceding session cleanup (1..120000 ms). */
+    timeoutMs?: number;
+    dropDatabase?: {
+        expectedDatabaseName: string;
+    };
+}
+export type TSmartdataReadinessFailureReason = 'not_initialized' | 'connecting' | 'connection_failed' | 'closing' | 'closed' | 'close_failed' | 'aborted' | 'timeout' | 'unavailable';
+export type TSmartdataReadinessResult = {
+    ready: true;
+    status: 'ready';
+    durationMs: number;
+} | {
+    ready: false;
+    status: 'unavailable';
+    reason: TSmartdataReadinessFailureReason;
+    durationMs: number;
+};
+export declare class SmartdataDb {
+    smartdataOptions: plugins.tsclass.database.IMongoDescriptor;
+    mongoDbClient: plugins.mongodb.MongoClient;
+    mongoDb: plugins.mongodb.Db;
+    status: TConnectionStatus;
+    statusConnectedDeferred: plugins.smartpromise.Deferred<void>;
+    smartdataCollectionMap: plugins.lik.ObjectMap<SmartdataCollection<any>>;
+    private lifecycleState;
+    private lifecycleEpoch;
+    private activeLifecycleOperation;
+    private pendingClient?;
+    constructor(smartdataOptions: plugins.tsclass.database.IMongoDescriptor);
+    createEasyStore<T = unknown>(nameIdArg: string): Promise<EasyStore<T>>;
+    /**
+     * connects to the database that was specified during instance creation
+     */
+    init(optionsArg?: ISmartdataInitOptions): Promise<void>;
+    /**
+     * closes the connection to the databse
+     */
+    close(optionsArg?: ISmartdataCloseOptions): Promise<void>;
+    /**
+     * Performs a bounded, read-only round trip to verify database readiness.
+     */
+    checkReadiness(optionsArg?: ISmartdataReadinessOptions): Promise<TSmartdataReadinessResult>;
+    /**
+     * Starts a raw MongoDB session. Use createSession() when every transaction
+     * operation goes through SmartData and stable persistence errors are needed.
+     */
+    startSession(): plugins.mongodb.ClientSession;
+    /**
+     * Creates a SmartData-owned session for model transactions.
+     */
+    createSession(): SmartdataSession;
+    /**
+     * Creates a narrowly scoped MongoDB administration facade bound to this
+     * SmartData lifecycle. Applications never need direct driver access.
+     */
+    createMongoAdministration(): SmartdataMongoAdministration;
+    /** Observe all namespaces, indexes and bounded counts without initializing models. */
+    inspectNamespace(optionsArg?: ISmartdataNamespaceInspectionOptions): Promise<ISmartdataNamespaceInspection>;
+    /** @internal Runs inspection or explicit model preparation against one connection generation. */
+    [collectionTopologyDbInspectionSymbol]<TResult>(operationArg: (mongoDbArg: plugins.mongodb.Db, assertCurrentArg: () => void) => Promise<TResult>): Promise<TResult>;
+    addCollection(SmartdataCollectionArg: SmartdataCollection<any>): void;
+    /**
+     * Gets a collection's name and returns a SmartdataCollection instance
+     * @param nameArg
+     * @returns DbTable
+     */
+    getSmartdataCollectionByName<T>(nameArg: string): Promise<SmartdataCollection<T>>;
+    private beginLifecycleOperation;
+    private assertLifecycleOperationCanBegin;
+    private resolveDatabaseToDrop;
+    private endLifecycleOperation;
+    private transitionLifecycle;
+    private getReadinessLifecycleReason;
+    private createReadinessFailure;
+}

package/dist_ts/nosqldb/classes.db.js

@@ -0,0 +1,434 @@
+import * as plugins from './plugins.js';
+import { SmartdataCollection } from './classes.collection.js';
+import { EasyStore } from './classes.easystore.js';
+import { SmartdataPersistenceError } from './classes.persistence.js';
+import { SmartdataMongoAdministration } from './classes.mongoadministration.js';
+import { createSmartdataSession, invalidateSmartdataSessions, SmartdataSession, unwrapSmartdataSessionInvalidationErrors, } from './classes.session.js';
+import { collectionTopologyDbInspectionSymbol } from './classes.collectiontopology.js';
+import { inspectSmartdataNamespace, } from './classes.namespaceinspection.js';
+export { SmartdataSession } from './classes.session.js';
+import { logger } from './logging.js';
+import { assertDataOptions, SmartdataOperationBudget } from './classes.operationbudget.js';
+const readinessDefaultTimeoutMs = 2_000;
+const readinessMaximumTimeoutMs = 30_000;
+const assertExactDataObject = (valueArg, expectedKeysArg, descriptionArg, allowEmptyArg = false) => {
+    if (valueArg === null ||
+        typeof valueArg !== 'object' ||
+        Array.isArray(valueArg) ||
+        Object.getPrototypeOf(valueArg) !== Object.prototype) {
+        throw new SmartdataPersistenceError('invalid_argument', `${descriptionArg} must be a plain object.`);
+    }
+    const keys = Reflect.ownKeys(valueArg);
+    if ((!allowEmptyArg && keys.length !== expectedKeysArg.length) ||
+        (allowEmptyArg && keys.length !== 0 && keys.length !== expectedKeysArg.length) ||
+        keys.some((keyArg) => typeof keyArg !== 'string' || !expectedKeysArg.includes(keyArg))) {
+        throw new SmartdataPersistenceError('invalid_argument', `${descriptionArg} has an invalid shape.`);
+    }
+    for (const key of keys) {
+        const descriptor = Object.getOwnPropertyDescriptor(valueArg, key);
+        if (!descriptor || !('value' in descriptor)) {
+            throw new SmartdataPersistenceError('invalid_argument', `${descriptionArg} must contain data properties only.`);
+        }
+    }
+    return valueArg;
+};
+export class SmartdataDb {
+    smartdataOptions;
+    mongoDbClient;
+    mongoDb;
+    status;
+    statusConnectedDeferred = plugins.smartpromise.defer();
+    smartdataCollectionMap = new plugins.lik.ObjectMap();
+    lifecycleState = 'initial';
+    lifecycleEpoch = 0;
+    activeLifecycleOperation = null;
+    pendingClient;
+    constructor(smartdataOptions) {
+        this.smartdataOptions = smartdataOptions;
+        this.status = 'initial';
+        void this.statusConnectedDeferred.promise.catch(() => { });
+    }
+    // easystore
+    async createEasyStore(nameIdArg) {
+        const easyStore = new EasyStore(nameIdArg, this);
+        return easyStore;
+    }
+    // basic connection stuff ----------------------------------------------
+    /**
+     * connects to the database that was specified during instance creation
+     */
+    async init(optionsArg = {}) {
+        this.assertLifecycleOperationCanBegin('init');
+        const options = assertDataOptions(optionsArg, ['timeoutMs', 'signal']);
+        const budget = Object.keys(options).length
+            ? new SmartdataOperationBudget(options.timeoutMs ?? 30_000, options.signal) : undefined;
+        try {
+            budget?.check();
+        }
+        catch (errorArg) {
+            budget?.close();
+            throw errorArg;
+        }
+        this.beginLifecycleOperation('init');
+        this.transitionLifecycle('connecting');
+        let candidateClient;
+        try {
+            try {
+                // Safely encode credentials to handle special characters
+                const encodedUser = this.smartdataOptions.mongoDbUser
+                    ? encodeURIComponent(this.smartdataOptions.mongoDbUser)
+                    : '';
+                const encodedPass = this.smartdataOptions.mongoDbPass
+                    ? encodeURIComponent(this.smartdataOptions.mongoDbPass)
+                    : '';
+                const finalConnectionUrl = this.smartdataOptions.mongoDbUrl
+                    .replace('<USERNAME>', encodedUser)
+                    .replace('<username>', encodedUser)
+                    .replace('<USER>', encodedUser)
+                    .replace('<user>', encodedUser)
+                    .replace('<PASSWORD>', encodedPass)
+                    .replace('<password>', encodedPass)
+                    .replace('<DBNAME>', this.smartdataOptions.mongoDbName || '')
+                    .replace('<dbname>', this.smartdataOptions.mongoDbName || '');
+                const descriptor = this.smartdataOptions;
+                const clientOptions = {
+                    maxPoolSize: descriptor.maxPoolSize ?? 100,
+                    maxIdleTimeMS: descriptor.maxIdleTimeMS ?? 300000,
+                    serverSelectionTimeoutMS: budget?.remainingMs() ?? descriptor.serverSelectionTimeoutMS ?? 30000,
+                    ...(budget ? { connectTimeoutMS: budget.remainingMs() } : {}),
+                    socketTimeoutMS: descriptor.socketTimeoutMS ?? 30000,
+                    retryWrites: true,
+                };
+                candidateClient = new plugins.mongodb.MongoClient(finalConnectionUrl, clientOptions);
+                this.pendingClient = candidateClient;
+                const connectingClient = candidateClient;
+                let cancellationCleanup;
+                const onAbort = () => {
+                    cancellationCleanup ??= connectingClient.close();
+                    // The connection and this cleanup are both joined below.
+                    void cancellationCleanup.catch(() => { });
+                };
+                budget?.signal.addEventListener('abort', onAbort, { once: true });
+                try {
+                    budget?.check();
+                    await connectingClient.connect();
+                    budget?.check();
+                }
+                finally {
+                    budget?.signal.removeEventListener('abort', onAbort);
+                    if (cancellationCleanup)
+                        await cancellationCleanup;
+                }
+                const candidateDb = candidateClient.db(this.smartdataOptions.mongoDbName);
+                for (const collection of this.smartdataCollectionMap.getArray()) {
+                    collection.resetForDatabaseReconnect();
+                }
+                budget?.check();
+                this.mongoDbClient = candidateClient;
+                this.mongoDb = candidateDb;
+                candidateClient = undefined;
+                this.pendingClient = undefined;
+                this.status = 'connected';
+                this.transitionLifecycle('connected');
+                this.statusConnectedDeferred.resolve();
+                logger.log('info', `Connected to database ${this.smartdataOptions.mongoDbName}`);
+            }
+            catch (error) {
+                let cleanupError;
+                if (candidateClient) {
+                    try {
+                        // A cancelled connect may establish resources after its first close.
+                        await candidateClient.close();
+                        this.pendingClient = undefined;
+                    }
+                    catch (errorArg) {
+                        cleanupError = errorArg;
+                    }
+                }
+                this.status = 'disconnected';
+                this.transitionLifecycle(this.pendingClient ? 'close_failed' : 'connection_failed');
+                logger.log('error', 'Failed to connect to the SmartData database.');
+                if (budget) {
+                    throw new SmartdataPersistenceError('unsupported_operation', this.pendingClient
+                        ? 'SmartData connection setup and cleanup failed; close must be retried.'
+                        : 'SmartData connection setup failed or was cancelled.');
+                }
+                if (cleanupError)
+                    throw new AggregateError([error, cleanupError], 'SmartData connection setup and cleanup failed; close must be retried.');
+                throw error;
+            }
+        }
+        finally {
+            this.endLifecycleOperation('init');
+            budget?.close();
+        }
+    }
+    /**
+     * closes the connection to the databse
+     */
+    async close(optionsArg = {}) {
+        this.assertLifecycleOperationCanBegin('close');
+        const databaseToDrop = this.resolveDatabaseToDrop(optionsArg);
+        const timeoutMs = Object.hasOwn(optionsArg, 'timeoutMs') ? optionsArg.timeoutMs : undefined;
+        const budget = timeoutMs === undefined ? undefined : new SmartdataOperationBudget(timeoutMs);
+        this.beginLifecycleOperation('close');
+        this.transitionLifecycle('closing');
+        this.status = 'disconnected';
+        const mongoDbClient = this.pendingClient ?? this.mongoDbClient;
+        try {
+            const closeErrors = [];
+            try {
+                await invalidateSmartdataSessions(this);
+            }
+            catch (errorArg) {
+                closeErrors.push(...(unwrapSmartdataSessionInvalidationErrors(errorArg) ?? [errorArg]));
+            }
+            if (databaseToDrop) {
+                try {
+                    const databaseDropped = await databaseToDrop.dropDatabase(budget?.operationOptions());
+                    if (!databaseDropped) {
+                        throw new SmartdataPersistenceError('unsupported_operation', 'MongoDB did not acknowledge the requested database removal.');
+                    }
+                }
+                catch (errorArg) {
+                    closeErrors.push(errorArg);
+                }
+            }
+            try {
+                await mongoDbClient?.close();
+                this.pendingClient = undefined;
+            }
+            catch (errorArg) {
+                closeErrors.push(errorArg);
+            }
+            if (closeErrors.length > 0) {
+                this.transitionLifecycle('close_failed');
+                if (budget)
+                    throw new SmartdataPersistenceError('unsupported_operation', 'SmartData database cleanup failed; close must be retried.');
+                if (closeErrors.length === 1) {
+                    throw closeErrors[0];
+                }
+                throw new AggregateError(closeErrors, 'Multiple SmartData database cleanup operations failed.');
+            }
+            this.transitionLifecycle('closed');
+            logger.log('info', `disconnected from database ${this.smartdataOptions.mongoDbName}`);
+        }
+        finally {
+            this.endLifecycleOperation('close');
+            budget?.close();
+        }
+    }
+    /**
+     * Performs a bounded, read-only round trip to verify database readiness.
+     */
+    async checkReadiness(optionsArg = {}) {
+        const startedAt = performance.now();
+        const timeoutMs = optionsArg.timeoutMs ?? readinessDefaultTimeoutMs;
+        if (!Number.isSafeInteger(timeoutMs) ||
+            timeoutMs <= 0 ||
+            timeoutMs > readinessMaximumTimeoutMs) {
+            throw new SmartdataPersistenceError('invalid_argument', `Readiness timeoutMs must be a positive safe integer no greater than ${readinessMaximumTimeoutMs}.`);
+        }
+        const lifecycleReason = this.getReadinessLifecycleReason();
+        if (lifecycleReason) {
+            return this.createReadinessFailure(lifecycleReason, startedAt);
+        }
+        const signal = optionsArg.signal;
+        if (signal?.aborted) {
+            return this.createReadinessFailure('aborted', startedAt);
+        }
+        const lifecycleEpoch = this.lifecycleEpoch;
+        const mongoDb = this.mongoDb;
+        const mongoDbClient = this.mongoDbClient;
+        let response;
+        try {
+            response = await mongoDb.command({ ping: 1 }, {
+                timeoutMS: timeoutMs,
+                signal,
+            });
+        }
+        catch (error) {
+            if (signal?.aborted) {
+                return this.createReadinessFailure('aborted', startedAt);
+            }
+            if (this.lifecycleEpoch !== lifecycleEpoch ||
+                this.mongoDb !== mongoDb ||
+                this.mongoDbClient !== mongoDbClient) {
+                return this.createReadinessFailure(this.getReadinessLifecycleReason() ?? 'unavailable', startedAt);
+            }
+            if (error instanceof plugins.mongodb.MongoOperationTimeoutError) {
+                return this.createReadinessFailure('timeout', startedAt);
+            }
+            return this.createReadinessFailure('unavailable', startedAt);
+        }
+        if (this.lifecycleEpoch !== lifecycleEpoch ||
+            this.mongoDb !== mongoDb ||
+            this.mongoDbClient !== mongoDbClient) {
+            return this.createReadinessFailure(this.getReadinessLifecycleReason() ?? 'unavailable', startedAt);
+        }
+        if (response.ok !== 1) {
+            return this.createReadinessFailure('unavailable', startedAt);
+        }
+        return {
+            ready: true,
+            status: 'ready',
+            durationMs: performance.now() - startedAt,
+        };
+    }
+    /**
+     * Starts a raw MongoDB session. Use createSession() when every transaction
+     * operation goes through SmartData and stable persistence errors are needed.
+     */
+    startSession() {
+        return this.mongoDbClient.startSession();
+    }
+    /**
+     * Creates a SmartData-owned session for model transactions.
+     */
+    createSession() {
+        return createSmartdataSession(this);
+    }
+    /**
+     * Creates a narrowly scoped MongoDB administration facade bound to this
+     * SmartData lifecycle. Applications never need direct driver access.
+     */
+    createMongoAdministration() {
+        return new SmartdataMongoAdministration(this);
+    }
+    /** Observe all namespaces, indexes and bounded counts without initializing models. */
+    async inspectNamespace(optionsArg) {
+        return inspectSmartdataNamespace(this, optionsArg);
+    }
+    /** @internal Runs inspection or explicit model preparation against one connection generation. */
+    async [collectionTopologyDbInspectionSymbol](operationArg) {
+        if (this.lifecycleState !== 'connected' ||
+            this.status !== 'connected' ||
+            !this.mongoDb ||
+            !this.mongoDbClient ||
+            this.mongoDb.client !== this.mongoDbClient) {
+            throw new SmartdataPersistenceError('unsupported_operation', 'Collection topology inspection requires a connected SmartdataDb.');
+        }
+        const lifecycleEpoch = this.lifecycleEpoch;
+        const mongoDb = this.mongoDb;
+        const mongoDbClient = this.mongoDbClient;
+        const connectionIsCurrent = () => this.lifecycleState === 'connected' &&
+            this.status === 'connected' &&
+            this.lifecycleEpoch === lifecycleEpoch &&
+            this.mongoDb === mongoDb &&
+            this.mongoDbClient === mongoDbClient &&
+            mongoDb.client === mongoDbClient;
+        let result;
+        try {
+            result = await operationArg(mongoDb, () => {
+                if (!connectionIsCurrent()) {
+                    throw new SmartdataPersistenceError('unsupported_operation', 'SmartData connection changed during operation.');
+                }
+            });
+        }
+        catch {
+            if (!connectionIsCurrent()) {
+                throw new SmartdataPersistenceError('unsupported_operation', 'SmartData connection changed during collection topology inspection.');
+            }
+            throw new SmartdataPersistenceError('unsupported_operation', 'Collection topology inspection failed.');
+        }
+        if (!connectionIsCurrent()) {
+            throw new SmartdataPersistenceError('unsupported_operation', 'SmartData connection changed during collection topology inspection.');
+        }
+        return result;
+    }
+    // handle table to class distribution
+    addCollection(SmartdataCollectionArg) {
+        this.smartdataCollectionMap.add(SmartdataCollectionArg);
+    }
+    /**
+     * Gets a collection's name and returns a SmartdataCollection instance
+     * @param nameArg
+     * @returns DbTable
+     */
+    async getSmartdataCollectionByName(nameArg) {
+        const resultCollection = await this.smartdataCollectionMap.find(async (dbTableArg) => {
+            return dbTableArg.collectionName === nameArg;
+        });
+        return resultCollection;
+    }
+    beginLifecycleOperation(operationArg) {
+        this.assertLifecycleOperationCanBegin(operationArg);
+        this.activeLifecycleOperation = operationArg;
+    }
+    assertLifecycleOperationCanBegin(operationArg) {
+        if (this.activeLifecycleOperation) {
+            throw new SmartdataPersistenceError('unsupported_operation', `Cannot start SmartData database ${operationArg} while ${this.activeLifecycleOperation} is still running.`);
+        }
+        if (operationArg === 'init' &&
+            (this.lifecycleState === 'connected' ||
+                this.lifecycleState === 'close_failed')) {
+            throw new SmartdataPersistenceError('unsupported_operation', `Cannot start SmartData database init while the existing client is ${this.lifecycleState}.`);
+        }
+    }
+    resolveDatabaseToDrop(optionsArg) {
+        const options = assertDataOptions(optionsArg, ['dropDatabase', 'timeoutMs']);
+        if (!Object.hasOwn(options, 'dropDatabase')) {
+            return undefined;
+        }
+        const dropDatabaseOptions = assertExactDataObject(options.dropDatabase, ['expectedDatabaseName'], 'SmartData dropDatabase options');
+        const expectedDatabaseName = dropDatabaseOptions.expectedDatabaseName;
+        if (typeof expectedDatabaseName !== 'string' ||
+            expectedDatabaseName.length === 0 ||
+            expectedDatabaseName.trim() !== expectedDatabaseName) {
+            throw new SmartdataPersistenceError('invalid_argument', 'SmartData expectedDatabaseName must be a non-empty string without surrounding whitespace.');
+        }
+        if (this.lifecycleState !== 'connected' ||
+            this.status !== 'connected' ||
+            !this.mongoDbClient ||
+            !this.mongoDb) {
+            throw new SmartdataPersistenceError('unsupported_operation', 'SmartData can remove a database only from a connected lifecycle.');
+        }
+        if (this.mongoDb.client !== this.mongoDbClient) {
+            throw new SmartdataPersistenceError('invalid_configuration', 'SmartData database and client bindings are inconsistent.');
+        }
+        const boundDatabaseName = this.mongoDb.databaseName;
+        if (expectedDatabaseName !== boundDatabaseName) {
+            throw new SmartdataPersistenceError('invalid_argument', 'SmartData expectedDatabaseName does not match the connected database.');
+        }
+        if (this.smartdataOptions.mongoDbName !== boundDatabaseName) {
+            throw new SmartdataPersistenceError('invalid_configuration', 'SmartData database descriptor no longer matches the connected database.');
+        }
+        return this.mongoDb;
+    }
+    endLifecycleOperation(operationArg) {
+        if (this.activeLifecycleOperation === operationArg) {
+            this.activeLifecycleOperation = null;
+        }
+    }
+    transitionLifecycle(stateArg) {
+        this.lifecycleState = stateArg;
+        this.lifecycleEpoch++;
+    }
+    getReadinessLifecycleReason() {
+        switch (this.lifecycleState) {
+            case 'initial':
+                return 'not_initialized';
+            case 'connecting':
+                return 'connecting';
+            case 'connection_failed':
+                return 'connection_failed';
+            case 'closing':
+                return 'closing';
+            case 'closed':
+                return 'closed';
+            case 'close_failed':
+                return 'close_failed';
+            case 'connected':
+                return undefined;
+        }
+    }
+    createReadinessFailure(reasonArg, startedAtArg) {
+        return {
+            ready: false,
+            status: 'unavailable',
+            reason: reasonArg,
+            durationMs: performance.now() - startedAtArg,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.db.js","sourceRoot":"","sources":["../../ts/nosqldb/classes.db.ts"],"names":[],"mappings":"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"}

package/dist_ts/nosqldb/classes.distributedcoordinator.d.ts

@@ -0,0 +1,52 @@
+import * as plugins from './plugins.js';
+import { SmartdataDb } from './classes.db.js';
+import { SmartDataDbDoc } from './classes.doc.js';
+import { SmartdataDbWatcher } from './classes.watcher.js';
+export declare class DistributedClass extends SmartDataDbDoc<DistributedClass, DistributedClass> {
+    id: string;
+    data: {
+        status: 'initializing' | 'bidding' | 'settled' | 'stopped';
+        biddingShortcode?: string;
+        biddingStartTime?: number;
+        lastUpdated: number;
+        elected: boolean;
+        /**
+         * used to store request
+         */
+        taskRequests: plugins.taskbuffer.distributedCoordination.IDistributedTaskRequest[];
+        /**
+         * only used by the leader to convey consultation results
+         */
+        taskRequestResults: plugins.taskbuffer.distributedCoordination.IDistributedTaskRequestResult[];
+    };
+}
+/**
+ * This file implements a distributed coordinator according to the @pushrocks/taskbuffer standard.
+ * you should not set up this yourself. Instead, there is a factory on the SmartdataDb class
+ * that will take care of setting this up.
+ */
+export declare class SmartdataDistributedCoordinator extends plugins.taskbuffer.distributedCoordination
+    .AbstractDistributedCoordinator {
+    readyPromise: Promise<any>;
+    db: SmartdataDb;
+    private asyncExecutionStack;
+    ownInstance: DistributedClass;
+    distributedWatcher: SmartdataDbWatcher<DistributedClass>;
+    constructor(dbArg: SmartdataDb);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    id: string;
+    private startHeartbeat;
+    sendHeartbeat(): Promise<void>;
+    private init;
+    getEligibleLeader(): Promise<DistributedClass | undefined>;
+    checkAndMaybeLead(): Promise<void>;
+    /**
+     * when it has been determined
+     * that this instance is leading
+     * the leading is implemented here
+     */
+    leadFunction(): Promise<void>;
+    fireDistributedTaskRequest(taskRequestArg: plugins.taskbuffer.distributedCoordination.IDistributedTaskRequest): Promise<plugins.taskbuffer.distributedCoordination.IDistributedTaskRequestResult>;
+    updateDistributedTaskRequest(infoBasisArg: plugins.taskbuffer.distributedCoordination.IDistributedTaskRequest): Promise<void>;
+}