@xyo-network/sdk-protocol 7.0.4

package/dist/_pkg/boundwitness-model/neutral/BoundWitness/BoundWitness.d.ts

@@ -0,0 +1,173 @@
+import * as z from 'zod/mini';
+import type { SignedSignaturesMeta, UnsignedSignaturesMeta } from './Signatures.ts';
+export declare const BoundWitnessRequiredFieldsZod: z.ZodMiniObject<{
+    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("../../../address/neutral/index.ts").XyoQuantAddress, string>>]>>;
+    payload_hashes: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>>;
+    payload_schemas: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("../../../payload-model/neutral/index.ts").BrandedSchema<string>, string>>>;
+    previous_hashes: z.ZodMiniArray<z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>>>;
+}, z.core.$strip>;
+export type BoundWitnessRequiredFields = z.infer<typeof BoundWitnessRequiredFieldsZod>;
+export declare const BoundWitnessMetaZod: z.ZodMiniObject<{
+    $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("../../../address/neutral/index.ts").XyoQuantAddress, string>>]>>;
+    $sourceQuery: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>>;
+    $signatures: z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHex, string>>, z.ZodMiniNull]>>;
+}, z.core.$strip>;
+export type BoundWitnessMeta = z.infer<typeof BoundWitnessMetaZod>;
+export declare const BoundWitnessZod: 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("../../../address/neutral/index.ts").XyoQuantAddress, string>>]>>;
+    payload_hashes: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>>;
+    payload_schemas: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("../../../payload-model/neutral/index.ts").BrandedSchema<string>, string>>>;
+    previous_hashes: z.ZodMiniArray<z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/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("../../../address/neutral/index.ts").XyoQuantAddress, string>>]>>;
+    $sourceQuery: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>>;
+    $signatures: z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHex, string>>, z.ZodMiniNull]>>;
+}, z.core.$strip>;
+export type BoundWitness = z.infer<typeof BoundWitnessZod>;
+export declare const isBoundWitness: <T>(value: T) => value is T & {
+    schema: "network.xyo.boundwitness" & {
+        readonly __schema: true;
+    };
+    addresses: ((Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }) | import("../../../address/neutral/index.ts").XyoQuantAddress)[];
+    payload_hashes: import("@xylabs/sdk").BrandedHash[];
+    payload_schemas: import("../../../payload-model/neutral/index.ts").BrandedSchema<string>[];
+    previous_hashes: (import("@xylabs/sdk").BrandedHash | null)[];
+    $signatures: (import("@xylabs/sdk").BrandedHex | null)[];
+    $destination?: (Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }) | import("../../../address/neutral/index.ts").XyoQuantAddress | undefined;
+    $sourceQuery?: import("@xylabs/sdk").BrandedHash | undefined;
+};
+export declare const asBoundWitness: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.boundwitness" & {
+            readonly __schema: true;
+        };
+        addresses: ((Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("../../../address/neutral/index.ts").XyoQuantAddress)[];
+        payload_hashes: import("@xylabs/sdk").BrandedHash[];
+        payload_schemas: import("../../../payload-model/neutral/index.ts").BrandedSchema<string>[];
+        previous_hashes: (import("@xylabs/sdk").BrandedHash | null)[];
+        $signatures: (import("@xylabs/sdk").BrandedHex | null)[];
+        $destination?: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("../../../address/neutral/index.ts").XyoQuantAddress | undefined;
+        $sourceQuery?: import("@xylabs/sdk").BrandedHash | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.boundwitness" & {
+            readonly __schema: true;
+        };
+        addresses: ((Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("../../../address/neutral/index.ts").XyoQuantAddress)[];
+        payload_hashes: import("@xylabs/sdk").BrandedHash[];
+        payload_schemas: import("../../../payload-model/neutral/index.ts").BrandedSchema<string>[];
+        previous_hashes: (import("@xylabs/sdk").BrandedHash | null)[];
+        $signatures: (import("@xylabs/sdk").BrandedHex | null)[];
+        $destination?: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("../../../address/neutral/index.ts").XyoQuantAddress | undefined;
+        $sourceQuery?: import("@xylabs/sdk").BrandedHash | undefined;
+    };
+};
+export declare const toBoundWitness: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.boundwitness" & {
+            readonly __schema: true;
+        };
+        addresses: ((Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("../../../address/neutral/index.ts").XyoQuantAddress)[];
+        payload_hashes: import("@xylabs/sdk").BrandedHash[];
+        payload_schemas: import("../../../payload-model/neutral/index.ts").BrandedSchema<string>[];
+        previous_hashes: (import("@xylabs/sdk").BrandedHash | null)[];
+        $signatures: (import("@xylabs/sdk").BrandedHex | null)[];
+        $destination?: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("../../../address/neutral/index.ts").XyoQuantAddress | undefined;
+        $sourceQuery?: import("@xylabs/sdk").BrandedHash | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.boundwitness" & {
+            readonly __schema: true;
+        };
+        addresses: ((Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("../../../address/neutral/index.ts").XyoQuantAddress)[];
+        payload_hashes: import("@xylabs/sdk").BrandedHash[];
+        payload_schemas: import("../../../payload-model/neutral/index.ts").BrandedSchema<string>[];
+        previous_hashes: (import("@xylabs/sdk").BrandedHash | null)[];
+        $signatures: (import("@xylabs/sdk").BrandedHex | null)[];
+        $destination?: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("../../../address/neutral/index.ts").XyoQuantAddress | undefined;
+        $sourceQuery?: import("@xylabs/sdk").BrandedHash | undefined;
+    };
+};
+export declare const AnyBoundWitnessZod: 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("../../../address/neutral/index.ts").XyoQuantAddress, string>>]>>;
+    payload_hashes: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>>;
+    payload_schemas: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("../../../payload-model/neutral/index.ts").BrandedSchema<string>, string>>>;
+    previous_hashes: z.ZodMiniArray<z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/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("../../../address/neutral/index.ts").XyoQuantAddress, string>>]>>;
+    $sourceQuery: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>>;
+    $signatures: z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHex, string>>, z.ZodMiniNull]>>;
+}, z.core.$loose>;
+export type AnyBoundWitness = z.infer<typeof AnyBoundWitnessZod>;
+export type Unsigned<T extends BoundWitness> = Omit<T, '$signatures'> & UnsignedSignaturesMeta;
+export type Signed<T extends BoundWitness> = Omit<T, '$signatures'> & SignedSignaturesMeta;
+export type PossiblySigned<T extends BoundWitness> = Unsigned<T> | Signed<T>;
+//# sourceMappingURL=BoundWitness.d.ts.map

