// This file is auto-generated by scripts/generate-schemas.ts
// Do not edit manually.

import { z } from "zod";

export const PermissionSchema = z.enum([
	"AddChildUnits",
	"UpdateAssociates",
	"UpdateBusinessUnitDetails",
	"UpdateParentUnit",
	"ViewMyCarts",
	"ViewOthersCarts",
	"UpdateMyCarts",
	"UpdateOthersCarts",
	"CreateMyCarts",
	"CreateOthersCarts",
	"DeleteMyCarts",
	"DeleteOthersCarts",
	"ViewMyOrders",
	"ViewOthersOrders",
	"UpdateMyOrders",
	"UpdateOthersOrders",
	"CreateMyOrdersFromMyCarts",
	"CreateMyOrdersFromMyQuotes",
	"CreateOrdersFromOthersCarts",
	"CreateOrdersFromOthersQuotes",
	"ViewMyQuotes",
	"ViewOthersQuotes",
	"AcceptMyQuotes",
	"AcceptOthersQuotes",
	"DeclineMyQuotes",
	"DeclineOthersQuotes",
	"RenegotiateMyQuotes",
	"RenegotiateOthersQuotes",
	"ReassignMyQuotes",
	"ReassignOthersQuotes",
	"ViewMyQuoteRequests",
	"ViewOthersQuoteRequests",
	"UpdateMyQuoteRequests",
	"UpdateOthersQuoteRequests",
	"CreateMyQuoteRequestsFromMyCarts",
	"CreateQuoteRequestsFromOthersCarts",
	"CreateApprovalRules",
	"UpdateApprovalRules",
	"UpdateApprovalFlows",
	"ViewMyShoppingLists",
	"ViewOthersShoppingLists",
	"UpdateMyShoppingLists",
	"UpdateOthersShoppingLists",
	"CreateMyShoppingLists",
	"CreateOthersShoppingLists",
	"DeleteMyShoppingLists",
	"DeleteOthersShoppingLists",
]);

export const ReferenceTypeIdSchema = z.enum([
	"approval-flow",
	"approval-rule",
	"associate-role",
	"attribute-group",
	"business-unit",
	"cart",
	"cart-discount",
	"category",
	"channel",
	"customer",
	"customer-email-token",
	"customer-group",
	"customer-password-token",
	"direct-discount",
	"discount-code",
	"discount-group",
	"extension",
	"inventory-entry",
	"key-value-document",
	"order",
	"order-edit",
	"payment-method",
	"payment",
	"product",
	"product-discount",
	"product-price",
	"product-selection",
	"product-tailoring",
	"product-type",
	"quote",
	"quote-request",
	"recurrence-policy",
	"recurring-order",
	"reservation",
	"review",
	"shipping-method",
	"shopping-list",
	"staged-quote",
	"standalone-price",
	"state",
	"store",
	"subscription",
	"tax-category",
	"type",
	"variant",
	"zone",
]);

export const BusinessUnitStatusSchema = z.enum(["Active", "Inactive"]);

export const BusinessUnitStoreModeSchema = z.enum(["Explicit", "FromParent"]);

export const BusinessUnitTypeSchema = z.enum(["Company", "Division"]);

export const BusinessUnitAssociateModeSchema = z.enum([
	"Explicit",
	"ExplicitAndFromParent",
]);

export const AssociateRoleInheritanceModeSchema = z.enum([
	"Enabled",
	"Disabled",
]);

export const AssociateRoleDeprecatedSchema = z.enum(["Admin", "Buyer"]);

export const BusinessUnitApprovalRuleModeSchema = z.enum([
	"Explicit",
	"ExplicitAndFromParent",
]);

export const InventoryModeSchema = z.enum([
	"None",
	"TrackOnly",
	"ReserveOnOrder",
	"ReserveOnCart",
]);

export const PriceSelectionModeSchema = z.enum(["Fixed", "Dynamic"]);

export const CustomLineItemPriceModeSchema = z.enum(["Standard", "External"]);

export const TaxModeSchema = z.enum([
	"Platform",
	"External",
	"ExternalAmount",
	"Disabled",
]);

export const RoundingModeSchema = z.enum(["HalfEven", "HalfUp", "HalfDown"]);

export const TaxCalculationModeSchema = z.enum([
	"LineItemLevel",
	"UnitPriceLevel",
]);

export const ShippingModeSchema = z.enum(["Single", "Multiple"]);

export const ShippingRateTierTypeSchema = z.enum([
	"CartValue",
	"CartClassification",
	"CartScore",
]);

export const CartOriginSchema = z.enum([
	"Customer",
	"Merchant",
	"Quote",
	"RecurringOrder",
]);

export const DiscountApplicationModeSchema = z.enum([
	"ProportionateDistribution",
	"EvenDistribution",
	"IndividualApplication",
]);

export const MoneyTypeSchema = z.enum(["centPrecision", "highPrecision"]);

export const StackingModeSchema = z.enum(["Stacking", "StopAfterThisDiscount"]);

export const ChannelRoleEnumSchema = z.enum([
	"InventorySupply",
	"ProductDistribution",
	"OrderExport",
	"OrderImport",
	"Primary",
]);

export const AuthenticationModeSchema = z.enum(["Password", "ExternalAuth"]);

export const ExtensionResourceTypeIdSchema = z.enum([
	"cart",
	"order",
	"payment",
	"payment-method",
	"customer",
	"customer-group",
	"quote-request",
	"staged-quote",
	"quote",
	"business-unit",
	"shopping-list",
]);

export const ExtensionActionSchema = z.enum(["Create", "Update"]);

