@xyo-network/sdk 2.102.4 → 7.0.2

package/dist/_pkg/module-model/neutral/instance/Instance.d.ts

@@ -0,0 +1,37 @@
+import type { CreatableStatus, Promisable, TypeCheck } from '@xylabs/sdk';
+import { IsObjectFactory } from '@xylabs/sdk';
+import type { AccountInstance, XyoAddress } from '../../../sdk-protocol/neutral/index.ts';
+import type { ModuleEventData } from '../EventsModels/index.ts';
+import type { ModuleIdentifier, ModuleName } from '../ModuleIdentifier.ts';
+import type { QueryableModule, QueryableModuleFunctions, QueryableModuleParams } from '../QueryableModule/index.ts';
+import type { Direction } from './ObjectFilter.ts';
+import type { ObjectResolver } from './ObjectResolver.ts';
+export type ModulePipeLine = Lowercase<'one-to-one' | 'one-to-many' | 'many-to-one' | 'many-to-many'>;
+export type ModuleStatus = CreatableStatus | 'wrapped' | 'proxy';
+export declare class DeadModuleError extends Error {
+    error: Error | undefined;
+    id: ModuleIdentifier;
+    constructor(id: ModuleIdentifier, error: Error | undefined, msg?: string);
+}
+export interface AddressToWeakInstanceCache {
+    get: (address: XyoAddress) => WeakRef<ModuleInstance> | null;
+    set: (address: XyoAddress, instance: WeakRef<ModuleInstance> | null) => void;
+}
+export interface ModuleFamilyFunctions {
+    account?: AccountInstance;
+    addParent: (mod: ModuleInstance) => void;
+    addressCache?: (direction: Direction, includePrivate: boolean) => AddressToWeakInstanceCache | undefined;
+    modName?: ModuleName;
+    parents: () => Promisable<ModuleInstance[]>;
+    privateChildren: () => Promisable<ModuleInstance[]>;
+    publicChildren: () => Promisable<ModuleInstance[]>;
+    removeParent: (address: XyoAddress) => void;
+    siblings: () => Promisable<ModuleInstance[]>;
+}
+export interface ModuleInstance<TParams extends QueryableModuleParams = QueryableModuleParams, TEventData extends ModuleEventData = ModuleEventData> extends QueryableModule<TParams, TEventData>, ObjectResolver<ModuleInstance>, QueryableModuleFunctions, ModuleFamilyFunctions {
+    readonly pipeline?: ModulePipeLine;
+    readonly status: ModuleStatus | null;
+}
+export type InstanceTypeCheck<T extends ModuleInstance = ModuleInstance> = TypeCheck<T>;
+export declare class IsInstanceFactory<T extends ModuleInstance = ModuleInstance> extends IsObjectFactory<T> {
+}

package/dist/_pkg/module-model/neutral/instance/ModuleFilter.d.ts

@@ -0,0 +1,13 @@
+import type { ModuleInstance } from './Instance.ts';
+import type { AddressObjectFilter, AnyObjectFilter, NameObjectFilter, ObjectFilter, ObjectFilterOptions, QueryObjectFilter } from './ObjectFilter.ts';
+export interface ModuleFilterOptions<T extends ModuleInstance = ModuleInstance> extends ObjectFilterOptions<T> {
+}
+export declare const isAddressModuleFilter: (value: unknown) => value is AddressObjectFilter<ModuleInstance>;
+export declare const isNameModuleFilter: (value: unknown) => value is NameObjectFilter<ModuleInstance>;
+export declare const isQueryModuleFilter: (value: unknown) => value is QueryObjectFilter<ModuleInstance>;
+export type AnyModuleFilter<T extends ModuleInstance = ModuleInstance> = AnyObjectFilter<T>;
+export type AddressModuleFilter<T extends ModuleInstance = ModuleInstance> = AddressObjectFilter<T>;
+export type NameModuleFilter<T extends ModuleInstance = ModuleInstance> = NameObjectFilter<T>;
+export type QueryModuleFilter<T extends ModuleInstance = ModuleInstance> = QueryObjectFilter<T>;
+/** @deprecated use ModuleIdentifier instead */
+export type ModuleFilter<T extends ModuleInstance = ModuleInstance> = ObjectFilter<T>;

package/dist/_pkg/module-model/neutral/instance/ModuleInstanceParams.d.ts

