@xyo-network/xl1-protocol-model 1.26.1

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

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+/** ChainQualificationZod constant. */
+export declare const ChainQualificationZod: z.ZodObject<{
+    head: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHash, string>>;
+    range: z.ZodTuple<[z.ZodPipe<z.ZodNumber, z.ZodTransform<import("../index.ts").XL1BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("../index.ts").XL1BlockNumber, number>>], null>;
+}, z.core.$strip>;
+/** ChainQualification type. */
+export type ChainQualification = z.infer<typeof ChainQualificationZod>;
+/** Type guard that checks if a value is a valid ChainQualification. */
+export declare const isChainQualification: <T>(value: T) => value is T & {
+    head: import("@xylabs/sdk-js").BrandedHash;
+    range: [import("../index.ts").XL1BlockNumber, import("../index.ts").XL1BlockNumber];
+};
+/** ChainQualifiedRangeConfigZod constant. */
+export declare const ChainQualifiedRangeConfigZod: z.ZodObject<{
+    range: z.ZodTuple<[z.ZodPipe<z.ZodNumber, z.ZodTransform<import("../index.ts").XL1BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("../index.ts").XL1BlockNumber, number>>], null>;
+}, z.core.$strip>;
+/** ChainQualifiedRangeConfig type. */
+export type ChainQualifiedRangeConfig = z.infer<typeof ChainQualifiedRangeConfigZod>;
+/** Type guard that checks if a value is a valid ChainQualifiedRangeConfig. */
+export declare const isChainQualifiedRangeConfig: <T>(value: T) => value is T & {
+    range: [import("../index.ts").XL1BlockNumber, import("../index.ts").XL1BlockNumber];
+};
+/** ChainQualifiedHeadConfigZod constant. */
+export declare const ChainQualifiedHeadConfigZod: z.ZodObject<{
+    head: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHash, string>>;
+}, z.core.$strip>;
+/** ChainQualifiedHeadConfig type. */
+export type ChainQualifiedHeadConfig = z.infer<typeof ChainQualifiedHeadConfigZod>;
+/** Type guard that checks if a value is a valid ChainQualifiedHeadConfig. */
+export declare const isChainQualifiedHeadConfig: <T>(value: T) => value is T & {
+    head: import("@xylabs/sdk-js").BrandedHash;
+};
+/** ChainQualifiedConfigZod constant. */
+export declare const ChainQualifiedConfigZod: z.ZodUnion<readonly [z.ZodObject<{
+    range: z.ZodTuple<[z.ZodPipe<z.ZodNumber, z.ZodTransform<import("../index.ts").XL1BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("../index.ts").XL1BlockNumber, number>>], null>;
+}, z.core.$strip>, z.ZodObject<{
+    head: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHash, string>>;
+}, z.core.$strip>, z.ZodObject<{}, z.core.$strip>]>;
+/** ChainQualifiedConfig type. */
+export type ChainQualifiedConfig = z.infer<typeof ChainQualifiedConfigZod>;
+/** Type guard that checks if a value is a valid ChainQualifiedConfig. */
+export declare const isChainQualifiedConfig: <T>(value: T) => value is T & (Record<string, never> | {
+    range: [import("../index.ts").XL1BlockNumber, import("../index.ts").XL1BlockNumber];
+} | {
+    head: import("@xylabs/sdk-js").BrandedHash;
+});
+/** ExtendChainQualifiedConfigZod constant. */
+export declare const ExtendChainQualifiedConfigZod: <T>(zodType: z.ZodType<T>) => z.ZodType<T & ChainQualifiedConfig>;
+/** ChainQualified type. */
+export type ChainQualified<T> = [T, ChainQualification];
+/** ChainQualifiedZod constant. */
+export declare const ChainQualifiedZod: <T>(zodType: z.ZodType<T>) => z.ZodTuple<[z.ZodType<T, unknown, z.core.$ZodTypeInternals<T, unknown>>, z.ZodObject<{
+    head: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHash, string>>;
+    range: z.ZodTuple<[z.ZodPipe<z.ZodNumber, z.ZodTransform<import("../index.ts").XL1BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("../index.ts").XL1BlockNumber, number>>], null>;
+}, z.core.$strip>], null>;
+//# sourceMappingURL=ChainQualification.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ChainQualification.d.ts","sourceRoot":"","sources":["../../../src/model/ChainQualification.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,sCAAsC;AACtC,eAAO,MAAM,qBAAqB;;;iBAAuD,CAAA;AACzF,+BAA+B;AAC/B,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AACtE,uEAAuE;AACvE,eAAO,MAAM,oBAAoB;;;CAAsC,CAAA;AAEvE,6CAA6C;AAC7C,eAAO,MAAM,4BAA4B;;iBAAwC,CAAA;AACjF,sCAAsC;AACtC,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AACpF,8EAA8E;AAC9E,eAAO,MAAM,2BAA2B;;CAA6C,CAAA;AAErF,4CAA4C;AAC5C,eAAO,MAAM,2BAA2B;;iBAA8B,CAAA;AACtE,qCAAqC;AACrC,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAClF,6EAA6E;AAC7E,eAAO,MAAM,0BAA0B;;CAA4C,CAAA;AAEnF,wCAAwC;AACxC,eAAO,MAAM,uBAAuB;;;;mDAAqF,CAAA;AACzH,iCAAiC;AACjC,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAC1E,yEAAyE;AACzE,eAAO,MAAM,sBAAsB;;;;EAAwC,CAAA;AAE3E,8CAA8C;AAC9C,eAAO,MAAM,6BAA6B,EAMpC,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG,oBAAoB,CAAC,CAAA;AAEvE,2BAA2B;AAC3B,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,kBAAkB,CAAC,CAAA;AACvD,kCAAkC;AAClC,eAAO,MAAM,iBAAiB,GAAI,CAAC,EAAE,SAAS,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC;;;yBAEzD,CAAA"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"BaseContext.d.ts","sourceRoot":"","sources":["../../../../src/model/Context/BaseContext.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/BaseContext.zod.d.ts