export const PaymentStateSchema = z.enum([
	"BalanceDue",
	"Failed",
	"Pending",
	"CreditOwed",
	"Paid",
]);

export const ShipmentStateSchema = z.enum([
	"Shipped",
	"Delivered",
	"Ready",
	"Pending",
	"Delayed",
	"Partial",
	"Backorder",
	"Canceled",
]);

export const OrderStateSchema = z.enum([
	"Open",
	"Confirmed",
	"Complete",
	"Cancelled",
]);

export const TransactionTypeSchema = z.enum([
	"Authorization",
	"CancelAuthorization",
	"Charge",
	"Refund",
	"Chargeback",
]);

export const TransactionStateSchema = z.enum([
	"Initial",
	"Pending",
	"Success",
	"Failure",
]);

export const ProductPriceModeEnumSchema = z.enum(["Embedded", "Standalone"]);

export const ProductSelectionTypeEnumSchema = z.enum([
	"individual",
	"individualExclusion",
]);

export const ProductSelectionModeSchema = z.enum([
	"Individual",
	"IndividualExclusion",
]);

export const AttributeLevelEnumSchema = z.enum(["Product", "Variant"]);

export const AttributeConstraintEnumSchema = z.enum([
	"None",
	"Unique",
	"CombinationUnique",
	"SameForAll",
]);

export const TextInputHintSchema = z.enum(["SingleLine", "MultiLine"]);

export const IntervalUnitSchema = z.enum(["Days", "Weeks", "Months"]);

export const StateTypeEnumSchema = z.enum([
	"OrderState",
	"RecurringOrderState",
	"LineItemState",
	"ProductState",
	"ReviewState",
	"PaymentState",
	"QuoteRequestState",
	"StagedQuoteState",
	"QuoteState",
]);

export const StateRoleEnumSchema = z.enum([
	"ReviewIncludedInStatistics",
	"Return",
]);

export const MessageSubscriptionResourceTypeIdSchema = z.enum([
	"approval-flow",
	"approval-rule",
	"associate-role",
	"business-unit",
	"category",
	"customer",
	"customer-email-token",
	"customer-group",
	"customer-password-token",
	"inventory-entry",
	"order",
	"payment",
	"product",
	"product-selection",
	"product-tailoring",
	"quote",
	"quote-request",
	"review",
	"shopping-list",
	"staged-quote",
	"standalone-price",
	"store",
]);

export const ChangeSubscriptionResourceTypeIdSchema = z.enum([
	"approval-flow",
	"approval-rule",
	"associate-role",
	"attribute-group",
	"business-unit",
	"cart",
	"cart-discount",
	"category",
	"channel",
	"customer",
	"customer-email-token",
	"customer-group",
	"customer-password-token",
	"discount-code",
	"discount-group",
	"extension",
	"inventory-entry",
	"key-value-document",
	"order",
	"order-edit",
	"payment",
	"product",
	"product-discount",
	"product-selection",
	"product-tailoring",
	"product-type",
	"quote",
	"quote-request",
	"recurrence-policy",
	"recurring-order",
	"review",
	"shipping-method",
	"shopping-list",
	"staged-quote",
	"standalone-price",
	"state",
	"store",
	"subscription",
	"tax-category",
	"type",
	"zone",
]);

export const EventSubscriptionResourceTypeIdSchema = z.enum([
	"checkout",
	"import-api",
]);

export const EventTypeSchema = z.enum([
	"CheckoutOrderCreationFailed",
	"CheckoutPaymentAuthorizationCancelled",
	"CheckoutPaymentAuthorizationFailed",
	"CheckoutPaymentAuthorized",
	"CheckoutPaymentCancelAuthorizationFailed",
	"CheckoutPaymentCharged",
	"CheckoutPaymentChargeFailed",
	"CheckoutPaymentRefunded",
	"CheckoutPaymentRefundFailed",
	"ImportContainerCreated",
	"ImportContainerDeleted",
	"ImportOperationRejected",
	"ImportUnresolved",
	"ImportValidationFailed",
	"ImportWaitForMasterVariant",
]);

export const ResourceTypeIdSchema = z.enum([
	"address",
	"asset",
	"approval-flow",
	"approval-rule",
	"associate-role",
	"business-unit",
	"cart-discount",
	"category",
	"channel",
	"customer",
	"customer-group",
	"custom-line-item",
	"discount-code",
	"inventory-entry",
	"line-item",
	"order",
	"order-edit",
	"order-delivery",
	"order-parcel",
	"order-return-item",
	"payment",
	"payment-interface-interaction",
	"payment-method",
	"payment-method-info",
	"product-price",
	"product-selection",
	"product-tailoring",
	"quote",
	"reservation",
	"review",
	"recurring-order",
	"shipping",
	"shipping-method",
	"shopping-list",
	"shopping-list-text-line-item",
	"standalone-price",
	"store",
	"transaction",
]);

export const TypeTextInputHintSchema = z.enum(["SingleLine", "MultiLine"]);

export const CountryCodeSchema = z.string();

export const CurrencyCodeSchema = z.string();

export const LocaleSchema = z.string();

export const TypeResourceIdentifierSchema = z
	.object({
		typeId: ReferenceTypeIdSchema,
		id: z.string().nullish(),
		key: z.string().nullish(),
	})
	.refine((data) => data.id !== undefined || data.key !== undefined, {
		message: "Either 'id' or 'key' must be provided",
	});

export const FieldContainerSchema = z.record(z.string(), z.unknown());

export const CustomFieldsDraftSchema = z.object({
	type: TypeResourceIdentifierSchema,
	fields: FieldContainerSchema.nullish(),
});