@@ -0,0 +1,9 @@
+import type { AnyConfigSchema, ModuleConfig } from '../Config/index.ts';
+import type { QueryableModuleParams } from '../QueryableModule/index.ts';
+import type { ModuleInstance } from './Instance.ts';
+export interface ModuleInstanceChildrenParams {
+    privateChildren?: ModuleInstance[];
+    publicChildren?: ModuleInstance[];
+}
+export interface ModuleInstanceParams<TConfig extends AnyConfigSchema<ModuleConfig> = AnyConfigSchema<ModuleConfig>> extends QueryableModuleParams<TConfig>, ModuleInstanceChildrenParams {
+}

package/dist/_pkg/module-model/neutral/instance/ModuleRepository.d.ts

@@ -0,0 +1,9 @@
+import type { XyoAddress } from '../../../sdk-protocol/neutral/index.ts';
+import type { ModuleInstance } from './Instance.ts';
+import type { ModuleResolverInstance } from './ModuleResolver.ts';
+export interface ModuleRepository<T extends ModuleInstance = ModuleInstance> extends ModuleResolverInstance<T> {
+    add(mod: T): this;
+    add(mod: T[]): this;
+    add(mod: T | T[]): this;
+    remove(address: XyoAddress | string[]): this;
+}

package/dist/_pkg/module-model/neutral/instance/ModuleResolver.d.ts

@@ -0,0 +1,17 @@
+import type { Promisable } from '@xylabs/sdk';
+import type { XyoAddress } from '../../../sdk-protocol/neutral/index.ts';
+import type { ModuleIdentifier } from '../ModuleIdentifier.ts';
+import type { ModuleInstance } from './Instance.ts';
+import type { ObjectFilterOptions } from './ObjectFilter.ts';
+import type { ObjectResolver } from './ObjectResolver.ts';
+export declare const isModuleResolver: (value?: unknown) => value is ObjectResolver<ModuleInstance>;
+export interface ModuleResolver<TResult extends ModuleInstance = ModuleInstance> extends ObjectResolver<TResult> {
+}
+export interface ModuleNameResolver {
+    readonly root: ModuleInstance;
+    resolveIdentifier(id: ModuleIdentifier, options?: ObjectFilterOptions): Promisable<XyoAddress | undefined>;
+}
+export interface ModuleResolverInstance<TResult extends ModuleInstance = ModuleInstance> extends ModuleResolver<TResult>, ModuleNameResolver {
+    addResolver: (resolver: ModuleResolverInstance<TResult>) => this;
+    removeResolver: (resolver: ModuleResolverInstance<TResult>) => this;
+}

package/dist/_pkg/module-model/neutral/instance/ObjectFilter.d.ts

@@ -0,0 +1,29 @@
+import type { AnyObject, EmptyObject, TypeCheck } from '@xylabs/sdk';
+import type { XyoAddress } from '../../../sdk-protocol/neutral/index.ts';
+import type { ModuleName } from '../ModuleIdentifier.ts';
+export type Direction = 'up' | 'down' | 'all';
+export type Visibility = 'public' | 'private' | 'all';
+export interface ResolveStrategy {
+    maxDepth?: number;
+    required?: boolean | 'warn' | 'log';
+    retry?: number;
+    timeout?: number;
+}
+export interface ObjectFilterOptions<T extends EmptyObject = AnyObject> extends ResolveStrategy {
+    direction?: Direction;
+    identity?: TypeCheck<T>;
+}
+export interface AddressObjectFilter<T extends EmptyObject = AnyObject> extends ObjectFilterOptions<T> {
+    address: XyoAddress[];
+}
+export declare const isAddressObjectFilter: <T extends EmptyObject = AnyObject>(value: unknown) => value is AddressObjectFilter<T>;
+export interface NameObjectFilter<T extends EmptyObject = AnyObject> extends ObjectFilterOptions<T> {
+    name: ModuleName[];
+}
+export declare const isNameObjectFilter: <T extends EmptyObject = AnyObject>(value: unknown) => value is NameObjectFilter<T>;
+export interface QueryObjectFilter<T extends EmptyObject = AnyObject> extends ObjectFilterOptions<T> {
+    query: string[][];
+}
+export declare const isQueryObjectFilter: <T extends EmptyObject = AnyObject>(value: unknown) => value is QueryObjectFilter<T>;
+export type AnyObjectFilter<T extends EmptyObject = AnyObject> = Partial<AddressObjectFilter<T>> & Partial<NameObjectFilter<T>> & Partial<QueryObjectFilter<T>>;
+export type ObjectFilter<T extends EmptyObject> = ObjectFilterOptions<T> | AddressObjectFilter<T> | NameObjectFilter<T> | QueryObjectFilter<T>;