@@ -0,0 +1,26 @@
+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>>;
+    meterProvider: z.ZodOptional<z.ZodCustom<MeterProvider, MeterProvider>>;
+    singletons: z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodSymbol]>, z.ZodUnknown>;
+    timeBudgetLimit: z.ZodOptional<z.ZodNumber>;
+    traceProvider: z.ZodOptional<z.ZodCustom<TracerProvider, TracerProvider>>;
+}, z.core.$strip>;
+//# sourceMappingURL=BaseContext.zod.d.ts.map

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

@@ -0,0 +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,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

@@ -0,0 +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

@@ -0,0 +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,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

@@ -0,0 +1,33 @@
+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>>;
+    singletons: z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodSymbol]>, z.ZodUnknown>;
+    timeBudgetLimit: z.ZodOptional<z.ZodNumber>;
+    traceProvider: z.ZodOptional<z.ZodCustom<import("@opentelemetry/api").TracerProvider, import("@opentelemetry/api").TracerProvider>>;
+    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>>;
+    singletons: z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodSymbol]>, z.ZodUnknown>;
+    timeBudgetLimit: z.ZodOptional<z.ZodNumber>;
+    traceProvider: z.ZodOptional<z.ZodCustom<import("@opentelemetry/api").TracerProvider, import("@opentelemetry/api").TracerProvider>>;
+    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>>;
+    singletons: z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodSymbol]>, z.ZodUnknown>;
+    timeBudgetLimit: z.ZodOptional<z.ZodNumber>;
+    traceProvider: z.ZodOptional<z.ZodCustom<import("@opentelemetry/api").TracerProvider, import("@opentelemetry/api").TracerProvider>>;
+    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>;
+//# sourceMappingURL=BlockContext.zod.d.ts.map

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

@@ -0,0 +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,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

@@ -0,0 +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

@@ -0,0 +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,2BAA2B;AAC3B,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA"}

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

