@voyant-travel/storefront 0.120.1

package/dist/validation-settings.js

@@ -0,0 +1,235 @@
+import { z } from "zod";
+export const languageTagSchema = z
+    .string()
+    .trim()
+    .regex(/^[A-Za-z]{2,3}(?:-[A-Za-z0-9]{2,8})*$/);
+const httpUrlSchema = z.url().refine((value) => {
+    try {
+        const protocol = new URL(value).protocol;
+        return protocol === "http:" || protocol === "https:";
+    }
+    catch {
+        return false;
+    }
+}, { message: "URL must use http or https" });
+const urlOrNullSchema = httpUrlSchema.nullable();
+const colorTokenSchema = z
+    .string()
+    .trim()
+    .regex(/^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/);
+const textOrNullSchema = z.string().trim().min(1).nullable();
+export const storefrontPaymentMethodCodeSchema = z.enum([
+    "card",
+    "bank_transfer",
+    "cash",
+    "voucher",
+    "invoice",
+]);
+export const storefrontFormFieldTypeSchema = z.enum([
+    "text",
+    "email",
+    "tel",
+    "textarea",
+    "select",
+    "checkbox",
+    "date",
+    "country",
+]);
+export const storefrontFormFieldOptionSchema = z.object({
+    value: z.string().trim().min(1),
+    label: z.string().trim().min(1),
+});
+export const storefrontFormFieldInputSchema = z.object({
+    key: z.string().trim().min(1),
+    label: z.string().trim().min(1),
+    type: storefrontFormFieldTypeSchema.default("text"),
+    required: z.boolean().default(false),
+    placeholder: z.string().trim().min(1).optional().nullable(),
+    description: z.string().trim().min(1).optional().nullable(),
+    autocomplete: z.string().trim().min(1).optional().nullable(),
+    options: z.array(storefrontFormFieldOptionSchema).default([]),
+});
+export const storefrontFormFieldSchema = z.object({
+    key: z.string().trim().min(1),
+    label: z.string().trim().min(1),
+    type: storefrontFormFieldTypeSchema,
+    required: z.boolean(),
+    placeholder: z.string().trim().min(1).nullable(),
+    description: z.string().trim().min(1).nullable(),
+    autocomplete: z.string().trim().min(1).nullable(),
+    options: z.array(storefrontFormFieldOptionSchema),
+});
+export const storefrontPaymentMethodInputSchema = z.object({
+    code: storefrontPaymentMethodCodeSchema,
+    label: z.string().trim().min(1).optional(),
+    description: z.string().trim().min(1).optional().nullable(),
+    enabled: z.boolean().default(true),
+});
+export const storefrontPaymentMethodSchema = z.object({
+    code: storefrontPaymentMethodCodeSchema,
+    label: z.string().trim().min(1),
+    description: z.string().trim().min(1).nullable(),
+    enabled: z.boolean(),
+});
+export const storefrontPaymentStructureSchema = z.enum(["full", "split"]);
+export const storefrontPaymentDueConditionSchema = z.enum(["after_booking", "before_departure"]);
+export const storefrontPaymentScheduleEntryInputSchema = z.object({
+    percent: z.number().min(0).max(100),
+    dueInDays: z.number().int().min(0),
+    dueCondition: storefrontPaymentDueConditionSchema,
+});
+export const storefrontPaymentScheduleEntrySchema = storefrontPaymentScheduleEntryInputSchema;
+export const storefrontSupportLinkInputSchema = z.object({
+    label: z.string().trim().min(1),
+    url: httpUrlSchema,
+});
+export const storefrontSupportLinkSchema = storefrontSupportLinkInputSchema;
+export const storefrontBankTransferAccountInputSchema = z.object({
+    provider: z.string().trim().min(1).optional().nullable(),
+    currency: z.string().trim().min(1).optional().nullable(),
+    iban: z.string().trim().min(1),
+    beneficiary: z.string().trim().min(1),
+    bank: z.string().trim().min(1),
+});
+export const storefrontBankTransferAccountSchema = z.object({
+    provider: textOrNullSchema,
+    currency: textOrNullSchema,
+    iban: z.string().trim().min(1),
+    beneficiary: z.string().trim().min(1),
+    bank: z.string().trim().min(1),
+});
+export const storefrontBankTransferInputSchema = z.object({
+    dueDays: z.number().int().min(0).optional().nullable(),
+    account: storefrontBankTransferAccountInputSchema.optional().nullable(),
+    accountHolder: z.string().trim().min(1).optional().nullable(),
+    bankName: z.string().trim().min(1).optional().nullable(),
+    iban: z.string().trim().min(1).optional().nullable(),
+    bic: z.string().trim().min(1).optional().nullable(),
+    paymentReference: z.string().trim().min(1).optional().nullable(),
+    instructions: z.string().trim().min(1).optional().nullable(),
+});
+export const storefrontBankTransferSchema = z.object({
+    dueDays: z.number().int().min(0).nullable(),
+    account: storefrontBankTransferAccountSchema.nullable(),
+    accountHolder: textOrNullSchema,
+    bankName: textOrNullSchema,
+    iban: textOrNullSchema,
+    bic: textOrNullSchema,
+    paymentReference: textOrNullSchema,
+    instructions: textOrNullSchema,
+});
+export const storefrontPaymentScheduleInputSchema = z.object({
+    depositPercent: z.number().min(0).max(100).optional().nullable(),
+    balanceDueDaysBeforeDeparture: z.number().int().min(0).optional().nullable(),
+});
+export const storefrontPaymentScheduleSchema = z.object({
+    depositPercent: z.number().min(0).max(100).nullable(),
+    balanceDueDaysBeforeDeparture: z.number().int().min(0).nullable(),
+});
+export const storefrontCurrencyDisplaySchema = z.enum(["code", "symbol", "name"]);
+export const storefrontSettingsInputSchema = z.object({
+    branding: z
+        .object({
+        logoUrl: httpUrlSchema.optional().nullable(),
+        faviconUrl: httpUrlSchema.optional().nullable(),
+        brandMarkUrl: httpUrlSchema.optional().nullable(),
+        primaryColor: colorTokenSchema.optional().nullable(),
+        accentColor: colorTokenSchema.optional().nullable(),
+        supportedLanguages: z.array(languageTagSchema).optional(),
+    })
+        .optional(),
+    support: z
+        .object({
+        email: z.email().optional().nullable(),
+        phone: z.string().trim().min(1).optional().nullable(),
+        links: z.array(storefrontSupportLinkInputSchema).optional(),
+    })
+        .optional(),
+    legal: z
+        .object({
+        termsUrl: httpUrlSchema.optional().nullable(),
+        privacyUrl: httpUrlSchema.optional().nullable(),
+        cancellationUrl: httpUrlSchema.optional().nullable(),
+        defaultContractTemplateId: z.string().trim().min(1).optional().nullable(),
+    })
+        .optional(),
+    localization: z
+        .object({
+        defaultLocale: languageTagSchema.optional().nullable(),
+        currencyDisplay: storefrontCurrencyDisplaySchema.optional(),
+    })
+        .optional(),
+    forms: z
+        .object({
+        billing: z
+            .object({
+            fields: z.array(storefrontFormFieldInputSchema).default([]),
+        })
+            .optional(),
+        travelers: z
+            .object({
+            fields: z.array(storefrontFormFieldInputSchema).default([]),
+        })
+            .optional(),
+    })
+        .optional(),
+    payment: z
+        .object({
+        defaultMethod: storefrontPaymentMethodCodeSchema.optional().nullable(),
+        methods: z.array(storefrontPaymentMethodInputSchema).optional(),
+        structure: storefrontPaymentStructureSchema.optional(),
+        schedule: z.array(storefrontPaymentScheduleEntryInputSchema).optional(),
+        defaultSchedule: storefrontPaymentScheduleInputSchema.optional().nullable(),
+        bankTransfer: storefrontBankTransferInputSchema.optional().nullable(),
+    })
+        .optional(),
+});
+export const storefrontSettingsSchema = z.object({
+    branding: z.object({
+        logoUrl: urlOrNullSchema,
+        faviconUrl: urlOrNullSchema,
+        brandMarkUrl: urlOrNullSchema,
+        primaryColor: colorTokenSchema.nullable(),
+        accentColor: colorTokenSchema.nullable(),
+        supportedLanguages: z.array(languageTagSchema),
+    }),
+    support: z.object({
+        email: z.email().nullable(),
+        phone: z.string().trim().min(1).nullable(),
+        links: z.array(storefrontSupportLinkSchema),
+    }),
+    legal: z.object({
+        termsUrl: urlOrNullSchema,
+        privacyUrl: urlOrNullSchema,
+        cancellationUrl: urlOrNullSchema,
+        defaultContractTemplateId: z.string().trim().min(1).nullable(),
+    }),
+    localization: z.object({
+        defaultLocale: languageTagSchema.nullable(),
+        currencyDisplay: storefrontCurrencyDisplaySchema,
+    }),
+    forms: z.object({
+        billing: z.object({
+            fields: z.array(storefrontFormFieldSchema),
+        }),
+        travelers: z.object({
+            fields: z.array(storefrontFormFieldSchema),
+        }),
+    }),
+    payment: z.object({
+        defaultMethod: storefrontPaymentMethodCodeSchema.nullable(),
+        methods: z.array(storefrontPaymentMethodSchema),
+        structure: storefrontPaymentStructureSchema,
+        schedule: z.array(storefrontPaymentScheduleEntrySchema),
+        defaultSchedule: storefrontPaymentScheduleSchema.nullable(),
+        bankTransfer: storefrontBankTransferSchema.nullable(),
+    }),
+});
+export const storefrontSettingsPatchSchema = z.object({
+    branding: storefrontSettingsInputSchema.shape.branding,
+    support: storefrontSettingsInputSchema.shape.support,
+    legal: storefrontSettingsInputSchema.shape.legal,
+    localization: storefrontSettingsInputSchema.shape.localization,
+    forms: storefrontSettingsInputSchema.shape.forms,
+    payment: storefrontSettingsInputSchema.shape.payment,
+});

