@xyo-network/sdk-protocol 7.0.5 → 7.0.7

package/dist/_pkg/payload-model/neutral/Error.d.ts

@@ -10,7 +10,7 @@ export declare const ModuleErrorZod: z.ZodMiniObject<{
     details: z.ZodMiniOptional<z.ZodMiniCustom<unknown, unknown>>;
     message: z.ZodMiniOptional<z.ZodMiniString<string>>;
     name: z.ZodMiniOptional<z.ZodMiniString<string>>;
-    query: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("./Schema.ts").BrandedSchema<string>, string>>]>>;
+    query: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("./Schema.ts").BrandedSchema<string>, string>>]>>;
 }, z.core.$strip>;
 export type ModuleError = z.infer<typeof ModuleErrorZod>;
 export declare const isModuleError: <T>(value: T) => value is T & {
@@ -20,7 +20,7 @@ export declare const isModuleError: <T>(value: T) => value is T & {
     details?: unknown;
     message?: string | undefined;
     name?: string | undefined;
-    query?: import("./Schema.ts").BrandedSchema<string> | import("@xylabs/sdk").BrandedHash | undefined;
+    query?: import("./Schema.ts").BrandedSchema<string> | import("@ariestools/sdk").BrandedHash | undefined;
 };
 export declare const asModuleError: {
     <T>(value: T): (T & {
@@ -30,16 +30,16 @@ export declare const asModuleError: {
         details?: unknown;
         message?: string | undefined;
         name?: string | undefined;
-        query?: import("./Schema.ts").BrandedSchema<string> | import("@xylabs/sdk").BrandedHash | undefined;
+        query?: import("./Schema.ts").BrandedSchema<string> | import("@ariestools/sdk").BrandedHash | undefined;
     }) | undefined;
-    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
         schema: "network.xyo.error.module" & {
             readonly __schema: true;
         };
         details?: unknown;
         message?: string | undefined;
         name?: string | undefined;
-        query?: import("./Schema.ts").BrandedSchema<string> | import("@xylabs/sdk").BrandedHash | undefined;
+        query?: import("./Schema.ts").BrandedSchema<string> | import("@ariestools/sdk").BrandedHash | undefined;
     };
 };
 export declare const toModuleError: {
@@ -50,16 +50,15 @@ export declare const toModuleError: {
         details?: unknown;
         message?: string | undefined;
         name?: string | undefined;
-        query?: import("./Schema.ts").BrandedSchema<string> | import("@xylabs/sdk").BrandedHash | undefined;
+        query?: import("./Schema.ts").BrandedSchema<string> | import("@ariestools/sdk").BrandedHash | undefined;
     }) | undefined;
-    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
         schema: "network.xyo.error.module" & {
             readonly __schema: true;
         };
         details?: unknown;
         message?: string | undefined;
         name?: string | undefined;
-        query?: import("./Schema.ts").BrandedSchema<string> | import("@xylabs/sdk").BrandedHash | undefined;
+        query?: import("./Schema.ts").BrandedSchema<string> | import("@ariestools/sdk").BrandedHash | undefined;
     };
 };
-//# sourceMappingURL=Error.d.ts.map

package/dist/_pkg/payload-model/neutral/Payload.d.ts