@@ -0,0 +1,10 @@
+/** 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>>;
+    singletons: import("zod").ZodRecord<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodSymbol]>, import("zod").ZodUnknown>;
+    timeBudgetLimit: import("zod").ZodOptional<import("zod").ZodNumber>;
+    traceProvider: import("zod").ZodOptional<import("zod").ZodCustom<import("@opentelemetry/api").TracerProvider, import("@opentelemetry/api").TracerProvider>>;
+    caches: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodCustom<import("../../index.ts").MapType<string, unknown>, import("../../index.ts").MapType<string, unknown>>>;
+}, import("zod/v4/core").$strip>;
+//# sourceMappingURL=CachingContext.zod.d.ts.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +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

@@ -0,0 +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,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

@@ -0,0 +1,115 @@
+/** 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>>;
+    singletons: import("zod").ZodRecord<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodSymbol]>, import("zod").ZodUnknown>;
+    timeBudgetLimit: import("zod").ZodOptional<import("zod").ZodNumber>;
+    traceProvider: import("zod").ZodOptional<import("zod").ZodCustom<import("@opentelemetry/api").TracerProvider, import("@opentelemetry/api").TracerProvider>>;
+    caches: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodCustom<import("../../index.ts").MapType<string, unknown>, import("../../index.ts").MapType<string, unknown>>>;
+    chainMap: import("zod").ZodCustom<import("@xyo-network/archivist-model").ReadArchivist<import("@xyo-network/payload-model").Payload, import("@xylabs/hex").BrandedHash, import("@xyo-network/payload-model").Sequence>, import("@xyo-network/archivist-model").ReadArchivist<import("@xyo-network/payload-model").Payload, import("@xylabs/hex").BrandedHash, import("@xyo-network/payload-model").Sequence>>;
+    head: import("zod").ZodObject<{
+        $epoch: import("zod").ZodNumber;
+        block: import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("../../index.ts").XL1BlockNumber, number>>;
+        chain: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@xylabs/hex").BrandedHex, string>>;
+        previous: import("zod").ZodNullable<import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@xylabs/hex").BrandedHash, string>>>;
+        protocol: import("zod").ZodOptional<import("zod").ZodNumber>;
+        step_hashes: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@xylabs/hex").BrandedHash, string>>>>;
+        schema: import("zod").ZodLiteral<"network.xyo.boundwitness" & {
+            readonly __schema: true;
+        }>;
+        addresses: import("zod").ZodArray<import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }, string>>>;
+        payload_hashes: import("zod").ZodArray<import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@xylabs/hex").BrandedHash, string>>>;
+        payload_schemas: import("zod").ZodArray<import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@xyo-network/payload-model").BrandedSchema<string>, string>>>;
+        previous_hashes: import("zod").ZodArray<import("zod").ZodNullable<import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@xylabs/hex").BrandedHash, string>>>>;
+        $destination: import("zod").ZodOptional<import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }, string>>>;
+        $sourceQuery: import("zod").ZodOptional<import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@xylabs/hex").BrandedHash, string>>>;
+        $signatures: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@xylabs/hex").BrandedHex, string>>, import("zod").ZodNull]>>;
+        _hash: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@xylabs/hex").BrandedHash, string>>;
+        _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>>;
+    singletons: import("zod").ZodRecord<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodSymbol]>, import("zod").ZodUnknown>;
+    timeBudgetLimit: import("zod").ZodOptional<import("zod").ZodNumber>;
+    traceProvider: import("zod").ZodOptional<import("zod").ZodCustom<import("@opentelemetry/api").TracerProvider, import("@opentelemetry/api").TracerProvider>>;
+    caches: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodCustom<import("../../index.ts").MapType<string, unknown>, import("../../index.ts").MapType<string, unknown>>>;
+    chainMap: import("zod").ZodCustom<import("@xyo-network/archivist-model").WriteArchivist<import("@xyo-network/payload-model").Payload, import("@xyo-network/payload-model").Payload, import("@xyo-network/payload-model").Payload, import("@xylabs/hex").BrandedHash>, import("@xyo-network/archivist-model").WriteArchivist<import("@xyo-network/payload-model").Payload, import("@xyo-network/payload-model").Payload, import("@xyo-network/payload-model").Payload, import("@xylabs/hex").BrandedHash>>;
+    head: import("zod").ZodObject<{
+        $epoch: import("zod").ZodNumber;
+        block: import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("../../index.ts").XL1BlockNumber, number>>;
+        chain: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@xylabs/hex").BrandedHex, string>>;
+        previous: import("zod").ZodNullable<import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@xylabs/hex").BrandedHash, string>>>;
+        protocol: import("zod").ZodOptional<import("zod").ZodNumber>;
+        step_hashes: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@xylabs/hex").BrandedHash, string>>>>;
+        schema: import("zod").ZodLiteral<"network.xyo.boundwitness" & {
+            readonly __schema: true;
+        }>;
+        addresses: import("zod").ZodArray<import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }, string>>>;
+        payload_hashes: import("zod").ZodArray<import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@xylabs/hex").BrandedHash, string>>>;
+        payload_schemas: import("zod").ZodArray<import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@xyo-network/payload-model").BrandedSchema<string>, string>>>;
+        previous_hashes: import("zod").ZodArray<import("zod").ZodNullable<import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@xylabs/hex").BrandedHash, string>>>>;
+        $destination: import("zod").ZodOptional<import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }, string>>>;
+        $sourceQuery: import("zod").ZodOptional<import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@xylabs/hex").BrandedHash, string>>>;
+        $signatures: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@xylabs/hex").BrandedHex, string>>, import("zod").ZodNull]>>;
+        _hash: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@xylabs/hex").BrandedHash, string>>;
+        _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>>;
+    singletons: import("zod").ZodRecord<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodSymbol]>, import("zod").ZodUnknown>;
+    timeBudgetLimit: import("zod").ZodOptional<import("zod").ZodNumber>;
+    traceProvider: import("zod").ZodOptional<import("zod").ZodCustom<import("@opentelemetry/api").TracerProvider, import("@opentelemetry/api").TracerProvider>>;
+    caches: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodCustom<import("../../index.ts").MapType<string, unknown>, import("../../index.ts").MapType<string, unknown>>>;
+    chainMap: import("zod").ZodCustom<import("@xyo-network/archivist-model").WriteArchivist<import("@xyo-network/payload-model").Payload, import("@xyo-network/payload-model").Payload, import("@xyo-network/payload-model").Payload, import("@xylabs/hex").BrandedHash>, import("@xyo-network/archivist-model").WriteArchivist<import("@xyo-network/payload-model").Payload, import("@xyo-network/payload-model").Payload, import("@xyo-network/payload-model").Payload, import("@xylabs/hex").BrandedHash>>;
+    head: import("zod").ZodObject<{
+        $epoch: import("zod").ZodNumber;
+        block: import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("../../index.ts").XL1BlockNumber, number>>;
+        chain: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@xylabs/hex").BrandedHex, string>>;
+        previous: import("zod").ZodNullable<import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@xylabs/hex").BrandedHash, string>>>;
+        protocol: import("zod").ZodOptional<import("zod").ZodNumber>;
+        step_hashes: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@xylabs/hex").BrandedHash, string>>>>;
+        schema: import("zod").ZodLiteral<"network.xyo.boundwitness" & {
+            readonly __schema: true;
+        }>;
+        addresses: import("zod").ZodArray<import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }, string>>>;
+        payload_hashes: import("zod").ZodArray<import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@xylabs/hex").BrandedHash, string>>>;
+        payload_schemas: import("zod").ZodArray<import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@xyo-network/payload-model").BrandedSchema<string>, string>>>;
+        previous_hashes: import("zod").ZodArray<import("zod").ZodNullable<import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@xylabs/hex").BrandedHash, string>>>>;
+        $destination: import("zod").ZodOptional<import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }, string>>>;
+        $sourceQuery: import("zod").ZodOptional<import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@xylabs/hex").BrandedHash, string>>>;
+        $signatures: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@xylabs/hex").BrandedHex, string>>, import("zod").ZodNull]>>;
+        _hash: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@xylabs/hex").BrandedHash, string>>;
+        _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>;
+//# sourceMappingURL=ChainContext.zod.d.ts.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +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

@@ -0,0 +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,wBAAwB;AACxB,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA"}

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

@@ -0,0 +1,70 @@
+import z from 'zod';
+/** HeadContextBaseZod constant. */
+export declare const HeadContextBaseZod: z.ZodObject<{
+    head: z.ZodObject<{
+        $epoch: z.ZodNumber;
+        block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("../../index.ts").XL1BlockNumber, number>>;
+        chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").BrandedHex, string>>;
+        previous: z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").BrandedHash, string>>>;
+        protocol: z.ZodOptional<z.ZodNumber>;
+        step_hashes: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").BrandedHash, string>>>>;
+        schema: z.ZodLiteral<"network.xyo.boundwitness" & {
+            readonly __schema: true;
+        }>;
+        addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }, string>>>;
+        payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").BrandedHash, string>>>;
+        payload_schemas: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/sdk-js").BrandedSchema<string>, string>>>;
+        previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").BrandedHash, string>>>>;
+        $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }, string>>>;
+        $sourceQuery: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").BrandedHash, string>>>;
+        $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").BrandedHex, string>>, z.ZodNull]>>;
+        _hash: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").BrandedHash, string>>;
+        _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>>;
+    singletons: z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodSymbol]>, z.ZodUnknown>;
+    timeBudgetLimit: z.ZodOptional<z.ZodNumber>;
+    traceProvider: z.ZodOptional<z.ZodCustom<import("@opentelemetry/api").TracerProvider, import("@opentelemetry/api").TracerProvider>>;
+    caches: z.ZodRecord<z.ZodString, z.ZodCustom<import("../../index.ts").MapType<string, unknown>, import("../../index.ts").MapType<string, unknown>>>;
+    head: z.ZodObject<{
+        $epoch: z.ZodNumber;
+        block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("../../index.ts").XL1BlockNumber, number>>;
+        chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").BrandedHex, string>>;
+        previous: z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").BrandedHash, string>>>;
+        protocol: z.ZodOptional<z.ZodNumber>;
+        step_hashes: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").BrandedHash, string>>>>;
+        schema: z.ZodLiteral<"network.xyo.boundwitness" & {
+            readonly __schema: true;
+        }>;
+        addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }, string>>>;
+        payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").BrandedHash, string>>>;
+        payload_schemas: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/sdk-js").BrandedSchema<string>, string>>>;
+        previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").BrandedHash, string>>>>;
+        $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }, string>>>;
+        $sourceQuery: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").BrandedHash, string>>>;
+        $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").BrandedHex, string>>, z.ZodNull]>>;
+        _hash: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").BrandedHash, string>>;
+        _dataHash: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").BrandedHash, string>>;
+    }, z.z.core.$strip>;
+}, z.z.core.$strip>;
+//# sourceMappingURL=HeadContext.zod.d.ts.map

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