package/dist/_pkg/boundwitness-model/neutral/BoundWitness/BoundWitnessJsonSchema.d.ts

@@ -0,0 +1,37 @@
+export declare const BoundWitnessJsonSchema: () => {
+    $id: string;
+    additionalProperties: boolean;
+    properties: {
+        addresses: {
+            items: {
+                type: string;
+            };
+            type: string;
+        };
+        payload_hashes: {
+            items: {
+                type: string;
+            };
+            type: string;
+        };
+        payload_schemas: {
+            items: {
+                type: string;
+            };
+            type: string;
+        };
+        previous_hashes: {
+            items: {
+                nullable: boolean;
+                type: string;
+            };
+            type: string;
+        };
+        schema: {
+            type: string;
+        };
+    };
+    required: string[];
+    type: string;
+};
+//# sourceMappingURL=BoundWitnessJsonSchema.d.ts.map

package/dist/_pkg/boundwitness-model/neutral/BoundWitness/BoundWitnessSchema.d.ts

@@ -0,0 +1,5 @@
+export declare const BoundWitnessSchema: "network.xyo.boundwitness" & {
+    readonly __schema: true;
+};
+export type BoundWitnessSchema = typeof BoundWitnessSchema;
+//# sourceMappingURL=BoundWitnessSchema.d.ts.map

package/dist/_pkg/boundwitness-model/neutral/BoundWitness/HydratedBoundWitness.d.ts

