@xyo-network/xl1-protocol 4.0.10 → 4.0.12

package/dist/neutral/modules/protocol-model/transaction/TransactionBoundWitness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransactionBoundWitness.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/transaction/TransactionBoundWitness.ts"],"names":[],"mappings":"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"}

package/dist/neutral/modules/protocol-model/transaction/TransactionFees.d.ts

@@ -0,0 +1,138 @@
+import { z } from 'zod/mini';
+/** AttoZod constant. */
+export declare const AttoZod: z.ZodMiniBigInt<bigint>;
+/** JsonToAttoZod constant. */
+export declare const JsonToAttoZod: z.ZodMiniPipe<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<bigint, string>>, z.ZodMiniTransform<import('../xl1/attoXl1.js').AttoXL1, bigint>>;
+/** AttoToJsonZod constant. */
+/** TransactionFeesHexZod constant. */
+export declare const TransactionFeesHexZod: z.ZodMiniObject<{
+    base: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
+    gasLimit: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
+    gasPrice: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
+    priority: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
+}, z.core.$strip>;
+/** TransactionFeesHex type. */
+export type TransactionFeesHex = z.infer<typeof TransactionFeesHexZod>;
+/** Type guard that checks if a value is a valid TransactionFeesHex. */
+export declare const isTransactionFeesHex: <T>(value: T) => value is T & {
+    base: import("@ariestools/sdk").BrandedHex;
+    gasLimit: import("@ariestools/sdk").BrandedHex;
+    gasPrice: import("@ariestools/sdk").BrandedHex;
+    priority: import("@ariestools/sdk").BrandedHex;
+};
+/** Converts a value to TransactionFeesHex, throwing if invalid. */
+export declare const asTransactionFeesHex: {
+    <T>(value: T): (T & {
+        base: import("@ariestools/sdk").BrandedHex;
+        gasLimit: import("@ariestools/sdk").BrandedHex;
+        gasPrice: import("@ariestools/sdk").BrandedHex;
+        priority: import("@ariestools/sdk").BrandedHex;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        base: import("@ariestools/sdk").BrandedHex;
+        gasLimit: import("@ariestools/sdk").BrandedHex;
+        gasPrice: import("@ariestools/sdk").BrandedHex;
+        priority: import("@ariestools/sdk").BrandedHex;
+    };
+};
+/** toTransactionFeesHex constant. */
+export declare const toTransactionFeesHex: {
+    <T>(value: T): (T & {
+        base: import("@ariestools/sdk").BrandedHex;
+        gasLimit: import("@ariestools/sdk").BrandedHex;
+        gasPrice: import("@ariestools/sdk").BrandedHex;
+        priority: import("@ariestools/sdk").BrandedHex;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        base: import("@ariestools/sdk").BrandedHex;
+        gasLimit: import("@ariestools/sdk").BrandedHex;
+        gasPrice: import("@ariestools/sdk").BrandedHex;
+        priority: import("@ariestools/sdk").BrandedHex;
+    };
+};
+/** TransactionFeesBigIntZod constant. */
+export declare const TransactionFeesBigIntZod: z.ZodMiniObject<{
+    base: z.ZodMiniBigInt<bigint>;
+    gasLimit: z.ZodMiniBigInt<bigint>;
+    gasPrice: z.ZodMiniBigInt<bigint>;
+    priority: z.ZodMiniBigInt<bigint>;
+}, z.core.$strip>;
+/** TransactionFeesBigInt type. */
+export type TransactionFeesBigInt = z.infer<typeof TransactionFeesBigIntZod>;
+/** Type guard that checks if a value is a valid TransactionFeesBigInt. */
+export declare const isTransactionFeesBigInt: <T>(value: T) => value is T & {
+    base: bigint;
+    gasLimit: bigint;
+    gasPrice: bigint;
+    priority: bigint;
+};
+/** Converts a value to TransactionFeesBigInt, throwing if invalid. */
+export declare const asTransactionFeesBigInt: {
+    <T>(value: T): (T & {
+        base: bigint;
+        gasLimit: bigint;
+        gasPrice: bigint;
+        priority: bigint;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        base: bigint;
+        gasLimit: bigint;
+        gasPrice: bigint;
+        priority: bigint;
+    };
+};
+/** toTransactionFeesBigInt constant. */
+export declare const toTransactionFeesBigInt: {
+    <T>(value: T): (T & {
+        base: bigint;
+        gasLimit: bigint;
+        gasPrice: bigint;
+        priority: bigint;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        base: bigint;
+        gasLimit: bigint;
+        gasPrice: bigint;
+        priority: bigint;
+    };
+};
+/** TransactionFeesJsonToBigIntZod constant. */
+export declare const TransactionFeesJsonToBigIntZod: z.ZodMiniPipe<z.ZodMiniObject<{
+    base: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
+    gasLimit: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
+    gasPrice: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
+    priority: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
+}, z.core.$strip>, z.ZodMiniTransform<{
+    base: bigint;
+    gasLimit: bigint;
+    gasPrice: bigint;
+    priority: bigint;
+}, {
+    base: import("@ariestools/sdk").BrandedHex;
+    gasLimit: import("@ariestools/sdk").BrandedHex;
+    gasPrice: import("@ariestools/sdk").BrandedHex;
+    priority: import("@ariestools/sdk").BrandedHex;
+}>>;
+/** TransactionFeesBigIntToJsonZod constant. */
+export declare const TransactionFeesBigIntToJsonZod: z.ZodMiniPipe<z.ZodMiniObject<{
+    base: z.ZodMiniBigInt<bigint>;
+    gasLimit: z.ZodMiniBigInt<bigint>;
+    gasPrice: z.ZodMiniBigInt<bigint>;
+    priority: z.ZodMiniBigInt<bigint>;
+}, z.core.$strip>, z.ZodMiniTransform<{
+    base: import("@ariestools/sdk").BrandedHex;
+    gasLimit: import("@ariestools/sdk").BrandedHex;
+    gasPrice: import("@ariestools/sdk").BrandedHex;
+    priority: import("@ariestools/sdk").BrandedHex;
+}, {
+    base: bigint;
+    gasLimit: bigint;
+    gasPrice: bigint;
+    priority: bigint;
+}>>;
+/** TransactionFeesJsonToBigIntZodType type. */
+export type TransactionFeesJsonToBigIntZodType = z.infer<typeof TransactionFeesJsonToBigIntZod>;
+/** TransactionFeesBigIntToJsonZodType type. */
+export type TransactionFeesBigIntToJsonZodType = z.infer<typeof TransactionFeesBigIntToJsonZod>;
+export { BigIntToJsonZod as AttoToJsonZod } from '@ariestools/sdk';
+//# sourceMappingURL=TransactionFees.d.ts.map

package/dist/neutral/modules/protocol-model/transaction/TransactionFees.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransactionFees.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/transaction/TransactionFees.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAI5B,wBAAwB;AACxB,eAAO,MAAM,OAAO,yBAAa,CAAA;AACjC,8BAA8B;AAC9B,eAAO,MAAM,aAAa,4JAAoE,CAAA;AAE9F,8BAA8B;AAE9B,sCAAsC;AACtC,eAAO,MAAM,qBAAqB;;;;;iBAKhC,CAAA;AAEF,+BAA+B;AAC/B,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEtE,uEAAuE;AACvE,eAAO,MAAM,oBAAoB;;;;;CAAsC,CAAA;AACvE,mEAAmE;AACnE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;CAA8D,CAAA;AAC/F,qCAAqC;AACrC,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;CAA8D,CAAA;AAE/F,yCAAyC;AACzC,eAAO,MAAM,wBAAwB;;;;;iBAKnC,CAAA;AAEF,kCAAkC;AAClC,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAE5E,0EAA0E;AAC1E,eAAO,MAAM,uBAAuB;;;;;CAAyC,CAAA;AAC7E,sEAAsE;AACtE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;CAAoE,CAAA;AACxG,wCAAwC;AACxC,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;CAAoE,CAAA;AAExG,+CAA+C;AAC/C,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;GAQ1C,CAAA;AAED,+CAA+C;AAC/C,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;GAQ1C,CAAA;AAED,+CAA+C;AAC/C,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAC/F,+CAA+C;AAC/C,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAE/F,OAAO,EAAE,eAAe,IAAI,aAAa,EAAE,MAAM,iBAAiB,CAAA"}

package/dist/neutral/modules/protocol-model/transaction/TransactionGasCosts.d.ts

@@ -0,0 +1,38 @@
+/** TransactionGasCosts constant. */
+export declare const TransactionGasCosts: {
+    /**
+     * The cost of storing each character that is added to the chain
+     * This includes the transaction JSON and all the elevated payloads' JSON
+    */
+    readonly characterStorage: 10n;
+    /** The cost of static validating every payload that will be included in the chain */
+    readonly payloadValidation: 1000n;
+    /** The cost of validating each signature that will be included in the chain */
+    readonly signatureValidation: 1000n;
+    /** The cost of validating each hash that will be included in the chain */
+    readonly hashValidation: 100n;
+    /** The cost of validating a balance state, triggered by a Transfer payload or gas collection */
+    readonly balanceValidation: 100n;
+};
+/** Gas Calculation
+ *
+ * 1 Million microXL1 (mXL1) = 1 XL1
+ *
+ * Gas amount is calculated as follows:
+ *
+ * 1. Each byte in the transaction cost 10 gas
+ * 2. Each payload validation in the transaction costs 1000 gas
+ * 3. Each signature verification in the transaction costs 1000 gas
+ * 4. Each hash validation in the transaction costs 100 gas
+ * 5. Each balance validation in the transaction costs 100 gas
+ * 6. Processing/Compute/Storage Cost?
+ * 7. operation Costs?
+ *
+ * The total gas cost is calculated by multiplying the gas amount by the gas price.
+ *
+ * minGasPrice is initially set to 100 mXL1
+ * minBase is initially set to 1000 mXL1
+ * minPriority is always 0 mXL1, but can be set to increase the priority of the transaction
+ *
+ */
+//# sourceMappingURL=TransactionGasCosts.d.ts.map

package/dist/neutral/modules/protocol-model/transaction/TransactionGasCosts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransactionGasCosts.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/transaction/TransactionGasCosts.ts"],"names":[],"mappings":"AAAA,oCAAoC;AACpC,eAAO,MAAM,mBAAmB;IAC9B;;;MAGE;;IAGF,qFAAqF;;IAGrF,+EAA+E;;IAG/E,0EAA0E;;IAG1E,gGAAgG;;CAExF,CAAA;AAEV;;;;;;;;;;;;;;;;;;;;GAoBG"}

package/dist/neutral/modules/protocol-model/transaction/index.d.ts

@@ -0,0 +1,4 @@
+export * from './TransactionBoundWitness.js';
+export * from './TransactionFees.js';
+export * from './TransactionGasCosts.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/neutral/modules/protocol-model/transaction/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/transaction/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAA;AAC5C,cAAc,sBAAsB,CAAA;AACpC,cAAc,0BAA0B,CAAA"}

package/dist/neutral/modules/protocol-model/xl1/attoXl1.d.ts

@@ -0,0 +1,15 @@
+/** Maximum value for the AttoXL1 branded type. */
+export declare const AttoXL1MaxValue: bigint;
+/** AttoXL1 type. */
+export type AttoXL1 = bigint & {
+    readonly _tag: 'AttoXL1';
+};
+/** Type guard that checks if a value is a valid AttoXL1. */
+export declare const isAttoXL1: (val: unknown) => val is AttoXL1;
+/** Converts a value to AttoXL1, throwing if invalid. */
+export declare const asAttoXL1: (val: unknown) => AttoXL1;
+/** Converts a bigint value to AttoXL1 without validation. */
+export declare const toAttoXL1: (val: unknown) => AttoXL1 | undefined;
+/** Shorthand alias for asAttoXL1. */
+export declare const AttoXL1: (val: unknown) => AttoXL1;
+//# sourceMappingURL=attoXl1.d.ts.map

package/dist/neutral/modules/protocol-model/xl1/attoXl1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attoXl1.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/xl1/attoXl1.ts"],"names":[],"mappings":"AAMA,kDAAkD;AAClD,eAAO,MAAM,eAAe,QAA8B,CAAA;AAC1D,oBAAoB;AACpB,MAAM,MAAM,OAAO,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;CAAE,CAAA;AAC3D,4DAA4D;AAC5D,eAAO,MAAM,SAAS,kCAAwC,CAAA;AAC9D,wDAAwD;AACxD,eAAO,MAAM,SAAS,2BAAwC,CAAA;AAC9D,6DAA6D;AAC7D,eAAO,MAAM,SAAS,uCAAwC,CAAA;AAE9D,qCAAqC;AACrC,eAAO,MAAM,OAAO,2BAAY,CAAA"}

package/dist/neutral/modules/protocol-model/xl1/femtoXl1.d.ts

@@ -0,0 +1,15 @@
+/** Maximum value for the FemtoXL1 branded type. */
+export declare const FemtoXL1MaxValue: bigint;
+/** FemtoXL1 type. */
+export type FemtoXL1 = bigint & {
+    readonly _tag: 'FemtoXL1';
+};
+/** Type guard that checks if a value is a valid FemtoXL1. */
+export declare const isFemtoXL1: (val: unknown) => val is FemtoXL1;
+/** Converts a value to FemtoXL1, throwing if invalid. */
+export declare const asFemtoXL1: (val: unknown) => FemtoXL1;
+/** Converts a bigint value to FemtoXL1 without validation. */
+export declare const toFemtoXL1: (val: unknown) => FemtoXL1 | undefined;
+/** Shorthand alias for asFemtoXL1. */
+export declare const FemtoXL1: (val: unknown) => FemtoXL1;
+//# sourceMappingURL=femtoXl1.d.ts.map

package/dist/neutral/modules/protocol-model/xl1/femtoXl1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"femtoXl1.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/xl1/femtoXl1.ts"],"names":[],"mappings":"AAMA,mDAAmD;AACnD,eAAO,MAAM,gBAAgB,QAA+B,CAAA;AAC5D,qBAAqB;AACrB,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;CAAE,CAAA;AAC7D,6DAA6D;AAC7D,eAAO,MAAM,UAAU,mCAA0C,CAAA;AACjE,yDAAyD;AACzD,eAAO,MAAM,UAAU,4BAA0C,CAAA;AAEjE,8DAA8D;AAC9D,eAAO,MAAM,UAAU,wCAA0C,CAAA;AAEjE,sCAAsC;AACtC,eAAO,MAAM,QAAQ,4BAAa,CAAA"}

package/dist/neutral/modules/protocol-model/xl1/index.d.ts

@@ -0,0 +1,9 @@
+export * from './attoXl1.js';
+export * from './femtoXl1.js';
+export * from './microXl1.js';
+export * from './milliXl1.js';
+export * from './nanoXl1.js';
+export * from './picoXl1.js';
+export * from './xl1.js';
+export * from './xl1Units.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/neutral/modules/protocol-model/xl1/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/xl1/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA;AAC5B,cAAc,eAAe,CAAA;AAC7B,cAAc,eAAe,CAAA;AAC7B,cAAc,eAAe,CAAA;AAC7B,cAAc,cAAc,CAAA;AAC5B,cAAc,cAAc,CAAA;AAC5B,cAAc,UAAU,CAAA;AACxB,cAAc,eAAe,CAAA"}

package/dist/neutral/modules/protocol-model/xl1/isXl1Factory.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+/** Type guard that checks if a value is a valid XL1Factory. */
+export declare const isXL1Factory: <T extends bigint>(places: bigint) => (val: unknown) => val is T;
+/** Creates a Zod schema factory for XL1 branded bigint types. */
+export declare const XL1ZodFactory: <T extends bigint>(places: bigint, name: string) => z.ZodBigInt & z.ZodType<T, bigint, z.core.$ZodTypeInternals<T, bigint>>;
+/** Creates a Zod transform factory that converts values between XL1 unit types. */
+export declare const XL1TransformZodFactory: <T extends bigint>(places: bigint, name: string) => z.ZodPipe<z.ZodUnion<readonly [z.ZodBigInt, z.ZodNumber, z.ZodString, z.ZodBoolean]>, z.ZodTransform<Awaited<T>, string | number | bigint | boolean>>;
+/** Converts a value to XL1Factory, throwing if invalid. */
+export declare const asXL1Factory: <T extends bigint>(places: bigint) => (val: unknown) => T;
+/** Creates a factory function that converts bigint values to a specific XL1 branded type. */
+export declare const toXL1Factory: <T extends bigint>(places: bigint) => (val: unknown) => T | undefined;
+//# sourceMappingURL=isXl1Factory.d.ts.map

package/dist/neutral/modules/protocol-model/xl1/isXl1Factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isXl1Factory.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/xl1/isXl1Factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,+DAA+D;AAC/D,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,MAAM,EAAE,QAAQ,MAAM,MAAM,KAAK,OAAO,KAAG,GAAG,IAAI,CAGxF,CAAA;AAED,iEAAiE;AACjE,eAAO,MAAM,aAAa,GAAI,CAAC,SAAS,MAAM,EAAE,QAAQ,MAAM,EAAE,MAAM,MAAM,4EAU3E,CAAA;AAED,mFAAmF;AACnF,eAAO,MAAM,sBAAsB,GAAI,CAAC,SAAS,MAAM,EAAE,QAAQ,MAAM,EAAE,MAAM,MAAM,0JAUpF,CAAA;AAED,2DAA2D;AAC3D,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,MAAM,EAAE,QAAQ,MAAM,MAEnD,KAAK,OAAO,KAAG,CAOxB,CAAA;AAED,6FAA6F;AAC7F,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,MAAM,EAAE,QAAQ,MAAM,MAEnD,KAAK,OAAO,KAAG,CAAC,GAAG,SAI5B,CAAA"}

package/dist/neutral/modules/protocol-model/xl1/microXl1.d.ts

@@ -0,0 +1,15 @@
+/** Maximum value for the MicroXL1 branded type. */
+export declare const MicroXL1MaxValue: bigint;
+/** MicroXL1 type. */
+export type MicroXL1 = bigint & {
+    readonly _tag: 'MicroXL1';
+};
+/** Type guard that checks if a value is a valid MicroXL1. */
+export declare const isMicroXL1: (val: unknown) => val is MicroXL1;
+/** Converts a value to MicroXL1, throwing if invalid. */
+export declare const asMicroXL1: (val: unknown) => MicroXL1;
+/** Converts a bigint value to MicroXL1 without validation. */
+export declare const toMicroXL1: (val: unknown) => MicroXL1 | undefined;
+/** Shorthand alias for asMicroXL1. */
+export declare const MicroXL1: (val: unknown) => MicroXL1;
+//# sourceMappingURL=microXl1.d.ts.map

package/dist/neutral/modules/protocol-model/xl1/microXl1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"microXl1.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/xl1/microXl1.ts"],"names":[],"mappings":"AAMA,mDAAmD;AACnD,eAAO,MAAM,gBAAgB,QAA+B,CAAA;AAC5D,qBAAqB;AACrB,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;CAAE,CAAA;AAC7D,6DAA6D;AAC7D,eAAO,MAAM,UAAU,mCAA0C,CAAA;AACjE,yDAAyD;AACzD,eAAO,MAAM,UAAU,4BAA0C,CAAA;AAEjE,8DAA8D;AAC9D,eAAO,MAAM,UAAU,wCAA0C,CAAA;AAEjE,sCAAsC;AACtC,eAAO,MAAM,QAAQ,4BAAa,CAAA"}

