@xyo-network/xl1-rpc 1.16.5 → 1.16.7

package/dist/node/types/schema/common/HydratedTransaction.d.ts

@@ -5,34 +5,20 @@ export declare const HydratedTransactionZod: z.ZodTuple<[z.ZodObject<{
         readonly __address: true;
     }>, string>>>;
     payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
-    payload_schemas: z.ZodArray<z.ZodString>;
+    payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
+        __schema: true;
+    }, string>>]>>;
     previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>>;
     $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
         readonly __address: true;
     }>, string>>>;
     $sourceQuery: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodNull]>>;
-    _hash: z.ZodOptional<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>>;
-    _dataHash: z.ZodOptional<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>>;
+    _hash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
+    _dataHash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").LocalSequence, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").QualifiedSequence, string>>]>>;
-    nbf: z.ZodNumber;
-    exp: z.ZodNumber;
+    nbf: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>;
+    exp: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>;
     fees: z.ZodObject<{
         base: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>;
         gasLimit: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>;
@@ -43,42 +29,30 @@ export declare const HydratedTransactionZod: z.ZodTuple<[z.ZodObject<{
     from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").ChainId, string>>;
     script: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>, z.ZodArray<z.ZodObject<{
-    schema: z.ZodString;
-}, z.core.$catchall<z.ZodAny>>>], null>;
+    schema: z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
+        __schema: true;
+    }, string>>]>;
+}, z.core.$strip>>], null>;
 export declare const UnsignedHydratedTransactionZod: z.ZodTuple<[z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.boundwitness">;
     addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
         readonly __address: true;
     }>, string>>>;
     payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
-    payload_schemas: z.ZodArray<z.ZodString>;
+    payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
+        __schema: true;
+    }, string>>]>>;
     previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>>;
     $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
         readonly __address: true;
     }>, string>>>;
     $sourceQuery: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodNull]>>;
-    _hash: z.ZodOptional<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>>;
-    _dataHash: z.ZodOptional<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>>;
+    _hash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
+    _dataHash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").LocalSequence, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").QualifiedSequence, string>>]>>;
-    nbf: z.ZodNumber;
-    exp: z.ZodNumber;
+    nbf: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>;
+    exp: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>;
     fees: z.ZodObject<{
         base: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>;
         gasLimit: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>;
@@ -89,42 +63,30 @@ export declare const UnsignedHydratedTransactionZod: z.ZodTuple<[z.ZodObject<{
     from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").ChainId, string>>;
     script: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>, z.ZodArray<z.ZodObject<{
-    schema: z.ZodString;
-}, z.core.$catchall<z.ZodAny>>>], null>;
+    schema: z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
+        __schema: true;
+    }, string>>]>;
+}, z.core.$strip>>], null>;
 export declare const SignedHydratedTransactionZod: z.ZodTuple<[z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.boundwitness">;
     addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
         readonly __address: true;
     }>, string>>>;
     payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
-    payload_schemas: z.ZodArray<z.ZodString>;
+    payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
+        __schema: true;
+    }, string>>]>>;
     previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>>;
     $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
         readonly __address: true;
     }>, string>>>;
     $sourceQuery: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodNull]>>;
-    _hash: z.ZodOptional<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>>;
-    _dataHash: z.ZodOptional<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>>;
+    _hash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
+    _dataHash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").LocalSequence, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").QualifiedSequence, string>>]>>;
-    nbf: z.ZodNumber;
-    exp: z.ZodNumber;
+    nbf: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>;
+    exp: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>;
     fees: z.ZodObject<{
         base: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>;
         gasLimit: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>;
@@ -135,42 +97,30 @@ export declare const SignedHydratedTransactionZod: z.ZodTuple<[z.ZodObject<{
     from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").ChainId, string>>;
     script: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
 }, z.core.$strip>, z.ZodArray<z.ZodObject<{
-    schema: z.ZodString;
-}, z.core.$catchall<z.ZodAny>>>], null>;
+    schema: z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
+        __schema: true;
+    }, string>>]>;
+}, z.core.$strip>>], null>;
 export declare const SignedHydratedTransactionToJsonZod: z.ZodPipe<z.ZodTuple<[z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.boundwitness">;
     addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
         readonly __address: true;
     }>, string>>>;
     payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