package/dist/_pkg/module-model/neutral/instance/ObjectResolver.d.ts

@@ -0,0 +1,26 @@
+import type { AnyObject, EmptyObject, Promisable } from '@xylabs/sdk';
+import type { ModuleIdentifier } from '../ModuleIdentifier.ts';
+import type { ObjectFilterOptions } from './ObjectFilter.ts';
+export declare const isObjectResolver: <T extends EmptyObject = AnyObject>(value?: unknown) => value is ObjectResolver<T>;
+export declare const ObjectResolverPriority: {
+    readonly Disabled: -1;
+    readonly VeryLow: 0;
+    readonly Low: 1;
+    readonly Normal: 2;
+    readonly High: 3;
+    readonly VeryHigh: 4;
+};
+export type ObjectResolverPriority = typeof ObjectResolverPriority[keyof typeof ObjectResolverPriority];
+export interface ObjectResolver<TResult extends EmptyObject> {
+    priority: ObjectResolverPriority;
+    resolve<T extends TResult = TResult>(all: '*', options?: ObjectFilterOptions<T>): Promisable<T[]>;
+    resolve<T extends TResult = TResult>(id: ModuleIdentifier, options?: ObjectFilterOptions<T>): Promisable<T | undefined>;
+    resolve<T extends TResult = TResult>(id?: ModuleIdentifier, options?: ObjectFilterOptions<T>): Promisable<T | T[] | undefined>;
+    resolvePrivate<T extends TResult = TResult>(all: '*', options?: ObjectFilterOptions<T>): Promise<T[]>;
+    resolvePrivate<T extends TResult = TResult>(id: ModuleIdentifier, options?: ObjectFilterOptions<T>): Promise<T | undefined>;
+    resolvePrivate<T extends TResult = TResult>(id: ModuleIdentifier, options?: ObjectFilterOptions<T>): Promise<T | T[] | undefined>;
+}
+export interface ObjectResolverInstance<TResult extends EmptyObject> extends ObjectResolver<TResult> {
+    addResolver: (resolver: ObjectResolverInstance<TResult>) => this;
+    removeResolver: (resolver: ObjectResolverInstance<TResult>) => this;
+}

package/dist/_pkg/module-model/neutral/instance/asModuleInstance.d.ts

@@ -0,0 +1,6 @@
+import type { AsTypeFunction } from '@xylabs/sdk';
+import type { AnyConfigSchema, ModuleConfig } from '../Config/Config.ts';
+import type { ModuleEventData } from '../EventsModels/ModuleEventData.ts';
+import type { QueryableModuleParams } from '../QueryableModule/QueryableModuleParams.ts';
+import type { ModuleInstance } from './Instance.ts';
+export declare const asModuleInstance: AsTypeFunction<ModuleInstance<QueryableModuleParams<AnyConfigSchema<ModuleConfig>>, ModuleEventData<object>>>;

package/dist/_pkg/module-model/neutral/instance/attachable/AttachableInstance.d.ts

@@ -0,0 +1,15 @@
+import type { CreatableInstance, TypeCheck } from '@xylabs/sdk';
+import { IsObjectFactory } from '@xylabs/sdk';
+import type { ModuleEventData } from '../../EventsModels/index.ts';
+import type { QueryableModuleParams } from '../../QueryableModule/index.ts';
+import type { ModuleInstance } from '../Instance.ts';
+import type { ModuleResolverInstance } from '../ModuleResolver.ts';
+export interface AttachableModuleInstance<TParams extends QueryableModuleParams = QueryableModuleParams, TEventData extends ModuleEventData = ModuleEventData> extends ModuleInstance<TParams, TEventData>, CreatableInstance<TParams, TEventData> {
+    config: TParams['config'];
+    readonly downResolver: ModuleResolverInstance;
+    readonly privateResolver: ModuleResolverInstance;
+    readonly upResolver: ModuleResolverInstance;
+}
+export type AttachableModuleInstanceTypeCheck<T extends AttachableModuleInstance = AttachableModuleInstance> = TypeCheck<T>;
+export declare class IsAttachableModuleInstanceFactory<T extends AttachableModuleInstance = AttachableModuleInstance> extends IsObjectFactory<T> {
+}