@@ -0,0 +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,mCAAmC;AACnC,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAE9B,CAAA;AAED,+BAA+B;AAC/B,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAAyD,CAAA"}

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

@@ -0,0 +1,11 @@
+export * from './BaseContext.ts';
+export * from './BaseContext.zod.ts';
+export * from './BlockContext.ts';
+export * from './BlockContext.zod.ts';
+export * from './CachingContext.ts';
+export * from './CachingContext.zod.ts';
+export * from './ChainContext.ts';
+export * from './ChainContext.zod.ts';
+export * from './HeadContext.ts';
+export * from './HeadContext.zod.ts';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/model/Context/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAA;AAChC,cAAc,sBAAsB,CAAA;AACpC,cAAc,mBAAmB,CAAA;AACjC,cAAc,uBAAuB,CAAA;AACrC,cAAc,qBAAqB,CAAA;AACnC,cAAc,yBAAyB,CAAA;AACvC,cAAc,mBAAmB,CAAA;AACjC,cAAc,uBAAuB,CAAA;AACrC,cAAc,kBAAkB,CAAA;AAChC,cAAc,sBAAsB,CAAA"}

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

@@ -0,0 +1,6 @@
+import type { Brand } from '@xylabs/sdk-js';
+/** GatewayName type. */
+export type GatewayName = Brand<string, {
+    __gatewayName: true;
+}>;
+//# sourceMappingURL=GatewayName.d.ts.map

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

@@ -0,0 +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,wBAAwB;AACxB,MAAM,MAAM,WAAW,GAAG,KAAK,CAAC,MAAM,EAAE;IAAE,aAAa,EAAE,IAAI,CAAA;CAAE,CAAC,CAAA"}