@@ -0,0 +1,72 @@
+import * as z from 'zod/mini';
+import { type BoundWitness } from './BoundWitness.ts';
+export declare function HydratedBoundWitnessZodBuilder<T extends z.core.$ZodType<BoundWitness>>(bwZod: T): z.ZodMiniTuple<readonly [T, z.ZodMiniArray<z.ZodMiniObject<{
+    schema: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("../../../payload-model/neutral/index.ts").BrandedSchema<string>, string>>;
+}, z.core.$loose>>], null>;
+export declare const HydratedBoundWitnessZod: 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("../../../address/neutral/index.ts").XyoQuantAddress, string>>]>>;
+    payload_hashes: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>>;
+    payload_schemas: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("../../../payload-model/neutral/index.ts").BrandedSchema<string>, string>>>;
+    previous_hashes: z.ZodMiniArray<z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/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("../../../address/neutral/index.ts").XyoQuantAddress, string>>]>>;
+    $sourceQuery: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>>;
+    $signatures: z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHex, string>>, z.ZodMiniNull]>>;
+}, z.core.$strip>, z.ZodMiniArray<z.ZodMiniObject<{
+    schema: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("../../../payload-model/neutral/index.ts").BrandedSchema<string>, string>>;
+}, z.core.$loose>>], null>;
+export declare const SignedHydratedBoundWitnessZod: 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("../../../address/neutral/index.ts").XyoQuantAddress, string>>]>>;
+    payload_hashes: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>>;
+    payload_schemas: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("../../../payload-model/neutral/index.ts").BrandedSchema<string>, string>>>;
+    previous_hashes: z.ZodMiniArray<z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/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("../../../address/neutral/index.ts").XyoQuantAddress, string>>]>>;
+    $sourceQuery: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>>;
+    $signatures: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHex, string>>>;
+}, z.core.$strip>, z.ZodMiniArray<z.ZodMiniObject<{
+    schema: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("../../../payload-model/neutral/index.ts").BrandedSchema<string>, string>>;
+}, z.core.$loose>>], null>;
+export declare const UnsignedHydratedBoundWitnessZod: 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("../../../address/neutral/index.ts").XyoQuantAddress, string>>]>>;
+    payload_hashes: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>>;
+    payload_schemas: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("../../../payload-model/neutral/index.ts").BrandedSchema<string>, string>>>;
+    previous_hashes: z.ZodMiniArray<z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/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("../../../address/neutral/index.ts").XyoQuantAddress, string>>]>>;
+    $sourceQuery: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>>;
+    $signatures: z.ZodMiniArray<z.ZodMiniNull>;
+}, z.core.$strip>, z.ZodMiniArray<z.ZodMiniObject<{
+    schema: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("../../../payload-model/neutral/index.ts").BrandedSchema<string>, string>>;
+}, z.core.$loose>>], null>;
+//# sourceMappingURL=HydratedBoundWitness.d.ts.map

package/dist/_pkg/boundwitness-model/neutral/BoundWitness/Signatures.d.ts

@@ -0,0 +1,14 @@
+import * as z from 'zod/mini';
+export declare const SignaturesMetaZod: z.ZodMiniObject<{
+    $signatures: z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHex, string>>, z.ZodMiniNull]>>;
+}, z.core.$strip>;
+export declare const UnsignedSignaturesMetaZod: z.ZodMiniObject<{
+    $signatures: z.ZodMiniArray<z.ZodMiniNull>;
+}, z.core.$strip>;
+export declare const SignedSignaturesMetaZod: z.ZodMiniObject<{
+    $signatures: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHex, string>>>;
+}, z.core.$strip>;
+export type SignaturesMeta = z.infer<typeof SignaturesMetaZod>;
+export type UnsignedSignaturesMeta = z.infer<typeof UnsignedSignaturesMetaZod>;
+export type SignedSignaturesMeta = z.infer<typeof SignedSignaturesMetaZod>;
+//# sourceMappingURL=Signatures.d.ts.map

package/dist/_pkg/boundwitness-model/neutral/BoundWitness/SignedBoundWitness.d.ts

@@ -0,0 +1,44 @@
+import * as z from 'zod/mini';
+export declare const SignedBoundWitnessZod: 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("../../../address/neutral/index.ts").XyoQuantAddress, string>>]>>;
+    payload_hashes: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>>;
+    payload_schemas: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("../../../payload-model/neutral/index.ts").BrandedSchema<string>, string>>>;
+    previous_hashes: z.ZodMiniArray<z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/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("../../../address/neutral/index.ts").XyoQuantAddress, string>>]>>;
+    $sourceQuery: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>>;
+    $signatures: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHex, string>>>;
+}, z.core.$strip>;
+export type SignedBoundWitness = z.infer<typeof SignedBoundWitnessZod>;
+export declare const AnySignedBoundWitnessZod: 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("../../../address/neutral/index.ts").XyoQuantAddress, string>>]>>;
+    payload_hashes: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>>;
+    payload_schemas: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("../../../payload-model/neutral/index.ts").BrandedSchema<string>, string>>>;
+    previous_hashes: z.ZodMiniArray<z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/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("../../../address/neutral/index.ts").XyoQuantAddress, string>>]>>;
+    $sourceQuery: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>>;
+    $signatures: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHex, string>>>;
+}, z.core.$loose>;
+export type AnySignedBoundWitness = z.infer<typeof AnySignedBoundWitnessZod>;
+//# sourceMappingURL=SignedBoundWitness.d.ts.map