package/dist/_pkg/module-model/neutral/instance/attachable/asAttachableInstance.d.ts

@@ -0,0 +1,3 @@
+import type { AsTypeFunction } from '@xylabs/sdk';
+import type { AttachableModuleInstance } from './AttachableInstance.ts';
+export declare const asAttachableModuleInstance: AsTypeFunction<AttachableModuleInstance>;

package/dist/_pkg/module-model/neutral/instance/attachable/index.d.ts

@@ -0,0 +1,3 @@
+export * from './asAttachableInstance.ts';
+export * from './AttachableInstance.ts';
+export * from './isAttachableInstance.ts';

package/dist/_pkg/module-model/neutral/instance/attachable/isAttachableInstance.d.ts

@@ -0,0 +1,4 @@
+import type { ObjectTypeShape, TypeCheck } from '@xylabs/sdk';
+import type { AttachableModuleInstance } from './AttachableInstance.ts';
+export declare const requiredAttachableModuleInstanceFunctions: ObjectTypeShape;
+export declare const isAttachableModuleInstance: TypeCheck<AttachableModuleInstance>;

package/dist/_pkg/module-model/neutral/instance/index.d.ts

@@ -0,0 +1,10 @@
+export * from './asModuleInstance.ts';
+export * from './attachable/index.ts';
+export * from './Instance.ts';
+export * from './isModuleInstance.ts';
+export * from './ModuleFilter.ts';
+export * from './ModuleInstanceParams.ts';
+export * from './ModuleRepository.ts';
+export * from './ModuleResolver.ts';
+export * from './ObjectFilter.ts';
+export * from './ObjectResolver.ts';

package/dist/_pkg/module-model/neutral/instance/isModuleInstance.d.ts

@@ -0,0 +1,4 @@
+import type { ObjectTypeShape, TypeCheck } from '@xylabs/sdk';
+import type { ModuleInstance } from './Instance.ts';
+export declare const requiredModuleInstanceFunctions: ObjectTypeShape;
+export declare const isModuleInstance: TypeCheck<ModuleInstance>;

package/dist/_pkg/module-model/neutral/lib/duplicateModules.d.ts

@@ -0,0 +1,11 @@
+import type { QueryableModule } from '../QueryableModule/index.ts';
+/**
+ * Used to filter duplicates from an array of modules
+ * @example: modulesArray.filter(duplicateModules)
+ * @param value Current Module
+ * @param index Current Module's index
+ * @param array Module Array
+ * @returns True if the Module's address is the first occurrence of
+ * that address in the array, false otherwise
+ */
+export declare const duplicateModules: (value: QueryableModule, index: number, array: QueryableModule[]) => value is QueryableModule;

package/dist/_pkg/module-model/neutral/lib/index.d.ts

@@ -0,0 +1,2 @@
+export * from './duplicateModules.ts';
+export * from './serializable.ts';

package/dist/_pkg/module-model/neutral/lib/serializable.d.ts

@@ -0,0 +1 @@
+export declare const isSerializable: (value: unknown, maxDepth?: number) => boolean;

package/dist/_pkg/module-model/neutral/withModule.d.ts

@@ -0,0 +1,5 @@
+import type { TypeCheck } from '@xylabs/sdk';
+/** @deprecated use narrowing instead [ if(is) ] */
+export declare const WithFactory: {
+    create: <T extends object>(typeCheck: TypeCheck<T>) => <R>(mod: any, closure: (mod: T) => R) => R | undefined;
+};

package/dist/_pkg/module-resolver/neutral/AbstractModuleResolver.d.ts