export const LocalizedStringSchema = z.record(z.string(), z.string());

export const AttributeReferenceSchema = z.object({
	key: z.string(),
});

export const StoreResourceIdentifierSchema = z
	.object({
		typeId: ReferenceTypeIdSchema,
		id: z.string().nullish(),
		key: z.string().nullish(),
	})
	.refine((data) => data.id !== undefined || data.key !== undefined, {
		message: "Either 'id' or 'key' must be provided",
	});

export const AssociateRoleResourceIdentifierSchema = z
	.object({
		typeId: ReferenceTypeIdSchema,
		id: z.string().nullish(),
		key: z.string().nullish(),
	})
	.refine((data) => data.id !== undefined || data.key !== undefined, {
		message: "Either 'id' or 'key' must be provided",
	});

export const AssociateRoleAssignmentDraftSchema = z.object({
	associateRole: AssociateRoleResourceIdentifierSchema,
	inheritance: AssociateRoleInheritanceModeSchema.nullish(),
});

export const CustomerResourceIdentifierSchema = z
	.object({
		typeId: ReferenceTypeIdSchema,
		id: z.string().nullish(),
		key: z.string().nullish(),
	})
	.refine((data) => data.id !== undefined || data.key !== undefined, {
		message: "Either 'id' or 'key' must be provided",
	});

export const AssociateDraftSchema = z.object({
	associateRoleAssignments: z.array(AssociateRoleAssignmentDraftSchema),
	roles: z.array(AssociateRoleDeprecatedSchema).nullish(),
	customer: CustomerResourceIdentifierSchema,
});

export const BaseAddressSchema = z.object({
	id: z.string().nullish(),
	key: z.string().nullish(),
	country: CountryCodeSchema,
	title: z.string().nullish(),
	salutation: z.string().nullish(),
	firstName: z.string().nullish(),
	lastName: z.string().nullish(),
	streetName: z.string().nullish(),
	streetNumber: z.string().nullish(),
	additionalStreetInfo: z.string().nullish(),
	postalCode: z.string().nullish(),
	city: z.string().nullish(),
	region: z.string().nullish(),
	state: z.string().nullish(),
	company: z.string().nullish(),
	department: z.string().nullish(),
	building: z.string().nullish(),
	apartment: z.string().nullish(),
	pOBox: z.string().nullish(),
	phone: z.string().nullish(),
	mobile: z.string().nullish(),
	email: z.string().nullish(),
	fax: z.string().nullish(),
	additionalAddressInfo: z.string().nullish(),
	externalId: z.string().nullish(),
});

export const CustomerGroupResourceIdentifierSchema = z
	.object({
		typeId: ReferenceTypeIdSchema,
		id: z.string().nullish(),
		key: z.string().nullish(),
	})
	.refine((data) => data.id !== undefined || data.key !== undefined, {
		message: "Either 'id' or 'key' must be provided",
	});

export const CustomerGroupAssignmentDraftSchema = z.object({
	customerGroup: CustomerGroupResourceIdentifierSchema,
});

export const CompanyDraftSchema = z.object({
	key: z.string(),
	status: BusinessUnitStatusSchema.nullish(),
	stores: z.array(StoreResourceIdentifierSchema).nullish(),
	storeMode: BusinessUnitStoreModeSchema.nullish(),
	unitType: z.literal("Company"),
	name: z.string(),
	contactEmail: z.string().nullish(),
	associateMode: BusinessUnitAssociateModeSchema.nullish(),
	associates: z.array(AssociateDraftSchema).nullish(),
	approvalRuleMode: BusinessUnitApprovalRuleModeSchema.nullish(),
	addresses: z.array(BaseAddressSchema).nullish(),
	shippingAddresses: z.array(z.number().int()).nullish(),
	defaultShippingAddress: z.number().int().nullish(),
	billingAddresses: z.array(z.number().int()).nullish(),
	defaultBillingAddress: z.number().int().nullish(),
	custom: CustomFieldsDraftSchema.nullish(),
	customerGroupAssignments: z
		.array(CustomerGroupAssignmentDraftSchema)
		.nullish(),
});

export const BusinessUnitResourceIdentifierSchema = z
	.object({
		typeId: ReferenceTypeIdSchema,
		id: z.string().nullish(),
		key: z.string().nullish(),
	})
	.refine((data) => data.id !== undefined || data.key !== undefined, {
		message: "Either 'id' or 'key' must be provided",
	});

export const DivisionDraftSchema = z.object({
	key: z.string(),
	status: BusinessUnitStatusSchema.nullish(),
	stores: z.array(StoreResourceIdentifierSchema).nullish(),
	storeMode: BusinessUnitStoreModeSchema.nullish(),
	unitType: z.literal("Division"),
	name: z.string(),
	contactEmail: z.string().nullish(),
	associateMode: BusinessUnitAssociateModeSchema.nullish(),
	associates: z.array(AssociateDraftSchema).nullish(),
	approvalRuleMode: BusinessUnitApprovalRuleModeSchema.nullish(),
	addresses: z.array(BaseAddressSchema).nullish(),
	shippingAddresses: z.array(z.number().int()).nullish(),
	defaultShippingAddress: z.number().int().nullish(),
	billingAddresses: z.array(z.number().int()).nullish(),
	defaultBillingAddress: z.number().int().nullish(),
	custom: CustomFieldsDraftSchema.nullish(),
	customerGroupAssignments: z
		.array(CustomerGroupAssignmentDraftSchema)
		.nullish(),
	parentUnit: BusinessUnitResourceIdentifierSchema,
});