package/dist/neutral/modules/protocol-model/xl1/milliXl1.d.ts

@@ -0,0 +1,15 @@
+/** Maximum value for the MilliXL1 branded type. */
+export declare const MilliXL1MaxValue: bigint;
+/** MilliXL1 type. */
+export type MilliXL1 = bigint & {
+    readonly _tag: 'MilliXL1';
+};
+/** Type guard that checks if a value is a valid MilliXL1. */
+export declare const isMilliXL1: (val: unknown) => val is MilliXL1;
+/** Converts a value to MilliXL1, throwing if invalid. */
+export declare const asMilliXL1: (val: unknown) => MilliXL1;
+/** Converts a bigint value to MilliXL1 without validation. */
+export declare const toMilliXL1: (val: unknown) => MilliXL1 | undefined;
+/** Shorthand alias for asMilliXL1. */
+export declare const MilliXL1: (val: unknown) => MilliXL1;
+//# sourceMappingURL=milliXl1.d.ts.map

package/dist/neutral/modules/protocol-model/xl1/milliXl1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"milliXl1.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/xl1/milliXl1.ts"],"names":[],"mappings":"AAMA,mDAAmD;AACnD,eAAO,MAAM,gBAAgB,QAA+B,CAAA;AAC5D,qBAAqB;AACrB,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;CAAE,CAAA;AAC7D,6DAA6D;AAC7D,eAAO,MAAM,UAAU,mCAA0C,CAAA;AACjE,yDAAyD;AACzD,eAAO,MAAM,UAAU,4BAA0C,CAAA;AAEjE,8DAA8D;AAC9D,eAAO,MAAM,UAAU,wCAA0C,CAAA;AAEjE,sCAAsC;AACtC,eAAO,MAAM,QAAQ,4BAAa,CAAA"}