-    payload_schemas: z.ZodArray<z.ZodString>;
+    payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
+        __schema: true;
+    }, string>>]>>;
     previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>>;
     $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
         readonly __address: true;
     }>, string>>>;
     $sourceQuery: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodNull]>>;
-    _hash: z.ZodOptional<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>>;
-    _dataHash: z.ZodOptional<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>>;
+    _hash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
+    _dataHash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").LocalSequence, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").QualifiedSequence, string>>]>>;
-    nbf: z.ZodNumber;
-    exp: z.ZodNumber;
+    nbf: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>;
+    exp: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>;
     fees: z.ZodObject<{
         base: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>;
         gasLimit: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>;
@@ -181,18 +131,22 @@ export declare const SignedHydratedTransactionToJsonZod: z.ZodPipe<z.ZodTuple<[z
     from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").ChainId, string>>;
     script: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
 }, z.core.$strip>, z.ZodArray<z.ZodObject<{
-    schema: z.ZodString;
-}, z.core.$catchall<z.ZodAny>>>], null>, z.ZodTransform<import("@xyo-network/xl1-protocol").SignedHydratedTransaction<import("@xyo-network/xl1-protocol").TransactionBoundWitness, import("@xyo-network/payload-model").Payload> | undefined, [{
+    schema: z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
+        __schema: true;
+    }, string>>]>;
+}, z.core.$strip>>], null>, z.ZodTransform<import("@xyo-network/xl1-protocol").SignedHydratedTransaction<import("@xyo-network/xl1-protocol").TransactionBoundWitness, import("@xyo-network/payload-model").Payload> | undefined, [{
     schema: "network.xyo.boundwitness";
     addresses: import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
         readonly __address: true;
     }>[];
     payload_hashes: import("@xylabs/hex").Hash[];
-    payload_schemas: string[];
+    payload_schemas: (string | (string & {
+        __schema: true;
+    }))[];
     previous_hashes: (import("@xylabs/hex").Hash | null)[];
     $signatures: (import("@xylabs/hex").Hex | null)[];
-    nbf: number;
-    exp: number;
+    nbf: import("@xyo-network/xl1-protocol").BlockNumber;
+    exp: import("@xyo-network/xl1-protocol").BlockNumber;
     fees: {
         base: import("@xylabs/hex").Hex;
         gasLimit: import("@xylabs/hex").Hex;
@@ -205,21 +159,14 @@ export declare const SignedHydratedTransactionToJsonZod: z.ZodPipe<z.ZodTuple<[z
         readonly __address: true;
     }> | undefined;
     $sourceQuery?: import("@xylabs/hex").Hash | undefined;
-    _hash?: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }> | undefined;
-    _dataHash?: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }> | undefined;
+    _hash?: import("@xylabs/hex").Hash | undefined;
+    _dataHash?: import("@xylabs/hex").Hash | undefined;
     _sequence?: import("@xyo-network/payload-model").LocalSequence | import("@xyo-network/payload-model").QualifiedSequence | undefined;
     script?: string[] | undefined;
 }, {
-    [x: string]: any;
-    schema: string;
+    schema: string | (string & {
+        __schema: true;
+    });
 }[]]>>;
 export declare const JsonToSignedHydratedTransactionZod: z.ZodPipe<z.ZodTuple<[z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.boundwitness">;
@@ -227,34 +174,20 @@ export declare const JsonToSignedHydratedTransactionZod: z.ZodPipe<z.ZodTuple<[z
         readonly __address: true;
     }>, string>>>;
     payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
-    payload_schemas: z.ZodArray<z.ZodString>;
+    payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
+        __schema: true;
+    }, string>>]>>;
     previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>>;
     $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
         readonly __address: true;
     }>, string>>>;
     $sourceQuery: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodNull]>>;
