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

package/dist/neutral/Dns/types/OperationCodes.d.ts

@@ -0,0 +1,14 @@
+import * as z from 'zod/mini';
+export declare const DNSQueryOpcodeZod: z.ZodMiniUnion<readonly [z.ZodMiniLiteral<0>, z.ZodMiniLiteral<1>, z.ZodMiniLiteral<2>, z.ZodMiniLiteral<4>, z.ZodMiniLiteral<5>, z.ZodMiniLiteral<6>]>;
+export type DNSQueryOpcode = z.infer<typeof DNSQueryOpcodeZod>;
+export declare const DNSQueryOpcodeNameZod: z.ZodMiniEnum<{
+    QUERY: "QUERY";
+    IQUERY: "IQUERY";
+    STATUS: "STATUS";
+    NOTIFY: "NOTIFY";
+    UPDATE: "UPDATE";
+    DSO: "DSO";
+}>;
+export type DNSQueryOpcodeName = z.infer<typeof DNSQueryOpcodeNameZod>;
+export declare const DNSQueryOpcodes: Record<DNSQueryOpcodeName, DNSQueryOpcode>;
+//# sourceMappingURL=OperationCodes.d.ts.map

package/dist/neutral/Dns/types/OperationCodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OperationCodes.d.ts","sourceRoot":"","sources":["../../../../src/Dns/types/OperationCodes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAE7B,eAAO,MAAM,iBAAiB,yJAO5B,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAG9D,eAAO,MAAM,qBAAqB;;;;;;;EAAmE,CAAA;AAErG,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEtE,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,kBAAkB,EAAE,cAAc,CAOtE,CAAA"}

package/dist/neutral/Dns/types/Record.d.ts

@@ -0,0 +1,9 @@
+import * as z from 'zod/mini';
+export declare const DNSRecordZod: z.ZodMiniObject<{
+    name: z.ZodMiniString<string>;
+    type: z.ZodMiniNumber<number>;
+    TTL: z.ZodMiniNumber<number>;
+    data: z.ZodMiniString<string>;
+}, z.core.$strip>;
+export type DNSRecord = z.infer<typeof DNSRecordZod>;
+//# sourceMappingURL=Record.d.ts.map

package/dist/neutral/Dns/types/Record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Record.d.ts","sourceRoot":"","sources":["../../../../src/Dns/types/Record.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAI7B,eAAO,MAAM,YAAY;;;;;iBAKvB,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA"}

package/dist/neutral/Dns/types/Request.d.ts

