@xyo-network/module-model 6.1.0 → 7.0.1

package/dist/neutral/index.mjs

@@ -1,8 +1,68 @@
+// src/Config/Archiving.ts
+import * as z from "zod/mini";
+var ArchivingModuleConfigZod = z.object({
+  archiving: z.optional(z.object({
+    archivists: z.optional(z.array(z.custom())),
+    queries: z.optional(z.array(z.custom()))
+  }))
+});
+
 // src/Config/Config.ts
 import {
-  asSchema
+  zodAsFactory,
+  zodIsFactory,
+  zodToFactory
+} from "@xylabs/sdk-js";
+import {
+  asSchema,
+  PayloadZod
 } from "@xyo-network/sdk-protocol-js";
+import * as z4 from "zod/mini";
+
+// src/Config/Fields.ts
+import * as z2 from "zod/mini";
+var ModuleConfigFieldsZod = z2.object({
+  allowedQueries: z2.optional(z2.array(z2.custom())),
+  archivist: z2.optional(z2.custom()),
+  labels: z2.optional(z2.custom()),
+  logLevel: z2.optional(z2.custom()),
+  name: z2.optional(z2.custom()),
+  paging: z2.optional(z2.record(z2.string(), z2.object({ size: z2.optional(z2.number()) }))),
+  retry: z2.optional(z2.custom()),
+  security: z2.optional(z2.custom()),
+  sign: z2.optional(z2.boolean()),
+  storeQueries: z2.optional(z2.boolean()),
+  timeBudget: z2.optional(z2.number()),
+  timestamp: z2.optional(z2.boolean())
+});
+
+// src/Config/Reentrancy.ts
+import * as z3 from "zod/mini";
+var ArchivingReentrancyConfigZod = z3.object({
+  reentrancy: z3.optional(z3.object({
+    action: z3.union([z3.literal("skip"), z3.literal("wait")]),
+    scope: z3.literal("global")
+  }))
+});
+
+// src/Config/Config.ts
 var ModuleConfigSchema = asSchema("network.xyo.module.config", true);