package/dist/_pkg/boundwitness-model/neutral/BoundWitness/UnsignedBoundWitness.d.ts

@@ -0,0 +1,44 @@
+import * as z from 'zod/mini';
+export declare const UnsignedBoundWitnessZod: 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("../../../address/neutral/index.ts").XyoQuantAddress, string>>]>>;
+    payload_hashes: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>>;
+    payload_schemas: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("../../../payload-model/neutral/index.ts").BrandedSchema<string>, string>>>;
+    previous_hashes: z.ZodMiniArray<z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/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("../../../address/neutral/index.ts").XyoQuantAddress, string>>]>>;
+    $sourceQuery: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>>;
+    $signatures: z.ZodMiniArray<z.ZodMiniNull>;
+}, z.core.$strip>;
+export type UnsignedBoundWitness = z.infer<typeof UnsignedBoundWitnessZod>;
+export declare const AnyUnsignedBoundWitnessZod: 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("../../../address/neutral/index.ts").XyoQuantAddress, string>>]>>;
+    payload_hashes: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>>;
+    payload_schemas: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("../../../payload-model/neutral/index.ts").BrandedSchema<string>, string>>>;
+    previous_hashes: z.ZodMiniArray<z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/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("../../../address/neutral/index.ts").XyoQuantAddress, string>>]>>;
+    $sourceQuery: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>>;
+    $signatures: z.ZodMiniArray<z.ZodMiniNull>;
+}, z.core.$loose>;
+export type AnyUnsignedBoundWitness = z.infer<typeof AnyUnsignedBoundWitnessZod>;
+//# sourceMappingURL=UnsignedBoundWitness.d.ts.map

package/dist/_pkg/boundwitness-model/neutral/BoundWitness/index.d.ts

@@ -0,0 +1,8 @@
+export * from './BoundWitness.ts';
+export * from './BoundWitnessJsonSchema.ts';
+export * from './BoundWitnessSchema.ts';
+export * from './HydratedBoundWitness.ts';
+export * from './Signatures.ts';
+export * from './SignedBoundWitness.ts';
+export * from './UnsignedBoundWitness.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/_pkg/boundwitness-model/neutral/QueryBoundWitness.d.ts

