repull 0.2.15 → 0.2.16

data/lib/repull/models/booking_availability_update.rb

@@ -14,7 +14,7 @@ require 'date'
 require 'time'
 
 module Repull
-  # One (room, rate-plan, date-range) availability update. Carries inventory (`availableRooms`), the dedicated stop-sell flag (`closed`), and the same length-of-stay / arrival restrictions as a rate update.
+  # One (room, rate-plan, date-range) availability update. Carries inventory (`availableRooms`), the dedicated stop-sell flag (`closed`), and length-of-stay / arrival restrictions. Omit `availableRooms` and `closed` for a restriction-only write — inventory is then left untouched.
   class BookingAvailabilityUpdate < ApiModelBase
     # Booking.com room id.
     attr_accessor :room_id
@@ -24,7 +24,7 @@ module Repull
 
     attr_accessor :date_range
 
-    # Rooms to sell (`roomstosell`). `0` blocks the room for the range.
+    # Rooms to sell (`roomstosell`). `0` blocks the room for the range. Omit it to leave inventory alone — `0` is a stop-sell, not a no-op.
     attr_accessor :available_rooms
 
     attr_accessor :status
@@ -62,7 +62,7 @@ module Repull
       {
         :'room_id' => :'String',
         :'rate_id' => :'String',
-        :'date_range' => :'BookingPricingRateUpdateDateRange',
+        :'date_range' => :'BookingAvailabilityUpdateDateRange',
         :'available_rooms' => :'Integer',
         :'status' => :'String',
         :'closed' => :'Boolean',
@@ -73,6 +73,7 @@ module Repull
     # List of attributes with nullable: true
     def self.openapi_nullable
       Set.new([
+        :'available_rooms',
         :'status',
         :'closed',
       ])
@@ -114,8 +115,6 @@ module Repull
 
       if attributes.key?(:'available_rooms')
         self.available_rooms = attributes[:'available_rooms']
-      else
-        self.available_rooms = nil
       end
 
       if attributes.key?(:'status')
@@ -148,10 +147,6 @@ module Repull
         invalid_properties.push('invalid value for "date_range", date_range cannot be nil.')
       end
 
-      if @available_rooms.nil?
-        invalid_properties.push('invalid value for "available_rooms", available_rooms cannot be nil.')
-      end
-
       invalid_properties
     end
 
@@ -162,7 +157,6 @@ module Repull
       return false if @room_id.nil?
       return false if @rate_id.nil?
       return false if @date_range.nil?
-      return false if @available_rooms.nil?
       true
     end
 
@@ -196,16 +190,6 @@ module Repull
       @date_range = date_range
     end
 
-    # Custom attribute writer method with validation
-    # @param [Object] available_rooms Value to be assigned
-    def available_rooms=(available_rooms)
-      if available_rooms.nil?
-        fail ArgumentError, 'available_rooms cannot be nil'
-      end
-
-      @available_rooms = available_rooms
-    end
-
     # Checks equality by comparing each attribute.
     # @param [Object] Object to be compared
     def ==(o)

data/lib/repull/models/booking_availability_update_date_range.rb

@@ -0,0 +1,193 @@
+=begin
+#Repull API
+
+#The unified API for vacation rental tech. Connect to 50+ PMS platforms and 4 OTA channels through one REST API. Built-in AI operations for guest communication, pricing, and listing optimization.  ## Designed for AI agents Every error response on this API includes machine-parseable fields so an LLM (Claude in MCP, Cursor, Cline, GPT, etc.) can self-recover without escalating to a human: - `error.code` — stable string identifier (e.g. `invalid_params`, `rate_limit_exceeded`) - `error.message` — human-readable cause - `error.fix` — exact recovery steps (e.g. \"Pass `check_in_after` as ISO 8601: `?check_in_after=2026-01-15`\") - `error.docs_url` — link to the canonical write-up at `https://repull.dev/docs/errors/{code}` - `error.request_id` — id to correlate with server-side logs - `error.field` / `error.value_received` / `error.valid_values` / `error.did_you_mean` — when the error is parameter-specific - `error.retry_after` — seconds to wait before retrying (rate-limit + transient upstream)  `Access-Control-Expose-Headers` lists `x-request-id` and the `X-RateLimit-*` family so browsers can read them on cross-origin responses.  ## Quick Start 1. Get an API key at https://repull.dev/dashboard 2. Connect a PMS: `POST /v1/connect/{provider}` 3. List properties: `GET /v1/properties` 4. Get reservations: `GET /v1/reservations`  ## Authentication All requests require a Bearer token: ``` Authorization: Bearer sk_live_YOUR_API_KEY ```  ## Request Correlation (X-Request-ID) Every response carries an `X-Request-ID` header, e.g. `X-Request-ID: req_01HXY...`. Include this id in support tickets and bug reports — we can trace the full request lifecycle (auth, rate limit, handler, downstream calls, log row) from a single id.  You may set the header on the inbound request to forward your own trace id; we will echo it back instead of generating a new one. Accepted format: `^[\\\\w.-]{1,128}$`.  The id is also embedded in error envelopes as `request_id` so server-side log diffs work even when the response headers are stripped by an intermediate proxy.  ## Rate Limits The public API enforces a per-API-key sliding-window rate limit on top of the per-tier monthly + daily-AI quotas.  **Default policy:** 600 requests per 60 seconds, per API key. Sliding window — there is no fixed-minute boundary you can burst across.  Every response includes:  | Header | Meaning | |---|---| | `X-RateLimit-Limit` | Requests permitted in the current window. | | `X-RateLimit-Remaining` | Requests left in the current window after this call. | | `X-RateLimit-Reset` | Unix epoch (seconds) when the next slot opens. | | `X-RateLimit-Policy` | Machine-readable policy descriptor, e.g. `600;w=60`. | | `Retry-After` | Seconds to wait before retrying. **Only present on 429 responses.** |  **On 429 (rate_limit_exceeded):** the response body matches the standard error envelope with `code: \"rate_limit_exceeded\"`, plus `limit`, `window_seconds`, `retry_after`, and `request_id` fields. SDKs MUST honor `Retry-After` and use exponential backoff with jitter on subsequent retries — never a tight loop.  Recommended backoff: ``` sleep_ms = (Retry-After * 1000) + random(0..250) ```  Monthly + daily-AI tier quotas (`free`, `starter`, `custom`) are enforced separately and also surface as 429s; they include `tier`, `scope`, and `resetsAt` fields.  ## Plan Limits (402 — `listings_limit_exceeded`) The Repull API also enforces a per-tier cap on **active listings**:  | Tier | Active listings cap | |---|---| | `free` | 3 | | `starter` | 50 | | `custom` | unlimited |  When a customer's active-listing count is above their tier cap, the API returns **`402 Payment Required`** with `error.code = \"listings_limit_exceeded\"` on every route EXCEPT:  - `/v1/health` — uptime probes are never gated. - `/v1/usage/*` — so dashboards can render the over-cap state. - Any `DELETE` — so the customer can trim listings to get back under the cap without paying.  Unlike 429, 402 is NOT a \"wait and retry\" condition — `Retry-After` is not set. The only paths back to 200 are:   1. `DELETE` enough listings to come back under the cap, or   2. Upgrade at `https://repull.dev/dashboard/billing`. The server-side usage cache is 60s, so the first 200 after an upgrade may take up to a minute.  The envelope mirrors `rate_limit_exceeded` for SDK ergonomics: `tier`, `limit`, `active_listings`, `upgrade_url`, plus the standard `code` / `message` / `fix` / `docs_url` / `request_id`.
+
+The version of the OpenAPI document: 1.0.0
+Contact: ivan@vanio.ai
+Generated by: https://openapi-generator.tech
+Generator version: 7.22.0
+
+=end
+
+require 'date'
+require 'time'
+
+module Repull
+  # The nights this update applies to. **Both ends are inclusive** — `start` equal to `end` is one night.
+  class BookingAvailabilityUpdateDateRange < ApiModelBase
+    # First night, YYYY-MM-DD.
+    attr_accessor :start
+
+    # Last night, YYYY-MM-DD, inclusive.
+    attr_accessor :_end
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'start' => :'start',
+        :'_end' => :'end'
+      }
+    end
+
+    # Returns attribute mapping this model knows about
+    def self.acceptable_attribute_map
+      attribute_map
+    end
+
+    # Returns all the JSON keys this model knows about
+    def self.acceptable_attributes
+      acceptable_attribute_map.values
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'start' => :'Date',
+        :'_end' => :'Date'
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+      ])
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      if (!attributes.is_a?(Hash))
+        fail ArgumentError, "The input argument (attributes) must be a hash in `Repull::BookingAvailabilityUpdateDateRange` initialize method"
+      end
+
+      # check to see if the attribute exists and convert string to symbol for hash key
+      acceptable_attribute_map = self.class.acceptable_attribute_map
+      attributes = attributes.each_with_object({}) { |(k, v), h|
+        if (!acceptable_attribute_map.key?(k.to_sym))
+          fail ArgumentError, "`#{k}` is not a valid attribute in `Repull::BookingAvailabilityUpdateDateRange`. Please check the name to make sure it's valid. List of attributes: " + acceptable_attribute_map.keys.inspect
+        end
+        h[k.to_sym] = v
+      }
+
+      if attributes.key?(:'start')
+        self.start = attributes[:'start']
+      else
+        self.start = nil
+      end
+
+      if attributes.key?(:'_end')
+        self._end = attributes[:'_end']
+      else
+        self._end = nil
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      warn '[DEPRECATED] the `list_invalid_properties` method is obsolete'
+      invalid_properties = Array.new
+      if @start.nil?
+        invalid_properties.push('invalid value for "start", start cannot be nil.')
+      end
+
+      if @_end.nil?
+        invalid_properties.push('invalid value for "_end", _end cannot be nil.')
+      end
+
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      warn '[DEPRECATED] the `valid?` method is obsolete'
+      return false if @start.nil?
+      return false if @_end.nil?
+      true
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] start Value to be assigned
+    def start=(start)
+      if start.nil?
+        fail ArgumentError, 'start cannot be nil'
+      end
+
+      @start = start
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] _end Value to be assigned
+    def _end=(_end)
+      if _end.nil?
+        fail ArgumentError, '_end cannot be nil'
+      end
+
+      @_end = _end
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          start == o.start &&
+          _end == o._end
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Integer] Hash code
+    def hash
+      [start, _end].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def self.build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      attributes = attributes.transform_keys(&:to_sym)
+      transformed_hash = {}
+      openapi_types.each_pair do |key, type|
+        if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = nil
+        elsif type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the attribute
+          # is documented as an array but the input is not
+          if attributes[attribute_map[key]].is_a?(Array)
+            transformed_hash["#{key}"] = attributes[attribute_map[key]].map { |v| _deserialize($1, v) }
+          end
+        elsif !attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = _deserialize(type, attributes[attribute_map[key]])
+        end
+      end
+      new(transformed_hash)
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        if value.nil?
+          is_nullable = self.class.openapi_nullable.include?(attr)
+          next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
+        end
+
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+  end
+
+end

