@xyo-network/xns-record-payload-plugins 6.1.0 → 7.0.0

package/dist/neutral/index.mjs

@@ -1,11 +1,126 @@
 // src/Address/Payload.ts
-import { asSchema, isPayloadOfSchemaType } from "@xyo-network/sdk-js";
-var AddressRecordSchema = asSchema("network.xyo.ns.record.address", true);
-var isAddressRecord = isPayloadOfSchemaType(AddressRecordSchema);
+import {
+  AddressZod,
+  zodAsFactory as zodAsFactory3,
+  zodIsFactory as zodIsFactory3,
+  zodToFactory as zodToFactory3
+} from "@xylabs/sdk-js";
+import { asSchema as asSchema3, PayloadZodOfSchema as PayloadZodOfSchema3 } from "@xyo-network/sdk-js";
+import * as z4 from "zod/mini";
+
+// src/Domain/Domain.ts
+import {
+  zodAsFactory,
+  zodIsFactory,
+  zodToFactory
+} from "@xylabs/sdk-js";
+import { asSchema, PayloadZodOfSchema } from "@xyo-network/sdk-js";
+import * as z from "zod/mini";
+var DomainSchema = asSchema("network.xyo.ns.domain", true);
+var TopLevelDomainZod = z.literal("xyo");
+var DomainFieldsZod = z.object({
+  /**
+   * The XNS domain of the record
+   */
+  domain: z.string(),
+  /**
+   * The Top-Level Domain of the domain
+   */
+  tld: TopLevelDomainZod
+});
+var DomainZod = z.extend(PayloadZodOfSchema(DomainSchema), { ...DomainFieldsZod.shape });
+var isDomain = zodIsFactory(DomainZod);
+var asDomain = zodAsFactory(DomainZod, "asDomain");
+var toDomain = zodToFactory(DomainZod, "toDomain");
+
+// src/Domain/DomainLease.ts
+import {
+  zodAsFactory as zodAsFactory2,
+  zodIsFactory as zodIsFactory2,
+  zodToFactory as zodToFactory2
+} from "@xylabs/sdk-js";
+import { asSchema as asSchema2, PayloadZodOfSchema as PayloadZodOfSchema2 } from "@xyo-network/sdk-js";
+import * as z3 from "zod/mini";
+
+// src/Duration/Duration.ts
+import * as z2 from "zod/mini";
+var DurationFieldsZod = z2.object({
+  /**
+   * A timestamp that indicates the expiration time of the record
+   */
+  exp: z2.number(),
+  /**
+   * A timestamp that indicates the time before which the record is not valid
+   */
+  nbf: z2.number()
+});
+
+// src/Duration/validation/validateBoundWitness.ts
+import { BoundWitnessValidator } from "@xyo-network/sdk-js";
+var validateBoundWitness = async (recordBw, requiredSchemas = []) => {
+  if (requiredSchemas.some((requiredSchema) => !recordBw.payload_schemas.includes(requiredSchema))) return false;
+  const validator = new BoundWitnessValidator(recordBw);
+  const errors = await validator.validate();
+  return errors.length === 0;
+};
+
+// src/Duration/validation/validateBoundWitnessAndDuration.ts
+import { PayloadBuilder } from "@xyo-network/sdk-js";
+var validateBoundWitnessAndDuration = async (recordBw, recordPayload) => {
+  if (!await recordIsInBoundWitness(recordBw, recordPayload)) return false;
+  return recordIsTemporallyValidToBoundWitness(recordBw, recordPayload);
+};
+var recordIsInBoundWitness = async (recordBw, recordPayload) => {
+  const hash = await PayloadBuilder.dataHash(recordPayload);
+  return recordBw.payload_hashes.includes(hash);
+};
+var recordIsTemporallyValidToBoundWitness = (_recordBw, _recordPayload) => {
+  return true;
+};
+
+// src/Duration/validation/validateDuration.ts
+var validateDuration = (recordPayload) => {
+  return isWithinDelegatedTimeframe(recordPayload);
+};
+var isWithinDelegatedTimeframe = (recordPayload, now = Date.now()) => {
+  return recordPayload.nbf < now && now < recordPayload.exp;
+};
+
+// src/Duration/validation/validateBoundWitnessWithDuration.ts
+var validateBoundWitnessWithDuration = async (recordBw, recordPayload) => {
+  if (!await validateBoundWitness(recordBw, [recordPayload.schema])) return false;
+  if (!validateDuration(recordPayload)) return false;
+  return await validateBoundWitnessAndDuration(recordBw, recordPayload);
+};
+
+// src/Domain/DomainLease.ts
+var DomainLeaseSchema = asSchema2("network.xyo.ns.domain.lease", true);
+var DomainLeaseFieldsZod = z3.object({
+  ...DomainFieldsZod.shape,
+  ...DurationFieldsZod.shape
+});
+var DomainLeaseZod = z3.extend(PayloadZodOfSchema2(DomainLeaseSchema), { ...DomainLeaseFieldsZod.shape });
+var isDomainLease = zodIsFactory2(DomainLeaseZod);
+var asDomainLease = zodAsFactory2(DomainLeaseZod, "asDomainLease");
+var toDomainLease = zodToFactory2(DomainLeaseZod, "toDomainLease");
+
+// src/Address/Payload.ts
+var AddressRecordSchema = asSchema3("network.xyo.ns.record.address", true);
+var AddressRecordFieldsZod = z4.object({
+  ...DomainFieldsZod.shape,
+  /**
+   * The address the record points to
+   */
+  address: z4.array(AddressZod)
+});
+var AddressRecordZod = z4.extend(PayloadZodOfSchema3(AddressRecordSchema), { ...AddressRecordFieldsZod.shape });
+var isAddressRecord = zodIsFactory3(AddressRecordZod);
+var asAddressRecord = zodAsFactory3(AddressRecordZod, "asAddressRecord");
+var toAddressRecord = zodToFactory3(AddressRecordZod, "toAddressRecord");
 
 // src/diviner/DomainLeaseEstimateDiviner/Schema.ts
