@xyo-network/xl1-protocol 4.0.11 → 4.0.14

package/dist/neutral/modules/protocol-model/payload/elevatable/Hash.d.ts

@@ -0,0 +1,21 @@
+import type { Hash } from '@ariestools/sdk';
+import type { Payload } from '@xyo-network/sdk';
+/** Schema identifier for hash payloads. */
+export declare const HashSchema: "network.xyo.hash" & {
+    readonly __schema: true;
+};
+/** Schema type for Hash payloads. */
+export type HashSchema = typeof HashSchema;
+/** Fields for a hash payload containing a single hash value. */
+export interface HashFields {
+    hash: Hash;
+}
+/** A payload containing a hash value. */
+export type HashPayload = Payload<HashFields, HashSchema>;
+/** Type guard that checks whether a value is a HashPayload. */
+export declare const isHashPayload: (x?: unknown) => x is HashPayload;
+/** Casts a value to HashPayload or returns undefined if it does not match. */
+export declare const asHashPayload: import("@ariestools/sdk").AsTypeFunction<HashPayload>;
+/** Casts a value to HashPayload with storage metadata or returns undefined. */
+export declare const asHashPayloadWithStorageMeta: import("@ariestools/sdk").AsTypeFunction<HashPayload>;
+//# sourceMappingURL=Hash.d.ts.map

package/dist/neutral/modules/protocol-model/payload/elevatable/Hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Hash.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-model/payload/elevatable/Hash.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAE3C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAG/C,2CAA2C;AAC3C,eAAO,MAAM,UAAU;;CAAqC,CAAA;AAC5D,qCAAqC;AACrC,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAA;AAE1C,gEAAgE;AAChE,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,IAAI,CAAA;CACX;AAED,yCAAyC;AACzC,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC,UAAU,EAAE,UAAU,CAAC,CAAA;AAEzD,+DAA+D;AAC/D,eAAO,MAAM,aAAa,mCAAiD,CAAA;AAE3E,8EAA8E;AAC9E,eAAO,MAAM,aAAa,uDAAwC,CAAA;AAClE,+EAA+E;AAC/E,eAAO,MAAM,4BAA4B,uDAAwC,CAAA"}

package/dist/neutral/modules/protocol-model/payload/elevatable/StepComplete.d.ts

@@ -0,0 +1,22 @@
+import type { Hash } from '@ariestools/sdk';
+import type { Payload } from '@xyo-network/sdk';
+import type { FromFields } from './Executable.js';
+/** Schema identifier for StepComplete payloads. */
+export declare const StepCompleteSchema: "network.xyo.chain.step.complete" & {
+    readonly __schema: true;
+};
+/** Schema type for StepComplete payloads. */
+export type StepCompleteSchema = typeof StepCompleteSchema;
+export interface StepCompleteFields extends FromFields {
+    block: number;
+    hash: Hash;
+    size: number;
+    stakeBlock: number;
+}
+/** StepComplete type. */
+export type StepComplete = Payload<StepCompleteFields, StepCompleteSchema>;
+/** Type guard that checks if a value is a valid StepComplete. */
+export declare const isStepComplete: (x?: unknown) => x is StepComplete;
+/** Converts a value to StepComplete, throwing if invalid. */
+export declare const asStepComplete: import("@ariestools/sdk").AsTypeFunction<StepComplete>;
+//# sourceMappingURL=StepComplete.d.ts.map

package/dist/neutral/modules/protocol-model/payload/elevatable/StepComplete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StepComplete.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-model/payload/elevatable/StepComplete.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAE3C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAG/C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAEjD,mDAAmD;AACnD,eAAO,MAAM,kBAAkB;;CAAoD,CAAA;AACnF,6CAA6C;AAC7C,MAAM,MAAM,kBAAkB,GAAG,OAAO,kBAAkB,CAAA;AAK1D,MAAM,WAAW,kBAAmB,SAAQ,UAAU;IACpD,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,IAAI,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,MAAM,CAAA;CACnB;AAGD,yBAAyB;AACzB,MAAM,MAAM,YAAY,GAAG,OAAO,CAAC,kBAAkB,EAAE,kBAAkB,CAAC,CAAA;AAE1E,iEAAiE;AACjE,eAAO,MAAM,cAAc,oCAA0D,CAAA;AAErF,6DAA6D;AAC7D,eAAO,MAAM,cAAc,wDAAyC,CAAA"}