export const ChannelResourceIdentifierSchema = z
	.object({
		typeId: ReferenceTypeIdSchema,
		id: z.string().nullish(),
		key: z.string().nullish(),
	})
	.refine((data) => data.id !== undefined || data.key !== undefined, {
		message: "Either 'id' or 'key' must be provided",
	});

export const MoneySchema = z.object({
	centAmount: z.number().int(),
	currencyCode: CurrencyCodeSchema,
});

export const ExternalLineItemTotalPriceSchema = z.object({
	price: MoneySchema,
	totalPrice: MoneySchema,
});

export const SubRateSchema = z.object({
	name: z.string(),
	amount: z.number(),
});

export const ExternalTaxRateDraftSchema = z.object({
	name: z.string(),
	amount: z.number().nullish(),
	includedInPrice: z.boolean().nullish(),
	country: CountryCodeSchema,
	state: z.string().nullish(),
	subRates: z.array(SubRateSchema).nullish(),
});

export const MethodExternalTaxRateDraftSchema = z.object({
	shippingMethodKey: z.string(),
	taxRate: ExternalTaxRateDraftSchema.nullish(),
});

export const ItemShippingTargetSchema = z.object({
	addressKey: z.string(),
	quantity: z.number().int(),
	shippingMethodKey: z.string().nullish(),
});

export const ItemShippingDetailsDraftSchema = z.object({
	targets: z.array(ItemShippingTargetSchema),
});

export const RecurrencePolicyResourceIdentifierSchema = z
	.object({
		typeId: ReferenceTypeIdSchema,
		id: z.string().nullish(),
		key: z.string().nullish(),
	})
	.refine((data) => data.id !== undefined || data.key !== undefined, {
		message: "Either 'id' or 'key' must be provided",
	});

export const LineItemRecurrenceInfoDraftSchema = z.object({
	recurrencePolicy: RecurrencePolicyResourceIdentifierSchema,
	priceSelectionMode: PriceSelectionModeSchema,
});

export const LineItemDraftSchema = z.object({
	key: z.string().nullish(),
	productId: z.string().nullish(),
	variantId: z.number().int().nullish(),
	sku: z.string().nullish(),
	quantity: z.number().int().nullish(),
	addedAt: z.string().nullish(),
	distributionChannel: ChannelResourceIdentifierSchema.nullish(),
	supplyChannel: ChannelResourceIdentifierSchema.nullish(),
	externalPrice: MoneySchema.nullish(),
	externalTotalPrice: ExternalLineItemTotalPriceSchema.nullish(),
	externalTaxRate: ExternalTaxRateDraftSchema.nullish(),
	perMethodExternalTaxRate: z.array(MethodExternalTaxRateDraftSchema).nullish(),
	inventoryMode: InventoryModeSchema.nullish(),
	shippingDetails: ItemShippingDetailsDraftSchema.nullish(),
	custom: CustomFieldsDraftSchema.nullish(),
	recurrenceInfo: LineItemRecurrenceInfoDraftSchema.nullish(),
});

export const TaxCategoryResourceIdentifierSchema = z
	.object({
		typeId: ReferenceTypeIdSchema,
		id: z.string().nullish(),
		key: z.string().nullish(),
	})
	.refine((data) => data.id !== undefined || data.key !== undefined, {
		message: "Either 'id' or 'key' must be provided",
	});

export const CustomLineItemRecurrenceInfoDraftSchema = z.object({
	recurrencePolicy: RecurrencePolicyResourceIdentifierSchema,
});

export const CustomLineItemDraftSchema = z.object({
	name: LocalizedStringSchema,
	key: z.string().nullish(),
	quantity: z.number().int().nullish(),
	money: MoneySchema,
	slug: z.string(),
	taxCategory: TaxCategoryResourceIdentifierSchema.nullish(),
	externalTaxRate: ExternalTaxRateDraftSchema.nullish(),
	custom: CustomFieldsDraftSchema.nullish(),
	shippingDetails: ItemShippingDetailsDraftSchema.nullish(),
	priceMode: CustomLineItemPriceModeSchema.nullish(),
	recurrenceInfo: CustomLineItemRecurrenceInfoDraftSchema.nullish(),
});

export const ShippingMethodResourceIdentifierSchema = z
	.object({
		typeId: ReferenceTypeIdSchema,
		id: z.string().nullish(),
		key: z.string().nullish(),
	})
	.refine((data) => data.id !== undefined || data.key !== undefined, {
		message: "Either 'id' or 'key' must be provided",
	});

export const ClassificationShippingRateInputDraftSchema = z.object({
	type: z.literal("Classification"),
	key: z.string(),
});

export const ScoreShippingRateInputDraftSchema = z.object({
	type: z.literal("Score"),
	score: z.number().int(),
});

export const ShippingRateInputDraftSchema = z.discriminatedUnion("type", [
	ClassificationShippingRateInputDraftSchema,
	ScoreShippingRateInputDraftSchema,
]);

export const CartClassificationTierSchema = z.object({
	type: z.literal("CartClassification"),
	value: z.string(),
	price: MoneySchema,
	isMatching: z.boolean().nullish(),
});

export const PriceFunctionSchema = z.object({
	currencyCode: CurrencyCodeSchema,
	function: z.string(),
});

export const CartScoreTierSchema = z.object({
	type: z.literal("CartScore"),
	score: z.number().int(),
	price: MoneySchema.nullish(),
	priceFunction: PriceFunctionSchema.nullish(),
	isMatching: z.boolean().nullish(),
});

export const CartValueTierSchema = z.object({
	type: z.literal("CartValue"),
	minimumCentAmount: z.number().int(),
	price: MoneySchema,
	isMatching: z.boolean().nullish(),
});