@@ -0,0 +1,23 @@
+import type { BaseParams, Promisable } from '@xylabs/sdk';
+import { Base } from '@xylabs/sdk';
+import type { ModuleFilterOptions, ModuleIdentifier, ModuleInstance, ModuleResolverInstance, ObjectFilterOptions } from '../../module-model/neutral/index.ts';
+import { ObjectResolverPriority } from '../../module-model/neutral/index.ts';
+import type { XyoAddress } from '../../sdk-protocol/neutral/index.ts';
+export interface ModuleResolverParams extends BaseParams {
+    priority?: ObjectResolverPriority;
+    root: ModuleInstance;
+}
+export declare abstract class AbstractModuleResolver<TParams extends ModuleResolverParams = ModuleResolverParams> extends Base<TParams> implements ModuleResolverInstance {
+    get priority(): ObjectResolverPriority;
+    set priority(value: ObjectResolverPriority);
+    get root(): ModuleInstance;
+    resolve<T extends ModuleInstance = ModuleInstance>(): Promise<T[]>;
+    resolve<T extends ModuleInstance = ModuleInstance>(all: '*', options?: ModuleFilterOptions<T>): Promise<T[]>;
+    resolve<T extends ModuleInstance = ModuleInstance>(id: ModuleIdentifier, options?: ModuleFilterOptions<T>): Promise<T | undefined>;
+    resolvePrivate<T extends ModuleInstance = ModuleInstance>(all: '*', options?: ObjectFilterOptions<T>): Promise<T[]>;
+    resolvePrivate<T extends ModuleInstance = ModuleInstance>(id: ModuleIdentifier, options?: ObjectFilterOptions<T>): Promise<T | undefined>;
+    abstract addResolver(resolver: ModuleResolverInstance): this;
+    abstract removeResolver(resolver: ModuleResolverInstance): this;
+    abstract resolveHandler<T extends ModuleInstance = ModuleInstance>(id: ModuleIdentifier, options?: ModuleFilterOptions<T>): Promisable<T[]>;
+    abstract resolveIdentifier(id: ModuleIdentifier, options?: ObjectFilterOptions): Promisable<XyoAddress | undefined>;
+}

package/dist/_pkg/module-resolver/neutral/CompositeModuleResolver.d.ts

@@ -0,0 +1,34 @@
+import type { Promisable } from '@xylabs/sdk';
+import type { CacheConfig, ModuleFilterOptions, ModuleIdentifier, ModuleIdentifierTransformer, ModuleInstance, ModuleRepository, ModuleResolverInstance, ObjectFilterOptions } from '../../module-model/neutral/index.ts';
+import type { XyoAddress } from '../../sdk-protocol/neutral/index.ts';
+import { LRUCache } from 'lru-cache';
+import type { ModuleResolverParams } from './AbstractModuleResolver.ts';
+import { AbstractModuleResolver } from './AbstractModuleResolver.ts';
+export interface CompositeModuleResolverParams extends ModuleResolverParams {
+    allowNameResolution?: boolean;
+    cache?: CacheConfig;
+    moduleIdentifierTransformers?: ModuleIdentifierTransformer[];
+}
+export declare class CompositeModuleResolver<T extends CompositeModuleResolverParams = CompositeModuleResolverParams> extends AbstractModuleResolver<T> implements ModuleRepository, ModuleResolverInstance {
+    static readonly defaultMaxDepth = 3;
+    protected _cache: LRUCache<ModuleIdentifier, ModuleInstance>;
+    protected resolvers: ModuleResolverInstance[];
+    private _allowAddResolver;
+    private _localResolver;
+    constructor(params: T);
+    get allowAddResolver(): boolean;
+    set allowAddResolver(value: boolean);
+    get allowNameResolution(): boolean;
+    private get moduleIdentifierTransformers();
+    add(mod: ModuleInstance): this;
+    add(mod: ModuleInstance[]): this;
+    addResolver(resolver: ModuleResolverInstance): this;
+    remove(addresses: XyoAddress[] | XyoAddress): this;
+    removeResolver(resolver: ModuleResolverInstance): this;
+    resolveHandler<T extends ModuleInstance = ModuleInstance>(id?: ModuleIdentifier, options?: ModuleFilterOptions<T>): Promise<T[]>;
+    resolveIdentifier(id: ModuleIdentifier, _options?: ObjectFilterOptions): Promise<XyoAddress | undefined>;
+    protected resolveComplexIdentifier(_id: ModuleIdentifier, _options?: ObjectFilterOptions): Promisable<XyoAddress | undefined>;
+    private addSingleModule;
+    private removeSingleModule;
+    private resolveMultipartIdentifier;
+}

package/dist/_pkg/module-resolver/neutral/NameRegistrarTransformer.d.ts

