Class ImageThumbnailDiviner

Hierarchy

  • IndexingDiviner
    • ImageThumbnailDiviner

Constructors

constructor

Properties

_account _baseModuleQueryAccountPaths _queryAccounts _startPromise _started backgroundDivine downResolver eventData moduleConfigQueryValidator params supportedQueryValidator upResolver allowRandomAccount configSchemas defaultLogger? enableLazyLoad labels privateConstructorKey targetSchema

Accessors

_queryAccountPaths account address allowAnonymous config ephemeralQueryAccountEnabled id logger payloadDivinerLimit pollFrequency queries queryAccountPaths queryAccounts timestamp configSchema

Methods

_getRootFunction _noOverride bindHashes bindHashesInternal bindQuery bindQueryInternal bindQueryResult busy clearListeners commitState describe describeHandler discover discoverHandler divine divineHandler emit emitSerial getArchivist getArchivistForStore getBoundWitnessDivinerForStore getIndexingDivinerStage getPayloadDivinerForStore initializeQueryAccounts listenerCount manifest manifestHandler moduleAddress moduleAddressHandler off offAny on onAny once previousHash query queryHandler queryable resolve resolveArchivingArchivists retrieveState start startHandler started stop stopHandler storeToArchivists subscribe subscribeHandler validateConfig _getRootFunction _noOverride create determineAccount factory

Constructors