@@ -0,0 +1,40 @@
+import * as z from 'zod/mini';
+import type { DNSResourceRecordTypeValue } from './ResourceRecord.ts';
+export declare const DNSQuestionZod: z.ZodMiniObject<{
+    name: z.ZodMiniString<string>;
+    type: z.ZodMiniNumber<number>;
+    class: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+}, z.core.$strip>;
+export type DNSQuestion = z.infer<typeof DNSQuestionZod>;
+export declare const DNSRequestFieldsZod: z.ZodMiniObject<{
+    ID: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    RD: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniLiteral<0>, z.ZodMiniLiteral<1>, z.ZodMiniLiteral<true>, z.ZodMiniLiteral<false>]>>;
+    QDCOUNT: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    QR: z.ZodMiniUnion<readonly [z.ZodMiniLiteral<0>, z.ZodMiniLiteral<false>]>;
+    Opcode: z.ZodMiniUnion<readonly [z.ZodMiniLiteral<0>, z.ZodMiniLiteral<1>, z.ZodMiniLiteral<2>, z.ZodMiniLiteral<4>, z.ZodMiniLiteral<5>, z.ZodMiniLiteral<6>]>;
+    AA: z.ZodMiniUnion<readonly [z.ZodMiniLiteral<0>, z.ZodMiniLiteral<false>]>;
+    TC: z.ZodMiniUnion<readonly [z.ZodMiniLiteral<0>, z.ZodMiniLiteral<false>]>;
+    RCODE: z.ZodMiniLiteral<0 | 2 | 1 | 4 | 3 | 5 | 6 | 7 | 8 | 9 | 10 | 16 | 17 | 18>;
+    ANCOUNT: z.ZodMiniLiteral<0>;
+    NSCOUNT: z.ZodMiniLiteral<0>;
+    ARCOUNT: z.ZodMiniLiteral<0>;
+    Question: z.ZodMiniArray<z.ZodMiniObject<{
+        name: z.ZodMiniString<string>;
+        type: z.ZodMiniNumber<number>;
+        class: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type DNSRequestFields = z.infer<typeof DNSRequestFieldsZod>;
+/**
+ * Helper for generating a DNS request for a given domain and record type
+ * @param domain The domain to query
+ * @param type The record type to query
+ * @returns A DNS request
+ */
+export declare const getRequestFor: (domain: string, type?: DNSResourceRecordTypeValue) => DNSRequestFields;
+/**
+ * Used to generate a random ID for a DNS request
+ * @returns A random number between 0 and 65,535
+ */
+export declare const getRandomId: () => number;
+//# sourceMappingURL=Request.d.ts.map

package/dist/neutral/Dns/types/Request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Request.d.ts","sourceRoot":"","sources":["../../../../src/Dns/types/Request.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAG7B,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAA;AAGrE,eAAO,MAAM,cAAc;;;;iBAIzB,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAExD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;iBAAuE,CAAA;AAEvG,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAElE;;;;;GAKG;AACH,eAAO,MAAM,aAAa,GAAI,QAAQ,MAAM,EAAE,OAAM,0BAAqD,KAAG,gBAQ3G,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,WAAW,QAAO,MAE9B,CAAA"}

package/dist/neutral/Dns/types/ResourceRecord.d.ts

@@ -0,0 +1,105 @@
+import * as z from 'zod/mini';
+export declare const DNSResourceRecordTypeZod: z.ZodMiniEnum<{
+    A: "A";
+    NS: "NS";
+    MD: "MD";
+    MF: "MF";
+    CNAME: "CNAME";
+    SOA: "SOA";
+    MB: "MB";
+    MG: "MG";
+    MR: "MR";
+    NULL: "NULL";
+    WKS: "WKS";
+    PTR: "PTR";
+    HINFO: "HINFO";
+    MINFO: "MINFO";
+    MX: "MX";
+    TXT: "TXT";
+    RP: "RP";
+    AFSDB: "AFSDB";
+    X25: "X25";
+    ISDN: "ISDN";
+    RT: "RT";
+    NSAP: "NSAP";
+    "NSAP-PTR": "NSAP-PTR";
+    SIG: "SIG";
+    KEY: "KEY";
+    PX: "PX";
+    GPOS: "GPOS";
+    AAAA: "AAAA";
+    LOC: "LOC";
+    NXT: "NXT";
+    EID: "EID";
+    NIMLOC: "NIMLOC";
+    SRV: "SRV";
+    ATMA: "ATMA";
+    NAPTR: "NAPTR";
+    KX: "KX";
+    CERT: "CERT";
+    A6: "A6";
+    DNAME: "DNAME";
+    SINK: "SINK";
+    OPT: "OPT";
+    APL: "APL";
+    DS: "DS";
+    SSHFP: "SSHFP";
+    IPSECKEY: "IPSECKEY";
+    RRSIG: "RRSIG";
+    NSEC: "NSEC";
+    DNSKEY: "DNSKEY";
+    DHCID: "DHCID";
+    NSEC3: "NSEC3";
+    NSEC3PARAM: "NSEC3PARAM";
+    TLSA: "TLSA";
+    SMIMEA: "SMIMEA";
+    HIP: "HIP";
+    NINFO: "NINFO";
+    RKEY: "RKEY";
+    TALINK: "TALINK";
+    CDS: "CDS";
+    CDNSKEY: "CDNSKEY";
+    OPENPGPKEY: "OPENPGPKEY";
+    CSYNC: "CSYNC";
+    ZONEMD: "ZONEMD";
+    SVCB: "SVCB";
+    HTTPS: "HTTPS";
+    SPF: "SPF";
+    UINFO: "UINFO";
+    UID: "UID";
+    GID: "GID";
+    UNSPEC: "UNSPEC";
+    NID: "NID";
+    L32: "L32";
+    L64: "L64";
+    LP: "LP";
+    EUI48: "EUI48";
+    EUI64: "EUI64";
+    NXNAME: "NXNAME";
+    TKEY: "TKEY";
+    TSIG: "TSIG";
+    IXFR: "IXFR";
+    AXFR: "AXFR";
+    MAILB: "MAILB";
+    MAILA: "MAILA";
+    "*": "*";
+    URI: "URI";
+    CAA: "CAA";
+    AVC: "AVC";
+    DOA: "DOA";
+    AMTRELAY: "AMTRELAY";
+    RESINFO: "RESINFO";
+    WALLET: "WALLET";
+    CLA: "CLA";
+    IPN: "IPN";
+    TA: "TA";
+    DLV: "DLV";
+    XYOA: "XYOA";
+    XYOH: "XYOH";
+}>;
+export type DNSResourceRecordType = z.infer<typeof DNSResourceRecordTypeZod>;
+export declare const DNSResourceRecordTypes: Readonly<Record<DNSResourceRecordType, number>>;
+export declare const DNSResourceRecordTypeValueZod: z.ZodMiniNumber<number>;
+export type DNSResourceRecordTypeValue = (typeof DNSResourceRecordTypes)[keyof typeof DNSResourceRecordTypes];
+export declare const findDNSResourceRecordTypesByValue: (value: DNSResourceRecordTypeValue) => DNSResourceRecordType | undefined;
+//# sourceMappingURL=ResourceRecord.d.ts.map

package/dist/neutral/Dns/types/ResourceRecord.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ResourceRecord.d.ts","sourceRoot":"","sources":["../../../../src/Dns/types/ResourceRecord.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAE7B,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkGnC,CAAA;AAEF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAE5E,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,MAAM,CAAC,qBAAqB,EAAE,MAAM,CAAC,CAkHlF,CAAA;AAED,eAAO,MAAM,6BAA6B,yBAAa,CAAA;AAEvD,MAAM,MAAM,0BAA0B,GAAG,CAAC,OAAO,sBAAsB,CAAC,CAAC,MAAM,OAAO,sBAAsB,CAAC,CAAA;AAE7G,eAAO,MAAM,iCAAiC,GAAI,OAAO,0BAA0B,KAAG,qBAAqB,GAAG,SAS7G,CAAA"}

package/dist/neutral/Dns/types/Response.d.ts

@@ -0,0 +1,41 @@
+import * as z from 'zod/mini';
+export declare const DNSResponseFieldsZod: z.ZodMiniObject<{
+    ID: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    RD: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniLiteral<0>, z.ZodMiniLiteral<1>, z.ZodMiniLiteral<true>, z.ZodMiniLiteral<false>]>>;
+    RCODE: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniLiteral<0>, z.ZodMiniLiteral<1>, z.ZodMiniLiteral<2>, z.ZodMiniLiteral<3>, z.ZodMiniLiteral<4>, z.ZodMiniLiteral<5>, z.ZodMiniLiteral<6>, z.ZodMiniLiteral<7>, z.ZodMiniLiteral<8>, z.ZodMiniLiteral<9>, z.ZodMiniLiteral<10>, z.ZodMiniLiteral<16>, z.ZodMiniLiteral<17>, z.ZodMiniLiteral<18>]>>;
+    QDCOUNT: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    ANCOUNT: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    NSCOUNT: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    ARCOUNT: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    QR: z.ZodMiniUnion<readonly [z.ZodMiniLiteral<1>, z.ZodMiniLiteral<true>]>;
+    Opcode: z.ZodMiniUnion<readonly [z.ZodMiniLiteral<0>, z.ZodMiniLiteral<1>, z.ZodMiniLiteral<2>, z.ZodMiniLiteral<4>, z.ZodMiniLiteral<5>, z.ZodMiniLiteral<6>]>;
+    AA: z.ZodMiniUnion<readonly [z.ZodMiniLiteral<0>, z.ZodMiniLiteral<1>, z.ZodMiniLiteral<true>, z.ZodMiniLiteral<false>]>;
+    TC: z.ZodMiniUnion<readonly [z.ZodMiniLiteral<0>, z.ZodMiniLiteral<1>, z.ZodMiniLiteral<true>, z.ZodMiniLiteral<false>]>;
+    RA: z.ZodMiniUnion<readonly [z.ZodMiniLiteral<0>, z.ZodMiniLiteral<1>, z.ZodMiniLiteral<true>, z.ZodMiniLiteral<false>]>;
+    Question: z.ZodMiniArray<z.ZodMiniObject<{
+        name: z.ZodMiniString<string>;
+        type: z.ZodMiniNumber<number>;
+        class: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    }, z.core.$strip>>;
+    Answer: z.ZodMiniArray<z.ZodMiniObject<{
+        name: z.ZodMiniString<string>;
+        type: z.ZodMiniNumber<number>;
+        TTL: z.ZodMiniNumber<number>;
+        data: z.ZodMiniString<string>;
+        class: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    }, z.core.$strip>>;
+    Authority: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniObject<{
+        name: z.ZodMiniString<string>;
+        type: z.ZodMiniNumber<number>;
+        TTL: z.ZodMiniNumber<number>;
+        data: z.ZodMiniString<string>;
+    }, z.core.$strip>>>;
+    Additional: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniObject<{
+        name: z.ZodMiniString<string>;
+        type: z.ZodMiniNumber<number>;
+        TTL: z.ZodMiniNumber<number>;
+        data: z.ZodMiniString<string>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type DNSResponseFields = z.infer<typeof DNSResponseFieldsZod>;
+//# sourceMappingURL=Response.d.ts.map

package/dist/neutral/Dns/types/Response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Response.d.ts","sourceRoot":"","sources":["../../../../src/Dns/types/Response.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAO7B,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAK/B,CAAA;AAEF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA"}

package/dist/neutral/Dns/types/ResponseCodes.d.ts

@@ -0,0 +1,22 @@
+import * as z from 'zod/mini';
+export declare const DNSRcodeZod: z.ZodMiniUnion<readonly [z.ZodMiniLiteral<0>, z.ZodMiniLiteral<1>, z.ZodMiniLiteral<2>, z.ZodMiniLiteral<3>, z.ZodMiniLiteral<4>, z.ZodMiniLiteral<5>, z.ZodMiniLiteral<6>, z.ZodMiniLiteral<7>, z.ZodMiniLiteral<8>, z.ZodMiniLiteral<9>, z.ZodMiniLiteral<10>, z.ZodMiniLiteral<16>, z.ZodMiniLiteral<17>, z.ZodMiniLiteral<18>]>;
+export type DNSRcode = z.infer<typeof DNSRcodeZod>;
+export declare const DNSRcodeNameZod: z.ZodMiniEnum<{
+    NOERROR: "NOERROR";
+    FORMERR: "FORMERR";
+    SERVFAIL: "SERVFAIL";
+    NXDOMAIN: "NXDOMAIN";
+    NOTIMP: "NOTIMP";
+    REFUSED: "REFUSED";
+    YXDOMAIN: "YXDOMAIN";
+    YXRRSET: "YXRRSET";
+    NXRRSET: "NXRRSET";
+    NOTAUTH: "NOTAUTH";
+    NOTZONE: "NOTZONE";
+    BADSIG: "BADSIG";
+    BADKEY: "BADKEY";
+    BADTIME: "BADTIME";
+}>;
+export type DNSRcodeName = z.infer<typeof DNSRcodeNameZod>;
+export declare const DNSRcodes: Readonly<Record<DNSRcodeName, DNSRcode>>;
+//# sourceMappingURL=ResponseCodes.d.ts.map

package/dist/neutral/Dns/types/ResponseCodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ResponseCodes.d.ts","sourceRoot":"","sources":["../../../../src/Dns/types/ResponseCodes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAE7B,eAAO,MAAM,WAAW,qUAetB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAElD,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;EAe1B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAE1D,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,YAAY,EAAE,QAAQ,CAAC,CAe9D,CAAA"}

package/dist/neutral/{DNS → Dns}/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/DNS/types/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA;AAC3B,cAAc,qBAAqB,CAAA;AACnC,cAAc,aAAa,CAAA;AAC3B,cAAc,cAAc,CAAA;AAC5B,cAAc,qBAAqB,CAAA;AACnC,cAAc,eAAe,CAAA;AAC7B,cAAc,oBAAoB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/Dns/types/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA;AAC3B,cAAc,qBAAqB,CAAA;AACnC,cAAc,aAAa,CAAA;AAC3B,cAAc,cAAc,CAAA;AAC5B,cAAc,qBAAqB,CAAA;AACnC,cAAc,eAAe,CAAA;AAC7B,cAAc,oBAAoB,CAAA"}

package/dist/neutral/Domain/Domain.d.ts

@@ -1,4 +1,4 @@
-import type { Payload, WithSources } from '@xyo-network/sdk-js';
+import * as z from 'zod/mini';
 export type DomainSchema = typeof DomainSchema;
 export declare const DomainSchema: "network.xyo.ns.domain" & {
     readonly __schema: true;
@@ -6,34 +6,67 @@ export declare const DomainSchema: "network.xyo.ns.domain" & {
 /**
  * The supported TLDs for XNS
  */
-export type TopLevelDomain = 'xyo';
+export declare const TopLevelDomainZod: z.ZodMiniLiteral<"xyo">;
+export type TopLevelDomain = z.infer<typeof TopLevelDomainZod>;
 /**
  * The fields for a domain record
  */
-export interface DomainFields {
-    /**
-     * The XNS domain of the record
-     */
-    domain: string;
-    /**
-     * The Top-Level Domain of the domain
-     */
-    tld: TopLevelDomain;
-}
+export declare const DomainFieldsZod: z.ZodMiniObject<{
+    domain: z.ZodMiniString<string>;
+    tld: z.ZodMiniLiteral<"xyo">;
+}, z.core.$strip>;
+export type DomainFields = z.infer<typeof DomainFieldsZod>;
 /**
  * A domain record is a record of a domain
  */
-export type Domain = Payload<DomainFields, DomainSchema>;
+export declare const DomainZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<"network.xyo.ns.domain" & {
+        readonly __schema: true;
+    }>;
+    domain: z.ZodMiniString<string>;
+    tld: z.ZodMiniLiteral<"xyo">;
+}, z.core.$strip>;
+export type Domain = z.infer<typeof DomainZod>;
 /**
  * Identity function for Domain payload
  */
-export declare const isDomain: (x?: unknown) => x is Domain;
-export declare const asDomain: import("@xylabs/sdk-js").AsTypeFunction<Domain>;
-export declare const asOptionalDomain: (value: import("@xylabs/sdk-js").AnyNonPromise) => Domain | undefined;
-/**
- * Identity function for Domain payload with sources
- */
-export declare const isDomainWithSources: (x?: unknown) => x is WithSources<WithSources<Domain>>;
-export declare const asDomainWithSources: import("@xylabs/sdk-js").AsTypeFunction<WithSources<Domain>>;
-export declare const asOptionalDomainWithSources: (value: import("@xylabs/sdk-js").AnyNonPromise) => WithSources<Domain> | undefined;
+export declare const isDomain: <T>(value: T) => value is T & {
+    schema: "network.xyo.ns.domain" & {
+        readonly __schema: true;
+    };
+    domain: string;
+    tld: "xyo";
+};
+export declare const asDomain: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.ns.domain" & {
+            readonly __schema: true;
+        };
+        domain: string;
+        tld: "xyo";
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk-js").ZodFactoryConfig): T & {
+        schema: "network.xyo.ns.domain" & {
+            readonly __schema: true;
+        };
+        domain: string;
+        tld: "xyo";
+    };
+};
+export declare const toDomain: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.ns.domain" & {
+            readonly __schema: true;
+        };
+        domain: string;
+        tld: "xyo";
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk-js").ZodFactoryConfig): T & {
+        schema: "network.xyo.ns.domain" & {
+            readonly __schema: true;
+        };
+        domain: string;
+        tld: "xyo";
+    };
+};
 //# sourceMappingURL=Domain.d.ts.map

