@xyo-network/module-abstract 2.111.2 → 3.0.0

package/dist/neutral/index.d.ts

@@ -1,6 +1,221 @@
-export * from './AbstractModule.ts';
-export * from './AbstractModuleInstance.ts';
-export * from './BaseEmitter.ts';
-export * from './Error.ts';
-export * from './QueryValidator/index.ts';
-//# sourceMappingURL=index.d.ts.map
+import * as _xyo_network_manifest_model from '@xyo-network/manifest-model';
+import { ModuleManifestPayload } from '@xyo-network/manifest-model';
+import * as _xyo_network_payload_model from '@xyo-network/payload-model';
+import { Payload, Schema, Query, WithMeta, ModuleError } from '@xyo-network/payload-model';
+import * as _xylabs_hex from '@xylabs/hex';
+import { Address, Hash } from '@xylabs/hex';
+import { Logger } from '@xylabs/logger';
+import { Promisable, PromiseEx } from '@xylabs/promise';
+import { AccountInstance } from '@xyo-network/account-model';
+import { ArchivistInstance } from '@xyo-network/archivist-model';
+import * as _xyo_network_boundwitness_model from '@xyo-network/boundwitness-model';
+import { QueryBoundWitness, BoundWitness } from '@xyo-network/boundwitness-model';
+import * as _xyo_network_module_model from '@xyo-network/module-model';
+import { AnyConfigSchema, ModuleConfig, Module, ModuleParams, ModuleEventData, Labels, ModuleDetailsError, ArchivingModuleConfig, ObjectResolverPriority, ModuleStatus, ModuleResolverInstance, AttachableModuleInstance, CreatableModule, CreatableModuleFactory, ModuleQueryResult, ModuleDescriptionPayload, AddressPreviousHashPayload, AddressPayload, ModuleQueryHandlerResult, ModuleNameResolver, ModuleInstance, ModuleFilterOptions, ModuleFilter, ModuleIdentifier, ObjectFilterOptions } from '@xyo-network/module-model';
+import { WalletInstance } from '@xyo-network/wallet-model';
+import { LRUCache } from 'lru-cache';
+import { BaseParams, Base, JsonValue } from '@xylabs/object';
+import { EventData, EventFunctions, EventListener, EventAnyListener } from '@xyo-network/module-events';
+import * as _xyo_network_module_resolver from '@xyo-network/module-resolver';
+import { CompositeModuleResolver } from '@xyo-network/module-resolver';
+import { NodeInstance } from '@xyo-network/node-model';
+import { PayloadBuilder } from '@xyo-network/payload-builder';
+
+declare class BaseEmitter<TParams extends BaseParams = BaseParams, TEventData extends EventData = EventData> extends Base<TParams> implements EventFunctions<TEventData> {
+    eventData: TEventData;
+    private events;
+    constructor(params: TParams);
+    clearListeners(eventNames: keyof TEventData | (keyof TEventData)[]): void;
+    emit<TEventName extends keyof TEventData = keyof TEventData, TEventArgs extends TEventData[TEventName] = TEventData[TEventName]>(eventName: TEventName, eventArgs: TEventArgs): Promise<void>;
+    emitSerial<TEventName extends keyof TEventData = keyof TEventData, TEventArgs extends TEventData[TEventName] = TEventData[TEventName]>(eventName: TEventName, eventArgs: TEventArgs): Promise<void>;
+    listenerCount(eventNames: keyof TEventData | (keyof TEventData)[]): number;
+    off<TEventName extends keyof TEventData>(eventNames: TEventName | TEventName[], listener: EventListener<TEventData[TEventName]>): void;
+    offAny(listener: EventAnyListener): void;
+    on<TEventName extends keyof TEventData>(eventNames: TEventName | TEventName[], listener: EventListener<TEventData[TEventName]>): () => void;
+    onAny(listener: EventAnyListener): () => void;
+    once<TEventName extends keyof TEventData>(eventName: TEventName, listener: EventListener<TEventData[TEventName]>): () => void;
+}
+
+type Queryable<T extends QueryBoundWitness = QueryBoundWitness> = (query: T, payloads?: Payload[]) => Promisable<boolean>;
+interface QueryValidator<T extends QueryBoundWitness = QueryBoundWitness> {
+    queryable: Queryable<T>;
+}
+
+type SortedPipedAddressesString = string;
+declare class ModuleConfigQueryValidator<TConfig extends AnyConfigSchema<ModuleConfig>> implements QueryValidator {
+    protected allowed: Record<Schema, SortedPipedAddressesString[]>;
+    protected disallowed: Record<Schema, SortedPipedAddressesString[]>;
+    protected readonly hasAllowedRules: boolean;
+    protected readonly hasDisallowedRules: boolean;
+    protected readonly hasRules: boolean;
+    constructor(config?: TConfig);
+    queryable: Queryable;
+    protected queryAllowed: (schema: Schema, addresses: Address[]) => boolean;
+    protected queryDisallowed: (schema: Schema, addresses: string[]) => boolean;
+}
+
+declare const isQuerySupportedByModule: <T extends QueryBoundWitness = _xyo_network_payload_model.SchemaFields & _xyo_network_payload_model.PayloadFields & Omit<_xyo_network_boundwitness_model.BoundWitnessFields & {
+    additional?: _xylabs_hex.Hash[];
+    query: _xylabs_hex.Hash;
+    resultSet?: string;
+    schema: _xyo_network_boundwitness_model.QueryBoundWitnessSchema;
+}, "schema"> & {
+    schema: "network.xyo.boundwitness";
+}>(mod: Module, query: T, payloads?: Payload[]) => Promise<boolean>;
+declare class SupportedQueryValidator implements QueryValidator {
+    protected readonly mod: Module;
+    constructor(mod: Module);
+    queryable: Queryable;
+}
+
+declare abstract class AbstractModule<TParams extends ModuleParams = ModuleParams, TEventData extends ModuleEventData = ModuleEventData> extends BaseEmitter<TParams, TEventData> implements Module<TParams, TEventData> {
+    static readonly allowRandomAccount: boolean;
+    static readonly configSchemas: Schema[];
+    static readonly defaultConfigSchema: Schema;
+    static defaultLogger: Logger;
+    static enableLazyLoad: boolean;
+    static readonly labels: Labels;
+    static readonly uniqueName: string;
+    protected static privateConstructorKey: string;
+    protected _account: AccountInstance;
+    protected _cachedManifests: LRUCache<number, (_xyo_network_payload_model.SchemaFields & _xyo_network_payload_model.PayloadFields & _xyo_network_manifest_model.ModuleManifest & {
+        schema: "network.xyo.module.manifest";
+    }) | (_xyo_network_payload_model.SchemaFields & _xyo_network_payload_model.PayloadFields & _xyo_network_manifest_model.ModuleManifest & {
+        schema: "network.xyo.node.manifest";
+    }), unknown>;
+    protected _lastError?: ModuleDetailsError;
+    protected _startPromise: Promisable<boolean> | undefined;
+    protected _started: Promisable<boolean> | undefined;
+    protected readonly moduleConfigQueryValidator: Queryable;
+    protected readonly supportedQueryValidator: Queryable;
+    private _busyCount;
+    private _logger;
+    private _status;
+    constructor(privateConstructorKey: string, params: TParams, account: AccountInstance);
+    get account(): AccountInstance;
+    get additionalSigners(): AccountInstance[];
+    get address(): Lowercase<string>;
+    get allowAnonymous(): boolean;
+    get allowNameResolution(): boolean;
+    get archiving(): ArchivingModuleConfig['archiving'] | undefined;
+    get archivist(): string | undefined;
+    get config(): TParams['config'];
+    get dead(): boolean;
+    get ephemeralQueryAccountEnabled(): boolean;
+    get id(): string;
+    get logger(): Logger;
+    get modName(): string | undefined;
+    get priority(): ObjectResolverPriority;
+    get queries(): Schema[];
+    get status(): ModuleStatus;
+    get timestamp(): boolean;
+    protected set status(value: ModuleStatus);
+    abstract get downResolver(): ModuleResolverInstance;
+    abstract get upResolver(): ModuleResolverInstance;
+    static _getRootFunction(funcName: string): any;
+    static _noOverride(functionName: string): void;
+    static create<TModule extends AttachableModuleInstance>(this: CreatableModule<TModule>, params?: Omit<TModule['params'], 'config'> & {
+        config?: TModule['params']['config'];
+    }): Promise<TModule>;
+    static determineAccount(params: {
+        account?: AccountInstance | 'random';
+        accountPath?: string;
+        wallet?: WalletInstance;
+    }): Promise<AccountInstance>;
+    static factory<TModule extends AttachableModuleInstance>(this: CreatableModule<TModule>, params?: Omit<TModule['params'], 'config'> & {
+        config?: TModule['params']['config'];
+    }): CreatableModuleFactory<TModule>;
+    _getRootFunction(funcName: string): any;
+    busy<R>(closure: () => Promise<R>): Promise<R>;
+    emit<TEventName extends keyof TEventData = keyof TEventData, TEventArgs extends TEventData[TEventName] = TEventData[TEventName]>(eventName: TEventName, eventArgs: TEventArgs): Promise<void>;
+    previousHash(): Promisable<string | undefined>;
+    query<T extends QueryBoundWitness = QueryBoundWitness, TConfig extends ModuleConfig = ModuleConfig>(query: T, payloads?: Payload[], queryConfig?: TConfig): Promise<ModuleQueryResult>;
+    queryable<T extends QueryBoundWitness = QueryBoundWitness, TConfig extends ModuleConfig = ModuleConfig>(query: T, payloads?: Payload[], queryConfig?: TConfig): Promise<boolean>;
+    start(_timeout?: number): Promisable<boolean>;
+    started(notStartedAction?: 'error' | 'throw' | 'warn' | 'log' | 'none', tryStart?: boolean): Promise<boolean>;
+    stop(_timeout?: number): Promise<boolean>;
+    protected _checkDead(): void;
+    protected _noOverride(functionName: string): void;
+    protected archivistInstance(): Promise<ArchivistInstance | undefined>;
+    protected archivistInstance(required: true): Promise<ArchivistInstance>;
+    protected bindHashes(hashes: Hash[], schema: Schema[], account?: AccountInstance): PromiseEx<unknown, AccountInstance>;
+    protected bindHashesInternal(hashes: Hash[], schema: Schema[], account?: AccountInstance): Promise<BoundWitness>;
+    protected bindQuery<T extends Query>(query: T, payloads?: Payload[], account?: AccountInstance, additionalSigners?: AccountInstance[]): PromiseEx<[WithMeta<QueryBoundWitness>, WithMeta<Payload>[], WithMeta<Payload>[]], AccountInstance>;
+    protected bindQueryInternal<T extends Query>(query: T, payloads?: Payload[], account?: AccountInstance, additionalSigners?: AccountInstance[]): Promise<[WithMeta<QueryBoundWitness>, WithMeta<Payload>[], WithMeta<Payload>[]]>;
+    protected bindQueryResult<T extends Query>(query: WithMeta<T>, payloads: Payload[], additionalWitnesses?: AccountInstance[], errors?: ModuleError[]): Promise<ModuleQueryResult>;
+    protected generateConfigAndAddress(_maxDepth?: number): Promise<Payload[]>;
+    protected generateDescribe(): Promise<ModuleDescriptionPayload>;
+    protected getArchivist(): Promise<ArchivistInstance | undefined>;
+    protected isAllowedArchivingQuery(schema: Schema): boolean;
+    protected manifestHandler(_maxDepth?: number, _ignoreAddresses?: Address[]): Promisable<ModuleManifestPayload>;
+    protected moduleAddressHandler(): Promisable<(AddressPreviousHashPayload | AddressPayload)[]>;
+    protected queryHandler<T extends QueryBoundWitness = QueryBoundWitness, TConfig extends ModuleConfig = ModuleConfig>(query: T, payloads?: Payload[], queryConfig?: TConfig): Promise<ModuleQueryHandlerResult>;
+    protected startHandler(): Promise<boolean>;
+    protected stateHandler(): Promise<Payload[]>;
+    protected stopHandler(_timeout?: number): Promisable<boolean>;
+    protected subscribeHandler(): void;
+    protected validateConfig(config?: unknown, parents?: string[]): boolean;
+    protected abstract certifyParents(): Promise<WithMeta<Payload>[]>;
+    protected abstract storeToArchivists(payloads: Payload[]): Promise<Payload[]>;
+}
+
+declare abstract class AbstractModuleInstance<TParams extends ModuleParams = ModuleParams, TEventData extends ModuleEventData = ModuleEventData> extends AbstractModule<TParams, TEventData> implements AttachableModuleInstance<TParams, TEventData>, ModuleNameResolver {
+    static readonly uniqueName: string;
+    static readonly useNewResolver = false;
+    private _downResolver?;
+    private _parents;
+    private _privateResolver?;
+    private _upResolver?;
+    constructor(privateConstructorKey: string, params: TParams, account: AccountInstance);
+    get downResolver(): CompositeModuleResolver<_xyo_network_module_resolver.CompositeModuleResolverParams>;
+    get modName(): string | undefined;
+    get moduleIdentifierTransformers(): _xyo_network_module_model.ModuleIdentifierTransformer[];
+    get privateResolver(): CompositeModuleResolver<_xyo_network_module_resolver.CompositeModuleResolverParams>;
+    get root(): this;
+    get upResolver(): CompositeModuleResolver<_xyo_network_module_resolver.CompositeModuleResolverParams>;
+    addParent(mod: ModuleInstance): void;
+    certifyParents(): Promise<WithMeta<Payload>[]>;
+    manifest(maxDepth?: number): Promise<ModuleManifestPayload>;
+    manifestQuery(account: AccountInstance, maxDepth?: number): Promise<ModuleQueryResult<ModuleManifestPayload>>;
+    moduleAddress(): Promise<(AddressPayload | AddressPreviousHashPayload)[]>;
+    parents(): Promisable<NodeInstance[]>;
+    privateChildren(): Promisable<ModuleInstance[]>;
+    publicChildren(): Promisable<ModuleInstance[]>;
+    removeParent(address: Address): void;
+    resolve(): Promise<ModuleInstance[]>;
+    resolve<T extends ModuleInstance = ModuleInstance>(all: '*', options?: ModuleFilterOptions<T>): Promise<T[]>;
+    resolve<T extends ModuleInstance = ModuleInstance>(filter: ModuleFilter, options?: ModuleFilterOptions<T>): Promise<T[]>;
+    resolve<T extends ModuleInstance = ModuleInstance>(id: ModuleIdentifier, options?: ModuleFilterOptions<T>): Promise<T | undefined>;
+    resolve<T extends ModuleInstance = ModuleInstance>(filter?: ModuleFilter, options?: ModuleFilterOptions<T>): Promise<T[]>;
+    resolveIdentifier(id: ModuleIdentifier, options?: ObjectFilterOptions): Promise<Address | undefined>;
+    resolvePrivate<T extends ModuleInstance = ModuleInstance>(all: '*', options?: ModuleFilterOptions<T>): Promise<T[]>;
+    resolvePrivate<T extends ModuleInstance = ModuleInstance>(id: ModuleIdentifier, options?: ModuleFilterOptions<T>): Promise<T | undefined>;
+    siblings(): Promise<ModuleInstance[]>;
+    state(): Promise<({
+        schema: string;
+    } & _xyo_network_payload_model.PayloadFields)[]>;
+    stateQuery(account: AccountInstance): Promise<ModuleQueryResult>;
+    subscribe(_queryAccount?: AccountInstance): void;
+    protected manifestHandler(maxDepth?: number, _ignoreAddresses?: Address[]): Promise<ModuleManifestPayload>;
+    protected resolveArchivingArchivists(): Promise<ArchivistInstance[]>;
+    protected sendQuery<T extends Query, P extends Payload = Payload, R extends Payload = Payload>(queryPayload: T, payloads?: P[], account?: AccountInstance): Promise<WithMeta<R>[]>;
+    protected sendQueryRaw<T extends Query, P extends Payload = Payload, R extends Payload = Payload>(queryPayload: T, payloads?: P[], account?: AccountInstance): Promise<ModuleQueryResult<R>>;
+    protected storeToArchivists(payloads: Payload[]): Promise<Payload[]>;
+}
+
+declare class ModuleErrorBuilder extends PayloadBuilder<ModuleError> {
+    _details?: JsonValue;
+    _message?: string;
+    _name?: string;
+    _query?: Hash;
+    _sources?: Hash[];
+    constructor();
+    build(): Promise<WithMeta<ModuleError>>;
+    details(details?: JsonValue): this;
+    message(message: string): this;
+    name(name: string): this;
+    query(query: Hash): this;
+    sources(sources: Hash[]): this;
+}
+
+export { AbstractModule, AbstractModuleInstance, BaseEmitter, ModuleConfigQueryValidator, ModuleErrorBuilder, type QueryValidator, type Queryable, type SortedPipedAddressesString, SupportedQueryValidator, isQuerySupportedByModule };