-    _hash: z.ZodOptional<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>>;
-    _dataHash: z.ZodOptional<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>>;
+    _hash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
+    _dataHash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").LocalSequence, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").QualifiedSequence, string>>]>>;
-    nbf: z.ZodNumber;
-    exp: z.ZodNumber;
+    nbf: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>;
+    exp: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>;
     fees: z.ZodObject<{
         base: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>;
         gasLimit: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>;
@@ -265,18 +198,22 @@ export declare const JsonToSignedHydratedTransactionZod: z.ZodPipe<z.ZodTuple<[z
     from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").ChainId, string>>;
     script: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
 }, z.core.$strip>, z.ZodArray<z.ZodObject<{
-    schema: z.ZodString;
-}, z.core.$catchall<z.ZodAny>>>], null>, z.ZodTransform<(import("@xyo-network/xl1-protocol").SignedHydratedTransaction<import("@xyo-network/xl1-protocol").TransactionBoundWitness, import("@xyo-network/payload-model").Payload> | (import("@xyo-network/payload-model").Payload | undefined)[] | undefined)[], [{
+    schema: z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
+        __schema: true;
+    }, string>>]>;
+}, z.core.$strip>>], null>, z.ZodTransform<(import("@xyo-network/xl1-protocol").SignedHydratedTransaction<import("@xyo-network/xl1-protocol").TransactionBoundWitness, import("@xyo-network/payload-model").Payload> | (import("@xyo-network/payload-model").Payload | undefined)[] | undefined)[], [{
     schema: "network.xyo.boundwitness";
     addresses: import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
         readonly __address: true;
     }>[];
     payload_hashes: import("@xylabs/hex").Hash[];
-    payload_schemas: string[];
+    payload_schemas: (string | (string & {
+        __schema: true;
+    }))[];
     previous_hashes: (import("@xylabs/hex").Hash | null)[];
     $signatures: (import("@xylabs/hex").Hex | null)[];
-    nbf: number;
-    exp: number;
+    nbf: import("@xyo-network/xl1-protocol").BlockNumber;
+    exp: import("@xyo-network/xl1-protocol").BlockNumber;
     fees: {
         base: import("@xylabs/hex").Hex;
         gasLimit: import("@xylabs/hex").Hex;
@@ -289,20 +226,13 @@ export declare const JsonToSignedHydratedTransactionZod: z.ZodPipe<z.ZodTuple<[z
         readonly __address: true;
     }> | undefined;
     $sourceQuery?: import("@xylabs/hex").Hash | undefined;
-    _hash?: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }> | undefined;
-    _dataHash?: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }> | undefined;
+    _hash?: import("@xylabs/hex").Hash | undefined;
+    _dataHash?: import("@xylabs/hex").Hash | undefined;
     _sequence?: import("@xyo-network/payload-model").LocalSequence | import("@xyo-network/payload-model").QualifiedSequence | undefined;
     script?: string[] | undefined;
 }, {
-    [x: string]: any;
-    schema: string;
+    schema: string | (string & {
+        __schema: true;
+    });
 }[]]>>;
 //# sourceMappingURL=HydratedTransaction.d.ts.map

package/dist/node/types/schema/common/HydratedTransaction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HydratedTransaction.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/HydratedTransaction.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAKxB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAGjC,CAAA;AAEF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAGzC,CAAA;AAEF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAGvC,CAAA;AAEF,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAM5C,CAAA;AAEH,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAM5C,CAAA"}
+{"version":3,"file":"HydratedTransaction.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/HydratedTransaction.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAIxB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAGjC,CAAA;AAEF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAGzC,CAAA;AAEF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAGvC,CAAA;AAEF,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAM5C,CAAA;AAEH,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAM5C,CAAA"}

