@xyo-network/module-model 2.93.3 → 2.93.5

package/dist/node/module/asModule.d.ts

@@ -1,29 +1,35 @@
 export declare const asModule: {
     <TType extends import("./Module").Module<import("@xylabs/object").BaseParamsFields & {
         account?: import("@xyo-network/account-model").AccountInstance | "random" | undefined;
+        addToResolvers?: boolean | undefined;
         config: import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & Omit<import("..").ArchivingModuleConfig & import("..").ModuleConfigFields & import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & {
             schema: "network.xyo.module.config";
         }, "schema"> & {
             schema: string;
         };
         ephemeralQueryAccountEnabled?: boolean | undefined;
+        moduleIdentifierTransformers?: import("..").ModuleIdentifierTransformer[] | undefined;
     }, import("..").ModuleEventData<object>>>(value: import("@xylabs/promise").AnyNonPromise<T_1>, config?: import("@xylabs/object").TypeCheckConfig | undefined): TType | undefined;
     <TType_1 extends import("./Module").Module<import("@xylabs/object").BaseParamsFields & {
         account?: import("@xyo-network/account-model").AccountInstance | "random" | undefined;
+        addToResolvers?: boolean | undefined;
         config: import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & Omit<import("..").ArchivingModuleConfig & import("..").ModuleConfigFields & import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & {
             schema: "network.xyo.module.config";
         }, "schema"> & {
             schema: string;
         };
         ephemeralQueryAccountEnabled?: boolean | undefined;
+        moduleIdentifierTransformers?: import("..").ModuleIdentifierTransformer[] | undefined;
     }, import("..").ModuleEventData<object>>>(value: import("@xylabs/promise").AnyNonPromise<T_1>, assert: import("@xylabs/object").StringOrAlertFunction<import("./Module").Module<import("@xylabs/object").BaseParamsFields & {
         account?: import("@xyo-network/account-model").AccountInstance | "random" | undefined;
+        addToResolvers?: boolean | undefined;
         config: import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & Omit<import("..").ArchivingModuleConfig & import("..").ModuleConfigFields & import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & {
             schema: "network.xyo.module.config";
         }, "schema"> & {
             schema: string;
         };
         ephemeralQueryAccountEnabled?: boolean | undefined;
+        moduleIdentifierTransformers?: import("..").ModuleIdentifierTransformer[] | undefined;
     }, import("..").ModuleEventData<object>>>, config?: import("@xylabs/object").TypeCheckConfig | undefined): TType_1;
 };
 //# sourceMappingURL=asModule.d.ts.map

