Variable export=

Type Declaration

• activeMode: () => string

  Returns the mode start() actually ran in.

• answersAfterCommit: () => boolean

• changeRowsWritten: () => any

  Returns how many change-log rows this process has written.

• clusterStore: () => any

  Returns the open driver when it can hold atomic claims and shared secrets.

• commitBacklog: () => boolean

• commitThrough: (target: any) => Promise<any[]>

  Waits until every write up to a position is committed to the store.

• configChanged: (realmId: any) => void

• coordinate: () => any

• currentDriver: () => any

• databaseConnection: () => Promise<{ url: string; verifyTls: boolean }>

• databaseMetrics: (options: any) => any

  Collects the database metrics /admin/database draws.

  Answers with available: false and a reason when the mode has no database, no store is open, or the driver has no metrics.

• dataDir: () => any

• dematerializeEntry: (realmId: any, key: any) => boolean

• directoryBridgeStats: () => any

  The directory bridge's figures in a windowed worker (#349), or null.

• directoryChanged: (dn: any) => void

• directoryTouched: () => boolean

• enabled: () => boolean

• flush: () => any

• flushMinted: () => Promise<any>

  Flushes the minted rows and waits for the keystore's queued writes.

• globalDatabaseConnection: () => Promise<{ readUrl: any; url: any; verifyTls: boolean }>

• keysPending: () => boolean

  Tells whether the keystore has queued writes not yet in the store.

• latestChangeSeq: () => Promise<number>

  Returns the change log's latest sequence number.

• materializeEntry: (realmId: any, key: any, row: any) => boolean

• mintedChanged: () => boolean

• mintedStatus: () => {
      droppedUnknown: number;
      droppedUnreadable: number;
      failures: number;
      handles: { handle: any; scope: any; shape: any }[];
      lastError: string;
      lastWriteAt: any;
      mode: string;
      pending: number;
      persisting: boolean;
      restored: number;
      restoredAt: any;
      retentionMs: number;
      rowsDeleted: number;
      rowsWritten: number;
      sealed: boolean;
      setting: boolean;
      shared: number;
      stores: number;
      supported: boolean;
      unsupportedReason: string;
      writes: number;
  }

  Returns persistence_minted.status().

• mode: () => any

• MODES: string[]

• pendingWrites: () => boolean

  Tells whether anything this process changed is not yet committed.

• realmsChanged: () => void

• replicationStatus: () => {
      appliedSeq: number;
      byKind: {};
      coordinating: boolean;
      failures: number;
      highestSeq: number;
      holes: number;
      holesAbandoned: number;
      lastError: string;
      lastPullAt: any;
      note: string;
      nudges: number;
      otherProcesses: number;
      pollIntervalMs: number;
      pulls: number;
      retention: {
          declaredGoneAt: any;
          lastTrim: any;
          readerTtlS: number;
          reportedAt: string;
          reportError: string;
          retentionS: number;
          trimming: boolean;
      };
      rowsApplied: number;
      startedAt: any;
      supported: boolean;
  }

  Returns persistence_replication.status().

• resolveDatabaseUrl: () => Promise<string>

• restoreMinted: () => any

  Restores the minted rows from the store, the third startup step.

• routingDigest: (realmId: any, kind: any, value: any) => any

• setDirectory: (hooks: any) => void

• start: () => any

• status: () => {
      answersAfterCommit: boolean;
      cells: {
          cell: string;
          globalReplication: any;
          jurisdiction: string;
          routing: any;
      };
      commitBacklog: boolean;
      configuredMode: any;
      coordinates: boolean;
      database: | {
          database: string;
          encrypted: boolean;
          host: string;
          note?: undefined;
          passwordFrom: string;
          passwordProvider: string;
          passwordSecret: {
              configured: boolean;
              field: any;
              known: boolean;
              label: string;
              provider: string;
              providers: { id: string; label: string }[];
              secret: any;
              shared: boolean;
              where: {};
          };
          port: string;
          sslmode: string;
          tls: string;
          user: string;
          verifyCertificate: boolean;
      }
      | {
          database: any;
          encrypted: boolean;
          host: any;
          note: string;
          passwordFrom?: undefined;
          passwordProvider?: undefined;
          passwordSecret?: undefined;
          port: any;
          sslmode: string;
          tls: string;
          user: any;
          verifyCertificate: boolean;
      };
      dataDir: any;
      enabled: boolean;
      entriesTracked: number;
      eventLoop: {
          lastReport: any;
          sinceReport: { at: string; maxMs: number; meanMs: number; p99Ms: number };
          warnAboveMs: number;
      };
      failures: number;
      healthy: boolean;
      lastError: string;
      lastWriteAt: any;
      liveness: any;
      minted: {
          droppedUnknown: number;
          droppedUnreadable: number;
          failures: number;
          handles: { handle: any; scope: any; shape: any }[];
          lastError: string;
          lastWriteAt: any;
          mode: string;
          pending: number;
          persisting: boolean;
          restored: number;
          restoredAt: any;
          retentionMs: number;
          rowsDeleted: number;
          rowsWritten: number;
          sealed: boolean;
          setting: boolean;
          shared: number;
          stores: number;
          supported: boolean;
          unsupportedReason: string;
          writes: number;
      };
      mode: string;
      note: string;
      origin: { adopted: boolean; origin: any; why: any };
      pending: boolean;
      persistsAppconfig: any;
      persistsDirectory: boolean;
      persistsRealms: any;
      realmsTracked: number;
      replication: {
          appliedSeq: number;
          byKind: {};
          coordinating: boolean;
          failures: number;
          highestSeq: number;
          holes: number;
          holesAbandoned: number;
          lastError: string;
          lastPullAt: any;
          note: string;
          nudges: number;
          otherProcesses: number;
          pollIntervalMs: number;
          pulls: number;
          retention: {
              declaredGoneAt: any;
              lastTrim: any;
              readerTtlS: number;
              reportedAt: string;
              reportError: string;
              retentionS: number;
              trimming: boolean;
          };
          rowsApplied: number;
          startedAt: any;
          supported: boolean;
      };
      restored: { entries: number; overrides: number; realms: number };
      restoredAt: any;
      retryArmed: boolean;
      usedAssertions: {
          atomicAcrossProcesses: boolean;
          cap: number;
          kind: string;
          live: any;
          liveIsCurrent: boolean;
          persistent: boolean;
          store: string;
          why: string;
      };
      writeDelayMs: any;
      writes: number;
  }

• stop: () => Promise<void>

• syncNow: () => any

  Waits until everything committed before the call is applied here.

• verifiesDatabaseTls: () => boolean

• writeGeneration: () => { directory: number; minted: number; observed: number }

  Returns how far this process's writes have got, as a position.