-import { asSchema as asSchema2 } from "@xyo-network/sdk-js";
-var DomainLeaseEstimateDivinerValidationErrorDetailsSchema = asSchema2("network.xyo.diviner.ns.domain.registration.lease.estimate.validation.error.details", true);
+import { asSchema as asSchema4 } from "@xyo-network/sdk-js";
+var DomainLeaseEstimateDivinerValidationErrorDetailsSchema = asSchema4("network.xyo.diviner.ns.domain.registration.lease.estimate.validation.error.details", true);
 
 // src/diviner/DomainLeaseEstimateDiviner/ErrorDetails/ErrorCodes.ts
 var DomainLeaseEstimateDivinerErrorDetailsDictionary = {
@@ -57,86 +172,97 @@ var DomainLeaseEstimateDivinerErrorDetailsDictionary = {
 };
 
 // src/diviner/DomainLeaseEstimateDiviner/ErrorDetails/Payload.ts
-import { isPayloadOfSchemaType as isPayloadOfSchemaType2, isPayloadOfSchemaTypeWithSources } from "@xyo-network/sdk-js";
-var isDomainLeaseEstimateDivinerValidationErrorDetails = isPayloadOfSchemaType2(
-  DomainLeaseEstimateDivinerValidationErrorDetailsSchema
+import {
+  zodAsFactory as zodAsFactory4,
+  zodIsFactory as zodIsFactory4,
+  zodToFactory as zodToFactory4
+} from "@xylabs/sdk-js";
+import { PayloadZodOfSchema as PayloadZodOfSchema4 } from "@xyo-network/sdk-js";
+import * as z5 from "zod/mini";
+var ErrorDetailsZod = z5.object({
+  /**
+   * A string code indicating the error type.
+   */
+  code: z5.optional(z5.string()),
+  /**
+   * A human-readable explanation specific to this occurrence of the problem
+   */
+  detail: z5.optional(z5.string()),
+  /**
+   * A short, human-readable summary of the problem type.
+   */
+  title: z5.optional(z5.string())
+});
+var DomainLeaseEstimateDivinerValidationErrorDetailsZod = z5.extend(
+  PayloadZodOfSchema4(DomainLeaseEstimateDivinerValidationErrorDetailsSchema),
+  { ...ErrorDetailsZod.shape }
+);
+var baseIsDomainLeaseEstimateDivinerValidationErrorDetails = zodIsFactory4(DomainLeaseEstimateDivinerValidationErrorDetailsZod);
+var isDomainLeaseEstimateDivinerValidationErrorDetails = (x) => baseIsDomainLeaseEstimateDivinerValidationErrorDetails(x);
+var asDomainLeaseEstimateDivinerValidationErrorDetails = zodAsFactory4(
+  DomainLeaseEstimateDivinerValidationErrorDetailsZod,
+  "asDomainLeaseEstimateDivinerValidationErrorDetails"
+);
+var toDomainLeaseEstimateDivinerValidationErrorDetails = zodToFactory4(
+  DomainLeaseEstimateDivinerValidationErrorDetailsZod,
+  "toDomainLeaseEstimateDivinerValidationErrorDetails"
 );
-var isDomainLeaseEstimateDivinerValidationErrorDetailsWithSources = isPayloadOfSchemaTypeWithSources(DomainLeaseEstimateDivinerValidationErrorDetailsSchema);
 
 // src/diviner/lib/parseEstimatesFromArray.ts
 import { exists, findAs } from "@xylabs/sdk-js";
 import { asHashLeaseEstimate, HashLeaseEstimateSchema } from "@xyo-network/diviner-hash-lease";
-import { isBoundWitness, PayloadBuilder } from "@xyo-network/sdk-js";
+import { isBoundWitness, PayloadBuilder as PayloadBuilder2 } from "@xyo-network/sdk-js";
 
 // src/DomainRegistration/DomainRegistration.ts
-import { AsObjectFactory as AsObjectFactory3 } from "@xylabs/sdk-js";
-import {
-  asSchema as asSchema5,
-  isPayloadOfSchemaType as isPayloadOfSchemaType5,
-  isPayloadOfSchemaTypeWithSources as isPayloadOfSchemaTypeWithSources4
-} from "@xyo-network/sdk-js";
-
-// src/Domain/Domain.ts
-import { AsObjectFactory } from "@xylabs/sdk-js";
-import {
-  asSchema as asSchema3,
-  isPayloadOfSchemaType as isPayloadOfSchemaType3,
-  isPayloadOfSchemaTypeWithSources as isPayloadOfSchemaTypeWithSources2
-} from "@xyo-network/sdk-js";
-var DomainSchema = asSchema3("network.xyo.ns.domain", true);
-var isDomain = isPayloadOfSchemaType3(DomainSchema);
-var asDomain = AsObjectFactory.create(isDomain);
-var asOptionalDomain = AsObjectFactory.createOptional(isDomain);
-var isDomainWithSources = isPayloadOfSchemaTypeWithSources2(DomainSchema);
-var asDomainWithSources = AsObjectFactory.create(isDomainWithSources);
-var asOptionalDomainWithSources = AsObjectFactory.createOptional(isDomainWithSources);
-
-// src/Domain/DomainLease.ts
-import { AsObjectFactory as AsObjectFactory2 } from "@xylabs/sdk-js";
 import {
-  asSchema as asSchema4,
-  isPayloadOfSchemaType as isPayloadOfSchemaType4,
-  isPayloadOfSchemaTypeWithSources as isPayloadOfSchemaTypeWithSources3
-} from "@xyo-network/sdk-js";
-var DomainLeaseSchema = asSchema4("network.xyo.ns.domain.lease", true);
-var isDomainLease = isPayloadOfSchemaType4(DomainLeaseSchema);
-var asDomainLease = AsObjectFactory2.create(isDomainLease);
-var asOptionalDomainLease = AsObjectFactory2.createOptional(isDomainLease);
-var isDomainLeaseWithSources = isPayloadOfSchemaTypeWithSources3(DomainLeaseSchema);
-var asDomainLeaseWithSources = AsObjectFactory2.create(isDomainLeaseWithSources);
-var asOptionalDomainLeaseWithSources = AsObjectFactory2.createOptional(isDomainLeaseWithSources);
-
-// src/DomainRegistration/DomainRegistration.ts
+  AddressZod as AddressZod2,
+  zodAsFactory as zodAsFactory5,
+  zodIsFactory as zodIsFactory5,
+  zodToFactory as zodToFactory5
+} from "@xylabs/sdk-js";
+import { asSchema as asSchema5, PayloadZodOfSchema as PayloadZodOfSchema5 } from "@xyo-network/sdk-js";
+import * as z6 from "zod/mini";
 var DomainRegistrationSchema = asSchema5(`${DomainSchema}.registration`, true);
-var isDomainRegistration = isPayloadOfSchemaType5(DomainRegistrationSchema);
-var asDomainRegistration = AsObjectFactory3.create(isDomainRegistration);
-var asOptionalDomainRegistration = AsObjectFactory3.createOptional(isDomainRegistration);
-var isDomainRegistrationWithSources = isPayloadOfSchemaTypeWithSources4(DomainRegistrationSchema);
-var asDomainRegistrationWithSources = AsObjectFactory3.create(isDomainRegistrationWithSources);
-var asOptionalDomainRegistrationWithSources = AsObjectFactory3.createOptional(isDomainRegistrationWithSources);
+var DomainRegistrationFieldsZod = z6.object({
+  ...DomainFieldsZod.shape,
+  /**
+   * The registrant of the domain
+   */
+  registrant: z6.array(AddressZod2),
+  /**
+   * The registrar of the domain
+   */
+  registrar: z6.array(AddressZod2)
+});
+var DomainRegistrationZod = z6.extend(PayloadZodOfSchema5(DomainRegistrationSchema), { ...DomainRegistrationFieldsZod.shape });
+var isDomainRegistration = zodIsFactory5(DomainRegistrationZod);
+var asDomainRegistration = zodAsFactory5(DomainRegistrationZod, "asDomainRegistration");
+var toDomainRegistration = zodToFactory5(DomainRegistrationZod, "toDomainRegistration");
 
 // src/DomainRegistration/DomainRegistrationLease.ts
-import { AsObjectFactory as AsObjectFactory4 } from "@xylabs/sdk-js";
 import {
-  asSchema as asSchema6,
-  isPayloadOfSchemaType as isPayloadOfSchemaType6,
-  isPayloadOfSchemaTypeWithSources as isPayloadOfSchemaTypeWithSources5
-} from "@xyo-network/sdk-js";
+  zodAsFactory as zodAsFactory6,
+  zodIsFactory as zodIsFactory6,
+  zodToFactory as zodToFactory6
+} from "@xylabs/sdk-js";
+import { asSchema as asSchema6, PayloadZodOfSchema as PayloadZodOfSchema6 } from "@xyo-network/sdk-js";
+import * as z7 from "zod/mini";
 var DomainRegistrationLeaseSchema = asSchema6(`${DomainRegistrationSchema}.lease`, true);