data/lib/repull/models/booking_availability_update_request.rb

@@ -14,11 +14,14 @@ require 'date'
 require 'time'
 
 module Repull
-  # Body for `PUT /v1/channels/booking/availability`. Selects one of Booking's three ARI write paths via `type` and forwards `updates` verbatim to the connector.
+  # Body for `PUT /v1/channels/booking/availability`. `type` selects which of Booking.com's writes to perform. Date ranges are inclusive at both ends everywhere in this body.
   class BookingAvailabilityUpdateRequest < ApiModelBase
-    # `rates` → price + restrictions (`updateRates`); `availability` → inventory + stop-sell + restrictions (`updateAvailability`); `derived-pricing` → occupancy-derived pricing rules (`updateDerivedPricing`).
+    # `rates` → nightly prices (+ any restrictions sent with them), written at an explicit `occupancy`; `availability` → inventory, stop-sell and restrictions; `derived-pricing` → occupancy-derived pricing rules. A rates update may not carry `roomsToSell`: inventory is an `availability` write.
     attr_accessor :type
 
+    # Only for `type: \"rates\"`. Default `true`: after the write the affected nights are read back off Booking.com so `applied` can say `verified` or `mismatch`. Send `false` to skip the read (one fewer Booking.com call); the response then reports `applied: \"unverified\"`.
+    attr_accessor :verify
+
     attr_accessor :property_id
 
     # For `type: \"rates\"` each item is a `BookingPricingRateUpdate`; for `type: \"availability\"` a `BookingAvailabilityUpdate`; for `type: \"derived-pricing\"` a derived-price rule set.
