Class AbstractNode<TParams, TEventData>`Abstract`

Type Parameters

TParams extends NodeModuleParams = NodeModuleParams
TEventData extends NodeModuleEventData = NodeModuleEventData

Hierarchy

AbstractModule<TParams, TEventData>
- AbstractNode
  - MemoryNode

Implements

NodeModule<TParams, TEventData>
Module<TParams, TEventData>

Constructors

constructor

new AbstractNode<TParams, TEventData>(params): AbstractNode<TParams, TEventData>
Type Parameters
- TParams extends NodeModuleParams<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: string;
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<Omit<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: "network.xyo.node.config";
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<{
      archivist?: string;
      schema: "network.xyo.node.config";
  } & Omit<undefined, "schema">, "schema">, "schema"> & {
      schema: string;
  }, "schema">, undefined> = NodeModuleParams<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: string;
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<Omit<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: "network.xyo.node.config";
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<{
      archivist?: string;
      schema: "network.xyo.node.config";
  } & Omit<undefined, "schema">, "schema">, "schema"> & {
      schema: string;
  }, "schema">, undefined>
- TEventData extends NodeModuleEventData<TEventData> = NodeModuleEventData
Parameters
- params: TParams
Returns AbstractNode<TParams, TEventData>
Inherited from AbstractModule.constructor
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:22

Properties

`Protected` `Readonly` _baseModuleQueryAccountPaths

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

`Protected` `Readonly` _queryAccounts

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

`Protected` _started

_started: boolean

`Protected` `Readonly` account

account: AccountInstance

`Protected` commitArchivist

commitArchivist: (() => Promise<undefined | ArchivistModule<ArchivistParams<SchemaFields & PayloadFields & {
    archivist?: ArchivistModuleConfig;
    name?: string;
    paging?: Record<string, {
        size?: number;
    }>;
    schema: string;
    security?: {
        allowAnonymous?: boolean;
        allowed?: Record<string, (string | CosigningAddressSet)[]>;
        disallowed?: Record<string, string[]>;
    };
    storeQueries?: boolean;
} & Omit<Omit<SchemaFields & PayloadFields & {
    archivist?: ArchivistModuleConfig;
    name?: string;
    paging?: Record<string, {
        size?: number;
    }>;
    schema: "network.xyo.archivist.config";
    security?: {
        allowAnonymous?: boolean;
        allowed?: Record<string, (string | CosigningAddressSet)[]>;
        disallowed?: Record<string, string[]>;
    };
    storeQueries?: boolean;
} & Omit<{
    parents?: ArchivistParents;
    schema: "network.xyo.archivist.config";
    storeParentReads?: boolean;
} & Omit<undefined, "schema">, "schema">, "schema"> & {
    schema: string;
}, "schema">, undefined>, ArchivistModuleEventData>>)

Type declaration

- (): Promise<undefined | ArchivistModule<ArchivistParams<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: string;
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<Omit<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: "network.xyo.archivist.config";
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<{
      parents?: ArchivistParents;
      schema: "network.xyo.archivist.config";
      storeParentReads?: boolean;
  } & Omit<undefined, "schema">, "schema">, "schema"> & {
      schema: string;
  }, "schema">, undefined>, ArchivistModuleEventData>>
- Returns Promise<undefined | ArchivistModule<ArchivistParams<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: string;
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<Omit<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: "network.xyo.archivist.config";
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<{
      parents?: ArchivistParents;
      schema: "network.xyo.archivist.config";
      storeParentReads?: boolean;
  } & Omit<undefined, "schema">, "schema">, "schema"> & {
      schema: string;
  }, "schema">, undefined>, ArchivistModuleEventData>>

`Readonly` downResolver

downResolver: CompositeModuleResolver

eventData

eventData: TEventData

`Private` `Readonly` isNode

isNode: any

`Protected` `Readonly` moduleConfigQueryValidator

moduleConfigQueryValidator: Queryable<SchemaFields & PayloadFields & BoundWitnessFields & {
    query: string;
    resultSet?: string;
    schema: "network.xyo.boundwitness";
}>

`Readonly` params

params: TParams

`Protected` `Readonly` privateResolver

privateResolver: CompositeModuleResolver

`Protected` readArchivist