package/dist/neutral/Domain/Domain.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Domain.d.ts","sourceRoot":"","sources":["../../../src/Domain/Domain.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AAK/D,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAA;AAC9C,eAAO,MAAM,YAAY;;CAA0C,CAAA;AAEnE;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,KAAK,CAAA;AAElC;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B;;OAEG;IACH,MAAM,EAAE,MAAM,CAAA;IAEd;;OAEG;IACH,GAAG,EAAE,cAAc,CAAA;CACpB;AAED;;GAEG;AACH,MAAM,MAAM,MAAM,GAAG,OAAO,CAAC,YAAY,EAAE,YAAY,CAAC,CAAA;AAExD;;GAEG;AACH,eAAO,MAAM,QAAQ,8BAA8C,CAAA;AACnE,eAAO,MAAM,QAAQ,iDAA2C,CAAA;AAChE,eAAO,MAAM,gBAAgB,uEAAmD,CAAA;AAEhF;;GAEG;AACH,eAAO,MAAM,mBAAmB,wDAAsE,CAAA;AACtG,eAAO,MAAM,mBAAmB,8DAAmE,CAAA;AACnG,eAAO,MAAM,2BAA2B,oFAA2E,CAAA"}
+{"version":3,"file":"Domain.d.ts","sourceRoot":"","sources":["../../../src/Domain/Domain.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAE7B,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAA;AAC9C,eAAO,MAAM,YAAY;;CAA0C,CAAA;AAEnE;;GAEG;AACH,eAAO,MAAM,iBAAiB,yBAAmB,CAAA;AAEjD,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE9D;;GAEG;AACH,eAAO,MAAM,eAAe;;;iBAU1B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAE1D;;GAEG;AACH,eAAO,MAAM,SAAS;;;;;;iBAA2E,CAAA;AAEjG,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA;AAE9C;;GAEG;AACH,eAAO,MAAM,QAAQ;;;;;;CAA0B,CAAA;AAC/C,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;CAAsC,CAAA;AAC3D,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;CAAsC,CAAA"}

package/dist/neutral/Domain/DomainLease.d.ts

@@ -1,6 +1,4 @@
-import type { Payload, WithSources } from '@xyo-network/sdk-js';
-import type { DurationFields } from '../Duration/index.ts';
-import type { DomainFields } from './Domain.ts';
+import * as z from 'zod/mini';
 export type DomainLeaseSchema = typeof DomainLeaseSchema;
 export declare const DomainLeaseSchema: "network.xyo.ns.domain.lease" & {
     readonly __schema: true;
@@ -8,22 +6,76 @@ export declare const DomainLeaseSchema: "network.xyo.ns.domain.lease" & {
 /**
  * A domain is leased for a duration
  */
-export interface DomainLeaseFields extends DomainFields, DurationFields {
-}
+export declare const DomainLeaseFieldsZod: z.ZodMiniObject<{
+    exp: z.ZodMiniNumber<number>;
+    nbf: z.ZodMiniNumber<number>;
+    domain: z.ZodMiniString<string>;
+    tld: z.ZodMiniLiteral<"xyo">;
+}, z.core.$strip>;
+export type DomainLeaseFields = z.infer<typeof DomainLeaseFieldsZod>;
 /**
  * A domain lease is a record of a domain and the duration it is leased for
  */
-export type DomainLease = Payload<DomainLeaseFields, DomainLeaseSchema>;
+export declare const DomainLeaseZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<"network.xyo.ns.domain.lease" & {
+        readonly __schema: true;
+    }>;
+    exp: z.ZodMiniNumber<number>;
+    nbf: z.ZodMiniNumber<number>;
+    domain: z.ZodMiniString<string>;
+    tld: z.ZodMiniLiteral<"xyo">;
+}, z.core.$strip>;
+export type DomainLease = z.infer<typeof DomainLeaseZod>;
 /**
  * Identity function for DomainLease payload
  */
-export declare const isDomainLease: (x?: unknown) => x is DomainLease;
-export declare const asDomainLease: import("@xylabs/sdk-js").AsTypeFunction<DomainLease>;
-export declare const asOptionalDomainLease: (value: import("@xylabs/sdk-js").AnyNonPromise) => DomainLease | undefined;
-/**
- * Identity function for DomainLease payload with sources
- */
-export declare const isDomainLeaseWithSources: (x?: unknown) => x is WithSources<WithSources<DomainLease>>;
-export declare const asDomainLeaseWithSources: import("@xylabs/sdk-js").AsTypeFunction<WithSources<DomainLease>>;
-export declare const asOptionalDomainLeaseWithSources: (value: import("@xylabs/sdk-js").AnyNonPromise) => WithSources<DomainLease> | undefined;
+export declare const isDomainLease: <T>(value: T) => value is T & {
+    schema: "network.xyo.ns.domain.lease" & {
+        readonly __schema: true;
+    };
+    exp: number;
+    nbf: number;
+    domain: string;
+    tld: "xyo";
+};
+export declare const asDomainLease: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.ns.domain.lease" & {
+            readonly __schema: true;
+        };
+        exp: number;
+        nbf: number;
+        domain: string;
+        tld: "xyo";
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk-js").ZodFactoryConfig): T & {
+        schema: "network.xyo.ns.domain.lease" & {
+            readonly __schema: true;
+        };
+        exp: number;
+        nbf: number;
+        domain: string;
+        tld: "xyo";
+    };
+};
+export declare const toDomainLease: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.ns.domain.lease" & {
+            readonly __schema: true;
+        };
+        exp: number;
+        nbf: number;
+        domain: string;
+        tld: "xyo";
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk-js").ZodFactoryConfig): T & {
+        schema: "network.xyo.ns.domain.lease" & {
+            readonly __schema: true;
+        };
+        exp: number;
+        nbf: number;
+        domain: string;
+        tld: "xyo";
+    };
+};
 //# sourceMappingURL=DomainLease.d.ts.map

