@voyantjs/pricing 0.2.0 → 0.3.1

package/dist/validation-public.d.ts

@@ -0,0 +1,410 @@
+import { z } from "zod";
+export declare const publicProductPricingQuerySchema: z.ZodObject<{
+    catalogId: z.ZodOptional<z.ZodString>;
+    optionId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const publicAvailabilitySnapshotQuerySchema: z.ZodObject<{
+    optionId: z.ZodOptional<z.ZodString>;
+    dateFrom: z.ZodOptional<z.ZodString>;
+    dateTo: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        open: "open";
+        closed: "closed";
+        sold_out: "sold_out";
+        cancelled: "cancelled";
+    }>>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export declare const publicPriceCatalogSchema: z.ZodObject<{
+    id: z.ZodString;
+    code: z.ZodString;
+    name: z.ZodString;
+    currencyCode: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const publicPricingTierSchema: z.ZodObject<{
+    id: z.ZodString;
+    minQuantity: z.ZodNumber;
+    maxQuantity: z.ZodNullable<z.ZodNumber>;
+    sellAmountCents: z.ZodNullable<z.ZodNumber>;
+    sortOrder: z.ZodNumber;
+}, z.core.$strip>;
+export declare const publicOptionUnitPriceSchema: z.ZodObject<{
+    id: z.ZodString;
+    unitId: z.ZodString;
+    unitName: z.ZodString;
+    unitType: z.ZodEnum<{
+        group: "group";
+        room: "room";
+        vehicle: "vehicle";
+        service: "service";
+        other: "other";
+        person: "person";
+    }>;
+    pricingMode: z.ZodEnum<{
+        per_person: "per_person";
+        per_booking: "per_booking";
+        free: "free";
+        on_request: "on_request";
+        per_unit: "per_unit";
+        included: "included";
+    }>;
+    sellAmountCents: z.ZodNullable<z.ZodNumber>;
+    minQuantity: z.ZodNullable<z.ZodNumber>;
+    maxQuantity: z.ZodNullable<z.ZodNumber>;
+    pricingCategoryId: z.ZodNullable<z.ZodString>;
+    sortOrder: z.ZodNumber;
+    tiers: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        minQuantity: z.ZodNumber;
+        maxQuantity: z.ZodNullable<z.ZodNumber>;
+        sellAmountCents: z.ZodNullable<z.ZodNumber>;
+        sortOrder: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const publicStartTimeAdjustmentSchema: z.ZodObject<{
+    id: z.ZodString;
+    startTimeId: z.ZodString;
+    label: z.ZodNullable<z.ZodString>;
+    startTimeLocal: z.ZodString;
+    ruleMode: z.ZodEnum<{
+        included: "included";
+        excluded: "excluded";
+        override: "override";
+        adjustment: "adjustment";
+    }>;
+    adjustmentType: z.ZodNullable<z.ZodEnum<{
+        fixed: "fixed";
+        percentage: "percentage";
+    }>>;
+    sellAdjustmentCents: z.ZodNullable<z.ZodNumber>;
+    adjustmentBasisPoints: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const publicOptionPricingRuleSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    pricingMode: z.ZodEnum<{
+        per_person: "per_person";
+        per_booking: "per_booking";
+        starting_from: "starting_from";
+        free: "free";
+        on_request: "on_request";
+    }>;
+    baseSellAmountCents: z.ZodNullable<z.ZodNumber>;
+    minPerBooking: z.ZodNullable<z.ZodNumber>;
+    maxPerBooking: z.ZodNullable<z.ZodNumber>;
+    isDefault: z.ZodBoolean;
+    cancellationPolicyId: z.ZodNullable<z.ZodString>;
+    unitPrices: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        unitId: z.ZodString;
+        unitName: z.ZodString;
+        unitType: z.ZodEnum<{
+            group: "group";
+            room: "room";
+            vehicle: "vehicle";
+            service: "service";
+            other: "other";
+            person: "person";
+        }>;
+        pricingMode: z.ZodEnum<{
+            per_person: "per_person";
+            per_booking: "per_booking";
+            free: "free";
+            on_request: "on_request";
+            per_unit: "per_unit";
+            included: "included";
+        }>;
+        sellAmountCents: z.ZodNullable<z.ZodNumber>;
+        minQuantity: z.ZodNullable<z.ZodNumber>;
+        maxQuantity: z.ZodNullable<z.ZodNumber>;
+        pricingCategoryId: z.ZodNullable<z.ZodString>;
+        sortOrder: z.ZodNumber;
+        tiers: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            minQuantity: z.ZodNumber;
+            maxQuantity: z.ZodNullable<z.ZodNumber>;
+            sellAmountCents: z.ZodNullable<z.ZodNumber>;
+            sortOrder: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    startTimeAdjustments: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        startTimeId: z.ZodString;
+        label: z.ZodNullable<z.ZodString>;
+        startTimeLocal: z.ZodString;
+        ruleMode: z.ZodEnum<{
+            included: "included";
+            excluded: "excluded";
+            override: "override";
+            adjustment: "adjustment";
+        }>;
+        adjustmentType: z.ZodNullable<z.ZodEnum<{
+            fixed: "fixed";
+            percentage: "percentage";
+        }>>;
+        sellAdjustmentCents: z.ZodNullable<z.ZodNumber>;
+        adjustmentBasisPoints: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const publicPricedOptionSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+        active: "active";
+        draft: "draft";
+        archived: "archived";
+    }>;
+    isDefault: z.ZodBoolean;
+    bookingMode: z.ZodEnum<{
+        other: "other";
+        date: "date";
+        open: "open";
+        date_time: "date_time";
+        stay: "stay";
+        transfer: "transfer";
+        itinerary: "itinerary";
+    }>;
+    capacityMode: z.ZodEnum<{
+        on_request: "on_request";
+        free_sale: "free_sale";
+        limited: "limited";
+    }>;
+    pricingRules: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        pricingMode: z.ZodEnum<{
+            per_person: "per_person";
+            per_booking: "per_booking";
+            starting_from: "starting_from";
+            free: "free";
+            on_request: "on_request";
+        }>;
+        baseSellAmountCents: z.ZodNullable<z.ZodNumber>;
+        minPerBooking: z.ZodNullable<z.ZodNumber>;
+        maxPerBooking: z.ZodNullable<z.ZodNumber>;
+        isDefault: z.ZodBoolean;
+        cancellationPolicyId: z.ZodNullable<z.ZodString>;
+        unitPrices: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            unitId: z.ZodString;
+            unitName: z.ZodString;
+            unitType: z.ZodEnum<{
+                group: "group";
+                room: "room";
+                vehicle: "vehicle";
+                service: "service";
+                other: "other";
+                person: "person";
+            }>;
+            pricingMode: z.ZodEnum<{
+                per_person: "per_person";
+                per_booking: "per_booking";
+                free: "free";
+                on_request: "on_request";
+                per_unit: "per_unit";
+                included: "included";
+            }>;
+            sellAmountCents: z.ZodNullable<z.ZodNumber>;
+            minQuantity: z.ZodNullable<z.ZodNumber>;
+            maxQuantity: z.ZodNullable<z.ZodNumber>;
+            pricingCategoryId: z.ZodNullable<z.ZodString>;
+            sortOrder: z.ZodNumber;
+            tiers: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                minQuantity: z.ZodNumber;
+                maxQuantity: z.ZodNullable<z.ZodNumber>;
+                sellAmountCents: z.ZodNullable<z.ZodNumber>;
+                sortOrder: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        startTimeAdjustments: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            startTimeId: z.ZodString;
+            label: z.ZodNullable<z.ZodString>;
+            startTimeLocal: z.ZodString;
+            ruleMode: z.ZodEnum<{
+                included: "included";
+                excluded: "excluded";
+                override: "override";
+                adjustment: "adjustment";
+            }>;
+            adjustmentType: z.ZodNullable<z.ZodEnum<{
+                fixed: "fixed";
+                percentage: "percentage";
+            }>>;
+            sellAdjustmentCents: z.ZodNullable<z.ZodNumber>;
+            adjustmentBasisPoints: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const publicProductPricingSnapshotSchema: z.ZodObject<{
+    productId: z.ZodString;
+    catalog: z.ZodObject<{
+        id: z.ZodString;
+        code: z.ZodString;
+        name: z.ZodString;
+        currencyCode: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    options: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        status: z.ZodEnum<{
+            active: "active";
+            draft: "draft";
+            archived: "archived";
+        }>;
+        isDefault: z.ZodBoolean;
+        bookingMode: z.ZodEnum<{
+            other: "other";
+            date: "date";
+            open: "open";
+            date_time: "date_time";
+            stay: "stay";
+            transfer: "transfer";
+            itinerary: "itinerary";
+        }>;
+        capacityMode: z.ZodEnum<{
+            on_request: "on_request";
+            free_sale: "free_sale";
+            limited: "limited";
+        }>;
+        pricingRules: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            description: z.ZodNullable<z.ZodString>;
+            pricingMode: z.ZodEnum<{
+                per_person: "per_person";
+                per_booking: "per_booking";
+                starting_from: "starting_from";
+                free: "free";
+                on_request: "on_request";
+            }>;
+            baseSellAmountCents: z.ZodNullable<z.ZodNumber>;
+            minPerBooking: z.ZodNullable<z.ZodNumber>;
+            maxPerBooking: z.ZodNullable<z.ZodNumber>;
+            isDefault: z.ZodBoolean;
+            cancellationPolicyId: z.ZodNullable<z.ZodString>;
+            unitPrices: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                unitId: z.ZodString;
+                unitName: z.ZodString;
+                unitType: z.ZodEnum<{
+                    group: "group";
+                    room: "room";
+                    vehicle: "vehicle";
+                    service: "service";
+                    other: "other";
+                    person: "person";
+                }>;
+                pricingMode: z.ZodEnum<{
+                    per_person: "per_person";
+                    per_booking: "per_booking";
+                    free: "free";
+                    on_request: "on_request";
+                    per_unit: "per_unit";
+                    included: "included";
+                }>;
+                sellAmountCents: z.ZodNullable<z.ZodNumber>;
+                minQuantity: z.ZodNullable<z.ZodNumber>;
+                maxQuantity: z.ZodNullable<z.ZodNumber>;
+                pricingCategoryId: z.ZodNullable<z.ZodString>;
+                sortOrder: z.ZodNumber;
+                tiers: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    minQuantity: z.ZodNumber;
+                    maxQuantity: z.ZodNullable<z.ZodNumber>;
+                    sellAmountCents: z.ZodNullable<z.ZodNumber>;
+                    sortOrder: z.ZodNumber;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            startTimeAdjustments: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                startTimeId: z.ZodString;
+                label: z.ZodNullable<z.ZodString>;
+                startTimeLocal: z.ZodString;
+                ruleMode: z.ZodEnum<{
+                    included: "included";
+                    excluded: "excluded";
+                    override: "override";
+                    adjustment: "adjustment";
+                }>;
+                adjustmentType: z.ZodNullable<z.ZodEnum<{
+                    fixed: "fixed";
+                    percentage: "percentage";
+                }>>;
+                sellAdjustmentCents: z.ZodNullable<z.ZodNumber>;
+                adjustmentBasisPoints: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const publicAvailabilityStartTimeSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodNullable<z.ZodString>;
+    startTimeLocal: z.ZodString;
+    durationMinutes: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const publicAvailabilitySlotSchema: z.ZodObject<{
+    id: z.ZodString;
+    optionId: z.ZodNullable<z.ZodString>;
+    dateLocal: z.ZodString;
+    startsAt: z.ZodString;
+    endsAt: z.ZodNullable<z.ZodString>;
+    timezone: z.ZodString;
+    status: z.ZodEnum<{
+        open: "open";
+        closed: "closed";
+        sold_out: "sold_out";
+        cancelled: "cancelled";
+    }>;
+    unlimited: z.ZodBoolean;
+    remainingPax: z.ZodNullable<z.ZodNumber>;
+    remainingResources: z.ZodNullable<z.ZodNumber>;
+    pastCutoff: z.ZodBoolean;
+    tooEarly: z.ZodBoolean;
+    startTime: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodNullable<z.ZodString>;
+        startTimeLocal: z.ZodString;
+        durationMinutes: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const publicAvailabilitySnapshotSchema: z.ZodObject<{
+    productId: z.ZodString;
+    slots: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        optionId: z.ZodNullable<z.ZodString>;
+        dateLocal: z.ZodString;
+        startsAt: z.ZodString;
+        endsAt: z.ZodNullable<z.ZodString>;
+        timezone: z.ZodString;
+        status: z.ZodEnum<{
+            open: "open";
+            closed: "closed";
+            sold_out: "sold_out";
+            cancelled: "cancelled";
+        }>;
+        unlimited: z.ZodBoolean;
+        remainingPax: z.ZodNullable<z.ZodNumber>;
+        remainingResources: z.ZodNullable<z.ZodNumber>;
+        pastCutoff: z.ZodBoolean;
+        tooEarly: z.ZodBoolean;
+        startTime: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodNullable<z.ZodString>;
+            startTimeLocal: z.ZodString;
+            durationMinutes: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+    limit: z.ZodNumber;
+    offset: z.ZodNumber;
+}, z.core.$strip>;
+export type PublicProductPricingQuery = z.infer<typeof publicProductPricingQuerySchema>;
+export type PublicAvailabilitySnapshotQuery = z.infer<typeof publicAvailabilitySnapshotQuerySchema>;
+//# sourceMappingURL=validation-public.d.ts.map

package/dist/validation-public.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation-public.d.ts","sourceRoot":"","sources":["../src/validation-public.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAWvB,eAAO,MAAM,+BAA+B;;;iBAG1C,CAAA;AAEF,eAAO,MAAM,qCAAqC;;;;;;;;;;;;iBAOhD,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;iBAKnC,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;;;iBAMlC,CAAA;AAEF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAYtC,CAAA;AAEF,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;iBAS1C,CAAA;AAEF,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAYxC,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBASnC,CAAA;AAEF,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAI7C,CAAA;AAEF,eAAO,MAAM,iCAAiC;;;;;iBAK5C,CAAA;AAEF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;iBAcvC,CAAA;AAEF,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAM3C,CAAA;AAEF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AACvF,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qCAAqC,CAAC,CAAA"}

package/dist/validation-public.js

@@ -0,0 +1,109 @@
+import { availabilitySlotStatusSchema } from "@voyantjs/availability/validation";
+import { optionUnitTypeSchema, productBookingModeSchema, productCapacityModeSchema, productOptionStatusSchema, } from "@voyantjs/products/validation";
+import { z } from "zod";
+import { optionPricingModeSchema, optionStartTimeRuleModeSchema, optionUnitPricingModeSchema, priceAdjustmentTypeSchema, } from "./validation-shared.js";
+const isoDateSchema = z.string().date();
+export const publicProductPricingQuerySchema = z.object({
+    catalogId: z.string().optional(),
+    optionId: z.string().optional(),
+});
+export const publicAvailabilitySnapshotQuerySchema = z.object({
+    optionId: z.string().optional(),
+    dateFrom: isoDateSchema.optional(),
+    dateTo: isoDateSchema.optional(),
+    status: availabilitySlotStatusSchema.optional(),
+    limit: z.coerce.number().int().min(1).max(200).default(100),
+    offset: z.coerce.number().int().min(0).default(0),
+});
+export const publicPriceCatalogSchema = z.object({
+    id: z.string(),
+    code: z.string(),
+    name: z.string(),
+    currencyCode: z.string().nullable(),
+});
+export const publicPricingTierSchema = z.object({
+    id: z.string(),
+    minQuantity: z.number().int(),
+    maxQuantity: z.number().int().nullable(),
+    sellAmountCents: z.number().int().nullable(),
+    sortOrder: z.number().int(),
+});
+export const publicOptionUnitPriceSchema = z.object({
+    id: z.string(),
+    unitId: z.string(),
+    unitName: z.string(),
+    unitType: optionUnitTypeSchema,
+    pricingMode: optionUnitPricingModeSchema,
+    sellAmountCents: z.number().int().nullable(),
+    minQuantity: z.number().int().nullable(),
+    maxQuantity: z.number().int().nullable(),
+    pricingCategoryId: z.string().nullable(),
+    sortOrder: z.number().int(),
+    tiers: z.array(publicPricingTierSchema),
+});
+export const publicStartTimeAdjustmentSchema = z.object({
+    id: z.string(),
+    startTimeId: z.string(),
+    label: z.string().nullable(),
+    startTimeLocal: z.string(),
+    ruleMode: optionStartTimeRuleModeSchema,
+    adjustmentType: priceAdjustmentTypeSchema.nullable(),
+    sellAdjustmentCents: z.number().int().nullable(),
+    adjustmentBasisPoints: z.number().int().nullable(),
+});
+export const publicOptionPricingRuleSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    description: z.string().nullable(),
+    pricingMode: optionPricingModeSchema,
+    baseSellAmountCents: z.number().int().nullable(),
+    minPerBooking: z.number().int().nullable(),
+    maxPerBooking: z.number().int().nullable(),
+    isDefault: z.boolean(),
+    cancellationPolicyId: z.string().nullable(),
+    unitPrices: z.array(publicOptionUnitPriceSchema),
+    startTimeAdjustments: z.array(publicStartTimeAdjustmentSchema),
+});
+export const publicPricedOptionSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    description: z.string().nullable(),
+    status: productOptionStatusSchema,
+    isDefault: z.boolean(),
+    bookingMode: productBookingModeSchema,
+    capacityMode: productCapacityModeSchema,
+    pricingRules: z.array(publicOptionPricingRuleSchema),
+});
+export const publicProductPricingSnapshotSchema = z.object({
+    productId: z.string(),
+    catalog: publicPriceCatalogSchema,
+    options: z.array(publicPricedOptionSchema),
+});
+export const publicAvailabilityStartTimeSchema = z.object({
+    id: z.string(),
+    label: z.string().nullable(),
+    startTimeLocal: z.string(),
+    durationMinutes: z.number().int().nullable(),
+});
+export const publicAvailabilitySlotSchema = z.object({
+    id: z.string(),
+    optionId: z.string().nullable(),
+    dateLocal: z.string(),
+    startsAt: z.string(),
+    endsAt: z.string().nullable(),
+    timezone: z.string(),
+    status: availabilitySlotStatusSchema,
+    unlimited: z.boolean(),
+    remainingPax: z.number().int().nullable(),
+    remainingResources: z.number().int().nullable(),
+    pastCutoff: z.boolean(),
+    tooEarly: z.boolean(),
+    startTime: publicAvailabilityStartTimeSchema.nullable(),
+});
+export const publicAvailabilitySnapshotSchema = z.object({
+    productId: z.string(),
+    slots: z.array(publicAvailabilitySlotSchema),
+    total: z.number().int(),
+    limit: z.number().int(),
+    offset: z.number().int(),
+});

package/dist/validation-shared.d.ts

@@ -0,0 +1,71 @@
+import { z } from "zod";
+export declare const pricingCategoryTypeSchema: z.ZodEnum<{
+    adult: "adult";
+    child: "child";
+    infant: "infant";
+    senior: "senior";
+    group: "group";
+    room: "room";
+    vehicle: "vehicle";
+    service: "service";
+    other: "other";
+}>;
+export declare const pricingDependencyTypeSchema: z.ZodEnum<{
+    requires: "requires";
+    limits_per_master: "limits_per_master";
+    limits_sum: "limits_sum";
+    excludes: "excludes";
+}>;
+export declare const cancellationPolicyTypeSchema: z.ZodEnum<{
+    simple: "simple";
+    advanced: "advanced";
+    non_refundable: "non_refundable";
+    custom: "custom";
+}>;
+export declare const cancellationChargeTypeSchema: z.ZodEnum<{
+    none: "none";
+    amount: "amount";
+    percentage: "percentage";
+}>;
+export declare const priceCatalogTypeSchema: z.ZodEnum<{
+    internal: "internal";
+    other: "other";
+    public: "public";
+    contract: "contract";
+    net: "net";
+    gross: "gross";
+    promo: "promo";
+}>;
+export declare const optionPricingModeSchema: z.ZodEnum<{
+    per_person: "per_person";
+    per_booking: "per_booking";
+    starting_from: "starting_from";
+    free: "free";
+    on_request: "on_request";
+}>;
+export declare const optionUnitPricingModeSchema: z.ZodEnum<{
+    per_person: "per_person";
+    per_booking: "per_booking";
+    free: "free";
+    on_request: "on_request";
+    per_unit: "per_unit";
+    included: "included";
+}>;
+export declare const optionStartTimeRuleModeSchema: z.ZodEnum<{
+    included: "included";
+    excluded: "excluded";
+    override: "override";
+    adjustment: "adjustment";
+}>;
+export declare const priceAdjustmentTypeSchema: z.ZodEnum<{
+    fixed: "fixed";
+    percentage: "percentage";
+}>;
+export declare const addonPricingModeSchema: z.ZodEnum<{
+    per_person: "per_person";
+    per_booking: "per_booking";
+    on_request: "on_request";
+    included: "included";
+    unavailable: "unavailable";
+}>;
+//# sourceMappingURL=validation-shared.d.ts.map

package/dist/validation-shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation-shared.d.ts","sourceRoot":"","sources":["../src/validation-shared.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,yBAAyB;;;;;;;;;;EAUpC,CAAA;AAEF,eAAO,MAAM,2BAA2B;;;;;EAKtC,CAAA;AAEF,eAAO,MAAM,4BAA4B;;;;;EAKvC,CAAA;AAEF,eAAO,MAAM,4BAA4B;;;;EAA2C,CAAA;AACpF,eAAO,MAAM,sBAAsB;;;;;;;;EAQjC,CAAA;AACF,eAAO,MAAM,uBAAuB;;;;;;EAMlC,CAAA;AACF,eAAO,MAAM,2BAA2B;;;;;;;EAOtC,CAAA;AACF,eAAO,MAAM,6BAA6B;;;;;EAKxC,CAAA;AACF,eAAO,MAAM,yBAAyB;;;EAAkC,CAAA;AACxE,eAAO,MAAM,sBAAsB;;;;;;EAMjC,CAAA"}

package/dist/validation-shared.js

@@ -0,0 +1,63 @@
+import { z } from "zod";
+export const pricingCategoryTypeSchema = z.enum([
+    "adult",
+    "child",
+    "infant",
+    "senior",
+    "group",
+    "room",
+    "vehicle",
+    "service",
+    "other",
+]);
+export const pricingDependencyTypeSchema = z.enum([
+    "requires",
+    "limits_per_master",
+    "limits_sum",
+    "excludes",
+]);
+export const cancellationPolicyTypeSchema = z.enum([
+    "simple",
+    "advanced",
+    "non_refundable",
+    "custom",
+]);
+export const cancellationChargeTypeSchema = z.enum(["none", "amount", "percentage"]);
+export const priceCatalogTypeSchema = z.enum([
+    "public",
+    "contract",
+    "net",
+    "gross",
+    "promo",
+    "internal",
+    "other",
+]);
+export const optionPricingModeSchema = z.enum([
+    "per_person",
+    "per_booking",
+    "starting_from",
+    "free",
+    "on_request",
+]);
+export const optionUnitPricingModeSchema = z.enum([
+    "per_unit",
+    "per_person",
+    "per_booking",
+    "included",
+    "free",
+    "on_request",
+]);
+export const optionStartTimeRuleModeSchema = z.enum([
+    "included",
+    "excluded",
+    "override",
+    "adjustment",
+]);
+export const priceAdjustmentTypeSchema = z.enum(["fixed", "percentage"]);
+export const addonPricingModeSchema = z.enum([
+    "included",
+    "per_person",
+    "per_booking",
+    "on_request",
+    "unavailable",
+]);