@xyo-network/payment-payload-plugins 6.1.0 → 7.0.0

package/dist/neutral/Discount/Payload/Coupon/Payload.d.ts

@@ -1,16 +1,193 @@
-import type { FixedAmountCoupon, FixedPercentageCoupon, FixedPriceCoupon } from './Coupons/index.ts';
+import * as z from 'zod/mini';
 /**
  * The type of coupons
  */
-export type Coupon = FixedAmountCoupon | FixedPercentageCoupon | FixedPriceCoupon;
+export declare const CouponZod: z.ZodMiniUnion<readonly [z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<string & {
+        readonly __schema: true;
+    }>;
+    amount: z.ZodMiniNumber<number>;
+    currency: z.ZodMiniCustom<import("../../../index.ts").Iso4217AlphabeticalCode, import("../../../index.ts").Iso4217AlphabeticalCode>;
+    conditions: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk-js").BrandedHash, string>>>>;
+    exp: z.ZodMiniNumber<number>;
+    nbf: z.ZodMiniNumber<number>;
+    stackable: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+}, z.core.$strip>, z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<string & {
+        readonly __schema: true;
+    }>;
+    percentage: z.ZodMiniNumber<number>;
+    conditions: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk-js").BrandedHash, string>>>>;
+    exp: z.ZodMiniNumber<number>;
+    nbf: z.ZodMiniNumber<number>;
+    stackable: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+}, z.core.$strip>, z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<string & {
+        readonly __schema: true;
+    }>;
+    amount: z.ZodMiniNumber<number>;
+    currency: z.ZodMiniCustom<import("../../../index.ts").Iso4217AlphabeticalCode, import("../../../index.ts").Iso4217AlphabeticalCode>;
+    conditions: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk-js").BrandedHash, string>>>>;
+    exp: z.ZodMiniNumber<number>;
+    nbf: z.ZodMiniNumber<number>;
+    stackable: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+}, z.core.$strip>]>;
+export type Coupon = z.infer<typeof CouponZod>;
 /**
  * Identity function for determining if an object is an Coupon
  */