@@ -1,4 +1,4 @@
-import type { DeepOmitStartsWith, DeepPickStartsWith, EmptyObject, Hash } from '@xylabs/sdk';
+import type { DeepOmitStartsWith, DeepPickStartsWith, EmptyObject, Hash } from '@ariestools/sdk';
 import type { BrandedSchema, Schema } from './Schema.ts';
 export interface SchemaField<T extends Schema = Schema> {
     schema: T;
@@ -32,4 +32,3 @@ export type WithoutMeta<T extends Payload | EmptyObject> = WithoutClientMeta<Wit
 export type WithoutSchema<T extends WithOptionalSchema<Payload>> = Omit<T, 'schema'>;
 export type WithOptionalSchema<T extends Payload = Payload> = WithoutSchema<T> & Partial<T & SchemaField>;
 export type WithOnlyClientMeta<T extends Payload> = DeepPickStartsWith<T, '$'>;
-//# sourceMappingURL=Payload.d.ts.map

package/dist/_pkg/payload-model/neutral/PayloadBundle.d.ts

@@ -7,7 +7,7 @@ export declare const PayloadBundleFieldsZod: z.ZodMiniObject<{
     payloads: z.ZodMiniArray<z.ZodMiniObject<{
         schema: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("./Schema.ts").BrandedSchema<string>, string>>;
     }, z.core.$strict>>;
-    root: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>;
+    root: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
 }, z.core.$strip>;
 export type PayloadBundleFields = z.infer<typeof PayloadBundleFieldsZod>;
 export declare const PayloadBundleZod: z.ZodMiniObject<{
@@ -17,7 +17,7 @@ export declare const PayloadBundleZod: z.ZodMiniObject<{
     payloads: z.ZodMiniArray<z.ZodMiniObject<{
         schema: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("./Schema.ts").BrandedSchema<string>, string>>;
     }, z.core.$strict>>;
-    root: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>;
+    root: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
 }, z.core.$strip>;
 export type PayloadBundle = z.infer<typeof PayloadBundleZod>;
 export declare const isPayloadBundle: <T>(value: T) => value is T & {
@@ -27,7 +27,7 @@ export declare const isPayloadBundle: <T>(value: T) => value is T & {
     payloads: {
         schema: import("./Schema.ts").BrandedSchema<string>;
     }[];
-    root: import("@xylabs/sdk").BrandedHash;
+    root: import("@ariestools/sdk").BrandedHash;
 };
 export declare const asPayloadBundle: {
     <T>(value: T): (T & {
@@ -37,16 +37,16 @@ export declare const asPayloadBundle: {
         payloads: {
             schema: import("./Schema.ts").BrandedSchema<string>;
         }[];
-        root: import("@xylabs/sdk").BrandedHash;
+        root: import("@ariestools/sdk").BrandedHash;
     }) | undefined;
-    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
         schema: "network.xyo.payload.bundle" & {
             readonly __schema: true;
         };
         payloads: {
             schema: import("./Schema.ts").BrandedSchema<string>;
         }[];
-        root: import("@xylabs/sdk").BrandedHash;
+        root: import("@ariestools/sdk").BrandedHash;
     };
 };
 export declare const asOptionalPayloadBundle: {
@@ -57,16 +57,15 @@ export declare const asOptionalPayloadBundle: {
         payloads: {
             schema: import("./Schema.ts").BrandedSchema<string>;
         }[];
-        root: import("@xylabs/sdk").BrandedHash;
+        root: import("@ariestools/sdk").BrandedHash;
     }) | undefined;
-    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
         schema: "network.xyo.payload.bundle" & {
             readonly __schema: true;
         };
         payloads: {
             schema: import("./Schema.ts").BrandedSchema<string>;
         }[];
-        root: import("@xylabs/sdk").BrandedHash;
+        root: import("@ariestools/sdk").BrandedHash;
     };
 };
-//# sourceMappingURL=PayloadBundle.d.ts.map

package/dist/_pkg/payload-model/neutral/PayloadFindFilter.d.ts

@@ -3,4 +3,3 @@ export interface PayloadFindFilter {
     order?: 'desc' | 'asc';
     schema?: string | string[];
 }
-//# sourceMappingURL=PayloadFindFilter.d.ts.map

package/dist/_pkg/payload-model/neutral/PayloadHashMap.d.ts

@@ -1,7 +1,6 @@
-import type { Hash } from '@xylabs/sdk';
+import type { Hash } from '@ariestools/sdk';
 import type { Payload } from './Payload.ts';
 export interface PayloadHashMap<TPayload extends Payload = Payload, TId extends string | number | symbol = Hash> {
     dataHash: Record<TId, TId>;
     hash: Record<TId, TPayload>;
 }
-//# sourceMappingURL=PayloadHashMap.d.ts.map

package/dist/_pkg/payload-model/neutral/PayloadSet/PayloadSetPayload.d.ts

@@ -27,7 +27,7 @@ export declare const asPayloadSetPayload: {
         optional?: Record<string, number> | undefined;
         required?: Record<string, number> | undefined;
     }) | undefined;