export const ShippingRatePriceTierSchema = z.discriminatedUnion("type", [
	CartClassificationTierSchema,
	CartScoreTierSchema,
	CartValueTierSchema,
]);

export const ShippingRateDraftSchema = z.object({
	price: MoneySchema,
	freeAbove: MoneySchema.nullish(),
	tiers: z.array(ShippingRatePriceTierSchema).nullish(),
});

export const DeliveryItemSchema = z.object({
	id: z.string(),
	quantity: z.number().int(),
});

export const ParcelMeasurementsSchema = z.object({
	heightInMillimeter: z.number().int().nullish(),
	lengthInMillimeter: z.number().int().nullish(),
	widthInMillimeter: z.number().int().nullish(),
	weightInGram: z.number().int().nullish(),
});

export const TrackingDataSchema = z.object({
	trackingId: z.string().nullish(),
	carrier: z.string().nullish(),
	provider: z.string().nullish(),
	providerTransaction: z.string().nullish(),
	isReturn: z.boolean().nullish(),
});

export const ParcelDraftSchema = z.object({
	key: z.string().nullish(),
	measurements: ParcelMeasurementsSchema.nullish(),
	trackingData: TrackingDataSchema.nullish(),
	items: z.array(DeliveryItemSchema).nullish(),
	custom: CustomFieldsDraftSchema.nullish(),
});

export const AddressDraftSchema = z.object({
	id: z.string().nullish(),
	key: z.string().nullish(),
	country: CountryCodeSchema,
	title: z.string().nullish(),
	salutation: z.string().nullish(),
	firstName: z.string().nullish(),
	lastName: z.string().nullish(),
	streetName: z.string().nullish(),
	streetNumber: z.string().nullish(),
	additionalStreetInfo: z.string().nullish(),
	postalCode: z.string().nullish(),
	city: z.string().nullish(),
	region: z.string().nullish(),
	state: z.string().nullish(),
	company: z.string().nullish(),
	department: z.string().nullish(),
	building: z.string().nullish(),
	apartment: z.string().nullish(),
	pOBox: z.string().nullish(),
	phone: z.string().nullish(),
	mobile: z.string().nullish(),
	email: z.string().nullish(),
	fax: z.string().nullish(),
	additionalAddressInfo: z.string().nullish(),
	externalId: z.string().nullish(),
	custom: CustomFieldsDraftSchema.nullish(),
});

export const DeliveryDraftSchema = z.object({
	key: z.string().nullish(),
	items: z.array(DeliveryItemSchema).nullish(),
	parcels: z.array(ParcelDraftSchema).nullish(),
	address: AddressDraftSchema.nullish(),
	custom: CustomFieldsDraftSchema.nullish(),
});

export const CustomShippingDraftSchema = z.object({
	key: z.string(),
	shippingMethodName: z.string(),
	shippingAddress: BaseAddressSchema.nullish(),
	shippingRate: ShippingRateDraftSchema,
	shippingRateInput: ShippingRateInputDraftSchema.nullish(),
	taxCategory: TaxCategoryResourceIdentifierSchema.nullish(),
	externalTaxRate: ExternalTaxRateDraftSchema.nullish(),
	deliveries: z.array(DeliveryDraftSchema).nullish(),
	custom: CustomFieldsDraftSchema.nullish(),
});

export const ShippingMethodReferenceSchema = z.object({
	typeId: ReferenceTypeIdSchema,
	id: z.string(),
});

export const ShippingDraftSchema = z.object({
	key: z.string(),
	shippingMethod: ShippingMethodReferenceSchema.nullish(),
	shippingAddress: BaseAddressSchema,
	shippingRateInput: ShippingRateInputDraftSchema.nullish(),
	externalTaxRate: ExternalTaxRateDraftSchema.nullish(),
	deliveries: z.array(DeliveryDraftSchema).nullish(),
	custom: CustomFieldsDraftSchema.nullish(),
});

export const CartDiscountValueAbsoluteDraftSchema = z.object({
	type: z.literal("absolute"),
	money: z.array(MoneySchema),
	applicationMode: DiscountApplicationModeSchema.nullish(),
});

export const TypedMoneyDraftSchema = z.object({
	centAmount: z.number().int(),
	currencyCode: CurrencyCodeSchema,
	type: MoneyTypeSchema,
	fractionDigits: z.number().int().nullish(),
});

export const CartDiscountValueFixedDraftSchema = z.object({
	type: z.literal("fixed"),
	money: z.array(TypedMoneyDraftSchema),
	applicationMode: DiscountApplicationModeSchema.nullish(),
});

export const ProductResourceIdentifierSchema = z
	.object({
		typeId: ReferenceTypeIdSchema,
		id: z.string().nullish(),
		key: z.string().nullish(),
	})
	.refine((data) => data.id !== undefined || data.key !== undefined, {
		message: "Either 'id' or 'key' must be provided",
	});

export const CartDiscountValueGiftLineItemDraftSchema = z.object({
	type: z.literal("giftLineItem"),
	product: ProductResourceIdentifierSchema,
	variantId: z.number().int(),
	supplyChannel: ChannelResourceIdentifierSchema.nullish(),
	distributionChannel: ChannelResourceIdentifierSchema.nullish(),
});

export const CartDiscountValueRelativeDraftSchema = z.object({
	type: z.literal("relative"),
	permyriad: z.number().int(),
	applicationMode: DiscountApplicationModeSchema.nullish(),
});

export const CartDiscountValueDraftSchema = z.discriminatedUnion("type", [
	CartDiscountValueAbsoluteDraftSchema,
	CartDiscountValueFixedDraftSchema,
	CartDiscountValueGiftLineItemDraftSchema,
	CartDiscountValueRelativeDraftSchema,
]);