package/dist/neutral/modules/protocol-model/xl1/nanoXl1.d.ts

@@ -0,0 +1,15 @@
+/** Maximum value for the NanoXL1 branded type. */
+export declare const NanoXL1MaxValue: bigint;
+/** NanoXL1 type. */
+export type NanoXL1 = bigint & {
+    readonly _tag: 'NanoXL1';
+};
+/** Type guard that checks if a value is a valid NanoXL1. */
+export declare const isNanoXL1: (val: unknown) => val is NanoXL1;
+/** Converts a value to NanoXL1, throwing if invalid. */
+export declare const asNanoXL1: (val: unknown) => NanoXL1;
+/** Converts a bigint value to NanoXL1 without validation. */
+export declare const toNanoXL1: (val: unknown) => NanoXL1 | undefined;
+/** Shorthand alias for asNanoXL1. */
+export declare const NanoXL1: (val: unknown) => NanoXL1;
+//# sourceMappingURL=nanoXl1.d.ts.map

package/dist/neutral/modules/protocol-model/xl1/nanoXl1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nanoXl1.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/xl1/nanoXl1.ts"],"names":[],"mappings":"AAMA,kDAAkD;AAClD,eAAO,MAAM,eAAe,QAA8B,CAAA;AAC1D,oBAAoB;AACpB,MAAM,MAAM,OAAO,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;CAAE,CAAA;AAC3D,4DAA4D;AAC5D,eAAO,MAAM,SAAS,kCAAwC,CAAA;AAC9D,wDAAwD;AACxD,eAAO,MAAM,SAAS,2BAAwC,CAAA;AAE9D,6DAA6D;AAC7D,eAAO,MAAM,SAAS,uCAAwC,CAAA;AAE9D,qCAAqC;AACrC,eAAO,MAAM,OAAO,2BAAY,CAAA"}