@@ -0,0 +1,9 @@
+import type { DivinerInstance } from '../../diviner-model/neutral/index.ts';
+import type { ModuleIdentifier, ModuleIdentifierTransformer } from '../../module-model/neutral/index.ts';
+export declare class NameRegistrarTransformer implements ModuleIdentifierTransformer {
+    private _cache;
+    private registrarDiviner;
+    private root;
+    constructor(registrarDiviner: DivinerInstance, root: string);
+    transform(identifier: ModuleIdentifier): Promise<ModuleIdentifier>;
+}

package/dist/_pkg/module-resolver/neutral/ResolveHelper/ResolveHelper.d.ts

@@ -0,0 +1,26 @@
+import type { Logger } from '@xylabs/sdk';
+import type { ModuleFilterOptions, ModuleIdentifier, ModuleIdentifierTransformer, ModuleInstance, ModuleResolver } from '../../../module-model/neutral/index.ts';
+import type { XyoAddress, XyoQuantAddress } from '../../../sdk-protocol/neutral/index.ts';
+import { ResolveHelperStatic } from './ResolveHelperStatic.ts';
+export interface ResolveHelperConfig {
+    address: XyoAddress;
+    dead?: boolean;
+    downResolver?: ModuleResolver;
+    logger?: Logger;
+    mod: ModuleInstance;
+    privateResolver?: ModuleResolver;
+    transformers: ModuleIdentifierTransformer[];
+    upResolver?: ModuleResolver;
+}
+export declare class ResolveHelper extends ResolveHelperStatic {
+    static resolve<T extends ModuleInstance = ModuleInstance>(config: ResolveHelperConfig, all: '*', options?: ModuleFilterOptions<T>): Promise<T[]>;
+    static resolve<T extends ModuleInstance = ModuleInstance>(config: ResolveHelperConfig, id: ModuleIdentifier, options?: ModuleFilterOptions<T>): Promise<T | undefined>;
+    static resolveModuleIdentifier<T extends ModuleInstance = ModuleInstance>(resolver: ModuleResolver, path: ModuleIdentifier, required?: boolean): Promise<T | undefined>;
+    static traceModuleIdentifier(resolver: ModuleResolver, path: ModuleIdentifier): Promise<((Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }) | XyoQuantAddress)[]>;
+    static transformModuleIdentifier(identifier: ModuleIdentifier, transformers?: ModuleIdentifierTransformer[]): Promise<ModuleIdentifier | undefined>;
+    static validateRequiredResolve(required: boolean | 'warn' | 'log', result: ModuleInstance[] | ModuleInstance | undefined, id: ModuleIdentifier, logger?: Logger | undefined): void;
+}

package/dist/_pkg/module-resolver/neutral/ResolveHelper/ResolveHelperStatic.d.ts

@@ -0,0 +1,6 @@
+import type { Logger } from '@xylabs/sdk';
+import type { ModuleIdentifierTransformer } from '../../../module-model/neutral/index.ts';
+export declare class ResolveHelperStatic {
+    static readonly defaultLogger?: Logger;
+    static transformers: ModuleIdentifierTransformer[];
+}

package/dist/_pkg/module-resolver/neutral/ResolveHelper/index.d.ts

@@ -0,0 +1,9 @@
+export * from './model.ts';
+export * from './resolveAddressToInstance.ts';
+export * from './resolveAll.ts';
+export * from './ResolveHelper.ts';
+export * from './resolveLocalNameToAddress.ts';
+export * from './resolveLocalNameToInstance.ts';
+export * from './resolvePathToAddress.ts';
+export * from './resolvePathToInstance.ts';
+export * from './transformModuleIdentifier.ts';

package/dist/_pkg/module-resolver/neutral/ResolveHelper/model.d.ts

@@ -0,0 +1 @@
+export type ModuleResolveDirection = 'all' | 'up' | 'down';

package/dist/_pkg/module-resolver/neutral/ResolveHelper/resolveAddressToInstance.d.ts