export const CartDiscountTargetSchema = z.object({
	type: z.string(),
});

export const DiscountGroupResourceIdentifierSchema = z
	.object({
		typeId: ReferenceTypeIdSchema,
		id: z.string().nullish(),
		key: z.string().nullish(),
	})
	.refine((data) => data.id !== undefined || data.key !== undefined, {
		message: "Either 'id' or 'key' must be provided",
	});

export const AnyOrderDraftSchema = z.object({
	type: z.literal("AnyOrder"),
});

export const ApplicableRecurrencePoliciesDraftSchema = z.object({
	type: z.literal("ApplicableRecurrencePolicies"),
	recurrencePolicies: z.array(RecurrencePolicyResourceIdentifierSchema),
});

export const NonRecurringOrdersOnlyDraftSchema = z.object({
	type: z.literal("NonRecurringOrdersOnly"),
});

export const RecurringOrdersOnlyDraftSchema = z.object({
	type: z.literal("RecurringOrdersOnly"),
});

export const RecurringOrderScopeDraftSchema = z.discriminatedUnion("type", [
	AnyOrderDraftSchema,
	ApplicableRecurrencePoliciesDraftSchema,
	NonRecurringOrdersOnlyDraftSchema,
	RecurringOrdersOnlyDraftSchema,
]);

export const CategoryResourceIdentifierSchema = z
	.object({
		typeId: ReferenceTypeIdSchema,
		id: z.string().nullish(),
		key: z.string().nullish(),
	})
	.refine((data) => data.id !== undefined || data.key !== undefined, {
		message: "Either 'id' or 'key' must be provided",
	});

export const AssetDimensionsSchema = z.object({
	w: z.number().int(),
	h: z.number().int(),
});

export const AssetSourceSchema = z.object({
	uri: z.string(),
	key: z.string().nullish(),
	dimensions: AssetDimensionsSchema.nullish(),
	contentType: z.string().nullish(),
});

export const AssetDraftSchema = z.object({
	sources: z.array(AssetSourceSchema),
	name: LocalizedStringSchema,
	description: LocalizedStringSchema.nullish(),
	tags: z.array(z.string()).nullish(),
	custom: CustomFieldsDraftSchema.nullish(),
	key: z.string().nullish(),
});

export const GeoJsonPointSchema = z.object({
	type: z.literal("Point"),
	coordinates: z.array(z.number()),
});

export const GeoJsonSchema = z.object({
	type: z.string(),
	coordinates: z.array(z.number()),
});

export const CartResourceIdentifierSchema = z
	.object({
		typeId: ReferenceTypeIdSchema,
		id: z.string().nullish(),
		key: z.string().nullish(),
	})
	.refine((data) => data.id !== undefined || data.key !== undefined, {
		message: "Either 'id' or 'key' must be provided",
	});

export const CartDiscountResourceIdentifierSchema = z
	.object({
		typeId: ReferenceTypeIdSchema,
		id: z.string().nullish(),
		key: z.string().nullish(),
	})
	.refine((data) => data.id !== undefined || data.key !== undefined, {
		message: "Either 'id' or 'key' must be provided",
	});

export const AWSLambdaDestinationSchema = z.object({
	type: z.literal("AWSLambda"),
	arn: z.string(),
	accessKey: z.string(),
	accessSecret: z.string(),
});

export const GoogleCloudFunctionDestinationSchema = z.object({
	type: z.literal("GoogleCloudFunction"),
	url: z.string(),
});

export const AuthorizationHeaderAuthenticationSchema = z.object({
	type: z.literal("AuthorizationHeader"),
	headerValue: z.string(),
});

export const AzureFunctionsAuthenticationSchema = z.object({
	type: z.literal("AzureFunctions"),
	key: z.string(),
});

export const HttpDestinationAuthenticationSchema = z.discriminatedUnion(
	"type",
	[AuthorizationHeaderAuthenticationSchema, AzureFunctionsAuthenticationSchema],
);

export const HttpDestinationSchema = z.object({
	type: z.literal("HTTP"),
	url: z.string(),
	authentication: HttpDestinationAuthenticationSchema.nullish(),
});

export const ExtensionDestinationSchema = z.discriminatedUnion("type", [
	AWSLambdaDestinationSchema,
	GoogleCloudFunctionDestinationSchema,
	HttpDestinationSchema,
]);

export const ExtensionTriggerSchema = z.object({
	resourceTypeId: ExtensionResourceTypeIdSchema,
	actions: z.array(ExtensionActionSchema),
	condition: z.string().nullish(),
});

export const ExtensionResourceIdentifierSchema = z
	.object({
		typeId: ReferenceTypeIdSchema,
		id: z.string().nullish(),
		key: z.string().nullish(),
	})
	.refine((data) => data.id !== undefined || data.key !== undefined, {
		message: "Either 'id' or 'key' must be provided",
	});

export const ExtensionAdditionalContextDraftSchema = z.object({
	includeOldResource: z.boolean().nullish(),
});

export const InventoryEntryStockLevelsSchema = z.object({
	reorderPoint: z.number().int().nullish(),
	safetyStock: z.number().int().nullish(),
});

export const OrderReferenceSchema = z.object({
	typeId: ReferenceTypeIdSchema,
	id: z.string(),
});

export const StagedOrderUpdateActionSchema = z.object({
	action: z.string(),
});