-    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
         schema: "network.xyo.payload.set" & {
             readonly __schema: true;
         };
@@ -43,7 +43,7 @@ export declare const toPayloadSetPayload: {
         optional?: Record<string, number> | undefined;
         required?: Record<string, number> | undefined;
     }) | undefined;
-    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
         schema: "network.xyo.payload.set" & {
             readonly __schema: true;
         };
@@ -51,4 +51,3 @@ export declare const toPayloadSetPayload: {
         required?: Record<string, number> | undefined;
     };
 };
-//# sourceMappingURL=PayloadSetPayload.d.ts.map

package/dist/_pkg/payload-model/neutral/PayloadSet/PayloadSetSchema.d.ts

@@ -2,4 +2,3 @@ export declare const PayloadSetSchema: "network.xyo.payload.set" & {
     readonly __schema: true;
 };
 export type PayloadSetSchema = typeof PayloadSetSchema;
-//# sourceMappingURL=PayloadSetSchema.d.ts.map

package/dist/_pkg/payload-model/neutral/PayloadSet/index.d.ts

@@ -1,3 +1,2 @@
 export * from './PayloadSetPayload.ts';
 export * from './PayloadSetSchema.ts';
-//# sourceMappingURL=index.d.ts.map

package/dist/_pkg/payload-model/neutral/PayloadValidationFunction.d.ts

@@ -11,4 +11,3 @@ export type AsyncPayloadValidationFunction<T extends Payload = Payload> = (paylo
  * A function that validates the supplied payload
  */
 export type PayloadValidationFunction<T extends Payload = Payload> = SyncPayloadValidationFunction<T> | AsyncPayloadValidationFunction<T>;
-//# sourceMappingURL=PayloadValidationFunction.d.ts.map

package/dist/_pkg/payload-model/neutral/PayloadValueExpression.d.ts

@@ -35,4 +35,3 @@ Key extends PayloadProperty<T> = PayloadProperty<T>,
  * The type of the selected property's value
  */
 TValue = PayloadValue<T, Key>> = (payload: T) => TValue;
-//# sourceMappingURL=PayloadValueExpression.d.ts.map

package/dist/_pkg/payload-model/neutral/PayloadZod.d.ts

@@ -2,33 +2,33 @@ import * as z from 'zod/mini';
 import type { Payload } from './Payload.ts';
 import type { Schema } from './Schema.ts';
 export declare const HashMetaZod: z.ZodMiniObject<{
-    _hash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>;
-    _dataHash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>;
+    _hash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+    _dataHash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
 }, z.core.$strip>;
 export type HashMeta = z.infer<typeof HashMetaZod>;
 export type WithHashMeta<T extends Payload> = T & HashMeta;
 export declare const isHashMeta: <T>(value: T) => value is T & {
-    _hash: import("@xylabs/sdk").BrandedHash;
-    _dataHash: import("@xylabs/sdk").BrandedHash;
+    _hash: import("@ariestools/sdk").BrandedHash;
+    _dataHash: import("@ariestools/sdk").BrandedHash;
 };
 export declare const asHashMeta: {
     <T>(value: T): (T & {
-        _hash: import("@xylabs/sdk").BrandedHash;
-        _dataHash: import("@xylabs/sdk").BrandedHash;
+        _hash: import("@ariestools/sdk").BrandedHash;
+        _dataHash: import("@ariestools/sdk").BrandedHash;
     }) | undefined;
-    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
-        _hash: import("@xylabs/sdk").BrandedHash;
-        _dataHash: import("@xylabs/sdk").BrandedHash;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        _hash: import("@ariestools/sdk").BrandedHash;
+        _dataHash: import("@ariestools/sdk").BrandedHash;
     };
 };
 export declare const toHashMeta: {
     <T>(value: T): (T & {
-        _hash: import("@xylabs/sdk").BrandedHash;
-        _dataHash: import("@xylabs/sdk").BrandedHash;
+        _hash: import("@ariestools/sdk").BrandedHash;
+        _dataHash: import("@ariestools/sdk").BrandedHash;
     }) | undefined;
-    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
-        _hash: import("@xylabs/sdk").BrandedHash;
-        _dataHash: import("@xylabs/sdk").BrandedHash;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        _hash: import("@ariestools/sdk").BrandedHash;
+        _dataHash: import("@ariestools/sdk").BrandedHash;
     };
 };
 export declare const SequenceMetaZod: z.ZodMiniObject<{
@@ -42,7 +42,7 @@ export declare const asSequenceMeta: {
     <T>(value: T): (T & {
         _sequence: import("./StorageMeta/index.ts").LocalSequence | import("./StorageMeta/index.ts").QualifiedSequence;
     }) | undefined;
-    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
         _sequence: import("./StorageMeta/index.ts").LocalSequence | import("./StorageMeta/index.ts").QualifiedSequence;
     };
 };