readArchivist: (() => Promise<undefined | ArchivistModule<ArchivistParams<SchemaFields & PayloadFields & {
    archivist?: ArchivistModuleConfig;
    name?: string;
    paging?: Record<string, {
        size?: number;
    }>;
    schema: string;
    security?: {
        allowAnonymous?: boolean;
        allowed?: Record<string, (string | CosigningAddressSet)[]>;
        disallowed?: Record<string, string[]>;
    };
    storeQueries?: boolean;
} & Omit<Omit<SchemaFields & PayloadFields & {
    archivist?: ArchivistModuleConfig;
    name?: string;
    paging?: Record<string, {
        size?: number;
    }>;
    schema: "network.xyo.archivist.config";
    security?: {
        allowAnonymous?: boolean;
        allowed?: Record<string, (string | CosigningAddressSet)[]>;
        disallowed?: Record<string, string[]>;
    };
    storeQueries?: boolean;
} & Omit<{
    parents?: ArchivistParents;
    schema: "network.xyo.archivist.config";
    storeParentReads?: boolean;
} & Omit<undefined, "schema">, "schema">, "schema"> & {
    schema: string;
}, "schema">, undefined>, ArchivistModuleEventData>>)

Type declaration

- (): Promise<undefined | ArchivistModule<ArchivistParams<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: string;
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<Omit<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: "network.xyo.archivist.config";
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<{
      parents?: ArchivistParents;
      schema: "network.xyo.archivist.config";
      storeParentReads?: boolean;
  } & Omit<undefined, "schema">, "schema">, "schema"> & {
      schema: string;
  }, "schema">, undefined>, ArchivistModuleEventData>>
- Returns Promise<undefined | ArchivistModule<ArchivistParams<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: string;
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<Omit<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: "network.xyo.archivist.config";
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<{
      parents?: ArchivistParents;
      schema: "network.xyo.archivist.config";
      storeParentReads?: boolean;
  } & Omit<undefined, "schema">, "schema">, "schema"> & {
      schema: string;
  }, "schema">, undefined>, ArchivistModuleEventData>>

`Protected` `Readonly` supportedQueryValidator

supportedQueryValidator: Queryable<SchemaFields & PayloadFields & BoundWitnessFields & {
    query: string;
    resultSet?: string;
    schema: "network.xyo.boundwitness";
}>

`Readonly` upResolver

upResolver: CompositeModuleResolver

`Protected` writeArchivist

writeArchivist: (() => Promise<undefined | ArchivistModule<ArchivistParams<SchemaFields & PayloadFields & {
    archivist?: ArchivistModuleConfig;
    name?: string;
    paging?: Record<string, {
        size?: number;
    }>;
    schema: string;
    security?: {
        allowAnonymous?: boolean;
        allowed?: Record<string, (string | CosigningAddressSet)[]>;
        disallowed?: Record<string, string[]>;
    };
    storeQueries?: boolean;
} & Omit<Omit<SchemaFields & PayloadFields & {
    archivist?: ArchivistModuleConfig;
    name?: string;
    paging?: Record<string, {
        size?: number;
    }>;
    schema: "network.xyo.archivist.config";
    security?: {
        allowAnonymous?: boolean;
        allowed?: Record<string, (string | CosigningAddressSet)[]>;
        disallowed?: Record<string, string[]>;
    };
    storeQueries?: boolean;
} & Omit<{
    parents?: ArchivistParents;
    schema: "network.xyo.archivist.config";
    storeParentReads?: boolean;
} & Omit<undefined, "schema">, "schema">, "schema"> & {
    schema: string;
}, "schema">, undefined>, ArchivistModuleEventData>>)

Type declaration

- (): Promise<undefined | ArchivistModule<ArchivistParams<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: string;
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<Omit<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: "network.xyo.archivist.config";
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<{
      parents?: ArchivistParents;
      schema: "network.xyo.archivist.config";
      storeParentReads?: boolean;
  } & Omit<undefined, "schema">, "schema">, "schema"> & {
      schema: string;
  }, "schema">, undefined>, ArchivistModuleEventData>>
- Returns Promise<undefined | ArchivistModule<ArchivistParams<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: string;
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<Omit<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: "network.xyo.archivist.config";
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<{
      parents?: ArchivistParents;
      schema: "network.xyo.archivist.config";
      storeParentReads?: boolean;
  } & Omit<undefined, "schema">, "schema">, "schema"> & {
      schema: string;
  }, "schema">, undefined>, ArchivistModuleEventData>>

`Static` `Readonly` configSchema

configSchema: "network.xyo.node.config"

`Static` `Optional` defaultLogger

defaultLogger?: Logger

Accessors

`Protected` _queryAccountPaths