package/dist/neutral/modules/protocol-model/xl1/picoXl1.d.ts

@@ -0,0 +1,15 @@
+/** PicoXL1MaxValue constant. */
+export declare const PicoXL1MaxValue: bigint;
+/** PicoXL1 type. */
+export type PicoXL1 = bigint & {
+    readonly _tag: 'PicoXL1';
+};
+/** Type guard that checks if a value is a valid PicoXL1. */
+export declare const isPicoXL1: (val: unknown) => val is PicoXL1;
+/** Converts a value to PicoXL1, throwing if invalid. */
+export declare const asPicoXL1: (val: unknown) => PicoXL1;
+/** toPicoXL1 constant. */
+export declare const toPicoXL1: (val: unknown) => PicoXL1 | undefined;
+/** PicoXL1 constant. */
+export declare const PicoXL1: (val: unknown) => PicoXL1;
+//# sourceMappingURL=picoXl1.d.ts.map

package/dist/neutral/modules/protocol-model/xl1/picoXl1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"picoXl1.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/xl1/picoXl1.ts"],"names":[],"mappings":"AAMA,gCAAgC;AAChC,eAAO,MAAM,eAAe,QAA8B,CAAA;AAC1D,oBAAoB;AACpB,MAAM,MAAM,OAAO,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;CAAE,CAAA;AAC3D,4DAA4D;AAC5D,eAAO,MAAM,SAAS,kCAAwC,CAAA;AAC9D,wDAAwD;AACxD,eAAO,MAAM,SAAS,2BAAwC,CAAA;AAE9D,0BAA0B;AAC1B,eAAO,MAAM,SAAS,uCAAwC,CAAA;AAE9D,wBAAwB;AACxB,eAAO,MAAM,OAAO,2BAAY,CAAA"}