-export declare const isCoupon: (x?: unknown) => x is FixedAmountCoupon | FixedPercentageCoupon | FixedPriceCoupon;
-export declare const asCoupon: import("@xylabs/sdk-js").AsTypeFunction<FixedAmountCoupon | FixedPercentageCoupon | FixedPriceCoupon>;
-/**
- * Identity function for determining if an object is an Coupon with sources
- */
-export declare const isCouponWithSources: (x?: unknown) => x is import("@xyo-network/sdk-protocol-js").WithSources<import("@xyo-network/sdk-protocol-js").WithSources<FixedAmountCoupon>> | import("@xyo-network/sdk-protocol-js").WithSources<import("@xyo-network/sdk-protocol-js").WithSources<FixedPercentageCoupon>> | import("@xyo-network/sdk-protocol-js").WithSources<import("@xyo-network/sdk-protocol-js").WithSources<FixedPriceCoupon>>;
-export declare const asCouponWithSources: import("@xylabs/sdk-js").AsTypeFunction<import("@xyo-network/sdk-protocol-js").WithSources<import("@xyo-network/sdk-protocol-js").WithSources<FixedAmountCoupon>> | import("@xyo-network/sdk-protocol-js").WithSources<import("@xyo-network/sdk-protocol-js").WithSources<FixedPercentageCoupon>> | import("@xyo-network/sdk-protocol-js").WithSources<import("@xyo-network/sdk-protocol-js").WithSources<FixedPriceCoupon>>>;
+export declare const isCoupon: <T>(value: T) => value is T & ({
+    schema: string & {
+        readonly __schema: true;
+    };
+    amount: number;
+    currency: import("../../../index.ts").Iso4217AlphabeticalCode;
+    exp: number;
+    nbf: number;
+    conditions?: import("@xylabs/sdk-js").BrandedHash[] | undefined;
+    stackable?: boolean | undefined;
+} | {
+    schema: string & {
+        readonly __schema: true;
+    };
+    percentage: number;
+    exp: number;
+    nbf: number;
+    conditions?: import("@xylabs/sdk-js").BrandedHash[] | undefined;
+    stackable?: boolean | undefined;
+} | {
+    schema: string & {
+        readonly __schema: true;
+    };
+    amount: number;
+    currency: import("../../../index.ts").Iso4217AlphabeticalCode;
+    exp: number;
+    nbf: number;
+    conditions?: import("@xylabs/sdk-js").BrandedHash[] | undefined;
+    stackable?: boolean | undefined;
+});
+export declare const asCoupon: {
+    <T>(value: T): (T & ({
+        schema: string & {
+            readonly __schema: true;
+        };
+        amount: number;
+        currency: import("../../../index.ts").Iso4217AlphabeticalCode;
+        exp: number;
+        nbf: number;
+        conditions?: import("@xylabs/sdk-js").BrandedHash[] | undefined;
+        stackable?: boolean | undefined;
+    } | {
+        schema: string & {
+            readonly __schema: true;
+        };
+        percentage: number;
+        exp: number;
+        nbf: number;
+        conditions?: import("@xylabs/sdk-js").BrandedHash[] | undefined;
+        stackable?: boolean | undefined;
+    } | {
+        schema: string & {
+            readonly __schema: true;
+        };
+        amount: number;
+        currency: import("../../../index.ts").Iso4217AlphabeticalCode;
+        exp: number;
+        nbf: number;
+        conditions?: import("@xylabs/sdk-js").BrandedHash[] | undefined;
+        stackable?: boolean | undefined;
+    })) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk-js").ZodFactoryConfig): T & ({
+        schema: string & {
+            readonly __schema: true;
+        };
+        amount: number;
+        currency: import("../../../index.ts").Iso4217AlphabeticalCode;
+        exp: number;
+        nbf: number;
+        conditions?: import("@xylabs/sdk-js").BrandedHash[] | undefined;
+        stackable?: boolean | undefined;
+    } | {
+        schema: string & {
+            readonly __schema: true;
+        };
+        percentage: number;
+        exp: number;
+        nbf: number;
+        conditions?: import("@xylabs/sdk-js").BrandedHash[] | undefined;
+        stackable?: boolean | undefined;
+    } | {
+        schema: string & {
+            readonly __schema: true;
+        };
+        amount: number;
+        currency: import("../../../index.ts").Iso4217AlphabeticalCode;
+        exp: number;
+        nbf: number;
+        conditions?: import("@xylabs/sdk-js").BrandedHash[] | undefined;
+        stackable?: boolean | undefined;
+    });
+};
+export declare const toCoupon: {
+    <T>(value: T): (T & ({
+        schema: string & {
+            readonly __schema: true;
+        };
+        amount: number;
+        currency: import("../../../index.ts").Iso4217AlphabeticalCode;
+        exp: number;
+        nbf: number;
+        conditions?: import("@xylabs/sdk-js").BrandedHash[] | undefined;
+        stackable?: boolean | undefined;
+    } | {
+        schema: string & {
+            readonly __schema: true;
+        };
+        percentage: number;
+        exp: number;
+        nbf: number;
+        conditions?: import("@xylabs/sdk-js").BrandedHash[] | undefined;
+        stackable?: boolean | undefined;
+    } | {
+        schema: string & {
+            readonly __schema: true;
+        };
+        amount: number;
+        currency: import("../../../index.ts").Iso4217AlphabeticalCode;
+        exp: number;
+        nbf: number;
+        conditions?: import("@xylabs/sdk-js").BrandedHash[] | undefined;
+        stackable?: boolean | undefined;
+    })) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk-js").ZodFactoryConfig): T & ({
+        schema: string & {
+            readonly __schema: true;
+        };
+        amount: number;
+        currency: import("../../../index.ts").Iso4217AlphabeticalCode;
+        exp: number;
+        nbf: number;
+        conditions?: import("@xylabs/sdk-js").BrandedHash[] | undefined;
+        stackable?: boolean | undefined;
+    } | {
+        schema: string & {
+            readonly __schema: true;
+        };
+        percentage: number;
+        exp: number;
+        nbf: number;
+        conditions?: import("@xylabs/sdk-js").BrandedHash[] | undefined;
+        stackable?: boolean | undefined;
+    } | {
+        schema: string & {
+            readonly __schema: true;
+        };
+        amount: number;
+        currency: import("../../../index.ts").Iso4217AlphabeticalCode;
+        exp: number;
+        nbf: number;
+        conditions?: import("@xylabs/sdk-js").BrandedHash[] | undefined;
+        stackable?: boolean | undefined;
+    });
+};
 //# sourceMappingURL=Payload.d.ts.map

