@xyo-network/payload-plugins 7.0.2 → 7.0.4

package/dist/neutral/modules/xns-record/Dns/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/xns-record/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/modules/xns-record/Domain/Domain.d.ts

@@ -0,0 +1,72 @@
+import * as z from 'zod/mini';
+export type DomainSchema = typeof DomainSchema;
+export declare const DomainSchema: "network.xyo.ns.domain" & {
+    readonly __schema: true;
+};
+/**
+ * The supported TLDs for XNS
+ */
+export declare const TopLevelDomainZod: z.ZodMiniLiteral<"xyo">;
+export type TopLevelDomain = z.infer<typeof TopLevelDomainZod>;
+/**
+ * The fields for a domain record
+ */
+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 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: <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("@ariestools/sdk").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("@ariestools/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.ns.domain" & {
+            readonly __schema: true;
+        };
+        domain: string;
+        tld: "xyo";
+    };
+};
+//# sourceMappingURL=Domain.d.ts.map

package/dist/neutral/modules/xns-record/Domain/Domain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Domain.d.ts","sourceRoot":"","sources":["../../../../../src/modules/xns-record/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/modules/xns-record/Domain/DomainLease.d.ts

@@ -0,0 +1,81 @@
+import * as z from 'zod/mini';
+export type DomainLeaseSchema = typeof DomainLeaseSchema;
+export declare const DomainLeaseSchema: "network.xyo.ns.domain.lease" & {
+    readonly __schema: true;
+};
+/**
+ * A domain is leased for a duration
+ */
+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 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: <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("@ariestools/sdk").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("@ariestools/sdk").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/modules/xns-record/Domain/DomainLease.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DomainLease.d.ts","sourceRoot":"","sources":["../../../../../src/modules/xns-record/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/modules/xns-record/Domain/index.d.ts

@@ -0,0 +1,3 @@
+export * from './Domain.js';
+export * from './DomainLease.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/neutral/modules/xns-record/Domain/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/modules/xns-record/Domain/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,kBAAkB,CAAA"}

package/dist/neutral/modules/xns-record/DomainEstimate/DomainEstimate.d.ts

@@ -0,0 +1,9 @@
+import type { HashLeaseEstimate } from '@xyo-network/diviner-hash-lease';
+import type { BoundWitness, WithSources } from '@xyo-network/sdk';
+import type { DomainRegistrationLease } from '../DomainRegistration/index.js';
+export type DomainEstimate = [
+    BoundWitness,
+    WithSources<HashLeaseEstimate>,
+    WithSources<DomainRegistrationLease>
+];
+//# sourceMappingURL=DomainEstimate.d.ts.map

package/dist/neutral/modules/xns-record/DomainEstimate/DomainEstimate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DomainEstimate.d.ts","sourceRoot":"","sources":["../../../../../src/modules/xns-record/DomainEstimate/DomainEstimate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAA;AACxE,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAEjE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAA;AAE7E,MAAM,MAAM,cAAc,GAAG;IAC3B,YAAY;IACZ,WAAW,CAAC,iBAAiB,CAAC;IAC9B,WAAW,CAAC,uBAAuB,CAAC;CACrC,CAAA"}

package/dist/neutral/modules/xns-record/DomainEstimate/index.d.ts

@@ -0,0 +1,2 @@
+export * from './DomainEstimate.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/neutral/modules/xns-record/DomainEstimate/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/modules/xns-record/DomainEstimate/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAA"}

package/dist/neutral/modules/xns-record/DomainRegistration/DomainRegistration.d.ts

@@ -0,0 +1,134 @@
+import * as z from 'zod/mini';
+export declare const DomainRegistrationSchema: string & {
+    readonly __schema: true;
+};
+export type DomainRegistrationSchema = typeof DomainRegistrationSchema;
+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 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: <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("@ariestools/sdk").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("@ariestools/sdk").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/modules/xns-record/DomainRegistration/DomainRegistration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DomainRegistration.d.ts","sourceRoot":"","sources":["../../../../../src/modules/xns-record/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"}

package/dist/neutral/modules/xns-record/DomainRegistration/DomainRegistrationLease.d.ts