@@ -28,6 +31,7 @@ module Repull
     def self.attribute_map
       {
         :'type' => :'type',
+        :'verify' => :'verify',
         :'property_id' => :'property_id',
         :'updates' => :'updates'
       }
@@ -47,6 +51,7 @@ module Repull
     def self.openapi_types
       {
         :'type' => :'String',
+        :'verify' => :'Boolean',
         :'property_id' => :'BookingAvailabilityUpdateRequestPropertyId',
         :'updates' => :'Array<BookingAvailabilityUpdateRequestUpdatesInner>'
       }
@@ -55,6 +60,7 @@ module Repull
     # List of attributes with nullable: true
     def self.openapi_nullable
       Set.new([
+        :'verify',
       ])
     end
 
@@ -80,6 +86,10 @@ module Repull
         self.type = nil
       end
 
+      if attributes.key?(:'verify')
+        self.verify = attributes[:'verify']
+      end
+
       if attributes.key?(:'property_id')
         self.property_id = attributes[:'property_id']
       else
@@ -170,6 +180,7 @@ module Repull
       return true if self.equal?(o)
       self.class == o.class &&
           type == o.type &&
+          verify == o.verify &&
           property_id == o.property_id &&
           updates == o.updates
     end
@@ -183,7 +194,7 @@ module Repull
     # Calculates hash code according to all attributes.
     # @return [Integer] Hash code
     def hash
