more-apartments-astro-integration 1.0.1

package/dist/index.js

@@ -0,0 +1,1009 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var zod = require('zod');
+
+// src/client.ts
+var PaginationLinksSchema = zod.z.object({
+  first: zod.z.string().nullable(),
+  last: zod.z.string().nullable(),
+  prev: zod.z.string().nullable(),
+  next: zod.z.string().nullable()
+});
+var PaginationMetaSchema = zod.z.object({
+  current_page: zod.z.number(),
+  from: zod.z.number().nullable(),
+  last_page: zod.z.number(),
+  links: zod.z.array(zod.z.object({
+    url: zod.z.string().nullable(),
+    label: zod.z.string(),
+    active: zod.z.boolean()
+  })),
+  path: zod.z.string(),
+  per_page: zod.z.number(),
+  to: zod.z.number().nullable(),
+  total: zod.z.number()
+});
+var PaginatedResponseSchema = (dataSchema) => zod.z.object({
+  data: zod.z.array(dataSchema),
+  links: PaginationLinksSchema,
+  meta: PaginationMetaSchema
+});
+var ApiErrorSchema = zod.z.object({
+  message: zod.z.string(),
+  errors: zod.z.record(zod.z.array(zod.z.string())).optional()
+});
+var PropertyImageSchema = zod.z.object({
+  id: zod.z.number(),
+  url: zod.z.string(),
+  alt: zod.z.string().optional()
+});
+var PropertySchema = zod.z.object({
+  id: zod.z.number(),
+  external_id: zod.z.number().optional(),
+  name: zod.z.string(),
+  slug: zod.z.string(),
+  // Descriptions
+  short_description: zod.z.string().nullable(),
+  description: zod.z.string(),
+  area_description: zod.z.string().nullable(),
+  arrival_description: zod.z.string().nullable(),
+  // Property type & capacity
+  type: zod.z.string().nullable(),
+  max_persons: zod.z.number().nullable(),
+  bedrooms: zod.z.number().nullable(),
+  bathrooms: zod.z.number().nullable(),
+  toilets: zod.z.number().nullable(),
+  size: zod.z.number().nullable(),
+  floor: zod.z.number().nullable(),
+  // Location
+  street: zod.z.string().nullable(),
+  zipcode: zod.z.string().nullable(),
+  area: zod.z.string().nullable(),
+  city: zod.z.string(),
+  country: zod.z.string(),
+  latitude: zod.z.number(),
+  longitude: zod.z.number(),
+  // Beds
+  single_bed: zod.z.number().nullable(),
+  double_bed: zod.z.number().nullable(),
+  single_sofa: zod.z.number().nullable(),
+  double_sofa: zod.z.number().nullable(),
+  single_bunk: zod.z.number().nullable(),
+  // Amenities - Outdoor
+  balcony: zod.z.boolean(),
+  terrace: zod.z.boolean(),
+  view: zod.z.string().nullable(),
+  // Amenities - Climate
+  airco: zod.z.boolean(),
+  fans: zod.z.boolean(),
+  heating: zod.z.boolean(),
+  // Amenities - Connectivity
+  internet: zod.z.string().nullable(),
+  internet_connection: zod.z.string().nullable(),
+  tv: zod.z.string().nullable(),
+  tv_connection: zod.z.string().nullable(),
+  dvd: zod.z.boolean(),
+  computer: zod.z.boolean(),
+  printer: zod.z.boolean(),
+  // Amenities - Kitchen
+  dishwasher: zod.z.boolean(),
+  oven: zod.z.boolean(),
+  microwave: zod.z.boolean(),
+  fridge: zod.z.boolean(),
+  freezer: zod.z.boolean(),
+  toaster: zod.z.boolean(),
+  kettle: zod.z.boolean(),
+  coffeemachine: zod.z.boolean(),
+  // Amenities - Laundry
+  washingmachine: zod.z.boolean(),
+  dryer: zod.z.boolean(),
+  iron: zod.z.boolean(),
+  // Amenities - Bathroom
+  bathtub: zod.z.boolean(),
+  jacuzzi: zod.z.boolean(),
+  shower_regular: zod.z.boolean(),
+  shower_steam: zod.z.boolean(),
+  hairdryer: zod.z.boolean(),
+  // Amenities - Recreation
+  swimmingpool: zod.z.string().nullable(),
+  sauna: zod.z.string().nullable(),
+  // Amenities - General
+  parking: zod.z.string().nullable(),
+  entresol: zod.z.boolean(),
+  wheelchair_friendly: zod.z.boolean(),
+  smoking_allowed: zod.z.boolean(),
+  pets_allowed: zod.z.boolean(),
+  // Supplies
+  supplies_coffee: zod.z.boolean(),
+  supplies_tea: zod.z.boolean(),
+  supplies_milk: zod.z.boolean(),
+  supplies_sugar: zod.z.boolean(),
+  supplies_dishwasher_tablets: zod.z.boolean(),
+  // Services
+  service_linen: zod.z.boolean(),
+  service_towels: zod.z.boolean(),
+  // Costs & Policies
+  cleaning_costs: zod.z.number().nullable(),
+  deposit_costs: zod.z.number().nullable(),
+  min_rate: zod.z.number().nullable(),
+  minimal_nights: zod.z.number().nullable(),
+  maximal_nights: zod.z.number().nullable(),
+  // Check-in/out
+  check_in: zod.z.string().nullable(),
+  check_out: zod.z.string().nullable(),
+  // Media
+  images: zod.z.array(zod.z.object({
+    id: zod.z.number(),
+    url: zod.z.string(),
+    thumb_url: zod.z.string(),
+    alt: zod.z.string()
+  })).optional(),
+  // Metadata
+  status: zod.z.string().nullable(),
+  provider_name: zod.z.string().nullable(),
+  created_at: zod.z.string(),
+  updated_at: zod.z.string()
+});
+var AvailableDay = zod.z.object({
+  available: zod.z.boolean(),
+  morning_available: zod.z.boolean(),
+  date: zod.z.string(),
+  day: zod.z.number()
+});
+var AvailabilitySchema = zod.z.object({
+  days: zod.z.record(zod.z.string(), AvailableDay)
+});
+var PropertySearchParamsSchema = zod.z.object({
+  // Date filters
+  arrival: zod.z.string().optional(),
+  departure: zod.z.string().optional(),
+  // Guest capacity
+  guests: zod.z.number().optional(),
+  // General search (deprecated in favor of direct column filters)
+  destination: zod.z.string().optional(),
+  segment: zod.z.string().optional(),
+  // DEPRECATED: use city/area instead
+  // Direct column filters (preferred for headless instances)
+  city: zod.z.string().optional(),
+  area: zod.z.string().optional(),
+  propertyType: zod.z.string().optional(),
+  bedrooms: zod.z.number().optional(),
+  bathrooms: zod.z.number().optional(),
+  maxPersons: zod.z.number().optional(),
+  elevator: zod.z.boolean().optional(),
+  parking: zod.z.boolean().optional(),
+  balcony: zod.z.boolean().optional()
+});
+var PropertySearchResultSchema = zod.z.object({
+  data: zod.z.array(PropertySchema)
+});
+var PropertyPageSettingsSchema = zod.z.object({
+  routing: zod.z.object({
+    base_url: zod.z.string()
+  }),
+  index: zod.z.object({
+    seo: zod.z.object({
+      title: zod.z.string(),
+      description: zod.z.string(),
+      openGraphTitle: zod.z.string().optional(),
+      tags: zod.z.array(zod.z.string()).optional()
+    })
+  }),
+  show: zod.z.object({
+    hero: zod.z.object({
+      provider: zod.z.boolean().optional(),
+      address: zod.z.boolean().optional()
+    }).optional(),
+    cancellation_policy: zod.z.object({
+      description: zod.z.string()
+    }).optional(),
+    related_properties: zod.z.object({
+      title: zod.z.string()
+    }).optional()
+  }).optional()
+});
+var PageSchema = zod.z.object({
+  id: zod.z.string(),
+  slug: zod.z.string(),
+  title: zod.z.string().nullable(),
+  description: zod.z.string().nullable(),
+  content: zod.z.string().nullable(),
+  sections: zod.z.array(zod.z.any()),
+  seo: zod.z.object({
+    title: zod.z.string(),
+    description: zod.z.string(),
+    image: zod.z.string().nullable()
+  }),
+  route_name: zod.z.string()
+});
+var PostSchema = zod.z.object({
+  id: zod.z.string(),
+  slug: zod.z.string(),
+  title: zod.z.string(),
+  description: zod.z.string().nullable(),
+  content: zod.z.string().nullable(),
+  excerpt: zod.z.string().nullable(),
+  author: zod.z.string().nullable(),
+  date: zod.z.string(),
+  // ISO date string
+  image: zod.z.string().nullable(),
+  tags: zod.z.array(zod.z.string()),
+  reading_time: zod.z.string().nullable(),
+  sections: zod.z.array(zod.z.any()),
+  seo: zod.z.object({
+    title: zod.z.string(),
+    description: zod.z.string(),
+    image: zod.z.string().nullable()
+  }),
+  route_name: zod.z.string()
+});
+var CategorySchema = zod.z.object({
+  slug: zod.z.string(),
+  name: zod.z.string(),
+  title: zod.z.string(),
+  description: zod.z.string().nullable(),
+  content: zod.z.string().nullable(),
+  segments: zod.z.union([zod.z.array(zod.z.string()), zod.z.number()]).optional()
+});
+var CategorySegmentSchema = zod.z.object({
+  name: zod.z.string(),
+  slug: zod.z.string(),
+  title: zod.z.string(),
+  description: zod.z.string().nullable(),
+  tags: zod.z.array(zod.z.string()).optional(),
+  sections: zod.z.array(zod.z.any()),
+  content: zod.z.string().nullable(),
+  image: zod.z.string()
+});
+var MainSettingsSchema = zod.z.object({
+  site: zod.z.object({
+    name: zod.z.string(),
+    domain: zod.z.string(),
+    locale: zod.z.string()
+  }),
+  contact: zod.z.object({
+    email: zod.z.string(),
+    phone: zod.z.string().optional()
+  }),
+  social: zod.z.object({
+    facebook: zod.z.string().optional(),
+    instagram: zod.z.string().optional()
+  }).optional(),
+  mail: zod.z.object({
+    from: zod.z.object({
+      address: zod.z.string(),
+      name: zod.z.string()
+    }),
+    contact_form_to: zod.z.string()
+  }).optional(),
+  pms: zod.z.object({
+    property_providers: zod.z.array(zod.z.object({
+      name: zod.z.string(),
+      system: zod.z.string(),
+      api_key: zod.z.string().optional(),
+      base_url: zod.z.string().optional(),
+      discount: zod.z.number().optional(),
+      enabled: zod.z.boolean().optional()
+    }))
+  }).optional(),
+  pricing: zod.z.object({
+    vat: zod.z.number(),
+    tourist_tax: zod.z.object({
+      type: zod.z.string(),
+      value: zod.z.number()
+    })
+  }).optional(),
+  discount: zod.z.number().optional()
+});
+var ThemeSettingsSchema = zod.z.object({
+  logo: zod.z.object({
+    path: zod.z.string(),
+    height: zod.z.number().optional()
+  }).optional(),
+  favicon_path: zod.z.string().optional(),
+  colors: zod.z.object({
+    primary: zod.z.string(),
+    secondary: zod.z.string()
+  }),
+  layout: zod.z.object({
+    homepage_style: zod.z.string().optional(),
+    navigation: zod.z.object({
+      variant: zod.z.string().optional(),
+      items: zod.z.array(zod.z.any()),
+      buttons: zod.z.array(zod.z.any()).optional()
+    }).optional(),
+    footer: zod.z.object({
+      blog_title: zod.z.string().optional(),
+      contact_title: zod.z.string().optional(),
+      categories: zod.z.array(zod.z.any()).optional()
+    }).optional()
+  }).optional()
+});
+var PropertySettingsSchema = zod.z.object({
+  routing: zod.z.object({
+    base_url: zod.z.string()
+  }),
+  seo: zod.z.object({
+    title: zod.z.string(),
+    description: zod.z.string(),
+    openGraphTitle: zod.z.string().optional(),
+    tags: zod.z.array(zod.z.string()).optional()
+  }).optional(),
+  index: zod.z.object({
+    seo: zod.z.object({
+      title: zod.z.string(),
+      description: zod.z.string(),
+      openGraphTitle: zod.z.string().optional(),
+      tags: zod.z.array(zod.z.string()).optional()
+    })
+  }),
+  show: zod.z.object({
+    hero: zod.z.object({
+      provider: zod.z.boolean().optional(),
+      address: zod.z.boolean().optional()
+    }).optional(),
+    cancellation_policy: zod.z.object({
+      description: zod.z.string()
+    }).optional(),
+    related_properties: zod.z.object({
+      title: zod.z.string()
+    }).optional()
+  }).optional()
+});
+var BookingSettingsSchema = zod.z.object({
+  booking_confirmation: zod.z.object({
+    sections: zod.z.object({
+      arrival_description: zod.z.boolean().optional()
+    }).optional(),
+    content: zod.z.object({
+      body: zod.z.string().optional(),
+      help: zod.z.string().optional()
+    }).optional()
+  }).optional()
+});
+var BookingRequestSchema = zod.z.object({
+  property_id: zod.z.number(),
+  check_in: zod.z.string(),
+  check_out: zod.z.string(),
+  guests: zod.z.number(),
+  first_name: zod.z.string(),
+  last_name: zod.z.string(),
+  email: zod.z.string().email(),
+  phone: zod.z.string().optional(),
+  notes: zod.z.string().optional(),
+  total_amount: zod.z.number(),
+  payment_method: zod.z.enum(["stripe", "cash", "bank_transfer"]).optional()
+});
+var BookingResponseSchema = zod.z.object({
+  id: zod.z.string(),
+  property_id: zod.z.number(),
+  check_in: zod.z.string(),
+  check_out: zod.z.string(),
+  guests: zod.z.number(),
+  status: zod.z.enum(["pending", "confirmed", "cancelled", "completed"]),
+  total_amount: zod.z.number(),
+  payment_status: zod.z.enum(["pending", "paid", "refunded"]),
+  confirmation_code: zod.z.string(),
+  created_at: zod.z.string(),
+  updated_at: zod.z.string()
+});
+var MoreApartmentsConfigSchema = zod.z.object({
+  baseUrl: zod.z.string().optional(),
+  apiKey: zod.z.string().optional(),
+  instance: zod.z.string().optional(),
+  timeout: zod.z.number().optional(),
+  retry: zod.z.object({
+    attempts: zod.z.number(),
+    delay: zod.z.number()
+  }).optional(),
+  cache: zod.z.object({
+    enabled: zod.z.boolean(),
+    ttl: zod.z.number()
+  }).optional()
+});
+
+// src/client.ts
+var MoreApartmentsClient = class {
+  config;
+  cache = /* @__PURE__ */ new Map();
+  /**
+   * Clear all cached data
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+  /**
+   * Get cache statistics
+   */
+  getCacheStats() {
+    return {
+      entries: this.cache.size,
+      size: Array.from(this.cache.values()).reduce((total, entry) => {
+        return total + JSON.stringify(entry.data).length;
+      }, 0)
+    };
+  }
+  constructor(config) {
+    this.config = {
+      baseUrl: config.baseUrl?.replace(/\/$/, "") || "",
+      apiKey: config.apiKey || "",
+      instance: config.instance || "",
+      timeout: config.timeout || 3e4,
+      retry: {
+        attempts: config.retry?.attempts || 3,
+        delay: config.retry?.delay || 1e3
+      },
+      cache: {
+        enabled: config.cache?.enabled ?? true,
+        ttl: config.cache?.ttl || 3e5
+        // 5 minutes default
+      }
+    };
+  }
+  async fetchWithRetry(url, options = {}, schema) {
+    const cacheKey = `${options.method || "GET"}:${url}`;
+    if (this.config.cache?.enabled && (!options.method || options.method === "GET")) {
+      const cached = this.cache.get(cacheKey);
+      if (cached && this.config.cache?.ttl && Date.now() - cached.timestamp < this.config.cache.ttl) {
+        return cached.data;
+      }
+    }
+    const headers = {
+      "Content-Type": "application/json",
+      "Accept": "application/json",
+      ...this.config.apiKey && { "Authorization": `Bearer ${this.config.apiKey}` },
+      ...this.config.instance && { "X-Instance": this.config.instance },
+      ...options.headers
+    };
+    let lastError = null;
+    for (let attempt = 0; attempt < (this.config.retry?.attempts ?? 3); attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => {
+          controller.abort();
+        }, this.config.timeout);
+        const response = await fetch(url, {
+          ...options,
+          headers,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+          const error = await response.json().catch(() => ({ message: response.statusText }));
+          throw new Error(error.message || `HTTP ${response.status}: ${response.statusText}`);
+        }
+        const data = await response.json();
+        if (schema) {
+          const result = schema.safeParse(data);
+          if (!result.success) {
+            throw new Error(`Invalid response format: ${result.error.message}`);
+          }
+          const validatedData = result.data;
+          if (this.config.cache?.enabled && (!options.method || options.method === "GET")) {
+            this.cache.set(cacheKey, { data: validatedData, timestamp: Date.now() });
+          }
+          return validatedData;
+        }
+        if (this.config.cache?.enabled && (!options.method || options.method === "GET")) {
+          this.cache.set(cacheKey, { data, timestamp: Date.now() });
+        }
+        return data;
+      } catch (error) {
+        lastError = error;
+        if (attempt < (this.config.retry?.attempts ?? 3) - 1) {
+          await new Promise((resolve) => setTimeout(resolve, (this.config.retry?.delay ?? 1e3) * (attempt + 1)));
+        }
+      }
+    }
+    throw lastError || new Error("Request failed");
+  }
+  // Property endpoints
+  async getProperties(params) {
+    const queryParams = new URLSearchParams();
+    if (params?.page) queryParams.append("page", params.page.toString());
+    if (params?.per_page) queryParams.append("per_page", params.per_page.toString());
+    const url = `${this.config.baseUrl}/api/v1/properties${queryParams.toString() ? "?" + queryParams.toString() : ""}`;
+    return this.fetchWithRetry(url, {}, PaginatedResponseSchema(PropertySchema));
+  }
+  async getProperty(propertyIdOrSlug) {
+    const url = `${this.config.baseUrl}/api/v1/properties/${propertyIdOrSlug}`;
+    const response = await this.fetchWithRetry(url, {}, zod.z.object({ data: PropertySchema }));
+    return response.data;
+  }
+  // Availability endpoints
+  async getAvailability(propertySlug, startDate, endDate) {
+    const queryParams = new URLSearchParams({
+      start_date: startDate,
+      end_date: endDate
+    });
+    const url = `${this.config.baseUrl}/api/v1/properties/${propertySlug}/availability?${queryParams}`;
+    const response = await this.fetchWithRetry(url, {}, zod.z.object({ data: AvailabilitySchema }));
+    return response.data;
+  }
+  // Content endpoints
+  async getPages() {
+    const url = `${this.config.baseUrl}/api/v1/pages`;
+    const response = await this.fetchWithRetry(url, {}, zod.z.object({ data: zod.z.array(PageSchema) }));
+    return response.data;
+  }
+  async getPage(slug) {
+    const url = `${this.config.baseUrl}/api/v1/pages/${slug}`;
+    const response = await this.fetchWithRetry(url, {}, zod.z.object({ data: PageSchema }));
+    return response.data;
+  }
+  async getPosts(params) {
+    const queryParams = new URLSearchParams();
+    if (params?.page) queryParams.append("page", params.page.toString());
+    if (params?.per_page) queryParams.append("per_page", params.per_page.toString());
+    if (params?.tag) queryParams.append("tag", params.tag);
+    const url = `${this.config.baseUrl}/api/v1/posts${queryParams.toString() ? "?" + queryParams.toString() : ""}`;
+    const response = await this.fetchWithRetry(url, {}, zod.z.object({ data: zod.z.array(PostSchema) }));
+    return response.data;
+  }
+  async getPost(slug) {
+    const url = `${this.config.baseUrl}/api/v1/posts/${slug}`;
+    const response = await this.fetchWithRetry(url, {}, zod.z.object({ data: PostSchema }));
+    return response.data;
+  }
+  async getLocations() {
+    const url = `${this.config.baseUrl}/api/v1/locations`;
+    const response = await this.fetchWithRetry(url, {}, zod.z.object({ data: zod.z.array(zod.z.string()) }));
+    return response.data;
+  }
+  async getCategories() {
+    const url = `${this.config.baseUrl}/api/v1/categories`;
+    const response = await this.fetchWithRetry(url, {}, zod.z.object({ data: zod.z.array(CategorySchema) }));
+    return response.data;
+  }
+  async getCategory(slug) {
+    const url = `${this.config.baseUrl}/api/v1/categories/${slug}`;
+    const response = await this.fetchWithRetry(url, {}, zod.z.object({ data: CategorySchema }));
+    return response.data;
+  }
+  async getCategorySegments(slug) {
+    const url = `${this.config.baseUrl}/api/v1/categories/${slug}/segments`;
+    const response = await this.fetchWithRetry(url, {}, zod.z.object({ data: zod.z.array(CategorySegmentSchema) }));
+    return response.data;
+  }
+  async getCategorySegment(slug, segment) {
+    const url = `${this.config.baseUrl}/api/v1/categories/${slug}/segments/${segment}`;
+    const response = await this.fetchWithRetry(url, {}, zod.z.object({ data: CategorySegmentSchema }));
+    return response.data;
+  }
+  // Settings endpoints
+  async getMainSettings() {
+    const url = `${this.config.baseUrl}/api/v1/settings/main`;
+    const response = await this.fetchWithRetry(url, {}, zod.z.object({ data: MainSettingsSchema }));
+    return response.data;
+  }
+  async getThemeSettings() {
+    const url = `${this.config.baseUrl}/api/v1/settings/theme`;
+    const response = await this.fetchWithRetry(url, {}, zod.z.object({ data: ThemeSettingsSchema }));
+    return response.data;
+  }
+  async getPropertySettings() {
+    const url = `${this.config.baseUrl}/api/v1/settings/properties`;
+    const response = await this.fetchWithRetry(url, {}, zod.z.object({ data: PropertySettingsSchema }));
+    return response.data;
+  }
+  async getBookingSettings() {
+    const url = `${this.config.baseUrl}/api/v1/settings/booking`;
+    const response = await this.fetchWithRetry(url, {}, zod.z.object({ data: BookingSettingsSchema }));
+    return response.data;
+  }
+  // Booking endpoints
+  async createBooking(booking) {
+    const url = `${this.config.baseUrl}/api/v1/bookings`;
+    const response = await this.fetchWithRetry(
+      url,
+      {
+        method: "POST",
+        body: JSON.stringify(booking)
+      },
+      zod.z.object({ data: BookingResponseSchema })
+    );
+    return response.data;
+  }
+  async getBooking(bookingId) {
+    const url = `${this.config.baseUrl}/api/v1/bookings/${bookingId}`;
+    const response = await this.fetchWithRetry(url, {}, zod.z.object({ data: BookingResponseSchema }));
+    return response.data;
+  }
+  /**
+   * Search properties with advanced filtering
+   */
+  async searchProperties(params) {
+    const searchParams = new URLSearchParams();
+    if (params.arrival) searchParams.set("arrival", params.arrival);
+    if (params.departure) searchParams.set("departure", params.departure);
+    if (params.guests) searchParams.set("guests", params.guests.toString());
+    if (params.destination) searchParams.set("destination", params.destination);
+    if (params.segment) searchParams.set("segment", params.segment);
+    if (params.city) searchParams.set("city", params.city);
+    if (params.area) searchParams.set("area", params.area);
+    if (params.propertyType) searchParams.set("property_type", params.propertyType);
+    if (params.bedrooms !== void 0) searchParams.set("bedrooms", params.bedrooms.toString());
+    if (params.bathrooms !== void 0) searchParams.set("bathrooms", params.bathrooms.toString());
+    if (params.maxPersons !== void 0) searchParams.set("max_persons", params.maxPersons.toString());
+    if (params.elevator !== void 0) searchParams.set("elevator", params.elevator ? "1" : "0");
+    if (params.parking !== void 0) searchParams.set("parking", params.parking ? "1" : "0");
+    if (params.balcony !== void 0) searchParams.set("balcony", params.balcony ? "1" : "0");
+    const url = `${this.config.baseUrl}/api/v1/properties/search?${searchParams.toString()}`;
+    const response = await this.fetchWithRetry(url, {}, PropertySearchResultSchema);
+    return response.data;
+  }
+};
+
+// src/utils/images.ts
+function getPrimaryImageUrl(property, fallbackUrl) {
+  if (property.images && property.images.length > 0) {
+    return property.images[0].url;
+  }
+  if (fallbackUrl) {
+    return fallbackUrl;
+  }
+  throw new Error(`Property "${property.name}" (ID: ${property.id}) has no images`);
+}
+function getThumbnailUrl(property, fallbackUrl) {
+  if (property.images && property.images.length > 0) {
+    return property.images[0].thumb_url;
+  }
+  if (fallbackUrl) {
+    return fallbackUrl;
+  }
+  throw new Error(`Property "${property.name}" (ID: ${property.id}) has no thumbnail images`);
+}
+function getAllImageUrls(property) {
+  return property.images?.map((img) => img.url) || [];
+}
+function getAllThumbnailUrls(property) {
+  return property.images?.map((img) => img.thumb_url) || [];
+}
+function getImageWithAlt(property, index = 0) {
+  const image = property.images?.[index];
+  if (!image?.url) {
+    throw new Error(`Property "${property.name}" (ID: ${property.id}) has no image at index ${index}`);
+  }
+  return {
+    url: image.url,
+    alt: image.alt || property.name
+  };
+}
+function getImage(property, index = 0) {
+  return property.images?.[index] || null;
+}
+function hasImages(property) {
+  return !!(property.images && Array.isArray(property.images) && property.images.length > 0);
+}
+function getImageCount(property) {
+  return Array.isArray(property.images) ? property.images.length : 0;
+}
+
+// src/index.ts
+function moreApartmentsIntegration(options) {
+  return {
+    name: "@shelfwood/more-apartments-astro-integration",
+    hooks: {
+      "astro:config:setup": async ({
+        config: astroConfig,
+        updateConfig,
+        injectScript,
+        injectRoute,
+        logger
+      }) => {
+        let apiKey = options.apiKey;
+        let apiKeySource = "environment variable";
+        if (options.instancePath && !apiKey) {
+          try {
+            const fs = await import('fs');
+            const path = await import('path');
+            const resolvedInstancePath = path.resolve(process.cwd(), options.instancePath);
+            const devKeyPath = path.join(resolvedInstancePath, ".dev-api-key");
+            if (fs.existsSync(devKeyPath)) {
+              apiKey = fs.readFileSync(devKeyPath, "utf-8").trim();
+              apiKeySource = `${path.basename(resolvedInstancePath)}/.dev-api-key`;
+              logger.info(`\u2713 Using development API key from ${apiKeySource}`);
+            } else {
+              logger.warn(`Instance directory configured but .dev-api-key not found. Run: php artisan dev:generate-api-key --instance=${path.basename(resolvedInstancePath)}`);
+            }
+          } catch (error) {
+            logger.debug(`Could not read .dev-api-key: ${error}`);
+          }
+        } else if (apiKey) {
+          logger.info(`\u2713 Using API key from ${apiKeySource}`);
+        } else {
+          logger.warn("\u26A0\uFE0F  No API key configured. Set MORE_APARTMENTS_API_KEY or configure instancePath for auto-discovery");
+        }
+        const clientOptions = { ...options, apiKey };
+        new MoreApartmentsClient(clientOptions);
+        if (options.virtualModules !== false) {
+          updateConfig({
+            vite: {
+              plugins: [
+                {
+                  name: "more-apartments-virtual-modules",
+                  resolveId(id) {
+                    if (id === "virtual:more-apartments/client") {
+                      return "\0virtual:more-apartments/client";
+                    }
+                    if (id === "virtual:more-apartments/config") {
+                      return "\0virtual:more-apartments/config";
+                    }
+                  },
+                  load(id) {
+                    if (id === "\0virtual:more-apartments/client") {
+                      const clientConfig = {
+                        baseUrl: options.baseUrl,
+                        instance: options.instance
+                        // Never include apiKey in client-side code
+                      };
+                      return `
+                        import { MoreApartmentsClient } from '@shelfwood/more-apartments-astro-integration';
+
+                        const config = ${JSON.stringify(clientConfig)};
+                        export const client = new MoreApartmentsClient(config);
+                        export default client;
+                      `;
+                    }
+                    if (id === "\0virtual:more-apartments/config") {
+                      const clientConfig = {
+                        baseUrl: options.baseUrl,
+                        instance: options.instance
+                      };
+                      return `export default ${JSON.stringify(clientConfig)};`;
+                    }
+                  }
+                }
+              ]
+            }
+          });
+          logger.info("Virtual modules configured for More Apartments API");
+        }
+        if (options.injectClient !== false) {
+          injectScript(
+            "before-hydration",
+            `
+              window.__moreApartments = {
+                baseUrl: '${options.baseUrl}',
+                instance: '${options.instance || ""}',
+                // apiKey intentionally excluded for security
+              };
+            `
+          );
+          logger.info("Global More Apartments client injected (client-side safe config)");
+        }
+        if (options.addApiRoutes !== false) {
+          const routePrefix = options.apiRoutePrefix || "/api/apartments";
+          injectRoute({
+            pattern: `${routePrefix}/properties`,
+            entrypoint: "@shelfwood/more-apartments-astro-integration/routes/properties.js"
+          });
+          injectRoute({
+            pattern: `${routePrefix}/properties/[id]`,
+            entrypoint: "@shelfwood/more-apartments-astro-integration/routes/property.js"
+          });
+          injectRoute({
+            pattern: `${routePrefix}/properties/[id]/availability`,
+            entrypoint: "@shelfwood/more-apartments-astro-integration/routes/availability.js"
+          });
+          injectRoute({
+            pattern: `${routePrefix}/pages`,
+            entrypoint: "@shelfwood/more-apartments-astro-integration/routes/pages.js"
+          });
+          injectRoute({
+            pattern: `${routePrefix}/pages/[slug]`,
+            entrypoint: "@shelfwood/more-apartments-astro-integration/routes/page.js"
+          });
+          injectRoute({
+            pattern: `${routePrefix}/posts`,
+            entrypoint: "@shelfwood/more-apartments-astro-integration/routes/posts.js"
+          });
+          injectRoute({
+            pattern: `${routePrefix}/posts/[slug]`,
+            entrypoint: "@shelfwood/more-apartments-astro-integration/routes/post.js"
+          });
+          injectRoute({
+            pattern: `${routePrefix}/settings/[type]`,
+            entrypoint: "@shelfwood/more-apartments-astro-integration/routes/settings.js"
+          });
+          injectRoute({
+            pattern: `${routePrefix}/bookings`,
+            entrypoint: "@shelfwood/more-apartments-astro-integration/routes/bookings.js"
+          });
+          logger.info(`API proxy routes added at ${routePrefix}`);
+        }
+      },
+      "astro:config:done": ({ config: finalConfig, logger }) => {
+        logger.info("More Apartments integration configured successfully");
+      },
+      "astro:server:setup": async ({ server, logger }) => {
+        server.middlewares.use((req, res, next) => {
+          if (req.url?.startsWith("/api/apartments")) {
+            logger.debug(`API request: ${req.method} ${req.url}`);
+          }
+          next();
+        });
+        logger.info(`Instance path config: ${options.instancePath || "not set"}`);
+        if (options.instancePath) {
+          const path = await import('path');
+          const chokidar = await import('chokidar');
+          const resolvedPath = path.resolve(process.cwd(), options.instancePath);
+          logger.info(`Watching instance directory: ${resolvedPath}`);
+          const watcher = chokidar.watch(resolvedPath, {
+            ignored: /(^|[\/\\])\../,
+            // ignore dotfiles
+            persistent: true,
+            ignoreInitial: true
+          });
+          watcher.on("change", (filePath) => {
+            logger.info(`Instance file changed: ${path.relative(resolvedPath, filePath)}`);
+            server.ws.send({
+              type: "full-reload",
+              path: "*"
+            });
+          });
+          watcher.on("add", (filePath) => {
+            logger.info(`Instance file added: ${path.relative(resolvedPath, filePath)}`);
+            server.ws.send({
+              type: "full-reload",
+              path: "*"
+            });
+          });
+          watcher.on("unlink", (filePath) => {
+            logger.info(`Instance file removed: ${path.relative(resolvedPath, filePath)}`);
+            server.ws.send({
+              type: "full-reload",
+              path: "*"
+            });
+          });
+          server.httpServer?.on("close", () => {
+            watcher.close();
+          });
+        }
+      },
+      "astro:build:done": ({ logger }) => {
+        logger.info("More Apartments integration build complete");
+      }
+    }
+  };
+}
+async function fetchProperties(client, params) {
+  try {
+    return await client.getProperties(params);
+  } catch (error) {
+    console.error("Error fetching properties:", error);
+    return { data: [], links: {}, meta: {} };
+  }
+}
+async function fetchProperty(client, idOrSlug) {
+  try {
+    return await client.getProperty(idOrSlug);
+  } catch (error) {
+    console.error("Error fetching property:", error);
+    return null;
+  }
+}
+async function fetchAvailability(client, propertySlug, startDate, endDate) {
+  try {
+    return await client.getAvailability(propertySlug, startDate, endDate);
+  } catch (error) {
+    console.error("Error fetching availability:", error);
+    return null;
+  }
+}
+async function fetchPages(client) {
+  try {
+    return await client.getPages();
+  } catch (error) {
+    console.error("Error fetching pages:", error);
+    return [];
+  }
+}
+async function fetchPage(client, slug) {
+  try {
+    return await client.getPage(slug);
+  } catch (error) {
+    console.error("Error fetching page:", error);
+    return null;
+  }
+}
+async function fetchPosts(client, params) {
+  try {
+    return await client.getPosts(params);
+  } catch (error) {
+    console.error("Error fetching posts:", error);
+    return { data: [], links: {}, meta: {} };
+  }
+}
+async function fetchPost(client, slug) {
+  try {
+    return await client.getPost(slug);
+  } catch (error) {
+    console.error("Error fetching post:", error);
+    return null;
+  }
+}
+async function fetchSettings(client, type) {
+  try {
+    switch (type) {
+      case "main":
+        return await client.getMainSettings();
+      case "theme":
+        return await client.getThemeSettings();
+      case "properties":
+        return await client.getPropertySettings();
+      case "booking":
+        return await client.getBookingSettings();
+      default:
+        throw new Error(`Unknown settings type: ${type}`);
+    }
+  } catch (error) {
+    console.error(`Error fetching ${type} settings:`, error);
+    return null;
+  }
+}
+function generateBookingUrl(propertyExternalId, arrival, departure, guests, baseUrl) {
+  const bookingBaseUrl = baseUrl || undefined.PUBLIC_LARAVEL_BOOKING_URL || "http://prj-more-apartments.test/booking/initiate";
+  const params = new URLSearchParams({
+    property_external_id: propertyExternalId.toString(),
+    arrival,
+    departure,
+    guests: guests.toString()
+  });
+  return `${bookingBaseUrl}?${params.toString()}`;
+}
+async function searchProperties(client, params) {
+  try {
+    return await client.searchProperties(params);
+  } catch (error) {
+    console.error("Error searching properties:", error);
+    return [];
+  }
+}
+
+exports.ApiErrorSchema = ApiErrorSchema;
+exports.AvailabilitySchema = AvailabilitySchema;
+exports.AvailableDay = AvailableDay;
+exports.BookingRequestSchema = BookingRequestSchema;
+exports.BookingResponseSchema = BookingResponseSchema;
+exports.BookingSettingsSchema = BookingSettingsSchema;
+exports.CategorySchema = CategorySchema;
+exports.CategorySegmentSchema = CategorySegmentSchema;
+exports.MainSettingsSchema = MainSettingsSchema;
+exports.MoreApartmentsClient = MoreApartmentsClient;
+exports.MoreApartmentsConfigSchema = MoreApartmentsConfigSchema;
+exports.PageSchema = PageSchema;
+exports.PaginatedResponseSchema = PaginatedResponseSchema;
+exports.PaginationLinksSchema = PaginationLinksSchema;
+exports.PaginationMetaSchema = PaginationMetaSchema;
+exports.PostSchema = PostSchema;
+exports.PropertyImageSchema = PropertyImageSchema;
+exports.PropertyPageSettingsSchema = PropertyPageSettingsSchema;
+exports.PropertySchema = PropertySchema;
+exports.PropertySearchParamsSchema = PropertySearchParamsSchema;
+exports.PropertySearchResultSchema = PropertySearchResultSchema;
+exports.PropertySettingsSchema = PropertySettingsSchema;
+exports.ThemeSettingsSchema = ThemeSettingsSchema;
+exports.default = moreApartmentsIntegration;
+exports.fetchAvailability = fetchAvailability;
+exports.fetchPage = fetchPage;
+exports.fetchPages = fetchPages;
+exports.fetchPost = fetchPost;
+exports.fetchPosts = fetchPosts;
+exports.fetchProperties = fetchProperties;
+exports.fetchProperty = fetchProperty;
+exports.fetchSettings = fetchSettings;
+exports.generateBookingUrl = generateBookingUrl;
+exports.getAllImageUrls = getAllImageUrls;
+exports.getAllThumbnailUrls = getAllThumbnailUrls;
+exports.getImage = getImage;
+exports.getImageCount = getImageCount;
+exports.getImageWithAlt = getImageWithAlt;
+exports.getPrimaryImageUrl = getPrimaryImageUrl;
+exports.getThumbnailUrl = getThumbnailUrl;
+exports.hasImages = hasImages;
+exports.searchProperties = searchProperties;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map