package/dist/neutral/Domain/DomainLease.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DomainLease.d.ts","sourceRoot":"","sources":["../../../src/Domain/DomainLease.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AAK/D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE/C,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAA;AACxD,eAAO,MAAM,iBAAiB;;CAAgD,CAAA;AAE9E;;GAEG;AACH,MAAM,WAAW,iBAAkB,SAAQ,YAAY,EAAE,cAAc;CAAG;AAE1E;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC,iBAAiB,EAAE,iBAAiB,CAAC,CAAA;AAEvE;;GAEG;AACH,eAAO,MAAM,aAAa,mCAAwD,CAAA;AAClF,eAAO,MAAM,aAAa,sDAAqD,CAAA;AAC/E,eAAO,MAAM,qBAAqB,4EAA6D,CAAA;AAE/F;;GAEG;AACH,eAAO,MAAM,wBAAwB,6DAAgF,CAAA;AACrH,eAAO,MAAM,wBAAwB,mEAA6E,CAAA;AAClH,eAAO,MAAM,gCAAgC,yFAAqF,CAAA"}
+{"version":3,"file":"DomainLease.d.ts","sourceRoot":"","sources":["../../../src/Domain/DomainLease.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAK7B,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAA;AACxD,eAAO,MAAM,iBAAiB;;CAAgD,CAAA;AAE9E;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;iBAG/B,CAAA;AAEF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEpE;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;iBAAqF,CAAA;AAEhH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAExD;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;;;;CAA+B,CAAA;AACzD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;CAAgD,CAAA;AAC1E,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;CAAgD,CAAA"}

package/dist/neutral/DomainRegistration/DomainRegistration.d.ts

@@ -1,34 +1,134 @@
-import type { Address } from '@xylabs/sdk-js';
-import type { Payload, WithSources } from '@xyo-network/sdk-js';
-import type { DomainFields } from '../Domain/index.ts';
+import * as z from 'zod/mini';
 export declare const DomainRegistrationSchema: string & {
     readonly __schema: true;
 };
 export type DomainRegistrationSchema = typeof DomainRegistrationSchema;
-export interface DomainRegistrationFields extends DomainFields {
-    /**
-     * The registrant of the domain
-     */
-    registrant: Address[];
-    /**
-     * The registrar of the domain
-     */
-    registrar: Address[];
-}
+export declare const DomainRegistrationFieldsZod: z.ZodMiniObject<{
+    registrant: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }, string>>>;
+    registrar: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }, string>>>;
+    domain: z.ZodMiniString<string>;
+    tld: z.ZodMiniLiteral<"xyo">;
+}, z.core.$strip>;
+export type DomainRegistrationFields = z.infer<typeof DomainRegistrationFieldsZod>;
 /**
  * Delegation of a domain to a registrar by a registrant
  */