-      [type, property_id, updates].hash
+      [type, verify, property_id, updates].hash
     end
 
     # Builds the object from hash

data/lib/repull/models/booking_pricing_rate_update.rb

@@ -14,25 +14,29 @@ require 'date'
 require 'time'
 
 module Repull
-  # A single (room, rate-plan, date-range) update pushed to Booking.com via the rates API.
+  # A single (room, rate-plan, date-range) price update. The amount is written against the party size in `occupancy`, for every night from `dateRange.start` to `dateRange.end` inclusive.
   class BookingPricingRateUpdate < ApiModelBase
-    # Booking.com room ID for the rate plan. Comes from `listings_booking_rooms` mapping.
+    # Booking.com room id the rate plan sells. `GET /v1/channels/booking/properties/{id}/rooms` lists them.
     attr_accessor :room_id
 
-    # Booking.com rate-plan ID.
+    # Booking.com rate-plan id.
     attr_accessor :rate_id
 
     attr_accessor :date_range
 
+    # Nightly amount, in `currency`, for a party of `occupancy`.
     attr_accessor :price
 
+    # Currency the rate plan is sold in.
     attr_accessor :currency
 
+    # Optional single-occupancy amount, written alongside the main amount.
     attr_accessor :single_price
 
+    # The party size this rate plan prices — a key, not a preference. Booking.com stores the amount against this number: above the rate plan's own maximum it declines the price in silence and the night keeps its old value; below it, it answers 400 and the old price stays published. Omit it and Repull resolves it from Booking.com's own data for this (room, rate plan) and echoes the value and its source back in `occupancy[]`. When it cannot be resolved the write is refused with `422` naming `updates[N].occupancy` — a price is never sent at a guessed party size.
     attr_accessor :occupancy
 