get _queryAccountPaths(): Record<"network.xyo.query.node.attach" | "network.xyo.query.node.attached" | "network.xyo.query.node.detach" | "network.xyo.query.node.registered", string>
Returns Record<"network.xyo.query.node.attach" | "network.xyo.query.node.attached" | "network.xyo.query.node.detach" | "network.xyo.query.node.registered", string>
Overrides AbstractModule._queryAccountPaths
- Defined in modules/packages/node/dist/types/AbstractNode.d.ts:11

address

get address(): string
Returns string
Implementation of NodeModule.address

Inherited from AbstractModule.address
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:23

allowAnonymous

get allowAnonymous(): boolean
Returns boolean
Inherited from AbstractModule.allowAnonymous
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:24

config

get config(): TParams["config"]
Returns TParams["config"]
Implementation of NodeModule.config

Inherited from AbstractModule.config
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:25

isModuleResolver

get isModuleResolver(): boolean
Returns boolean
- Defined in modules/packages/node/dist/types/AbstractNode.d.ts:9

`Protected` logger

get logger(): Logger | Console
Returns Logger | Console
Inherited from AbstractModule.logger
- Defined in protocol/packages/core/dist/types/lib/Base.d.ts:23

queries

get queries(): string[]
Returns string[]
Implementation of NodeModule.queries

Overrides AbstractModule.queries
- Defined in modules/packages/node/dist/types/AbstractNode.d.ts:10

queryAccountPaths

get queryAccountPaths(): Readonly<Record<string, undefined | string>>
Returns Readonly<Record<string, undefined | string>>
Inherited from AbstractModule.queryAccountPaths
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:27

queryAccounts

get queryAccounts(): Readonly<Record<string, undefined | AccountInstance>>
Returns Readonly<Record<string, undefined | AccountInstance>>
Inherited from AbstractModule.queryAccounts
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:28

Methods

`Abstract` attach

attach(nameOrAddress, external?): Promisable<undefined | string, never>
Parameters
- nameOrAddress: string
- Optional external: boolean
Returns Promisable<undefined | string, never>
Implementation of NodeModule.attach
- Defined in modules/packages/node/dist/types/AbstractNode.d.ts:22

attached

attached(): Promise<string[]>
Returns Promise<string[]>
Implementation of NodeModule.attached
- Defined in modules/packages/node/dist/types/AbstractNode.d.ts:13

attachedModules

attachedModules(): Promise<Module<ModuleParams<SchemaFields & PayloadFields & {
    archivist?: ArchivistModuleConfig;
    name?: string;
    paging?: Record<string, {
        size?: number;
    }>;
    schema: string;
    security?: {
        allowAnonymous?: boolean;
        allowed?: Record<string, (string | CosigningAddressSet)[]>;
        disallowed?: Record<string, string[]>;
    };
    storeQueries?: boolean;
} & Omit<Omit<SchemaFields & PayloadFields & {
    archivist?: ArchivistModuleConfig;
    name?: string;
    paging?: Record<string, {
        size?: number;
    }>;
    schema: "network.xyo.module.config";
    security?: {
        allowAnonymous?: boolean;
        allowed?: Record<string, (string | CosigningAddressSet)[]>;
        disallowed?: Record<string, string[]>;
    };
    storeQueries?: boolean;
} & Omit<undefined, "schema">, "schema"> & {
    schema: string;
}, "schema">, undefined>, ModuleEventData>[]>
Returns Promise<Module<ModuleParams<SchemaFields & PayloadFields & {
    archivist?: ArchivistModuleConfig;
    name?: string;
    paging?: Record<string, {
        size?: number;
    }>;
    schema: string;
    security?: {
        allowAnonymous?: boolean;
        allowed?: Record<string, (string | CosigningAddressSet)[]>;
        disallowed?: Record<string, string[]>;
    };
    storeQueries?: boolean;
} & Omit<Omit<SchemaFields & PayloadFields & {
    archivist?: ArchivistModuleConfig;
    name?: string;
    paging?: Record<string, {
        size?: number;
    }>;
    schema: "network.xyo.module.config";
    security?: {
        allowAnonymous?: boolean;
        allowed?: Record<string, (string | CosigningAddressSet)[]>;
        disallowed?: Record<string, string[]>;
    };
    storeQueries?: boolean;
} & Omit<undefined, "schema">, "schema"> & {
    schema: string;
}, "schema">, undefined>, ModuleEventData>[]>
- Defined in modules/packages/node/dist/types/AbstractNode.d.ts:14