@@ -50,43 +50,43 @@ export declare const toSequenceMeta: {
     <T>(value: T): (T & {
         _sequence: import("./StorageMeta/index.ts").LocalSequence | import("./StorageMeta/index.ts").QualifiedSequence;
     }) | undefined;
-    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
         _sequence: import("./StorageMeta/index.ts").LocalSequence | import("./StorageMeta/index.ts").QualifiedSequence;
     };
 };
 export declare const StorageMetaZod: z.ZodMiniObject<{
-    _hash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>;
-    _dataHash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>;
+    _hash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+    _dataHash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
     _sequence: z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("./StorageMeta/index.ts").LocalSequence, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("./StorageMeta/index.ts").QualifiedSequence, string>>]>;
 }, z.core.$strip>;
 export type StorageMeta = z.infer<typeof StorageMetaZod>;
 export type WithStorageMeta<T extends Payload = Payload> = T & StorageMeta;
 export declare const isStorageMeta: <T>(value: T) => value is T & {
-    _hash: import("@xylabs/sdk").BrandedHash;
-    _dataHash: import("@xylabs/sdk").BrandedHash;
+    _hash: import("@ariestools/sdk").BrandedHash;
+    _dataHash: import("@ariestools/sdk").BrandedHash;
     _sequence: import("./StorageMeta/index.ts").LocalSequence | import("./StorageMeta/index.ts").QualifiedSequence;
 };
 export declare const asStorageMeta: {
     <T>(value: T): (T & {
-        _hash: import("@xylabs/sdk").BrandedHash;
-        _dataHash: import("@xylabs/sdk").BrandedHash;
+        _hash: import("@ariestools/sdk").BrandedHash;
+        _dataHash: import("@ariestools/sdk").BrandedHash;
         _sequence: import("./StorageMeta/index.ts").LocalSequence | import("./StorageMeta/index.ts").QualifiedSequence;
     }) | undefined;
-    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
-        _hash: import("@xylabs/sdk").BrandedHash;
-        _dataHash: import("@xylabs/sdk").BrandedHash;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        _hash: import("@ariestools/sdk").BrandedHash;
+        _dataHash: import("@ariestools/sdk").BrandedHash;
         _sequence: import("./StorageMeta/index.ts").LocalSequence | import("./StorageMeta/index.ts").QualifiedSequence;
     };
 };
 export declare const toStorageMeta: {
     <T>(value: T): (T & {
-        _hash: import("@xylabs/sdk").BrandedHash;
-        _dataHash: import("@xylabs/sdk").BrandedHash;
+        _hash: import("@ariestools/sdk").BrandedHash;
+        _dataHash: import("@ariestools/sdk").BrandedHash;
         _sequence: import("./StorageMeta/index.ts").LocalSequence | import("./StorageMeta/index.ts").QualifiedSequence;
     }) | undefined;
-    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
-        _hash: import("@xylabs/sdk").BrandedHash;
-        _dataHash: import("@xylabs/sdk").BrandedHash;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        _hash: import("@ariestools/sdk").BrandedHash;
+        _dataHash: import("@ariestools/sdk").BrandedHash;
         _sequence: import("./StorageMeta/index.ts").LocalSequence | import("./StorageMeta/index.ts").QualifiedSequence;
     };
 };