package/dist/neutral/Discount/Payload/Coupon/Payload.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Payload.d.ts","sourceRoot":"","sources":["../../../../../src/Discount/Payload/Coupon/Payload.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,iBAAiB,EAAE,qBAAqB,EAAE,gBAAgB,EAC3D,MAAM,oBAAoB,CAAA;AAQ3B;;GAEG;AACH,MAAM,MAAM,MAAM,GACd,iBAAiB,GACf,qBAAqB,GACrB,gBAAgB,CAAA;AAEtB;;GAEG;AACH,eAAO,MAAM,QAAQ,GAAI,IAAI,OAAO,sEAGV,CAAA;AAC1B,eAAO,MAAM,QAAQ,uGAAmC,CAAA;AAExD;;GAEG;AACH,eAAO,MAAM,mBAAmB,GAAI,IAAI,OAAO,8XAGV,CAAA;AACrC,eAAO,MAAM,mBAAmB,+ZAA8C,CAAA"}
+{"version":3,"file":"Payload.d.ts","sourceRoot":"","sources":["../../../../../src/Discount/Payload/Coupon/Payload.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAM7B;;GAEG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAIpB,CAAA;AAEF,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA;AAE9C;;GAEG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA0B,CAAA;AAC/C,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAsC,CAAA;AAC3D,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAsC,CAAA"}

package/dist/neutral/Discount/Payload/Coupon/types/Condition.d.ts

@@ -1,4 +1,31 @@
 import type { SchemaPayload } from '@xyo-network/sdk-js';
+import * as z from 'zod/mini';
+/**
+ * The payloads that can be used as conditions for a coupon
+ */
+export declare const ConditionZod: z.ZodMiniCustom<{
+    schema: "network.xyo.schema" & {
+        readonly __schema: true;
+    };
+    definition: {
+        [x: string]: unknown;
+        $id?: string | undefined;
+    };
+    extends?: string | undefined;
+    name?: string | undefined;
+    version?: number | undefined;
+}, {
+    schema: "network.xyo.schema" & {
+        readonly __schema: true;
+    };
+    definition: {
+        [x: string]: unknown;
+        $id?: string | undefined;
+    };
+    extends?: string | undefined;
+    name?: string | undefined;
+    version?: number | undefined;
+}>;
 /**
  * The payloads that can be used as conditions for a coupon
  */
@@ -6,11 +33,68 @@ export type Condition = SchemaPayload;
 /**
  * Identity function for determining if an object is a Condition payload
  */
-export declare const isCondition: (x?: unknown) => x is SchemaPayload;
-export declare const asCondition: import("@xylabs/sdk-js").AsTypeFunction<SchemaPayload>;
-/**
- * Identity function for determining if an object is a Condition payload with sources
-*/
-export declare const isConditionWithSources: (x?: unknown) => x is import("@xyo-network/sdk-js").WithSources<SchemaPayload>;
-export declare const asConditionWithSources: import("@xylabs/sdk-js").AsTypeFunction<import("@xyo-network/sdk-js").WithSources<SchemaPayload>>;
+export declare const isCondition: <T>(value: T) => value is T & {
+    schema: "network.xyo.schema" & {
+        readonly __schema: true;
+    };
+    definition: {
+        [x: string]: unknown;
+        $id?: string | undefined;
+    };
+    extends?: string | undefined;
+    name?: string | undefined;
+    version?: number | undefined;
+};
+export declare const asCondition: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.schema" & {
+            readonly __schema: true;
+        };
+        definition: {
+            [x: string]: unknown;
+            $id?: string | undefined;
+        };
+        extends?: string | undefined;
+        name?: string | undefined;
+        version?: number | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk-js").ZodFactoryConfig): T & {
+        schema: "network.xyo.schema" & {
+            readonly __schema: true;
+        };
+        definition: {
+            [x: string]: unknown;
+            $id?: string | undefined;
+        };
+        extends?: string | undefined;
+        name?: string | undefined;
+        version?: number | undefined;
+    };
+};
+export declare const toCondition: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.schema" & {
+            readonly __schema: true;
+        };
+        definition: {
+            [x: string]: unknown;
+            $id?: string | undefined;
+        };
+        extends?: string | undefined;
+        name?: string | undefined;
+        version?: number | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk-js").ZodFactoryConfig): T & {
+        schema: "network.xyo.schema" & {
+            readonly __schema: true;
+        };
+        definition: {
+            [x: string]: unknown;
+            $id?: string | undefined;
+        };
+        extends?: string | undefined;
+        name?: string | undefined;
+        version?: number | undefined;
+    };
+};
 //# sourceMappingURL=Condition.d.ts.map