`Protected` bindHashes

bindHashes(hashes, schema, account?): PromiseEx<unknown, AccountInstance>
Parameters
- hashes: string[]
- schema: string[]
- Optional account: AccountInstance
Returns PromiseEx<unknown, AccountInstance>
Inherited from AbstractModule.bindHashes
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:39

`Protected` bindHashesInternal

bindHashesInternal(hashes, schema, account?): Promise<SchemaFields & PayloadFields & BoundWitnessFields & {
schema: "network.xyo.boundwitness";
}>
Parameters
- hashes: string[]
- schema: string[]
- Optional account: AccountInstance
Returns Promise<SchemaFields & PayloadFields & BoundWitnessFields & {
schema: "network.xyo.boundwitness";
}>
Inherited from AbstractModule.bindHashesInternal
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:40

`Protected` bindQuery

bindQuery<T>(query, payloads?, account?): PromiseEx<[SchemaFields & PayloadFields & BoundWitnessFields & {
    query: string;
    resultSet?: string;
    schema: "network.xyo.boundwitness";
}, (SchemaFields & PayloadFields & {
    schema: string;
})[]], AccountInstance>
Type Parameters
- T extends SchemaFields & PayloadFields & QueryFields & {
  schema: string;
  } | PayloadWrapper<SchemaFields & PayloadFields & QueryFields & {
  schema: string;
  }>
Parameters
- query: T
- Optional payloads: (SchemaFields & PayloadFields & {
  schema: string;
  })[]
- Optional account: AccountInstance
Returns PromiseEx<[SchemaFields & PayloadFields & BoundWitnessFields & {
    query: string;
    resultSet?: string;
    schema: "network.xyo.boundwitness";
}, (SchemaFields & PayloadFields & {
    schema: string;
})[]], AccountInstance>
Inherited from AbstractModule.bindQuery
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:41

`Protected` bindQueryInternal

bindQueryInternal<T>(query, payloads?, account?): Promise<[SchemaFields & PayloadFields & BoundWitnessFields & {
    query: string;
    resultSet?: string;
    schema: "network.xyo.boundwitness";
}, (SchemaFields & PayloadFields & {
    schema: string;
})[]]>
Type Parameters
- T extends SchemaFields & PayloadFields & QueryFields & {
  schema: string;
  } | PayloadWrapper<SchemaFields & PayloadFields & QueryFields & {
  schema: string;
  }>
Parameters
- query: T
- Optional payloads: (SchemaFields & PayloadFields & {
  schema: string;
  })[]
- Optional account: AccountInstance
Returns Promise<[SchemaFields & PayloadFields & BoundWitnessFields & {
    query: string;
    resultSet?: string;
    schema: "network.xyo.boundwitness";
}, (SchemaFields & PayloadFields & {
    schema: string;
})[]]>
Inherited from AbstractModule.bindQueryInternal
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:42

`Protected` bindQueryResult

bindQueryResult<T>(query, payloads, additionalWitnesses?): PromiseEx<ModuleQueryResult<SchemaFields & PayloadFields & {
schema: string;
}>, AccountInstance[]>
Type Parameters
- T extends SchemaFields & PayloadFields & QueryFields & {
  schema: string;
  } | PayloadWrapper<SchemaFields & PayloadFields & QueryFields & {
  schema: string;
  }>
Parameters
- query: T
- payloads: (SchemaFields & PayloadFields & {
  schema: string;
  })[]
- Optional additionalWitnesses: AccountInstance[]
Returns PromiseEx<ModuleQueryResult<SchemaFields & PayloadFields & {
schema: string;
}>, AccountInstance[]>
Inherited from AbstractModule.bindQueryResult
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:43

clearListeners

clearListeners(eventNames): void
Parameters
- eventNames: keyof TEventData | (keyof TEventData)[]
Returns void
Implementation of NodeModule.clearListeners

Inherited from AbstractModule.clearListeners
- Defined in modules/packages/module/packages/abstract/dist/types/BaseEmitter.d.ts:7

`Abstract` detach

detach(nameOrAddress): Promisable<undefined | string, never>
Parameters
- nameOrAddress: string
Returns Promisable<undefined | string, never>
Implementation of NodeModule.detach
- Defined in modules/packages/node/dist/types/AbstractNode.d.ts:23

discover

discover(): Promise<(SchemaFields & PayloadFields & {
schema: string;
})[]>
Returns Promise<(SchemaFields & PayloadFields & {
schema: string;
})[]>
Overrides AbstractModule.discover
- Defined in modules/packages/node/dist/types/AbstractNode.d.ts:15