@@ -0,0 +1,8 @@
+import type { ModuleInstance } from '../../../module-model/neutral/index.ts';
+import type { XyoAddress } from '../../../sdk-protocol/neutral/index.ts';
+import type { ModuleResolveDirection } from './model.ts';
+export declare const resolveAddressToInstanceDown: (root: ModuleInstance, address: XyoAddress, includePrivate?: boolean | undefined, ignore?: XyoAddress[]) => Promise<ModuleInstance | undefined>;
+export declare const resolveAddressToInstanceSiblings: (root: ModuleInstance, address: XyoAddress, includePrivate?: boolean | undefined, ignore?: XyoAddress[]) => Promise<ModuleInstance | undefined>;
+export declare const resolveAddressToInstanceUp: (root: ModuleInstance, address: XyoAddress, includePrivate?: boolean | undefined, ignore?: XyoAddress[]) => Promise<ModuleInstance | undefined>;
+export declare const resolveAddressToInstanceAll: (root: ModuleInstance, address: XyoAddress, includePrivate?: boolean | undefined, ignore?: XyoAddress[]) => Promise<ModuleInstance | undefined>;
+export declare const resolveAddressToInstance: (root: ModuleInstance, address: XyoAddress, includePrivate?: boolean | undefined, ignore?: XyoAddress[], direction?: ModuleResolveDirection) => Promise<ModuleInstance | undefined>;

package/dist/_pkg/module-resolver/neutral/ResolveHelper/resolveAll.d.ts

@@ -0,0 +1,5 @@
+import type { ModuleInstance } from '../../../module-model/neutral/index.ts';
+import type { XyoAddress } from '../../../sdk-protocol/neutral/index.ts';
+export declare const resolveAllUp: (root: ModuleInstance, maxDepth?: number, exclude?: XyoAddress[]) => Promise<ModuleInstance[]>;
+export declare const resolveAllDown: (root: ModuleInstance, maxDepth?: number, exclude?: XyoAddress[], includePrivate?: boolean) => Promise<ModuleInstance[]>;
+export declare const resolveAll: (root: ModuleInstance, maxDepth?: number, exclude?: XyoAddress[]) => Promise<ModuleInstance[]>;

package/dist/_pkg/module-resolver/neutral/ResolveHelper/resolveLocalNameToAddress.d.ts

@@ -0,0 +1,7 @@
+import type { ModuleInstance, ModuleName } from '../../../module-model/neutral/index.ts';
+import type { XyoAddress } from '../../../sdk-protocol/neutral/index.ts';
+import type { ModuleResolveDirection } from './model.ts';
+export declare const resolveLocalNameToAddressUp: (root: ModuleInstance, modName: ModuleName) => Promise<XyoAddress | undefined>;
+export declare const resolveLocalNameToAddressDown: (root: ModuleInstance, modName: ModuleName, includePrivate?: boolean | undefined) => Promise<XyoAddress | undefined>;
+export declare const resolveLocalNameToAddressAll: (root: ModuleInstance, modName: ModuleName, includePrivate?: boolean | undefined) => Promise<XyoAddress | undefined>;
+export declare const resolveLocalNameToAddress: (root: ModuleInstance, modName: ModuleName, includePrivate?: boolean | undefined, direction?: ModuleResolveDirection) => Promise<XyoAddress | undefined>;

package/dist/_pkg/module-resolver/neutral/ResolveHelper/resolveLocalNameToInstance.d.ts

@@ -0,0 +1,6 @@
+import type { ModuleInstance, ModuleName } from '../../../module-model/neutral/index.ts';
+import type { ModuleResolveDirection } from './model.ts';
+export declare const resolveLocalNameToInstanceUp: (root: ModuleInstance, modName: ModuleName) => Promise<ModuleInstance | undefined>;
+export declare const resolveLocalNameToInstanceDown: (root: ModuleInstance, modName: ModuleName, includePrivate?: boolean | undefined) => Promise<ModuleInstance | undefined>;
+export declare const resolveLocalNameToInstanceAll: (root: ModuleInstance, modName: ModuleName, includePrivate?: boolean) => Promise<ModuleInstance | undefined>;
+export declare const resolveLocalNameToInstance: (root: ModuleInstance, modName: ModuleName, includePrivate?: boolean, direction?: ModuleResolveDirection) => Promise<ModuleInstance | undefined>;

package/dist/_pkg/module-resolver/neutral/ResolveHelper/resolvePathToAddress.d.ts

@@ -0,0 +1,3 @@
+import type { ModuleIdentifierTransformer, ModuleInstance } from '../../../module-model/neutral/index.ts';
+import type { XyoAddress } from '../../../sdk-protocol/neutral/index.ts';
+export declare const resolvePathToAddress: (root: ModuleInstance, path: string, includePrivate?: boolean | undefined, transformers?: ModuleIdentifierTransformer[]) => Promise<XyoAddress | undefined>;