package/dist/validation-transport-eligibility.d.ts

@@ -0,0 +1,314 @@
+import { z } from "zod";
+export declare const storefrontTravelDocumentTypeSchema: z.ZodEnum<{
+    passport: "passport";
+    visa: "visa";
+    other: "other";
+    id_card: "id_card";
+    residence_permit: "residence_permit";
+    minor_consent: "minor_consent";
+}>;
+export declare const storefrontRequiredDocumentTypeSchema: z.ZodEnum<{
+    passport: "passport";
+    none: "none";
+    id_card: "id_card";
+    passport_or_id_card: "passport_or_id_card";
+}>;
+export declare const storefrontTransportEligibilitySeveritySchema: z.ZodEnum<{
+    warning: "warning";
+    blocking: "blocking";
+}>;
+export declare const storefrontTransportEligibilityRuleSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    productId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    departureId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    destinationCountries: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+    nationalityCountries: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+    requiredDocumentType: z.ZodDefault<z.ZodEnum<{
+        passport: "passport";
+        none: "none";
+        id_card: "id_card";
+        passport_or_id_card: "passport_or_id_card";
+    }>>;
+    minValidityDaysAfterReturn: z.ZodDefault<z.ZodNumber>;
+    minAge: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    maxAge: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    visaRequired: z.ZodDefault<z.ZodBoolean>;
+    minorConsentRequired: z.ZodDefault<z.ZodBoolean>;
+    severity: z.ZodDefault<z.ZodEnum<{
+        warning: "warning";
+        blocking: "blocking";
+    }>>;
+    message: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+export declare const storefrontTransportEligibilityDocumentInputSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        passport: "passport";
+        visa: "visa";
+        other: "other";
+        id_card: "id_card";
+        residence_permit: "residence_permit";
+        minor_consent: "minor_consent";
+    }>;
+    issuingCountry: z.ZodNullable<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+    expiresOn: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+export declare const storefrontTransportEligibilityTravelerInputSchema: z.ZodObject<{
+    travelerRef: z.ZodString;
+    nationalityCountry: z.ZodNullable<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+    dateOfBirth: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    documents: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            passport: "passport";
+            visa: "visa";
+            other: "other";
+            id_card: "id_card";
+            residence_permit: "residence_permit";
+            minor_consent: "minor_consent";
+        }>;
+        issuingCountry: z.ZodNullable<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+        expiresOn: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    }, z.core.$strip>>>;
+    hasVisa: z.ZodDefault<z.ZodBoolean>;
+    travelingWithGuardian: z.ZodDefault<z.ZodBoolean>;
+    hasMinorConsent: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const storefrontTransportEligibilityInputSchema: z.ZodObject<{
+    travelStartsOn: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    travelEndsOn: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    travelers: z.ZodArray<z.ZodObject<{
+        travelerRef: z.ZodString;
+        nationalityCountry: z.ZodNullable<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+        dateOfBirth: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        documents: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<{
+                passport: "passport";
+                visa: "visa";
+                other: "other";
+                id_card: "id_card";
+                residence_permit: "residence_permit";
+                minor_consent: "minor_consent";
+            }>;
+            issuingCountry: z.ZodNullable<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+            expiresOn: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        }, z.core.$strip>>>;
+        hasVisa: z.ZodDefault<z.ZodBoolean>;
+        travelingWithGuardian: z.ZodDefault<z.ZodBoolean>;
+        hasMinorConsent: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const storefrontTransportEligibilityIssueCodeSchema: z.ZodEnum<{
+    date_of_birth_required: "date_of_birth_required";
+    document_required: "document_required";
+    document_expiry_required: "document_expiry_required";
+    document_validity: "document_validity";
+    nationality_required: "nationality_required";
+    visa_required: "visa_required";
+    minor_consent_required: "minor_consent_required";
+    travel_dates_required: "travel_dates_required";
+}>;
+export declare const storefrontTransportEligibilityIssueSchema: z.ZodObject<{
+    code: z.ZodEnum<{
+        date_of_birth_required: "date_of_birth_required";
+        document_required: "document_required";
+        document_expiry_required: "document_expiry_required";
+        document_validity: "document_validity";
+        nationality_required: "nationality_required";
+        visa_required: "visa_required";
+        minor_consent_required: "minor_consent_required";
+        travel_dates_required: "travel_dates_required";
+    }>;
+    severity: z.ZodEnum<{
+        warning: "warning";
+        blocking: "blocking";
+    }>;
+    message: z.ZodString;
+    travelerRef: z.ZodString;
+    ruleId: z.ZodString;
+    destinationCountries: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+    requiredDocumentType: z.ZodEnum<{
+        passport: "passport";
+        none: "none";
+        id_card: "id_card";
+        passport_or_id_card: "passport_or_id_card";
+    }>;
+}, z.core.$strip>;
+export declare const storefrontTransportEligibilityTravelerResultSchema: z.ZodObject<{
+    travelerRef: z.ZodString;
+    eligible: z.ZodBoolean;
+    matchedRuleIds: z.ZodArray<z.ZodString>;
+    blockingIssues: z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<{
+            date_of_birth_required: "date_of_birth_required";
+            document_required: "document_required";
+            document_expiry_required: "document_expiry_required";
+            document_validity: "document_validity";
+            nationality_required: "nationality_required";
+            visa_required: "visa_required";
+            minor_consent_required: "minor_consent_required";
+            travel_dates_required: "travel_dates_required";
+        }>;
+        severity: z.ZodEnum<{
+            warning: "warning";
+            blocking: "blocking";
+        }>;
+        message: z.ZodString;
+        travelerRef: z.ZodString;
+        ruleId: z.ZodString;
+        destinationCountries: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        requiredDocumentType: z.ZodEnum<{
+            passport: "passport";
+            none: "none";
+            id_card: "id_card";
+            passport_or_id_card: "passport_or_id_card";
+        }>;
+    }, z.core.$strip>>;
+    warnings: z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<{
+            date_of_birth_required: "date_of_birth_required";
+            document_required: "document_required";
+            document_expiry_required: "document_expiry_required";
+            document_validity: "document_validity";
+            nationality_required: "nationality_required";
+            visa_required: "visa_required";
+            minor_consent_required: "minor_consent_required";
+            travel_dates_required: "travel_dates_required";
+        }>;
+        severity: z.ZodEnum<{
+            warning: "warning";
+            blocking: "blocking";
+        }>;
+        message: z.ZodString;
+        travelerRef: z.ZodString;
+        ruleId: z.ZodString;
+        destinationCountries: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        requiredDocumentType: z.ZodEnum<{
+            passport: "passport";
+            none: "none";
+            id_card: "id_card";
+            passport_or_id_card: "passport_or_id_card";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const storefrontTransportEligibilityResultSchema: z.ZodObject<{
+    departureId: z.ZodString;
+    productId: z.ZodNullable<z.ZodString>;
+    travelStartsOn: z.ZodNullable<z.ZodString>;
+    travelEndsOn: z.ZodNullable<z.ZodString>;
+    eligible: z.ZodBoolean;
+    blockingIssues: z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<{
+            date_of_birth_required: "date_of_birth_required";
+            document_required: "document_required";
+            document_expiry_required: "document_expiry_required";
+            document_validity: "document_validity";
+            nationality_required: "nationality_required";
+            visa_required: "visa_required";
+            minor_consent_required: "minor_consent_required";
+            travel_dates_required: "travel_dates_required";
+        }>;
+        severity: z.ZodEnum<{
+            warning: "warning";
+            blocking: "blocking";
+        }>;
+        message: z.ZodString;
+        travelerRef: z.ZodString;
+        ruleId: z.ZodString;
+        destinationCountries: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        requiredDocumentType: z.ZodEnum<{
+            passport: "passport";
+            none: "none";
+            id_card: "id_card";
+            passport_or_id_card: "passport_or_id_card";
+        }>;
+    }, z.core.$strip>>;
+    warnings: z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<{
+            date_of_birth_required: "date_of_birth_required";
+            document_required: "document_required";
+            document_expiry_required: "document_expiry_required";
+            document_validity: "document_validity";
+            nationality_required: "nationality_required";
+            visa_required: "visa_required";
+            minor_consent_required: "minor_consent_required";
+            travel_dates_required: "travel_dates_required";
+        }>;
+        severity: z.ZodEnum<{
+            warning: "warning";
+            blocking: "blocking";
+        }>;
+        message: z.ZodString;
+        travelerRef: z.ZodString;
+        ruleId: z.ZodString;
+        destinationCountries: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        requiredDocumentType: z.ZodEnum<{
+            passport: "passport";
+            none: "none";
+            id_card: "id_card";
+            passport_or_id_card: "passport_or_id_card";
+        }>;
+    }, z.core.$strip>>;
+    travelers: z.ZodArray<z.ZodObject<{
+        travelerRef: z.ZodString;
+        eligible: z.ZodBoolean;
+        matchedRuleIds: z.ZodArray<z.ZodString>;
+        blockingIssues: z.ZodArray<z.ZodObject<{
+            code: z.ZodEnum<{
+                date_of_birth_required: "date_of_birth_required";
+                document_required: "document_required";
+                document_expiry_required: "document_expiry_required";
+                document_validity: "document_validity";
+                nationality_required: "nationality_required";
+                visa_required: "visa_required";
+                minor_consent_required: "minor_consent_required";
+                travel_dates_required: "travel_dates_required";
+            }>;
+            severity: z.ZodEnum<{
+                warning: "warning";
+                blocking: "blocking";
+            }>;
+            message: z.ZodString;
+            travelerRef: z.ZodString;
+            ruleId: z.ZodString;
+            destinationCountries: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+            requiredDocumentType: z.ZodEnum<{
+                passport: "passport";
+                none: "none";
+                id_card: "id_card";
+                passport_or_id_card: "passport_or_id_card";
+            }>;
+        }, z.core.$strip>>;
+        warnings: z.ZodArray<z.ZodObject<{
+            code: z.ZodEnum<{
+                date_of_birth_required: "date_of_birth_required";
+                document_required: "document_required";
+                document_expiry_required: "document_expiry_required";
+                document_validity: "document_validity";
+                nationality_required: "nationality_required";
+                visa_required: "visa_required";
+                minor_consent_required: "minor_consent_required";
+                travel_dates_required: "travel_dates_required";
+            }>;
+            severity: z.ZodEnum<{
+                warning: "warning";
+                blocking: "blocking";
+            }>;
+            message: z.ZodString;
+            travelerRef: z.ZodString;
+            ruleId: z.ZodString;
+            destinationCountries: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+            requiredDocumentType: z.ZodEnum<{
+                passport: "passport";
+                none: "none";
+                id_card: "id_card";
+                passport_or_id_card: "passport_or_id_card";
+            }>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type StorefrontTransportEligibilityInput = z.infer<typeof storefrontTransportEligibilityInputSchema>;
+export type StorefrontTransportEligibilityRule = z.infer<typeof storefrontTransportEligibilityRuleSchema>;
+export type StorefrontTransportEligibilityRuleInput = z.input<typeof storefrontTransportEligibilityRuleSchema>;
+export type StorefrontTransportEligibilityIssue = z.infer<typeof storefrontTransportEligibilityIssueSchema>;
+export type StorefrontTransportEligibilityResult = z.infer<typeof storefrontTransportEligibilityResultSchema>;
+//# sourceMappingURL=validation-transport-eligibility.d.ts.map

package/dist/validation-transport-eligibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation-transport-eligibility.d.ts","sourceRoot":"","sources":["../src/validation-transport-eligibility.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAQvB,eAAO,MAAM,kCAAkC;;;;;;;EAO7C,CAAA;AAEF,eAAO,MAAM,oCAAoC;;;;;EAK/C,CAAA;AAEF,eAAO,MAAM,4CAA4C;;;EAAkC,CAAA;AAE3F,eAAO,MAAM,wCAAwC;;;;;;;;;;;;;;;;;;;;;;;iBAoBjD,CAAA;AAEJ,eAAO,MAAM,iDAAiD;;;;;;;;;;;iBAI5D,CAAA;AAEF,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;iBAQ5D,CAAA;AAEF,eAAO,MAAM,yCAAyC;;;;;;;;;;;;;;;;;;;;;;;iBAIpD,CAAA;AAEF,eAAO,MAAM,6CAA6C;;;;;;;;;EASxD,CAAA;AAEF,eAAO,MAAM,yCAAyC;;;;;;;;;;;;;;;;;;;;;;;;;iBAQpD,CAAA;AAEF,eAAO,MAAM,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAM7D,CAAA;AAEF,eAAO,MAAM,0CAA0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBASrD,CAAA;AAEF,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CACvD,OAAO,yCAAyC,CACjD,CAAA;AACD,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CACtD,OAAO,wCAAwC,CAChD,CAAA;AACD,MAAM,MAAM,uCAAuC,GAAG,CAAC,CAAC,KAAK,CAC3D,OAAO,wCAAwC,CAChD,CAAA;AACD,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CACvD,OAAO,yCAAyC,CACjD,CAAA;AACD,MAAM,MAAM,oCAAoC,GAAG,CAAC,CAAC,KAAK,CACxD,OAAO,0CAA0C,CAClD,CAAA"}

package/dist/validation-transport-eligibility.js

@@ -0,0 +1,97 @@
+import { z } from "zod";
+const countryCodeSchema = z
+    .string()
+    .trim()
+    .length(2)
+    .transform((value) => value.toUpperCase());
+export const storefrontTravelDocumentTypeSchema = z.enum([
+    "passport",
+    "id_card",
+    "residence_permit",
+    "visa",
+    "minor_consent",
+    "other",
+]);
+export const storefrontRequiredDocumentTypeSchema = z.enum([
+    "none",
+    "passport",
+    "id_card",
+    "passport_or_id_card",
+]);
+export const storefrontTransportEligibilitySeveritySchema = z.enum(["blocking", "warning"]);
+export const storefrontTransportEligibilityRuleSchema = z
+    .object({
+    id: z.string().trim().min(1),
+    label: z.string().trim().min(1),
+    productId: z.string().trim().min(1).optional().nullable(),
+    departureId: z.string().trim().min(1).optional().nullable(),
+    destinationCountries: z.array(countryCodeSchema).min(1),
+    nationalityCountries: z.array(countryCodeSchema).default([]),
+    requiredDocumentType: storefrontRequiredDocumentTypeSchema.default("passport"),
+    minValidityDaysAfterReturn: z.number().int().min(0).default(0),
+    minAge: z.number().int().min(0).optional().nullable(),
+    maxAge: z.number().int().min(0).optional().nullable(),
+    visaRequired: z.boolean().default(false),
+    minorConsentRequired: z.boolean().default(false),
+    severity: storefrontTransportEligibilitySeveritySchema.default("blocking"),
+    message: z.string().trim().min(1).optional().nullable(),
+})
+    .refine((rule) => rule.minAge == null || rule.maxAge == null || rule.minAge <= rule.maxAge, {
+    message: "minAge must be less than or equal to maxAge",
+    path: ["maxAge"],
+});
+export const storefrontTransportEligibilityDocumentInputSchema = z.object({
+    type: storefrontTravelDocumentTypeSchema,
+    issuingCountry: countryCodeSchema.optional().nullable(),
+    expiresOn: z.string().date().optional().nullable(),
+});
+export const storefrontTransportEligibilityTravelerInputSchema = z.object({
+    travelerRef: z.string().trim().min(1),
+    nationalityCountry: countryCodeSchema.optional().nullable(),
+    dateOfBirth: z.string().date().optional().nullable(),
+    documents: z.array(storefrontTransportEligibilityDocumentInputSchema).default([]),
+    hasVisa: z.boolean().default(false),
+    travelingWithGuardian: z.boolean().default(false),
+    hasMinorConsent: z.boolean().default(false),
+});
+export const storefrontTransportEligibilityInputSchema = z.object({
+    travelStartsOn: z.string().date().optional().nullable(),
+    travelEndsOn: z.string().date().optional().nullable(),
+    travelers: z.array(storefrontTransportEligibilityTravelerInputSchema).min(1),
+});
+export const storefrontTransportEligibilityIssueCodeSchema = z.enum([
+    "date_of_birth_required",
+    "document_required",
+    "document_expiry_required",
+    "document_validity",
+    "nationality_required",
+    "visa_required",
+    "minor_consent_required",
+    "travel_dates_required",
+]);
+export const storefrontTransportEligibilityIssueSchema = z.object({
+    code: storefrontTransportEligibilityIssueCodeSchema,
+    severity: storefrontTransportEligibilitySeveritySchema,
+    message: z.string(),
+    travelerRef: z.string(),
+    ruleId: z.string(),
+    destinationCountries: z.array(countryCodeSchema),
+    requiredDocumentType: storefrontRequiredDocumentTypeSchema,
+});
+export const storefrontTransportEligibilityTravelerResultSchema = z.object({
+    travelerRef: z.string(),
+    eligible: z.boolean(),
+    matchedRuleIds: z.array(z.string()),
+    blockingIssues: z.array(storefrontTransportEligibilityIssueSchema),
+    warnings: z.array(storefrontTransportEligibilityIssueSchema),
+});
+export const storefrontTransportEligibilityResultSchema = z.object({
+    departureId: z.string(),
+    productId: z.string().nullable(),
+    travelStartsOn: z.string().nullable(),
+    travelEndsOn: z.string().nullable(),
+    eligible: z.boolean(),
+    blockingIssues: z.array(storefrontTransportEligibilityIssueSchema),
+    warnings: z.array(storefrontTransportEligibilityIssueSchema),
+    travelers: z.array(storefrontTransportEligibilityTravelerResultSchema),
+});

package/dist/validation.d.ts

@@ -0,0 +1,6 @@
+export * from "./validation/departures.js";
+export * from "./validation/intake.js";
+export * from "./validation/offers.js";
+export type { StorefrontBankTransfer, StorefrontBankTransferAccount, StorefrontBankTransferAccountInput, StorefrontBankTransferInput, StorefrontCurrencyDisplay, StorefrontFormField, StorefrontFormFieldInput, StorefrontPaymentDueCondition, StorefrontPaymentMethod, StorefrontPaymentMethodCode, StorefrontPaymentMethodInput, StorefrontPaymentSchedule, StorefrontPaymentScheduleEntry, StorefrontPaymentScheduleEntryInput, StorefrontPaymentScheduleInput, StorefrontPaymentStructure, StorefrontSettings, StorefrontSettingsInput, StorefrontSettingsPatchInput, StorefrontSupportLink, StorefrontSupportLinkInput, } from "./validation-settings.js";
+export { storefrontBankTransferAccountInputSchema, storefrontBankTransferAccountSchema, storefrontBankTransferInputSchema, storefrontBankTransferSchema, storefrontCurrencyDisplaySchema, storefrontFormFieldInputSchema, storefrontFormFieldOptionSchema, storefrontFormFieldSchema, storefrontFormFieldTypeSchema, storefrontPaymentDueConditionSchema, storefrontPaymentMethodCodeSchema, storefrontPaymentMethodInputSchema, storefrontPaymentMethodSchema, storefrontPaymentScheduleEntryInputSchema, storefrontPaymentScheduleEntrySchema, storefrontPaymentScheduleInputSchema, storefrontPaymentScheduleSchema, storefrontPaymentStructureSchema, storefrontSettingsInputSchema, storefrontSettingsPatchSchema, storefrontSettingsSchema, storefrontSupportLinkInputSchema, storefrontSupportLinkSchema, } from "./validation-settings.js";
+//# sourceMappingURL=validation.d.ts.map

package/dist/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAA;AAC1C,cAAc,wBAAwB,CAAA;AACtC,cAAc,wBAAwB,CAAA;AACtC,YAAY,EACV,sBAAsB,EACtB,6BAA6B,EAC7B,kCAAkC,EAClC,2BAA2B,EAC3B,yBAAyB,EACzB,mBAAmB,EACnB,wBAAwB,EACxB,6BAA6B,EAC7B,uBAAuB,EACvB,2BAA2B,EAC3B,4BAA4B,EAC5B,yBAAyB,EACzB,8BAA8B,EAC9B,mCAAmC,EACnC,8BAA8B,EAC9B,0BAA0B,EAC1B,kBAAkB,EAClB,uBAAuB,EACvB,4BAA4B,EAC5B,qBAAqB,EACrB,0BAA0B,GAC3B,MAAM,0BAA0B,CAAA;AACjC,OAAO,EACL,wCAAwC,EACxC,mCAAmC,EACnC,iCAAiC,EACjC,4BAA4B,EAC5B,+BAA+B,EAC/B,8BAA8B,EAC9B,+BAA+B,EAC/B,yBAAyB,EACzB,6BAA6B,EAC7B,mCAAmC,EACnC,iCAAiC,EACjC,kCAAkC,EAClC,6BAA6B,EAC7B,yCAAyC,EACzC,oCAAoC,EACpC,oCAAoC,EACpC,+BAA+B,EAC/B,gCAAgC,EAChC,6BAA6B,EAC7B,6BAA6B,EAC7B,wBAAwB,EACxB,gCAAgC,EAChC,2BAA2B,GAC5B,MAAM,0BAA0B,CAAA"}

package/dist/validation.js

@@ -0,0 +1,4 @@
+export * from "./validation/departures.js";
+export * from "./validation/intake.js";
+export * from "./validation/offers.js";
+export { storefrontBankTransferAccountInputSchema, storefrontBankTransferAccountSchema, storefrontBankTransferInputSchema, storefrontBankTransferSchema, storefrontCurrencyDisplaySchema, storefrontFormFieldInputSchema, storefrontFormFieldOptionSchema, storefrontFormFieldSchema, storefrontFormFieldTypeSchema, storefrontPaymentDueConditionSchema, storefrontPaymentMethodCodeSchema, storefrontPaymentMethodInputSchema, storefrontPaymentMethodSchema, storefrontPaymentScheduleEntryInputSchema, storefrontPaymentScheduleEntrySchema, storefrontPaymentScheduleInputSchema, storefrontPaymentScheduleSchema, storefrontPaymentStructureSchema, storefrontSettingsInputSchema, storefrontSettingsPatchSchema, storefrontSettingsSchema, storefrontSupportLinkInputSchema, storefrontSupportLinkSchema, } from "./validation-settings.js";