package/dist/node/types/schema/common/RewardsRangeOptions.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 export declare const RewardsRangeOptionsZod: z.ZodObject<{
     positions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-    range: z.ZodOptional<z.ZodTuple<[z.ZodOptional<z.ZodNumber>, z.ZodOptional<z.ZodNumber>], null>>;
+    range: z.ZodOptional<z.ZodTuple<[z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>], null>>;
     steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
         block: z.ZodNumber;
         step: z.ZodNumber;

package/dist/node/types/schema/common/RewardsRangeOptions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RewardsRangeOptions.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/RewardsRangeOptions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB,eAAO,MAAM,sBAAsB;;;;;;;;;;iBAKjC,CAAA"}
+{"version":3,"file":"RewardsRangeOptions.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/RewardsRangeOptions.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,eAAO,MAAM,sBAAsB;;;;;;;;;;iBAKjC,CAAA"}

package/dist/node/types/schema/common/StepIdentity.d.ts

@@ -1,4 +1,7 @@
 import * as z from 'zod';
+/**
+ * @deprecated Use StepIdentityZod from \@xyo-network/xl1-protocol
+ */
 export declare const StepIdentityZod: z.ZodObject<{
     block: z.ZodNumber;
     step: z.ZodNumber;

package/dist/node/types/schema/common/StepIdentity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StepIdentity.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/StepIdentity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,eAAO,MAAM,eAAe;;;iBAG1B,CAAA"}
+{"version":3,"file":"StepIdentity.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/StepIdentity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB;;GAEG;AACH,eAAO,MAAM,eAAe;;;iBAG1B,CAAA"}

package/dist/node/types/schema/common/TransactionBoundWitness.d.ts

@@ -1,13 +1,13 @@
 import * as z from 'zod';
 export declare const BlockStartZod: z.ZodObject<{
-    nbf: z.ZodNumber;
+    nbf: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>;
 }, z.core.$strip>;
 export declare const BlockEndZod: z.ZodObject<{
-    exp: z.ZodNumber;
+    exp: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>;
 }, z.core.$strip>;
 export declare const BlockDurationZod: z.ZodObject<{
-    nbf: z.ZodNumber;
-    exp: z.ZodNumber;
+    nbf: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>;
+    exp: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>;
 }, z.core.$strip>;
 export declare const BlockScriptsZod: z.ZodObject<{
     script: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -26,34 +26,20 @@ export declare const TransactionBoundWitnessZod: z.ZodObject<{
         readonly __address: true;
     }>, string>>>;
     payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
-    payload_schemas: z.ZodArray<z.ZodString>;
+    payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
+        __schema: true;
+    }, string>>]>>;
     previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>>;
     $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
         readonly __address: true;
     }>, string>>>;
     $sourceQuery: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodNull]>>;
-    _hash: z.ZodOptional<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>>;
-    _dataHash: z.ZodOptional<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>>;
+    _hash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
+    _dataHash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").LocalSequence, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").QualifiedSequence, string>>]>>;
-    nbf: z.ZodNumber;
-    exp: z.ZodNumber;
+    nbf: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>;
+    exp: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>;
     fees: z.ZodObject<{
         base: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>;
         gasLimit: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>;
@@ -70,34 +56,20 @@ export declare const SignedTransactionBoundWitnessZod: z.ZodObject<{
         readonly __address: true;
     }>, string>>>;
     payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
-    payload_schemas: z.ZodArray<z.ZodString>;
+    payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
+        __schema: true;
+    }, string>>]>>;
     previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>>;
     $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
         readonly __address: true;
     }>, string>>>;
     $sourceQuery: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodNull]>>;
-    _hash: z.ZodOptional<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>>;
-    _dataHash: z.ZodOptional<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>>;
+    _hash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
+    _dataHash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").LocalSequence, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").QualifiedSequence, string>>]>>;
-    nbf: z.ZodNumber;
-    exp: z.ZodNumber;
+    nbf: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>;
+    exp: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>;
     fees: z.ZodObject<{
         base: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>;
         gasLimit: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>;

package/dist/node/types/schema/common/TransactionBoundWitness.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TransactionBoundWitness.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/TransactionBoundWitness.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAOxB,eAAO,MAAM,aAAa;;iBAAoC,CAAA;AAC9D,eAAO,MAAM,WAAW;;iBAAoC,CAAA;AAC5D,eAAO,MAAM,gBAAgB;;;iBAAyD,CAAA;AACtF,eAAO,MAAM,eAAe;;iBAAuD,CAAA;AAEnF,eAAO,MAAM,sBAAsB;;;;;;;iBAA4C,CAAA;AAM/E,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAUd,CAAA;AAEzB,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAUV,CAAA"}
+{"version":3,"file":"TransactionBoundWitness.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/TransactionBoundWitness.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAMxB,eAAO,MAAM,aAAa;;iBAAoC,CAAA;AAC9D,eAAO,MAAM,WAAW;;iBAAoC,CAAA;AAC5D,eAAO,MAAM,gBAAgB;;;iBAAyD,CAAA;AACtF,eAAO,MAAM,eAAe;;iBAAuD,CAAA;AAEnF,eAAO,MAAM,sBAAsB;;;;;;;iBAA4C,CAAA;AAM/E,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAUd,CAAA;AAEzB,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAUV,CAAA"}

package/dist/node/types/schema/common/Transfer.d.ts

@@ -22,35 +22,4 @@ export declare const TransferZod: z.ZodObject<{
         readonly __address: true;
     }>, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>>;
 }, z.z.core.$strict>;
