@eventconnectors/ndtrc_model 1.1.0 → 1.4.0

package/dist/index.cjs

@@ -0,0 +1,934 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AddressSchema: () => AddressSchema,
+  CalendarCommentSchema: () => CalendarCommentSchema,
+  CalendarResponseSchema: () => CalendarResponseSchema,
+  CalendarSchema: () => CalendarSchema,
+  CalendarTypeSchema: () => CalendarTypeSchema,
+  CanonicalConfigSchema: () => CanonicalConfigSchema,
+  CategorySchema: () => CategorySchema,
+  CategoryTranslationSchema: () => CategoryTranslationSchema,
+  CategoryValueSchema: () => CategoryValueSchema,
+  CommentTranslationSchema: () => CommentTranslationSchema,
+  ContactinfoSchema: () => ContactinfoSchema,
+  ConvertedEntrySchema: () => ConvertedEntrySchema,
+  DataTypeSchema: () => DataTypeSchema,
+  DescriptionTranslationSchema: () => DescriptionTranslationSchema,
+  DiscountSchema: () => DiscountSchema,
+  EntityTypeSchema: () => EntityTypeSchema,
+  EventLinkSchema: () => EventLinkSchema,
+  ExceptionDateSchema: () => ExceptionDateSchema,
+  ExternalLocationInfoSchema: () => ExternalLocationInfoSchema,
+  ExtraInformationSchema: () => ExtraInformationSchema,
+  ExtraPriceInformationSchema: () => ExtraPriceInformationSchema,
+  FaxSchema: () => FaxSchema,
+  FetchedEntrySchema: () => FetchedEntrySchema,
+  FileSchema: () => FileSchema,
+  FileTypeSchema: () => FileTypeSchema,
+  GISCoordinateSchema: () => GISCoordinateSchema,
+  LangCodeSchema: () => LangCodeSchema,
+  LatLngSchema: () => LatLngSchema,
+  LocationItemSchema: () => LocationItemSchema,
+  LocationSchema: () => LocationSchema,
+  MailSchema: () => MailSchema,
+  MediaTypeSchema: () => MediaTypeSchema,
+  OGTypeSchema: () => OGTypeSchema,
+  OpenSchema: () => OpenSchema,
+  PatternDateSchema: () => PatternDateSchema,
+  PerformerSchema: () => PerformerSchema,
+  PhoneSchema: () => PhoneSchema,
+  PoiCategorySchema: () => PoiCategorySchema,
+  PoiSchema: () => PoiSchema,
+  PriceDescriptionValueSchema: () => PriceDescriptionValueSchema,
+  PriceElementCommentSchema: () => PriceElementCommentSchema,
+  PriceElementDescriptionSchema: () => PriceElementDescriptionSchema,
+  PriceElementDescriptionTranslationSchema: () => PriceElementDescriptionTranslationSchema,
+  PriceElementExtraPriceInformationSchema: () => PriceElementExtraPriceInformationSchema,
+  PriceElementSchema: () => PriceElementSchema,
+  PriceValueSchema: () => PriceValueSchema,
+  PromotionSchema: () => PromotionSchema,
+  PromotionTranslationSchema: () => PromotionTranslationSchema,
+  PromotionTypeSchema: () => PromotionTypeSchema,
+  RecurrencyTypeSchema: () => RecurrencyTypeSchema,
+  RouteDifficultySchema: () => RouteDifficultySchema,
+  RouteInfoSchema: () => RouteInfoSchema,
+  RouteInfoTypeSchema: () => RouteInfoTypeSchema,
+  RouteTypeSchema: () => RouteTypeSchema,
+  SeoDetailSchema: () => SeoDetailSchema,
+  SeoMetadataSchema: () => SeoMetadataSchema,
+  SingleDateSchema: () => SingleDateSchema,
+  StandardPriceDescriptionValues: () => StandardPriceDescriptionValues,
+  StatusTranslationSchema: () => StatusTranslationSchema,
+  SubItemGroupSchema: () => SubItemGroupSchema,
+  SubItemTranslationSchema: () => SubItemTranslationSchema,
+  SurfaceTypeSchema: () => SurfaceTypeSchema,
+  TRCItemCategoriesSchema: () => TRCItemCategoriesSchema,
+  TRCItemDetailSchema: () => TRCItemDetailSchema,
+  TRCItemGroupSchema: () => TRCItemGroupSchema,
+  TRCItemResponseSchema: () => TRCItemResponseSchema,
+  TRCItemSchema: () => TRCItemSchema,
+  TitleSchema: () => TitleSchema,
+  TitleTranslationSchema: () => TitleTranslationSchema,
+  TranslationsSchema: () => TranslationsSchema,
+  TrcitemRelationSchema: () => TrcitemRelationSchema,
+  TwitterCardTypeSchema: () => TwitterCardTypeSchema,
+  TypeSchema: () => TypeSchema,
+  URLServiceTypeSchema: () => URLServiceTypeSchema,
+  UrlSchema: () => UrlSchema,
+  ValidityStrategySchema: () => ValidityStrategySchema,
+  WFStatusSchema: () => WFStatusSchema,
+  WhenSchema: () => WhenSchema,
+  WhenStatusSchema: () => WhenStatusSchema
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/address.ts
+var import_zod2 = require("zod");
+
+// src/gis-coordinate.ts
+var import_zod = require("zod");
+var numericString = (min, max) => import_zod.z.string().refine(
+  (v) => {
+    const n = Number(v);
+    return !Number.isNaN(n) && n >= min && n <= max;
+  },
+  { message: `Must be a numeric string in [${min}, ${max}]` }
+);
+var GISCoordinateSchema = import_zod.z.object({
+  xcoordinate: numericString(-180, 180).optional(),
+  ycoordinate: numericString(-90, 90).optional(),
+  label: import_zod.z.string().optional()
+}).passthrough();
+
+// src/address.ts
+var AddressSchema = import_zod2.z.object({
+  main: import_zod2.z.boolean().optional(),
+  reservation: import_zod2.z.boolean().optional(),
+  title: import_zod2.z.string().optional(),
+  city: import_zod2.z.string().optional(),
+  citytrcid: import_zod2.z.string().optional(),
+  country: import_zod2.z.string().optional(),
+  housenr: import_zod2.z.string().optional(),
+  street: import_zod2.z.string().optional(),
+  streettrcid: import_zod2.z.string().optional(),
+  zipcode: import_zod2.z.string().optional(),
+  province: import_zod2.z.string().optional(),
+  neighbourhood: import_zod2.z.string().optional(),
+  district: import_zod2.z.string().optional(),
+  gisCoordinates: import_zod2.z.array(GISCoordinateSchema).optional()
+}).passthrough();
+
+// src/converted-entry.ts
+var import_zod20 = require("zod");
+
+// src/trc-item.ts
+var import_zod19 = require("zod");
+
+// src/calendar.ts
+var import_zod5 = require("zod");
+
+// src/internal/lang-code.ts
+var import_zod3 = require("zod");
+var LangCodeSchema = import_zod3.z.string().regex(/^[a-z]{2}$/, {
+  message: "Must be a lowercase ISO 639-1 two-letter language code"
+});
+
+// src/contactinfo.ts
+var import_zod4 = require("zod");
+var URLServiceTypeSchema = import_zod4.z.enum([
+  "general",
+  "booking",
+  "review",
+  "video",
+  "webshop",
+  "socialmedia",
+  "lastminute",
+  "virtualtour",
+  "dmo",
+  "sustainability",
+  "venuefinder",
+  "travelbase",
+  "homepage"
+]);
+var DescriptionTranslationSchema = import_zod4.z.object({
+  lang: LangCodeSchema.optional(),
+  label: import_zod4.z.string().optional()
+}).passthrough();
+var MailSchema = import_zod4.z.object({
+  email: import_zod4.z.string().email().optional(),
+  descriptioncode: import_zod4.z.string().optional(),
+  reservations: import_zod4.z.boolean().optional(),
+  descriptionTranslations: import_zod4.z.array(DescriptionTranslationSchema).optional()
+}).passthrough();
+var PhoneSchema = import_zod4.z.object({
+  number: import_zod4.z.string().optional(),
+  descriptioncode: import_zod4.z.string().optional(),
+  reservations: import_zod4.z.boolean().optional(),
+  descriptionTranslations: import_zod4.z.array(DescriptionTranslationSchema).optional()
+}).passthrough();
+var FaxSchema = import_zod4.z.object({
+  number: import_zod4.z.string().optional(),
+  descriptioncode: import_zod4.z.string().optional(),
+  reservations: import_zod4.z.boolean().optional(),
+  descriptionTranslations: import_zod4.z.array(DescriptionTranslationSchema).optional()
+}).passthrough();
+var UrlSchema = import_zod4.z.object({
+  url: import_zod4.z.string().url().optional(),
+  descriptioncode: import_zod4.z.string().optional(),
+  targetLanguage: LangCodeSchema.optional(),
+  reservations: import_zod4.z.boolean().optional(),
+  urlServiceType: URLServiceTypeSchema.optional(),
+  descriptionTranslations: import_zod4.z.array(DescriptionTranslationSchema).optional()
+}).passthrough();
+var ContactinfoSchema = import_zod4.z.object({
+  label: import_zod4.z.string().optional(),
+  /** @deprecated Use mail instead */
+  mails: import_zod4.z.array(MailSchema).optional(),
+  /** @deprecated Use phone instead */
+  phones: import_zod4.z.array(PhoneSchema).optional(),
+  /** @deprecated Use fax instead */
+  faxes: import_zod4.z.array(FaxSchema).optional(),
+  urls: import_zod4.z.array(UrlSchema).optional(),
+  /** @deprecated Use address instead */
+  addresses: import_zod4.z.array(AddressSchema).optional(),
+  mail: MailSchema.optional(),
+  phone: PhoneSchema.optional(),
+  fax: FaxSchema.optional(),
+  address: AddressSchema.optional()
+}).passthrough();
+
+// src/calendar.ts
+var CalendarTypeSchema = import_zod5.z.enum([
+  "NONE",
+  "ALWAYSOPEN",
+  "ONREQUEST",
+  "OPENINGTIMES",
+  "PATTERNDATES",
+  "SINGLEDATES"
+]);
+var RecurrencyTypeSchema = import_zod5.z.enum([
+  "daily",
+  "weekly",
+  "monthlySimple",
+  "monthlyComplex",
+  "yearly"
+]);
+var WhenStatusSchema = import_zod5.z.enum([
+  "normal",
+  "cancelled",
+  "soldout",
+  "movedto",
+  "premiere",
+  "reprise"
+]);
+var HHmm = import_zod5.z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, {
+  message: "Must be a 24-hour time in HH:mm format"
+});
+var StatusTranslationSchema = import_zod5.z.object({
+  lang: LangCodeSchema.optional(),
+  text: import_zod5.z.string().optional()
+}).passthrough();
+var ExtraInformationSchema = import_zod5.z.object({
+  lang: LangCodeSchema.optional(),
+  text: import_zod5.z.string().optional()
+}).passthrough();
+var WhenSchema = import_zod5.z.object({
+  timestart: HHmm.optional(),
+  timeend: HHmm.optional(),
+  status: WhenStatusSchema.optional(),
+  valid: import_zod5.z.boolean().optional(),
+  statustranslations: import_zod5.z.array(StatusTranslationSchema).optional(),
+  extrainformations: import_zod5.z.array(ExtraInformationSchema).optional(),
+  urls: import_zod5.z.array(UrlSchema).optional()
+}).passthrough();
+var SingleDateSchema = import_zod5.z.object({
+  date: import_zod5.z.string().optional(),
+  /** Wire-format wart: singular "when" holds a list of When, cf. ExceptionDate.whens */
+  when: import_zod5.z.array(WhenSchema).optional()
+}).passthrough();
+var OpenSchema = import_zod5.z.object({
+  month: import_zod5.z.number().int().optional(),
+  weeknumber: import_zod5.z.number().int().optional(),
+  daynumber: import_zod5.z.number().int().optional(),
+  day: import_zod5.z.number().int().optional(),
+  /** Wire-format wart: plural "whens" holds a list of When, cf. SingleDate.when */
+  whens: import_zod5.z.array(WhenSchema).optional()
+}).passthrough();
+var PatternDateSchema = import_zod5.z.object({
+  startdate: import_zod5.z.string().optional(),
+  enddate: import_zod5.z.string().optional(),
+  recurrencyType: RecurrencyTypeSchema.optional(),
+  occurrence: import_zod5.z.number().int().optional(),
+  recurrence: import_zod5.z.number().int().optional(),
+  opens: import_zod5.z.array(OpenSchema).optional()
+}).passthrough();
+var ExceptionDateSchema = import_zod5.z.object({
+  date: import_zod5.z.string().optional(),
+  /** Wire-format wart: plural "whens" holds a list of When, cf. SingleDate.when */
+  whens: import_zod5.z.array(WhenSchema).optional()
+}).passthrough();
+var CommentTranslationSchema = import_zod5.z.object({
+  label: import_zod5.z.string().optional(),
+  lang: LangCodeSchema.optional()
+}).passthrough();
+var CalendarCommentSchema = import_zod5.z.object({
+  label: import_zod5.z.string().optional(),
+  commentTranslations: import_zod5.z.array(CommentTranslationSchema).optional()
+}).passthrough();
+var CalendarSchema = import_zod5.z.object({
+  singleDates: import_zod5.z.array(SingleDateSchema).optional(),
+  patternDates: import_zod5.z.array(PatternDateSchema).optional(),
+  opens: import_zod5.z.array(ExceptionDateSchema).optional(),
+  closeds: import_zod5.z.array(ExceptionDateSchema).optional(),
+  soldouts: import_zod5.z.array(ExceptionDateSchema).optional(),
+  cancelleds: import_zod5.z.array(ExceptionDateSchema).optional(),
+  excludeholidays: import_zod5.z.boolean().optional(),
+  cancelled: import_zod5.z.boolean().optional(),
+  soldout: import_zod5.z.boolean().optional(),
+  onrequest: import_zod5.z.boolean().optional(),
+  alwaysopen: import_zod5.z.boolean().optional(),
+  comment: CalendarCommentSchema.optional(),
+  calendarType: CalendarTypeSchema.optional()
+}).passthrough();
+var CalendarResponseSchema = CalendarSchema.extend({
+  cancelled: import_zod5.z.boolean(),
+  soldout: import_zod5.z.boolean(),
+  excludeholidays: import_zod5.z.boolean(),
+  calendarType: CalendarTypeSchema
+});
+
+// src/extra-price-information.ts
+var import_zod6 = require("zod");
+var ExtraPriceInformationSchema = import_zod6.z.object({
+  lang: LangCodeSchema.optional(),
+  text: import_zod6.z.string().optional()
+}).passthrough();
+
+// src/file.ts
+var import_zod7 = require("zod");
+var FileTypeSchema = import_zod7.z.enum([
+  "jpeg",
+  "jpg",
+  "gif",
+  "png",
+  "mp3",
+  "pdf",
+  "gpx",
+  "kml",
+  "youtube",
+  "kmz",
+  "vimeo",
+  "tif",
+  "bmp",
+  "jfif",
+  "tiff",
+  "webp"
+]);
+var MediaTypeSchema = import_zod7.z.enum([
+  "poster",
+  "other",
+  "audio",
+  "brochure",
+  "floorplan",
+  "photo",
+  "logo",
+  "video",
+  "roadmap",
+  "text",
+  "attachment",
+  "qr"
+]);
+var TitleTranslationSchema = import_zod7.z.object({
+  lang: LangCodeSchema.optional(),
+  label: import_zod7.z.string().optional()
+}).passthrough();
+var TitleSchema = import_zod7.z.object({
+  label: import_zod7.z.string().optional(),
+  titleTranslations: import_zod7.z.array(TitleTranslationSchema).optional()
+}).passthrough();
+var FileSchema = import_zod7.z.object({
+  trcid: import_zod7.z.string().optional(),
+  main: import_zod7.z.boolean().optional(),
+  copyright: import_zod7.z.string().optional(),
+  filename: import_zod7.z.string().optional(),
+  hlink: import_zod7.z.string().url().optional(),
+  filetype: FileTypeSchema.optional(),
+  mediatype: MediaTypeSchema.optional(),
+  targetLanguage: LangCodeSchema.optional(),
+  title: TitleSchema.optional()
+}).passthrough();
+
+// src/location.ts
+var import_zod8 = require("zod");
+var LocationItemSchema = import_zod8.z.object({
+  id: import_zod8.z.string().optional(),
+  trcid: import_zod8.z.string().optional(),
+  text: import_zod8.z.string().optional()
+}).passthrough();
+var LocationSchema = import_zod8.z.object({
+  address: AddressSchema.optional(),
+  label: import_zod8.z.string().optional(),
+  locationItem: LocationItemSchema.optional(),
+  venueItem: LocationItemSchema.optional()
+}).passthrough();
+
+// src/performer.ts
+var import_zod9 = require("zod");
+var PerformerSchema = import_zod9.z.object({
+  roleid: import_zod9.z.string().optional(),
+  label: import_zod9.z.string().optional(),
+  rolelabel: import_zod9.z.string().optional()
+}).passthrough();
+
+// src/price-element.ts
+var import_zod10 = require("zod");
+var StandardPriceDescriptionValues = [
+  "Adults",
+  "Children",
+  "Groups",
+  "CJP",
+  "Pasholders",
+  "Lastminute"
+];
+var PriceDescriptionValueSchema = import_zod10.z.string();
+var PriceElementDescriptionTranslationSchema = import_zod10.z.object({
+  lang: LangCodeSchema.optional(),
+  text: import_zod10.z.string().optional()
+}).passthrough();
+var PriceElementExtraPriceInformationSchema = import_zod10.z.object({
+  lang: LangCodeSchema.optional(),
+  text: import_zod10.z.string().optional()
+}).passthrough();
+var PriceValueSchema = import_zod10.z.object({
+  from: import_zod10.z.number().optional(),
+  until: import_zod10.z.number().optional()
+}).passthrough();
+var PriceElementCommentSchema = import_zod10.z.object({
+  text: import_zod10.z.string().optional()
+}).passthrough();
+var PriceElementDescriptionSchema = import_zod10.z.object({
+  value: PriceDescriptionValueSchema.optional(),
+  descriptionTranslations: import_zod10.z.array(PriceElementDescriptionTranslationSchema).optional()
+}).passthrough();
+var PriceElementSchema = import_zod10.z.object({
+  freeentrance: import_zod10.z.boolean().optional(),
+  priceValue: PriceValueSchema.optional(),
+  description: PriceElementDescriptionSchema.optional(),
+  comments: import_zod10.z.array(PriceElementCommentSchema).optional(),
+  extraPriceInformations: import_zod10.z.array(PriceElementExtraPriceInformationSchema).optional()
+}).passthrough();
+
+// src/promotion.ts
+var import_zod11 = require("zod");
+var ValidityStrategySchema = import_zod11.z.enum([
+  "always",
+  "dateRange",
+  "earlyBird",
+  "lastMinute"
+]);
+var PromotionTypeSchema = import_zod11.z.enum([
+  "none",
+  "free",
+  "discount",
+  "gift",
+  "allowance"
+]);
+var DiscountSchema = import_zod11.z.object({
+  free: import_zod11.z.boolean().optional(),
+  percentage: import_zod11.z.number().int().optional(),
+  amount: import_zod11.z.number().optional()
+}).passthrough();
+var PromotionTranslationSchema = import_zod11.z.object({
+  lang: LangCodeSchema.optional(),
+  description: import_zod11.z.string().optional()
+}).passthrough();
+var PromotionOpenSchema = import_zod11.z.object({
+  month: import_zod11.z.number().int().optional(),
+  weeknumber: import_zod11.z.number().int().optional(),
+  daynumber: import_zod11.z.number().int().optional(),
+  day: import_zod11.z.number().int().optional(),
+  whens: import_zod11.z.array(import_zod11.z.any()).optional()
+}).passthrough();
+var PromotionSchema = import_zod11.z.object({
+  product: import_zod11.z.string().optional(),
+  externalReference: import_zod11.z.string().optional(),
+  promotionType: PromotionTypeSchema.optional(),
+  discount: DiscountSchema.optional(),
+  translations: import_zod11.z.array(PromotionTranslationSchema).optional(),
+  detailsUrls: import_zod11.z.array(UrlSchema).optional(),
+  enabled: import_zod11.z.boolean().optional(),
+  restrictedToRegisteredUsers: import_zod11.z.boolean().optional(),
+  validityStrategy: ValidityStrategySchema.optional(),
+  eventRelativeDuration: import_zod11.z.string().optional(),
+  startDate: import_zod11.z.string().datetime({ offset: true }).optional(),
+  endDate: import_zod11.z.string().datetime({ offset: true }).optional(),
+  opens: import_zod11.z.array(PromotionOpenSchema).optional()
+}).passthrough();
+
+// src/route-info.ts
+var import_zod13 = require("zod");
+
+// src/trc-item-detail.ts
+var import_zod12 = require("zod");
+var TRCItemDetailSchema = import_zod12.z.object({
+  lang: LangCodeSchema.optional(),
+  longdescription: import_zod12.z.string().optional(),
+  shortdescription: import_zod12.z.string().optional(),
+  title: import_zod12.z.string().optional()
+}).passthrough();
+
+// src/route-info.ts
+var RouteTypeSchema = import_zod13.z.enum([
+  "driving_traffic",
+  "driving",
+  "walking",
+  "cycling"
+]);
+var RouteInfoTypeSchema = import_zod13.z.enum([
+  "eventConnectors",
+  "route_maker",
+  "route_iq",
+  "odp_routes",
+  "other"
+]);
+var RouteDifficultySchema = import_zod13.z.enum([
+  "easy",
+  "moderate",
+  "challenging",
+  "difficult",
+  "expert"
+]);
+var SurfaceTypeSchema = import_zod13.z.enum([
+  "paved",
+  "gravel",
+  "dirt",
+  "sand",
+  "grass",
+  "cobblestone",
+  "boardwalk",
+  "rock",
+  "snow",
+  "water",
+  "mixed"
+]);
+var PoiCategorySchema = import_zod13.z.enum([
+  "museum",
+  "monument",
+  "castle",
+  "church",
+  "nature_area",
+  "parking",
+  "toilet",
+  "rest_area",
+  "picnic_area",
+  "hotel",
+  "camping",
+  "hostel",
+  "bed_breakfast",
+  "restaurant",
+  "cafe",
+  "bar",
+  "bakery",
+  "swimming",
+  "hiking_start",
+  "cycling_start",
+  "boat_rental",
+  "bus_stop",
+  "train_station",
+  "ferry",
+  "bike_rental",
+  "viewpoint",
+  "information_point",
+  "other"
+]);
+var LatLngSchema = import_zod13.z.object({
+  lat: import_zod13.z.number().optional(),
+  lng: import_zod13.z.number().optional(),
+  altitude: import_zod13.z.number().optional(),
+  label: import_zod13.z.string().optional()
+}).passthrough();
+var LocationItemRefSchema = import_zod13.z.object({
+  id: import_zod13.z.string().optional(),
+  trcid: import_zod13.z.string().optional(),
+  text: import_zod13.z.string().optional()
+}).passthrough();
+var LocationRefSchema = import_zod13.z.object({
+  address: AddressSchema.optional(),
+  label: import_zod13.z.string().optional(),
+  locationItem: LocationItemRefSchema.optional(),
+  venueItem: LocationItemRefSchema.optional()
+}).passthrough();
+var CalendarRefSchema = import_zod13.z.object({}).passthrough();
+var PoiSchema = import_zod13.z.object({
+  distanceInKilometersFromStart: import_zod13.z.number().optional(),
+  durationInMinutesFromStart: import_zod13.z.number().int().optional(),
+  coordinate: LatLngSchema.optional(),
+  location: LocationRefSchema.optional(),
+  label: import_zod13.z.string().optional(),
+  icon: import_zod13.z.string().optional(),
+  category: PoiCategorySchema.optional(),
+  trcItemDetails: import_zod13.z.array(TRCItemDetailSchema).optional(),
+  files: import_zod13.z.array(FileSchema).optional(),
+  calendar: CalendarRefSchema.optional(),
+  locationItem: LocationItemRefSchema.optional()
+}).passthrough();
+var RouteInfoSchema = import_zod13.z.object({
+  type: RouteInfoTypeSchema.optional(),
+  routeType: RouteTypeSchema.optional(),
+  url: import_zod13.z.string().optional(),
+  distanceInKilometers: import_zod13.z.number().optional(),
+  durationInMinutes: import_zod13.z.number().int().optional(),
+  start: AddressSchema.optional(),
+  end: AddressSchema.optional(),
+  pois: import_zod13.z.array(PoiSchema).optional(),
+  routeCoordinates: import_zod13.z.array(LatLngSchema).optional(),
+  calculatedCoordinates: import_zod13.z.array(LatLngSchema).optional(),
+  waterPoints: import_zod13.z.array(LatLngSchema).optional(),
+  difficulty: RouteDifficultySchema.optional(),
+  primarySurface: SurfaceTypeSchema.optional()
+}).passthrough();
+
+// src/seo-metadata.ts
+var import_zod14 = require("zod");
+var OGTypeSchema = import_zod14.z.enum(["event", "place", "article", "organization"]);
+var TwitterCardTypeSchema = import_zod14.z.enum(["summary", "summary_large_image"]);
+var SeoDetailSchema = import_zod14.z.object({
+  lang: LangCodeSchema.optional(),
+  metaTitle: import_zod14.z.string().optional(),
+  metaDescription: import_zod14.z.string().optional(),
+  ogImageUrl: import_zod14.z.string().optional(),
+  ogImageAlt: import_zod14.z.string().optional(),
+  ogType: OGTypeSchema.optional(),
+  twitterCardType: TwitterCardTypeSchema.optional()
+}).passthrough();
+var CanonicalConfigSchema = import_zod14.z.object({
+  canonicalUrl: import_zod14.z.string().optional()
+}).passthrough();
+var SeoMetadataSchema = import_zod14.z.object({
+  seoDetails: import_zod14.z.array(SeoDetailSchema).optional(),
+  canonical: CanonicalConfigSchema.optional(),
+  schemaOrgJsonLd: import_zod14.z.string().optional()
+}).passthrough();
+
+// src/trc-item-categories.ts
+var import_zod15 = require("zod");
+var DataTypeSchema = import_zod15.z.enum([
+  "yes",
+  "yesno",
+  "nullableyesno",
+  "choice",
+  "multichoice",
+  "freetext",
+  "integer",
+  "decimal",
+  "date",
+  "data",
+  "url",
+  "email",
+  "phone"
+]);
+var CategoryTranslationSchema = import_zod15.z.object({
+  catid: import_zod15.z.string().optional(),
+  lang: LangCodeSchema.optional(),
+  label: import_zod15.z.string().optional(),
+  unit: import_zod15.z.string().optional(),
+  value: import_zod15.z.string().optional(),
+  explanation: import_zod15.z.string().optional()
+}).passthrough();
+var CategoryValueSchema = import_zod15.z.object({
+  catid: import_zod15.z.string().optional(),
+  value: import_zod15.z.string().optional(),
+  categorytranslations: import_zod15.z.array(CategoryTranslationSchema).optional()
+}).passthrough();
+var CategorySchema = import_zod15.z.object({
+  catid: import_zod15.z.string().optional(),
+  valueid: import_zod15.z.string().optional(),
+  value: import_zod15.z.string().optional(),
+  defaultValue: import_zod15.z.string().optional(),
+  datatype: DataTypeSchema.optional(),
+  categoryvalues: import_zod15.z.array(CategoryValueSchema).optional(),
+  categoryTranslations: import_zod15.z.array(CategoryTranslationSchema).optional(),
+  parentCategoryTranslations: import_zod15.z.array(CategoryTranslationSchema).optional(),
+  valueCategoryTranslations: import_zod15.z.array(CategoryTranslationSchema).optional()
+}).passthrough();
+var TypeSchema = import_zod15.z.object({
+  catid: import_zod15.z.string().optional(),
+  isDefault: import_zod15.z.boolean().optional(),
+  categoryTranslations: import_zod15.z.array(CategoryTranslationSchema).optional()
+}).passthrough();
+var TRCItemCategoriesSchema = import_zod15.z.object({
+  types: import_zod15.z.array(TypeSchema).optional(),
+  categories: import_zod15.z.array(CategorySchema).optional(),
+  soldout: import_zod15.z.boolean().optional(),
+  canceled: import_zod15.z.boolean().optional()
+}).passthrough();
+
+// src/trcitem-relation.ts
+var import_zod17 = require("zod");
+
+// src/sub-item-group.ts
+var import_zod16 = require("zod");
+var SubItemTranslationSchema = import_zod16.z.object({
+  lang: LangCodeSchema.optional(),
+  title: import_zod16.z.string().optional()
+}).passthrough();
+var SubItemGroupSchema = import_zod16.z.object({
+  trcid: import_zod16.z.string().optional(),
+  type: TypeSchema.optional(),
+  categories: import_zod16.z.array(CategorySchema).optional(),
+  subItemTranslations: import_zod16.z.array(SubItemTranslationSchema).optional(),
+  media: import_zod16.z.array(FileSchema).optional()
+}).passthrough();
+
+// src/trcitem-relation.ts
+var TrcitemRelationSchema = import_zod17.z.object({
+  subItemGroups: import_zod17.z.array(SubItemGroupSchema).optional()
+}).passthrough();
+
+// src/translations.ts
+var import_zod18 = require("zod");
+var TranslationsSchema = import_zod18.z.object({
+  primaryLanguage: LangCodeSchema.optional(),
+  availableLanguages: import_zod18.z.array(LangCodeSchema).optional()
+}).passthrough();
+
+// src/trc-item.ts
+var WFStatusSchema = import_zod19.z.enum([
+  "draft",
+  "readyforvalidation",
+  "approved",
+  "rejected",
+  "deleted",
+  "archived"
+]);
+var EntityTypeSchema = import_zod19.z.enum([
+  "EVENEMENT",
+  "LOCATIE",
+  "EVENTGROUP",
+  "ROUTE",
+  "VENUE"
+]);
+var _trcItemBase = import_zod19.z.object({
+  trcid: import_zod19.z.string().optional(),
+  creationdate: import_zod19.z.string().optional(),
+  availablefrom: import_zod19.z.string().optional(),
+  availableto: import_zod19.z.string().optional(),
+  lastupdated: import_zod19.z.string().optional(),
+  lastimportedon: import_zod19.z.string().optional(),
+  createdby: import_zod19.z.string().optional(),
+  lastupdatedby: import_zod19.z.string().optional(),
+  owner: import_zod19.z.string().optional(),
+  legalowner: import_zod19.z.string().optional(),
+  externalid: import_zod19.z.string().optional(),
+  slug: import_zod19.z.string().optional(),
+  validator: import_zod19.z.string().optional(),
+  validatedby: import_zod19.z.string().optional(),
+  wfstatus: WFStatusSchema.optional(),
+  cidn: import_zod19.z.string().optional(),
+  published: import_zod19.z.boolean().optional(),
+  deleted: import_zod19.z.boolean().optional(),
+  offline: import_zod19.z.boolean().optional(),
+  isprivate: import_zod19.z.boolean().optional(),
+  entitytype: EntityTypeSchema.optional(),
+  productiontrcid: import_zod19.z.string().optional(),
+  calendar: CalendarSchema.optional(),
+  contactinfo: ContactinfoSchema.optional(),
+  trcItemCategories: TRCItemCategoriesSchema.optional(),
+  performers: import_zod19.z.array(PerformerSchema).optional(),
+  files: import_zod19.z.array(FileSchema).optional(),
+  trcItemDetails: import_zod19.z.array(TRCItemDetailSchema).optional(),
+  trcitemRelation: TrcitemRelationSchema.optional(),
+  keywords: import_zod19.z.string().optional(),
+  markers: import_zod19.z.string().optional(),
+  location: LocationSchema.optional(),
+  locationRef: import_zod19.z.string().optional(),
+  userorganisation: import_zod19.z.string().optional(),
+  priceElements: import_zod19.z.array(PriceElementSchema).optional(),
+  extrapriceinformations: import_zod19.z.array(ExtraPriceInformationSchema).optional(),
+  routeInfo: RouteInfoSchema.optional(),
+  translations: TranslationsSchema.optional(),
+  promotions: import_zod19.z.array(PromotionSchema).optional(),
+  seoMetadata: SeoMetadataSchema.optional()
+}).passthrough();
+var TRCItemSchema = _trcItemBase;
+var TRCItemResponseSchema = _trcItemBase.extend({
+  trcid: import_zod19.z.string(),
+  entitytype: EntityTypeSchema,
+  creationdate: import_zod19.z.string(),
+  lastupdated: import_zod19.z.string(),
+  wfstatus: WFStatusSchema
+});
+
+// src/converted-entry.ts
+var ConvertedEntrySchema = import_zod20.z.object({
+  label: import_zod20.z.string().optional(),
+  created: import_zod20.z.string().optional(),
+  modified: import_zod20.z.string().optional(),
+  errorMessage: import_zod20.z.string().optional(),
+  externalId: import_zod20.z.string().optional(),
+  trcItem: TRCItemSchema.optional()
+}).passthrough();
+
+// src/fetched-entry.ts
+var import_zod21 = require("zod");
+var ExternalLocationInfoSchema = import_zod21.z.object({
+  externalId: import_zod21.z.string().optional(),
+  locationName: import_zod21.z.string().optional(),
+  address: import_zod21.z.string().optional(),
+  housenr: import_zod21.z.string().optional(),
+  zipcode: import_zod21.z.string().optional(),
+  city: import_zod21.z.string().optional(),
+  latitude: import_zod21.z.string().optional(),
+  longitude: import_zod21.z.string().optional(),
+  trcid: import_zod21.z.string().optional(),
+  ffId: import_zod21.z.string().optional()
+}).passthrough();
+var FetchedEntrySchema = import_zod21.z.object({
+  feed: import_zod21.z.string().optional(),
+  sourceId: import_zod21.z.string().optional(),
+  sourceUrl: import_zod21.z.string().optional(),
+  errorMessage: import_zod21.z.string().optional(),
+  label: import_zod21.z.string().optional(),
+  created: import_zod21.z.string().optional(),
+  modified: import_zod21.z.string().optional(),
+  externalId: import_zod21.z.string().optional(),
+  data: import_zod21.z.record(import_zod21.z.unknown()).optional(),
+  externalLocationInfo: ExternalLocationInfoSchema.optional()
+}).passthrough();
+
+// src/trc-item-group.ts
+var import_zod22 = require("zod");
+var EventLinkSchema = import_zod22.z.object({
+  eventId: import_zod22.z.string().optional()
+}).passthrough();
+var _trcItemGroupBase = import_zod22.z.object({
+  trcid: import_zod22.z.string().optional(),
+  creationdate: import_zod22.z.string().optional(),
+  availablefrom: import_zod22.z.string().optional(),
+  availableto: import_zod22.z.string().optional(),
+  lastupdated: import_zod22.z.string().optional(),
+  lastimportedon: import_zod22.z.string().optional(),
+  createdby: import_zod22.z.string().optional(),
+  lastupdatedby: import_zod22.z.string().optional(),
+  owner: import_zod22.z.string().optional(),
+  legalowner: import_zod22.z.string().optional(),
+  externalid: import_zod22.z.string().optional(),
+  validator: import_zod22.z.string().optional(),
+  wfstatus: WFStatusSchema.optional(),
+  entitytype: EntityTypeSchema.optional(),
+  calendar: CalendarSchema.optional(),
+  contactinfo: ContactinfoSchema.optional(),
+  trcItemCategories: TRCItemCategoriesSchema.optional(),
+  files: import_zod22.z.array(FileSchema).optional(),
+  trcItemDetails: import_zod22.z.array(TRCItemDetailSchema).optional(),
+  keywords: import_zod22.z.string().optional(),
+  markers: import_zod22.z.string().optional(),
+  userorganisation: import_zod22.z.string().optional(),
+  priceElements: import_zod22.z.array(PriceElementSchema).optional(),
+  translations: TranslationsSchema.optional(),
+  promotions: import_zod22.z.array(PromotionSchema).optional(),
+  eventLinks: import_zod22.z.array(EventLinkSchema).optional()
+}).passthrough();
+var TRCItemGroupSchema = _trcItemGroupBase;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AddressSchema,
+  CalendarCommentSchema,
+  CalendarResponseSchema,
+  CalendarSchema,
+  CalendarTypeSchema,
+  CanonicalConfigSchema,
+  CategorySchema,
+  CategoryTranslationSchema,
+  CategoryValueSchema,
+  CommentTranslationSchema,
+  ContactinfoSchema,
+  ConvertedEntrySchema,
+  DataTypeSchema,
+  DescriptionTranslationSchema,
+  DiscountSchema,
+  EntityTypeSchema,
+  EventLinkSchema,
+  ExceptionDateSchema,
+  ExternalLocationInfoSchema,
+  ExtraInformationSchema,
+  ExtraPriceInformationSchema,
+  FaxSchema,
+  FetchedEntrySchema,
+  FileSchema,
+  FileTypeSchema,
+  GISCoordinateSchema,
+  LangCodeSchema,
+  LatLngSchema,
+  LocationItemSchema,
+  LocationSchema,
+  MailSchema,
+  MediaTypeSchema,
+  OGTypeSchema,
+  OpenSchema,
+  PatternDateSchema,
+  PerformerSchema,
+  PhoneSchema,
+  PoiCategorySchema,
+  PoiSchema,
+  PriceDescriptionValueSchema,
+  PriceElementCommentSchema,
+  PriceElementDescriptionSchema,
+  PriceElementDescriptionTranslationSchema,
+  PriceElementExtraPriceInformationSchema,
+  PriceElementSchema,
+  PriceValueSchema,
+  PromotionSchema,
+  PromotionTranslationSchema,
+  PromotionTypeSchema,
+  RecurrencyTypeSchema,
+  RouteDifficultySchema,
+  RouteInfoSchema,
+  RouteInfoTypeSchema,
+  RouteTypeSchema,
+  SeoDetailSchema,
+  SeoMetadataSchema,
+  SingleDateSchema,
+  StandardPriceDescriptionValues,
+  StatusTranslationSchema,
+  SubItemGroupSchema,
+  SubItemTranslationSchema,
+  SurfaceTypeSchema,
+  TRCItemCategoriesSchema,
+  TRCItemDetailSchema,
+  TRCItemGroupSchema,
+  TRCItemResponseSchema,
+  TRCItemSchema,
+  TitleSchema,
+  TitleTranslationSchema,
+  TranslationsSchema,
+  TrcitemRelationSchema,
+  TwitterCardTypeSchema,
+  TypeSchema,
+  URLServiceTypeSchema,
+  UrlSchema,
+  ValidityStrategySchema,
+  WFStatusSchema,
+  WhenSchema,
+  WhenStatusSchema
+});