more-apartments-astro-integration 1.0.1

package/dist/cli/index.js

@@ -0,0 +1,1010 @@
+#!/usr/bin/env node
+'use strict';
+
+var commander = require('commander');
+var dotenv = require('dotenv');
+var path = require('path');
+var zod = require('zod');
+var util = require('util');
+var fs = require('fs');
+
+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
+});
+zod.z.object({
+  message: zod.z.string(),
+  errors: zod.z.record(zod.z.array(zod.z.string())).optional()
+});
+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)
+});
+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)
+});
+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()
+});
+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()
+});
+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(config2) {
+    this.config = {
+      baseUrl: config2.baseUrl?.replace(/\/$/, "") || "",
+      apiKey: config2.apiKey || "",
+      instance: config2.instance || "",
+      timeout: config2.timeout || 3e4,
+      retry: {
+        attempts: config2.retry?.attempts || 3,
+        delay: config2.retry?.delay || 1e3
+      },
+      cache: {
+        enabled: config2.cache?.enabled ?? true,
+        ttl: config2.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((resolve3) => setTimeout(resolve3, (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;
+  }
+};
+function formatOutput(data, format = "json") {
+  switch (format) {
+    case "json":
+      console.log(JSON.stringify(data, null, 2));
+      break;
+    case "yaml":
+      console.log(toYAML(data));
+      break;
+    case "table":
+      if (Array.isArray(data)) {
+        console.table(data);
+      } else {
+        console.table([data]);
+      }
+      break;
+    default:
+      console.log(util.inspect(data, { depth: null, colors: true }));
+  }
+}
+function toYAML(obj, indent = 0) {
+  const spaces = "  ".repeat(indent);
+  if (obj === null || obj === void 0) {
+    return "null";
+  }
+  if (typeof obj === "string") {
+    return obj.includes("\n") ? `|
+${obj.split("\n").map((line) => `${spaces}  ${line}`).join("\n")}` : obj;
+  }
+  if (typeof obj === "number" || typeof obj === "boolean") {
+    return String(obj);
+  }
+  if (Array.isArray(obj)) {
+    if (obj.length === 0) return "[]";
+    return "\n" + obj.map((item) => `${spaces}- ${toYAML(item, indent + 1)}`).join("\n");
+  }
+  if (typeof obj === "object") {
+    const entries = Object.entries(obj);
+    if (entries.length === 0) return "{}";
+    return "\n" + entries.map(([key, value]) => {
+      const formattedValue = toYAML(value, indent + 1);
+      if (formattedValue.startsWith("\n")) {
+        return `${spaces}${key}:${formattedValue}`;
+      }
+      return `${spaces}${key}: ${formattedValue}`;
+    }).join("\n");
+  }
+  return String(obj);
+}
+function handleError(error) {
+  if (error.message) {
+    console.error(`Error: ${error.message}`);
+  } else {
+    console.error("An unexpected error occurred:", error);
+  }
+  process.exit(1);
+}
+
+// src/cli/commands/properties.ts
+function propertiesCommand(program2) {
+  const properties = program2.command("properties").alias("props").description("Manage properties");
+  properties.command("list").description("List all properties").option("-p, --page <number>", "Page number", "1").option("-l, --limit <number>", "Items per page", "10").action(async (options, command) => {
+    try {
+      const client = command.parent.parent.client;
+      const format = command.parent.parent.format;
+      const result = await client.getProperties({
+        page: parseInt(options.page),
+        per_page: parseInt(options.limit)
+      });
+      formatOutput(result, format);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  properties.command("show <id>").description("Show property details by ID or slug").action(async (id, options, command) => {
+    try {
+      const client = command.parent.parent.client;
+      const format = command.parent.parent.format;
+      const property = await client.getProperty(id);
+      formatOutput(property, format);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  properties.command("search").description("Search properties with filters").option("-d, --destination <destination>", "Destination (general search)").option("-c, --city <city>", "City name").option("-a, --area <area>", "Area/neighborhood").option("--arrival <date>", "Arrival date (YYYY-MM-DD)").option("--departure <date>", "Departure date (YYYY-MM-DD)").option("-g, --guests <number>", "Number of guests").option("-b, --bedrooms <number>", "Number of bedrooms").option("--bathrooms <number>", "Number of bathrooms").option("--max-persons <number>", "Maximum persons").option("--property-type <type>", "Property type").option("--elevator", "Has elevator").option("--parking", "Has parking").option("--balcony", "Has balcony").action(async (options, command) => {
+    try {
+      const client = command.parent.parent.client;
+      const format = command.parent.parent.format;
+      const searchParams = {};
+      if (options.destination) searchParams.destination = options.destination;
+      if (options.city) searchParams.city = options.city;
+      if (options.area) searchParams.area = options.area;
+      if (options.arrival) searchParams.arrival = options.arrival;
+      if (options.departure) searchParams.departure = options.departure;
+      if (options.guests) searchParams.guests = parseInt(options.guests);
+      if (options.bedrooms) searchParams.bedrooms = parseInt(options.bedrooms);
+      if (options.bathrooms) searchParams.bathrooms = parseInt(options.bathrooms);
+      if (options.maxPersons) searchParams.maxPersons = parseInt(options.maxPersons);
+      if (options.propertyType) searchParams.propertyType = options.propertyType;
+      if (options.elevator) searchParams.elevator = true;
+      if (options.parking) searchParams.parking = true;
+      if (options.balcony) searchParams.balcony = true;
+      const results = await client.searchProperties(searchParams);
+      formatOutput(results, format);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  properties.command("availability <id>").description("Get property availability").requiredOption("-s, --start <date>", "Start date (YYYY-MM-DD)").requiredOption("-e, --end <date>", "End date (YYYY-MM-DD)").action(async (id, options, command) => {
+    try {
+      const client = command.parent.parent.client;
+      const format = command.parent.parent.format;
+      const availability = await client.getAvailability(id, options.start, options.end);
+      formatOutput(availability, format);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/cli/commands/content.ts
+function contentCommand(program2) {
+  const content = program2.command("content").description("Manage content (pages, posts, categories)");
+  const pages = content.command("pages").description("Manage pages");
+  pages.command("list").description("List all pages").action(async (options, command) => {
+    try {
+      const client = command.parent.parent.parent.client;
+      const format = command.parent.parent.parent.format;
+      const result = await client.getPages();
+      formatOutput(result, format);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  pages.command("show <slug>").description("Show page details by slug").action(async (slug, options, command) => {
+    try {
+      const client = command.parent.parent.parent.client;
+      const format = command.parent.parent.parent.format;
+      const page = await client.getPage(slug);
+      formatOutput(page, format);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  const posts = content.command("posts").description("Manage posts");
+  posts.command("list").description("List all posts").option("-p, --page <number>", "Page number", "1").option("-l, --limit <number>", "Items per page", "10").option("-t, --tag <tag>", "Filter by tag").action(async (options, command) => {
+    try {
+      const client = command.parent.parent.parent.client;
+      const format = command.parent.parent.parent.format;
+      const params = {
+        page: parseInt(options.page),
+        per_page: parseInt(options.limit)
+      };
+      if (options.tag) params.tag = options.tag;
+      const result = await client.getPosts(params);
+      formatOutput(result, format);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  posts.command("show <slug>").description("Show post details by slug").action(async (slug, options, command) => {
+    try {
+      const client = command.parent.parent.parent.client;
+      const format = command.parent.parent.parent.format;
+      const post = await client.getPost(slug);
+      formatOutput(post, format);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  const categories = content.command("categories").alias("cats").description("Manage categories");
+  categories.command("list").description("List all categories").action(async (options, command) => {
+    try {
+      const client = command.parent.parent.parent.client;
+      const format = command.parent.parent.parent.format;
+      const result = await client.getCategories();
+      formatOutput(result, format);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  categories.command("show <slug>").description("Show category details by slug").action(async (slug, options, command) => {
+    try {
+      const client = command.parent.parent.parent.client;
+      const format = command.parent.parent.parent.format;
+      const category = await client.getCategory(slug);
+      formatOutput(category, format);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  categories.command("segments <slug>").description("List segments for a category").action(async (slug, options, command) => {
+    try {
+      const client = command.parent.parent.parent.client;
+      const format = command.parent.parent.parent.format;
+      const segments = await client.getCategorySegments(slug);
+      formatOutput(segments, format);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  categories.command("segment <category> <segment>").description("Show specific segment details").action(async (category, segment, options, command) => {
+    try {
+      const client = command.parent.parent.parent.client;
+      const format = command.parent.parent.parent.format;
+      const result = await client.getCategorySegment(category, segment);
+      formatOutput(result, format);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  content.command("locations").description("List all locations").action(async (options, command) => {
+    try {
+      const client = command.parent.parent.client;
+      const format = command.parent.parent.format;
+      const locations = await client.getLocations();
+      formatOutput(locations, format);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/cli/commands/settings.ts
+function settingsCommand(program2) {
+  const settings = program2.command("settings").description("Manage settings");
+  settings.command("main").description("Get main site settings").action(async (options, command) => {
+    try {
+      const client = command.parent.parent.client;
+      const format = command.parent.parent.format;
+      const result = await client.getMainSettings();
+      formatOutput(result, format);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  settings.command("theme").description("Get theme settings").action(async (options, command) => {
+    try {
+      const client = command.parent.parent.client;
+      const format = command.parent.parent.format;
+      const result = await client.getThemeSettings();
+      formatOutput(result, format);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  settings.command("properties").alias("props").description("Get property settings").action(async (options, command) => {
+    try {
+      const client = command.parent.parent.client;
+      const format = command.parent.parent.format;
+      const result = await client.getPropertySettings();
+      formatOutput(result, format);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  settings.command("booking").description("Get booking settings").action(async (options, command) => {
+    try {
+      const client = command.parent.parent.client;
+      const format = command.parent.parent.format;
+      const result = await client.getBookingSettings();
+      formatOutput(result, format);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  settings.command("all").description("Get all settings").action(async (options, command) => {
+    try {
+      const client = command.parent.parent.client;
+      const format = command.parent.parent.format;
+      const [main, theme, properties, booking] = await Promise.all([
+        client.getMainSettings(),
+        client.getThemeSettings(),
+        client.getPropertySettings(),
+        client.getBookingSettings()
+      ]);
+      const result = {
+        main,
+        theme,
+        properties,
+        booking
+      };
+      formatOutput(result, format);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+function bookingsCommand(program2) {
+  const bookings = program2.command("bookings").description("Manage bookings");
+  bookings.command("create").description("Create a new booking").requiredOption("-f, --file <path>", "Path to JSON file with booking data").action(async (options, command) => {
+    try {
+      const client = command.parent.parent.client;
+      const format = command.parent.parent.format;
+      const filePath = path.resolve(process.cwd(), options.file);
+      const bookingData = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+      const result = await client.createBooking(bookingData);
+      console.log("\u2713 Booking created successfully");
+      formatOutput(result, format);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  bookings.command("show <id>").description("Show booking details by ID").action(async (id, options, command) => {
+    try {
+      const client = command.parent.parent.client;
+      const format = command.parent.parent.format;
+      const booking = await client.getBooking(id);
+      formatOutput(booking, format);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  bookings.command("example").description("Print example booking JSON structure").action(() => {
+    const example = {
+      property_id: 123,
+      customer: {
+        first_name: "John",
+        last_name: "Doe",
+        email: "john.doe@example.com",
+        phone: "+31612345678",
+        address: "123 Main St",
+        city: "Amsterdam",
+        country: "Netherlands",
+        postal_code: "1012AB"
+      },
+      arrival_date: "2024-06-01",
+      departure_date: "2024-06-07",
+      guests: 2,
+      total_price: 850,
+      notes: "Late check-in requested"
+    };
+    console.log("Example booking structure (save to file and use with --file):");
+    console.log(JSON.stringify(example, null, 2));
+  });
+}
+
+// src/cli/index.ts
+dotenv.config({ path: path.resolve(process.cwd(), ".env") });
+var program = new commander.Command();
+program.name("more-apartments").description("CLI to interact with More Apartments REST API").version("1.0.1").option("-u, --base-url <url>", "API base URL", process.env.MORE_APARTMENTS_BASE_URL).option("-k, --api-key <key>", "API key", process.env.MORE_APARTMENTS_API_KEY).option("-i, --instance <instance>", "Instance name", process.env.MORE_APARTMENTS_INSTANCE).option("-t, --timeout <ms>", "Request timeout in ms", "30000").option("-f, --format <format>", "Output format (json, table, yaml)", "json").hook("preAction", (thisCommand) => {
+  const opts = thisCommand.opts();
+  if (!opts.baseUrl) {
+    console.error("Error: --base-url is required (or set MORE_APARTMENTS_BASE_URL env var)");
+    process.exit(1);
+  }
+  if (!opts.apiKey) {
+    console.error("Error: --api-key is required (or set MORE_APARTMENTS_API_KEY env var)");
+    process.exit(1);
+  }
+  if (!opts.instance) {
+    console.error("Error: --instance is required (or set MORE_APARTMENTS_INSTANCE env var)");
+    process.exit(1);
+  }
+  const clientConfig = {
+    baseUrl: opts.baseUrl,
+    apiKey: opts.apiKey,
+    instance: opts.instance,
+    timeout: parseInt(opts.timeout),
+    cache: { enabled: false, ttl: 0 }
+  };
+  thisCommand.client = new MoreApartmentsClient(clientConfig);
+  thisCommand.format = opts.format;
+});
+propertiesCommand(program);
+contentCommand(program);
+settingsCommand(program);
+bookingsCommand(program);
+program.parse();
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map