package/dist/neutral/modules/protocol-model/xl1/xl1.d.ts

@@ -0,0 +1,15 @@
+/** XL1MaxValue constant. */
+export declare const XL1MaxValue: bigint;
+/** XL1 type. */
+export type XL1 = bigint & {
+    readonly _tag: 'XL1';
+};
+/** Type guard that checks if a value is a valid XL1. */
+export declare const isXL1: (val: unknown) => val is XL1;
+/** Converts a value to XL1, throwing if invalid. */
+export declare const asXL1: (val: unknown) => XL1;
+/** toXL1 constant. */
+export declare const toXL1: (val: unknown) => XL1 | undefined;
+/** XL1 constant. */
+export declare const XL1: (val: unknown) => XL1;
+//# sourceMappingURL=xl1.d.ts.map

package/dist/neutral/modules/protocol-model/xl1/xl1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xl1.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/xl1/xl1.ts"],"names":[],"mappings":"AAMA,4BAA4B;AAC5B,eAAO,MAAM,WAAW,QAA6B,CAAA;AACrD,gBAAgB;AAChB,MAAM,MAAM,GAAG,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAA;CAAE,CAAA;AACnD,wDAAwD;AACxD,eAAO,MAAM,KAAK,8BAAmC,CAAA;AACrD,oDAAoD;AACpD,eAAO,MAAM,KAAK,uBAAmC,CAAA;AAErD,sBAAsB;AACtB,eAAO,MAAM,KAAK,mCAAmC,CAAA;AAErD,oBAAoB;AACpB,eAAO,MAAM,GAAG,uBAAQ,CAAA"}