-export declare const TransferZodWithStorageMeta: z.ZodObject<{
-    schema: z.ZodLiteral<"network.xyo.transfer">;
-    $opCodes: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
-    epoch: z.ZodNumber;
-    from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>;
-    transfers: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>>;
-    _hash: z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>;
-    _dataHash: z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>;
-    _sequence: z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").LocalSequence, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").QualifiedSequence, string>>]>;
-}, z.z.core.$strict>;
 //# sourceMappingURL=Transfer.d.ts.map

package/dist/node/types/schema/common/Transfer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Transfer.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/Transfer.ts"],"names":[],"mappings":"AAGA,OAAO,CAAC,MAAM,KAAK,CAAA;AAInB,eAAO,MAAM,iBAAiB;;;;;;;;;;mBAM5B,CAAA;AAEF,eAAO,MAAM,WAAW;;;;;;;;;;;oBAA2E,CAAA;AACnG,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAA2C,CAAA"}
+{"version":3,"file":"Transfer.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/Transfer.ts"],"names":[],"mappings":"AAGA,OAAO,CAAC,MAAM,KAAK,CAAA;AAInB,eAAO,MAAM,iBAAiB;;;;;;;;;;mBAM5B,CAAA;AAEF,eAAO,MAAM,WAAW;;;;;;;;;;;oBAA2E,CAAA"}

package/dist/node/types/schema/common/index.d.ts

@@ -1,13 +1,11 @@
 export * from './Address.ts';
 export * from './ArrayBuffer.ts';
 export * from './BlockBoundWitness.ts';
-export * from './BlockRange.ts';
 export * from './BoundWitness.ts';
 export * from './Chain.ts';
 export * from './HydratedBlock.ts';
 export * from './HydratedTransaction.ts';
 export * from './Json.ts';
-export * from './Payload.ts';
 export * from './Permission.ts';
 export * from './RewardsRangeOptions.ts';
 export * from './Sequence.ts';

package/dist/node/types/schema/common/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA;AAC5B,cAAc,kBAAkB,CAAA;AAChC,cAAc,wBAAwB,CAAA;AACtC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,mBAAmB,CAAA;AACjC,cAAc,YAAY,CAAA;AAC1B,cAAc,oBAAoB,CAAA;AAClC,cAAc,0BAA0B,CAAA;AACxC,cAAc,WAAW,CAAA;AACzB,cAAc,cAAc,CAAA;AAC5B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,0BAA0B,CAAA;AACxC,cAAc,eAAe,CAAA;AAC7B,cAAc,YAAY,CAAA;AAC1B,cAAc,mBAAmB,CAAA;AACjC,cAAc,8BAA8B,CAAA;AAC5C,cAAc,sBAAsB,CAAA;AACpC,cAAc,eAAe,CAAA;AAC7B,cAAc,mBAAmB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA;AAC5B,cAAc,kBAAkB,CAAA;AAChC,cAAc,wBAAwB,CAAA;AACtC,cAAc,mBAAmB,CAAA;AACjC,cAAc,YAAY,CAAA;AAC1B,cAAc,oBAAoB,CAAA;AAClC,cAAc,0BAA0B,CAAA;AACxC,cAAc,WAAW,CAAA;AACzB,cAAc,iBAAiB,CAAA;AAC/B,cAAc,0BAA0B,CAAA;AACxC,cAAc,eAAe,CAAA;AAC7B,cAAc,YAAY,CAAA;AAC1B,cAAc,mBAAmB,CAAA;AACjC,cAAc,8BAA8B,CAAA;AAC5C,cAAc,sBAAsB,CAAA;AACpC,cAAc,eAAe,CAAA;AAC7B,cAAc,mBAAmB,CAAA"}