export const StateResourceIdentifierSchema = z
	.object({
		typeId: ReferenceTypeIdSchema,
		id: z.string().nullish(),
		key: z.string().nullish(),
	})
	.refine((data) => data.id !== undefined || data.key !== undefined, {
		message: "Either 'id' or 'key' must be provided",
	});

export const QuoteResourceIdentifierSchema = z
	.object({
		typeId: ReferenceTypeIdSchema,
		id: z.string().nullish(),
		key: z.string().nullish(),
	})
	.refine((data) => data.id !== undefined || data.key !== undefined, {
		message: "Either 'id' or 'key' must be provided",
	});

export const PaymentMethodTokenSchema = z.object({
	value: z.string(),
});

export const PaymentMethodInfoDraftSchema = z.object({
	paymentInterface: z.string().nullish(),
	method: z.string().nullish(),
	name: LocalizedStringSchema.nullish(),
	token: PaymentMethodTokenSchema.nullish(),
	interfaceAccount: z.string().nullish(),
	custom: CustomFieldsDraftSchema.nullish(),
});

export const PaymentStatusDraftSchema = z.object({
	interfaceCode: z.string().nullish(),
	interfaceText: z.string().nullish(),
	state: StateResourceIdentifierSchema.nullish(),
});

export const TransactionDraftSchema = z.object({
	timestamp: z.string().nullish(),
	type: TransactionTypeSchema,
	amount: MoneySchema,
	interactionId: z.string().nullish(),
	state: TransactionStateSchema.nullish(),
	custom: CustomFieldsDraftSchema.nullish(),
	interfaceId: z.string().nullish(),
});

export const ProductTypeResourceIdentifierSchema = z
	.object({
		typeId: ReferenceTypeIdSchema,
		id: z.string().nullish(),
		key: z.string().nullish(),
	})
	.refine((data) => data.id !== undefined || data.key !== undefined, {
		message: "Either 'id' or 'key' must be provided",
	});

export const CategoryOrderHintsSchema = z.record(z.string(), z.string());

export const ProductDiscountReferenceSchema = z.object({
	typeId: ReferenceTypeIdSchema,
	id: z.string(),
});

export const DiscountedPriceDraftSchema = z.object({
	value: MoneySchema,
	discount: ProductDiscountReferenceSchema,
});

export const PriceTierDraftSchema = z.object({
	minimumQuantity: z.number().int(),
	value: MoneySchema,
});

export const PriceDraftSchema = z.object({
	key: z.string().nullish(),
	value: MoneySchema,
	country: CountryCodeSchema.nullish(),
	customerGroup: CustomerGroupResourceIdentifierSchema.nullish(),
	channel: ChannelResourceIdentifierSchema.nullish(),
	validFrom: z.string().nullish(),
	validUntil: z.string().nullish(),
	discounted: DiscountedPriceDraftSchema.nullish(),
	tiers: z.array(PriceTierDraftSchema).nullish(),
	custom: CustomFieldsDraftSchema.nullish(),
	recurrencePolicy: RecurrencePolicyResourceIdentifierSchema.nullish(),
});

export const AttributeSchema = z.object({
	name: z.string(),
	value: z.unknown(),
});

export const ImageDimensionsSchema = z.object({
	w: z.number().int(),
	h: z.number().int(),
});

export const ImageSchema = z.object({
	url: z.string(),
	dimensions: ImageDimensionsSchema,
	label: z.string().nullish(),
});

export const ProductVariantDraftSchema = z.object({
	sku: z.string().nullish(),
	key: z.string().nullish(),
	prices: z.array(PriceDraftSchema).nullish(),
	attributes: z.array(AttributeSchema).nullish(),
	images: z.array(ImageSchema).nullish(),
	assets: z.array(AssetDraftSchema).nullish(),
});

export const SearchKeywordsSchema = z.record(z.string(), z.string());

export const ProductDiscountValueAbsoluteDraftSchema = z.object({
	type: z.literal("absolute"),
	money: z.array(MoneySchema),
});

export const ProductDiscountValueExternalDraftSchema = z.object({
	type: z.literal("external"),
});

export const ProductDiscountValueRelativeDraftSchema = z.object({
	type: z.literal("relative"),
	permyriad: z.number().int(),
});

export const ProductDiscountValueDraftSchema = z.discriminatedUnion("type", [
	ProductDiscountValueAbsoluteDraftSchema,
	ProductDiscountValueExternalDraftSchema,
	ProductDiscountValueRelativeDraftSchema,
]);

export const TypeReferenceSchema = z.object({
	typeId: ReferenceTypeIdSchema,
	id: z.string(),
});

export const CustomFieldsSchema = z.object({
	type: TypeReferenceSchema,
	fields: FieldContainerSchema,
});

export const AssetSchema = z.object({
	id: z.string(),
	sources: z.array(AssetSourceSchema),
	name: LocalizedStringSchema,
	description: LocalizedStringSchema.nullish(),
	tags: z.array(z.string()).nullish(),
	custom: CustomFieldsSchema.nullish(),
	key: z.string().nullish(),
});

export const ProductTailoringAttributeSchema = z.object({
	name: z.string(),
	value: z.unknown(),
});

export const ProductVariantTailoringDraftSchema = z.object({
	id: z.number().int().nullish(),
	sku: z.string().nullish(),
	images: z.array(ImageSchema).nullish(),
	assets: z.array(AssetSchema).nullish(),
	attributes: z.array(ProductTailoringAttributeSchema).nullish(),
});

export const AttributeTypeSchema = z.object({
	name: z.string(),
});

