@xyo-network/sdk 2.102.4 → 7.0.3

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,2 @@
+export * from './BoundWitness/index.ts';
+export * from './QueryBoundWitness.ts';

package/dist/_pkg/boundwitness-model/neutral/index.mjs

@@ -0,0 +1,130 @@
+// src/BoundWitness/BoundWitness.ts
+import {
+  HashZod,
+  zodAsFactory,
+  zodIsFactory,
+  zodToFactory
+} from "@xylabs/sdk";
+import { XyoAddressZod } from "../../address/neutral/index.mjs";
+import { PayloadZod, SchemaZod } from "../../payload-model/neutral/index.mjs";
+import * as z2 from "zod/mini";
+
+// src/BoundWitness/BoundWitnessSchema.ts
+import { asSchema } from "../../payload-model/neutral/index.mjs";
+var BoundWitnessSchema = asSchema("network.xyo.boundwitness", true);
+
+// src/BoundWitness/Signatures.ts
+import { HexZod } from "@xylabs/sdk";
+import * as z from "zod/mini";
+var signatureOrNullZod = z.union([HexZod, z.null()]);
+var SignaturesMetaZod = z.object({ $signatures: z.array(signatureOrNullZod) });
+var UnsignedSignaturesMetaZod = z.object({ $signatures: z.array(z.null()) });
+var SignedSignaturesMetaZod = z.object({ $signatures: z.array(HexZod).check(z.minLength(1)) });
+
+// src/BoundWitness/BoundWitness.ts
+var BoundWitnessRequiredFieldsZod = z2.object({
+  addresses: z2.array(XyoAddressZod),
+  payload_hashes: z2.array(HashZod),
+  payload_schemas: z2.array(SchemaZod),
+  previous_hashes: z2.array(z2.nullable(HashZod))
+});
+var BoundWitnessMetaZod = z2.extend(
+  z2.object({
+    $destination: z2.optional(XyoAddressZod),
+    $sourceQuery: z2.optional(HashZod)
+  }),
+  SignaturesMetaZod.shape
+);
+var BoundWitnessPayloadZod = z2.safeExtend(PayloadZod, { schema: z2.literal(BoundWitnessSchema) });
+var BoundWitnessWithRequiredZod = z2.safeExtend(BoundWitnessPayloadZod, BoundWitnessRequiredFieldsZod.shape);
+var BoundWitnessZod = z2.safeExtend(BoundWitnessWithRequiredZod, BoundWitnessMetaZod.shape);
+var isBoundWitness = zodIsFactory(BoundWitnessZod);
+var asBoundWitness = zodAsFactory(BoundWitnessZod, "asBoundWitness");
+var toBoundWitness = zodToFactory(BoundWitnessZod, "toBoundWitness");
+var AnyBoundWitnessZod = z2.looseObject(BoundWitnessZod.shape);
+
+// src/BoundWitness/BoundWitnessJsonSchema.ts
+var BoundWitnessJsonSchema = () => {
+  return {
+    $id: "https://schemas.xyo.network/2.0/boundwitness",
+    additionalProperties: false,
+    properties: {
+      addresses: { items: { type: "string" }, type: "array" },
+      payload_hashes: { items: { type: "string" }, type: "array" },
+      payload_schemas: { items: { type: "string" }, type: "array" },
+      previous_hashes: { items: { nullable: true, type: "string" }, type: "array" },
+      schema: { type: "string" }
+    },
+    required: ["addresses", "payload_hashes", "payload_schemas", "previous_hashes", "schema"],
+    type: "object"
+  };
+};
+
+// src/BoundWitness/HydratedBoundWitness.ts
+import { AnyPayloadZod } from "../../payload-model/neutral/index.mjs";
+import * as z5 from "zod/mini";
+
+// src/BoundWitness/SignedBoundWitness.ts
+import * as z3 from "zod/mini";
+var SignedBoundWitnessZod = z3.extend(BoundWitnessZod, SignedSignaturesMetaZod.shape);
+var AnySignedBoundWitnessZod = z3.looseObject(SignedBoundWitnessZod.shape);
+
+// src/BoundWitness/UnsignedBoundWitness.ts
+import * as z4 from "zod/mini";
+var UnsignedBoundWitnessZod = z4.extend(BoundWitnessZod, UnsignedSignaturesMetaZod.shape);
+var AnyUnsignedBoundWitnessZod = z4.looseObject(UnsignedBoundWitnessZod.shape);
+
+// src/BoundWitness/HydratedBoundWitness.ts
+function HydratedBoundWitnessZodBuilder(bwZod) {
+  return z5.tuple([bwZod, z5.array(AnyPayloadZod)]);
+}
+var HydratedBoundWitnessZod = HydratedBoundWitnessZodBuilder(BoundWitnessZod);
+var SignedHydratedBoundWitnessZod = HydratedBoundWitnessZodBuilder(SignedBoundWitnessZod);
+var UnsignedHydratedBoundWitnessZod = HydratedBoundWitnessZodBuilder(UnsignedBoundWitnessZod);
+
+// src/QueryBoundWitness.ts
+import {
+  HashZod as HashZod2,
+  zodAsFactory as zodAsFactory2,
+  zodIsFactory as zodIsFactory2,
+  zodToFactory as zodToFactory2
+} from "@xylabs/sdk";
+import { isStorageMeta } from "../../payload-model/neutral/index.mjs";
+import * as z6 from "zod/mini";
+var QueryBoundWitnessFieldsZod = z6.object({
+  error_hashes: z6.optional(z6.array(HashZod2)),
+  query: HashZod2
+});
+var QueryBoundWitnessZod = z6.safeExtend(BoundWitnessZod, QueryBoundWitnessFieldsZod.shape);
+var isQueryBoundWitness = zodIsFactory2(QueryBoundWitnessZod);
+var asQueryBoundWitness = zodAsFactory2(QueryBoundWitnessZod, "asQueryBoundWitness");
+var toQueryBoundWitness = zodToFactory2(QueryBoundWitnessZod, "toQueryBoundWitness");
+var isQueryBoundWitnessWithStorageMeta = (x) => isQueryBoundWitness(x) && isStorageMeta(x);
+export {
+  AnyBoundWitnessZod,
+  AnySignedBoundWitnessZod,
+  AnyUnsignedBoundWitnessZod,
+  BoundWitnessJsonSchema,
+  BoundWitnessMetaZod,
+  BoundWitnessRequiredFieldsZod,
+  BoundWitnessSchema,
+  BoundWitnessZod,
+  HydratedBoundWitnessZod,
+  HydratedBoundWitnessZodBuilder,
+  QueryBoundWitnessFieldsZod,
+  QueryBoundWitnessZod,
+  SignaturesMetaZod,
+  SignedBoundWitnessZod,
+  SignedHydratedBoundWitnessZod,
+  SignedSignaturesMetaZod,
+  UnsignedBoundWitnessZod,
+  UnsignedHydratedBoundWitnessZod,
+  UnsignedSignaturesMetaZod,
+  asBoundWitness,
+  asQueryBoundWitness,
+  isBoundWitness,
+  isQueryBoundWitness,
+  isQueryBoundWitnessWithStorageMeta,
+  toBoundWitness,
+  toQueryBoundWitness
+};

package/dist/_pkg/boundwitness-validator/neutral/Validator.d.ts

@@ -0,0 +1,16 @@
+import type { BoundWitness } from '../../boundwitness-model/neutral/index.ts';
+import { PayloadValidator } from '../../payload-validator/neutral/index.ts';
+export declare class BoundWitnessValidator<T extends BoundWitness = BoundWitness> extends PayloadValidator<T> {
+    static validateSignature(hash: ArrayBufferLike, address: string, signature?: ArrayBufferLike): Promise<Error[]>;
+    private validateArrayLength;
+    protected get expectedSchema(): string;
+    addresses(): Error[];
+    addressesUniqueness(): Error[];
+    previousHashes(): Error[];
+    schema(): Error[];
+    schemas(): Error[];
+    signatures(): Promise<Error[]>;
+    validate(): Promise<Error[]>;
+    validateArrayLengths(): Error[];
+    validatePayloadHashesLength(): Error[];
+}

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

@@ -0,0 +1,2 @@
+export * from './lib/index.ts';
+export * from './Validator.ts';