package/dist/neutral/modules/protocol-model/payload/elevatable/Time.d.ts

@@ -0,0 +1,71 @@
+import { z } from 'zod/mini';
+/** Supported time domains: xl1 block number, epoch timestamp, or ethereum block number. */
+export type TimeDomain = 'xl1' | 'epoch' | 'ethereum';
+/** Schema identifier for time payloads. */
+export declare const TimeSchema: "network.xyo.time" & {
+    readonly __schema: true;
+};
+/** Schema type for Time payloads. */
+export type TimeSchema = typeof TimeSchema;
+/** Zod schema for XL1 time fields including block number and hash. */
+export declare const XL1TimeFieldsZod: z.ZodMiniObject<{
+    xl1: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    xl1Hash: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+}, z.core.$strip>;
+/** Zod schema for Ethereum time fields including block number and hash. */
+export declare const EthereumTimeFieldsZod: z.ZodMiniObject<{
+    ethereum: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    ethereumHash: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+}, z.core.$strip>;
+/** Zod schema for epoch time fields in milliseconds. */
+export declare const EpochTimeFieldsZod: z.ZodMiniObject<{
+    epoch: z.ZodMiniNumber<number>;
+}, z.core.$strip>;
+/** Combined Zod schema for all time fields across XL1, Ethereum, and epoch domains. */
+export declare const TimeFieldsZod: z.ZodMiniObject<{
+    xl1: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    xl1Hash: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+    ethereum: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    ethereumHash: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+    epoch: z.ZodMiniNumber<number>;
+}, z.core.$strip>;
+/** Zod schema for a complete time payload including schema and all time fields. */
+export declare const TimePayloadZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<"network.xyo.time" & {
+        readonly __schema: true;
+    }>;
+    xl1: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    xl1Hash: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+    ethereum: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    ethereumHash: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+    epoch: z.ZodMiniNumber<number>;
+}, z.core.$strip>;
+/** A payload containing time information across multiple domains. */
+export type TimePayload = z.infer<typeof TimePayloadZod>;
+/** Checks whether a value is a safe epoch timestamp (less than double the current time). */
+export declare const isSafeEpoch: (value: unknown) => value is number;
+/** Type guard that checks whether a value is a valid TimePayload with a safe epoch. */
+export declare const isTimePayload: (value: unknown) => value is TimePayload;
+/** Casts a value to TimePayload or returns undefined if it does not match. */
+export declare const asTimePayload: import("@ariestools/sdk").AsTypeFunction<{
+    schema: "network.xyo.time" & {
+        readonly __schema: true;
+    };
+    epoch: number;
+    xl1?: number | undefined;
+    xl1Hash?: import("@ariestools/sdk").BrandedHash | undefined;
+    ethereum?: number | undefined;
+    ethereumHash?: import("@ariestools/sdk").BrandedHash | undefined;
+}>;
+/** Casts a value to TimePayload with storage metadata or returns undefined. */
+export declare const asTimePayloadWithStorageMeta: import("@ariestools/sdk").AsTypeFunction<{
+    schema: "network.xyo.time" & {
+        readonly __schema: true;
+    };
+    epoch: number;
+    xl1?: number | undefined;
+    xl1Hash?: import("@ariestools/sdk").BrandedHash | undefined;
+    ethereum?: number | undefined;
+    ethereumHash?: import("@ariestools/sdk").BrandedHash | undefined;
+}>;
+//# sourceMappingURL=Time.d.ts.map