+var ModuleConfigZod = z4.extend(PayloadZod, {
+  ...ModuleConfigFieldsZod.shape,
+  ...ArchivingModuleConfigZod.shape,
+  ...ArchivingReentrancyConfigZod.shape
+});
+var isModuleConfig = zodIsFactory(ModuleConfigZod);
+var asModuleConfig = zodAsFactory(ModuleConfigZod, "asModuleConfig");
+var toModuleConfig = zodToFactory(ModuleConfigZod, "toModuleConfig");
+
+// src/Config/Security.ts
+import * as z5 from "zod/mini";
+var ModuleSecurityConfigZod = z5.object({
+  allowAnonymous: z5.optional(z5.boolean()),
+  allowed: z5.optional(z5.record(z5.custom(), z5.array(z5.custom()))),
+  disallowed: z5.optional(z5.record(z5.custom(), z5.array(z5.custom())))
+});
 
 // src/CreatableModule/CreatableModule.ts
 function creatableModule() {
@@ -148,22 +208,87 @@ import { IsObjectFactory as IsObjectFactory2 } from "@xylabs/sdk-js";
 import { AsObjectFactory as AsObjectFactory2 } from "@xylabs/sdk-js";
 
 // src/Queries/Manifest.ts
-import { asSchema as asSchema3 } from "@xyo-network/sdk-protocol-js";
+import {
+  zodAsFactory as zodAsFactory2,
+  zodIsFactory as zodIsFactory2,
+  zodToFactory as zodToFactory2
+} from "@xylabs/sdk-js";
+import {
+  asSchema as asSchema3,
+  PayloadZodOfSchema,
+  QueryFieldsZod
+} from "@xyo-network/sdk-protocol-js";
+import * as z6 from "zod/mini";
 var ModuleManifestQuerySchema = asSchema3("network.xyo.query.module.manifest", true);
+var ModuleManifestQueryZod = z6.extend(PayloadZodOfSchema(ModuleManifestQuerySchema), {
+  ...QueryFieldsZod.shape,
+  maxDepth: z6.optional(z6.number())
+});
+var isModuleManifestQuery = zodIsFactory2(ModuleManifestQueryZod);
+var asModuleManifestQuery = zodAsFactory2(ModuleManifestQueryZod, "asModuleManifestQuery");
+var toModuleManifestQuery = zodToFactory2(ModuleManifestQueryZod, "toModuleManifestQuery");
 
 // src/Queries/ModuleAddress/Query.ts
-import { asSchema as asSchema4 } from "@xyo-network/sdk-protocol-js";
+import {
+  zodAsFactory as zodAsFactory3,
+  zodIsFactory as zodIsFactory3,
+  zodToFactory as zodToFactory3
+} from "@xylabs/sdk-js";
+import {
+  asSchema as asSchema4,
+  PayloadZodOfSchema as PayloadZodOfSchema2,
+  QueryFieldsZod as QueryFieldsZod2
+} from "@xyo-network/sdk-protocol-js";
+import * as z7 from "zod/mini";
 var ModuleAddressQuerySchema = asSchema4("network.xyo.query.module.address", true);
+var ModuleAddressQueryZod = z7.extend(PayloadZodOfSchema2(ModuleAddressQuerySchema), { ...QueryFieldsZod2.shape });
+var isModuleAddressQuery = zodIsFactory3(ModuleAddressQueryZod);
+var asModuleAddressQuery = zodAsFactory3(ModuleAddressQueryZod, "asModuleAddressQuery");
+var toModuleAddressQuery = zodToFactory3(ModuleAddressQueryZod, "toModuleAddressQuery");
 
 // src/Queries/State.ts
-import { asSchema as asSchema5 } from "@xyo-network/sdk-protocol-js";
+import {
+  zodAsFactory as zodAsFactory4,
+  zodIsFactory as zodIsFactory4,
+  zodToFactory as zodToFactory4
+} from "@xylabs/sdk-js";
+import {
+  asSchema as asSchema5,
+  PayloadZodOfSchema as PayloadZodOfSchema3,
+  QueryFieldsZod as QueryFieldsZod3
+} from "@xyo-network/sdk-protocol-js";
+import * as z8 from "zod/mini";
 var ModuleStateQuerySchema = asSchema5("network.xyo.query.module.state", true);
+var ModuleStateQueryZod = z8.extend(PayloadZodOfSchema3(ModuleStateQuerySchema), { ...QueryFieldsZod3.shape });
+var isModuleStateQuery = zodIsFactory4(ModuleStateQueryZod);
+var asModuleStateQuery = zodAsFactory4(ModuleStateQueryZod, "asModuleStateQuery");
+var toModuleStateQuery = zodToFactory4(ModuleStateQueryZod, "toModuleStateQuery");
 
 // src/Queries/Subscribe.ts
 import {
-  asSchema as asSchema6
+  zodAsFactory as zodAsFactory5,
+  zodIsFactory as zodIsFactory5,
+  zodToFactory as zodToFactory5
+} from "@xylabs/sdk-js";
+import {
+  asSchema as asSchema6,
+  PayloadZodOfSchema as PayloadZodOfSchema4,
+  QueryFieldsZod as QueryFieldsZod4
 } from "@xyo-network/sdk-protocol-js";
+import * as z9 from "zod/mini";
 var ModuleSubscribeQuerySchema = asSchema6("network.xyo.query.module.subscribe", true);
+var ModuleSubscribeQueryZod = z9.extend(PayloadZodOfSchema4(ModuleSubscribeQuerySchema), {
+  ...QueryFieldsZod4.shape,
+  /** @field The address that will receive notifications */
+  address: z9.custom(),
+  /** @field A subscribe with a null for filter is an unsubscribe */
+  filter: z9.optional(z9.nullable(z9.custom())),
+  /** @field The maximum events queued per send [may increase frequency] */
+  maxQueue: z9.optional(z9.number())
+});
+var isModuleSubscribeQuery = zodIsFactory5(ModuleSubscribeQueryZod);
+var asModuleSubscribeQuery = zodAsFactory5(ModuleSubscribeQueryZod, "asModuleSubscribeQuery");
+var toModuleSubscribeQuery = zodToFactory5(ModuleSubscribeQueryZod, "toModuleSubscribeQuery");
 
 // src/QueryableModule/asQueryableModuleObject.ts
 import { AsObjectFactory } from "@xylabs/sdk-js";
@@ -295,8 +420,8 @@ var ModuleLimitationLabelName = "network.xyo.module.limitation";
 var ModuleLimitationViewLabel = { ModuleLimitationLabelName: "view" };
 
 // src/lib/duplicateModules.ts
-var duplicateModules = (value, index, array) => {
-  return array.findIndex((v) => v.address === value.address) === index;
+var duplicateModules = (value, index, array4) => {
+  return array4.findIndex((v) => v.address === value.address) === index;
 };
 
 // src/lib/serializable.ts
@@ -372,43 +497,88 @@ var isModuleIdentifierPart = (value) => {
 };
 
 // src/Payload/Address.ts
-import { AsObjectFactory as AsObjectFactory5 } from "@xylabs/sdk-js";
+import {
+  zodAsFactory as zodAsFactory6,
+  zodIsFactory as zodIsFactory6,
+  zodToFactory as zodToFactory6
+} from "@xylabs/sdk-js";
 import {
   asSchema as asSchema7,
-  isPayloadOfSchemaType
+  PayloadZodOfSchema as PayloadZodOfSchema5
 } from "@xyo-network/sdk-protocol-js";
+import * as z10 from "zod/mini";
 var AddressSchema = asSchema7("network.xyo.address", true);
 var AddressChildSchema = asSchema7("network.xyo.address.child", true);
-var isAddressPayload = isPayloadOfSchemaType(AddressSchema);
-var asAddressPayload = AsObjectFactory5.create(isAddressPayload);
-var asOptionalAddressPayload = AsObjectFactory5.createOptional(isAddressPayload);
+var AddressPayloadZod = z10.extend(PayloadZodOfSchema5(AddressSchema), { address: z10.custom() });
+var isAddressPayload = zodIsFactory6(AddressPayloadZod);
+var asAddressPayload = zodAsFactory6(AddressPayloadZod, "asAddressPayload");
+var toAddressPayload = zodToFactory6(AddressPayloadZod, "toAddressPayload");
+var asOptionalAddressPayload = asAddressPayload;
+var AddressChildPayloadZod = z10.extend(PayloadZodOfSchema5(AddressChildSchema), {
+  address: z10.custom(),
+  path: z10.optional(z10.string()),
+  root: z10.optional(z10.custom())
+});
+var isAddressChildPayload = zodIsFactory6(AddressChildPayloadZod);
+var asAddressChildPayload = zodAsFactory6(AddressChildPayloadZod, "asAddressChildPayload");
+var toAddressChildPayload = zodToFactory6(AddressChildPayloadZod, "toAddressChildPayload");
 
 // src/Payload/AddressPreviousHash.ts
 import {
-  asSchema as asSchema8
+  zodAsFactory as zodAsFactory7,
+  zodIsFactory as zodIsFactory7,
+  zodToFactory as zodToFactory7
+} from "@xylabs/sdk-js";
+import {
+  asSchema as asSchema8,
+  PayloadZodOfSchema as PayloadZodOfSchema6
 } from "@xyo-network/sdk-protocol-js";
+import * as z11 from "zod/mini";
 var AddressPreviousHashSchema = asSchema8("network.xyo.address.hash.previous", true);
+var AddressPreviousHashPayloadZod = z11.extend(PayloadZodOfSchema6(AddressPreviousHashSchema), {
+  address: z11.custom(),
+  previousHash: z11.optional(z11.string())
+});
+var isAddressPreviousHashPayload = zodIsFactory7(AddressPreviousHashPayloadZod);
+var asAddressPreviousHashPayload = zodAsFactory7(AddressPreviousHashPayloadZod, "asAddressPreviousHashPayload");
+var toAddressPreviousHashPayload = zodToFactory7(AddressPreviousHashPayloadZod, "toAddressPreviousHashPayload");
 
 // src/Payload/Description.ts
-import { asSchema as asSchema9 } from "@xyo-network/sdk-protocol-js";
+import {
+  zodAsFactory as zodAsFactory8,
+  zodIsFactory as zodIsFactory8,
+  zodToFactory as zodToFactory8
+} from "@xylabs/sdk-js";
+import { asSchema as asSchema9, PayloadZodOfSchema as PayloadZodOfSchema7 } from "@xyo-network/sdk-protocol-js";
+import * as z12 from "zod/mini";
 var ModuleDescriptionSchema = asSchema9("network.xyo.module.description", true);
+var ModuleDescriptionPayloadZod = z12.intersection(PayloadZodOfSchema7(ModuleDescriptionSchema), z12.custom());
+var isModuleDescriptionPayload = zodIsFactory8(ModuleDescriptionPayloadZod);
+var asModuleDescriptionPayload = zodAsFactory8(ModuleDescriptionPayloadZod, "asModuleDescriptionPayload");
+var toModuleDescriptionPayload = zodToFactory8(ModuleDescriptionPayloadZod, "toModuleDescriptionPayload");
 
 // src/Payload/ModuleState.ts
-import { AsObjectFactory as AsObjectFactory6 } from "@xylabs/sdk-js";
+import {
+  zodAsFactory as zodAsFactory9,
+  zodIsFactory as zodIsFactory9,
+  zodToFactory as zodToFactory9
+} from "@xylabs/sdk-js";
 import {
   asSchema as asSchema10,
-  isPayloadOfSchemaType as isPayloadOfSchemaType2,
-  isPayloadOfSchemaTypeWithSources
+  isPayloadOfSchemaTypeWithSources,
+  PayloadZodOfSchema as PayloadZodOfSchema8
 } from "@xyo-network/sdk-protocol-js";
+import * as z13 from "zod/mini";
 var ModuleStateSchema = asSchema10("network.xyo.module.state", true);
-var isModuleState = (payload) => {
-  return isPayloadOfSchemaType2(ModuleStateSchema)(payload);
-};
+var ModuleStateZod = z13.extend(PayloadZodOfSchema8(ModuleStateSchema), { state: z13.custom() });
+var isModuleStateInternal = zodIsFactory9(ModuleStateZod);
+var isModuleState = (payload) => isModuleStateInternal(payload);
 var isModuleStateWithSources = (payload) => {
   return isPayloadOfSchemaTypeWithSources(ModuleStateSchema)(payload);
 };
-var asModuleState = AsObjectFactory6.create(isModuleState);
-var asOptionalModuleState = AsObjectFactory6.createOptional(isModuleState);
+var asModuleState = zodAsFactory9(ModuleStateZod, "asModuleState");
+var toModuleState = zodToFactory9(ModuleStateZod, "toModuleState");
+var asOptionalModuleState = asModuleState;
 
 // src/withModule.ts
 var WithFactory = {
@@ -419,9 +589,14 @@ var WithFactory = {
   }
 };
 export {
+  AddressChildPayloadZod,
   AddressChildSchema,
+  AddressPayloadZod,
+  AddressPreviousHashPayloadZod,
   AddressPreviousHashSchema,
   AddressSchema,
+  ArchivingModuleConfigZod,
+  ArchivingReentrancyConfigZod,
   DeadModuleError,
   DisallowedModuleIdentifierCharacters,
   IsAttachableModuleInstanceFactory,
@@ -430,25 +605,42 @@ export {
   IsQueryableModuleFactory,
   MODULE_PATH_SEPARATOR,
   ModuleAddressQuerySchema,
+  ModuleAddressQueryZod,
+  ModuleConfigFieldsZod,
   ModuleConfigSchema,
+  ModuleConfigZod,
+  ModuleDescriptionPayloadZod,
   ModuleDescriptionSchema,
   ModuleDetailsError,
   ModuleFactory,
   ModuleLimitationLabelName,
   ModuleLimitationViewLabel,
   ModuleManifestQuerySchema,
+  ModuleManifestQueryZod,
+  ModuleSecurityConfigZod,
   ModuleStateQuerySchema,
+  ModuleStateQueryZod,
   ModuleStateSchema,
+  ModuleStateZod,
   ModuleSubscribeQuerySchema,
+  ModuleSubscribeQueryZod,
   ObjectResolverPriority,
   ReservedModuleIdentifierCharacters,
   WithFactory,
+  asAddressChildPayload,
   asAddressPayload,
+  asAddressPreviousHashPayload,
   asAttachableModuleInstance,
   asModule,
+  asModuleAddressQuery,
+  asModuleConfig,
+  asModuleDescriptionPayload,
   asModuleInstance,
+  asModuleManifestQuery,
   asModuleObject,
   asModuleState,
+  asModuleStateQuery,
+  asModuleSubscribeQuery,
   asOptionalAddressPayload,
   asOptionalModuleState,
   asQueryableModule,
@@ -459,18 +651,26 @@ export {
   hasAllLabels,
   hasLabels,
   includesReservedModuleIdentifierCharacter,
+  isAddressChildPayload,
   isAddressModuleFilter,
   isAddressObjectFilter,
   isAddressPayload,
+  isAddressPreviousHashPayload,
   isAttachableModuleInstance,
   isModule,
+  isModuleAddressQuery,
+  isModuleConfig,
+  isModuleDescriptionPayload,
   isModuleIdentifierPart,
   isModuleInstance,
+  isModuleManifestQuery,
   isModuleName,
   isModuleObject,
   isModuleResolver,
   isModuleState,
+  isModuleStateQuery,
   isModuleStateWithSources,
+  isModuleSubscribeQuery,
   isNameModuleFilter,
   isNameObjectFilter,
   isObjectResolver,
@@ -488,6 +688,16 @@ export {
   requiredModuleQueries,
   requiredModuleShape,
   requiredQueryableModuleQueries,
-  requiredQueryableModuleShape
+  requiredQueryableModuleShape,
+  toAddressChildPayload,
+  toAddressPayload,
+  toAddressPreviousHashPayload,
+  toModuleAddressQuery,
+  toModuleConfig,
+  toModuleDescriptionPayload,
+  toModuleManifestQuery,
+  toModuleState,
+  toModuleStateQuery,
+  toModuleSubscribeQuery
 };
 //# sourceMappingURL=index.mjs.map