-export type DomainRegistration = Payload<DomainRegistrationFields, DomainRegistrationSchema>;
+export declare const DomainRegistrationZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<string & {
+        readonly __schema: true;
+    }>;
+    registrant: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }, string>>>;
+    registrar: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }, string>>>;
+    domain: z.ZodMiniString<string>;
+    tld: z.ZodMiniLiteral<"xyo">;
+}, z.core.$strip>;
+export type DomainRegistration = z.infer<typeof DomainRegistrationZod>;
 /**
  * Identity function for DomainRegistration payload
  */
-export declare const isDomainRegistration: (x?: unknown) => x is DomainRegistration;
-export declare const asDomainRegistration: import("@xylabs/sdk-js").AsTypeFunction<DomainRegistration>;
-export declare const asOptionalDomainRegistration: (value: import("@xylabs/sdk-js").AnyNonPromise) => DomainRegistration | undefined;
-/**
- * Identity function for DomainRegistration payload with sources
- */
-export declare const isDomainRegistrationWithSources: (x?: unknown) => x is WithSources<WithSources<DomainRegistration>>;
-export declare const asDomainRegistrationWithSources: import("@xylabs/sdk-js").AsTypeFunction<WithSources<DomainRegistration>>;
-export declare const asOptionalDomainRegistrationWithSources: (value: import("@xylabs/sdk-js").AnyNonPromise) => WithSources<DomainRegistration> | undefined;
+export declare const isDomainRegistration: <T>(value: T) => value is T & {
+    schema: string & {
+        readonly __schema: true;
+    };
+    registrant: (Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    })[];
+    registrar: (Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    })[];
+    domain: string;
+    tld: "xyo";
+};
+export declare const asDomainRegistration: {
+    <T>(value: T): (T & {
+        schema: string & {
+            readonly __schema: true;
+        };
+        registrant: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        })[];
+        registrar: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        })[];
+        domain: string;
+        tld: "xyo";
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk-js").ZodFactoryConfig): T & {
+        schema: string & {
+            readonly __schema: true;
+        };
+        registrant: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        })[];
+        registrar: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        })[];
+        domain: string;
+        tld: "xyo";
+    };
+};
+export declare const toDomainRegistration: {
+    <T>(value: T): (T & {
+        schema: string & {
+            readonly __schema: true;
+        };
+        registrant: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        })[];
+        registrar: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        })[];
+        domain: string;
+        tld: "xyo";
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk-js").ZodFactoryConfig): T & {
+        schema: string & {
+            readonly __schema: true;
+        };
+        registrant: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        })[];
+        registrar: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        })[];
+        domain: string;
+        tld: "xyo";
+    };
+};
 //# sourceMappingURL=DomainRegistration.d.ts.map