emit

emit<TEventName, TEventArgs>(eventName, eventArgs): Promise<void>
Type Parameters
- TEventName extends string | number | symbol = keyof TEventData
- TEventArgs extends EventArgs = TEventData[TEventName]
Parameters
- eventName: TEventName
- eventArgs: TEventArgs
Returns Promise<void>
Implementation of NodeModule.emit

Inherited from AbstractModule.emit
- Defined in modules/packages/module/packages/abstract/dist/types/BaseEmitter.d.ts:8

emitSerial

emitSerial<TEventName, TEventArgs>(eventName, eventArgs): Promise<void>
Type Parameters
- TEventName extends string | number | symbol = keyof TEventData
- TEventArgs extends EventArgs = TEventData[TEventName]
Parameters
- eventName: TEventName
- eventArgs: TEventArgs
Returns Promise<void>
Implementation of NodeModule.emitSerial

Inherited from AbstractModule.emitSerial
- Defined in modules/packages/module/packages/abstract/dist/types/BaseEmitter.d.ts:9

`Protected` initializeQueryAccounts

initializeQueryAccounts(): void
Returns void
Inherited from AbstractModule.initializeQueryAccounts
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:77

listenerCount

listenerCount(eventNames): number
Parameters
- eventNames: keyof TEventData | (keyof TEventData)[]
Returns number
Implementation of NodeModule.listenerCount

Inherited from AbstractModule.listenerCount
- Defined in modules/packages/module/packages/abstract/dist/types/BaseEmitter.d.ts:10

`Protected` loadAccount

loadAccount(account?): AccountInstance
Parameters
- Optional account: AccountInstance
Returns AccountInstance
Inherited from AbstractModule.loadAccount
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:78

moduleAccountQuery

moduleAccountQuery(): Promisable<(SchemaFields & PayloadFields & {
    address: string;
    name?: string;
    schema: "network.xyo.address";
} | SchemaFields & PayloadFields & {
    address: string;
    previousHash?: string;
    schema: string;
})[], never>
Returns Promisable<(SchemaFields & PayloadFields & {
    address: string;
    name?: string;
    schema: "network.xyo.address";
} | SchemaFields & PayloadFields & {
    address: string;
    previousHash?: string;
    schema: string;
})[], never>
Inherited from AbstractModule.moduleAccountQuery
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:33

off

off<TEventName>(eventNames, listener): void
Type Parameters
- TEventName extends string | number | symbol
Parameters
- eventNames: TEventName | TEventName[]
- listener: EventListener<TEventData[TEventName]>
Returns void
Implementation of NodeModule.off

Inherited from AbstractModule.off
- Defined in modules/packages/module/packages/abstract/dist/types/BaseEmitter.d.ts:11

offAny

offAny(listener): void
Parameters
- listener: EventAnyListener<EventArgs>
Returns void
Implementation of NodeModule.offAny

Inherited from AbstractModule.offAny
- Defined in modules/packages/module/packages/abstract/dist/types/BaseEmitter.d.ts:12

on

on<TEventName>(eventNames, listener): (() => void)
Type Parameters
- TEventName extends string | number | symbol
Parameters
- eventNames: TEventName | TEventName[]
- listener: EventListener<TEventData[TEventName]>
Returns (() => void)
- - (): void
  - Returns void
Implementation of NodeModule.on

Inherited from AbstractModule.on
- Defined in modules/packages/module/packages/abstract/dist/types/BaseEmitter.d.ts:13

onAny

onAny(listener): (() => void)
Parameters
- listener: EventAnyListener<EventArgs>
Returns (() => void)
- - (): void
  - Returns void
Implementation of NodeModule.onAny

Inherited from AbstractModule.onAny
- Defined in modules/packages/module/packages/abstract/dist/types/BaseEmitter.d.ts:14

once

once<TEventName>(eventName, listener): (() => void)
Type Parameters
- TEventName extends string | number | symbol
Parameters
- eventName: TEventName
- listener: EventListener<TEventData[TEventName]>
Returns (() => void)
- - (): void
  - Returns void
Implementation of NodeModule.once

Inherited from AbstractModule.once
- Defined in modules/packages/module/packages/abstract/dist/types/BaseEmitter.d.ts:15

query