@@ -0,0 +1,148 @@
+import * as z from 'zod/mini';
+export declare const DomainRegistrationLeaseSchema: string & {
+    readonly __schema: true;
+};
+export type DomainRegistrationLeaseSchema = typeof DomainRegistrationLeaseSchema;
+export declare const DomainRegistrationLeaseFieldsZod: z.ZodMiniObject<{
+    exp: z.ZodMiniNumber<number>;
+    nbf: z.ZodMiniNumber<number>;
+    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 DomainRegistrationLeaseFields = z.infer<typeof DomainRegistrationLeaseFieldsZod>;
+/**
+ * Temporal delegation of a domain to a registrar by a registrant
+ */
+export declare const DomainRegistrationLeaseZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<string & {
+        readonly __schema: true;
+    }>;
+    exp: z.ZodMiniNumber<number>;
+    nbf: z.ZodMiniNumber<number>;
+    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 DomainRegistrationLease = z.infer<typeof DomainRegistrationLeaseZod>;
+/**
+ * Identity function for DomainRegistrationLease payload
+ */
+export declare const isDomainRegistrationLease: <T>(value: T) => value is T & {
+    schema: string & {
+        readonly __schema: true;
+    };
+    exp: number;
+    nbf: number;
+    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 asDomainRegistrationLease: {
+    <T>(value: T): (T & {
+        schema: string & {
+            readonly __schema: true;
+        };
+        exp: number;
+        nbf: number;
+        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("@ariestools/sdk").ZodFactoryConfig): T & {
+        schema: string & {
+            readonly __schema: true;
+        };
+        exp: number;
+        nbf: number;
+        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 toDomainRegistrationLease: {
+    <T>(value: T): (T & {
+        schema: string & {
+            readonly __schema: true;
+        };
+        exp: number;
+        nbf: number;
+        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("@ariestools/sdk").ZodFactoryConfig): T & {
+        schema: string & {
+            readonly __schema: true;
+        };
+        exp: number;
+        nbf: number;
+        registrant: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        })[];
+        registrar: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        })[];
+        domain: string;
+        tld: "xyo";
+    };
+};
+//# sourceMappingURL=DomainRegistrationLease.d.ts.map

package/dist/neutral/modules/xns-record/DomainRegistration/DomainRegistrationLease.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DomainRegistrationLease.d.ts","sourceRoot":"","sources":["../../../../../src/modules/xns-record/DomainRegistration/DomainRegistrationLease.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAK7B,eAAO,MAAM,6BAA6B;;CAAsD,CAAA;AAChG,MAAM,MAAM,6BAA6B,GAAG,OAAO,6BAA6B,CAAA;AAEhF,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;iBAG3C,CAAA;AAEF,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAA;AAE5F;;GAEG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;iBAA6G,CAAA;AAEpJ,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAEhF;;GAEG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;CAA2C,CAAA;AACjF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAwE,CAAA;AAC9G,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAwE,CAAA"}

package/dist/neutral/modules/xns-record/DomainRegistration/index.d.ts

@@ -0,0 +1,3 @@
+export * from './DomainRegistration.js';
+export * from './DomainRegistrationLease.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/neutral/modules/xns-record/DomainRegistration/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/modules/xns-record/DomainRegistration/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAA;AACvC,cAAc,8BAA8B,CAAA"}

package/dist/neutral/modules/xns-record/Duration/Duration.d.ts

@@ -0,0 +1,7 @@
+import * as z from 'zod/mini';
+export declare const DurationFieldsZod: z.ZodMiniObject<{
+    exp: z.ZodMiniNumber<number>;
+    nbf: z.ZodMiniNumber<number>;
+}, z.core.$strip>;
+export type DurationFields = z.infer<typeof DurationFieldsZod>;
+//# sourceMappingURL=Duration.d.ts.map

package/dist/neutral/modules/xns-record/Duration/Duration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Duration.d.ts","sourceRoot":"","sources":["../../../../../src/modules/xns-record/Duration/Duration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAE7B,eAAO,MAAM,iBAAiB;;;iBAU5B,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA"}

package/dist/neutral/modules/xns-record/Duration/index.d.ts

@@ -0,0 +1,3 @@
+export * from './Duration.js';
+export * from './validation/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/neutral/modules/xns-record/Duration/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/modules/xns-record/Duration/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA;AAC7B,cAAc,uBAAuB,CAAA"}

package/dist/neutral/modules/xns-record/Duration/validation/index.d.ts

@@ -0,0 +1,3 @@
+export * from './validateBoundWitnessWithDuration.js';
+export * from './validateDuration.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/neutral/modules/xns-record/Duration/validation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/xns-record/Duration/validation/index.ts"],"names":[],"mappings":"AAAA,cAAc,uCAAuC,CAAA;AACrD,cAAc,uBAAuB,CAAA"}

package/dist/neutral/modules/xns-record/Duration/validation/validateBoundWitness.d.ts

@@ -0,0 +1,3 @@
+import type { BoundWitness, Schema } from '@xyo-network/sdk';
+export declare const validateBoundWitness: (recordBw: BoundWitness, requiredSchemas?: Schema[]) => Promise<boolean>;
+//# sourceMappingURL=validateBoundWitness.d.ts.map

package/dist/neutral/modules/xns-record/Duration/validation/validateBoundWitness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateBoundWitness.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/xns-record/Duration/validation/validateBoundWitness.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAI5D,eAAO,MAAM,oBAAoB,GAAU,UAAU,YAAY,EAAE,kBAAiB,MAAM,EAAO,KAAG,OAAO,CAAC,OAAO,CAOlH,CAAA"}

package/dist/neutral/modules/xns-record/Duration/validation/validateBoundWitnessAndDuration.d.ts

@@ -0,0 +1,4 @@
+import type { BoundWitness, Payload } from '@xyo-network/sdk';
+import type { DurationFields } from '../Duration.js';
+export declare const validateBoundWitnessAndDuration: (recordBw: BoundWitness, recordPayload: Payload<DurationFields>) => Promise<boolean>;
+//# sourceMappingURL=validateBoundWitnessAndDuration.d.ts.map

package/dist/neutral/modules/xns-record/Duration/validation/validateBoundWitnessAndDuration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateBoundWitnessAndDuration.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/xns-record/Duration/validation/validateBoundWitnessAndDuration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAG7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAGpD,eAAO,MAAM,+BAA+B,GAAU,UAAU,YAAY,EAAE,eAAe,OAAO,CAAC,cAAc,CAAC,KAAG,OAAO,CAAC,OAAO,CAGrI,CAAA"}

package/dist/neutral/modules/xns-record/Duration/validation/validateBoundWitnessWithDuration.d.ts

@@ -0,0 +1,4 @@
+import type { BoundWitness, Payload } from '@xyo-network/sdk';
+import type { DurationFields } from '../Duration.js';
+export declare const validateBoundWitnessWithDuration: (recordBw: BoundWitness, recordPayload: Payload<DurationFields>) => Promise<boolean>;
+//# sourceMappingURL=validateBoundWitnessWithDuration.d.ts.map

package/dist/neutral/modules/xns-record/Duration/validation/validateBoundWitnessWithDuration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateBoundWitnessWithDuration.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/xns-record/Duration/validation/validateBoundWitnessWithDuration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAE7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAKpD,eAAO,MAAM,gCAAgC,GAAU,UAAU,YAAY,EAAE,eAAe,OAAO,CAAC,cAAc,CAAC,KAAG,OAAO,CAAC,OAAO,CAOtI,CAAA"}

package/dist/neutral/modules/xns-record/Duration/validation/validateDuration.d.ts

@@ -0,0 +1,5 @@
+import type { Payload } from '@xyo-network/sdk';
+import type { DurationFields } from '../Duration.js';
+export declare const validateDuration: (recordPayload: Payload<DurationFields>) => boolean;
+export declare const isWithinDelegatedTimeframe: (recordPayload: Payload<DurationFields>, now?: number) => boolean;
+//# sourceMappingURL=validateDuration.d.ts.map

package/dist/neutral/modules/xns-record/Duration/validation/validateDuration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateDuration.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/xns-record/Duration/validation/validateDuration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAE/C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAGpD,eAAO,MAAM,gBAAgB,GAAI,eAAe,OAAO,CAAC,cAAc,CAAC,KAAG,OAGzE,CAAA;AAED,eAAO,MAAM,0BAA0B,GAAI,eAAe,OAAO,CAAC,cAAc,CAAC,EAAE,YAAgB,KAAG,OAGrG,CAAA"}

package/dist/neutral/modules/xns-record/Hash/Payload.d.ts

@@ -0,0 +1,68 @@
+import * as z from 'zod/mini';
+export type HashRecordSchema = typeof HashRecordSchema;
+export declare const HashRecordSchema: "network.xyo.ns.record.hash" & {
+    readonly __schema: true;
+};
+export declare const HashRecordFieldsZod: z.ZodMiniObject<{
+    hash: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+    domain: z.ZodMiniString<string>;
+    tld: z.ZodMiniLiteral<"xyo">;
+}, z.core.$strip>;
+export type HashRecordFields = z.infer<typeof HashRecordFieldsZod>;
+/**
+ * An hash record points a domain to an hash
+ */
+export declare const HashRecordZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<"network.xyo.ns.record.hash" & {
+        readonly __schema: true;
+    }>;
+    hash: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+    domain: z.ZodMiniString<string>;
+    tld: z.ZodMiniLiteral<"xyo">;
+}, z.core.$strip>;
+export type HashRecord = z.infer<typeof HashRecordZod>;
+export declare const isHashRecord: <T>(value: T) => value is T & {
+    schema: "network.xyo.ns.record.hash" & {
+        readonly __schema: true;
+    };
+    hash: import("@ariestools/sdk").BrandedHash[];
+    domain: string;
+    tld: "xyo";
+};
+export declare const asHashRecord: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.ns.record.hash" & {
+            readonly __schema: true;
+        };
+        hash: import("@ariestools/sdk").BrandedHash[];
+        domain: string;
+        tld: "xyo";
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.ns.record.hash" & {
+            readonly __schema: true;
+        };
+        hash: import("@ariestools/sdk").BrandedHash[];
+        domain: string;
+        tld: "xyo";
+    };
+};
+export declare const toHashRecord: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.ns.record.hash" & {
+            readonly __schema: true;
+        };
+        hash: import("@ariestools/sdk").BrandedHash[];
+        domain: string;
+        tld: "xyo";
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.ns.record.hash" & {
+            readonly __schema: true;
+        };
+        hash: import("@ariestools/sdk").BrandedHash[];
+        domain: string;
+        tld: "xyo";
+    };
+};
+//# sourceMappingURL=Payload.d.ts.map