-    # Rooms to sell for the date range. Set to `0` to stop-sell this room/rate on the rates endpoint (Booking's dedicated `<closed>` stop-sell flag lives on the availability endpoint — see `BookingAvailabilityUpdate.closed`).
+    # Refused. A rate update carries prices only; sending this returns `422 inventory_not_in_rate_update` naming `updates[N].roomsToSell`. Write inventory with `type: \"availability\"` and `availableRooms` (plus `closed: true` for a stop-sell).
     attr_accessor :rooms_to_sell
 
     attr_accessor :restrictions
@@ -170,10 +174,18 @@ module Repull
         invalid_properties.push('invalid value for "price", price cannot be nil.')
       end
 
+      if @price < 0
+        invalid_properties.push('invalid value for "price", must be greater than or equal to 0.')
+      end
+
       if @currency.nil?
         invalid_properties.push('invalid value for "currency", currency cannot be nil.')
       end
 
+      if !@occupancy.nil? && @occupancy < 1
+        invalid_properties.push('invalid value for "occupancy", must be greater than or equal to 1.')
+      end
+
       invalid_properties
     end
 
@@ -185,7 +197,9 @@ module Repull
       return false if @rate_id.nil?
       return false if @date_range.nil?
       return false if @price.nil?
+      return false if @price < 0
       return false if @currency.nil?
+      return false if !@occupancy.nil? && @occupancy < 1
       true
     end
 
@@ -226,6 +240,10 @@ module Repull
         fail ArgumentError, 'price cannot be nil'
       end
 
+      if price < 0
+        fail ArgumentError, 'invalid value for "price", must be greater than or equal to 0.'
+      end
+
       @price = price
     end
 
@@ -239,6 +257,16 @@ module Repull
       @currency = currency
     end
 
+    # Custom attribute writer method with validation
+    # @param [Object] occupancy Value to be assigned
+    def occupancy=(occupancy)
+      if !occupancy.nil? && occupancy < 1
+        fail ArgumentError, 'invalid value for "occupancy", must be greater than or equal to 1.'
+      end
+
+      @occupancy = occupancy
+    end
+
     # Checks equality by comparing each attribute.
     # @param [Object] Object to be compared
     def ==(o)

data/lib/repull/models/booking_pricing_rate_update_date_range.rb

@@ -14,9 +14,12 @@ require 'date'
 require 'time'
 
 module Repull
+  # The nights this update applies to. **Both ends are inclusive**: `{ \"start\": \"2026-11-04\", \"end\": \"2026-11-04\" }` writes exactly one night.
   class BookingPricingRateUpdateDateRange < ApiModelBase
+    # First night, YYYY-MM-DD.
     attr_accessor :start
 
+    # Last night, YYYY-MM-DD, inclusive — the same date as `start` for a single night.
     attr_accessor :_end
 
     # Attribute mapping from ruby-style variable name to JSON key.

data/lib/repull/models/booking_pricing_rate_update_restrictions.rb

@@ -14,33 +14,33 @@ require 'date'
 require 'time'
 
 module Repull
-  # Optional length-of-stay / availability restrictions for one rate update. Every field here is forwarded verbatim into Booking.com's rates XML (`minimumstay`, `maximumstay`, `closedonarrival`, `closedondeparture`, …) — omit a field to leave that restriction untouched.
+  # Length-of-stay and arrival restrictions for the nights in this update. Omit a field to leave that restriction untouched — nothing you do not state is changed.  These are written on Booking.com's availability notification, which is the wire that carries a restriction when no inventory changes hands. Sending them alongside a price is supported: the prices and the restrictions are two writes, and the response reports each one separately (`price` and `restrictions`), so a half that lands is never reported as a failure and a half that is refused is never reported as applied.  Three restrictions are refused with `422 restriction_not_supported` naming the field: Booking.com's notification has no element for them, and dropping a restriction you stated would be worse than refusing it. Set those on the rate plan in the Booking.com Extranet.
   class BookingPricingRateUpdateRestrictions < ApiModelBase
-    # Minimum length of stay (`minimumstay`).
+    # Minimum length of stay. Booking.com stores a 1-night minimum as no minimum at all, so `minStay: 1` reads back as `0` and is reported as applied.
     attr_accessor :min_stay
 