package/dist/neutral/modules/protocol-model/payload/elevatable/Time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Time.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-model/payload/elevatable/Time.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAG5B,2FAA2F;AAC3F,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,OAAO,GAAG,UAAU,CAAA;AAErD,2CAA2C;AAC3C,eAAO,MAAM,UAAU;;CAAqC,CAAA;AAC5D,qCAAqC;AACrC,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAA;AAE1C,sEAAsE;AACtE,eAAO,MAAM,gBAAgB;;;iBAK3B,CAAA;AAEF,2EAA2E;AAC3E,eAAO,MAAM,qBAAqB;;;iBAKhC,CAAA;AAEF,wDAAwD;AACxD,eAAO,MAAM,kBAAkB;;iBAG7B,CAAA;AAEF,uFAAuF;AACvF,eAAO,MAAM,aAAa;;;;;;iBAGzB,CAAA;AAED,mFAAmF;AACnF,eAAO,MAAM,cAAc;;;;;;;;;iBAAgE,CAAA;AAE3F,qEAAqE;AACrE,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAGxD,4FAA4F;AAC5F,eAAO,MAAM,WAAW,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,MAErD,CAAA;AAED,uFAAuF;AACvF,eAAO,MAAM,aAAa,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,WAEvD,CAAA;AAED,8EAA8E;AAC9E,eAAO,MAAM,aAAa;;;;;;;;;EAAwC,CAAA;AAClE,+EAA+E;AAC/E,eAAO,MAAM,4BAA4B;;;;;;;;;EAAwC,CAAA"}

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

@@ -0,0 +1,7 @@
+export * from './Bridge/index.js';
+export * from './ChainStakeIntent.js';
+export * from './Executable.js';
+export * from './Hash.js';
+export * from './StepComplete.js';
+export * from './Time.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-model/payload/elevatable/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA;AACjC,cAAc,uBAAuB,CAAA;AACrC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,WAAW,CAAA;AACzB,cAAc,mBAAmB,CAAA;AACjC,cAAc,WAAW,CAAA"}

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

@@ -0,0 +1,4 @@
+export * from './application/index.js';
+export * from './elevatable/index.js';
+export * from './StepIdentityPayload.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/payload/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAA;AACtC,cAAc,uBAAuB,CAAA;AACrC,cAAc,0BAA0B,CAAA"}

package/dist/neutral/modules/protocol-model/provider/Provider.d.ts

@@ -0,0 +1,6 @@
+import type { ProviderMoniker } from './ProviderMoniker.js';
+/** Provider interface. */
+export interface Provider<T extends ProviderMoniker> {
+    moniker: T;
+}
+//# sourceMappingURL=Provider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Provider.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/provider/Provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAE3D,0BAA0B;AAC1B,MAAM,WAAW,QAAQ,CAAC,CAAC,SAAS,eAAe;IACjD,OAAO,EAAE,CAAC,CAAA;CACX"}

package/dist/neutral/modules/protocol-model/provider/ProviderMoniker.d.ts

@@ -0,0 +1,9 @@
+/** Type literal for the Provider provider moniker. */
+export type ProviderMoniker = string;
+/** Moniker identifier for the asProvider provider. */
+export declare const asProviderMoniker: <T>(value: T) => string;
+/** Moniker identifier for the DefaultProvider provider. */
+export declare const DefaultProviderMoniker: "Provider";
+/** Type literal for the DefaultProvider provider moniker. */
+export type DefaultProviderMoniker = typeof DefaultProviderMoniker;
+//# sourceMappingURL=ProviderMoniker.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ProviderMoniker.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/provider/ProviderMoniker.ts"],"names":[],"mappings":"AAEA,sDAAsD;AACtD,MAAM,MAAM,eAAe,GAAG,MAAM,CAAA;AAEpC,sDAAsD;AACtD,eAAO,MAAM,iBAAiB,GAAI,CAAC,EAAE,OAAO,CAAC,WAG5C,CAAA;AAED,2DAA2D;AAC3D,eAAO,MAAM,sBAAsB,EAAG,UAAmB,CAAA;AACzD,6DAA6D;AAC7D,MAAM,MAAM,sBAAsB,GAAG,OAAO,sBAAsB,CAAA"}

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

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

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

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

package/dist/neutral/modules/protocol-model/rejection/BlockRejectionPayload.d.ts