package/dist/neutral/modules/protocol-model/xl1/xl1MaxValue.d.ts

@@ -0,0 +1,3 @@
+/** Computes the maximum value for an XL1 unit given its decimal places. */
+export declare const xl1MaxValue: (places: bigint) => bigint;
+//# sourceMappingURL=xl1MaxValue.d.ts.map

package/dist/neutral/modules/protocol-model/xl1/xl1MaxValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xl1MaxValue.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/xl1/xl1MaxValue.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,eAAO,MAAM,WAAW,GAAI,QAAQ,MAAM,WAA+B,CAAA"}

package/dist/neutral/modules/protocol-model/xl1/xl1Units.d.ts

@@ -0,0 +1,10 @@
+type XL1Units = 'xl1' | 'milli' | 'micro' | 'nano' | 'pico' | 'femto' | 'atto';
+/** Decimal place definitions for each XL1 currency unit (atto=18, femto=15, etc.). */
+export declare const XL1Places: Record<XL1Units, bigint>;
+/**
+ * Convert factor by which a respective unit is multiplied to convert it to AttoXL1 or
+ * by which AttoXL1 is divided to convert it to respective unit is multiplied.
+ */
+export declare const AttoXL1ConvertFactor: Record<XL1Units, bigint>;
+export {};
+//# sourceMappingURL=xl1Units.d.ts.map

package/dist/neutral/modules/protocol-model/xl1/xl1Units.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xl1Units.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/xl1/xl1Units.ts"],"names":[],"mappings":"AAAA,KAAK,QAAQ,GAAG,KAAK,GAAG,OAAO,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAA;AAE9E,sFAAsF;AACtF,eAAO,MAAM,SAAS,EAAE,MAAM,CAAC,QAAQ,EAAE,MAAM,CAQrC,CAAA;AAEV;;;GAGG;AACH,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,QAAQ,EAAE,MAAM,CAQhD,CAAA"}

package/dist/neutral/modules/schema/Executable.d.ts

@@ -0,0 +1,5 @@
+import type { JSONSchemaType } from 'ajv';
+import type { Executable } from '../protocol-lib/index.js';
+/** JSON schema for validating Executable payloads containing elevation scripts. */
+export declare const ExecutableJsonSchema: JSONSchemaType<Executable>;
+//# sourceMappingURL=Executable.d.ts.map

package/dist/neutral/modules/schema/Executable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Executable.d.ts","sourceRoot":"","sources":["../../../../src/modules/schema/Executable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,KAAK,CAAA;AAEzC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAE/C,mFAAmF;AACnF,eAAO,MAAM,oBAAoB,EAAE,cAAc,CAAC,UAAU,CAMlD,CAAA"}

package/dist/neutral/modules/schema/StorageMeta.d.ts

@@ -0,0 +1,5 @@
+import type { StorageMeta } from '@xyo-network/sdk';
+import type { JSONSchemaType } from 'ajv';
+/** JSON schema for validating storage metadata fields (_sequence, _hash, _dataHash). */
+export declare const StorageMetaJsonSchema: JSONSchemaType<StorageMeta>;
+//# sourceMappingURL=StorageMeta.d.ts.map

package/dist/neutral/modules/schema/StorageMeta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StorageMeta.d.ts","sourceRoot":"","sources":["../../../../src/modules/schema/StorageMeta.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AACnD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,KAAK,CAAA;AAEzC,wFAAwF;AACxF,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,WAAW,CASpD,CAAA"}

package/dist/neutral/modules/schema/boundwitness/BlockBoundWitness.d.ts

@@ -0,0 +1,17 @@
+import type { JSONSchemaType } from 'ajv';
+import type { BlockBoundWitness } from '../../protocol-lib/index.js';
+/** JSON schema for validating BlockBoundWitness payloads. */
+export declare const BlockBoundWitnessJsonSchema: JSONSchemaType<BlockBoundWitness>;
+export declare const BlockBoundWitnessSchemaPayload: {
+    schema: "network.xyo.schema" & {
+        readonly __schema: true;
+    };
+    definition: {
+        [x: string]: unknown;
+        $id?: string | undefined;
+    };
+    extends?: string | undefined;
+    name?: string | undefined;
+    version?: number | undefined;
+};
+//# sourceMappingURL=BlockBoundWitness.d.ts.map

