@xyo-network/xns-record-payload-plugins 7.0.2 → 7.0.4

package/dist/neutral/index.mjs

@@ -1,987 +1,3 @@
-// src/Address/Payload.ts
-import {
-  AddressZod,
-  zodAsFactory as zodAsFactory3,
-  zodIsFactory as zodIsFactory3,
-  zodToFactory as zodToFactory3
-} from "@ariestools/sdk";
-import { asSchema as asSchema3, PayloadZodOfSchema as PayloadZodOfSchema3 } from "@xyo-network/sdk";
-import * as z4 from "zod/mini";
-
-// src/Domain/Domain.ts
-import {
-  zodAsFactory,
-  zodIsFactory,
-  zodToFactory
-} from "@ariestools/sdk";
-import { asSchema, PayloadZodOfSchema } from "@xyo-network/sdk";
-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 "@ariestools/sdk";
-import { asSchema as asSchema2, PayloadZodOfSchema as PayloadZodOfSchema2 } from "@xyo-network/sdk";
-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";
-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";
-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 asSchema4 } from "@xyo-network/sdk";
-var DomainLeaseEstimateDivinerValidationErrorDetailsSchema = asSchema4("network.xyo.diviner.ns.domain.registration.lease.estimate.validation.error.details", true);
-
-// src/diviner/DomainLeaseEstimateDiviner/ErrorDetails/ErrorCodes.ts
-var DomainLeaseEstimateDivinerErrorDetailsDictionary = {
-  0: {
-    code: "0",
-    schema: DomainLeaseEstimateDivinerValidationErrorDetailsSchema,
-    title: "Success"
-  },
-  1: {
-    code: "1",
-    schema: DomainLeaseEstimateDivinerValidationErrorDetailsSchema,
-    title: "Invalid casing"
-  },
-  2: {
-    code: "2",
-    schema: DomainLeaseEstimateDivinerValidationErrorDetailsSchema,
-    title: "Invalid coin signature"
-  },
-  3: {
-    code: "3",
-    schema: DomainLeaseEstimateDivinerValidationErrorDetailsSchema,
-    title: "Invalid length"
-  },
-  4: {
-    code: "4",
-    schema: DomainLeaseEstimateDivinerValidationErrorDetailsSchema,
-    title: "Invalid name"
-  },
-  5: {
-    code: "5",
-    schema: DomainLeaseEstimateDivinerValidationErrorDetailsSchema,
-    title: "Reserved fragment"
-  },
-  6: {
-    code: "6",
-    schema: DomainLeaseEstimateDivinerValidationErrorDetailsSchema,
-    title: "Reserved name"
-  },
-  7: {
-    code: "7",
-    schema: DomainLeaseEstimateDivinerValidationErrorDetailsSchema,
-    title: "Reserved string"
-  },
-  8: {
-    code: "8",
-    schema: DomainLeaseEstimateDivinerValidationErrorDetailsSchema,
-    title: "Invalid TLD"
-  }
-};
-
-// src/diviner/DomainLeaseEstimateDiviner/ErrorDetails/Payload.ts
-import {
-  zodAsFactory as zodAsFactory4,
-  zodIsFactory as zodIsFactory4,
-  zodToFactory as zodToFactory4
-} from "@ariestools/sdk";
-import { PayloadZodOfSchema as PayloadZodOfSchema4 } from "@xyo-network/sdk";
-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"
-);
-
-// src/diviner/lib/parseEstimatesFromArray.ts
-import { exists, findAs } from "@ariestools/sdk";
-import { asHashLeaseEstimate, HashLeaseEstimateSchema } from "@xyo-network/diviner-hash-lease";
-import { isBoundWitness, PayloadBuilder as PayloadBuilder2 } from "@xyo-network/sdk";
-
-// src/DomainRegistration/DomainRegistration.ts
-import {
-  AddressZod as AddressZod2,
-  zodAsFactory as zodAsFactory5,
-  zodIsFactory as zodIsFactory5,
-  zodToFactory as zodToFactory5
-} from "@ariestools/sdk";
-import { asSchema as asSchema5, PayloadZodOfSchema as PayloadZodOfSchema5 } from "@xyo-network/sdk";
-import * as z6 from "zod/mini";
-var DomainRegistrationSchema = asSchema5(`${DomainSchema}.registration`, true);
-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 {
-  zodAsFactory as zodAsFactory6,
-  zodIsFactory as zodIsFactory6,
-  zodToFactory as zodToFactory6
-} from "@ariestools/sdk";
-import { asSchema as asSchema6, PayloadZodOfSchema as PayloadZodOfSchema6 } from "@xyo-network/sdk";
-import * as z7 from "zod/mini";
-var DomainRegistrationLeaseSchema = asSchema6(`${DomainRegistrationSchema}.lease`, true);
-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 PayloadBuilder2.toAllHashMap(payloads);
-  return bws.map((bw) => {
-    const hashLeaseEstimate = getPayloadBySchemaFromBoundWitness(
-      bw,
-      HashLeaseEstimateSchema,
-      hashMap,
-      asHashLeaseEstimate
-    );
-    if (!hashLeaseEstimate) return;
-    const domainLease = getPayloadBySchemaFromBoundWitness(
-      bw,
-      DomainRegistrationLeaseSchema,
-      hashMap,
-      asDomainRegistrationLease
-    );
-    if (!domainLease) return;
-    return [bw, hashLeaseEstimate, domainLease];
-  }).filter(exists);
-};
-var hasEstimatePayloads = (bw) => {
-  return bw.payload_schemas.includes(DomainRegistrationLeaseSchema) && bw.payload_schemas.includes(HashLeaseEstimateSchema);
-};
-var getPayloadBySchemaFromBoundWitness = (bw, schema, hashMap, identity) => {
-  const schemaIndex = bw.payload_schemas.indexOf(schema);
-  if (schemaIndex === -1) return;
-  const hash = bw.payload_hashes[schemaIndex];
-  return findAs([hashMap[hash]], identity);
-};
-
-// src/Dns/types/Answer.ts
-import * as z10 from "zod/mini";
-
-// src/Dns/types/Record.ts
-import * as z9 from "zod/mini";
-
-// 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
-  "NS": 2,
-  // an authoritative name server
-  "MD": 3,
-  // a mail destination (OBSOLETE - use MX)
-  "MF": 4,
-  // a mail forwarder (OBSOLETE - use MX)
-  "CNAME": 5,
-  // the canonical name for an alias
-  "SOA": 6,
-  // marks the start of a zone of authority
-  "MB": 7,
-  // a mailbox domain name (EXPERIMENTAL)
-  "MG": 8,
-  // a mail group member (EXPERIMENTAL)
-  "MR": 9,
-  // a mail rename domain name (EXPERIMENTAL)
-  "NULL": 10,
-  // a null RR (EXPERIMENTAL)
-  "WKS": 11,
-  // a well known service description
-  "PTR": 12,
-  // a domain name pointer
-  "HINFO": 13,
-  // host information
-  "MINFO": 14,
-  // mailbox or mail list information
-  "MX": 15,
-  // mail exchange
-  "TXT": 16,
-  // text strings
-  "RP": 17,
-  // for Responsible Person
-  "AFSDB": 18,
-  // for AFS Data Base location
-  "X25": 19,
-  // for X.25 PSDN address
-  "ISDN": 20,
-  // for ISDN address
-  "RT": 21,
-  // for Route Through
-  "NSAP": 22,
-  // for NSAP address, NSAP style A record (DEPRECATED)
-  "NSAP-PTR": 23,
-  // for domain name pointer, NSAP style (DEPRECATED)
-  "SIG": 24,
-  // for security signature
-  "KEY": 25,
-  // for security key
-  "PX": 26,
-  // X.400 mail mapping information
-  "GPOS": 27,
-  // Geographical Position
-  "AAAA": 28,
-  // IP6 Address
-  "LOC": 29,
-  // Location Information
-  "NXT": 30,
-  // Next Domain (OBSOLETE)
-  "EID": 31,
-  // Endpoint Identifier
-  "NIMLOC": 32,
-  // Nimrod Locator
-  "SRV": 33,
-  // Server Selection
-  "ATMA": 34,
-  // ATM Address
-  "NAPTR": 35,
-  // Naming Authority Pointer
-  "KX": 36,
-  // Key Exchanger
-  "CERT": 37,
-  // CERT
-  "A6": 38,
-  // A6 (OBSOLETE - use AAAA)
-  "DNAME": 39,
-  // DNAME
-  "SINK": 40,
-  // SINK
-  "OPT": 41,
-  // OPT
-  "APL": 42,
-  // APL
-  "DS": 43,
-  // Delegation Signer
-  "SSHFP": 44,
-  // SSH Key Fingerprint
-  "IPSECKEY": 45,
-  // IPSECKEY
-  "RRSIG": 46,
-  // RRSIG
-  "NSEC": 47,
-  // NSEC
-  "DNSKEY": 48,
-  // DNSKEY
-  "DHCID": 49,
-  // DHCID
-  "NSEC3": 50,
-  // NSEC3
-  "NSEC3PARAM": 51,
-  // NSEC3PARAM
-  "TLSA": 52,
-  // TLSA
-  "SMIMEA": 53,
-  // S/MIME cert association
-  "HIP": 55,
-  // Host Identity Protocol
-  "NINFO": 56,
-  // NINFO
-  "RKEY": 57,
-  // RKEY
-  "TALINK": 58,
-  // Trust Anchor LINK
-  "CDS": 59,
-  // Child DS
-  "CDNSKEY": 60,
-  // DNSKEY(s) the Child wants reflected in DS
-  "OPENPGPKEY": 61,
-  // OpenPGP Key
-  "CSYNC": 62,
-  // Child-To-Parent Synchronization
-  "ZONEMD": 63,
-  // Message Digest Over Zone Data
-  "SVCB": 64,
-  // General-purpose service binding
-  "HTTPS": 65,
-  // SVCB-compatible type for use with HTTP
-  "SPF": 99,
-  "UINFO": 100,
-  "UID": 101,
-  "GID": 102,
-  "UNSPEC": 103,
-  "NID": 104,
-  "L32": 105,
-  "L64": 106,
-  "LP": 107,
-  "EUI48": 108,
-  // an EUI-48 address
-  "EUI64": 109,
-  // an EUI-64 address
-  "NXNAME": 128,
-  // NXDOMAIN indicator for Compact Denial of Existence
-  "TKEY": 249,
-  // Transaction Key
-  "TSIG": 250,
-  // Transaction Signature
-  "IXFR": 251,
-  // incremental transfer
-  "AXFR": 252,
-  // transfer of an entire zone
-  "MAILB": 253,
-  // mailbox-related RRs (MB, MG or MR)
-  "MAILA": 254,
-  // mail agent RRs (OBSOLETE - see MX)
-  "*": 255,
-  // A request for some or all records the server has available
-  "URI": 256,
-  // URI
-  "CAA": 257,
-  // Certification Authority Restriction
-  "AVC": 258,
-  // Application Visibility and Control
-  "DOA": 259,
-  // Digital Object Architecture
-  "AMTRELAY": 260,
-  // Automatic Multicast Tunneling Relay
-  "RESINFO": 261,
-  // Resolver Information as Key/Value Pairs
-  "WALLET": 262,
-  // Public wallet address
-  "CLA": 263,
-  // BP Convergence Layer Adapter
-  "IPN": 264,
-  // BP Node Number
-  "TA": 32768,
-  // DNSSEC Trust Authorities
-  "DLV": 32769,
-  // DNSSEC Lookaside Validation (OBSOLETE)
-  // Custom types here chosen within the Private Use Range
-  // https://www.iana.org/assignments/dns-parameters/dns-parameters.xhtml#dns-parameters-4
-  // https://www.rfc-editor.org/rfc/rfc5226
-  // as, per the RFC, the Private Use Range is reserved
-  // "For private or local use only, with the type and
-  // purpose defined by the local site.  No attempt is made to
-  // prevent multiple sites from using the same value in
-  // different (and incompatible) ways.  There is no need for
-  // IANA to review such assignments (since IANA does not record
-  // them) and assignments are not generally useful for broad
-  // interoperability.  It is the responsibility of the sites
-  // making use of the Private Use range to ensure that no
-  // conflicts occur (within the intended scope of use)."
-  // If we want to apply for a custom reserved code later
-  // on, once the usage is proven enough we can absolutely
-  // do that.
-  "XYOA": 65432,
-  // XYO Address
-  "XYOH": 65433
-  // XYO Hash
-};
-var DNSResourceRecordTypeValueZod = z8.number();
-var findDNSResourceRecordTypesByValue = (value) => {
-  for (const key in DNSResourceRecordTypes) {
-    const resourceRecordType = key;
-    if (DNSResourceRecordTypes[resourceRecordType] === value) {
-      return resourceRecordType;
-    }
-  }
-  return void 0;
-};
-
-// 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,
-    ID: getRandomId(),
-    Question: [{
-      name: domain,
-      type,
-      class: 1
-    }]
-  };
-};
-var getRandomId = () => {
-  return Math.floor(Math.random() * 65536);
-};
-
-// 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";
-
-// src/Dns/Witness/Schema.ts
-import { asSchema as asSchema7 } from "@xyo-network/sdk";
-var DNSSchema = asSchema7("network.xyo.dns", true);
-
-// src/Dns/Witness/Config.ts
-var DNSWitnessConfigSchema = asSchema8(`${DNSSchema}.witness.config`, true);
-
-// src/Dns/Witness/Payload/Request.ts
-import {
-  zodAsFactory as zodAsFactory7,
-  zodIsFactory as zodIsFactory7,
-  zodToFactory as zodToFactory7
-} from "@ariestools/sdk";
-import { PayloadZodOfSchema as PayloadZodOfSchema7 } from "@xyo-network/sdk";
-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 {
-  zodAsFactory as zodAsFactory8,
-  zodIsFactory as zodIsFactory8,
-  zodToFactory as zodToFactory8
-} from "@ariestools/sdk";
-import { PayloadZodOfSchema as PayloadZodOfSchema8 } from "@xyo-network/sdk";
-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 {
-  HashZod,
-  zodAsFactory as zodAsFactory9,
-  zodIsFactory as zodIsFactory9,
-  zodToFactory as zodToFactory9
-} from "@ariestools/sdk";
-import { asSchema as asSchema9, PayloadZodOfSchema as PayloadZodOfSchema9 } from "@xyo-network/sdk";
-import * as z18 from "zod/mini";
-var HashRecordSchema = asSchema9("network.xyo.ns.record.hash", true);
-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,
-  asDNSResponse,
-  asDomain,
-  asDomainLease,
-  asDomainLeaseEstimateDivinerValidationErrorDetails,
-  asDomainRegistration,
-  asDomainRegistrationLease,
-  asHashRecord,
-  findDNSResourceRecordTypesByValue,
-  getDnsRequestFor,
-  getRandomId,
-  getRequestFor,
-  isAddressRecord,
-  isDNSRequest,
-  isDNSResponse,
-  isDomain,
-  isDomainLease,
-  isDomainLeaseEstimateDivinerValidationErrorDetails,
-  isDomainRegistration,
-  isDomainRegistrationLease,
-  isHashRecord,
-  isWithinDelegatedTimeframe,
-  parseEstimatesFromArray,
-  toAddressRecord,
-  toDNSRequest,
-  toDNSResponse,
-  toDomain,
-  toDomainLease,
-  toDomainLeaseEstimateDivinerValidationErrorDetails,
-  toDomainRegistration,
-  toDomainRegistrationLease,
-  toHashRecord,
-  validateBoundWitnessWithDuration,
-  validateDuration
-};
+// src/index.ts
+export * from "@xyo-network/payload-plugins/xns-record";
 //# sourceMappingURL=index.mjs.map