package/dist/neutral/Discount/Payload/Coupon/types/Condition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Condition.d.ts","sourceRoot":"","sources":["../../../../../../src/Discount/Payload/Coupon/types/Condition.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAKxD;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,aAAa,CAAA;AAErC;;GAEG;AACH,eAAO,MAAM,WAAW,qCAAiD,CAAA;AACzE,eAAO,MAAM,WAAW,wDAAsC,CAAA;AAE9D;;EAEE;AACF,eAAO,MAAM,sBAAsB,gFAA4D,CAAA;AAC/F,eAAO,MAAM,sBAAsB,mGAAiD,CAAA"}
+{"version":3,"file":"Condition.d.ts","sourceRoot":"","sources":["../../../../../../src/Discount/Payload/Coupon/types/Condition.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAExD,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAE7B;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;EACiF,CAAA;AAE1G;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,aAAa,CAAA;AAErC;;GAEG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;CAA6B,CAAA;AACrD,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;CAA4C,CAAA;AACpE,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;CAA4C,CAAA"}

package/dist/neutral/Discount/Payload/Coupon/types/CouponFields.d.ts

@@ -1,16 +1,12 @@
-import type { Hash } from '@xylabs/sdk-js';
-import type { DurationFields } from '@xyo-network/xns-record-payload-plugins';
+import * as z from 'zod/mini';
 /**
  * The fields that are common across all coupons
  */
-export interface CouponFields extends DurationFields {
-    /**
-     * The conditions that must be met in order for this coupon to be applied
-     */
-    conditions?: Hash[];
-    /**
-     * Whether or not this discount can be stacked with other discounts
-     */
-    stackable?: boolean;
-}
+export declare const CouponFieldsZod: z.ZodMiniObject<{
+    conditions: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk-js").BrandedHash, string>>>>;
+    exp: z.ZodMiniNumber<number>;
+    nbf: z.ZodMiniNumber<number>;
+    stackable: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+}, z.core.$strip>;
+export type CouponFields = z.infer<typeof CouponFieldsZod>;
 //# sourceMappingURL=CouponFields.d.ts.map

package/dist/neutral/Discount/Payload/Coupon/types/CouponFields.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CouponFields.d.ts","sourceRoot":"","sources":["../../../../../../src/Discount/Payload/Coupon/types/CouponFields.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yCAAyC,CAAA;AAE7E;;GAEG;AACH,MAAM,WAAW,YAAa,SAAQ,cAAc;IAClD;;OAEG;IACH,UAAU,CAAC,EAAE,IAAI,EAAE,CAAA;IACnB;;OAEG;IACH,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB"}
+{"version":3,"file":"CouponFields.d.ts","sourceRoot":"","sources":["../../../../../../src/Discount/Payload/Coupon/types/CouponFields.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAE7B;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;iBAiB1B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA"}

package/dist/neutral/Discount/Payload/Discount.d.ts

@@ -1,25 +1,64 @@
-import type { Payload, WithSources } from '@xyo-network/sdk-js';
-import type { AmountFields } from '../../Amount/index.ts';
+import * as z from 'zod/mini';
 export declare const DiscountSchema: "network.xyo.payments.discount" & {
     readonly __schema: true;
 };
 export type DiscountSchema = typeof DiscountSchema;
-export interface DiscountFields extends AmountFields {
-}
+export declare const DiscountFieldsZod: z.ZodMiniObject<{
+    amount: z.ZodMiniNumber<number>;
+    currency: z.ZodMiniCustom<import("../../Amount/Iso4217Currency.ts").Iso4217AlphabeticalCode, import("../../Amount/Iso4217Currency.ts").Iso4217AlphabeticalCode>;
+}, z.core.$strip>;
+export type DiscountFields = z.infer<typeof DiscountFieldsZod>;
 /**
  * The result of a discount
  */
-export type Discount = Payload<DiscountFields, DiscountSchema>;
+export declare const DiscountZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<"network.xyo.payments.discount" & {
+        readonly __schema: true;
+    }>;
+    amount: z.ZodMiniNumber<number>;
+    currency: z.ZodMiniCustom<import("../../Amount/Iso4217Currency.ts").Iso4217AlphabeticalCode, import("../../Amount/Iso4217Currency.ts").Iso4217AlphabeticalCode>;
+}, z.core.$strip>;
+export type Discount = z.infer<typeof DiscountZod>;
 /**
  * Identity function for determining if an object is an Discount
  */
-export declare const isDiscount: (x?: unknown) => x is Discount;
-export declare const asDiscount: import("@xylabs/sdk-js").AsTypeFunction<Discount>;
-export declare const asOptionalDiscount: (value: import("@xylabs/sdk-js").AnyNonPromise) => Discount | undefined;
-/**
- * Identity function for determining if an object is an Discount with sources
- */
-export declare const isDiscountWithSources: (x?: unknown) => x is WithSources<Discount>;
-export declare const asDiscountWithSources: import("@xylabs/sdk-js").AsTypeFunction<WithSources<Discount>>;
-export declare const asOptionalDiscountWithSources: (value: import("@xylabs/sdk-js").AnyNonPromise) => WithSources<Discount> | undefined;
+export declare const isDiscount: <T>(value: T) => value is T & {
+    schema: "network.xyo.payments.discount" & {
+        readonly __schema: true;
+    };
+    amount: number;
+    currency: import("../../Amount/Iso4217Currency.ts").Iso4217AlphabeticalCode;
+};
+export declare const asDiscount: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.payments.discount" & {
+            readonly __schema: true;
+        };
+        amount: number;
+        currency: import("../../Amount/Iso4217Currency.ts").Iso4217AlphabeticalCode;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk-js").ZodFactoryConfig): T & {
+        schema: "network.xyo.payments.discount" & {
+            readonly __schema: true;
+        };
+        amount: number;
+        currency: import("../../Amount/Iso4217Currency.ts").Iso4217AlphabeticalCode;
+    };
+};
+export declare const toDiscount: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.payments.discount" & {
+            readonly __schema: true;
+        };
+        amount: number;
+        currency: import("../../Amount/Iso4217Currency.ts").Iso4217AlphabeticalCode;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk-js").ZodFactoryConfig): T & {
+        schema: "network.xyo.payments.discount" & {
+            readonly __schema: true;
+        };
+        amount: number;
+        currency: import("../../Amount/Iso4217Currency.ts").Iso4217AlphabeticalCode;
+    };
+};
 //# sourceMappingURL=Discount.d.ts.map

