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

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

@@ -1,26 +1,92 @@
-import type { Payload, WithSources } from '@xyo-network/sdk-js';
-import type { AmountFields } from '../../../../Amount/index.ts';
-import type { CouponFields } from '../types/index.ts';
+import * as z from 'zod/mini';
 export declare const FixedPriceCouponSchema: string & {
     readonly __schema: true;
 };
 export type FixedPriceCouponSchema = typeof FixedPriceCouponSchema;
-export interface FixedPriceCouponFields extends CouponFields, AmountFields {
-}
+export declare const FixedPriceCouponFieldsZod: z.ZodMiniObject<{
+    amount: z.ZodMiniNumber<number>;
+    currency: z.ZodMiniCustom<import("../../../../Amount/Iso4217Currency.ts").Iso4217AlphabeticalCode, import("../../../../Amount/Iso4217Currency.ts").Iso4217AlphabeticalCode>;
+    conditions: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>>>;
+    exp: z.ZodMiniNumber<number>;
+    nbf: z.ZodMiniNumber<number>;
+    stackable: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+}, z.core.$strip>;
+export type FixedPriceCouponFields = z.infer<typeof FixedPriceCouponFieldsZod>;
 /**
  * A coupon that provides a fixed total price
  */
-export type FixedPriceCoupon = Payload<FixedPriceCouponFields, FixedPriceCouponSchema>;
+export declare const FixedPriceCouponZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<string & {
+        readonly __schema: true;
+    }>;
+    amount: z.ZodMiniNumber<number>;
+    currency: z.ZodMiniCustom<import("../../../../Amount/Iso4217Currency.ts").Iso4217AlphabeticalCode, import("../../../../Amount/Iso4217Currency.ts").Iso4217AlphabeticalCode>;
+    conditions: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>>>;
+    exp: z.ZodMiniNumber<number>;
+    nbf: z.ZodMiniNumber<number>;
+    stackable: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+}, z.core.$strip>;
+export type FixedPriceCoupon = z.infer<typeof FixedPriceCouponZod>;
 /**
  * Identity function for determining if an object is an FixedPriceCoupon
  */