package/dist/neutral/modules/xns-record/Hash/Payload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Payload.d.ts","sourceRoot":"","sources":["../../../../../src/modules/xns-record/Hash/Payload.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAI7B,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAA;AACtD,eAAO,MAAM,gBAAgB;;CAA+C,CAAA;AAE5E,eAAO,MAAM,mBAAmB;;;;iBAM9B,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAElE;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;;;iBAAmF,CAAA;AAE7G,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AAEtD,eAAO,MAAM,YAAY;;;;;;;CAA8B,CAAA;AACvD,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;CAA8C,CAAA;AACvE,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;CAA8C,CAAA"}

package/dist/neutral/modules/xns-record/Hash/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Payload.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/neutral/modules/xns-record/Hash/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/modules/xns-record/Hash/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA"}

package/dist/neutral/modules/xns-record/diviner/DomainLeaseEstimateDiviner/ErrorDetails/ErrorCodes.d.ts

@@ -0,0 +1,4 @@
+import type { DomainLeaseEstimateDivinerValidationErrorDetails, ErrorDetailsDictionary } from './Payload.js';
+export type DomainLeaseEstimateDivinerErrorDetailsDictionaryErrorCode = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
+export declare const DomainLeaseEstimateDivinerErrorDetailsDictionary: Readonly<Readonly<Record<DomainLeaseEstimateDivinerErrorDetailsDictionaryErrorCode, DomainLeaseEstimateDivinerValidationErrorDetails>> & ErrorDetailsDictionary>;
+//# sourceMappingURL=ErrorCodes.d.ts.map