constructor

  • new ImageThumbnailDiviner(privateConstructorKey, params, account): ImageThumbnailDiviner

  • Parameters

    • privateConstructorKey: string
    • params: BaseParamsFields & {
          account?: AccountInstance | "random";
          config: SchemaFields & object & Omit<{
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.diviner.indexing.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & ArchivingModuleConfig & SchemaFields & object & {
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.diviner.indexing.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & {
              schema: "network.xyo.diviner.indexing.config";
          } & {
              indexStore?: SearchableStorage;
              indexingDivinerStages?: IndexingDivinerStageConfig;
              payloadDivinerLimit?: number;
              pollFrequency?: number;
              schema: "network.xyo.diviner.indexing.config";
              stateStore?: SearchableStorage;
          }, "schema"> & {
              schema: string;
          };
          ephemeralQueryAccountEnabled?: boolean;
      }
    • account: AccountInstance

    Returns ImageThumbnailDiviner

Properties

Protected _account

_account: undefined | AccountInstance

Protected Readonly _baseModuleQueryAccountPaths

_baseModuleQueryAccountPaths: Record<"network.xyo.query.module.discover" | "network.xyo.query.module.address" | "network.xyo.query.module.subscribe" | "network.xyo.query.module.describe" | "network.xyo.query.module.manifest", string>

Protected Readonly _queryAccounts

_queryAccounts: Record<"network.xyo.query.module.discover" | "network.xyo.query.module.address" | "network.xyo.query.module.subscribe" | "network.xyo.query.module.describe" | "network.xyo.query.module.manifest", undefined | AccountInstance>

Protected _startPromise

_startPromise: undefined | Promisable<boolean>

Protected _started

_started: undefined | Promisable<boolean>

Protected backgroundDivine

backgroundDivine: (() => Promise<void>)

Works via batched iteration of the source archivist to populate the index.

Type declaration

    • (): Promise<void>

    • Works via batched iteration of the source archivist to populate the index.

      Returns Promise<void>

      A promise that resolves when the background process is complete

Returns

A promise that resolves when the background process is complete

Readonly downResolver

downResolver: Omit<CompositeModuleResolver, "resolve">

eventData

eventData: DivinerModuleEventData<DivinerModule<BaseParamsFields & {
    account?: AccountInstance | "random";
    config: SchemaFields & object & Omit<{
        archivist?: string;
        labels?: Labels;
        name?: string;
        paging?: Record<string, {
            size?: number;
        }>;
        retry?: RetryConfig;
        schema: "network.xyo.diviner.indexing.config";
        security?: {
            allowAnonymous?: boolean;
            allowed?: Record<string, (string | CosigningAddressSet)[]>;
            disallowed?: Record<string, string[]>;
        };
        sign?: boolean;
        storeQueries?: boolean;
        timestamp?: boolean;
    } & ArchivingModuleConfig & SchemaFields & object & {
        archivist?: string;
        labels?: Labels;
        name?: string;
        paging?: Record<string, {
            size?: number;
        }>;
        retry?: RetryConfig;
        schema: "network.xyo.diviner.indexing.config";
        security?: {
            allowAnonymous?: boolean;
            allowed?: Record<string, (string | CosigningAddressSet)[]>;
            disallowed?: Record<string, string[]>;
        };
        sign?: boolean;
        storeQueries?: boolean;
        timestamp?: boolean;
    } & {
        schema: "network.xyo.diviner.indexing.config";
    } & {
        indexStore?: SearchableStorage;
        indexingDivinerStages?: IndexingDivinerStageConfig;
        payloadDivinerLimit?: number;
        pollFrequency?: number;
        schema: "network.xyo.diviner.indexing.config";
        stateStore?: SearchableStorage;
    }, "schema"> & {
        schema: string;
    };
    ephemeralQueryAccountEnabled?: boolean;
}, {
    schema: string;
} & object, {
    schema: string;
} & object>, {
    schema: string;
} & object, {
    schema: string;
} & object>

Protected Readonly moduleConfigQueryValidator

moduleConfigQueryValidator: Queryable

Readonly params

params: BaseParamsFields & {
    account?: AccountInstance | "random";
    config: SchemaFields & object & Omit<{
        archivist?: string;
        labels?: Labels;
        name?: string;
        paging?: Record<string, {
            size?: number;
        }>;
        retry?: RetryConfig;
        schema: "network.xyo.diviner.indexing.config";
        security?: {
            allowAnonymous?: boolean;
            allowed?: Record<string, (string | CosigningAddressSet)[]>;
            disallowed?: Record<string, string[]>;
        };
        sign?: boolean;
        storeQueries?: boolean;
        timestamp?: boolean;
    } & ArchivingModuleConfig & SchemaFields & object & {
        archivist?: string;
        labels?: Labels;
        name?: string;
        paging?: Record<string, {
            size?: number;
        }>;
        retry?: RetryConfig;
        schema: "network.xyo.diviner.indexing.config";
        security?: {
            allowAnonymous?: boolean;
            allowed?: Record<string, (string | CosigningAddressSet)[]>;
            disallowed?: Record<string, string[]>;
        };
        sign?: boolean;
        storeQueries?: boolean;
        timestamp?: boolean;
    } & {
        schema: "network.xyo.diviner.indexing.config";
    } & {
        indexStore?: SearchableStorage;
        indexingDivinerStages?: IndexingDivinerStageConfig;
        payloadDivinerLimit?: number;
        pollFrequency?: number;
        schema: "network.xyo.diviner.indexing.config";
        stateStore?: SearchableStorage;
    }, "schema"> & {
        schema: string;
    };
    ephemeralQueryAccountEnabled?: boolean;
}

Type declaration

  • Optional account?: AccountInstance | "random"
  • config: SchemaFields & object & Omit<{
        archivist?: string;
        labels?: Labels;
        name?: string;
        paging?: Record<string, {
            size?: number;
        }>;
        retry?: RetryConfig;
        schema: "network.xyo.diviner.indexing.config";
        security?: {
            allowAnonymous?: boolean;
            allowed?: Record<string, (string | CosigningAddressSet)[]>;
            disallowed?: Record<string, string[]>;
        };
        sign?: boolean;
        storeQueries?: boolean;
        timestamp?: boolean;
    } & ArchivingModuleConfig & SchemaFields & object & {
        archivist?: string;
        labels?: Labels;
        name?: string;
        paging?: Record<string, {
            size?: number;
        }>;
        retry?: RetryConfig;
        schema: "network.xyo.diviner.indexing.config";
        security?: {
            allowAnonymous?: boolean;
            allowed?: Record<string, (string | CosigningAddressSet)[]>;
            disallowed?: Record<string, string[]>;
        };
        sign?: boolean;
        storeQueries?: boolean;
        timestamp?: boolean;
    } & {
        schema: "network.xyo.diviner.indexing.config";
    } & {
        indexStore?: SearchableStorage;
        indexingDivinerStages?: IndexingDivinerStageConfig;
        payloadDivinerLimit?: number;
        pollFrequency?: number;
        schema: "network.xyo.diviner.indexing.config";
        stateStore?: SearchableStorage;
    }, "schema"> & {
        schema: string;
    }
  • Optional ephemeralQueryAccountEnabled?: boolean

Protected Readonly supportedQueryValidator

supportedQueryValidator: Queryable

Readonly upResolver

upResolver: Omit<CompositeModuleResolver, "resolve>">

Static Readonly allowRandomAccount

allowRandomAccount: false = false

Static Readonly configSchemas

configSchemas: string[]

Static Optional defaultLogger

defaultLogger?: Logger

Static enableLazyLoad

enableLazyLoad: boolean

Static labels

labels: ImageThumbnailDivinerLabels

Protected Static privateConstructorKey

privateConstructorKey: string

Static targetSchema

targetSchema: string

Accessors

Protected _queryAccountPaths

  • get _queryAccountPaths(): Record<"network.xyo.query.diviner.divine", string>

  • Returns Record<"network.xyo.query.diviner.divine", string>

account

  • get account(): AccountInstance

  • Returns AccountInstance

address

  • get address(): string

  • Returns string

allowAnonymous

  • get allowAnonymous(): boolean

  • Returns boolean

config

  • get config(): TParams["config"]

  • Returns TParams["config"]

ephemeralQueryAccountEnabled

  • get ephemeralQueryAccountEnabled(): boolean

  • Returns boolean

id

  • get id(): string

  • Returns string

Protected logger

  • get logger(): undefined | Logger

  • Returns undefined | Logger

payloadDivinerLimit

  • get payloadDivinerLimit(): number

  • Returns number

pollFrequency

  • get pollFrequency(): number

  • Returns number

queries

  • get queries(): string[]

  • Returns string[]

queryAccountPaths

  • get queryAccountPaths(): Readonly<Record<string, undefined | string>>

  • Returns Readonly<Record<string, undefined | string>>

queryAccounts

  • get queryAccounts(): Readonly<Record<string, undefined | AccountInstance>>

  • Returns Readonly<Record<string, undefined | AccountInstance>>

timestamp

  • get timestamp(): boolean

  • Returns boolean

Static configSchema

  • get configSchema(): string

  • Returns string

Methods

_getRootFunction

  • _getRootFunction(funcName): any

  • Parameters

    • funcName: string

    Returns any

_noOverride

  • _noOverride(functionName): void

  • Parameters

    • functionName: string

    Returns void

Protected bindHashes

  • bindHashes(hashes, schema, account?): PromiseEx<unknown, AccountInstance>

  • Parameters

    • hashes: string[]
    • schema: string[]
    • Optional account: AccountInstance

    Returns PromiseEx<unknown, AccountInstance>

Protected bindHashesInternal

  • bindHashesInternal(hashes, schema, account?): Promise<SchemaFields & object & BoundWitnessFields & {
        schema: "network.xyo.boundwitness";
    }>

  • Parameters

    • hashes: string[]
    • schema: string[]
    • Optional account: AccountInstance

    Returns Promise<SchemaFields & object & BoundWitnessFields & {
        schema: "network.xyo.boundwitness";
    }>

Protected bindQuery

  • bindQuery<T>(query, payloads?, account?): PromiseEx<[SchemaFields & object & Omit<BoundWitnessFields & {
        query: string;
        resultSet?: string;
        schema: "network.xyo.boundwitness";
    }, "schema"> & {
        schema: "network.xyo.boundwitness";
    }, ({
        schema: string;
    } & object)[], ({
        schema: string;
    } & object)[]], AccountInstance>

  • Type Parameters

    • T extends SchemaFields & object & QueryFields & {
          schema: string;
      }

    Parameters

    • query: T
    • Optional payloads: ({
          schema: string;
      } & object)[]
    • Optional account: AccountInstance

    Returns PromiseEx<[SchemaFields & object & Omit<BoundWitnessFields & {
        query: string;
        resultSet?: string;
        schema: "network.xyo.boundwitness";
    }, "schema"> & {
        schema: "network.xyo.boundwitness";
    }, ({
        schema: string;
    } & object)[], ({
        schema: string;
    } & object)[]], AccountInstance>

Protected bindQueryInternal

  • bindQueryInternal<T>(query, payloads?, account?): Promise<[SchemaFields & object & Omit<BoundWitnessFields & {
        query: string;
        resultSet?: string;
        schema: "network.xyo.boundwitness";
    }, "schema"> & {
        schema: "network.xyo.boundwitness";
    }, ({
        schema: string;
    } & object)[], ({
        schema: string;
    } & object)[]]>

  • Type Parameters

    • T extends SchemaFields & object & QueryFields & {
          schema: string;
      }

    Parameters

    • query: T
    • Optional payloads: ({
          schema: string;
      } & object)[]
    • Optional account: AccountInstance

    Returns Promise<[SchemaFields & object & Omit<BoundWitnessFields & {
        query: string;
        resultSet?: string;
        schema: "network.xyo.boundwitness";
    }, "schema"> & {
        schema: "network.xyo.boundwitness";
    }, ({
        schema: string;
    } & object)[], ({
        schema: string;
    } & object)[]]>

Protected bindQueryResult

  • bindQueryResult<T>(query, payloads, additionalWitnesses?, errors?): Promise<ModuleQueryResult>

  • Type Parameters

    • T extends SchemaFields & object & QueryFields & {
          schema: string;
      }

    Parameters

    • query: WithMeta<T>
    • payloads: ({
          schema: string;
      } & object)[]
    • Optional additionalWitnesses: AccountInstance[]
    • Optional errors: (SchemaFields & object & {
          message?: string;
          name?: string;
          query?: string;
          schema: "network.xyo.error.module";
          sources?: string[];
      })[]

    Returns Promise<ModuleQueryResult>

busy

  • busy<R>(closure): Promise<R>

  • Type Parameters

    • R

    Parameters

    • closure: (() => Promise<R>)
        • (): Promise<R>

        • Returns Promise<R>

    Returns Promise<R>

clearListeners

  • clearListeners(eventNames): void

  • Parameters

    • eventNames: (keyof DivinerModuleEventData<DivinerModule<BaseParamsFields & { account?: AccountInstance | "random" | undefined; config: SchemaFields & object & Omit<{ readonly archivist?: string | undefined; ... 8 more ...; readonly timestamp?: boolean | undefined; } & ... 5 more ... & { ...; }, "schema"> & { ...; }; ephemeralQue...) | (keyof DivinerModuleEventData<DivinerModule<BaseParamsFields & { account?: AccountInstance | "random" | undefined; config: SchemaFields & object & Omit<{ readonly archivist?: string | undefined; ... 8 more ...; readonly timestamp?: boolean | undefined; } & ... 5 more ... & { ...; }, "schema"> & { ...; }; ephemeralQue...)[]

    Returns void

Protected commitState

  • commitState(nextState): Promise<void>

  • Commit the internal state of the Diviner process. This is similar to a transaction completion in a database and should only be called when results have been successfully persisted to the appropriate external stores.

    Parameters

    • nextState: ModuleState<IndexingDivinerState>

      The state to commit

    Returns Promise<void>

describe

  • describe(): Promise<SchemaFields & object & ModuleDescription & {
        schema: "network.xyo.module.description";
    }>

  • Returns Promise<SchemaFields & object & ModuleDescription & {
        schema: "network.xyo.module.description";
    }>

Protected describeHandler

  • describeHandler(): Promise<SchemaFields & object & ModuleDescription & {
        schema: "network.xyo.module.description";
    }>

  • Returns Promise<SchemaFields & object & ModuleDescription & {
        schema: "network.xyo.module.description";
    }>

discover

  • discover(): Promise<({
        schema: string;
    } & object)[]>

  • Returns Promise<({
        schema: string;
    } & object)[]>

Protected discoverHandler

  • discoverHandler(_maxDepth?): Promise<({
        schema: string;
    } & object)[]>

  • Parameters

    • Optional _maxDepth: number

    Returns Promise<({
        schema: string;
    } & object)[]>

divine

  • divine(payloads?, retryConfigIn?): Promise<({
        schema: string;
    } & object)[]>

  • Parameters

    • Optional payloads: ({
          schema: string;
      } & object)[]
    • Optional retryConfigIn: RetryConfigWithComplete<unknown>

    Returns Promise<({
        schema: string;
    } & object)[]>

    Function

    divine The main entry point for a diviner. Do not override this function. Implement/override divineHandler for custom functionality

Protected divineHandler

  • divineHandler(payloads?): Promise<({
        schema: string;
    } & object)[]>

  • Parameters

    • Optional payloads: ({
          schema: string;
      } & object)[]

    Returns Promise<({
        schema: string;
    } & object)[]>

emit

  • emit<TEventName, TEventArgs>(eventName, eventArgs): Promise<void>

  • Type Parameters

    • TEventName extends keyof DivinerModuleEventData<DivinerModule<BaseParamsFields & {
          account?: AccountInstance | "random";
          config: SchemaFields & object & Omit<{
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.diviner.indexing.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & ArchivingModuleConfig & SchemaFields & object & {
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.diviner.indexing.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & {
              schema: "network.xyo.diviner.indexing.config";
          } & {
              indexStore?: SearchableStorage;
              indexingDivinerStages?: IndexingDivinerStageConfig;
              payloadDivinerLimit?: number;
              pollFrequency?: number;
              schema: "network.xyo.diviner.indexing.config";
              stateStore?: SearchableStorage;
          }, "schema"> & {
              schema: string;
          };
          ephemeralQueryAccountEnabled?: boolean;
      }, {
          schema: string;
      } & object, {
          schema: string;
      } & object>, {
          schema: string;
      } & object, {
          schema: string;
      } & object> = keyof DivinerModuleEventData<DivinerModule<BaseParamsFields & {
          account?: AccountInstance | "random";
          config: SchemaFields & object & Omit<{
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.diviner.indexing.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & ArchivingModuleConfig & SchemaFields & object & {
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.diviner.indexing.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & {
              schema: "network.xyo.diviner.indexing.config";
          } & {
              indexStore?: SearchableStorage;
              indexingDivinerStages?: IndexingDivinerStageConfig;
              payloadDivinerLimit?: number;
              pollFrequency?: number;
              schema: "network.xyo.diviner.indexing.config";
              stateStore?: SearchableStorage;
          }, "schema"> & {
              schema: string;
          };
          ephemeralQueryAccountEnabled?: boolean;
      }, {
          schema: string;
      } & object, {
          schema: string;
      } & object>, {
          schema: string;
      } & object, {
          schema: string;
      } & object>

    • TEventArgs extends EventArgs = DivinerModuleEventData<DivinerModule<BaseParamsFields & {
          account?: AccountInstance | "random";
          config: SchemaFields & object & Omit<{
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.diviner.indexing.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & ArchivingModuleConfig & SchemaFields & object & {
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.diviner.indexing.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & {
              schema: "network.xyo.diviner.indexing.config";
          } & {
              indexStore?: SearchableStorage;
              indexingDivinerStages?: IndexingDivinerStageConfig;
              payloadDivinerLimit?: number;
              pollFrequency?: number;
              schema: "network.xyo.diviner.indexing.config";
              stateStore?: SearchableStorage;
          }, "schema"> & {
              schema: string;
          };
          ephemeralQueryAccountEnabled?: boolean;
      }, {
          schema: string;
      } & object, {
          schema: string;
      } & object>, {
          schema: string;
      } & object, {
          schema: string;
      } & object>[TEventName]

    Parameters

    Returns Promise<void>

emitSerial

  • emitSerial<TEventName, TEventArgs>(eventName, eventArgs): Promise<void>

  • Type Parameters

    • TEventName extends keyof DivinerModuleEventData<DivinerModule<BaseParamsFields & {
          account?: AccountInstance | "random";
          config: SchemaFields & object & Omit<{
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.diviner.indexing.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & ArchivingModuleConfig & SchemaFields & object & {
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.diviner.indexing.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & {
              schema: "network.xyo.diviner.indexing.config";
          } & {
              indexStore?: SearchableStorage;
              indexingDivinerStages?: IndexingDivinerStageConfig;
              payloadDivinerLimit?: number;
              pollFrequency?: number;
              schema: "network.xyo.diviner.indexing.config";
              stateStore?: SearchableStorage;
          }, "schema"> & {
              schema: string;
          };
          ephemeralQueryAccountEnabled?: boolean;
      }, {
          schema: string;
      } & object, {
          schema: string;
      } & object>, {
          schema: string;
      } & object, {
          schema: string;
      } & object> = keyof DivinerModuleEventData<DivinerModule<BaseParamsFields & {
          account?: AccountInstance | "random";
          config: SchemaFields & object & Omit<{
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.diviner.indexing.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & ArchivingModuleConfig & SchemaFields & object & {
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.diviner.indexing.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & {
              schema: "network.xyo.diviner.indexing.config";
          } & {
              indexStore?: SearchableStorage;
              indexingDivinerStages?: IndexingDivinerStageConfig;
              payloadDivinerLimit?: number;
              pollFrequency?: number;
              schema: "network.xyo.diviner.indexing.config";
              stateStore?: SearchableStorage;
          }, "schema"> & {
              schema: string;
          };
          ephemeralQueryAccountEnabled?: boolean;
      }, {
          schema: string;
      } & object, {
          schema: string;
      } & object>, {
          schema: string;
      } & object, {
          schema: string;
      } & object>

    • TEventArgs extends EventArgs = DivinerModuleEventData<DivinerModule<BaseParamsFields & {
          account?: AccountInstance | "random";
          config: SchemaFields & object & Omit<{
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.diviner.indexing.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & ArchivingModuleConfig & SchemaFields & object & {
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.diviner.indexing.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & {
              schema: "network.xyo.diviner.indexing.config";
          } & {
              indexStore?: SearchableStorage;
              indexingDivinerStages?: IndexingDivinerStageConfig;
              payloadDivinerLimit?: number;
              pollFrequency?: number;
              schema: "network.xyo.diviner.indexing.config";
              stateStore?: SearchableStorage;
          }, "schema"> & {
              schema: string;
          };
          ephemeralQueryAccountEnabled?: boolean;
      }, {
          schema: string;
      } & object, {
          schema: string;
      } & object>, {
          schema: string;
      } & object, {
          schema: string;
      } & object>[TEventName]

    Parameters

    Returns Promise<void>

Protected getArchivist

  • getArchivist(): Promise<undefined | ArchivistInstance<BaseParamsFields & {
        account?: AccountInstance | "random";
        config: SchemaFields & object & Omit<{
            archivist?: string;
            labels?: Labels;
            name?: string;
            paging?: Record<string, {
                size?: number;
            }>;
            retry?: RetryConfig;
            schema: "network.xyo.archivist.config";
            security?: {
                allowAnonymous?: boolean;
                allowed?: Record<string, (string | CosigningAddressSet)[]>;
                disallowed?: Record<string, string[]>;
            };
            sign?: boolean;
            storeQueries?: boolean;
            timestamp?: boolean;
        } & ArchivingModuleConfig & SchemaFields & object & {
            archivist?: string;
            labels?: Labels;
            name?: string;
            paging?: Record<string, {
                size?: number;
            }>;
            retry?: RetryConfig;
            schema: "network.xyo.archivist.config";
            security?: {
                allowAnonymous?: boolean;
                allowed?: Record<string, (string | CosigningAddressSet)[]>;
                disallowed?: Record<string, string[]>;
            };
            sign?: boolean;
            storeQueries?: boolean;
            timestamp?: boolean;
        } & {
            parents?: ArchivistParents;
            requireAllParents?: boolean;
            schema: "network.xyo.archivist.config";
            storeParentReads?: boolean;
        }, "schema"> & {
            schema: string;
        };
        ephemeralQueryAccountEnabled?: boolean;
    }, ArchivistModuleEventData>>

  • Returns Promise<undefined | ArchivistInstance<BaseParamsFields & {
        account?: AccountInstance | "random";
        config: SchemaFields & object & Omit<{
            archivist?: string;
            labels?: Labels;
            name?: string;
            paging?: Record<string, {
                size?: number;
            }>;
            retry?: RetryConfig;
            schema: "network.xyo.archivist.config";
            security?: {
                allowAnonymous?: boolean;
                allowed?: Record<string, (string | CosigningAddressSet)[]>;
                disallowed?: Record<string, string[]>;
            };
            sign?: boolean;
            storeQueries?: boolean;
            timestamp?: boolean;
        } & ArchivingModuleConfig & SchemaFields & object & {
            archivist?: string;
            labels?: Labels;
            name?: string;
            paging?: Record<string, {
                size?: number;
            }>;
            retry?: RetryConfig;
            schema: "network.xyo.archivist.config";
            security?: {
                allowAnonymous?: boolean;
                allowed?: Record<string, (string | CosigningAddressSet)[]>;
                disallowed?: Record<string, string[]>;
            };
            sign?: boolean;
            storeQueries?: boolean;
            timestamp?: boolean;
        } & {
            parents?: ArchivistParents;
            requireAllParents?: boolean;
            schema: "network.xyo.archivist.config";
            storeParentReads?: boolean;
        }, "schema"> & {
            schema: string;
        };
        ephemeralQueryAccountEnabled?: boolean;
    }, ArchivistModuleEventData>>

Protected getArchivistForStore

  • getArchivistForStore(store): Promise<ArchivistWrapper<ArchivistModule<BaseParamsFields & {
        account?: AccountInstance | "random";
        config: SchemaFields & object & Omit<{
            archivist?: string;
            labels?: Labels;
            name?: string;
            paging?: Record<string, {
                size?: number;
            }>;
            retry?: RetryConfig;
            schema: "network.xyo.archivist.config";
            security?: {
                allowAnonymous?: boolean;
                allowed?: Record<string, (string | CosigningAddressSet)[]>;
                disallowed?: Record<string, string[]>;
            };
            sign?: boolean;
            storeQueries?: boolean;
            timestamp?: boolean;
        } & ArchivingModuleConfig & SchemaFields & object & {
            archivist?: string;
            labels?: Labels;
            name?: string;
            paging?: Record<string, {
                size?: number;
            }>;
            retry?: RetryConfig;
            schema: "network.xyo.archivist.config";
            security?: {
                allowAnonymous?: boolean;
                allowed?: Record<string, (string | CosigningAddressSet)[]>;
                disallowed?: Record<string, string[]>;
            };
            sign?: boolean;
            storeQueries?: boolean;
            timestamp?: boolean;
        } & {
            parents?: ArchivistParents;
            requireAllParents?: boolean;
            schema: "network.xyo.archivist.config";
            storeParentReads?: boolean;
        }, "schema"> & {
            schema: string;
        };
        ephemeralQueryAccountEnabled?: boolean;
    }, ArchivistModuleEventData>>>

  • Retrieves the archivist for the specified store

    Parameters

    • store: ConfigStore

      The store to retrieve the archivist for

    Returns Promise<ArchivistWrapper<ArchivistModule<BaseParamsFields & {
        account?: AccountInstance | "random";
        config: SchemaFields & object & Omit<{
            archivist?: string;
            labels?: Labels;
            name?: string;
            paging?: Record<string, {
                size?: number;
            }>;
            retry?: RetryConfig;
            schema: "network.xyo.archivist.config";
            security?: {
                allowAnonymous?: boolean;
                allowed?: Record<string, (string | CosigningAddressSet)[]>;
                disallowed?: Record<string, string[]>;
            };
            sign?: boolean;
            storeQueries?: boolean;
            timestamp?: boolean;
        } & ArchivingModuleConfig & SchemaFields & object & {
            archivist?: string;
            labels?: Labels;
            name?: string;
            paging?: Record<string, {
                size?: number;
            }>;
            retry?: RetryConfig;
            schema: "network.xyo.archivist.config";
            security?: {
                allowAnonymous?: boolean;
                allowed?: Record<string, (string | CosigningAddressSet)[]>;
                disallowed?: Record<string, string[]>;
            };
            sign?: boolean;
            storeQueries?: boolean;
            timestamp?: boolean;
        } & {
            parents?: ArchivistParents;
            requireAllParents?: boolean;
            schema: "network.xyo.archivist.config";
            storeParentReads?: boolean;
        }, "schema"> & {
            schema: string;
        };
        ephemeralQueryAccountEnabled?: boolean;
    }, ArchivistModuleEventData>>>

    The archivist for the specified store

Protected getBoundWitnessDivinerForStore

  • getBoundWitnessDivinerForStore(store): Promise<DivinerWrapper<DivinerModule<BaseParamsFields & {
        account?: AccountInstance | "random";
        config: SchemaFields & object & Omit<{
            archivist?: string;
            labels?: Labels;
            name?: string;
            paging?: Record<string, {
                size?: number;
            }>;
            retry?: RetryConfig;
            schema: "network.xyo.diviner.config";
            security?: {
                allowAnonymous?: boolean;
                allowed?: Record<string, (string | CosigningAddressSet)[]>;
                disallowed?: Record<string, string[]>;
            };
            sign?: boolean;
            storeQueries?: boolean;
            timestamp?: boolean;
        } & ArchivingModuleConfig & SchemaFields & object & {
            archivist?: string;
            labels?: Labels;
            name?: string;
            paging?: Record<string, {
                size?: number;
            }>;
            retry?: RetryConfig;
            schema: "network.xyo.diviner.config";
            security?: {
                allowAnonymous?: boolean;
                allowed?: Record<string, (string | CosigningAddressSet)[]>;
                disallowed?: Record<string, string[]>;
            };
            sign?: boolean;
            storeQueries?: boolean;
            timestamp?: boolean;
        } & {
            schema: "network.xyo.diviner.config";
        }, "schema"> & {
            schema: string;
        };
        ephemeralQueryAccountEnabled?: boolean;
    }, {
        schema: string;
    } & object, {
        schema: string;
    } & object>>>

  • Retrieves the BoundWitness Diviner for the specified store

    Parameters

    • store: ConfigStore

      The store to retrieve the BoundWitness Diviner for

    Returns Promise<DivinerWrapper<DivinerModule<BaseParamsFields & {
        account?: AccountInstance | "random";
        config: SchemaFields & object & Omit<{
            archivist?: string;
            labels?: Labels;
            name?: string;
            paging?: Record<string, {
                size?: number;
            }>;
            retry?: RetryConfig;
            schema: "network.xyo.diviner.config";
            security?: {
                allowAnonymous?: boolean;
                allowed?: Record<string, (string | CosigningAddressSet)[]>;
                disallowed?: Record<string, string[]>;
            };
            sign?: boolean;
            storeQueries?: boolean;
            timestamp?: boolean;
        } & ArchivingModuleConfig & SchemaFields & object & {
            archivist?: string;
            labels?: Labels;
            name?: string;
            paging?: Record<string, {
                size?: number;
            }>;
            retry?: RetryConfig;
            schema: "network.xyo.diviner.config";
            security?: {
                allowAnonymous?: boolean;
                allowed?: Record<string, (string | CosigningAddressSet)[]>;
                disallowed?: Record<string, string[]>;
            };
            sign?: boolean;
            storeQueries?: boolean;
            timestamp?: boolean;
        } & {
            schema: "network.xyo.diviner.config";
        }, "schema"> & {
            schema: string;
        };
        ephemeralQueryAccountEnabled?: boolean;
    }, {
        schema: string;
    } & object, {
        schema: string;
    } & object>>>

    The BoundWitness Diviner for the specified store

Protected getIndexingDivinerStage

  • getIndexingDivinerStage(transform): Promise<DivinerInstance<BaseParamsFields & {
        account?: AccountInstance | "random";
        config: SchemaFields & object & Omit<{
            archivist?: string;
            labels?: Labels;
            name?: string;
            paging?: Record<string, {
                size?: number;
            }>;
            retry?: RetryConfig;
            schema: "network.xyo.diviner.config";
            security?: {
                allowAnonymous?: boolean;
                allowed?: Record<string, (string | CosigningAddressSet)[]>;
                disallowed?: Record<string, string[]>;
            };
            sign?: boolean;
            storeQueries?: boolean;
            timestamp?: boolean;
        } & ArchivingModuleConfig & SchemaFields & object & {
            archivist?: string;
            labels?: Labels;
            name?: string;
            paging?: Record<string, {
                size?: number;
            }>;
            retry?: RetryConfig;
            schema: "network.xyo.diviner.config";
            security?: {
                allowAnonymous?: boolean;
                allowed?: Record<string, (string | CosigningAddressSet)[]>;
                disallowed?: Record<string, string[]>;
            };
            sign?: boolean;
            storeQueries?: boolean;
            timestamp?: boolean;
        } & {
            schema: "network.xyo.diviner.config";
        }, "schema"> & {
            schema: string;
        };
        ephemeralQueryAccountEnabled?: boolean;
    }, {
        schema: string;
    } & object, {
        schema: string;
    } & object>>

  • Gets the Diviner for the supplied Indexing Diviner stage

    Parameters

    • transform: IndexingDivinerStage

      The Indexing Diviner stage

    Returns Promise<DivinerInstance<BaseParamsFields & {
        account?: AccountInstance | "random";
        config: SchemaFields & object & Omit<{
            archivist?: string;
            labels?: Labels;
            name?: string;
            paging?: Record<string, {
                size?: number;
            }>;
            retry?: RetryConfig;
            schema: "network.xyo.diviner.config";
            security?: {
                allowAnonymous?: boolean;
                allowed?: Record<string, (string | CosigningAddressSet)[]>;
                disallowed?: Record<string, string[]>;
            };
            sign?: boolean;
            storeQueries?: boolean;
            timestamp?: boolean;
        } & ArchivingModuleConfig & SchemaFields & object & {
            archivist?: string;
            labels?: Labels;
            name?: string;
            paging?: Record<string, {
                size?: number;
            }>;
            retry?: RetryConfig;
            schema: "network.xyo.diviner.config";
            security?: {
                allowAnonymous?: boolean;
                allowed?: Record<string, (string | CosigningAddressSet)[]>;
                disallowed?: Record<string, string[]>;
            };
            sign?: boolean;
            storeQueries?: boolean;
            timestamp?: boolean;
        } & {
            schema: "network.xyo.diviner.config";
        }, "schema"> & {
            schema: string;
        };
        ephemeralQueryAccountEnabled?: boolean;
    }, {
        schema: string;
    } & object, {
        schema: string;
    } & object>>

    The diviner corresponding to the Indexing Diviner stage

Protected getPayloadDivinerForStore

  • getPayloadDivinerForStore(store): Promise<DivinerWrapper<DivinerModule<BaseParamsFields & {
        account?: AccountInstance | "random";
        config: SchemaFields & object & Omit<{
            archivist?: string;
            labels?: Labels;
            name?: string;
            paging?: Record<string, {
                size?: number;
            }>;
            retry?: RetryConfig;
            schema: "network.xyo.diviner.config";
            security?: {
                allowAnonymous?: boolean;
                allowed?: Record<string, (string | CosigningAddressSet)[]>;
                disallowed?: Record<string, string[]>;
            };
            sign?: boolean;
            storeQueries?: boolean;
            timestamp?: boolean;
        } & ArchivingModuleConfig & SchemaFields & object & {
            archivist?: string;
            labels?: Labels;
            name?: string;
            paging?: Record<string, {
                size?: number;
            }>;
            retry?: RetryConfig;
            schema: "network.xyo.diviner.config";
            security?: {
                allowAnonymous?: boolean;
                allowed?: Record<string, (string | CosigningAddressSet)[]>;
                disallowed?: Record<string, string[]>;
            };
            sign?: boolean;
            storeQueries?: boolean;
            timestamp?: boolean;
        } & {
            schema: "network.xyo.diviner.config";
        }, "schema"> & {
            schema: string;
        };
        ephemeralQueryAccountEnabled?: boolean;
    }, {
        schema: string;
    } & object, {
        schema: string;
    } & object>>>

  • Retrieves the Payload Diviner for the specified store

    Parameters

    • store: ConfigStore

      The store to retrieve the Payload Diviner for

    Returns Promise<DivinerWrapper<DivinerModule<BaseParamsFields & {
        account?: AccountInstance | "random";
        config: SchemaFields & object & Omit<{
            archivist?: string;
            labels?: Labels;
            name?: string;
            paging?: Record<string, {
                size?: number;
            }>;
            retry?: RetryConfig;
            schema: "network.xyo.diviner.config";
            security?: {
                allowAnonymous?: boolean;
                allowed?: Record<string, (string | CosigningAddressSet)[]>;
                disallowed?: Record<string, string[]>;
            };
            sign?: boolean;
            storeQueries?: boolean;
            timestamp?: boolean;
        } & ArchivingModuleConfig & SchemaFields & object & {
            archivist?: string;
            labels?: Labels;
            name?: string;
            paging?: Record<string, {
                size?: number;
            }>;
            retry?: RetryConfig;
            schema: "network.xyo.diviner.config";
            security?: {
                allowAnonymous?: boolean;
                allowed?: Record<string, (string | CosigningAddressSet)[]>;
                disallowed?: Record<string, string[]>;
            };
            sign?: boolean;
            storeQueries?: boolean;
            timestamp?: boolean;
        } & {
            schema: "network.xyo.diviner.config";
        }, "schema"> & {
            schema: string;
        };
        ephemeralQueryAccountEnabled?: boolean;
    }, {
        schema: string;
    } & object, {
        schema: string;
    } & object>>>

    The Payload Diviner for the specified store

Protected initializeQueryAccounts

  • initializeQueryAccounts(): Promise<void>

  • Returns Promise<void>

listenerCount

  • listenerCount(eventNames): number

  • Parameters

    • eventNames: (keyof DivinerModuleEventData<DivinerModule<BaseParamsFields & { account?: AccountInstance | "random" | undefined; config: SchemaFields & object & Omit<{ readonly archivist?: string | undefined; ... 8 more ...; readonly timestamp?: boolean | undefined; } & ... 5 more ... & { ...; }, "schema"> & { ...; }; ephemeralQue...) | (keyof DivinerModuleEventData<DivinerModule<BaseParamsFields & { account?: AccountInstance | "random" | undefined; config: SchemaFields & object & Omit<{ readonly archivist?: string | undefined; ... 8 more ...; readonly timestamp?: boolean | undefined; } & ... 5 more ... & { ...; }, "schema"> & { ...; }; ephemeralQue...)[]

    Returns number

manifest

  • manifest(maxDepth?, ignoreAddresses?): Promise<SchemaFields & object & ModuleManifest & {
        schema: "network.xyo.module.manifest";
    } | SchemaFields & object & ModuleManifest & {
        schema: "network.xyo.node.manifest";
    }>

  • Parameters

    • Optional maxDepth: number
    • Optional ignoreAddresses: string[]

    Returns Promise<SchemaFields & object & ModuleManifest & {
        schema: "network.xyo.module.manifest";
    } | SchemaFields & object & ModuleManifest & {
        schema: "network.xyo.node.manifest";
    }>

Protected manifestHandler

  • manifestHandler(_depth?, _ignoreAddresses?): Promisable<SchemaFields & object & ModuleManifest & {
        schema: "network.xyo.module.manifest";
    } | SchemaFields & object & ModuleManifest & {
        schema: "network.xyo.node.manifest";
    }>

  • Parameters

    • Optional _depth: number
    • Optional _ignoreAddresses: string[]

    Returns Promisable<SchemaFields & object & ModuleManifest & {
        schema: "network.xyo.module.manifest";
    } | SchemaFields & object & ModuleManifest & {
        schema: "network.xyo.node.manifest";
    }>

moduleAddress

  • moduleAddress(): Promise<(SchemaFields & object & {
        address: string;
        previousHash?: string;
        schema: string;
    })[]>

  • Returns Promise<(SchemaFields & object & {
        address: string;
        previousHash?: string;
        schema: string;
    })[]>

Protected moduleAddressHandler

  • moduleAddressHandler(): Promisable<(SchemaFields & object & {
        address: string;
        previousHash?: string;
        schema: string;
    })[]>

  • Returns Promisable<(SchemaFields & object & {
        address: string;
        previousHash?: string;
        schema: string;
    })[]>

off

  • off<TEventName>(eventNames, listener): void

  • Type Parameters

    • TEventName extends keyof DivinerModuleEventData<DivinerModule<BaseParamsFields & {
          account?: AccountInstance | "random";
          config: SchemaFields & object & Omit<{
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.diviner.indexing.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & ArchivingModuleConfig & SchemaFields & object & {
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.diviner.indexing.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & {
              schema: "network.xyo.diviner.indexing.config";
          } & {
              indexStore?: SearchableStorage;
              indexingDivinerStages?: IndexingDivinerStageConfig;
              payloadDivinerLimit?: number;
              pollFrequency?: number;
              schema: "network.xyo.diviner.indexing.config";
              stateStore?: SearchableStorage;
          }, "schema"> & {
              schema: string;
          };
          ephemeralQueryAccountEnabled?: boolean;
      }, {
          schema: string;
      } & object, {
          schema: string;
      } & object>, {
          schema: string;
      } & object, {
          schema: string;
      } & object>

    Parameters

    • eventNames: TEventName | TEventName[]
    • listener: EventListener<DivinerModuleEventData<DivinerModule<BaseParamsFields & {
          account?: AccountInstance | "random";
          config: SchemaFields & object & Omit<{
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.diviner.indexing.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & ArchivingModuleConfig & SchemaFields & object & {
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.diviner.indexing.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & {
              schema: "network.xyo.diviner.indexing.config";
          } & {
              indexStore?: SearchableStorage;
              indexingDivinerStages?: IndexingDivinerStageConfig;
              payloadDivinerLimit?: number;
              pollFrequency?: number;
              schema: "network.xyo.diviner.indexing.config";
              stateStore?: SearchableStorage;
          }, "schema"> & {
              schema: string;
          };
          ephemeralQueryAccountEnabled?: boolean;
      }, {
          schema: string;
      } & object, {
          schema: string;
      } & object>, {
          schema: string;
      } & object, {
          schema: string;
      } & object>[TEventName]>

    Returns void

offAny

  • offAny(listener): void

  • Parameters

    • listener: EventAnyListener

    Returns void

on

  • on<TEventName>(eventNames, listener): (() => void)

  • Type Parameters

    • TEventName extends keyof DivinerModuleEventData<DivinerModule<BaseParamsFields & {
          account?: AccountInstance | "random";
          config: SchemaFields & object & Omit<{
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.diviner.indexing.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & ArchivingModuleConfig & SchemaFields & object & {
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.diviner.indexing.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & {
              schema: "network.xyo.diviner.indexing.config";
          } & {
              indexStore?: SearchableStorage;
              indexingDivinerStages?: IndexingDivinerStageConfig;
              payloadDivinerLimit?: number;
              pollFrequency?: number;
              schema: "network.xyo.diviner.indexing.config";
              stateStore?: SearchableStorage;
          }, "schema"> & {
              schema: string;
          };
          ephemeralQueryAccountEnabled?: boolean;
      }, {
          schema: string;
      } & object, {
          schema: string;
      } & object>, {
          schema: string;
      } & object, {
          schema: string;
      } & object>

    Parameters

    • eventNames: TEventName | TEventName[]
    • listener: EventListener<DivinerModuleEventData<DivinerModule<BaseParamsFields & {
          account?: AccountInstance | "random";
          config: SchemaFields & object & Omit<{
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.diviner.indexing.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & ArchivingModuleConfig & SchemaFields & object & {
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.diviner.indexing.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & {
              schema: "network.xyo.diviner.indexing.config";
          } & {
              indexStore?: SearchableStorage;
              indexingDivinerStages?: IndexingDivinerStageConfig;
              payloadDivinerLimit?: number;
              pollFrequency?: number;
              schema: "network.xyo.diviner.indexing.config";
              stateStore?: SearchableStorage;
          }, "schema"> & {
              schema: string;
          };
          ephemeralQueryAccountEnabled?: boolean;
      }, {
          schema: string;
      } & object, {
          schema: string;
      } & object>, {
          schema: string;
      } & object, {
          schema: string;
      } & object>[TEventName]>

    Returns (() => void)

      • (): void

      • Returns void

onAny

  • onAny(listener): (() => void)

  • Parameters

    • listener: EventAnyListener

    Returns (() => void)

      • (): void

      • Returns void

once

  • once<TEventName>(eventName, listener): (() => void)

  • Type Parameters

    • TEventName extends keyof DivinerModuleEventData<DivinerModule<BaseParamsFields & {
          account?: AccountInstance | "random";
          config: SchemaFields & object & Omit<{
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.diviner.indexing.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & ArchivingModuleConfig & SchemaFields & object & {
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.diviner.indexing.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & {
              schema: "network.xyo.diviner.indexing.config";
          } & {
              indexStore?: SearchableStorage;
              indexingDivinerStages?: IndexingDivinerStageConfig;
              payloadDivinerLimit?: number;
              pollFrequency?: number;
              schema: "network.xyo.diviner.indexing.config";
              stateStore?: SearchableStorage;
          }, "schema"> & {
              schema: string;
          };
          ephemeralQueryAccountEnabled?: boolean;
      }, {
          schema: string;
      } & object, {
          schema: string;
      } & object>, {
          schema: string;
      } & object, {
          schema: string;
      } & object>

    Parameters

    • eventName: TEventName
    • listener: EventListener<DivinerModuleEventData<DivinerModule<BaseParamsFields & {
          account?: AccountInstance | "random";
          config: SchemaFields & object & Omit<{
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.diviner.indexing.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & ArchivingModuleConfig & SchemaFields & object & {
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.diviner.indexing.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & {
              schema: "network.xyo.diviner.indexing.config";
          } & {
              indexStore?: SearchableStorage;
              indexingDivinerStages?: IndexingDivinerStageConfig;
              payloadDivinerLimit?: number;
              pollFrequency?: number;
              schema: "network.xyo.diviner.indexing.config";
              stateStore?: SearchableStorage;
          }, "schema"> & {
              schema: string;
          };
          ephemeralQueryAccountEnabled?: boolean;
      }, {
          schema: string;
      } & object, {
          schema: string;
      } & object>, {
          schema: string;
      } & object, {
          schema: string;
      } & object>[TEventName]>

    Returns (() => void)

      • (): void

      • Returns void

previousHash

  • previousHash(): Promisable<undefined | string>

  • Returns Promisable<undefined | string>

query

  • query<T, TConfig>(query, payloads?, queryConfig?): Promise<ModuleQueryResult>

  • Type Parameters

    • T extends SchemaFields & object & Omit<BoundWitnessFields & {
          query: string;
          resultSet?: string;
          schema: "network.xyo.boundwitness";
      }, "schema"> & {
          schema: "network.xyo.boundwitness";
      } = SchemaFields & object & Omit<BoundWitnessFields & {
          query: string;
          resultSet?: string;
          schema: "network.xyo.boundwitness";
      }, "schema"> & {
          schema: "network.xyo.boundwitness";
      }

    • TConfig extends SchemaFields & object & {
          archivist?: string;
          labels?: Labels;
          name?: string;
          paging?: Record<string, {
              size?: number;
          }>;
          retry?: RetryConfig;
          schema: "network.xyo.module.config";
          security?: {
              allowAnonymous?: boolean;
              allowed?: Record<string, (string | CosigningAddressSet)[]>;
              disallowed?: Record<string, string[]>;
          };
          sign?: boolean;
          storeQueries?: boolean;
          timestamp?: boolean;
      } & ArchivingModuleConfig = SchemaFields & object & {
          archivist?: string;
          labels?: Labels;
          name?: string;
          paging?: Record<string, {
              size?: number;
          }>;
          retry?: RetryConfig;
          schema: "network.xyo.module.config";
          security?: {
              allowAnonymous?: boolean;
              allowed?: Record<string, (string | CosigningAddressSet)[]>;
              disallowed?: Record<string, string[]>;
          };
          sign?: boolean;
          storeQueries?: boolean;
          timestamp?: boolean;
      } & ArchivingModuleConfig

    Parameters

    • query: T
    • Optional payloads: ({
          schema: string;
      } & object)[]
    • Optional queryConfig: TConfig

    Returns Promise<ModuleQueryResult>

Protected queryHandler

  • queryHandler<T, TConfig>(query, payloads?, queryConfig?): Promise<ModuleQueryHandlerResult>

  • Type Parameters

    • T extends SchemaFields & object & Omit<BoundWitnessFields & {
          query: string;
          resultSet?: string;
          schema: "network.xyo.boundwitness";
      }, "schema"> & {
          schema: "network.xyo.boundwitness";
      } = SchemaFields & object & Omit<BoundWitnessFields & {
          query: string;
          resultSet?: string;
          schema: "network.xyo.boundwitness";
      }, "schema"> & {
          schema: "network.xyo.boundwitness";
      }

    • TConfig extends SchemaFields & object & {
          archivist?: string;
          labels?: Labels;
          name?: string;
          paging?: Record<string, {
              size?: number;
          }>;
          retry?: RetryConfig;
          schema: "network.xyo.module.config";
          security?: {
              allowAnonymous?: boolean;
              allowed?: Record<string, (string | CosigningAddressSet)[]>;
              disallowed?: Record<string, string[]>;
          };
          sign?: boolean;
          storeQueries?: boolean;
          timestamp?: boolean;
      } & ArchivingModuleConfig = SchemaFields & object & {
          archivist?: string;
          labels?: Labels;
          name?: string;
          paging?: Record<string, {
              size?: number;
          }>;
          retry?: RetryConfig;
          schema: "network.xyo.module.config";
          security?: {
              allowAnonymous?: boolean;
              allowed?: Record<string, (string | CosigningAddressSet)[]>;
              disallowed?: Record<string, string[]>;
          };
          sign?: boolean;
          storeQueries?: boolean;
          timestamp?: boolean;
      } & ArchivingModuleConfig

    Parameters

    • query: T
    • Optional payloads: ({
          schema: string;
      } & object)[]
    • Optional queryConfig: TConfig

    Returns Promise<ModuleQueryHandlerResult>

    Function

    queryHandler Calls divine for a divine query. Override to support additional queries.

queryable

  • queryable<T, TConfig>(query, payloads?, queryConfig?): Promise<boolean>

  • Type Parameters

    • T extends SchemaFields & object & Omit<BoundWitnessFields & {
          query: string;
          resultSet?: string;
          schema: "network.xyo.boundwitness";
      }, "schema"> & {
          schema: "network.xyo.boundwitness";
      } = SchemaFields & object & Omit<BoundWitnessFields & {
          query: string;
          resultSet?: string;
          schema: "network.xyo.boundwitness";
      }, "schema"> & {
          schema: "network.xyo.boundwitness";
      }

    • TConfig extends SchemaFields & object & {
          archivist?: string;
          labels?: Labels;
          name?: string;
          paging?: Record<string, {
              size?: number;
          }>;
          retry?: RetryConfig;
          schema: "network.xyo.module.config";
          security?: {
              allowAnonymous?: boolean;
              allowed?: Record<string, (string | CosigningAddressSet)[]>;
              disallowed?: Record<string, string[]>;
          };
          sign?: boolean;
          storeQueries?: boolean;
          timestamp?: boolean;
      } & ArchivingModuleConfig = SchemaFields & object & {
          archivist?: string;
          labels?: Labels;
          name?: string;
          paging?: Record<string, {
              size?: number;
          }>;
          retry?: RetryConfig;
          schema: "network.xyo.module.config";
          security?: {
              allowAnonymous?: boolean;
              allowed?: Record<string, (string | CosigningAddressSet)[]>;
              disallowed?: Record<string, string[]>;
          };
          sign?: boolean;
          storeQueries?: boolean;
          timestamp?: boolean;
      } & ArchivingModuleConfig

    Parameters

    • query: T
    • Optional payloads: ({
          schema: string;
      } & object)[]
    • Optional queryConfig: TConfig

    Returns Promise<boolean>

resolve

  • resolve<T>(filter?, options?): Promise<T[]>

  • Type Parameters

    • T extends ModuleInstance<BaseParamsFields & {
          account?: AccountInstance | "random";
          config: SchemaFields & object & Omit<{
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.module.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & ArchivingModuleConfig & SchemaFields & object & {
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.module.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          }, "schema"> & {
              schema: string;
          };
          ephemeralQueryAccountEnabled?: boolean;
      }, ModuleEventData<object>> = ModuleInstance<BaseParamsFields & {
          account?: AccountInstance | "random";
          config: SchemaFields & object & Omit<{
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.module.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & ArchivingModuleConfig & SchemaFields & object & {
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.module.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          }, "schema"> & {
              schema: string;
          };
          ephemeralQueryAccountEnabled?: boolean;
      }, ModuleEventData<object>>

    Parameters

    • Optional filter: ModuleFilter
    • Optional options: ModuleFilterOptions<T>

    Returns Promise<T[]>

  • resolve<T>(nameOrAddress, options?): Promise<undefined | T>

  • Type Parameters

    • T extends ModuleInstance<BaseParamsFields & {
          account?: AccountInstance | "random";
          config: SchemaFields & object & Omit<{
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.module.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & ArchivingModuleConfig & SchemaFields & object & {
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.module.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          }, "schema"> & {
              schema: string;
          };
          ephemeralQueryAccountEnabled?: boolean;
      }, ModuleEventData<object>> = ModuleInstance<BaseParamsFields & {
          account?: AccountInstance | "random";
          config: SchemaFields & object & Omit<{
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.module.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & ArchivingModuleConfig & SchemaFields & object & {
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.module.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          }, "schema"> & {
              schema: string;
          };
          ephemeralQueryAccountEnabled?: boolean;
      }, ModuleEventData<object>>

    Parameters

    • nameOrAddress: string
    • Optional options: ModuleFilterOptions<T>

    Returns Promise<undefined | T>

Protected resolveArchivingArchivists

  • resolveArchivingArchivists(): Promise<ArchivistInstance<BaseParamsFields & {
        account?: AccountInstance | "random";
        config: SchemaFields & object & Omit<{
            archivist?: string;
            labels?: Labels;
            name?: string;
            paging?: Record<string, {
                size?: number;
            }>;
            retry?: RetryConfig;
            schema: "network.xyo.archivist.config";
            security?: {
                allowAnonymous?: boolean;
                allowed?: Record<string, (string | CosigningAddressSet)[]>;
                disallowed?: Record<string, string[]>;
            };
            sign?: boolean;
            storeQueries?: boolean;
            timestamp?: boolean;
        } & ArchivingModuleConfig & SchemaFields & object & {
            archivist?: string;
            labels?: Labels;
            name?: string;
            paging?: Record<string, {
                size?: number;
            }>;
            retry?: RetryConfig;
            schema: "network.xyo.archivist.config";
            security?: {
                allowAnonymous?: boolean;
                allowed?: Record<string, (string | CosigningAddressSet)[]>;
                disallowed?: Record<string, string[]>;
            };
            sign?: boolean;
            storeQueries?: boolean;
            timestamp?: boolean;
        } & {
            parents?: ArchivistParents;
            requireAllParents?: boolean;
            schema: "network.xyo.archivist.config";
            storeParentReads?: boolean;
        }, "schema"> & {
            schema: string;
        };
        ephemeralQueryAccountEnabled?: boolean;
    }, ArchivistModuleEventData>[]>

  • Returns Promise<ArchivistInstance<BaseParamsFields & {
        account?: AccountInstance | "random";
        config: SchemaFields & object & Omit<{
            archivist?: string;
            labels?: Labels;
            name?: string;
            paging?: Record<string, {
                size?: number;
            }>;
            retry?: RetryConfig;
            schema: "network.xyo.archivist.config";
            security?: {
                allowAnonymous?: boolean;
                allowed?: Record<string, (string | CosigningAddressSet)[]>;
                disallowed?: Record<string, string[]>;
            };
            sign?: boolean;
            storeQueries?: boolean;
            timestamp?: boolean;
        } & ArchivingModuleConfig & SchemaFields & object & {
            archivist?: string;
            labels?: Labels;
            name?: string;
            paging?: Record<string, {
                size?: number;
            }>;
            retry?: RetryConfig;
            schema: "network.xyo.archivist.config";
            security?: {
                allowAnonymous?: boolean;
                allowed?: Record<string, (string | CosigningAddressSet)[]>;
                disallowed?: Record<string, string[]>;
            };
            sign?: boolean;
            storeQueries?: boolean;
            timestamp?: boolean;
        } & {
            parents?: ArchivistParents;
            requireAllParents?: boolean;
            schema: "network.xyo.archivist.config";
            storeParentReads?: boolean;
        }, "schema"> & {
            schema: string;
        };
        ephemeralQueryAccountEnabled?: boolean;
    }, ArchivistModuleEventData>[]>

Protected retrieveState

  • retrieveState(): Promise<undefined | ModuleState<IndexingDivinerState>>

  • Retrieves the last state of the Diviner process. Used to recover state after preemptions, reboots, etc.

    Returns Promise<undefined | ModuleState<IndexingDivinerState>>

start

  • start(_timeout?): Promisable<boolean>

  • Parameters

    • Optional _timeout: number

    Returns Promisable<boolean>

Protected startHandler

  • startHandler(): Promise<boolean>

  • Returns Promise<boolean>

started

  • started(notStartedAction?, tryStart?): Promise<boolean>

  • Parameters

    • Optional notStartedAction: "error" | "throw" | "warn" | "log" | "none"
    • Optional tryStart: boolean

    Returns Promise<boolean>

stop

  • stop(_timeout?): Promise<boolean>

  • Parameters

    • Optional _timeout: number

    Returns Promise<boolean>

Protected stopHandler

  • stopHandler(_timeout?): Promise<boolean>

  • Parameters

    • Optional _timeout: number

    Returns Promise<boolean>

Protected storeToArchivists

  • storeToArchivists(payloads): Promise<({
        schema: string;
    } & object)[]>

  • Parameters

    • payloads: ({
          schema: string;
      } & object)[]

    Returns Promise<({
        schema: string;
    } & object)[]>

subscribe

  • subscribe(_queryAccount?): void

  • Parameters

    • Optional _queryAccount: AccountInstance

    Returns void

Protected subscribeHandler

  • subscribeHandler(): void

  • Returns void

Protected validateConfig

  • validateConfig(config?, parents?): boolean

  • Parameters

    • Optional config: unknown
    • Optional parents: string[]

    Returns boolean

Static _getRootFunction

  • _getRootFunction(funcName): any

  • Parameters

    • funcName: string

    Returns any

Static _noOverride

  • _noOverride(functionName): void

  • Parameters

    • functionName: string

    Returns void

Static create

  • create<TModule>(this, params?): Promise<TModule>

  • Type Parameters

    • TModule extends ModuleInstance<BaseParamsFields & {
          account?: AccountInstance | "random";
          config: SchemaFields & object & Omit<{
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.module.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & ArchivingModuleConfig & SchemaFields & object & {
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.module.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          }, "schema"> & {
              schema: string;
          };
          ephemeralQueryAccountEnabled?: boolean;
      }, ModuleEventData<object>>

    Parameters

    • this: CreatableModule<TModule>
    • Optional params: Omit<TModule["params"], "config"> & {
          config?: TModule["params"]["config"];
      }

    Returns Promise<TModule>

Static determineAccount

  • determineAccount(params): Promise<AccountInstance>

  • Parameters

    • params: {
          account?: AccountInstance | "random";
          accountPath?: string;
          wallet?: WalletInstance;
      }
      • Optional account?: AccountInstance | "random"
      • Optional accountPath?: string
      • Optional wallet?: WalletInstance

    Returns Promise<AccountInstance>

Static factory

  • factory<TModule>(this, params?): CreatableModuleFactory<TModule>

  • Type Parameters

    • TModule extends ModuleInstance<BaseParamsFields & {
          account?: AccountInstance | "random";
          config: SchemaFields & object & Omit<{
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.module.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & ArchivingModuleConfig & SchemaFields & object & {
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.module.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          }, "schema"> & {
              schema: string;
          };
          ephemeralQueryAccountEnabled?: boolean;
      }, ModuleEventData<object>>

    Parameters

    • this: CreatableModule<TModule>
    • Optional params: Omit<TModule["params"], "config"> & {
          config?: TModule["params"]["config"];
      }

    Returns CreatableModuleFactory<TModule>

Settings

Member Visibility

Theme

On This Page

Generated using TypeDoc