@@ -0,0 +1,150 @@
+import type { WithStorageMeta } from '../../payload-model/neutral/index.ts';
+import * as z from 'zod/mini';
+export declare const QueryBoundWitnessFieldsZod: z.ZodMiniObject<{
+    error_hashes: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>>>;
+    query: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>;
+}, z.core.$strip>;
+export type QueryBoundWitnessFields = z.infer<typeof QueryBoundWitnessFieldsZod>;
+export declare const QueryBoundWitnessZod: 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("../../address/neutral/index.ts").XyoQuantAddress, string>>]>>;
+    payload_hashes: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>>;
+    payload_schemas: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("../../payload-model/neutral/index.ts").BrandedSchema<string>, string>>>;
+    previous_hashes: z.ZodMiniArray<z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/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("../../address/neutral/index.ts").XyoQuantAddress, string>>]>>;
+    $sourceQuery: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>>;
+    $signatures: z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHex, string>>, z.ZodMiniNull]>>;
+    error_hashes: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>>>;
+    query: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>;
+}, z.core.$strip>;
+export type QueryBoundWitness = z.infer<typeof QueryBoundWitnessZod>;
+/**
+ * @deprecated Use `QueryBoundWitness` instead
+ */
+export type UnsignedQueryBoundWitness = QueryBoundWitness;
+export declare const isQueryBoundWitness: <T>(value: T) => value is T & {
+    schema: "network.xyo.boundwitness" & {
+        readonly __schema: true;
+    };
+    addresses: ((Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }) | import("../../address/neutral/index.ts").XyoQuantAddress)[];
+    payload_hashes: import("@xylabs/sdk").BrandedHash[];
+    payload_schemas: import("../../payload-model/neutral/index.ts").BrandedSchema<string>[];
+    previous_hashes: (import("@xylabs/sdk").BrandedHash | null)[];
+    $signatures: (import("@xylabs/sdk").BrandedHex | null)[];
+    query: import("@xylabs/sdk").BrandedHash;
+    $destination?: (Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }) | import("../../address/neutral/index.ts").XyoQuantAddress | undefined;
+    $sourceQuery?: import("@xylabs/sdk").BrandedHash | undefined;
+    error_hashes?: import("@xylabs/sdk").BrandedHash[] | undefined;
+};
+export declare const asQueryBoundWitness: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.boundwitness" & {
+            readonly __schema: true;
+        };
+        addresses: ((Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("../../address/neutral/index.ts").XyoQuantAddress)[];
+        payload_hashes: import("@xylabs/sdk").BrandedHash[];
+        payload_schemas: import("../../payload-model/neutral/index.ts").BrandedSchema<string>[];
+        previous_hashes: (import("@xylabs/sdk").BrandedHash | null)[];
+        $signatures: (import("@xylabs/sdk").BrandedHex | null)[];
+        query: import("@xylabs/sdk").BrandedHash;
+        $destination?: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("../../address/neutral/index.ts").XyoQuantAddress | undefined;
+        $sourceQuery?: import("@xylabs/sdk").BrandedHash | undefined;
+        error_hashes?: import("@xylabs/sdk").BrandedHash[] | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.boundwitness" & {
+            readonly __schema: true;
+        };
+        addresses: ((Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("../../address/neutral/index.ts").XyoQuantAddress)[];
+        payload_hashes: import("@xylabs/sdk").BrandedHash[];
+        payload_schemas: import("../../payload-model/neutral/index.ts").BrandedSchema<string>[];
+        previous_hashes: (import("@xylabs/sdk").BrandedHash | null)[];
+        $signatures: (import("@xylabs/sdk").BrandedHex | null)[];
+        query: import("@xylabs/sdk").BrandedHash;
+        $destination?: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("../../address/neutral/index.ts").XyoQuantAddress | undefined;
+        $sourceQuery?: import("@xylabs/sdk").BrandedHash | undefined;
+        error_hashes?: import("@xylabs/sdk").BrandedHash[] | undefined;
+    };
+};
+export declare const toQueryBoundWitness: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.boundwitness" & {
+            readonly __schema: true;
+        };
+        addresses: ((Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("../../address/neutral/index.ts").XyoQuantAddress)[];
+        payload_hashes: import("@xylabs/sdk").BrandedHash[];
+        payload_schemas: import("../../payload-model/neutral/index.ts").BrandedSchema<string>[];
+        previous_hashes: (import("@xylabs/sdk").BrandedHash | null)[];
+        $signatures: (import("@xylabs/sdk").BrandedHex | null)[];
+        query: import("@xylabs/sdk").BrandedHash;
+        $destination?: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("../../address/neutral/index.ts").XyoQuantAddress | undefined;
+        $sourceQuery?: import("@xylabs/sdk").BrandedHash | undefined;
+        error_hashes?: import("@xylabs/sdk").BrandedHash[] | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.boundwitness" & {
+            readonly __schema: true;
+        };
+        addresses: ((Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("../../address/neutral/index.ts").XyoQuantAddress)[];
+        payload_hashes: import("@xylabs/sdk").BrandedHash[];
+        payload_schemas: import("../../payload-model/neutral/index.ts").BrandedSchema<string>[];
+        previous_hashes: (import("@xylabs/sdk").BrandedHash | null)[];
+        $signatures: (import("@xylabs/sdk").BrandedHex | null)[];
+        query: import("@xylabs/sdk").BrandedHash;
+        $destination?: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("../../address/neutral/index.ts").XyoQuantAddress | undefined;
+        $sourceQuery?: import("@xylabs/sdk").BrandedHash | undefined;
+        error_hashes?: import("@xylabs/sdk").BrandedHash[] | undefined;
+    };
+};
+export declare const isQueryBoundWitnessWithStorageMeta: (x?: unknown) => x is WithStorageMeta<QueryBoundWitness>;
+//# sourceMappingURL=QueryBoundWitness.d.ts.map

package/dist/_pkg/boundwitness-model/neutral/index.d.ts

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