package/dist/neutral/Discount/Payload/Discount.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Discount.d.ts","sourceRoot":"","sources":["../../../../src/Discount/Payload/Discount.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AAO/D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAEzD,eAAO,MAAM,cAAc;;CAAkD,CAAA;AAC7E,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAA;AAElD,MAAM,WAAW,cAAe,SAAQ,YAAY;CAAI;AAExD;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,OAAO,CAAC,cAAc,EAAE,cAAc,CAAC,CAAA;AAE9D;;GAEG;AACH,eAAO,MAAM,UAAU,gCAAkD,CAAA;AACzE,eAAO,MAAM,UAAU,mDAA+C,CAAA;AACtE,eAAO,MAAM,kBAAkB,yEAAuD,CAAA;AAEtF;;GAEG;AACH,eAAO,MAAM,qBAAqB,6CAA6D,CAAA;AAC/F,eAAO,MAAM,qBAAqB,gEAAuE,CAAA;AACzG,eAAO,MAAM,6BAA6B,sFAA+E,CAAA"}
+{"version":3,"file":"Discount.d.ts","sourceRoot":"","sources":["../../../../src/Discount/Payload/Discount.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAI7B,eAAO,MAAM,cAAc;;CAAkD,CAAA;AAC7E,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAA;AAElD,eAAO,MAAM,iBAAiB;;;iBAAyC,CAAA;AAEvE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE9D;;GAEG;AACH,eAAO,MAAM,WAAW;;;;;;iBAA+E,CAAA;AAEvG,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAElD;;GAEG;AACH,eAAO,MAAM,UAAU;;;;;;CAA4B,CAAA;AACnD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;CAA0C,CAAA;AACjE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;CAA0C,CAAA"}

package/dist/neutral/Escrow/Outcome.d.ts

@@ -1,5 +1,4 @@
-import type { Hash } from '@xylabs/sdk-js';
-import type { PayloadWithSources, WithSources } from '@xyo-network/sdk-js';
+import * as z from 'zod/mini';
 export declare const EscrowOutcomeSchema: string & {
     readonly __schema: true;
 };
@@ -7,25 +6,73 @@ export type EscrowOutcomeSchema = typeof EscrowOutcomeSchema;
 /**
  * The possible outcomes for an escrow
  */
-export type EscrowOutcomes = 'fulfilled' | 'expired';
-export interface EscrowOutcomeFields {
-    outcome: EscrowOutcomes;
-    terms: Hash;
-}
+export declare const EscrowOutcomesZod: z.ZodMiniEnum<{
+    fulfilled: "fulfilled";
+    expired: "expired";
+}>;
+export type EscrowOutcomes = z.infer<typeof EscrowOutcomesZod>;
+export declare const EscrowOutcomeFieldsZod: z.ZodMiniObject<{
+    outcome: z.ZodMiniEnum<{
+        fulfilled: "fulfilled";
+        expired: "expired";
+    }>;
+    terms: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk-js").BrandedHash, string>>;
+}, z.core.$strip>;
+export type EscrowOutcomeFields = z.infer<typeof EscrowOutcomeFieldsZod>;
 /**
  * The terms of an escrow
  */
-export type EscrowOutcome = PayloadWithSources<EscrowOutcomeFields, EscrowOutcomeSchema>;
+export declare const EscrowOutcomeZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<string & {
+        readonly __schema: true;
+    }>;
+    outcome: z.ZodMiniEnum<{
+        fulfilled: "fulfilled";
+        expired: "expired";
+    }>;
+    terms: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk-js").BrandedHash, string>>;
+}, z.core.$strip>;
+export type EscrowOutcome = z.infer<typeof EscrowOutcomeZod>;
 /**
  * Identity function for determining if an object is an EscrowOutcome
  */