package/dist/neutral/modules/schema/boundwitness/BlockBoundWitness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlockBoundWitness.d.ts","sourceRoot":"","sources":["../../../../../src/modules/schema/boundwitness/BlockBoundWitness.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,KAAK,CAAA;AAEzC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAA;AAItD,6DAA6D;AAC7D,eAAO,MAAM,2BAA2B,EAAE,cAAc,CAAC,iBAAiB,CAoBhE,CAAA;AAIV,eAAO,MAAM,8BAA8B;;;;;;;;;;;CACmB,CAAA"}

package/dist/neutral/modules/schema/boundwitness/BlockBoundWitnessWithStorageMeta.d.ts

@@ -0,0 +1,18 @@
+import type { WithStorageMeta } from '@xyo-network/sdk';
+import type { JSONSchemaType } from 'ajv';
+import type { BlockBoundWitness } from '../../protocol-lib/index.js';
+/** JSON schema for validating BlockBoundWitness payloads including storage metadata. */
+export declare const BlockBoundWitnessWithStorageMetaJsonSchema: JSONSchemaType<WithStorageMeta<BlockBoundWitness>>;
+export declare const BlockBoundWitnessWithStorageMetaSchemaPayload: {
+    schema: "network.xyo.schema" & {
+        readonly __schema: true;
+    };
+    definition: {
+        [x: string]: unknown;
+        $id?: string | undefined;
+    };
+    extends?: string | undefined;
+    name?: string | undefined;
+    version?: number | undefined;
+};
+//# sourceMappingURL=BlockBoundWitnessWithStorageMeta.d.ts.map

package/dist/neutral/modules/schema/boundwitness/BlockBoundWitnessWithStorageMeta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlockBoundWitnessWithStorageMeta.d.ts","sourceRoot":"","sources":["../../../../../src/modules/schema/boundwitness/BlockBoundWitnessWithStorageMeta.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiB,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAKtE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,KAAK,CAAA;AAEzC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAA;AAMtD,wFAAwF;AACxF,eAAO,MAAM,0CAA0C,EAAE,cAAc,CAAC,eAAe,CAAC,iBAAiB,CAAC,CAehG,CAAA;AAIV,eAAO,MAAM,6CAA6C;;;;;;;;;;;CACmB,CAAA"}

package/dist/neutral/modules/schema/boundwitness/TransactionBoundWitness.d.ts

@@ -0,0 +1,17 @@
+import type { JSONSchemaType } from 'ajv';
+import type { TransactionBoundWitness } from '../../protocol-lib/index.js';
+/** JSON schema for validating TransactionBoundWitness payloads. */
+export declare const TransactionBoundWitnessJsonSchema: JSONSchemaType<TransactionBoundWitness>;
+export declare const TransactionBoundWitnessSchemaPayload: {
+    schema: "network.xyo.schema" & {
+        readonly __schema: true;
+    };
+    definition: {
+        [x: string]: unknown;
+        $id?: string | undefined;
+    };
+    extends?: string | undefined;
+    name?: string | undefined;
+    version?: number | undefined;
+};
+//# sourceMappingURL=TransactionBoundWitness.d.ts.map

package/dist/neutral/modules/schema/boundwitness/TransactionBoundWitness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransactionBoundWitness.d.ts","sourceRoot":"","sources":["../../../../../src/modules/schema/boundwitness/TransactionBoundWitness.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,KAAK,CAAA;AAEzC,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAA;AAK5D,mEAAmE;AACnE,eAAO,MAAM,iCAAiC,EAAE,cAAc,CAAC,uBAAuB,CA2B5E,CAAA;AAIV,eAAO,MAAM,oCAAoC;;;;;;;;;;;CACmB,CAAA"}

package/dist/neutral/modules/schema/boundwitness/TransactionBoundWitnessWithStorageMeta.d.ts

@@ -0,0 +1,17 @@
+import type { JSONSchemaType } from 'ajv';
+import type { TransactionBoundWitness } from '../../protocol-lib/index.js';
+/** JSON schema for validating TransactionBoundWitness payloads including storage metadata. */
+export declare const TransactionBoundWitnessWithStorageMetaJsonSchema: JSONSchemaType<TransactionBoundWitness>;
+export declare const TransactionBoundWitnessWithStorageMetaSchemaPayload: {
+    schema: "network.xyo.schema" & {
+        readonly __schema: true;
+    };
+    definition: {
+        [x: string]: unknown;
+        $id?: string | undefined;
+    };
+    extends?: string | undefined;
+    name?: string | undefined;
+    version?: number | undefined;
+};
+//# sourceMappingURL=TransactionBoundWitnessWithStorageMeta.d.ts.map

package/dist/neutral/modules/schema/boundwitness/TransactionBoundWitnessWithStorageMeta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransactionBoundWitnessWithStorageMeta.d.ts","sourceRoot":"","sources":["../../../../../src/modules/schema/boundwitness/TransactionBoundWitnessWithStorageMeta.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,KAAK,CAAA;AAEzC,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAA;AAK5D,8FAA8F;AAC9F,eAAO,MAAM,gDAAgD,EAAE,cAAc,CAAC,uBAAuB,CAgB3F,CAAA;AAIV,eAAO,MAAM,mDAAmD;;;;;;;;;;;CACmB,CAAA"}