@@ -100,7 +100,7 @@ export declare const asPayload: {
     <T>(value: T): (T & {
         schema: import("./Schema.ts").BrandedSchema<string>;
     }) | undefined;
-    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
         schema: import("./Schema.ts").BrandedSchema<string>;
     };
 };
@@ -108,7 +108,7 @@ export declare const toPayload: {
     <T>(value: T): (T & {
         schema: import("./Schema.ts").BrandedSchema<string>;
     }) | undefined;
-    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
         schema: import("./Schema.ts").BrandedSchema<string>;
     };
 };
@@ -124,7 +124,7 @@ export declare const asAnyPayload: {
         [x: string]: unknown;
         schema: import("./Schema.ts").BrandedSchema<string>;
     }) | undefined;
-    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
         [x: string]: unknown;
         schema: import("./Schema.ts").BrandedSchema<string>;
     };
@@ -134,20 +134,20 @@ export declare const toAnyPayload: {
         [x: string]: unknown;
         schema: import("./Schema.ts").BrandedSchema<string>;
     }) | undefined;
-    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
         [x: string]: unknown;
         schema: import("./Schema.ts").BrandedSchema<string>;
     };
 };
 export type AnyPayload = z.infer<typeof AnyPayloadZod>;
 export declare function WithStorageMetaZod<T extends z.core.$ZodLooseShape>(valueZod: z.ZodMiniObject<T>): z.ZodMiniObject<T & {
-    _hash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>;
-    _dataHash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>;
+    _hash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+    _dataHash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
     _sequence: z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("./StorageMeta/index.ts").LocalSequence, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("./StorageMeta/index.ts").QualifiedSequence, string>>]>;
 } extends infer T_1 ? { -readonly [P in keyof T_1]: T_1[P]; } : never, z.core.$strip>;
 export declare function WithHashMetaZod<T extends z.core.$ZodLooseShape>(valueZod: z.ZodMiniObject<T>): z.ZodMiniObject<T & {
-    _hash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>;
-    _dataHash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>;
+    _hash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+    _dataHash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
 } extends infer T_1 ? { -readonly [P in keyof T_1]: T_1[P]; } : never, z.core.$strip>;
 export declare const PayloadZodStrict: z.ZodMiniObject<{
     schema: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("./Schema.ts").BrandedSchema<string>, string>>;
@@ -157,8 +157,8 @@ export declare const PayloadZodLoose: PayloadZodStrict;
 export type PayloadZodLoose = typeof PayloadZodLoose;
 export declare const WithHashMetaPayloadZodLoose: z.ZodMiniObject<{
     schema: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("./Schema.ts").BrandedSchema<string>, string>>;
-    _hash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>;
-    _dataHash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>;
+    _hash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+    _dataHash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
 }, z.core.$strict>;
 export type WithHashMetaPayloadZodLoose = typeof WithHashMetaPayloadZodLoose;
 export declare const PayloadZodOfSchema: <S extends Schema>(schema: S) => z.ZodMiniObject<{
@@ -170,4 +170,3 @@ export declare const PayloadZodStrictOfSchema: <S extends Schema>(schema: S) =>
 export declare const PayloadZodLooseOfSchema: <S extends Schema>(schema: S) => z.ZodMiniObject<{
     schema: z.ZodMiniLiteral<S>;
 }, z.core.$strict>;
-//# sourceMappingURL=PayloadZod.d.ts.map

package/dist/_pkg/payload-model/neutral/Query.d.ts

@@ -1,4 +1,4 @@
-import type { EmptyObject } from '@xylabs/sdk';
+import type { EmptyObject } from '@ariestools/sdk';
 import * as z from 'zod/mini';
 import type { Payload, SchemaField } from './Payload.ts';
 import type { Schema } from './Schema.ts';
@@ -18,4 +18,3 @@ export declare const QueryFieldsZod: z.ZodMiniObject<{
 }, z.core.$strip>;
 export type QueryFields = z.infer<typeof QueryFieldsZod>;
 export type Query<T extends void | EmptyObject | SchemaField = void, S extends Schema | void = void> = Payload<T extends void ? QueryFields : T & QueryFields, S extends void ? T extends SchemaField ? T['schema'] : T extends void ? Schema : void : S>;
-//# sourceMappingURL=Query.d.ts.map

package/dist/_pkg/payload-model/neutral/Schema.d.ts

@@ -1,4 +1,4 @@
-import type { Brand } from '@xylabs/sdk';
+import type { Brand } from '@ariestools/sdk';
 import * as z from 'zod/mini';
 export type BrandedSchema<T extends string = string> = Brand<T, {
     readonly __schema: true;
@@ -16,7 +16,7 @@ export declare const asSchema: {
     <T>(value: T): (T & string & {
         readonly __schema: true;
     }) | undefined;
-    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & string & {
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & string & {
         readonly __schema: true;
     };
 };
@@ -24,7 +24,7 @@ export declare const toSchema: {
     <T>(value: T): (T & string & {
         readonly __schema: true;
     }) | undefined;
-    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & string & {
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & string & {
         readonly __schema: true;
     };
 };
@@ -35,4 +35,3 @@ export declare const PayloadSchemaZod: z.ZodMiniLiteral<"network.xyo.payload" &
     readonly __schema: true;
 }>;
 export type PayloadSchema = z.infer<typeof PayloadSchemaZod>;
-//# sourceMappingURL=Schema.d.ts.map

package/dist/_pkg/payload-model/neutral/StorageMeta/DataHash.d.ts

@@ -1,4 +1,4 @@
-import type { Hash } from '@xylabs/sdk';
+import type { Hash } from '@ariestools/sdk';
 import type { Payload } from '../Payload.ts';
 export interface DataHashMeta {
     _dataHash: Hash;
@@ -6,8 +6,8 @@ export interface DataHashMeta {
 export type WithDataHashMeta<T extends Payload = Payload> = T & DataHashMeta;
 export type WithPartialDataHashMeta<T extends Payload = Payload> = Partial<WithDataHashMeta<T>>;
 export declare const isDataHashMeta: (value: unknown) => value is DataHashMeta;
-export declare const asDataHashMeta: import("@xylabs/sdk").AsTypeFunction<DataHashMeta>;
-export declare const asOptionalDataHashMeta: (value: import("@xylabs/sdk").AnyNonPromise) => DataHashMeta | undefined;
+export declare const asDataHashMeta: import("@ariestools/sdk").AsTypeFunction<DataHashMeta>;
+export declare const asOptionalDataHashMeta: (value: import("@ariestools/sdk").AnyNonPromise) => DataHashMeta | undefined;
 /** @deprecated use DataHashMeta instead */
 export interface DataHashStorageMeta extends DataHashMeta {
 }
@@ -18,7 +18,6 @@ export type WithPartialDataHashStorageMeta<T extends Payload = Payload> = WithPa
 /** @deprecated use isDataHashMeta instead */
 export declare const isDataHashStorageMeta: (value: unknown) => value is DataHashMeta;
 /** @deprecated use asDataHashMeta instead */
-export declare const asDataHashStorageMeta: import("@xylabs/sdk").AsTypeFunction<DataHashMeta>;
+export declare const asDataHashStorageMeta: import("@ariestools/sdk").AsTypeFunction<DataHashMeta>;
 /** @deprecated use asOptionalDataHashMeta instead */
-export declare const asOptionalDataHashStorageMeta: (value: import("@xylabs/sdk").AnyNonPromise) => DataHashMeta | undefined;
-//# sourceMappingURL=DataHash.d.ts.map
+export declare const asOptionalDataHashStorageMeta: (value: import("@ariestools/sdk").AnyNonPromise) => DataHashMeta | undefined;

package/dist/_pkg/payload-model/neutral/StorageMeta/Hash.d.ts

@@ -1,4 +1,4 @@
-import type { Hash } from '@xylabs/sdk';
+import type { Hash } from '@ariestools/sdk';
 import type { Payload } from '../Payload.ts';
 import type { DataHashMeta } from './DataHash.ts';
 export interface HashMeta extends DataHashMeta {
@@ -7,8 +7,8 @@ export interface HashMeta extends DataHashMeta {
 export type WithHashMeta<T extends Payload = Payload> = T & HashMeta;
 export type WithPartialHashMeta<T extends Payload = Payload> = Partial<WithHashMeta<T>>;
 export declare const isHashMeta: (value: unknown) => value is HashMeta;
-export declare const asHashMeta: import("@xylabs/sdk").AsTypeFunction<HashMeta>;
-export declare const asOptionalHashMeta: (value: import("@xylabs/sdk").AnyNonPromise) => HashMeta | undefined;
+export declare const asHashMeta: import("@ariestools/sdk").AsTypeFunction<HashMeta>;
+export declare const asOptionalHashMeta: (value: import("@ariestools/sdk").AnyNonPromise) => HashMeta | undefined;
 /** @deprecated use HashMeta instead */
 export interface HashStorageMeta extends HashMeta {
 }
@@ -19,7 +19,6 @@ export type WithPartialHashStorageMeta<T extends Payload = Payload> = Partial<Wi
 /** @deprecated use isHashMeta instead */
 export declare const isHashStorageMeta: (value: unknown) => value is HashMeta;
 /** @deprecated use asHashMeta instead */
-export declare const asHashStorageMeta: import("@xylabs/sdk").AsTypeFunction<HashMeta>;
+export declare const asHashStorageMeta: import("@ariestools/sdk").AsTypeFunction<HashMeta>;
 /** @deprecated use asOptionalHashMeta instead */
-export declare const asOptionalHashStorageMeta: (value: import("@xylabs/sdk").AnyNonPromise) => HashMeta | undefined;
-//# sourceMappingURL=Hash.d.ts.map
+export declare const asOptionalHashStorageMeta: (value: import("@ariestools/sdk").AnyNonPromise) => HashMeta | undefined;

package/dist/_pkg/payload-model/neutral/StorageMeta/Sequence.d.ts

@@ -6,6 +6,5 @@ export interface SequenceStorageMeta {
 export type WithSequenceStorageMeta<T extends Payload = Payload> = T & SequenceStorageMeta;
 export type WithPartialSequenceStorageMeta<T extends Payload = Payload> = Partial<WithSequenceStorageMeta<T>>;
 export declare const isSequenceStorageMeta: (value: unknown) => value is SequenceStorageMeta;
-export declare const asSequenceStorageMeta: import("@xylabs/sdk").AsTypeFunction<SequenceStorageMeta>;
-export declare const asOptionalSequenceStorageMeta: (value: import("@xylabs/sdk").AnyNonPromise) => SequenceStorageMeta | undefined;
-//# sourceMappingURL=Sequence.d.ts.map
+export declare const asSequenceStorageMeta: import("@ariestools/sdk").AsTypeFunction<SequenceStorageMeta>;
+export declare const asOptionalSequenceStorageMeta: (value: import("@ariestools/sdk").AnyNonPromise) => SequenceStorageMeta | undefined;

package/dist/_pkg/payload-model/neutral/StorageMeta/index.d.ts

@@ -1,3 +1,2 @@
 export * from './Sequence.ts';
 export * from './sequence/index.ts';
-//# sourceMappingURL=index.d.ts.map

package/dist/_pkg/payload-model/neutral/StorageMeta/sequence/Comparer.d.ts

@@ -1,7 +1,6 @@
-import type { Compare } from '@xylabs/sdk';
+import type { Compare } from '@ariestools/sdk';
 import type { Sequence } from './Sequence.ts';
 export declare const SequenceComparer: {
     local: Compare<Sequence>;
     qualified: Compare<Sequence>;
 };
-//# sourceMappingURL=Comparer.d.ts.map

package/dist/_pkg/payload-model/neutral/StorageMeta/sequence/Parser.d.ts

@@ -1,4 +1,4 @@
-import type { Hash, Hex } from '@xylabs/sdk';
+import type { Hash, Hex } from '@ariestools/sdk';
 import type { XyoLegacyAddress } from '../../../../address/neutral/index.ts';
 import type { Epoch, LocalSequence, Nonce, QualifiedSequence, Sequence } from './Sequence.ts';
 export declare class SequenceParser {
@@ -28,4 +28,3 @@ export declare class SequenceParser {
     get nonce(): Nonce;
     get qualifiedSequence(): QualifiedSequence;
 }
-//# sourceMappingURL=Parser.d.ts.map

package/dist/_pkg/payload-model/neutral/StorageMeta/sequence/Sequence.d.ts

@@ -1,4 +1,4 @@
-import type { Brand, Hex } from '@xylabs/sdk';
+import type { Brand, Hex } from '@ariestools/sdk';
 import type { XyoLegacyAddress } from '../../../../address/neutral/index.ts';
 export type LocalSequence = Brand<Hex, {
     __localSequence: true;
@@ -77,4 +77,3 @@ export declare const SequenceConstants: {
     nonceIndexBytes: number;
     nonceHashBytes: number;
 };
-//# sourceMappingURL=Sequence.d.ts.map

package/dist/_pkg/payload-model/neutral/StorageMeta/sequence/SequenceZod.d.ts

@@ -6,4 +6,3 @@ export declare const QualifiedSequenceToStringZod: z.ZodMiniString<string>;
 export declare const QualifiedSequenceFromStringZod: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<QualifiedSequence, string>>;
 export declare const SequenceToStringZod: z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniString<string>]>;
 export declare const SequenceFromStringZod: z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<LocalSequence, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<QualifiedSequence, string>>]>;
-//# sourceMappingURL=SequenceZod.d.ts.map

package/dist/_pkg/payload-model/neutral/StorageMeta/sequence/index.d.ts

@@ -2,4 +2,3 @@ export * from './Comparer.ts';
 export * from './Parser.ts';
 export * from './Sequence.ts';
 export * from './SequenceZod.ts';
-//# sourceMappingURL=index.d.ts.map

package/dist/_pkg/payload-model/neutral/Timestamp.d.ts

@@ -1,8 +1,7 @@
-import type { EmptyObject } from '@xylabs/sdk';
+import type { EmptyObject } from '@ariestools/sdk';
 /** Object with a timestamp */
 export interface Timestamp {
     timestamp: number;
 }
 /** Add a timestamp field to any object */
 export type WithTimestamp<T extends EmptyObject = EmptyObject> = T & Timestamp;
-//# sourceMappingURL=Timestamp.d.ts.map

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

@@ -13,4 +13,3 @@ export * from './Query.ts';
 export * from './Schema.ts';
 export * from './StorageMeta/index.ts';
 export * from './Timestamp.ts';
-//# sourceMappingURL=index.d.ts.map