-export declare const isEscrowOutcome: (x?: unknown) => x is EscrowOutcome;
-export declare const asEscrowOutcome: import("@xylabs/sdk-js").AsTypeFunction<EscrowOutcome>;
-export declare const asOptionalEscrowOutcome: (value: import("@xylabs/sdk-js").AnyNonPromise) => EscrowOutcome | undefined;
-/**
- * Identity function for determining if an object is an EscrowOutcome with sources
- */
-export declare const isEscrowOutcomeWithSources: (x?: unknown) => x is WithSources<EscrowOutcome>;
-export declare const asEscrowOutcomeWithSources: (value: import("@xylabs/sdk-js").AnyNonPromise) => WithSources<EscrowOutcome> | undefined;
-export declare const asOptionalEscrowOutcomeWithSources: (value: import("@xylabs/sdk-js").AnyNonPromise) => WithSources<EscrowOutcome> | undefined;
+export declare const isEscrowOutcome: <T>(value: T) => value is T & {
+    schema: string & {
+        readonly __schema: true;
+    };
+    outcome: "fulfilled" | "expired";
+    terms: import("@xylabs/sdk-js").BrandedHash;
+};
+export declare const asEscrowOutcome: {
+    <T>(value: T): (T & {
+        schema: string & {
+            readonly __schema: true;
+        };
+        outcome: "fulfilled" | "expired";
+        terms: import("@xylabs/sdk-js").BrandedHash;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk-js").ZodFactoryConfig): T & {
+        schema: string & {
+            readonly __schema: true;
+        };
+        outcome: "fulfilled" | "expired";
+        terms: import("@xylabs/sdk-js").BrandedHash;
+    };
+};
+export declare const toEscrowOutcome: {
+    <T>(value: T): (T & {
+        schema: string & {
+            readonly __schema: true;
+        };
+        outcome: "fulfilled" | "expired";
+        terms: import("@xylabs/sdk-js").BrandedHash;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk-js").ZodFactoryConfig): T & {
+        schema: string & {
+            readonly __schema: true;
+        };
+        outcome: "fulfilled" | "expired";
+        terms: import("@xylabs/sdk-js").BrandedHash;
+    };
+};
 //# sourceMappingURL=Outcome.d.ts.map

package/dist/neutral/Escrow/Outcome.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Outcome.d.ts","sourceRoot":"","sources":["../../../src/Escrow/Outcome.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAA;AAE1C,OAAO,KAAK,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AAS1E,eAAO,MAAM,mBAAmB;;CAA4C,CAAA;AAC5E,MAAM,MAAM,mBAAmB,GAAG,OAAO,mBAAmB,CAAA;AAE5D;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,WAAW,GAAG,SAAS,CAAA;AAEpD,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,cAAc,CAAA;IACvB,KAAK,EAAE,IAAI,CAAA;CACZ;AAED;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,kBAAkB,CAAC,mBAAmB,EAAE,mBAAmB,CAAC,CAAA;AAExF;;GAEG;AACH,eAAO,MAAM,eAAe,qCAA4D,CAAA;AACxF,eAAO,MAAM,eAAe,wDAAyD,CAAA;AACrF,eAAO,MAAM,uBAAuB,8EAAiE,CAAA;AAErG;;GAEG;AACH,eAAO,MAAM,0BAA0B,kDAAuE,CAAA;AAC9G,eAAO,MAAM,0BAA0B,2FAAyF,CAAA;AAChI,eAAO,MAAM,kCAAkC,2FAAyF,CAAA"}
+{"version":3,"file":"Outcome.d.ts","sourceRoot":"","sources":["../../../src/Escrow/Outcome.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAI7B,eAAO,MAAM,mBAAmB;;CAA4C,CAAA;AAC5E,MAAM,MAAM,mBAAmB,GAAG,OAAO,mBAAmB,CAAA;AAE5D;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;EAAmC,CAAA;AAEjE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE9D,eAAO,MAAM,sBAAsB;;;;;;iBAGjC,CAAA;AAEF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAExE;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;iBAAyF,CAAA;AAEtH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAE5D;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;;CAAiC,CAAA;AAC7D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;CAAoD,CAAA;AAChF,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;CAAoD,CAAA"}