package/dist/node/module/asModule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"asModule.d.ts","sourceRoot":"","sources":["../../../src/module/asModule.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAmC,CAAA"}
+{"version":3,"file":"asModule.d.ts","sourceRoot":"","sources":["../../../src/module/asModule.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAmC,CAAA"}

package/dist/node/module/asModuleObject.d.cts

@@ -1,29 +1,35 @@
 export declare const asModuleObject: {
     <TType extends import("./Module").Module<import("@xylabs/object").BaseParamsFields & {
         account?: import("@xyo-network/account-model").AccountInstance | "random" | undefined;
+        addToResolvers?: boolean | undefined;
         config: import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & Omit<import("..").ArchivingModuleConfig & import("..").ModuleConfigFields & import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & {
             schema: "network.xyo.module.config";
         }, "schema"> & {
             schema: string;
         };
         ephemeralQueryAccountEnabled?: boolean | undefined;
+        moduleIdentifierTransformers?: import("..").ModuleIdentifierTransformer[] | undefined;
     }, import("..").ModuleEventData<object>>>(value: import("@xylabs/promise").AnyNonPromise<T_1>, config?: import("@xylabs/object").TypeCheckConfig | undefined): TType | undefined;
     <TType_1 extends import("./Module").Module<import("@xylabs/object").BaseParamsFields & {
         account?: import("@xyo-network/account-model").AccountInstance | "random" | undefined;
+        addToResolvers?: boolean | undefined;
         config: import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & Omit<import("..").ArchivingModuleConfig & import("..").ModuleConfigFields & import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & {
             schema: "network.xyo.module.config";
         }, "schema"> & {
             schema: string;
         };
         ephemeralQueryAccountEnabled?: boolean | undefined;
+        moduleIdentifierTransformers?: import("..").ModuleIdentifierTransformer[] | undefined;
     }, import("..").ModuleEventData<object>>>(value: import("@xylabs/promise").AnyNonPromise<T_1>, assert: import("@xylabs/object").StringOrAlertFunction<import("./Module").Module<import("@xylabs/object").BaseParamsFields & {
         account?: import("@xyo-network/account-model").AccountInstance | "random" | undefined;
+        addToResolvers?: boolean | undefined;
         config: import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & Omit<import("..").ArchivingModuleConfig & import("..").ModuleConfigFields & import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & {
             schema: "network.xyo.module.config";
         }, "schema"> & {
             schema: string;
         };
         ephemeralQueryAccountEnabled?: boolean | undefined;
+        moduleIdentifierTransformers?: import("..").ModuleIdentifierTransformer[] | undefined;
     }, import("..").ModuleEventData<object>>>, config?: import("@xylabs/object").TypeCheckConfig | undefined): TType_1;
 };
 //# sourceMappingURL=asModuleObject.d.ts.map

package/dist/node/module/asModuleObject.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"asModuleObject.d.ts","sourceRoot":"","sources":["../../../src/module/asModuleObject.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAyC,CAAA"}
+{"version":3,"file":"asModuleObject.d.ts","sourceRoot":"","sources":["../../../src/module/asModuleObject.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAyC,CAAA"}

package/dist/node/module/asModuleObject.d.mts

@@ -1,29 +1,35 @@
 export declare const asModuleObject: {
     <TType extends import("./Module").Module<import("@xylabs/object").BaseParamsFields & {
         account?: import("@xyo-network/account-model").AccountInstance | "random" | undefined;
+        addToResolvers?: boolean | undefined;
         config: import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & Omit<import("..").ArchivingModuleConfig & import("..").ModuleConfigFields & import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & {
             schema: "network.xyo.module.config";
         }, "schema"> & {
             schema: string;
         };
         ephemeralQueryAccountEnabled?: boolean | undefined;
+        moduleIdentifierTransformers?: import("..").ModuleIdentifierTransformer[] | undefined;
     }, import("..").ModuleEventData<object>>>(value: import("@xylabs/promise").AnyNonPromise<T_1>, config?: import("@xylabs/object").TypeCheckConfig | undefined): TType | undefined;
     <TType_1 extends import("./Module").Module<import("@xylabs/object").BaseParamsFields & {
         account?: import("@xyo-network/account-model").AccountInstance | "random" | undefined;
+        addToResolvers?: boolean | undefined;
         config: import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & Omit<import("..").ArchivingModuleConfig & import("..").ModuleConfigFields & import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & {
             schema: "network.xyo.module.config";
         }, "schema"> & {
             schema: string;
         };
         ephemeralQueryAccountEnabled?: boolean | undefined;
+        moduleIdentifierTransformers?: import("..").ModuleIdentifierTransformer[] | undefined;
     }, import("..").ModuleEventData<object>>>(value: import("@xylabs/promise").AnyNonPromise<T_1>, assert: import("@xylabs/object").StringOrAlertFunction<import("./Module").Module<import("@xylabs/object").BaseParamsFields & {
         account?: import("@xyo-network/account-model").AccountInstance | "random" | undefined;
+        addToResolvers?: boolean | undefined;
         config: import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & Omit<import("..").ArchivingModuleConfig & import("..").ModuleConfigFields & import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & {
             schema: "network.xyo.module.config";
         }, "schema"> & {
             schema: string;
         };
         ephemeralQueryAccountEnabled?: boolean | undefined;
+        moduleIdentifierTransformers?: import("..").ModuleIdentifierTransformer[] | undefined;
     }, import("..").ModuleEventData<object>>>, config?: import("@xylabs/object").TypeCheckConfig | undefined): TType_1;
 };
 //# sourceMappingURL=asModuleObject.d.ts.map

package/dist/node/module/asModuleObject.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"asModuleObject.d.ts","sourceRoot":"","sources":["../../../src/module/asModuleObject.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAyC,CAAA"}
+{"version":3,"file":"asModuleObject.d.ts","sourceRoot":"","sources":["../../../src/module/asModuleObject.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAyC,CAAA"}

package/dist/node/module/asModuleObject.d.ts

@@ -1,29 +1,35 @@
 export declare const asModuleObject: {
     <TType extends import("./Module").Module<import("@xylabs/object").BaseParamsFields & {
         account?: import("@xyo-network/account-model").AccountInstance | "random" | undefined;
+        addToResolvers?: boolean | undefined;
         config: import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & Omit<import("..").ArchivingModuleConfig & import("..").ModuleConfigFields & import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & {
             schema: "network.xyo.module.config";
         }, "schema"> & {
             schema: string;
         };
         ephemeralQueryAccountEnabled?: boolean | undefined;
+        moduleIdentifierTransformers?: import("..").ModuleIdentifierTransformer[] | undefined;
     }, import("..").ModuleEventData<object>>>(value: import("@xylabs/promise").AnyNonPromise<T_1>, config?: import("@xylabs/object").TypeCheckConfig | undefined): TType | undefined;
     <TType_1 extends import("./Module").Module<import("@xylabs/object").BaseParamsFields & {
         account?: import("@xyo-network/account-model").AccountInstance | "random" | undefined;
+        addToResolvers?: boolean | undefined;
         config: import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & Omit<import("..").ArchivingModuleConfig & import("..").ModuleConfigFields & import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & {
             schema: "network.xyo.module.config";
         }, "schema"> & {
             schema: string;
         };
         ephemeralQueryAccountEnabled?: boolean | undefined;
+        moduleIdentifierTransformers?: import("..").ModuleIdentifierTransformer[] | undefined;
     }, import("..").ModuleEventData<object>>>(value: import("@xylabs/promise").AnyNonPromise<T_1>, assert: import("@xylabs/object").StringOrAlertFunction<import("./Module").Module<import("@xylabs/object").BaseParamsFields & {
         account?: import("@xyo-network/account-model").AccountInstance | "random" | undefined;
+        addToResolvers?: boolean | undefined;
         config: import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & Omit<import("..").ArchivingModuleConfig & import("..").ModuleConfigFields & import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & {
             schema: "network.xyo.module.config";
         }, "schema"> & {
             schema: string;
         };
         ephemeralQueryAccountEnabled?: boolean | undefined;
+        moduleIdentifierTransformers?: import("..").ModuleIdentifierTransformer[] | undefined;
     }, import("..").ModuleEventData<object>>>, config?: import("@xylabs/object").TypeCheckConfig | undefined): TType_1;
 };
 //# sourceMappingURL=asModuleObject.d.ts.map

package/dist/node/module/asModuleObject.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"asModuleObject.d.ts","sourceRoot":"","sources":["../../../src/module/asModuleObject.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAyC,CAAA"}
+{"version":3,"file":"asModuleObject.d.ts","sourceRoot":"","sources":["../../../src/module/asModuleObject.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAyC,CAAA"}

package/dist/node/module/isModuleObject.d.cts

@@ -3,11 +3,13 @@ import { Module } from './Module';
 export declare const requiredModuleShape: ObjectTypeShape;
 export declare const isModuleObject: import("@xylabs/object").TypeCheck<Module<import("@xylabs/object").BaseParamsFields & {
     account?: import("@xyo-network/account-model").AccountInstance | "random" | undefined;
+    addToResolvers?: boolean | undefined;
     config: import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & Omit<import("..").ArchivingModuleConfig & import("..").ModuleConfigFields & import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & {
         schema: "network.xyo.module.config";
     }, "schema"> & {
         schema: string;
     };
     ephemeralQueryAccountEnabled?: boolean | undefined;
+    moduleIdentifierTransformers?: import("..").ModuleIdentifierTransformer[] | undefined;
 }, import("..").ModuleEventData<object>>>;
 //# sourceMappingURL=isModuleObject.d.ts.map

package/dist/node/module/isModuleObject.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"isModuleObject.d.ts","sourceRoot":"","sources":["../../../src/module/isModuleObject.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAEjE,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAEjC,eAAO,MAAM,mBAAmB,EAAE,eAIjC,CAAA;AAID,eAAO,MAAM,cAAc;;;;;;;;yCAAsC,CAAA"}
+{"version":3,"file":"isModuleObject.d.ts","sourceRoot":"","sources":["../../../src/module/isModuleObject.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAEjE,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAEjC,eAAO,MAAM,mBAAmB,EAAE,eAIjC,CAAA;AAID,eAAO,MAAM,cAAc;;;;;;;;;;yCAAsC,CAAA"}

package/dist/node/module/isModuleObject.d.mts

@@ -3,11 +3,13 @@ import { Module } from './Module';
 export declare const requiredModuleShape: ObjectTypeShape;
 export declare const isModuleObject: import("@xylabs/object").TypeCheck<Module<import("@xylabs/object").BaseParamsFields & {
     account?: import("@xyo-network/account-model").AccountInstance | "random" | undefined;
+    addToResolvers?: boolean | undefined;
     config: import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & Omit<import("..").ArchivingModuleConfig & import("..").ModuleConfigFields & import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & {
         schema: "network.xyo.module.config";
     }, "schema"> & {
         schema: string;
     };
     ephemeralQueryAccountEnabled?: boolean | undefined;
+    moduleIdentifierTransformers?: import("..").ModuleIdentifierTransformer[] | undefined;
 }, import("..").ModuleEventData<object>>>;
 //# sourceMappingURL=isModuleObject.d.ts.map

package/dist/node/module/isModuleObject.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"isModuleObject.d.ts","sourceRoot":"","sources":["../../../src/module/isModuleObject.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAEjE,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAEjC,eAAO,MAAM,mBAAmB,EAAE,eAIjC,CAAA;AAID,eAAO,MAAM,cAAc;;;;;;;;yCAAsC,CAAA"}
+{"version":3,"file":"isModuleObject.d.ts","sourceRoot":"","sources":["../../../src/module/isModuleObject.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAEjE,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAEjC,eAAO,MAAM,mBAAmB,EAAE,eAIjC,CAAA;AAID,eAAO,MAAM,cAAc;;;;;;;;;;yCAAsC,CAAA"}

package/dist/node/module/isModuleObject.d.ts

@@ -3,11 +3,13 @@ import { Module } from './Module';
 export declare const requiredModuleShape: ObjectTypeShape;
 export declare const isModuleObject: import("@xylabs/object").TypeCheck<Module<import("@xylabs/object").BaseParamsFields & {
     account?: import("@xyo-network/account-model").AccountInstance | "random" | undefined;
+    addToResolvers?: boolean | undefined;
     config: import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & Omit<import("..").ArchivingModuleConfig & import("..").ModuleConfigFields & import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & {
         schema: "network.xyo.module.config";
     }, "schema"> & {
         schema: string;
     };
     ephemeralQueryAccountEnabled?: boolean | undefined;
+    moduleIdentifierTransformers?: import("..").ModuleIdentifierTransformer[] | undefined;
 }, import("..").ModuleEventData<object>>>;
 //# sourceMappingURL=isModuleObject.d.ts.map

package/dist/node/module/isModuleObject.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isModuleObject.d.ts","sourceRoot":"","sources":["../../../src/module/isModuleObject.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAEjE,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAEjC,eAAO,MAAM,mBAAmB,EAAE,eAIjC,CAAA;AAID,eAAO,MAAM,cAAc;;;;;;;;yCAAsC,CAAA"}
+{"version":3,"file":"isModuleObject.d.ts","sourceRoot":"","sources":["../../../src/module/isModuleObject.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAEjE,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAEjC,eAAO,MAAM,mBAAmB,EAAE,eAIjC,CAAA;AAID,eAAO,MAAM,cAAc;;;;;;;;;;yCAAsC,CAAA"}

package/dist/node/withModule.d.cts

@@ -4,20 +4,24 @@ export declare const WithFactory: {
 };
 export declare const withModule: <R>(module: any, closure: (module: import("./module").Module<import("@xylabs/object").BaseParamsFields & {
     account?: import("@xyo-network/account-model").AccountInstance | "random" | undefined;
+    addToResolvers?: boolean | undefined;
     config: import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & Omit<import("./Config").ArchivingModuleConfig & import("./Config").ModuleConfigFields & import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & {
         schema: "network.xyo.module.config";
     }, "schema"> & {
         schema: string;
     };
     ephemeralQueryAccountEnabled?: boolean | undefined;
+    moduleIdentifierTransformers?: import("./ModuleIdentifierTransformer").ModuleIdentifierTransformer[] | undefined;
 }, import("./EventsModels").ModuleEventData<object>>) => R) => R | undefined;
 export declare const withModuleInstance: <R>(module: any, closure: (module: import("./instance").ModuleInstance<import("@xylabs/object").BaseParamsFields & {
     account?: import("@xyo-network/account-model").AccountInstance | "random" | undefined;
+    addToResolvers?: boolean | undefined;
     config: import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & Omit<import("./Config").ArchivingModuleConfig & import("./Config").ModuleConfigFields & import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & {
         schema: "network.xyo.module.config";
     }, "schema"> & {
         schema: string;
     };
     ephemeralQueryAccountEnabled?: boolean | undefined;
+    moduleIdentifierTransformers?: import("./ModuleIdentifierTransformer").ModuleIdentifierTransformer[] | undefined;
 }, import("./EventsModels").ModuleEventData<object>>) => R) => R | undefined;
 //# sourceMappingURL=withModule.d.ts.map

package/dist/node/withModule.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"withModule.d.ts","sourceRoot":"","sources":["../../src/withModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAK1C,eAAO,MAAM,WAAW;0CACgB,UAAU,CAAC,CAAC,iBAGtC,GAAG,oBAEO,CAAC,KAAK,CAAC,KACxB,CAAC,GAAG,SAAS;CAInB,CAAA;AAED,eAAO,MAAM,UAAU,cATT,GAAG;;;;;;;;4EASqC,CAAA;AACtD,eAAO,MAAM,kBAAkB,cAVjB,GAAG;;;;;;;;4EAUqD,CAAA"}
+{"version":3,"file":"withModule.d.ts","sourceRoot":"","sources":["../../src/withModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAK1C,eAAO,MAAM,WAAW;0CACgB,UAAU,CAAC,CAAC,iBAGtC,GAAG,oBAEO,CAAC,KAAK,CAAC,KACxB,CAAC,GAAG,SAAS;CAInB,CAAA;AAED,eAAO,MAAM,UAAU,cATT,GAAG;;;;;;;;;;4EASqC,CAAA;AACtD,eAAO,MAAM,kBAAkB,cAVjB,GAAG;;;;;;;;;;4EAUqD,CAAA"}

package/dist/node/withModule.d.mts

@@ -4,20 +4,24 @@ export declare const WithFactory: {
 };
 export declare const withModule: <R>(module: any, closure: (module: import("./module").Module<import("@xylabs/object").BaseParamsFields & {
     account?: import("@xyo-network/account-model").AccountInstance | "random" | undefined;
+    addToResolvers?: boolean | undefined;
     config: import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & Omit<import("./Config").ArchivingModuleConfig & import("./Config").ModuleConfigFields & import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & {
         schema: "network.xyo.module.config";
     }, "schema"> & {
         schema: string;
     };
     ephemeralQueryAccountEnabled?: boolean | undefined;
+    moduleIdentifierTransformers?: import("./ModuleIdentifierTransformer").ModuleIdentifierTransformer[] | undefined;
 }, import("./EventsModels").ModuleEventData<object>>) => R) => R | undefined;
 export declare const withModuleInstance: <R>(module: any, closure: (module: import("./instance").ModuleInstance<import("@xylabs/object").BaseParamsFields & {
     account?: import("@xyo-network/account-model").AccountInstance | "random" | undefined;
+    addToResolvers?: boolean | undefined;
     config: import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & Omit<import("./Config").ArchivingModuleConfig & import("./Config").ModuleConfigFields & import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & {
         schema: "network.xyo.module.config";
     }, "schema"> & {
         schema: string;
     };
     ephemeralQueryAccountEnabled?: boolean | undefined;
+    moduleIdentifierTransformers?: import("./ModuleIdentifierTransformer").ModuleIdentifierTransformer[] | undefined;
 }, import("./EventsModels").ModuleEventData<object>>) => R) => R | undefined;
 //# sourceMappingURL=withModule.d.ts.map

package/dist/node/withModule.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"withModule.d.ts","sourceRoot":"","sources":["../../src/withModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAK1C,eAAO,MAAM,WAAW;0CACgB,UAAU,CAAC,CAAC,iBAGtC,GAAG,oBAEO,CAAC,KAAK,CAAC,KACxB,CAAC,GAAG,SAAS;CAInB,CAAA;AAED,eAAO,MAAM,UAAU,cATT,GAAG;;;;;;;;4EASqC,CAAA;AACtD,eAAO,MAAM,kBAAkB,cAVjB,GAAG;;;;;;;;4EAUqD,CAAA"}
+{"version":3,"file":"withModule.d.ts","sourceRoot":"","sources":["../../src/withModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAK1C,eAAO,MAAM,WAAW;0CACgB,UAAU,CAAC,CAAC,iBAGtC,GAAG,oBAEO,CAAC,KAAK,CAAC,KACxB,CAAC,GAAG,SAAS;CAInB,CAAA;AAED,eAAO,MAAM,UAAU,cATT,GAAG;;;;;;;;;;4EASqC,CAAA;AACtD,eAAO,MAAM,kBAAkB,cAVjB,GAAG;;;;;;;;;;4EAUqD,CAAA"}

package/dist/node/withModule.d.ts

@@ -4,20 +4,24 @@ export declare const WithFactory: {
 };
 export declare const withModule: <R>(module: any, closure: (module: import("./module").Module<import("@xylabs/object").BaseParamsFields & {
     account?: import("@xyo-network/account-model").AccountInstance | "random" | undefined;
+    addToResolvers?: boolean | undefined;
     config: import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & Omit<import("./Config").ArchivingModuleConfig & import("./Config").ModuleConfigFields & import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & {
         schema: "network.xyo.module.config";
     }, "schema"> & {
         schema: string;
     };
     ephemeralQueryAccountEnabled?: boolean | undefined;
+    moduleIdentifierTransformers?: import("./ModuleIdentifierTransformer").ModuleIdentifierTransformer[] | undefined;
 }, import("./EventsModels").ModuleEventData<object>>) => R) => R | undefined;
 export declare const withModuleInstance: <R>(module: any, closure: (module: import("./instance").ModuleInstance<import("@xylabs/object").BaseParamsFields & {
     account?: import("@xyo-network/account-model").AccountInstance | "random" | undefined;
+    addToResolvers?: boolean | undefined;
     config: import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & Omit<import("./Config").ArchivingModuleConfig & import("./Config").ModuleConfigFields & import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & {
         schema: "network.xyo.module.config";
     }, "schema"> & {
         schema: string;
     };
     ephemeralQueryAccountEnabled?: boolean | undefined;
+    moduleIdentifierTransformers?: import("./ModuleIdentifierTransformer").ModuleIdentifierTransformer[] | undefined;
 }, import("./EventsModels").ModuleEventData<object>>) => R) => R | undefined;
 //# sourceMappingURL=withModule.d.ts.map

package/dist/node/withModule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"withModule.d.ts","sourceRoot":"","sources":["../../src/withModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAK1C,eAAO,MAAM,WAAW;0CACgB,UAAU,CAAC,CAAC,iBAGtC,GAAG,oBAEO,CAAC,KAAK,CAAC,KACxB,CAAC,GAAG,SAAS;CAInB,CAAA;AAED,eAAO,MAAM,UAAU,cATT,GAAG;;;;;;;;4EASqC,CAAA;AACtD,eAAO,MAAM,kBAAkB,cAVjB,GAAG;;;;;;;;4EAUqD,CAAA"}
+{"version":3,"file":"withModule.d.ts","sourceRoot":"","sources":["../../src/withModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAK1C,eAAO,MAAM,WAAW;0CACgB,UAAU,CAAC,CAAC,iBAGtC,GAAG,oBAEO,CAAC,KAAK,CAAC,KACxB,CAAC,GAAG,SAAS;CAInB,CAAA;AAED,eAAO,MAAM,UAAU,cATT,GAAG;;;;;;;;;;4EASqC,CAAA;AACtD,eAAO,MAAM,kBAAkB,cAVjB,GAAG;;;;;;;;;;4EAUqD,CAAA"}

package/package.json

@@ -17,12 +17,12 @@
     "@xylabs/object": "^3.0.24",
     "@xylabs/promise": "^3.0.24",
     "@xylabs/retry": "^3.0.24",
-    "@xyo-network/account-model": "~2.93.3",
-    "@xyo-network/address-payload-plugin": "~2.93.3",
-    "@xyo-network/boundwitness-model": "~2.93.3",
-    "@xyo-network/manifest-model": "~2.93.3",
-    "@xyo-network/module-events": "~2.93.3",
-    "@xyo-network/payload-model": "~2.93.3"
+    "@xyo-network/account-model": "~2.93.5",
+    "@xyo-network/address-payload-plugin": "~2.93.5",
+    "@xyo-network/boundwitness-model": "~2.93.5",
+    "@xyo-network/manifest-model": "~2.93.5",
+    "@xyo-network/module-events": "~2.93.5",
+    "@xyo-network/payload-model": "~2.93.5"
   },
   "devDependencies": {
     "@xylabs/ts-scripts-yarn3": "^3.5.2",
@@ -68,6 +68,6 @@
     "url": "https://github.com/XYOracleNetwork/sdk-xyo-client-js.git"
   },
   "sideEffects": false,
-  "version": "2.93.3",
+  "version": "2.93.5",
   "type": "module"
 }

package/src/CreatableModule/CreatableModule.ts

@@ -1,20 +1,23 @@
 import { Logger } from '@xylabs/logger'
 import { AccountInstance } from '@xyo-network/account-model'
 
-import { ModuleInstance } from '../instance'
+import { AttachableModuleInstance } from '../instance'
 
-export type CreatableModuleFactory<T extends ModuleInstance = ModuleInstance> = Omit<Omit<CreatableModule<T>, 'new'>, 'create'> & {
-  create<T extends ModuleInstance>(this: CreatableModuleFactory<T>, params?: T['params']): Promise<T>
+export type CreatableModuleFactory<T extends AttachableModuleInstance = AttachableModuleInstance> = Omit<
+  Omit<CreatableModule<T>, 'new'>,
+  'create'
+> & {
+  create<T extends AttachableModuleInstance>(this: CreatableModuleFactory<T>, params?: T['params']): Promise<T>
 }
 
-export interface CreatableModule<T extends ModuleInstance = ModuleInstance> {
+export interface CreatableModule<T extends AttachableModuleInstance = AttachableModuleInstance> {
   configSchema: string
   configSchemas: string[]
   defaultLogger?: Logger
   new (privateConstructorKey: string, params: T['params'], account: AccountInstance): T
   _noOverride(functionName: string): void
-  create<T extends ModuleInstance>(this: CreatableModule<T>, params?: T['params']): Promise<T>
-  factory<T extends ModuleInstance>(this: CreatableModule<T>, params?: T['params']): CreatableModuleFactory<T>
+  create<T extends AttachableModuleInstance>(this: CreatableModule<T>, params?: T['params']): Promise<T>
+  factory<T extends AttachableModuleInstance>(this: CreatableModule<T>, params?: T['params']): CreatableModuleFactory<T>
 }
 
 /**
@@ -23,7 +26,7 @@ export interface CreatableModule<T extends ModuleInstance = ModuleInstance> {
  * @returns The decorated Module requiring it implement the members
  * of the CreatableModule as statics properties/methods
  */
-export function creatableModule<TModule extends ModuleInstance = ModuleInstance>() {
+export function creatableModule<TModule extends AttachableModuleInstance = AttachableModuleInstance>() {
   return <U extends CreatableModule<TModule>>(constructor: U) => {
     constructor
   }

package/src/CreatableModule/LabeledCreatableModuleFactory.ts

@@ -1,8 +1,9 @@
-import { ModuleInstance } from '../instance'
+import { AttachableModuleInstance } from '../instance'
 import { WithOptionalLabels } from '../Labels'
 import { CreatableModuleFactory } from './CreatableModule'
 
-export type LabeledCreatableModuleFactory<T extends ModuleInstance = ModuleInstance> = CreatableModuleFactory<T> & WithOptionalLabels
+export type LabeledCreatableModuleFactory<T extends AttachableModuleInstance = AttachableModuleInstance> = CreatableModuleFactory<T> &
+  WithOptionalLabels
 
 export const hasLabels = (factory: CreatableModuleFactory | LabeledCreatableModuleFactory): factory is LabeledCreatableModuleFactory => {
   return (factory as LabeledCreatableModuleFactory).labels !== undefined

package/src/CreatableModule/ModuleFactory.ts

@@ -2,11 +2,11 @@ import { assertEx } from '@xylabs/assert'
 import { merge } from '@xylabs/lodash'
 import { Logger } from '@xylabs/logger'
 
-import { ModuleInstance } from '../instance'
+import { AttachableModuleInstance } from '../instance'
 import { Labels, WithOptionalLabels } from '../Labels'
 import { CreatableModule, CreatableModuleFactory } from './CreatableModule'
 
-export class ModuleFactory<TModule extends ModuleInstance> implements CreatableModuleFactory<TModule> {
+export class ModuleFactory<TModule extends AttachableModuleInstance> implements CreatableModuleFactory<TModule> {
   configSchemas: CreatableModuleFactory<TModule>['configSchemas']
 
   creatableModule: CreatableModule<TModule>
@@ -32,7 +32,7 @@ export class ModuleFactory<TModule extends ModuleInstance> implements CreatableM
     return this.configSchemas[0]
   }
 
-  static withParams<T extends ModuleInstance>(
+  static withParams<T extends AttachableModuleInstance>(
     creatableModule: CreatableModule<T>,
     params?: Omit<T['params'], 'config'> & { config?: T['params']['config'] },
     labels: Labels = {},
@@ -57,7 +57,7 @@ export class ModuleFactory<TModule extends ModuleInstance> implements CreatableM
     assertEx(thisFunc === rootFunc, () => `Override not allowed for [${functionName}] - override ${functionName}Handler instead`)
   }
 
-  create<T extends ModuleInstance>(this: CreatableModuleFactory<T>, params?: TModule['params'] | undefined): Promise<T> {
+  create<T extends AttachableModuleInstance>(this: CreatableModuleFactory<T>, params?: TModule['params'] | undefined): Promise<T> {
     const factory = this as ModuleFactory<T>
     const schema = factory.creatableModule.configSchema
     const mergedParams: TModule['params'] = merge({}, factory.defaultParams, params, {
@@ -66,7 +66,7 @@ export class ModuleFactory<TModule extends ModuleInstance> implements CreatableM
     return factory.creatableModule.create<T>(mergedParams)
   }
 
-  factory<T extends ModuleInstance>(this: CreatableModule<T>, _params?: T['params'] | undefined): CreatableModuleFactory<T> {
+  factory<T extends AttachableModuleInstance>(this: CreatableModule<T>, _params?: T['params'] | undefined): CreatableModuleFactory<T> {
     throw new Error('Method not implemented.')
   }
 }

package/src/CreatableModule/ModuleFactoryLocator.ts

@@ -1,6 +1,6 @@
 import { assertEx } from '@xylabs/assert'
 
-import { ModuleInstance } from '../instance'
+import { AttachableModuleInstance, ModuleInstance } from '../instance'
 import { hasAllLabels, Labels } from '../Labels'
 import { CreatableModuleFactory } from './CreatableModule'
 import { CreatableModuleRegistry } from './CreatableModuleRegistry'
@@ -37,7 +37,7 @@ export class ModuleFactoryLocator {
    * Registers a single module factory (with optional tags) with the locator
    * @param additional Additional module factories to register
    */
-  register<TModule extends ModuleInstance>(mod: CreatableModuleFactory<TModule>, labels?: Labels): this {
+  register<TModule extends AttachableModuleInstance>(mod: CreatableModuleFactory<TModule>, labels?: Labels): this {
     mod.configSchemas.map((schema) => {
       const existingFactories = this._registry[schema]
       const factory: LabeledCreatableModuleFactory<TModule> = {

package/src/ModuleIdentifierTransformer.ts

@@ -0,0 +1,9 @@
+import { Promisable } from '@xylabs/promise'
+
+import { ModuleIdentifier } from './ModuleIdentifier'
+
+export type ModuleIdentifierTransformerFunc = (id: ModuleIdentifier) => Promisable<ModuleIdentifier>
+
+export interface ModuleIdentifierTransformer {
+  transform: ModuleIdentifierTransformerFunc
+}

package/src/ModuleParams.ts

@@ -2,6 +2,7 @@ import { BaseParams, EmptyObject, WithAdditional } from '@xylabs/object'
 import { AccountInstance } from '@xyo-network/account-model'
 
 import { AnyConfigSchema, ModuleConfig } from './Config'
+import { ModuleIdentifierTransformer } from './ModuleIdentifierTransformer'
 
 export type ModuleParams<
   TConfig extends AnyConfigSchema<ModuleConfig> | void = void,
@@ -9,8 +10,10 @@ export type ModuleParams<
 > = WithAdditional<
   BaseParams<{
     account?: AccountInstance | 'random'
+    addToResolvers?: boolean
     config: TConfig extends AnyConfigSchema<ModuleConfig> ? TConfig : AnyConfigSchema<ModuleConfig>
     ephemeralQueryAccountEnabled?: boolean
+    moduleIdentifierTransformers?: ModuleIdentifierTransformer[]
   }>,
   TAdditionalParams
 >

package/src/index.ts

@@ -8,6 +8,7 @@ export * from './lib'
 export * from './module'
 export * from './ModuleDescription'
 export * from './ModuleIdentifier'
+export * from './ModuleIdentifierTransformer'
 export * from './ModuleParams'
 export * from './ModuleQueryHandlerResult'
 export * from './ModuleQueryResult'

package/src/instance/Instance.ts

@@ -4,7 +4,7 @@ import { ModuleEventData } from '../EventsModels'
 import { Module, ModuleQueryFunctions } from '../module'
 import { ModuleIdentifier } from '../ModuleIdentifier'
 import { ModuleParams } from '../ModuleParams'
-import { ObjectResolver, ObjectResolverInstance } from './ObjectResolver'
+import { ObjectResolver } from './ObjectResolver'
 
 export type ModulePipeLine = Lowercase<'one-to-one' | 'one-to-many' | 'many-to-one' | 'many-to-many'>
 
@@ -27,17 +27,10 @@ export interface ModuleInstance<TParams extends ModuleParams = ModuleParams, TEv
   extends Module<TParams, TEventData>,
     ObjectResolver<ModuleInstance>,
     ModuleQueryFunctions {
-  /* The resolver is a 'down' resolver.  It can resolve the module or any children (if it is a node for example), that are in the module*/
-  readonly downResolver: Omit<ObjectResolverInstance<ModuleInstance>, 'resolve'>
-
   readonly pipeline?: ModulePipeLine
 
   //if the module has become non-functional, such as a broken bridge connection, this will be 'dead'
   readonly status: ModuleStatus
-
-  /* The resolver is a 'up' resolver.  It can resolve the parent or any children of the parent*/
-  /* This is set by a NodeModule when attaching to the module */
-  readonly upResolver: Omit<ObjectResolverInstance<ModuleInstance>, 'resolve'>
 }
 
 export type InstanceTypeCheck<T extends ModuleInstance = ModuleInstance> = TypeCheck<T>

package/src/instance/ModuleResolver.ts

@@ -1,11 +1,20 @@
+import { Address } from '@xylabs/hex'
+import { Promisable } from '@xylabs/promise'
+
+import { ModuleIdentifier } from '../ModuleIdentifier'
 import { ModuleInstance } from './Instance'
+import { ObjectFilterOptions } from './ObjectFilter'
 import { isObjectResolver, ObjectResolver } from './ObjectResolver'
 
 export const isModuleResolver = isObjectResolver<ModuleInstance>
 
 export interface ModuleResolver<TResult extends ModuleInstance = ModuleInstance> extends ObjectResolver<TResult> {}
 
-export interface ModuleResolverInstance<TResult extends ModuleInstance = ModuleInstance> extends ModuleResolver<TResult> {
+export interface ModuleNameResolver {
+  resolveIdentifier(id: ModuleIdentifier, options?: ObjectFilterOptions): Promisable<Address | undefined>
+}
+
+export interface ModuleResolverInstance<TResult extends ModuleInstance = ModuleInstance> extends ModuleResolver<TResult>, ModuleNameResolver {
   addResolver: (resolver: ModuleResolverInstance<TResult>) => this
   removeResolver: (resolver: ModuleResolverInstance<TResult>) => this
 }

package/src/instance/attachable/AttachableInstance.ts

@@ -0,0 +1,20 @@
+import { IsObjectFactory, TypeCheck } from '@xylabs/object'
+
+import { ModuleEventData } from '../../EventsModels'
+import { ModuleParams } from '../../ModuleParams'
+import { ModuleInstance } from '../Instance'
+import { ModuleResolverInstance } from '../ModuleResolver'
+
+export interface AttachableModuleInstance<TParams extends ModuleParams = ModuleParams, TEventData extends ModuleEventData = ModuleEventData>
+  extends ModuleInstance<TParams, TEventData> {
+  /* The resolver is a 'down' resolver.  It can resolve the module or any children (if it is a node for example), that are in the module*/
+  readonly downResolver: ModuleResolverInstance
+
+  /* The resolver is a 'up' resolver.  It can resolve the parent or any children of the parent*/
+  /* This is set by a NodeModule when attaching to the module */
+  readonly upResolver: ModuleResolverInstance
+}
+
+export type AttachableModuleInstanceTypeCheck<T extends AttachableModuleInstance = AttachableModuleInstance> = TypeCheck<T>
+
+export class IsAttachableModuleInstanceFactory<T extends AttachableModuleInstance = AttachableModuleInstance> extends IsObjectFactory<T> {}

package/src/instance/attachable/asAttachableInstance.ts

@@ -0,0 +1,5 @@
+import { AsObjectFactory } from '@xylabs/object'
+
+import { isAttachableModuleInstance } from './isAttachableInstance'
+
+export const asAttachableModuleInstance = AsObjectFactory.create(isAttachableModuleInstance)

package/src/instance/attachable/index.ts

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