export const AttributeDefinitionDraftSchema = z.object({
	type: AttributeTypeSchema,
	name: z.string(),
	label: LocalizedStringSchema,
	isRequired: z.boolean(),
	level: AttributeLevelEnumSchema.nullish(),
	attributeConstraint: AttributeConstraintEnumSchema.nullish(),
	inputTip: LocalizedStringSchema.nullish(),
	inputHint: TextInputHintSchema.nullish(),
	isSearchable: z.boolean().nullish(),
});

export const StagedQuoteResourceIdentifierSchema = z
	.object({
		typeId: ReferenceTypeIdSchema,
		id: z.string().nullish(),
		key: z.string().nullish(),
	})
	.refine((data) => data.id !== undefined || data.key !== undefined, {
		message: "Either 'id' or 'key' must be provided",
	});

export const StateReferenceSchema = z.object({
	typeId: ReferenceTypeIdSchema,
	id: z.string(),
});

export const DayOfMonthScheduleDraftSchema = z.object({
	type: z.literal("dayOfMonth"),
	day: z.number().int(),
});

export const StandardScheduleDraftSchema = z.object({
	type: z.literal("standard"),
	value: z.number().int(),
	intervalUnit: IntervalUnitSchema,
});

export const RecurrencePolicyScheduleDraftSchema = z.discriminatedUnion(
	"type",
	[DayOfMonthScheduleDraftSchema, StandardScheduleDraftSchema],
);

export const ZoneResourceIdentifierSchema = z
	.object({
		typeId: ReferenceTypeIdSchema,
		id: z.string().nullish(),
		key: z.string().nullish(),
	})
	.refine((data) => data.id !== undefined || data.key !== undefined, {
		message: "Either 'id' or 'key' must be provided",
	});

export const ZoneRateDraftSchema = z.object({
	zone: ZoneResourceIdentifierSchema,
	shippingRates: z.array(ShippingRateDraftSchema),
});

export const ShoppingListLineItemDraftSchema = z.object({
	key: z.string().nullish(),
	productId: z.string().nullish(),
	variantId: z.number().int().nullish(),
	sku: z.string().nullish(),
	addedAt: z.string().nullish(),
	custom: CustomFieldsDraftSchema.nullish(),
	quantity: z.number().int().nullish(),
});

export const TextLineItemDraftSchema = z.object({
	key: z.string().nullish(),
	addedAt: z.string().nullish(),
	custom: CustomFieldsDraftSchema.nullish(),
	description: LocalizedStringSchema.nullish(),
	name: LocalizedStringSchema,
	quantity: z.number().int().nullish(),
});

export const StagedPriceDraftSchema = z.object({
	value: TypedMoneyDraftSchema,
});

export const QuoteRequestResourceIdentifierSchema = z
	.object({
		typeId: ReferenceTypeIdSchema,
		id: z.string().nullish(),
		key: z.string().nullish(),
	})
	.refine((data) => data.id !== undefined || data.key !== undefined, {
		message: "Either 'id' or 'key' must be provided",
	});

export const StoreCountrySchema = z.object({
	code: CountryCodeSchema,
});

export const ProductSelectionResourceIdentifierSchema = z
	.object({
		typeId: ReferenceTypeIdSchema,
		id: z.string().nullish(),
		key: z.string().nullish(),
	})
	.refine((data) => data.id !== undefined || data.key !== undefined, {
		message: "Either 'id' or 'key' must be provided",
	});

export const ProductSelectionSettingDraftSchema = z.object({
	productSelection: ProductSelectionResourceIdentifierSchema,
	active: z.boolean().nullish(),
});

export const StorefrontSchema = z.object({
	checkoutUrlTemplate: z.string().nullish(),
	orderUrlTemplate: z.string().nullish(),
	termsOfServiceUrl: z.string().nullish(),
	privacyPolicyUrl: z.string().nullish(),
	refundPolicyUrl: z.string().nullish(),
	shippingPolicyUrl: z.string().nullish(),
	cookiePolicyUrl: z.string().nullish(),
	imprintUrl: z.string().nullish(),
	faqUrl: z.string().nullish(),
	contactUrl: z.string().nullish(),
});

export const DestinationSchema = z.object({
	type: z.string(),
});

export const MessageSubscriptionSchema = z.object({
	resourceTypeId: MessageSubscriptionResourceTypeIdSchema,
	types: z.array(z.string()).nullish(),
});

export const ChangeSubscriptionSchema = z.object({
	resourceTypeId: ChangeSubscriptionResourceTypeIdSchema,
});

export const EventSubscriptionSchema = z.object({
	resourceTypeId: EventSubscriptionResourceTypeIdSchema,
	types: z.array(EventTypeSchema).nullish(),
});

export const CloudEventsFormatSchema = z.object({
	type: z.literal("CloudEvents"),
	cloudEventsVersion: z.string(),
});

export const PlatformFormatSchema = z.object({
	type: z.literal("Platform"),
});

export const DeliveryFormatSchema = z.discriminatedUnion("type", [
	CloudEventsFormatSchema,
	PlatformFormatSchema,
]);

export const TaxRateDraftSchema = z.object({
	name: z.string(),
	amount: z.number().nullish(),
	includedInPrice: z.boolean(),
	country: CountryCodeSchema,
	state: z.string().nullish(),
	subRates: z.array(SubRateSchema).nullish(),
	key: z.string().nullish(),
});

export const FieldTypeSchema = z.object({
	name: z.string(),
});

export const FieldDefinitionSchema = z.object({
	type: FieldTypeSchema,
	name: z.string(),
	label: LocalizedStringSchema,
	required: z.boolean(),
	inputHint: TypeTextInputHintSchema.nullish(),
});

export const LocationSchema = z.object({
	country: CountryCodeSchema,
	state: z.string().nullish(),
});