-var isDomainRegistrationLease = isPayloadOfSchemaType6(DomainRegistrationLeaseSchema);
-var asDomainRegistrationLease = AsObjectFactory4.create(isDomainRegistrationLease);
-var asOptionalDomainRegistrationLease = AsObjectFactory4.createOptional(isDomainRegistrationLease);
-var isDomainRegistrationLeaseWithSources = isPayloadOfSchemaTypeWithSources5(DomainRegistrationLeaseSchema);
-var asDomainRegistrationLeaseWithSources = AsObjectFactory4.create(isDomainRegistrationLeaseWithSources);
-var asOptionalDomainRegistrationLeaseWithSources = AsObjectFactory4.createOptional(isDomainRegistrationLeaseWithSources);
-var isDomainRegistrationLeaseSources = isDomainRegistrationLeaseWithSources;
+var DomainRegistrationLeaseFieldsZod = z7.object({
+  ...DomainRegistrationFieldsZod.shape,
+  ...DurationFieldsZod.shape
+});
+var DomainRegistrationLeaseZod = z7.extend(PayloadZodOfSchema6(DomainRegistrationLeaseSchema), { ...DomainRegistrationLeaseFieldsZod.shape });
+var isDomainRegistrationLease = zodIsFactory6(DomainRegistrationLeaseZod);
+var asDomainRegistrationLease = zodAsFactory6(DomainRegistrationLeaseZod, "asDomainRegistrationLease");
+var toDomainRegistrationLease = zodToFactory6(DomainRegistrationLeaseZod, "toDomainRegistrationLease");
 
 // src/diviner/lib/parseEstimatesFromArray.ts
 var parseEstimatesFromArray = async (payloads) => {
   if (!payloads) return [];
   const bws = payloads.filter(isBoundWitness).filter(hasEstimatePayloads) ?? [];
   if (bws.length === 0) return [];
-  const hashMap = await PayloadBuilder.toAllHashMap(payloads);
+  const hashMap = await PayloadBuilder2.toAllHashMap(payloads);
   return bws.map((bw) => {
     const hashLeaseEstimate = getPayloadBySchemaFromBoundWitness(
       bw,
@@ -149,7 +275,7 @@ var parseEstimatesFromArray = async (payloads) => {
       bw,
       DomainRegistrationLeaseSchema,
       hashMap,
-      asDomainRegistrationLeaseWithSources
+      asDomainRegistrationLease
     );
     if (!domainLease) return;
     return [bw, hashLeaseEstimate, domainLease];
@@ -165,56 +291,113 @@ var getPayloadBySchemaFromBoundWitness = (bw, schema, hashMap, identity) => {
   return findAs([hashMap[hash]], identity);
 };
 
-// src/DNS/types/OperationCodes.ts
-var DNSQueryOpcodes = {
-  QUERY: 0,
-  IQUERY: 1,
-  STATUS: 2,
-  NOTIFY: 4,
-  UPDATE: 5,
-  DSO: 6
-};
-
-// src/DNS/types/ResponseCodes.ts
-var DNSRcodes = {
-  NOERROR: 0,
-  FORMERR: 1,
-  SERVFAIL: 2,
-  NXDOMAIN: 3,
-  NOTIMP: 4,
-  REFUSED: 5,
-  YXDOMAIN: 6,
-  YXRRSET: 7,
-  NXRRSET: 8,
-  NOTAUTH: 9,
-  NOTZONE: 10,
-  BADSIG: 16,
-  BADKEY: 17,
-  BADTIME: 18
-};
+// src/Dns/types/Answer.ts
+import * as z10 from "zod/mini";
 
-// src/DNS/types/Header.ts
-var StandardRequestHeader = {
-  ID: 0,
-  QR: 0,
-  // Query/Response Flag (0 = Query)
-  Opcode: DNSQueryOpcodes.QUERY,
-  // Operation Code (0 for standard query)
-  AA: 0,
-  // Authoritative Answer (0 in query)
-  TC: 0,
-  // Truncation (0 for non-truncated)
-  RD: 1,
-  // Recursion Desired (1 if recursion is requested)
-  RCODE: DNSRcodes.NOERROR,
-  // Response Code (always 0 in query)
-  QDCOUNT: 1,
-  ANCOUNT: 0,
-  NSCOUNT: 0,
-  ARCOUNT: 0
-};
+// src/Dns/types/Record.ts
+import * as z9 from "zod/mini";
 
-// src/DNS/types/ResourceRecord.ts
+// src/Dns/types/ResourceRecord.ts
+import * as z8 from "zod/mini";
+var DNSResourceRecordTypeZod = z8.enum([
+  "A",
+  "NS",
+  "MD",
+  "MF",
+  "CNAME",
+  "SOA",
+  "MB",
+  "MG",
+  "MR",
+  "NULL",
+  "WKS",
+  "PTR",
+  "HINFO",
+  "MINFO",
+  "MX",
+  "TXT",
+  "RP",
+  "AFSDB",
+  "X25",
+  "ISDN",
+  "RT",
+  "NSAP",
+  "NSAP-PTR",
+  "SIG",
+  "KEY",
+  "PX",
+  "GPOS",
+  "AAAA",
+  "LOC",
+  "NXT",
+  "EID",
+  "NIMLOC",
+  "SRV",
+  "ATMA",
+  "NAPTR",
+  "KX",
+  "CERT",
+  "A6",
+  "DNAME",
+  "SINK",
+  "OPT",
+  "APL",
+  "DS",
+  "SSHFP",
+  "IPSECKEY",
+  "RRSIG",
+  "NSEC",
+  "DNSKEY",
+  "DHCID",
+  "NSEC3",
+  "NSEC3PARAM",
+  "TLSA",
+  "SMIMEA",
+  "HIP",
+  "NINFO",
+  "RKEY",
+  "TALINK",
+  "CDS",
+  "CDNSKEY",
+  "OPENPGPKEY",
+  "CSYNC",
+  "ZONEMD",
+  "SVCB",
+  "HTTPS",
+  "SPF",
+  "UINFO",
+  "UID",
+  "GID",
+  "UNSPEC",
+  "NID",
+  "L32",
+  "L64",
+  "LP",
+  "EUI48",
+  "EUI64",
+  "NXNAME",
+  "TKEY",
+  "TSIG",
+  "IXFR",
+  "AXFR",
+  "MAILB",
+  "MAILA",
+  "*",
+  "URI",
+  "CAA",
+  "AVC",
+  "DOA",
+  "AMTRELAY",
+  "RESINFO",
+  "WALLET",
+  "CLA",
+  "IPN",
+  "TA",
+  "DLV",
+  // Custom types here
+  "XYOA",
+  "XYOH"
+]);
 var DNSResourceRecordTypes = {
   "A": 1,
   // a host address
@@ -416,6 +599,7 @@ var DNSResourceRecordTypes = {
   "XYOH": 65433
   // XYO Hash
 };
+var DNSResourceRecordTypeValueZod = z8.number();
 var findDNSResourceRecordTypesByValue = (value) => {
   for (const key in DNSResourceRecordTypes) {
     const resourceRecordType = key;
@@ -426,7 +610,208 @@ var findDNSResourceRecordTypesByValue = (value) => {
   return void 0;
 };
 
-// src/DNS/types/Request.ts
+// src/Dns/types/Record.ts
+var DNSRecordZod = z9.object({
+  name: z9.string(),
+  // The domain name that was queried
+  type: DNSResourceRecordTypeValueZod,
+  // The record type (e.g., 1 for A record)
+  TTL: z9.number(),
+  // Time to Live (how long the record can be cached)
+  data: z9.string()
+  // The actual data, such as an IP address or TXT record
+});
+
+// src/Dns/types/Answer.ts
+var DNSAnswerZod = z10.extend(DNSRecordZod, { class: z10.optional(z10.number()) });
+
+// src/Dns/types/Header.ts
+import * as z13 from "zod/mini";
+
+// src/Dns/types/OperationCodes.ts
+import * as z11 from "zod/mini";
+var DNSQueryOpcodeZod = z11.union([
+  z11.literal(0),
+  z11.literal(1),
+  z11.literal(2),
+  z11.literal(4),
+  z11.literal(5),
+  z11.literal(6)
+]);
+var DNSQueryOpcodeNameZod = z11.enum(["QUERY", "IQUERY", "STATUS", "NOTIFY", "UPDATE", "DSO"]);
+var DNSQueryOpcodes = {
+  QUERY: 0,
+  IQUERY: 1,
+  STATUS: 2,
+  NOTIFY: 4,
+  UPDATE: 5,
+  DSO: 6
+};
+
+// src/Dns/types/ResponseCodes.ts
+import * as z12 from "zod/mini";
+var DNSRcodeZod = z12.union([
+  z12.literal(0),
+  z12.literal(1),
+  z12.literal(2),
+  z12.literal(3),
+  z12.literal(4),
+  z12.literal(5),
+  z12.literal(6),
+  z12.literal(7),
+  z12.literal(8),
+  z12.literal(9),
+  z12.literal(10),
+  z12.literal(16),
+  z12.literal(17),
+  z12.literal(18)
+]);
+var DNSRcodeNameZod = z12.enum([
+  "NOERROR",
+  "FORMERR",
+  "SERVFAIL",
+  "NXDOMAIN",
+  "NOTIMP",
+  "REFUSED",
+  "YXDOMAIN",
+  "YXRRSET",
+  "NXRRSET",
+  "NOTAUTH",
+  "NOTZONE",
+  "BADSIG",
+  "BADKEY",
+  "BADTIME"
+]);
+var DNSRcodes = {
+  NOERROR: 0,
+  FORMERR: 1,
+  SERVFAIL: 2,
+  NXDOMAIN: 3,
+  NOTIMP: 4,
+  REFUSED: 5,
+  YXDOMAIN: 6,
+  YXRRSET: 7,
+  NXRRSET: 8,
+  NOTAUTH: 9,
+  NOTZONE: 10,
+  BADSIG: 16,
+  BADKEY: 17,
+  BADTIME: 18
+};
+
+// src/Dns/types/Header.ts
+var NumericBooleanZod = z13.union([z13.literal(0), z13.literal(1), z13.literal(true), z13.literal(false)]);
+var NumericBooleanFalsyZod = z13.union([z13.literal(0), z13.literal(false)]);
+var NumericBooleanTruthyZod = z13.union([z13.literal(1), z13.literal(true)]);
+var DNSHeaderZod = z13.object({
+  /**
+   * Transaction ID, typically a random number. Integer whose value is 0 to 65535
+   */
+  ID: z13.optional(z13.number()),
+  /**
+   * Query/Response Flag (0 = Query, 1 = Response)
+   */
+  QR: z13.optional(NumericBooleanZod),
+  /**
+   * Operation Code (0 for standard query)
+   */
+  Opcode: z13.optional(DNSQueryOpcodeZod),
+  /**
+   * Authoritative Answer (set in response)
+   */
+  AA: z13.optional(NumericBooleanZod),
+  /**
+   * Truncated Flag
+   */
+  TC: z13.optional(NumericBooleanZod),
+  // Truncation
+  /**
+   * Recursion Desired
+   */
+  RD: z13.optional(NumericBooleanZod),
+  // Recursion Desired (set in query)
+  /**
+   * Response Code (0 for no error, non-0 for errors)
+   */
+  RCODE: z13.optional(DNSRcodeZod),
+  /**
+   * Number of questions in the query (usually 1)
+   */
+  QDCOUNT: z13.optional(z13.number()),
+  /**
+   * Number of answer records in the response
+   */
+  ANCOUNT: z13.optional(z13.number()),
+  /**
+   * Number of authority records in the response
+   */
+  NSCOUNT: z13.optional(z13.number()),
+  /**
+   * Number of additional records in the response
+   */
+  ARCOUNT: z13.optional(z13.number())
+});
+var DNSRequestHeaderZod = z13.extend(DNSHeaderZod, {
+  QR: NumericBooleanFalsyZod,
+  // Query/Response Flag (0 = Query)
+  Opcode: DNSQueryOpcodeZod,
+  // Operation Code (0 for standard query)
+  AA: NumericBooleanFalsyZod,
+  // Authoritative Answer (0 in query)
+  TC: NumericBooleanFalsyZod,
+  // Truncation (0 for non-truncated)
+  RCODE: z13.literal(DNSRcodes.NOERROR),
+  // Response Code (always 0 in query)
+  ANCOUNT: z13.literal(0),
+  // Number of answer records (always 0 in query)
+  NSCOUNT: z13.literal(0),
+  // Number of authority records (always 0 in query)
+  ARCOUNT: z13.literal(0)
+  // Number of additional records (always 0 in query)
+});
+var StandardRequestHeader = {
+  ID: 0,
+  QR: 0,
+  // Query/Response Flag (0 = Query)
+  Opcode: DNSQueryOpcodes.QUERY,
+  // Operation Code (0 for standard query)
+  AA: 0,
+  // Authoritative Answer (0 in query)
+  TC: 0,
+  // Truncation (0 for non-truncated)
+  RD: 1,
+  // Recursion Desired (1 if recursion is requested)
+  RCODE: DNSRcodes.NOERROR,
+  // Response Code (always 0 in query)
+  QDCOUNT: 1,
+  ANCOUNT: 0,
+  NSCOUNT: 0,
+  ARCOUNT: 0
+};
+var DNSResponseHeaderZod = z13.extend(DNSHeaderZod, {
+  QR: NumericBooleanTruthyZod,
+  // Query/Response Flag (1 = Response)
+  Opcode: DNSQueryOpcodeZod,
+  // Operation Code (0 for standard query)
+  AA: NumericBooleanZod,
+  // Authoritative Answer (1 if the response is authoritative)
+  TC: NumericBooleanZod,
+  // Truncation (1 if the message is truncated)
+  RA: NumericBooleanZod
+  // Recursion Available (1 if the server supports recursion)
+});
+
+// src/Dns/types/Request.ts
+import * as z14 from "zod/mini";
+var DNSQuestionZod = z14.object({
+  name: z14.string(),
+  // The domain name that was queried
+  type: DNSResourceRecordTypeValueZod,
+  // The record type (e.g., 1 for A record)
+  class: z14.optional(z14.number())
+  // Query Class (typically 1 for IN - Internet)
+});
+var DNSRequestFieldsZod = z14.extend(DNSRequestHeaderZod, { Question: z14.array(DNSQuestionZod) });
 var getRequestFor = (domain, type = DNSResourceRecordTypes.A) => {
   return {
     ...StandardRequestHeader,
@@ -442,149 +827,160 @@ var getRandomId = () => {
   return Math.floor(Math.random() * 65536);
 };
 
-// src/DNS/Witness/Config.ts
+// src/Dns/types/Response.ts
+import * as z15 from "zod/mini";
+var DNSResponseFieldsZod = z15.extend(DNSResponseHeaderZod, {
+  Question: z15.array(DNSQuestionZod),
+  // The questions that were asked
+  Answer: z15.array(DNSAnswerZod),
+  // Reusing DNSAnswer for the Answer Section
+  Authority: z15.optional(z15.array(DNSRecordZod)),
+  Additional: z15.optional(z15.array(DNSRecordZod))
+});
+
+// src/Dns/Witness/Config.ts
 import { asSchema as asSchema8 } from "@xyo-network/sdk-js";
 
-// src/DNS/Witness/Schema.ts
+// src/Dns/Witness/Schema.ts
 import { asSchema as asSchema7 } from "@xyo-network/sdk-js";
 var DNSSchema = asSchema7("network.xyo.dns", true);
 
-// src/DNS/Witness/Config.ts
+// src/Dns/Witness/Config.ts
 var DNSWitnessConfigSchema = asSchema8(`${DNSSchema}.witness.config`, true);
 
-// src/DNS/Witness/Payload/Request.ts
-import { AsObjectFactory as AsObjectFactory5 } from "@xylabs/sdk-js";
+// src/Dns/Witness/Payload/Request.ts
 import {
-  isPayloadOfSchemaType as isPayloadOfSchemaType7,
-  isPayloadOfSchemaTypeWithSources as isPayloadOfSchemaTypeWithSources6
-} from "@xyo-network/sdk-js";
-var isDNSRequest = isPayloadOfSchemaType7(DNSSchema);
-var asDNSRequest = AsObjectFactory5.create(isDNSRequest);
-var asOptionalDNSRequest = AsObjectFactory5.createOptional(isDNSRequest);
-var isDNSRequestWithSources = isPayloadOfSchemaTypeWithSources6(DNSSchema);
-var asDNSRequestWithSources = AsObjectFactory5.create(isDNSRequestWithSources);
-var asOptionalDNSRequestWithSources = AsObjectFactory5.createOptional(isDNSRequestWithSources);
+  zodAsFactory as zodAsFactory7,
+  zodIsFactory as zodIsFactory7,
+  zodToFactory as zodToFactory7
+} from "@xylabs/sdk-js";
+import { PayloadZodOfSchema as PayloadZodOfSchema7 } from "@xyo-network/sdk-js";
+import * as z16 from "zod/mini";
+var DNSRequestZod = z16.extend(PayloadZodOfSchema7(DNSSchema), { ...DNSRequestFieldsZod.shape });
+var isDNSRequest = zodIsFactory7(DNSRequestZod);
+var asDNSRequest = zodAsFactory7(DNSRequestZod, "asDNSRequest");
+var toDNSRequest = zodToFactory7(DNSRequestZod, "toDNSRequest");
 var getDnsRequestFor = (domain, type = DNSResourceRecordTypes.A) => {
   return { ...getRequestFor(domain, type), schema: DNSSchema };
 };
 
-// src/DNS/Witness/Payload/Response.ts
-import { AsObjectFactory as AsObjectFactory6 } from "@xylabs/sdk-js";
+// src/Dns/Witness/Payload/Response.ts
 import {
-  isPayloadOfSchemaType as isPayloadOfSchemaType8,
-  isPayloadOfSchemaTypeWithSources as isPayloadOfSchemaTypeWithSources7
-} from "@xyo-network/sdk-js";
-var isDNSResponse = isPayloadOfSchemaType8(DNSSchema);
-var asDNSResponse = AsObjectFactory6.create(isDNSResponse);
-var asOptionalDNSResponse = AsObjectFactory6.createOptional(isDNSResponse);
-var isDNSResponseWithSources = isPayloadOfSchemaTypeWithSources7(DNSSchema);
-var asDNSResponseWithSources = AsObjectFactory6.create(isDNSResponseWithSources);
-var asOptionalDNSResponseWithSources = AsObjectFactory6.createOptional(isDNSResponseWithSources);
-
-// src/Duration/validation/validateBoundWitness.ts
-import { BoundWitnessValidator } from "@xyo-network/sdk-js";
-var validateBoundWitness = async (recordBw, requiredSchemas = []) => {
-  if (!requiredSchemas.every((requiredSchema) => recordBw.payload_schemas.includes(requiredSchema))) return false;
-  const validator = new BoundWitnessValidator(recordBw);
-  const errors = await validator.validate();
-  return errors.length === 0;
-};
-
-// src/Duration/validation/validateBoundWitnessAndDuration.ts
-import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/sdk-js";
-var validateBoundWitnessAndDuration = async (recordBw, recordPayload) => {
-  if (!await recordIsInBoundWitness(recordBw, recordPayload)) return false;
-  return recordIsTemporallyValidToBoundWitness(recordBw, recordPayload);
-};
-var recordIsInBoundWitness = async (recordBw, recordPayload) => {
-  const hash = await PayloadBuilder2.dataHash(recordPayload);
-  return recordBw.payload_hashes.includes(hash);
-};
-var recordIsTemporallyValidToBoundWitness = (_recordBw, _recordPayload) => {
-  return true;
-};
-
-// src/Duration/validation/validateDuration.ts
-var validateDuration = (recordPayload) => {
-  return isWithinDelegatedTimeframe(recordPayload);
-};
-var isWithinDelegatedTimeframe = (recordPayload, now = Date.now()) => {
-  return recordPayload.nbf < now && now < recordPayload.exp;
-};
-
-// src/Duration/validation/validateBoundWitnessWithDuration.ts
-var validateBoundWitnessWithDuration = async (recordBw, recordPayload) => {
-  if (!await validateBoundWitness(recordBw, [recordPayload.schema])) return false;
-  if (!validateDuration(recordPayload)) return false;
-  return await validateBoundWitnessAndDuration(recordBw, recordPayload);
-};
+  zodAsFactory as zodAsFactory8,
+  zodIsFactory as zodIsFactory8,
+  zodToFactory as zodToFactory8
+} from "@xylabs/sdk-js";
+import { PayloadZodOfSchema as PayloadZodOfSchema8 } from "@xyo-network/sdk-js";
+import * as z17 from "zod/mini";
+var DNSResponseZod = z17.extend(PayloadZodOfSchema8(DNSSchema), { ...DNSResponseFieldsZod.shape });
+var isDNSResponse = zodIsFactory8(DNSResponseZod);
+var asDNSResponse = zodAsFactory8(DNSResponseZod, "asDNSResponse");
+var toDNSResponse = zodToFactory8(DNSResponseZod, "toDNSResponse");
 
 // src/Hash/Payload.ts
-import { asSchema as asSchema9, isPayloadOfSchemaType as isPayloadOfSchemaType9 } from "@xyo-network/sdk-js";
+import {
+  HashZod,
+  zodAsFactory as zodAsFactory9,
+  zodIsFactory as zodIsFactory9,
+  zodToFactory as zodToFactory9
+} from "@xylabs/sdk-js";
+import { asSchema as asSchema9, PayloadZodOfSchema as PayloadZodOfSchema9 } from "@xyo-network/sdk-js";
+import * as z18 from "zod/mini";
 var HashRecordSchema = asSchema9("network.xyo.ns.record.hash", true);
-var isHashRecord = isPayloadOfSchemaType9(HashRecordSchema);
+var HashRecordFieldsZod = z18.object({
+  ...DomainFieldsZod.shape,
+  /**
+   * The hash the record points to
+   */
+  hash: z18.array(HashZod)
+});
+var HashRecordZod = z18.extend(PayloadZodOfSchema9(HashRecordSchema), { ...HashRecordFieldsZod.shape });
+var isHashRecord = zodIsFactory9(HashRecordZod);
+var asHashRecord = zodAsFactory9(HashRecordZod, "asHashRecord");
+var toHashRecord = zodToFactory9(HashRecordZod, "toHashRecord");
 export {
+  AddressRecordFieldsZod,
   AddressRecordSchema,
+  AddressRecordZod,
+  DNSAnswerZod,
+  DNSHeaderZod,
+  DNSQueryOpcodeNameZod,
+  DNSQueryOpcodeZod,
   DNSQueryOpcodes,
+  DNSQuestionZod,
+  DNSRcodeNameZod,
+  DNSRcodeZod,
   DNSRcodes,
+  DNSRecordZod,
+  DNSRequestFieldsZod,
+  DNSRequestHeaderZod,
+  DNSRequestZod,
+  DNSResourceRecordTypeValueZod,
+  DNSResourceRecordTypeZod,
   DNSResourceRecordTypes,
+  DNSResponseFieldsZod,
+  DNSResponseHeaderZod,
+  DNSResponseZod,
   DNSSchema,
   DNSWitnessConfigSchema,
+  DomainFieldsZod,
   DomainLeaseEstimateDivinerErrorDetailsDictionary,
   DomainLeaseEstimateDivinerValidationErrorDetailsSchema,
+  DomainLeaseEstimateDivinerValidationErrorDetailsZod,
+  DomainLeaseFieldsZod,
   DomainLeaseSchema,
+  DomainLeaseZod,
+  DomainRegistrationFieldsZod,
+  DomainRegistrationLeaseFieldsZod,
   DomainRegistrationLeaseSchema,
+  DomainRegistrationLeaseZod,
   DomainRegistrationSchema,
+  DomainRegistrationZod,
   DomainSchema,
+  DomainZod,
+  DurationFieldsZod,
+  ErrorDetailsZod,
+  HashRecordFieldsZod,
   HashRecordSchema,
+  HashRecordZod,
+  NumericBooleanFalsyZod,
+  NumericBooleanTruthyZod,
+  NumericBooleanZod,
   StandardRequestHeader,
+  TopLevelDomainZod,
+  asAddressRecord,
   asDNSRequest,
-  asDNSRequestWithSources,
   asDNSResponse,
-  asDNSResponseWithSources,
   asDomain,
   asDomainLease,
-  asDomainLeaseWithSources,
+  asDomainLeaseEstimateDivinerValidationErrorDetails,
   asDomainRegistration,
   asDomainRegistrationLease,
-  asDomainRegistrationLeaseWithSources,
-  asDomainRegistrationWithSources,
-  asDomainWithSources,
-  asOptionalDNSRequest,
-  asOptionalDNSRequestWithSources,
-  asOptionalDNSResponse,
-  asOptionalDNSResponseWithSources,
-  asOptionalDomain,
-  asOptionalDomainLease,
-  asOptionalDomainLeaseWithSources,
-  asOptionalDomainRegistration,
-  asOptionalDomainRegistrationLease,
-  asOptionalDomainRegistrationLeaseWithSources,
-  asOptionalDomainRegistrationWithSources,
-  asOptionalDomainWithSources,
+  asHashRecord,
   findDNSResourceRecordTypesByValue,
   getDnsRequestFor,
   getRandomId,
   getRequestFor,
   isAddressRecord,
   isDNSRequest,
-  isDNSRequestWithSources,
   isDNSResponse,
-  isDNSResponseWithSources,
   isDomain,
   isDomainLease,
   isDomainLeaseEstimateDivinerValidationErrorDetails,
-  isDomainLeaseEstimateDivinerValidationErrorDetailsWithSources,
-  isDomainLeaseWithSources,
   isDomainRegistration,
   isDomainRegistrationLease,
-  isDomainRegistrationLeaseSources,
-  isDomainRegistrationLeaseWithSources,
-  isDomainRegistrationWithSources,
-  isDomainWithSources,
   isHashRecord,
   isWithinDelegatedTimeframe,
   parseEstimatesFromArray,
+  toAddressRecord,
+  toDNSRequest,
+  toDNSResponse,
+  toDomain,
+  toDomainLease,
+  toDomainLeaseEstimateDivinerValidationErrorDetails,
+  toDomainRegistration,
+  toDomainRegistrationLease,
+  toHashRecord,
   validateBoundWitnessWithDuration,
   validateDuration
 };