@@ -0,0 +1,169 @@
+import { z } from 'zod/mini';
+/** Schema identifier for block rejection payloads. */
+export declare const BlockRejectionSchema: "network.xyo.block.rejection" & {
+    readonly __schema: true;
+};
+/** The literal type of the block rejection schema string. */
+export type BlockRejectionSchema = typeof BlockRejectionSchema;
+/** Zod schema for the fields specific to a block rejection payload. */
+export declare const BlockRejectionFieldsZod: z.ZodMiniObject<{
+    block: z.ZodMiniTuple<readonly [z.ZodMiniObject<{
+        $epoch: z.ZodMiniNumber<number>;
+        block: import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import('../index.js').XL1BlockNumber, number>>;
+        chain: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@ariestools/sdk").BrandedHex, string>>;
+        previous: z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+        protocol: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+        step_hashes: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>>;
+        schema: z.ZodMiniLiteral<"network.xyo.boundwitness" & {
+            readonly __schema: true;
+        }>;
+        addresses: z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xyo-network/sdk").XyoQuantAddress, string>>]>>;
+        payload_hashes: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+        payload_schemas: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xyo-network/sdk").BrandedSchema<string>, string>>>;
+        previous_hashes: z.ZodMiniArray<z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>>;
+        $destination: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xyo-network/sdk").XyoQuantAddress, string>>]>>;
+        $sourceQuery: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+        $signatures: z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>, z.ZodMiniNull]>>;
+    }, z.core.$strip>, z.ZodMiniArray<z.ZodMiniObject<{
+        schema: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xyo-network/sdk").BrandedSchema<string>, string>>;
+    }, z.core.$strict>>], null>;
+    errors: z.ZodMiniArray<import("zod").ZodObject<{
+        hash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+        message: import("zod").ZodOptional<import("zod").ZodString>;
+        name: import("zod").ZodString;
+    }, z.core.$loose>>;
+    rejector: z.ZodMiniString<string>;
+}, z.core.$strip>;
+/** Zod schema for a complete block rejection payload. */
+export declare const BlockRejectionZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<"network.xyo.block.rejection" & {
+        readonly __schema: true;
+    }>;
+    block: z.ZodMiniTuple<readonly [z.ZodMiniObject<{
+        $epoch: z.ZodMiniNumber<number>;
+        block: import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import('../index.js').XL1BlockNumber, number>>;
+        chain: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@ariestools/sdk").BrandedHex, string>>;
+        previous: z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+        protocol: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+        step_hashes: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>>;
+        schema: z.ZodMiniLiteral<"network.xyo.boundwitness" & {
+            readonly __schema: true;
+        }>;
+        addresses: z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xyo-network/sdk").XyoQuantAddress, string>>]>>;
+        payload_hashes: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+        payload_schemas: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xyo-network/sdk").BrandedSchema<string>, string>>>;
+        previous_hashes: z.ZodMiniArray<z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>>;
+        $destination: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xyo-network/sdk").XyoQuantAddress, string>>]>>;
+        $sourceQuery: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+        $signatures: z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>, z.ZodMiniNull]>>;
+    }, z.core.$strip>, z.ZodMiniArray<z.ZodMiniObject<{
+        schema: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xyo-network/sdk").BrandedSchema<string>, string>>;
+    }, z.core.$strict>>], null>;
+    errors: z.ZodMiniArray<import("zod").ZodObject<{
+        hash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+        message: import("zod").ZodOptional<import("zod").ZodString>;
+        name: import("zod").ZodString;
+    }, z.core.$loose>>;
+    rejector: z.ZodMiniString<string>;
+}, z.core.$strip>;
+/** A block rejection payload representing a rejected block with reasons. */
+export type BlockRejection = z.infer<typeof BlockRejectionZod>;
+/** Type guard that checks if a value is a BlockRejection payload. */
+export declare const isBlockRejection: (x?: unknown) => x is {
+    schema: "network.xyo.block.rejection" & {
+        readonly __schema: true;
+    };
+    block: [{
+        $epoch: number;
+        block: import('../index.js').XL1BlockNumber;
+        chain: import("@ariestools/sdk").BrandedHex;
+        previous: import("@ariestools/sdk").BrandedHash | null;
+        schema: "network.xyo.boundwitness" & {
+            readonly __schema: true;
+        };
+        addresses: (import("@xyo-network/sdk").XyoQuantAddress | (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }))[];
+        payload_hashes: import("@ariestools/sdk").BrandedHash[];
+        payload_schemas: import("@xyo-network/sdk").BrandedSchema<string>[];
+        previous_hashes: (import("@ariestools/sdk").BrandedHash | null)[];
+        $signatures: (import("@ariestools/sdk").BrandedHex | null)[];
+        protocol?: number | undefined;
+        step_hashes?: import("@ariestools/sdk").BrandedHash[] | undefined;
+        $destination?: import("@xyo-network/sdk").XyoQuantAddress | (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | undefined;
+        $sourceQuery?: import("@ariestools/sdk").BrandedHash | undefined;
+    }, {
+        schema: import("@xyo-network/sdk").BrandedSchema<string>;
+    }[]];
+    errors: {
+        [x: string]: unknown;
+        hash: import("@ariestools/sdk").BrandedHash;
+        name: string;
+        message?: string | undefined;
+    }[];
+    rejector: string;
+};
+/** Casts a value to BlockRejection or returns undefined if invalid. */
+export declare const asBlockRejection: import("@ariestools/sdk").AsTypeFunction<{
+    schema: "network.xyo.block.rejection" & {
+        readonly __schema: true;
+    };
+    block: [{
+        $epoch: number;
+        block: import('../index.js').XL1BlockNumber;
+        chain: import("@ariestools/sdk").BrandedHex;
+        previous: import("@ariestools/sdk").BrandedHash | null;
+        schema: "network.xyo.boundwitness" & {
+            readonly __schema: true;
+        };
+        addresses: (import("@xyo-network/sdk").XyoQuantAddress | (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }))[];
+        payload_hashes: import("@ariestools/sdk").BrandedHash[];
+        payload_schemas: import("@xyo-network/sdk").BrandedSchema<string>[];
+        previous_hashes: (import("@ariestools/sdk").BrandedHash | null)[];
+        $signatures: (import("@ariestools/sdk").BrandedHex | null)[];
+        protocol?: number | undefined;
+        step_hashes?: import("@ariestools/sdk").BrandedHash[] | undefined;
+        $destination?: import("@xyo-network/sdk").XyoQuantAddress | (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | undefined;
+        $sourceQuery?: import("@ariestools/sdk").BrandedHash | undefined;
+    }, {
+        schema: import("@xyo-network/sdk").BrandedSchema<string>;
+    }[]];
+    errors: {
+        [x: string]: unknown;
+        hash: import("@ariestools/sdk").BrandedHash;
+        name: string;
+        message?: string | undefined;
+    }[];
+    rejector: string;
+}>;
+//# sourceMappingURL=BlockRejectionPayload.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BlockRejectionPayload.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/rejection/BlockRejectionPayload.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAK5B,sDAAsD;AACtD,eAAO,MAAM,oBAAoB;;CAAgD,CAAA;AACjF,6DAA6D;AAC7D,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAA;AAE9D,uEAAuE;AACvE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIlC,CAAA;AAEF,yDAAyD;AACzD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAG7B,CAAA;AAED,4EAA4E;AAC5E,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE9D,qEAAqE;AACrE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA8D,CAAA;AAE3F,uEAAuE;AACvE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA2C,CAAA"}