-    # Maximum length of stay (`maximumstay`).
+    # Maximum length of stay.
     attr_accessor :max_stay
 
-    # Closed-to-arrival — guests may not check in on the affected dates (`closedonarrival`).
+    # Closed-to-arrival — guests may not check in on these nights. `false` clears the flag; omit the field to leave it as it is.
     attr_accessor :closed_to_arrival
 
-    # Closed-to-departure — guests may not check out on the affected dates (`closedondeparture`).
+    # Closed-to-departure — guests may not check out on these nights. `false` clears the flag; omit the field to leave it as it is.
     attr_accessor :closed_to_departure
 
-    # Arrival-based minimum length of stay (`minimumstay_arrival`).
+    # Arrival-based minimum length of stay — applies to stays that START on these nights, rather than any stay covering them.
     attr_accessor :min_stay_arrival
 
-    # Arrival-based maximum length of stay (`maximumstay_arrival`).
+    # Arrival-based maximum length of stay.
     attr_accessor :max_stay_arrival
 
-    # Arrival-based exact length of stay (`exactstay_arrival`).
+    # Refused. Booking.com's restriction notification has no element for an exact arrival-based stay length, so it cannot be written through the API; sending it returns `422 restriction_not_supported` naming `updates[N].restrictions.exactStayArrival`. Set it on the rate plan in the Booking.com Extranet.
     attr_accessor :exact_stay_arrival
 
-    # Minimum advance-reservation window, format `XDY` (X days Y hours) — `min_advance_res`.
+    # Refused, for the same reason as `exactStayArrival` — returns `422 restriction_not_supported`. Set the minimum advance-reservation window on the rate plan in the Booking.com Extranet.
     attr_accessor :min_advance_res
 
-    # Maximum advance-reservation window, format `XDY` (X days Y hours) — `max_advance_res`.
+    # Refused, for the same reason as `exactStayArrival` — returns `422 restriction_not_supported`. Set the maximum advance-reservation window on the rate plan in the Booking.com Extranet.
     attr_accessor :max_advance_res
 
     # Attribute mapping from ruby-style variable name to JSON key.

data/lib/repull/models/booking_pricing_response.rb

@@ -20,11 +20,15 @@ module Repull
 
     attr_accessor :listing_id
 
+    # Other Booking.com properties this listing is also published under. Empty in the normal case. Pass one as `?hotel_id=` to read its pricing instead.
+    attr_accessor :other_hotel_ids
+
     # Attribute mapping from ruby-style variable name to JSON key.
     def self.attribute_map
       {
         :'hotel_id' => :'hotelId',
-        :'listing_id' => :'listingId'
+        :'listing_id' => :'listingId',
+        :'other_hotel_ids' => :'otherHotelIds'
       }
     end
 
@@ -42,7 +46,8 @@ module Repull
     def self.openapi_types
       {
         :'hotel_id' => :'String',
-        :'listing_id' => :'String'
+        :'listing_id' => :'String',
+        :'other_hotel_ids' => :'Array<String>'
       }
     end
 
@@ -75,6 +80,12 @@ module Repull
       if attributes.key?(:'listing_id')
         self.listing_id = attributes[:'listing_id']
       end
+
+      if attributes.key?(:'other_hotel_ids')
+        if (value = attributes[:'other_hotel_ids']).is_a?(Array)
+          self.other_hotel_ids = value
+        end
+      end
     end
 
     # Show invalid properties with the reasons. Usually used together with valid?
@@ -98,7 +109,8 @@ module Repull
       return true if self.equal?(o)
       self.class == o.class &&
           hotel_id == o.hotel_id &&
-          listing_id == o.listing_id
+          listing_id == o.listing_id &&
+          other_hotel_ids == o.other_hotel_ids
     end
 
     # @see the `==` method
@@ -110,7 +122,7 @@ module Repull
     # Calculates hash code according to all attributes.
     # @return [Integer] Hash code
     def hash
-      [hotel_id, listing_id].hash
+      [hotel_id, listing_id, other_hotel_ids].hash
     end
 
     # Builds the object from hash