package/dist/_pkg/module-resolver/neutral/ResolveHelper/resolvePathToInstance.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleIdentifierTransformer, ModuleInstance } from '../../../module-model/neutral/index.ts';
+export declare const resolvePathToInstance: (root: ModuleInstance, path: string, includePrivate?: boolean | undefined, transformers?: ModuleIdentifierTransformer[]) => Promise<ModuleInstance | undefined>;

package/dist/_pkg/module-resolver/neutral/ResolveHelper/traceModuleIdentifier.d.ts

@@ -0,0 +1,3 @@
+import type { ModuleIdentifier, ModuleResolver } from '../../../module-model/neutral/index.ts';
+import type { XyoAddress } from '../../../sdk-protocol/neutral/index.ts';
+export declare const traceModuleIdentifier: (resolver: ModuleResolver, path: ModuleIdentifier) => Promise<XyoAddress[]>;

package/dist/_pkg/module-resolver/neutral/ResolveHelper/transformModuleIdentifier.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleIdentifier, ModuleIdentifierTransformer } from '../../../module-model/neutral/index.ts';
+export declare const transformModuleIdentifier: (id: ModuleIdentifier, transformers: ModuleIdentifierTransformer[]) => Promise<ModuleIdentifier | undefined>;

package/dist/_pkg/module-resolver/neutral/ResolverEventEmitter.d.ts

@@ -0,0 +1,9 @@
+import type { ModuleIdentifier, ModuleResolver, QueryableModule } from '../../module-model/neutral/index.ts';
+export interface ModuleResolvedEventArgs {
+    id?: ModuleIdentifier;
+    mod: QueryableModule;
+}
+export interface ResolverEventEmitter {
+    on(event: 'moduleResolved', listener: (args: ModuleResolvedEventArgs) => void): void;
+}
+export declare const mixinResolverEventEmitter: <T extends ModuleResolver = ModuleResolver>(resolver: T) => T & ResolverEventEmitter;

package/dist/_pkg/module-resolver/neutral/SimpleModuleResolver.d.ts

@@ -0,0 +1,26 @@
+import type { Promisable } from '@xylabs/sdk';
+import type { ModuleFilterOptions, ModuleIdentifier, ModuleInstance, ModuleRepository, ModuleResolverInstance, ObjectFilterOptions } from '../../module-model/neutral/index.ts';
+import type { XyoAddress } from '../../sdk-protocol/neutral/index.ts';
+import type { ModuleResolverParams } from './AbstractModuleResolver.ts';
+import { AbstractModuleResolver } from './AbstractModuleResolver.ts';
+export type SimpleModuleResolverParams = ModuleResolverParams & {
+    allowNameResolution?: boolean;
+};
+export declare class SimpleModuleResolver extends AbstractModuleResolver<SimpleModuleResolverParams> implements ModuleRepository {
+    private modules;
+    private nameToModule;
+    constructor(params: SimpleModuleResolverParams);
+    get allowNameResolution(): boolean;
+    add(mods: ModuleInstance): this;
+    add(mods: ModuleInstance[]): this;
+    addResolver(_resolver: ModuleResolverInstance): this;
+    remove(address: XyoAddress | XyoAddress[]): this;
+    removeResolver(_resolver: ModuleResolverInstance): this;
+    resolveHandler<T extends ModuleInstance = ModuleInstance>(id?: ModuleIdentifier, options?: ModuleFilterOptions<T>): Promisable<T[]>;
+    resolveIdentifier(id: ModuleIdentifier, _options?: ObjectFilterOptions): Promisable<XyoAddress | undefined>;
+    private addSingleModule;
+    private removeSingleModule;
+    private resolveByAddress;
+    private resolveByName;
+    private resolveByQuery;
+}

package/dist/_pkg/module-resolver/neutral/index.d.ts

@@ -0,0 +1,6 @@
+export * from './AbstractModuleResolver.ts';
+export * from './CompositeModuleResolver.ts';
+export * from './NameRegistrarTransformer.ts';
+export * from './ResolveHelper/index.ts';
+export * from './ResolverEventEmitter.ts';
+export * from './SimpleModuleResolver.ts';