package/dist/neutral/modules/schema/boundwitness/index.d.ts

@@ -0,0 +1,5 @@
+export * from './BlockBoundWitness.js';
+export * from './BlockBoundWitnessWithStorageMeta.js';
+export * from './TransactionBoundWitness.js';
+export * from './TransactionBoundWitnessWithStorageMeta.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/neutral/modules/schema/boundwitness/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/modules/schema/boundwitness/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAA;AACtC,cAAc,uCAAuC,CAAA;AACrD,cAAc,8BAA8B,CAAA;AAC5C,cAAc,6CAA6C,CAAA"}

package/dist/neutral/modules/schema/index.d.ts

@@ -0,0 +1,5 @@
+export * from './boundwitness/index.js';
+export * from './Executable.js';
+export * from './payload/index.js';
+export * from './StorageMeta.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/neutral/modules/schema/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/modules/schema/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAA;AACvC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,oBAAoB,CAAA;AAClC,cAAc,kBAAkB,CAAA"}

package/dist/neutral/modules/schema/mergeJsonSchemaRequired.d.ts

@@ -0,0 +1,7 @@
+import type { JSONSchemaType } from 'ajv';
+export declare const asRequiredStrings: (required: unknown) => readonly string[];
+/** Merge JSON schema `required` arrays without spreading untyped sdk-js values. */
+export declare const mergeJsonSchemaRequired: <T>(...groups: readonly unknown[]) => JSONSchemaType<T> extends {
+    required: infer R;
+} ? R : never;
+//# sourceMappingURL=mergeJsonSchemaRequired.d.ts.map

package/dist/neutral/modules/schema/mergeJsonSchemaRequired.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mergeJsonSchemaRequired.d.ts","sourceRoot":"","sources":["../../../../src/modules/schema/mergeJsonSchemaRequired.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,KAAK,CAAA;AAEzC,eAAO,MAAM,iBAAiB,GAAI,UAAU,OAAO,KAAG,SAAS,MAAM,EAIpE,CAAA;AAED,mFAAmF;AACnF,eAAO,MAAM,uBAAuB,GAAI,CAAC,EACvC,GAAG,QAAQ,SAAS,OAAO,EAAE,KAC5B,cAAc,CAAC,CAAC,CAAC,SAAS;IAAE,QAAQ,EAAE,MAAM,CAAC,CAAA;CAAE,GAAG,CAAC,GAAG,KAExD,CAAA"}

package/dist/neutral/modules/schema/payload/ChainStakeIntent.d.ts

@@ -0,0 +1,17 @@
+import type { JSONSchemaType } from 'ajv';
+import type { ChainStakeIntent } from '../../protocol-lib/index.js';
+/** JSON schema for validating ChainStakeIntent payloads. */
+export declare const ChainStakeIntentPayloadJsonSchema: JSONSchemaType<ChainStakeIntent>;
+export declare const ChainStakeIntentPayloadJsonSchemaPayload: {
+    schema: "network.xyo.schema" & {
+        readonly __schema: true;
+    };
+    definition: {
+        [x: string]: unknown;
+        $id?: string | undefined;
+    };
+    extends?: string | undefined;
+    name?: string | undefined;
+    version?: number | undefined;
+};
+//# sourceMappingURL=ChainStakeIntent.d.ts.map

package/dist/neutral/modules/schema/payload/ChainStakeIntent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChainStakeIntent.d.ts","sourceRoot":"","sources":["../../../../../src/modules/schema/payload/ChainStakeIntent.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,KAAK,CAAA;AAEzC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAA;AAKrD,4DAA4D;AAC5D,eAAO,MAAM,iCAAiC,EAAE,cAAc,CAAC,gBAAgB,CAa9E,CAAA;AAID,eAAO,MAAM,wCAAwC;;;;;;;;;;;CACe,CAAA"}

package/dist/neutral/modules/schema/payload/HashPayload.d.ts

@@ -0,0 +1,17 @@
+import type { JSONSchemaType } from 'ajv';
+import type { HashPayload } from '../../protocol-lib/index.js';
+/** JSON schema for validating Hash payloads. */
+export declare const HashPayloadJsonSchema: JSONSchemaType<HashPayload>;
+export declare const HashPayloadJsonSchemaPayload: {
+    schema: "network.xyo.schema" & {
+        readonly __schema: true;
+    };
+    definition: {
+        [x: string]: unknown;
+        $id?: string | undefined;
+    };
+    extends?: string | undefined;
+    name?: string | undefined;
+    version?: number | undefined;
+};
+//# sourceMappingURL=HashPayload.d.ts.map

package/dist/neutral/modules/schema/payload/HashPayload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HashPayload.d.ts","sourceRoot":"","sources":["../../../../../src/modules/schema/payload/HashPayload.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,KAAK,CAAA;AAEzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAKhD,gDAAgD;AAChD,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,WAAW,CAY7D,CAAA;AAID,eAAO,MAAM,4BAA4B;;;;;;;;;;;CACe,CAAA"}