package/dist/neutral/DomainRegistration/DomainRegistration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DomainRegistration.d.ts","sourceRoot":"","sources":["../../../src/DomainRegistration/DomainRegistration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAA;AAE7C,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AAK/D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAGtD,eAAO,MAAM,wBAAwB;;CAAiD,CAAA;AACtF,MAAM,MAAM,wBAAwB,GAAG,OAAO,wBAAwB,CAAA;AAEtE,MAAM,WAAW,wBAAyB,SAAQ,YAAY;IAC5D;;OAEG;IACH,UAAU,EAAE,OAAO,EAAE,CAAA;IACrB;;OAEG;IACH,SAAS,EAAE,OAAO,EAAE,CAAA;CACrB;AAED;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,OAAO,CAAC,wBAAwB,EAAE,wBAAwB,CAAC,CAAA;AAE5F;;GAEG;AACH,eAAO,MAAM,oBAAoB,0CAAsE,CAAA;AACvG,eAAO,MAAM,oBAAoB,6DAAmE,CAAA;AACpG,eAAO,MAAM,4BAA4B,mFAA2E,CAAA;AAEpH;;GAEG;AACH,eAAO,MAAM,+BAA+B,oEAA8F,CAAA;AAC1I,eAAO,MAAM,+BAA+B,0EAA2F,CAAA;AACvI,eAAO,MAAM,uCAAuC,gGAAmG,CAAA"}
+{"version":3,"file":"DomainRegistration.d.ts","sourceRoot":"","sources":["../../../src/DomainRegistration/DomainRegistration.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAI7B,eAAO,MAAM,wBAAwB;;CAAiD,CAAA;AACtF,MAAM,MAAM,wBAAwB,GAAG,OAAO,wBAAwB,CAAA;AAEtE,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;iBAUtC,CAAA;AAEF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAElF;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;iBAAmG,CAAA;AAErI,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEtE;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;CAAsC,CAAA;AACvE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA8D,CAAA;AAC/F,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA8D,CAAA"}