query<T, TConfig>(query, payloads?, queryConfig?): Promise<ModuleQueryResult<SchemaFields & PayloadFields & {
schema: string;
}>>
Type Parameters
- T extends SchemaFields & PayloadFields & BoundWitnessFields & {
      query: string;
      resultSet?: string;
      schema: "network.xyo.boundwitness";
  } = SchemaFields & PayloadFields & BoundWitnessFields & {
      query: string;
      resultSet?: string;
      schema: "network.xyo.boundwitness";
  }
- TConfig extends SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: "network.xyo.module.config";
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<undefined, "schema"> = SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: "network.xyo.module.config";
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<undefined, "schema">
Parameters
- query: T
- Optional payloads: (SchemaFields & PayloadFields & {
  schema: string;
  })[]
- Optional queryConfig: TConfig
Returns Promise<ModuleQueryResult<SchemaFields & PayloadFields & {
schema: string;
}>>
Implementation of NodeModule.query

Inherited from AbstractModule.query
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:34

`Protected` queryHandler

queryHandler<T, TConfig>(query, payloads?, queryConfig?): Promise<ModuleQueryResult<SchemaFields & PayloadFields & {
schema: string;
}>>
Type Parameters
- T extends SchemaFields & PayloadFields & BoundWitnessFields & {
      query: string;
      resultSet?: string;
      schema: "network.xyo.boundwitness";
  } = SchemaFields & PayloadFields & BoundWitnessFields & {
      query: string;
      resultSet?: string;
      schema: "network.xyo.boundwitness";
  }
- TConfig extends SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: "network.xyo.module.config";
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<undefined, "schema"> = SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: "network.xyo.module.config";
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<undefined, "schema">
Parameters
- query: T
- Optional payloads: (SchemaFields & PayloadFields & {
  schema: string;
  })[]
- Optional queryConfig: TConfig
Returns Promise<ModuleQueryResult<SchemaFields & PayloadFields & {
schema: string;
}>>
Overrides AbstractModule.queryHandler
- Defined in modules/packages/node/dist/types/AbstractNode.d.ts:20

queryable

queryable<T, TConfig>(query, payloads?, queryConfig?): boolean
Type Parameters
- T extends SchemaFields & PayloadFields & BoundWitnessFields & {
      query: string;
      resultSet?: string;
      schema: "network.xyo.boundwitness";
  } = SchemaFields & PayloadFields & BoundWitnessFields & {
      query: string;
      resultSet?: string;
      schema: "network.xyo.boundwitness";
  }
- TConfig extends SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: "network.xyo.module.config";
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<undefined, "schema"> = SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: "network.xyo.module.config";
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<undefined, "schema">
Parameters
- query: T
- Optional payloads: (SchemaFields & PayloadFields & {
  schema: string;
  })[]
- Optional queryConfig: TConfig
Returns boolean
Implementation of NodeModule.queryable

Inherited from AbstractModule.queryable
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:35

register

register(_module): Promisable<AbstractNode<TParams, TEventData>, never>
Parameters
- _module: Module<ModuleParams<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: string;
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<Omit<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: "network.xyo.module.config";
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<undefined, "schema">, "schema"> & {
      schema: string;
  }, "schema">, undefined>, ModuleEventData>
Returns Promisable<AbstractNode<TParams, TEventData>, never>
- Defined in modules/packages/node/dist/types/AbstractNode.d.ts:16

registered

registered(): Promisable<string[], never>
Returns Promisable<string[], never>
Implementation of NodeModule.registered
- Defined in modules/packages/node/dist/types/AbstractNode.d.ts:17

registeredModules

