@xyo-network/xl1-protocol 1.25.26 → 1.25.28

package/dist/neutral/model/Context/BaseContext.zod.d.ts

@@ -2,12 +2,19 @@ import type { MeterProvider, TracerProvider } from '@opentelemetry/api';
 import type { Logger } from '@xylabs/sdk-js';
 import { z } from 'zod';
 import type { MapType } from '../../map/index.ts';
+/** CachesZod constant. */
 export declare const CachesZod: z.ZodRecord<z.ZodString, z.ZodCustom<MapType<string, unknown>, MapType<string, unknown>>>;
+/** SingletonsZod constant. */
 export declare const SingletonsZod: z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodSymbol]>, z.ZodUnknown>;
+/** LoggerZod constant. */
 export declare const LoggerZod: z.ZodCustom<Logger, Logger>;
+/** MeterProviderZod constant. */
 export declare const MeterProviderZod: z.ZodCustom<MeterProvider, MeterProvider>;
+/** TracerProviderZod constant. */
 export declare const TracerProviderZod: z.ZodCustom<TracerProvider, TracerProvider>;
+/** TimeBudgetLimitZod constant. */
 export declare const TimeBudgetLimitZod: z.ZodNumber;
+/** BaseContextZod constant. */
 export declare const BaseContextZod: z.ZodObject<{
     caches: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodCustom<MapType<string, unknown>, MapType<string, unknown>>>>;
     logger: z.ZodOptional<z.ZodCustom<Logger, Logger>>;

package/dist/neutral/model/Context/BaseContext.zod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BaseContext.zod.d.ts","sourceRoot":"","sources":["../../../../src/model/Context/BaseContext.zod.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AACvE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAC5C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAA;AAEjD,eAAO,MAAM,SAAS,2FAGrB,CAAA;AAED,eAAO,MAAM,aAAa,4EAA2D,CAAA;AAErF,eAAO,MAAM,SAAS,6BAA6F,CAAA;AAEnH,eAAO,MAAM,gBAAgB,2CAAsF,CAAA;AAEnH,eAAO,MAAM,iBAAiB,6CAAwF,CAAA;AAEtH,eAAO,MAAM,kBAAkB,aAAa,CAAA;AAE5C,eAAO,MAAM,cAAc;;;;;;;iBAOzB,CAAA"}
+{"version":3,"file":"BaseContext.zod.d.ts","sourceRoot":"","sources":["../../../../src/model/Context/BaseContext.zod.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AACvE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAC5C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAA;AAEjD,0BAA0B;AAC1B,eAAO,MAAM,SAAS,2FAGrB,CAAA;AAED,8BAA8B;AAC9B,eAAO,MAAM,aAAa,4EAA2D,CAAA;AAErF,0BAA0B;AAC1B,eAAO,MAAM,SAAS,6BAA6F,CAAA;AAEnH,iCAAiC;AACjC,eAAO,MAAM,gBAAgB,2CAAsF,CAAA;AAEnH,kCAAkC;AAClC,eAAO,MAAM,iBAAiB,6CAAwF,CAAA;AAEtH,mCAAmC;AACnC,eAAO,MAAM,kBAAkB,aAAa,CAAA;AAE5C,+BAA+B;AAC/B,eAAO,MAAM,cAAc;;;;;;;iBAOzB,CAAA"}

package/dist/neutral/model/Context/BlockContext.d.ts

@@ -1,6 +1,9 @@
 import type z from 'zod';
 import type { BlockContextReadZod, BlockContextWriteZod, BlockContextZod } from './BlockContext.zod.ts';
+/** BlockContextRead type. */
 export type BlockContextRead = z.infer<typeof BlockContextReadZod>;
+/** BlockContextWrite type. */
 export type BlockContextWrite = z.infer<typeof BlockContextWriteZod>;
+/** BlockContext type. */
 export type BlockContext = z.infer<typeof BlockContextZod>;
 //# sourceMappingURL=BlockContext.d.ts.map

package/dist/neutral/model/Context/BlockContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BlockContext.d.ts","sourceRoot":"","sources":["../../../../src/model/Context/BlockContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,OAAO,KAAK,EACV,mBAAmB,EAAE,oBAAoB,EAAE,eAAe,EAC3D,MAAM,uBAAuB,CAAA;AAE9B,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAClE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AACpE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA"}
+{"version":3,"file":"BlockContext.d.ts","sourceRoot":"","sources":["../../../../src/model/Context/BlockContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,OAAO,KAAK,EACV,mBAAmB,EAAE,oBAAoB,EAAE,eAAe,EAC3D,MAAM,uBAAuB,CAAA;AAE9B,6BAA6B;AAC7B,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAClE,8BAA8B;AAC9B,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AACpE,yBAAyB;AACzB,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA"}

package/dist/neutral/model/Context/BlockContext.zod.d.ts

@@ -1,5 +1,6 @@
 import type { Payload, ReadArchivist, WriteArchivist } from '@xyo-network/sdk-js';
 import z from 'zod';
+/** BlockContextReadZod constant. */
 export declare const BlockContextReadZod: z.ZodObject<{
     logger: z.ZodOptional<z.ZodCustom<import("@xylabs/logger").Logger, import("@xylabs/logger").Logger>>;
     meterProvider: z.ZodOptional<z.ZodCustom<import("@opentelemetry/api").MeterProvider, import("@opentelemetry/api").MeterProvider>>;
@@ -9,6 +10,7 @@ export declare const BlockContextReadZod: z.ZodObject<{
     caches: z.ZodRecord<z.ZodString, z.ZodCustom<import("../../index.ts").MapType<string, unknown>, import("../../index.ts").MapType<string, unknown>>>;
     chainMap: z.ZodCustom<ReadArchivist<Payload, import("@xylabs/hex").BrandedHash, import("@xyo-network/sdk-js").Sequence>, ReadArchivist<Payload, import("@xylabs/hex").BrandedHash, import("@xyo-network/sdk-js").Sequence>>;
 }, z.z.core.$strip>;
+/** BlockContextWriteZod constant. */
 export declare const BlockContextWriteZod: z.ZodObject<{
     logger: z.ZodOptional<z.ZodCustom<import("@xylabs/logger").Logger, import("@xylabs/logger").Logger>>;
     meterProvider: z.ZodOptional<z.ZodCustom<import("@opentelemetry/api").MeterProvider, import("@opentelemetry/api").MeterProvider>>;
@@ -18,6 +20,7 @@ export declare const BlockContextWriteZod: z.ZodObject<{
     caches: z.ZodRecord<z.ZodString, z.ZodCustom<import("../../index.ts").MapType<string, unknown>, import("../../index.ts").MapType<string, unknown>>>;
     chainMap: z.ZodCustom<WriteArchivist<Payload, Payload, Payload, import("@xylabs/hex").BrandedHash>, WriteArchivist<Payload, Payload, Payload, import("@xylabs/hex").BrandedHash>>;
 }, z.z.core.$strip>;
+/** BlockContextZod constant. */
 export declare const BlockContextZod: z.ZodObject<{
     logger: z.ZodOptional<z.ZodCustom<import("@xylabs/logger").Logger, import("@xylabs/logger").Logger>>;
     meterProvider: z.ZodOptional<z.ZodCustom<import("@opentelemetry/api").MeterProvider, import("@opentelemetry/api").MeterProvider>>;

package/dist/neutral/model/Context/BlockContext.zod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BlockContext.zod.d.ts","sourceRoot":"","sources":["../../../../src/model/Context/BlockContext.zod.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,aAAa,EAAE,cAAc,EAC9B,MAAM,qBAAqB,CAAA;AAC5B,OAAO,CAAC,MAAM,KAAK,CAAA;AAInB,eAAO,MAAM,mBAAmB;;;;;;;;mBAE/B,CAAA;AAED,eAAO,MAAM,oBAAoB;;;;;;;;mBAEhC,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;;;mBAAuB,CAAA"}
+{"version":3,"file":"BlockContext.zod.d.ts","sourceRoot":"","sources":["../../../../src/model/Context/BlockContext.zod.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,aAAa,EAAE,cAAc,EAC9B,MAAM,qBAAqB,CAAA;AAC5B,OAAO,CAAC,MAAM,KAAK,CAAA;AAInB,oCAAoC;AACpC,eAAO,MAAM,mBAAmB;;;;;;;;mBAE/B,CAAA;AAED,qCAAqC;AACrC,eAAO,MAAM,oBAAoB;;;;;;;;mBAEhC,CAAA;AAED,gCAAgC;AAChC,eAAO,MAAM,eAAe;;;;;;;;mBAAuB,CAAA"}

package/dist/neutral/model/Context/CachingContext.d.ts

@@ -1,4 +1,5 @@
 import type z from 'zod';
 import type { CachingContextZod } from './CachingContext.zod.ts';
+/** CachingContext type. */
 export type CachingContext = z.infer<typeof CachingContextZod>;
 //# sourceMappingURL=CachingContext.d.ts.map

package/dist/neutral/model/Context/CachingContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CachingContext.d.ts","sourceRoot":"","sources":["../../../../src/model/Context/CachingContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAA;AAEhE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA"}
+{"version":3,"file":"CachingContext.d.ts","sourceRoot":"","sources":["../../../../src/model/Context/CachingContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAA;AAEhE,2BAA2B;AAC3B,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA"}

package/dist/neutral/model/Context/CachingContext.zod.d.ts

@@ -1,3 +1,4 @@
+/** CachingContextZod constant. */
 export declare const CachingContextZod: import("zod").ZodObject<{
     logger: import("zod").ZodOptional<import("zod").ZodCustom<import("@xylabs/logger").Logger, import("@xylabs/logger").Logger>>;
     meterProvider: import("zod").ZodOptional<import("zod").ZodCustom<import("@opentelemetry/api").MeterProvider, import("@opentelemetry/api").MeterProvider>>;

package/dist/neutral/model/Context/CachingContext.zod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CachingContext.zod.d.ts","sourceRoot":"","sources":["../../../../src/model/Context/CachingContext.zod.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,iBAAiB;;;;;;;gCAA+C,CAAA"}
+{"version":3,"file":"CachingContext.zod.d.ts","sourceRoot":"","sources":["../../../../src/model/Context/CachingContext.zod.ts"],"names":[],"mappings":"AAEA,kCAAkC;AAClC,eAAO,MAAM,iBAAiB;;;;;;;gCAA+C,CAAA"}

package/dist/neutral/model/Context/ChainContext.d.ts

@@ -1,6 +1,9 @@
 import type z from 'zod';
 import type { ChainContextReadZod, ChainContextWriteZod, ChainContextZod } from './ChainContext.zod.ts';
+/** ChainContextRead type. */
 export type ChainContextRead = z.infer<typeof ChainContextReadZod>;
+/** ChainContextWrite type. */
 export type ChainContextWrite = z.infer<typeof ChainContextWriteZod>;
+/** ChainContext type. */
 export type ChainContext = z.infer<typeof ChainContextZod>;
 //# sourceMappingURL=ChainContext.d.ts.map

package/dist/neutral/model/Context/ChainContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ChainContext.d.ts","sourceRoot":"","sources":["../../../../src/model/Context/ChainContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,OAAO,KAAK,EACV,mBAAmB,EAAE,oBAAoB,EAAE,eAAe,EAC3D,MAAM,uBAAuB,CAAA;AAE9B,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAClE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AACpE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA"}
+{"version":3,"file":"ChainContext.d.ts","sourceRoot":"","sources":["../../../../src/model/Context/ChainContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,OAAO,KAAK,EACV,mBAAmB,EAAE,oBAAoB,EAAE,eAAe,EAC3D,MAAM,uBAAuB,CAAA;AAE9B,6BAA6B;AAC7B,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAClE,8BAA8B;AAC9B,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AACpE,yBAAyB;AACzB,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA"}

package/dist/neutral/model/Context/ChainContext.zod.d.ts

@@ -1,3 +1,4 @@
+/** ChainContextReadZod constant. */
 export declare const ChainContextReadZod: import("zod").ZodObject<{
     logger: import("zod").ZodOptional<import("zod").ZodCustom<import("@xylabs/logger").Logger, import("@xylabs/logger").Logger>>;
     meterProvider: import("zod").ZodOptional<import("zod").ZodCustom<import("@opentelemetry/api").MeterProvider, import("@opentelemetry/api").MeterProvider>>;
@@ -35,6 +36,7 @@ export declare const ChainContextReadZod: import("zod").ZodObject<{
         _dataHash: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@xylabs/hex").BrandedHash, string>>;
     }, import("zod/v4/core").$strip>;
 }, import("zod/v4/core").$strip>;
+/** ChainContextWriteZod constant. */
 export declare const ChainContextWriteZod: import("zod").ZodObject<{
     logger: import("zod").ZodOptional<import("zod").ZodCustom<import("@xylabs/logger").Logger, import("@xylabs/logger").Logger>>;
     meterProvider: import("zod").ZodOptional<import("zod").ZodCustom<import("@opentelemetry/api").MeterProvider, import("@opentelemetry/api").MeterProvider>>;
@@ -72,6 +74,7 @@ export declare const ChainContextWriteZod: import("zod").ZodObject<{
         _dataHash: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@xylabs/hex").BrandedHash, string>>;
     }, import("zod/v4/core").$strip>;
 }, import("zod/v4/core").$strip>;
+/** ChainContextZod constant. */
 export declare const ChainContextZod: import("zod").ZodObject<{
     logger: import("zod").ZodOptional<import("zod").ZodCustom<import("@xylabs/logger").Logger, import("@xylabs/logger").Logger>>;
     meterProvider: import("zod").ZodOptional<import("zod").ZodCustom<import("@opentelemetry/api").MeterProvider, import("@opentelemetry/api").MeterProvider>>;

package/dist/neutral/model/Context/ChainContext.zod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ChainContext.zod.d.ts","sourceRoot":"","sources":["../../../../src/model/Context/ChainContext.zod.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAA2D,CAAA;AAE3F,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAEhC,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAE3B,CAAA"}
+{"version":3,"file":"ChainContext.zod.d.ts","sourceRoot":"","sources":["../../../../src/model/Context/ChainContext.zod.ts"],"names":[],"mappings":"AAKA,oCAAoC;AACpC,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAA2D,CAAA;AAE3F,qCAAqC;AACrC,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAEhC,CAAA;AAED,gCAAgC;AAChC,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAE3B,CAAA"}

package/dist/neutral/model/Context/HeadContext.d.ts

@@ -1,4 +1,5 @@
 import type z from 'zod';
 import type { HeadContextZod } from './HeadContext.zod.ts';
+/** HeadContext type. */
 export type HeadContext = z.infer<typeof HeadContextZod>;
 //# sourceMappingURL=HeadContext.d.ts.map

package/dist/neutral/model/Context/HeadContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HeadContext.d.ts","sourceRoot":"","sources":["../../../../src/model/Context/HeadContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAE1D,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA"}
+{"version":3,"file":"HeadContext.d.ts","sourceRoot":"","sources":["../../../../src/model/Context/HeadContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAE1D,wBAAwB;AACxB,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA"}

package/dist/neutral/model/Context/HeadContext.zod.d.ts

@@ -1,4 +1,5 @@
 import z from 'zod';
+/** HeadContextBaseZod constant. */
 export declare const HeadContextBaseZod: z.ZodObject<{
     head: z.ZodObject<{
         $epoch: z.ZodNumber;
@@ -29,6 +30,7 @@ export declare const HeadContextBaseZod: z.ZodObject<{
         _dataHash: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").BrandedHash, string>>;
     }, z.z.core.$strip>;
 }, z.z.core.$strip>;
+/** HeadContextZod constant. */
 export declare const HeadContextZod: z.ZodObject<{
     logger: z.ZodOptional<z.ZodCustom<import("@xylabs/logger").Logger, import("@xylabs/logger").Logger>>;
     meterProvider: z.ZodOptional<z.ZodCustom<import("@opentelemetry/api").MeterProvider, import("@opentelemetry/api").MeterProvider>>;

package/dist/neutral/model/Context/HeadContext.zod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HeadContext.zod.d.ts","sourceRoot":"","sources":["../../../../src/model/Context/HeadContext.zod.ts"],"names":[],"mappings":"AACA,OAAO,CAAC,MAAM,KAAK,CAAA;AAKnB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAE9B,CAAA;AAED,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAAyD,CAAA"}
+{"version":3,"file":"HeadContext.zod.d.ts","sourceRoot":"","sources":["../../../../src/model/Context/HeadContext.zod.ts"],"names":[],"mappings":"AACA,OAAO,CAAC,MAAM,KAAK,CAAA;AAKnB,mCAAmC;AACnC,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAE9B,CAAA;AAED,+BAA+B;AAC/B,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAAyD,CAAA"}

package/dist/neutral/model/GatewayName.d.ts

@@ -1,4 +1,5 @@
 import type { Brand } from '@xylabs/sdk-js';
+/** GatewayName type. */
 export type GatewayName = Brand<string, {
     __gatewayName: true;
 }>;

package/dist/neutral/model/GatewayName.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GatewayName.d.ts","sourceRoot":"","sources":["../../../src/model/GatewayName.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAA;AAE3C,MAAM,MAAM,WAAW,GAAG,KAAK,CAAC,MAAM,EAAE;IAAE,aAAa,EAAE,IAAI,CAAA;CAAE,CAAC,CAAA"}
+{"version":3,"file":"GatewayName.d.ts","sourceRoot":"","sources":["../../../src/model/GatewayName.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAA;AAE3C,wBAAwB;AACxB,MAAM,MAAM,WAAW,GAAG,KAAK,CAAC,MAAM,EAAE;IAAE,aAAa,EAAE,IAAI,CAAA;CAAE,CAAC,CAAA"}

package/dist/neutral/model/HydratedTransaction.d.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+/** HydratedTransactionZod constant. */
 export declare const HydratedTransactionZod: z.ZodTuple<[z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.boundwitness" & {
         readonly __schema: true;
@@ -36,7 +37,9 @@ export declare const HydratedTransactionZod: z.ZodTuple<[z.ZodObject<{
 }, z.core.$strip>, z.ZodArray<z.ZodObject<{
     schema: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/sdk-js").BrandedSchema<string>, string>>;
 }, z.core.$strict>>], null>;
+/** Type representing a hydrated Transaction with resolved payloads. */
 export type HydratedTransaction = z.infer<typeof HydratedTransactionZod>;
+/** Type guard that checks if a value is a valid HydratedTransaction. */
 export declare const isHydratedTransaction: <T>(value: T) => value is T & [{
     schema: "network.xyo.boundwitness" & {
         readonly __schema: true;
@@ -74,6 +77,7 @@ export declare const isHydratedTransaction: <T>(value: T) => value is T & [{
 }, {
     schema: import("@xyo-network/sdk-js").BrandedSchema<string>;
 }[]];
+/** Converts a value to HydratedTransaction, throwing if invalid. */
 export declare const asHydratedTransaction: {
     <T>(value: T): (T & [{
         schema: "network.xyo.boundwitness" & {
@@ -150,6 +154,7 @@ export declare const asHydratedTransaction: {
         schema: import("@xyo-network/sdk-js").BrandedSchema<string>;
     }[]];
 };
+/** toHydratedTransaction constant. */
 export declare const toHydratedTransaction: {
     <T>(value: T): (T & [{
         schema: "network.xyo.boundwitness" & {
@@ -226,6 +231,7 @@ export declare const toHydratedTransaction: {
         schema: import("@xyo-network/sdk-js").BrandedSchema<string>;
     }[]];
 };
+/** HydratedTransactionWithHashMetaZod constant. */
 export declare const HydratedTransactionWithHashMetaZod: z.ZodTuple<[z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.boundwitness" & {
         readonly __schema: true;
@@ -267,7 +273,9 @@ export declare const HydratedTransactionWithHashMetaZod: z.ZodTuple<[z.ZodObject
     _hash: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHash, string>>;
     _dataHash: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHash, string>>;
 }, z.core.$loose>>], null>;
+/** Type representing a hydrated TransactionWithHashMeta with resolved payloads. */
 export type HydratedTransactionWithHashMeta = z.infer<typeof HydratedTransactionWithHashMetaZod>;
+/** Type guard that checks if a value is a valid HydratedTransactionWithHashMeta. */
 export declare const isHydratedTransactionWithHashMeta: <T>(value: T) => value is T & [{
     schema: "network.xyo.boundwitness" & {
         readonly __schema: true;
@@ -310,6 +318,7 @@ export declare const isHydratedTransactionWithHashMeta: <T>(value: T) => value i
     _hash: import("@xylabs/sdk-js").BrandedHash;
     _dataHash: import("@xylabs/sdk-js").BrandedHash;
 }[]];
+/** Converts a value to HydratedTransactionWithHashMeta, throwing if invalid. */
 export declare const asHydratedTransactionWithHashMeta: {
     <T>(value: T): (T & [{
         schema: "network.xyo.boundwitness" & {
@@ -396,6 +405,7 @@ export declare const asHydratedTransactionWithHashMeta: {
         _dataHash: import("@xylabs/sdk-js").BrandedHash;
     }[]];
 };
+/** toHydratedTransactionWithHashMeta constant. */
 export declare const toHydratedTransactionWithHashMeta: {
     <T>(value: T): (T & [{
         schema: "network.xyo.boundwitness" & {
@@ -482,6 +492,7 @@ export declare const toHydratedTransactionWithHashMeta: {
         _dataHash: import("@xylabs/sdk-js").BrandedHash;
     }[]];
 };
+/** HydratedTransactionWithStorageMetaZod constant. */
 export declare const HydratedTransactionWithStorageMetaZod: z.ZodTuple<[z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.boundwitness" & {
         readonly __schema: true;
@@ -525,7 +536,9 @@ export declare const HydratedTransactionWithStorageMetaZod: z.ZodTuple<[z.ZodObj
     _dataHash: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHash, string>>;
     _sequence: z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/sdk-js").LocalSequence, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/sdk-js").QualifiedSequence, string>>]>;
 }, z.core.$loose>>], null>;
+/** Type representing a hydrated TransactionWithStorageMeta with resolved payloads. */
 export type HydratedTransactionWithStorageMeta = z.infer<typeof HydratedTransactionWithStorageMetaZod>;
+/** Type guard that checks if a value is a valid HydratedTransactionWithStorageMeta. */
 export declare const isHydratedTransactionWithStorageMeta: <T>(value: T) => value is T & [{
     schema: "network.xyo.boundwitness" & {
         readonly __schema: true;
@@ -570,6 +583,7 @@ export declare const isHydratedTransactionWithStorageMeta: <T>(value: T) => valu
     _dataHash: import("@xylabs/sdk-js").BrandedHash;
     _sequence: import("@xyo-network/sdk-js").LocalSequence | import("@xyo-network/sdk-js").QualifiedSequence;
 }[]];
+/** Converts a value to HydratedTransactionWithStorageMeta, throwing if invalid. */
 export declare const asHydratedTransactionWithStorageMeta: {
     <T>(value: T): (T & [{
         schema: "network.xyo.boundwitness" & {
@@ -660,6 +674,7 @@ export declare const asHydratedTransactionWithStorageMeta: {
         _sequence: import("@xyo-network/sdk-js").LocalSequence | import("@xyo-network/sdk-js").QualifiedSequence;
     }[]];
 };
+/** toHydratedTransactionWithStorageMeta constant. */
 export declare const toHydratedTransactionWithStorageMeta: {
     <T>(value: T): (T & [{
         schema: "network.xyo.boundwitness" & {
@@ -750,6 +765,7 @@ export declare const toHydratedTransactionWithStorageMeta: {
         _sequence: import("@xyo-network/sdk-js").LocalSequence | import("@xyo-network/sdk-js").QualifiedSequence;
     }[]];
 };
+/** UnsignedHydratedTransactionZod constant. */
 export declare const UnsignedHydratedTransactionZod: z.ZodTuple<[z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.boundwitness" & {
         readonly __schema: true;
@@ -787,7 +803,9 @@ export declare const UnsignedHydratedTransactionZod: z.ZodTuple<[z.ZodObject<{
 }, z.core.$strip>, z.ZodArray<z.ZodObject<{
     schema: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/sdk-js").BrandedSchema<string>, string>>;
 }, z.core.$strict>>], null>;
+/** Type representing a hydrated UnsignedTransaction with resolved payloads. */
 export type UnsignedHydratedTransaction = z.infer<typeof UnsignedHydratedTransactionZod>;
+/** Type guard that checks if a value is a valid UnsignedHydratedTransaction. */
 export declare const isUnsignedHydratedTransaction: <T>(value: T) => value is T & [{
     schema: "network.xyo.boundwitness" & {
         readonly __schema: true;
@@ -825,6 +843,7 @@ export declare const isUnsignedHydratedTransaction: <T>(value: T) => value is T
 }, {
     schema: import("@xyo-network/sdk-js").BrandedSchema<string>;
 }[]];
+/** Converts a value to UnsignedHydratedTransaction, throwing if invalid. */
 export declare const asUnsignedHydratedTransaction: {
     <T>(value: T): (T & [{
         schema: "network.xyo.boundwitness" & {
@@ -901,6 +920,7 @@ export declare const asUnsignedHydratedTransaction: {
         schema: import("@xyo-network/sdk-js").BrandedSchema<string>;
     }[]];
 };
+/** toUnsignedHydratedTransaction constant. */
 export declare const toUnsignedHydratedTransaction: {
     <T>(value: T): (T & [{
         schema: "network.xyo.boundwitness" & {
@@ -977,6 +997,7 @@ export declare const toUnsignedHydratedTransaction: {
         schema: import("@xyo-network/sdk-js").BrandedSchema<string>;
     }[]];
 };
+/** UnsignedHydratedTransactionWithHashMetaZod constant. */
 export declare const UnsignedHydratedTransactionWithHashMetaZod: z.ZodTuple<[z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.boundwitness" & {
         readonly __schema: true;
@@ -1018,7 +1039,9 @@ export declare const UnsignedHydratedTransactionWithHashMetaZod: z.ZodTuple<[z.Z
     _hash: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHash, string>>;
     _dataHash: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHash, string>>;
 }, z.core.$loose>>], null>;
+/** Type representing a hydrated UnsignedTransactionWithHashMeta with resolved payloads. */
 export type UnsignedHydratedTransactionWithHashMeta = z.infer<typeof UnsignedHydratedTransactionWithHashMetaZod>;
+/** Type guard that checks if a value is a valid UnsignedHydratedTransactionWithHashMeta. */
 export declare const isUnsignedHydratedTransactionWithHashMeta: <T>(value: T) => value is T & [{
     schema: "network.xyo.boundwitness" & {
         readonly __schema: true;
@@ -1061,6 +1084,7 @@ export declare const isUnsignedHydratedTransactionWithHashMeta: <T>(value: T) =>
     _hash: import("@xylabs/sdk-js").BrandedHash;
     _dataHash: import("@xylabs/sdk-js").BrandedHash;
 }[]];
+/** Converts a value to UnsignedHydratedTransactionWithHashMeta, throwing if invalid. */
 export declare const asUnsignedHydratedTransactionWithHashMeta: {
     <T>(value: T): (T & [{
         schema: "network.xyo.boundwitness" & {
@@ -1147,6 +1171,7 @@ export declare const asUnsignedHydratedTransactionWithHashMeta: {
         _dataHash: import("@xylabs/sdk-js").BrandedHash;
     }[]];
 };
+/** toUnsignedHydratedTransactionWithHashMeta constant. */
 export declare const toUnsignedHydratedTransactionWithHashMeta: {
     <T>(value: T): (T & [{
         schema: "network.xyo.boundwitness" & {
@@ -1233,6 +1258,7 @@ export declare const toUnsignedHydratedTransactionWithHashMeta: {
         _dataHash: import("@xylabs/sdk-js").BrandedHash;
     }[]];
 };
+/** UnsignedHydratedTransactionWithStorageMetaZod constant. */
 export declare const UnsignedHydratedTransactionWithStorageMetaZod: z.ZodTuple<[z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.boundwitness" & {
         readonly __schema: true;
@@ -1276,7 +1302,9 @@ export declare const UnsignedHydratedTransactionWithStorageMetaZod: z.ZodTuple<[
     _dataHash: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHash, string>>;
     _sequence: z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/sdk-js").LocalSequence, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/sdk-js").QualifiedSequence, string>>]>;
 }, z.core.$loose>>], null>;
+/** Type representing a hydrated UnsignedTransactionWithStorageMeta with resolved payloads. */
 export type UnsignedHydratedTransactionWithStorageMeta = z.infer<typeof UnsignedHydratedTransactionWithStorageMetaZod>;
+/** Type guard that checks if a value is a valid UnsignedHydratedTransactionWithStorageMeta. */
 export declare const isUnsignedHydratedTransactionWithStorageMeta: <T>(value: T) => value is T & [{
     schema: "network.xyo.boundwitness" & {
         readonly __schema: true;
@@ -1321,6 +1349,7 @@ export declare const isUnsignedHydratedTransactionWithStorageMeta: <T>(value: T)
     _dataHash: import("@xylabs/sdk-js").BrandedHash;
     _sequence: import("@xyo-network/sdk-js").LocalSequence | import("@xyo-network/sdk-js").QualifiedSequence;
 }[]];
+/** Converts a value to UnsignedHydratedTransactionWithStorageMeta, throwing if invalid. */
 export declare const asUnsignedHydratedTransactionWithStorageMeta: {
     <T>(value: T): (T & [{
         schema: "network.xyo.boundwitness" & {
@@ -1411,6 +1440,7 @@ export declare const asUnsignedHydratedTransactionWithStorageMeta: {
         _sequence: import("@xyo-network/sdk-js").LocalSequence | import("@xyo-network/sdk-js").QualifiedSequence;
     }[]];
 };
+/** toUnsignedHydratedTransactionWithStorageMeta constant. */
 export declare const toUnsignedHydratedTransactionWithStorageMeta: {
     <T>(value: T): (T & [{
         schema: "network.xyo.boundwitness" & {
@@ -1501,6 +1531,7 @@ export declare const toUnsignedHydratedTransactionWithStorageMeta: {
         _sequence: import("@xyo-network/sdk-js").LocalSequence | import("@xyo-network/sdk-js").QualifiedSequence;
     }[]];
 };
+/** SignedHydratedTransactionZod constant. */
 export declare const SignedHydratedTransactionZod: z.ZodTuple<[z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.boundwitness" & {
         readonly __schema: true;
@@ -1538,7 +1569,9 @@ export declare const SignedHydratedTransactionZod: z.ZodTuple<[z.ZodObject<{
 }, z.core.$strip>, z.ZodArray<z.ZodObject<{
     schema: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/sdk-js").BrandedSchema<string>, string>>;
 }, z.core.$strict>>], null>;
+/** Type representing a hydrated SignedTransaction with resolved payloads. */
 export type SignedHydratedTransaction = z.infer<typeof SignedHydratedTransactionZod>;
+/** Type guard that checks if a value is a valid SignedHydratedTransaction. */
 export declare const isSignedHydratedTransaction: <T>(value: T) => value is T & [{
     schema: "network.xyo.boundwitness" & {
         readonly __schema: true;
@@ -1576,6 +1609,7 @@ export declare const isSignedHydratedTransaction: <T>(value: T) => value is T &
 }, {
     schema: import("@xyo-network/sdk-js").BrandedSchema<string>;
 }[]];
+/** Converts a value to SignedHydratedTransaction, throwing if invalid. */
 export declare const asSignedHydratedTransaction: {
     <T>(value: T): (T & [{
         schema: "network.xyo.boundwitness" & {
@@ -1652,6 +1686,7 @@ export declare const asSignedHydratedTransaction: {
         schema: import("@xyo-network/sdk-js").BrandedSchema<string>;
     }[]];
 };
+/** toSignedHydratedTransaction constant. */
 export declare const toSignedHydratedTransaction: {
     <T>(value: T): (T & [{
         schema: "network.xyo.boundwitness" & {
@@ -1728,6 +1763,7 @@ export declare const toSignedHydratedTransaction: {
         schema: import("@xyo-network/sdk-js").BrandedSchema<string>;
     }[]];
 };
+/** SignedHydratedTransactionWithHashMetaZod constant. */
 export declare const SignedHydratedTransactionWithHashMetaZod: z.ZodTuple<[z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.boundwitness" & {
         readonly __schema: true;
@@ -1769,7 +1805,9 @@ export declare const SignedHydratedTransactionWithHashMetaZod: z.ZodTuple<[z.Zod
     _hash: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHash, string>>;
     _dataHash: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHash, string>>;
 }, z.core.$loose>>], null>;
+/** Type representing a hydrated SignedTransactionWithHashMeta with resolved payloads. */
 export type SignedHydratedTransactionWithHashMeta = z.infer<typeof SignedHydratedTransactionWithHashMetaZod>;
+/** Type guard that checks if a value is a valid SignedHydratedTransactionWithHashMeta. */
 export declare const isSignedHydratedTransactionWithHashMeta: <T>(value: T) => value is T & [{
     schema: "network.xyo.boundwitness" & {
         readonly __schema: true;
@@ -1812,6 +1850,7 @@ export declare const isSignedHydratedTransactionWithHashMeta: <T>(value: T) => v
     _hash: import("@xylabs/sdk-js").BrandedHash;
     _dataHash: import("@xylabs/sdk-js").BrandedHash;
 }[]];
+/** Converts a value to SignedHydratedTransactionWithHashMeta, throwing if invalid. */
 export declare const asSignedHydratedTransactionWithHashMeta: {
     <T>(value: T): (T & [{
         schema: "network.xyo.boundwitness" & {
@@ -1898,6 +1937,7 @@ export declare const asSignedHydratedTransactionWithHashMeta: {
         _dataHash: import("@xylabs/sdk-js").BrandedHash;
     }[]];
 };
+/** toSignedHydratedTransactionWithHashMeta constant. */
 export declare const toSignedHydratedTransactionWithHashMeta: {
     <T>(value: T): (T & [{
         schema: "network.xyo.boundwitness" & {
@@ -1984,6 +2024,7 @@ export declare const toSignedHydratedTransactionWithHashMeta: {
         _dataHash: import("@xylabs/sdk-js").BrandedHash;
     }[]];
 };
+/** SignedHydratedTransactionWithStorageMetaZod constant. */
 export declare const SignedHydratedTransactionWithStorageMetaZod: z.ZodTuple<[z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.boundwitness" & {
         readonly __schema: true;
@@ -2027,7 +2068,9 @@ export declare const SignedHydratedTransactionWithStorageMetaZod: z.ZodTuple<[z.
     _dataHash: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHash, string>>;
     _sequence: z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/sdk-js").LocalSequence, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/sdk-js").QualifiedSequence, string>>]>;
 }, z.core.$loose>>], null>;
+/** Type representing a hydrated SignedTransactionWithStorageMeta with resolved payloads. */
 export type SignedHydratedTransactionWithStorageMeta = z.infer<typeof SignedHydratedTransactionWithStorageMetaZod>;
+/** Type guard that checks if a value is a valid SignedHydratedTransactionWithStorageMeta. */
 export declare const isSignedHydratedTransactionWithStorageMeta: <T>(value: T) => value is T & [{
     schema: "network.xyo.boundwitness" & {
         readonly __schema: true;
@@ -2072,6 +2115,7 @@ export declare const isSignedHydratedTransactionWithStorageMeta: <T>(value: T) =
     _dataHash: import("@xylabs/sdk-js").BrandedHash;
     _sequence: import("@xyo-network/sdk-js").LocalSequence | import("@xyo-network/sdk-js").QualifiedSequence;
 }[]];
+/** Converts a value to SignedHydratedTransactionWithStorageMeta, throwing if invalid. */
 export declare const asSignedHydratedTransactionWithStorageMeta: {
     <T>(value: T): (T & [{
         schema: "network.xyo.boundwitness" & {
@@ -2162,6 +2206,7 @@ export declare const asSignedHydratedTransactionWithStorageMeta: {
         _sequence: import("@xyo-network/sdk-js").LocalSequence | import("@xyo-network/sdk-js").QualifiedSequence;
     }[]];
 };
+/** toSignedHydratedTransactionWithStorageMeta constant. */
 export declare const toSignedHydratedTransactionWithStorageMeta: {
     <T>(value: T): (T & [{
         schema: "network.xyo.boundwitness" & {

package/dist/neutral/model/HydratedTransaction.d.ts.map

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

package/dist/neutral/model/OpCodes.d.ts

@@ -1,2 +1,3 @@
+/** ELEVATE_OPCODE constant. */
 export declare const ELEVATE_OPCODE = "elevate";
 //# sourceMappingURL=OpCodes.d.ts.map

package/dist/neutral/model/OpCodes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OpCodes.d.ts","sourceRoot":"","sources":["../../../src/model/OpCodes.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,YAAY,CAAA"}
+{"version":3,"file":"OpCodes.d.ts","sourceRoot":"","sources":["../../../src/model/OpCodes.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,eAAO,MAAM,cAAc,YAAY,CAAA"}

package/dist/neutral/model/PayloadMap.d.ts

@@ -1,7 +1,10 @@
 import type { Hash } from '@xylabs/sdk-js';
 import type { Payload } from '@xyo-network/sdk-js';
 import type { MapType, MapTypeRead, MapTypeWrite } from '../map/index.ts';
+/** PayloadMapWrite type. */
 export type PayloadMapWrite<T extends Payload = Payload> = MapTypeWrite<Hash, T>;
+/** PayloadMapRead type. */
 export type PayloadMapRead<T extends Payload = Payload> = MapTypeRead<Hash, T>;
+/** PayloadMap type. */
 export type PayloadMap<T extends Payload = Payload> = MapType<Hash, T>;
 //# sourceMappingURL=PayloadMap.d.ts.map

package/dist/neutral/model/PayloadMap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PayloadMap.d.ts","sourceRoot":"","sources":["../../../src/model/PayloadMap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAElD,OAAO,KAAK,EACV,OAAO,EAAE,WAAW,EAAE,YAAY,EACnC,MAAM,iBAAiB,CAAA;AAExB,MAAM,MAAM,eAAe,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,YAAY,CAAC,IAAI,EAAE,CAAC,CAAC,CAAA;AAChF,MAAM,MAAM,cAAc,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC,CAAA;AAC9E,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,CAAA"}
+{"version":3,"file":"PayloadMap.d.ts","sourceRoot":"","sources":["../../../src/model/PayloadMap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAElD,OAAO,KAAK,EACV,OAAO,EAAE,WAAW,EAAE,YAAY,EACnC,MAAM,iBAAiB,CAAA;AAExB,4BAA4B;AAC5B,MAAM,MAAM,eAAe,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,YAAY,CAAC,IAAI,EAAE,CAAC,CAAC,CAAA;AAChF,2BAA2B;AAC3B,MAAM,MAAM,cAAc,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC,CAAA;AAC9E,uBAAuB;AACvB,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,CAAA"}

package/dist/neutral/model/Permission.d.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+/** CaveatTypesZod constant. */
 export declare const CaveatTypesZod: z.ZodEnum<{
     chain: "chain";
     expiration: "expiration";
@@ -6,6 +7,7 @@ export declare const CaveatTypesZod: z.ZodEnum<{
     rateLimit: "rateLimit";
     restrictReturnedAccounts: "restrictReturnedAccounts";
 }>;
+/** CaveatsZod constant. */
 export declare const CaveatsZod: z.ZodObject<{
     type: z.ZodEnum<{
         chain: "chain";
@@ -16,6 +18,7 @@ export declare const CaveatsZod: z.ZodObject<{
     }>;
     value: z.ZodJSONSchema;
 }, z.core.$strip>;
+/** PermissionZod constant. */
 export declare const PermissionZod: z.ZodObject<{
     parentCapability: z.ZodString;
     caveats: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -30,6 +33,7 @@ export declare const PermissionZod: z.ZodObject<{
     }, z.core.$strip>>>;
     invoker: z.ZodString;
 }, z.core.$strip>;
+/** InvokerPermissionZod constant. */
 export declare const InvokerPermissionZod: z.ZodObject<{
     parentCapability: z.ZodString;
     caveats: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -45,7 +49,9 @@ export declare const InvokerPermissionZod: z.ZodObject<{
     invoker: z.ZodString;
     date: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
+/** PermissionRequestZod constant. */
 export declare const PermissionRequestZod: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>>;
+/** RequestedPermissionZod constant. */
 export declare const RequestedPermissionZod: z.ZodObject<{
     parentCapability: z.ZodString;
     date: z.ZodOptional<z.ZodNumber>;

package/dist/neutral/model/Permission.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Permission.d.ts","sourceRoot":"","sources":["../../../src/model/Permission.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,cAAc;;;;;;EAA+F,CAAA;AAE1H,eAAO,MAAM,UAAU;;;;;;;;;iBAGrB,CAAA;AAEF,eAAO,MAAM,aAAa;;;;;;;;;;;;;iBAIxB,CAAA;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;iBAA4D,CAAA;AAE7F,eAAO,MAAM,oBAAoB,8DAAsD,CAAA;AAEvF,eAAO,MAAM,sBAAsB;;;iBAGjC,CAAA"}
+{"version":3,"file":"Permission.d.ts","sourceRoot":"","sources":["../../../src/model/Permission.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,+BAA+B;AAC/B,eAAO,MAAM,cAAc;;;;;;EAA+F,CAAA;AAE1H,2BAA2B;AAC3B,eAAO,MAAM,UAAU;;;;;;;;;iBAGrB,CAAA;AAEF,8BAA8B;AAC9B,eAAO,MAAM,aAAa;;;;;;;;;;;;;iBAIxB,CAAA;AAEF,qCAAqC;AACrC,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;iBAA4D,CAAA;AAE7F,qCAAqC;AACrC,eAAO,MAAM,oBAAoB,8DAAsD,CAAA;AAEvF,uCAAuC;AACvC,eAAO,MAAM,sBAAsB;;;iBAGjC,CAAA"}

package/dist/neutral/model/Position.d.ts

@@ -1,5 +1,6 @@
 import type { Address } from '@xylabs/sdk-js';
 import type { PositionId } from './PositionId.ts';
+/** Position type. */
 export type Position = {
     addBlock: number;
     amount: bigint;

package/dist/neutral/model/Position.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Position.d.ts","sourceRoot":"","sources":["../../../src/model/Position.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAA;AAE7C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAEjD,MAAM,MAAM,QAAQ,GAAG;IAErB,QAAQ,EAAE,MAAM,CAAA;IAEhB,MAAM,EAAE,MAAM,CAAA;IAEd,EAAE,EAAE,UAAU,CAAA;IAEd,WAAW,EAAE,MAAM,CAAA;IAEnB,MAAM,EAAE,OAAO,CAAA;IAEf,MAAM,EAAE,OAAO,CAAA;IAEf,aAAa,EAAE,MAAM,CAAA;CACtB,CAAA"}
+{"version":3,"file":"Position.d.ts","sourceRoot":"","sources":["../../../src/model/Position.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAA;AAE7C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAEjD,qBAAqB;AACrB,MAAM,MAAM,QAAQ,GAAG;IAErB,QAAQ,EAAE,MAAM,CAAA;IAEhB,MAAM,EAAE,MAAM,CAAA;IAEd,EAAE,EAAE,UAAU,CAAA;IAEd,WAAW,EAAE,MAAM,CAAA;IAEnB,MAAM,EAAE,OAAO,CAAA;IAEf,MAAM,EAAE,OAAO,CAAA;IAEf,aAAa,EAAE,MAAM,CAAA;CACtB,CAAA"}

package/dist/neutral/model/PositionId.d.ts

@@ -1,4 +1,5 @@
 import type { Brand } from '@xylabs/sdk-js';
+/** PositionId type. */
 export type PositionId = Brand<number, {
     readonly __positionId: true;
 }>;

package/dist/neutral/model/PositionId.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PositionId.d.ts","sourceRoot":"","sources":["../../../src/model/PositionId.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAA;AAE3C,MAAM,MAAM,UAAU,GAAG,KAAK,CAAC,MAAM,EAAE;IAAE,QAAQ,CAAC,YAAY,EAAE,IAAI,CAAA;CAAE,CAAC,CAAA"}
+{"version":3,"file":"PositionId.d.ts","sourceRoot":"","sources":["../../../src/model/PositionId.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAA;AAE3C,uBAAuB;AACvB,MAAM,MAAM,UAAU,GAAG,KAAK,CAAC,MAAM,EAAE;IAAE,QAAQ,CAAC,YAAY,EAAE,IAAI,CAAA;CAAE,CAAC,CAAA"}