-export declare const isFixedPriceCoupon: (x?: unknown) => x is FixedPriceCoupon;
-export declare const asFixedPriceCoupon: import("@xylabs/sdk-js").AsTypeFunction<FixedPriceCoupon>;
-export declare const asOptionalFixedPriceCoupon: (value: import("@xylabs/sdk-js").AnyNonPromise) => FixedPriceCoupon | undefined;
-/**
- * Identity function for determining if an object is an FixedPriceCoupon with sources
-*/
-export declare const isFixedPriceCouponWithSources: (x?: unknown) => x is WithSources<WithSources<FixedPriceCoupon>>;
-export declare const asFixedPriceCouponWithSources: import("@xylabs/sdk-js").AsTypeFunction<WithSources<FixedPriceCoupon>>;
-export declare const asOptionalFixedPriceCouponWithSources: (value: import("@xylabs/sdk-js").AnyNonPromise) => WithSources<FixedPriceCoupon> | undefined;
+export declare const isFixedPriceCoupon: <T>(value: T) => value is T & {
+    schema: string & {
+        readonly __schema: true;
+    };
+    amount: number;
+    currency: import("../../../../Amount/Iso4217Currency.ts").Iso4217AlphabeticalCode;
+    exp: number;
+    nbf: number;
+    conditions?: import("@xylabs/sdk").BrandedHash[] | undefined;
+    stackable?: boolean | undefined;
+};
+export declare const asFixedPriceCoupon: {
+    <T>(value: T): (T & {
+        schema: string & {
+            readonly __schema: true;
+        };
+        amount: number;
+        currency: import("../../../../Amount/Iso4217Currency.ts").Iso4217AlphabeticalCode;
+        exp: number;
+        nbf: number;
+        conditions?: import("@xylabs/sdk").BrandedHash[] | undefined;
+        stackable?: boolean | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        schema: string & {
+            readonly __schema: true;
+        };
+        amount: number;
+        currency: import("../../../../Amount/Iso4217Currency.ts").Iso4217AlphabeticalCode;
+        exp: number;
+        nbf: number;
+        conditions?: import("@xylabs/sdk").BrandedHash[] | undefined;
+        stackable?: boolean | undefined;
+    };
+};
+export declare const toFixedPriceCoupon: {
+    <T>(value: T): (T & {
+        schema: string & {
+            readonly __schema: true;
+        };
+        amount: number;
+        currency: import("../../../../Amount/Iso4217Currency.ts").Iso4217AlphabeticalCode;
+        exp: number;
+        nbf: number;
+        conditions?: import("@xylabs/sdk").BrandedHash[] | undefined;
+        stackable?: boolean | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        schema: string & {
+            readonly __schema: true;
+        };
+        amount: number;
+        currency: import("../../../../Amount/Iso4217Currency.ts").Iso4217AlphabeticalCode;
+        exp: number;
+        nbf: number;
+        conditions?: import("@xylabs/sdk").BrandedHash[] | undefined;
+        stackable?: boolean | undefined;
+    };
+};
 //# sourceMappingURL=FixedPrice.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"FixedPrice.d.ts","sourceRoot":"","sources":["../../../../../../src/Discount/Payload/Coupon/Coupons/FixedPrice.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AAO/D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAA;AAE/D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAErD,eAAO,MAAM,sBAAsB;;CAAgD,CAAA;AACnF,MAAM,MAAM,sBAAsB,GAAG,OAAO,sBAAsB,CAAA;AAElE,MAAM,WAAW,sBAAuB,SAAQ,YAAY,EAAE,YAAY;CAAI;AAE9E;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,OAAO,CAAC,sBAAsB,EAAE,sBAAsB,CAAC,CAAA;AAEtF;;GAEG;AACH,eAAO,MAAM,kBAAkB,wCAAkE,CAAA;AACjG,eAAO,MAAM,kBAAkB,2DAA+D,CAAA;AAC9F,eAAO,MAAM,0BAA0B,iFAAuE,CAAA;AAE9G;;EAEE;AACF,eAAO,MAAM,6BAA6B,kEAA0F,CAAA;AACpI,eAAO,MAAM,6BAA6B,wEAAuF,CAAA;AACjI,eAAO,MAAM,qCAAqC,8FAA+F,CAAA"}
+{"version":3,"file":"FixedPrice.d.ts","sourceRoot":"","sources":["../../../../../../src/Discount/Payload/Coupon/Coupons/FixedPrice.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAM7B,eAAO,MAAM,sBAAsB;;CAAgD,CAAA;AACnF,MAAM,MAAM,sBAAsB,GAAG,OAAO,sBAAsB,CAAA;AAElE,eAAO,MAAM,yBAAyB;;;;;;;iBAGpC,CAAA;AAEF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE9E;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;iBAA+F,CAAA;AAE/H,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAElE;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;CAAoC,CAAA;AACnE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;CAA0D,CAAA;AACzF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;CAA0D,CAAA"}

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").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").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").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").BrandedHash[] | undefined;
+    stackable?: boolean | undefined;
+} | {
+    schema: string & {
+        readonly __schema: true;
+    };
+    percentage: number;
+    exp: number;
+    nbf: number;
+    conditions?: import("@xylabs/sdk").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").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").BrandedHash[] | undefined;
+        stackable?: boolean | undefined;
+    } | {
+        schema: string & {
+            readonly __schema: true;
+        };
+        percentage: number;
+        exp: number;
+        nbf: number;
+        conditions?: import("@xylabs/sdk").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").BrandedHash[] | undefined;
+        stackable?: boolean | undefined;
+    })) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & ({
+        schema: string & {
+            readonly __schema: true;
+        };
+        amount: number;
+        currency: import("../../../index.ts").Iso4217AlphabeticalCode;
+        exp: number;
+        nbf: number;
+        conditions?: import("@xylabs/sdk").BrandedHash[] | undefined;
+        stackable?: boolean | undefined;
+    } | {
+        schema: string & {
+            readonly __schema: true;
+        };
+        percentage: number;
+        exp: number;
+        nbf: number;
+        conditions?: import("@xylabs/sdk").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").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").BrandedHash[] | undefined;
+        stackable?: boolean | undefined;
+    } | {
+        schema: string & {
+            readonly __schema: true;
+        };
+        percentage: number;
+        exp: number;
+        nbf: number;
+        conditions?: import("@xylabs/sdk").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").BrandedHash[] | undefined;
+        stackable?: boolean | undefined;
+    })) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & ({
+        schema: string & {
+            readonly __schema: true;
+        };
+        amount: number;
+        currency: import("../../../index.ts").Iso4217AlphabeticalCode;
+        exp: number;
+        nbf: number;
+        conditions?: import("@xylabs/sdk").BrandedHash[] | undefined;
+        stackable?: boolean | undefined;
+    } | {
+        schema: string & {
+            readonly __schema: true;
+        };
+        percentage: number;
+        exp: number;
+        nbf: number;
+        conditions?: import("@xylabs/sdk").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").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 type { SchemaPayload } from '@xyo-network/sdk';
+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").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").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,kBAAkB,CAAA;AAErD,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").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").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").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"}