registeredModules(): Promisable<Module<ModuleParams<SchemaFields & PayloadFields & {
    archivist?: ArchivistModuleConfig;
    name?: string;
    paging?: Record<string, {
        size?: number;
    }>;
    schema: string;
    security?: {
        allowAnonymous?: boolean;
        allowed?: Record<string, (string | CosigningAddressSet)[]>;
        disallowed?: Record<string, string[]>;
    };
    storeQueries?: boolean;
} & Omit<Omit<SchemaFields & PayloadFields & {
    archivist?: ArchivistModuleConfig;
    name?: string;
    paging?: Record<string, {
        size?: number;
    }>;
    schema: "network.xyo.module.config";
    security?: {
        allowAnonymous?: boolean;
        allowed?: Record<string, (string | CosigningAddressSet)[]>;
        disallowed?: Record<string, string[]>;
    };
    storeQueries?: boolean;
} & Omit<undefined, "schema">, "schema"> & {
    schema: string;
}, "schema">, undefined>, ModuleEventData>[], never>
Returns Promisable<Module<ModuleParams<SchemaFields & PayloadFields & {
    archivist?: ArchivistModuleConfig;
    name?: string;
    paging?: Record<string, {
        size?: number;
    }>;
    schema: string;
    security?: {
        allowAnonymous?: boolean;
        allowed?: Record<string, (string | CosigningAddressSet)[]>;
        disallowed?: Record<string, string[]>;
    };
    storeQueries?: boolean;
} & Omit<Omit<SchemaFields & PayloadFields & {
    archivist?: ArchivistModuleConfig;
    name?: string;
    paging?: Record<string, {
        size?: number;
    }>;
    schema: "network.xyo.module.config";
    security?: {
        allowAnonymous?: boolean;
        allowed?: Record<string, (string | CosigningAddressSet)[]>;
        disallowed?: Record<string, string[]>;
    };
    storeQueries?: boolean;
} & Omit<undefined, "schema">, "schema"> & {
    schema: string;
}, "schema">, undefined>, ModuleEventData>[], never>
- Defined in modules/packages/node/dist/types/AbstractNode.d.ts:18

`Protected` resolve

resolve<TModule>(filter?): Promise<TModule[]>
Type Parameters
- TModule extends ModuleFields<ModuleParams<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: string;
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<Omit<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: "network.xyo.module.config";
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<undefined, "schema">, "schema"> & {
      schema: string;
  }, "schema">, undefined>> & EventFunctions<ModuleEventData, TModule> = Module<ModuleParams<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: string;
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<Omit<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: "network.xyo.module.config";
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<undefined, "schema">, "schema"> & {
      schema: string;
  }, "schema">, undefined>, ModuleEventData>
Parameters
- Optional filter: ModuleFilter
Returns Promise<TModule[]>
Overrides AbstractModule.resolve
- Defined in modules/packages/node/dist/types/AbstractNode.d.ts:21

start

start(_timeout?): Promisable<void, never>
Parameters
- Optional _timeout: number
Returns Promisable<void, never>
Implementation of NodeModule.start

Inherited from AbstractModule.start
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:36

started

started(notStartedAction?): boolean
Parameters
- Optional notStartedAction: "error" | "throw" | "warn" | "log" | "none"
Returns boolean
Inherited from AbstractModule.started
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:37

`Protected` stop

stop(_timeout?): Promisable<AbstractNode<TParams, TEventData>, never>
Parameters
- Optional _timeout: number
Returns Promisable<AbstractNode<TParams, TEventData>, never>
Inherited from AbstractModule.stop
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:114

subscribe(_queryAccount?): void
Parameters
- Optional _queryAccount: AccountInstance
Returns void
Inherited from AbstractModule.subscribe
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:38

unregister

unregister(_module): Promisable<AbstractNode<TParams, TEventData>, never>
Parameters
- _module: Module<ModuleParams<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: string;
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<Omit<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: "network.xyo.module.config";
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<undefined, "schema">, "schema"> & {
      schema: string;
  }, "schema">, undefined>, ModuleEventData>
Returns Promisable<AbstractNode<TParams, TEventData>, never>
- Defined in modules/packages/node/dist/types/AbstractNode.d.ts:19

`Protected` validateConfig

validateConfig(config?, parents?): boolean
Parameters
- Optional config: unknown
- Optional parents: string[]
Returns boolean
Inherited from AbstractModule.validateConfig
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:115

`Static` create

create<TModule>(this, params?): Promise<TModule>
Type Parameters
- TModule extends ModuleFields<ModuleParams<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: string;
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<Omit<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: "network.xyo.module.config";
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<undefined, "schema">, "schema"> & {
      schema: string;
  }, "schema">, undefined>> & EventFunctions<ModuleEventData, TModule>
Parameters
- this: CreatableModule<TModule>
- Optional params: TModule["params"]
Returns Promise<TModule>
Inherited from AbstractModule.create
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:30

`Static` factory

factory<TModule>(this, params?): CreatableModuleFactory<TModule>
Type Parameters
- TModule extends ModuleFields<ModuleParams<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: string;
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<Omit<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: "network.xyo.module.config";
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<undefined, "schema">, "schema"> & {
      schema: string;
  }, "schema">, undefined>> & EventFunctions<ModuleEventData, TModule>
Parameters
- this: CreatableModule<TModule>
- Optional params: TModule["params"]
Returns CreatableModuleFactory<TModule>
Inherited from AbstractModule.factory
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:31

`Static` isNode