package/dist/neutral/modules/protocol-model/rejection/RejectionError.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+/** Zod schema for a rejection error reason (slimmed from ValidationErrorZod, omitting value). */
+export declare const RejectionErrorZod: z.ZodObject<{
+    hash: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+    message: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+}, z.core.$loose>;
+/** A single rejection error reason. */
+export type RejectionError = z.infer<typeof RejectionErrorZod>;
+//# sourceMappingURL=RejectionError.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RejectionError.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/rejection/RejectionError.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,iGAAiG;AACjG,eAAO,MAAM,iBAAiB;;;;iBAIpB,CAAA;AAEV,uCAAuC;AACvC,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA"}

package/dist/neutral/modules/protocol-model/rejection/TransactionRejectionPayload.d.ts

@@ -0,0 +1,205 @@
+import { z } from 'zod/mini';
+/** Schema identifier for transaction rejection payloads. */
+export declare const TransactionRejectionSchema: "network.xyo.transaction.rejection" & {
+    readonly __schema: true;
+};
+/** The literal type of the transaction rejection schema string. */
+export type TransactionRejectionSchema = typeof TransactionRejectionSchema;
+/** Zod schema for the fields specific to a transaction rejection payload. */
+export declare const TransactionRejectionFieldsZod: z.ZodMiniObject<{
+    errors: z.ZodMiniArray<import("zod").ZodObject<{
+        hash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+        message: import("zod").ZodOptional<import("zod").ZodString>;
+        name: import("zod").ZodString;
+    }, z.core.$loose>>;
+    rejector: z.ZodMiniString<string>;
+    transaction: z.ZodMiniTuple<readonly [z.ZodMiniObject<{
+        schema: z.ZodMiniLiteral<"network.xyo.boundwitness" & {
+            readonly __schema: true;
+        }>;
+        addresses: z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xyo-network/sdk").XyoQuantAddress, string>>]>>;
+        payload_hashes: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+        payload_schemas: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xyo-network/sdk").BrandedSchema<string>, string>>>;
+        previous_hashes: z.ZodMiniArray<z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>>;
+        $destination: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xyo-network/sdk").XyoQuantAddress, string>>]>>;
+        $sourceQuery: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+        $signatures: z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>, z.ZodMiniNull]>>;
+        nbf: import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import('../index.js').XL1BlockNumber, number>>;
+        exp: import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import('../index.js').XL1BlockNumber, number>>;
+        fees: 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>;
+        chain: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@ariestools/sdk").BrandedHex, string>>;
+        from: z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xyo-network/sdk").XyoQuantAddress, string>>]>;
+        script: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
+    }, z.core.$strip>, z.ZodMiniArray<z.ZodMiniObject<{
+        schema: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xyo-network/sdk").BrandedSchema<string>, string>>;
+    }, z.core.$strict>>], null>;
+}, z.core.$strip>;
+/** Zod schema for a complete transaction rejection payload. */
+export declare const TransactionRejectionZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<"network.xyo.transaction.rejection" & {
+        readonly __schema: true;
+    }>;
+    errors: z.ZodMiniArray<import("zod").ZodObject<{
+        hash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+        message: import("zod").ZodOptional<import("zod").ZodString>;
+        name: import("zod").ZodString;
+    }, z.core.$loose>>;
+    rejector: z.ZodMiniString<string>;
+    transaction: z.ZodMiniTuple<readonly [z.ZodMiniObject<{
+        schema: z.ZodMiniLiteral<"network.xyo.boundwitness" & {
+            readonly __schema: true;
+        }>;
+        addresses: z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xyo-network/sdk").XyoQuantAddress, string>>]>>;
+        payload_hashes: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+        payload_schemas: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xyo-network/sdk").BrandedSchema<string>, string>>>;
+        previous_hashes: z.ZodMiniArray<z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>>;
+        $destination: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xyo-network/sdk").XyoQuantAddress, string>>]>>;
+        $sourceQuery: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+        $signatures: z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>, z.ZodMiniNull]>>;
+        nbf: import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import('../index.js').XL1BlockNumber, number>>;
+        exp: import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import('../index.js').XL1BlockNumber, number>>;
+        fees: 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>;
+        chain: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@ariestools/sdk").BrandedHex, string>>;
+        from: z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xyo-network/sdk").XyoQuantAddress, string>>]>;
+        script: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
+    }, z.core.$strip>, z.ZodMiniArray<z.ZodMiniObject<{
+        schema: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xyo-network/sdk").BrandedSchema<string>, string>>;
+    }, z.core.$strict>>], null>;
+}, z.core.$strip>;
+/** A transaction rejection payload representing a rejected transaction with reasons. */
+export type TransactionRejection = z.infer<typeof TransactionRejectionZod>;
+/** Type guard that checks if a value is a TransactionRejection payload. */
+export declare const isTransactionRejection: (x?: unknown) => x is {
+    schema: "network.xyo.transaction.rejection" & {
+        readonly __schema: true;
+    };
+    errors: {
+        [x: string]: unknown;
+        hash: import("@ariestools/sdk").BrandedHash;
+        name: string;
+        message?: string | undefined;
+    }[];
+    rejector: string;
+    transaction: [{
+        schema: "network.xyo.boundwitness" & {
+            readonly __schema: true;
+        };
+        addresses: (import("@xyo-network/sdk").XyoQuantAddress | (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }))[];
+        payload_hashes: import("@ariestools/sdk").BrandedHash[];
+        payload_schemas: import("@xyo-network/sdk").BrandedSchema<string>[];
+        previous_hashes: (import("@ariestools/sdk").BrandedHash | null)[];
+        $signatures: (import("@ariestools/sdk").BrandedHex | null)[];
+        nbf: import('../index.js').XL1BlockNumber;
+        exp: import('../index.js').XL1BlockNumber;
+        fees: {
+            base: import("@ariestools/sdk").BrandedHex;
+            gasLimit: import("@ariestools/sdk").BrandedHex;
+            gasPrice: import("@ariestools/sdk").BrandedHex;
+            priority: import("@ariestools/sdk").BrandedHex;
+        };
+        chain: import("@ariestools/sdk").BrandedHex;
+        from: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("@xyo-network/sdk").XyoQuantAddress;
+        $destination?: import("@xyo-network/sdk").XyoQuantAddress | (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | undefined;
+        $sourceQuery?: import("@ariestools/sdk").BrandedHash | undefined;
+        script?: string[] | undefined;
+    }, {
+        schema: import("@xyo-network/sdk").BrandedSchema<string>;
+    }[]];
+};
+/** Casts a value to TransactionRejection or returns undefined if invalid. */
+export declare const asTransactionRejection: import("@ariestools/sdk").AsTypeFunction<{
+    schema: "network.xyo.transaction.rejection" & {
+        readonly __schema: true;
+    };
+    errors: {
+        [x: string]: unknown;
+        hash: import("@ariestools/sdk").BrandedHash;
+        name: string;
+        message?: string | undefined;
+    }[];
+    rejector: string;
+    transaction: [{
+        schema: "network.xyo.boundwitness" & {
+            readonly __schema: true;
+        };
+        addresses: (import("@xyo-network/sdk").XyoQuantAddress | (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }))[];
+        payload_hashes: import("@ariestools/sdk").BrandedHash[];
+        payload_schemas: import("@xyo-network/sdk").BrandedSchema<string>[];
+        previous_hashes: (import("@ariestools/sdk").BrandedHash | null)[];
+        $signatures: (import("@ariestools/sdk").BrandedHex | null)[];
+        nbf: import('../index.js').XL1BlockNumber;
+        exp: import('../index.js').XL1BlockNumber;
+        fees: {
+            base: import("@ariestools/sdk").BrandedHex;
+            gasLimit: import("@ariestools/sdk").BrandedHex;
+            gasPrice: import("@ariestools/sdk").BrandedHex;
+            priority: import("@ariestools/sdk").BrandedHex;
+        };
+        chain: import("@ariestools/sdk").BrandedHex;
+        from: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("@xyo-network/sdk").XyoQuantAddress;
+        $destination?: import("@xyo-network/sdk").XyoQuantAddress | (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | undefined;
+        $sourceQuery?: import("@ariestools/sdk").BrandedHash | undefined;
+        script?: string[] | undefined;
+    }, {
+        schema: import("@xyo-network/sdk").BrandedSchema<string>;
+    }[]];
+}>;
+//# sourceMappingURL=TransactionRejectionPayload.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TransactionRejectionPayload.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/rejection/TransactionRejectionPayload.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAK5B,4DAA4D;AAC5D,eAAO,MAAM,0BAA0B;;CAAsD,CAAA;AAC7F,mEAAmE;AACnE,MAAM,MAAM,0BAA0B,GAAG,OAAO,0BAA0B,CAAA;AAE1E,6EAA6E;AAC7E,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIxC,CAAA;AAEF,+DAA+D;AAC/D,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGnC,CAAA;AAED,wFAAwF;AACxF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAE1E,2EAA2E;AAC3E,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA0E,CAAA;AAE7G,6EAA6E;AAC7E,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAiD,CAAA"}

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

@@ -0,0 +1,4 @@
+export * from './BlockRejectionPayload.js';
+export * from './RejectionError.js';
+export * from './TransactionRejectionPayload.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/rejection/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAA;AAC1C,cAAc,qBAAqB,CAAA;AACnC,cAAc,kCAAkC,CAAA"}