isNode(module): boolean
Parameters
- module: unknown
Returns boolean
- Defined in modules/packages/node/dist/types/AbstractNode.d.ts:12

Class AbstractNode<TParams, TEventData>Abstract

Type Parameters

TParams extends NodeModuleParams = NodeModuleParams

TEventData extends NodeModuleEventData = NodeModuleEventData

Hierarchy

Implements

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Type Parameters

TEventData extends NodeModuleEventData<TEventData> = NodeModuleEventData

Parameters

params: TParams

Returns AbstractNode<TParams, TEventData>

Properties

Protected Readonly _baseModuleQueryAccountPaths

Protected Readonly _queryAccounts

Protected _started

Protected Readonly account

Protected commitArchivist

Type declaration

Readonly downResolver

eventData

Private Readonly isNode

Protected Readonly moduleConfigQueryValidator

Readonly params

Protected Readonly privateResolver

Protected readArchivist

Type declaration

Protected Readonly supportedQueryValidator

Readonly upResolver

Protected writeArchivist

Type declaration

Static Readonly configSchema

Static Optional defaultLogger

Accessors

Protected _queryAccountPaths

Returns Record<"network.xyo.query.node.attach" | "network.xyo.query.node.attached" | "network.xyo.query.node.detach" | "network.xyo.query.node.registered", string>

address

Returns string

allowAnonymous

Returns boolean

config

Returns TParams["config"]

isModuleResolver

Returns boolean

Protected logger

Returns Logger | Console

queries

Returns string[]

queryAccountPaths

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

queryAccounts

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

Methods

Abstract attach

Parameters

nameOrAddress: string

Optional external: boolean

Returns Promisable<undefined | string, never>

attached

Returns Promise<string[]>

attachedModules

Protected bindHashes

Parameters

hashes: string[]

schema: string[]

Optional account: AccountInstance

Returns PromiseEx<unknown, AccountInstance>

Protected bindHashesInternal

Parameters

hashes: string[]

schema: string[]

Optional account: AccountInstance

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

Protected bindQuery

Class AbstractNode<TParams, TEventData>`Abstract`

`Protected` `Readonly` _baseModuleQueryAccountPaths

`Protected` `Readonly` _queryAccounts

`Protected` _started

`Protected` `Readonly` account

`Protected` commitArchivist

`Readonly` downResolver

`Private` `Readonly` isNode

`Protected` `Readonly` moduleConfigQueryValidator

`Readonly` params

`Protected` `Readonly` privateResolver

`Protected` readArchivist

`Protected` `Readonly` supportedQueryValidator

`Readonly` upResolver

`Protected` writeArchivist

`Static` `Readonly` configSchema

`Static` `Optional` defaultLogger

`Protected` _queryAccountPaths

`Protected` logger

`Abstract` attach

`Optional` external: boolean

`Protected` bindHashes

`Optional` account: AccountInstance

`Protected` bindHashesInternal

`Optional` account: AccountInstance

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

`Protected` bindQuery

T extends SchemaFields & PayloadFields & QueryFields & {
schema: string;
} | PayloadWrapper<SchemaFields & PayloadFields & QueryFields & {
schema: string;
}>

`Optional` payloads: (SchemaFields & PayloadFields & {
schema: string;
})[]

`Optional` account: AccountInstance

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

`Protected` bindQueryInternal

T extends SchemaFields & PayloadFields & QueryFields & {
schema: string;
} | PayloadWrapper<SchemaFields & PayloadFields & QueryFields & {
schema: string;
}>

`Optional` payloads: (SchemaFields & PayloadFields & {
schema: string;
})[]

`Optional` account: AccountInstance

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

`Protected` bindQueryResult

T extends SchemaFields & PayloadFields & QueryFields & {
schema: string;
} | PayloadWrapper<SchemaFields & PayloadFields & QueryFields & {
schema: string;
}>

payloads: (SchemaFields & PayloadFields & {
schema: string;
})[]

`Optional` additionalWitnesses: AccountInstance[]

Returns PromiseEx<ModuleQueryResult<SchemaFields & PayloadFields & {
schema: string;
}>, AccountInstance[]>

`Abstract` detach

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

`Protected` initializeQueryAccounts

`Protected` loadAccount

`Optional` account: AccountInstance

Returns Promisable<(SchemaFields & PayloadFields & {
address: string;
name?: string;
schema: "network.xyo.address";
} | SchemaFields & PayloadFields & {
address: string;
previousHash?: string;
schema: string;
})[], never>