repull 0.2.15 → 0.2.16

data/lib/repull/models/booking_pricing_update_response.rb

@@ -14,31 +14,53 @@ require 'date'
 require 'time'
 
 module Repull
+  # What a Booking.com rate write actually did. Returned by `PUT /v1/channels/booking/listings/{id}/pricing` and by `PUT /v1/channels/booking/availability` with `type: \"rates\"`.  Prices and restrictions are two writes on two of Booking.com's wires, and Booking.com can take one and refuse the other. The response says so: `price` and `restrictions` each carry their own state, their own read-back and — when refused — Booking.com's own reason. The top-level `applied` summarises them, and is `partial` when they disagree. A half that landed is never reported as a failure.
   class BookingPricingUpdateResponse < ApiModelBase
     attr_accessor :hotel_id
 
     attr_accessor :listing_id
 
-    # Number of updates Booking.com accepted as `success`. Falls back to total update count when Booking omits per-update status on full success.
-    attr_accessor :pushed
+    # Echoed back by `PUT /v1/channels/booking/availability`.
+    attr_accessor :property_id
 
+    # How many updates were sent.
     attr_accessor :requested
 
-    # Per-update failure rows from Booking — shape mirrors the Booking rates API response.
+    attr_accessor :occupancy
+
+    # What is known about the nights now. `verified` — read back, every night carries what was sent. `mismatch` — read back, some do not (`verification.rows` / `restrictions.verification.rows` name them). `rejected` — Booking.com refused everything that was sent. `partial` — one half landed and the other did not; read `price.applied` and `restrictions.applied` to see which, and `restrictions.rejection.message` for Booking.com's reason. `unverified` — Booking.com acknowledged the request and no read-back ran: an unknown, not a success. A bare acknowledgement is never reported as \"all applied\".
+    attr_accessor :applied
+
+    attr_accessor :price
+
+    attr_accessor :restrictions
+
+    attr_accessor :verification
+
+    # Booking.com's own answers, verbatim: `rates` (the rate-amount notification) and `restrictions` (the availability notification, when the updates carried any restriction).
+    attr_accessor :booking
+
+    # Failures Booking.com named, across both wires. Empty means Booking.com named none — not that the nights changed; that is what `applied` is for.
     attr_accessor :errors
 
-    # Verbatim Booking response envelope for debugging.
-    attr_accessor :raw
+    # Present when Booking.com's rate-plan read did not complete, so an occupancy fell back to the room definition.
+    attr_accessor :rate_plan_read_error
 
     # Attribute mapping from ruby-style variable name to JSON key.
     def self.attribute_map
       {
         :'hotel_id' => :'hotelId',
         :'listing_id' => :'listingId',
-        :'pushed' => :'pushed',
+        :'property_id' => :'propertyId',
         :'requested' => :'requested',
+        :'occupancy' => :'occupancy',
+        :'applied' => :'applied',
+        :'price' => :'price',
+        :'restrictions' => :'restrictions',
+        :'verification' => :'verification',
+        :'booking' => :'booking',
         :'errors' => :'errors',
-        :'raw' => :'raw'
+        :'rate_plan_read_error' => :'ratePlanReadError'
       }
     end
 
@@ -57,16 +79,26 @@ module Repull
       {
         :'hotel_id' => :'String',
         :'listing_id' => :'String',
-        :'pushed' => :'Integer',
+        :'property_id' => :'String',
         :'requested' => :'Integer',
+        :'occupancy' => :'Array<BookingRateWriteOccupancy>',
+        :'applied' => :'String',
+        :'price' => :'BookingRateWritePriceHalf',
+        :'restrictions' => :'BookingRateWriteRestrictionHalf',
+        :'verification' => :'BookingRateWriteVerification',
+        :'booking' => :'Hash<String, Object>',
         :'errors' => :'Array<Hash<String, Object>>',
-        :'raw' => :'Hash<String, Object>'
+        :'rate_plan_read_error' => :'String'
       }
     end
 
     # List of attributes with nullable: true
     def self.openapi_nullable
       Set.new([
+        :'hotel_id',
+        :'listing_id',
+        :'property_id',
+        :'rate_plan_read_error'
       ])
     end
 
@@ -94,24 +126,50 @@ module Repull
         self.listing_id = attributes[:'listing_id']
       end
 
-      if attributes.key?(:'pushed')
-        self.pushed = attributes[:'pushed']
+      if attributes.key?(:'property_id')
+        self.property_id = attributes[:'property_id']
       end
 
       if attributes.key?(:'requested')
         self.requested = attributes[:'requested']
       end
 
+      if attributes.key?(:'occupancy')
+        if (value = attributes[:'occupancy']).is_a?(Array)
+          self.occupancy = value
+        end
+      end
+
+      if attributes.key?(:'applied')
+        self.applied = attributes[:'applied']
+      end
+
+      if attributes.key?(:'price')
+        self.price = attributes[:'price']
+      end
+
+      if attributes.key?(:'restrictions')
+        self.restrictions = attributes[:'restrictions']
+      end
+
+      if attributes.key?(:'verification')
+        self.verification = attributes[:'verification']
+      end
+
+      if attributes.key?(:'booking')
+        if (value = attributes[:'booking']).is_a?(Hash)
+          self.booking = value
+        end
+      end
+
       if attributes.key?(:'errors')
         if (value = attributes[:'errors']).is_a?(Array)
           self.errors = value
         end
       end
 
-      if attributes.key?(:'raw')
-        if (value = attributes[:'raw']).is_a?(Hash)
-          self.raw = value
-        end
+      if attributes.key?(:'rate_plan_read_error')
+        self.rate_plan_read_error = attributes[:'rate_plan_read_error']
       end
     end
 
@@ -137,10 +195,16 @@ module Repull
       self.class == o.class &&
           hotel_id == o.hotel_id &&
           listing_id == o.listing_id &&
-          pushed == o.pushed &&
+          property_id == o.property_id &&
           requested == o.requested &&
+          occupancy == o.occupancy &&
+          applied == o.applied &&
+          price == o.price &&
+          restrictions == o.restrictions &&
+          verification == o.verification &&
+          booking == o.booking &&
           errors == o.errors &&
-          raw == o.raw
+          rate_plan_read_error == o.rate_plan_read_error
     end
 
     # @see the `==` method
@@ -152,7 +216,7 @@ module Repull
     # Calculates hash code according to all attributes.
     # @return [Integer] Hash code
     def hash
-      [hotel_id, listing_id, pushed, requested, errors, raw].hash
+      [hotel_id, listing_id, property_id, requested, occupancy, applied, price, restrictions, verification, booking, errors, rate_plan_read_error].hash
     end
 
     # Builds the object from hash

data/lib/repull/models/booking_property.rb

@@ -14,27 +14,51 @@ require 'date'
 require 'time'
 
 module Repull
-  # A property registered in the Booking.com extranet for the connected hotel ID.
+  # A Booking.com property this workspace holds, with the Repull listings mapped under it. A property is a building; its rooms are what guests book, and each room maps to one Repull listing — so one property commonly carries many listings.
   class BookingProperty < ApiModelBase
-    # Booking.com hotel/property ID
-    attr_accessor :id
+    # Repull-side id for this Booking.com connection.
+    attr_accessor :connection_id
 
-    attr_accessor :name
+    # Booking.com hotel/property id. This is what `/v1/channels/booking/availability` takes as `property_id`.
+    attr_accessor :hotel_id
 
-    attr_accessor :status
+    attr_accessor :active
 
-    attr_accessor :country
+    attr_accessor :sync_enabled
 
-    attr_accessor :city
+    attr_accessor :booking_url
+
+    attr_accessor :markup
+
+    attr_accessor :sync_category
+
+    attr_accessor :suspended_at
+
+    attr_accessor :suspension_reason
+
+    attr_accessor :created_at
+
+    # `mapped` — at least one room points at a listing. `unmapped` — the property is claimed but its rooms are not mapped yet, so `listings` is empty; finish `POST /v1/connect/booking/map-rooms`. An unmapped property is listed rather than hidden, so a half-finished connection is visible instead of looking like no connection at all.
+    attr_accessor :mapping_status
+
+    # The Repull listings mapped under this property. Empty when `mappingStatus` is `unmapped`. Inactive listings are left out.
+    attr_accessor :listings
 
     # Attribute mapping from ruby-style variable name to JSON key.
     def self.attribute_map
       {
-        :'id' => :'id',
-        :'name' => :'name',
-        :'status' => :'status',
-        :'country' => :'country',
-        :'city' => :'city'
+        :'connection_id' => :'connectionId',
+        :'hotel_id' => :'hotelId',
+        :'active' => :'active',
+        :'sync_enabled' => :'syncEnabled',
+        :'booking_url' => :'bookingUrl',
+        :'markup' => :'markup',
+        :'sync_category' => :'syncCategory',
+        :'suspended_at' => :'suspendedAt',
+        :'suspension_reason' => :'suspensionReason',
+        :'created_at' => :'createdAt',
+        :'mapping_status' => :'mappingStatus',
+        :'listings' => :'listings'
       }
     end
 
@@ -51,20 +75,30 @@ module Repull
     # Attribute type mapping.
     def self.openapi_types
       {
-        :'id' => :'String',
-        :'name' => :'String',
-        :'status' => :'String',
-        :'country' => :'String',
-        :'city' => :'String'
+        :'connection_id' => :'String',
+        :'hotel_id' => :'String',
+        :'active' => :'Boolean',
+        :'sync_enabled' => :'Boolean',
+        :'booking_url' => :'String',
+        :'markup' => :'String',
+        :'sync_category' => :'String',
+        :'suspended_at' => :'Time',
+        :'suspension_reason' => :'String',
+        :'created_at' => :'Time',
+        :'mapping_status' => :'String',
+        :'listings' => :'Array<BookingPropertyListingsInner>'
       }
     end
 
     # List of attributes with nullable: true
     def self.openapi_nullable
       Set.new([
-        :'status',
-        :'country',
-        :'city'
+        :'booking_url',
+        :'markup',
+        :'sync_category',
+        :'suspended_at',
+        :'suspension_reason',
+        :'created_at',
       ])
     end
 
@@ -84,24 +118,54 @@ module Repull
         h[k.to_sym] = v
       }
 
-      if attributes.key?(:'id')
-        self.id = attributes[:'id']
+      if attributes.key?(:'connection_id')
+        self.connection_id = attributes[:'connection_id']
+      end
+
+      if attributes.key?(:'hotel_id')
+        self.hotel_id = attributes[:'hotel_id']
+      end
+
+      if attributes.key?(:'active')
+        self.active = attributes[:'active']
       end
 
-      if attributes.key?(:'name')
-        self.name = attributes[:'name']
+      if attributes.key?(:'sync_enabled')
+        self.sync_enabled = attributes[:'sync_enabled']
       end
 
-      if attributes.key?(:'status')
-        self.status = attributes[:'status']
+      if attributes.key?(:'booking_url')
+        self.booking_url = attributes[:'booking_url']
       end
 
-      if attributes.key?(:'country')
-        self.country = attributes[:'country']
+      if attributes.key?(:'markup')
+        self.markup = attributes[:'markup']
       end
 
-      if attributes.key?(:'city')
-        self.city = attributes[:'city']
+      if attributes.key?(:'sync_category')
+        self.sync_category = attributes[:'sync_category']
+      end
+
+      if attributes.key?(:'suspended_at')
+        self.suspended_at = attributes[:'suspended_at']
+      end
+
+      if attributes.key?(:'suspension_reason')
+        self.suspension_reason = attributes[:'suspension_reason']
+      end
+
+      if attributes.key?(:'created_at')
+        self.created_at = attributes[:'created_at']
+      end
+
+      if attributes.key?(:'mapping_status')
+        self.mapping_status = attributes[:'mapping_status']
+      end
+
+      if attributes.key?(:'listings')
+        if (value = attributes[:'listings']).is_a?(Array)
+          self.listings = value
+        end
       end
     end
 
@@ -125,11 +189,18 @@ module Repull
     def ==(o)
       return true if self.equal?(o)
       self.class == o.class &&
-          id == o.id &&
-          name == o.name &&
-          status == o.status &&
-          country == o.country &&
-          city == o.city
+          connection_id == o.connection_id &&
+          hotel_id == o.hotel_id &&
+          active == o.active &&
+          sync_enabled == o.sync_enabled &&
+          booking_url == o.booking_url &&
+          markup == o.markup &&
+          sync_category == o.sync_category &&
+          suspended_at == o.suspended_at &&
+          suspension_reason == o.suspension_reason &&
+          created_at == o.created_at &&
+          mapping_status == o.mapping_status &&
+          listings == o.listings
     end
 
     # @see the `==` method
@@ -141,7 +212,7 @@ module Repull
     # Calculates hash code according to all attributes.
     # @return [Integer] Hash code
     def hash
-      [id, name, status, country, city].hash
+      [connection_id, hotel_id, active, sync_enabled, booking_url, markup, sync_category, suspended_at, suspension_reason, created_at, mapping_status, listings].hash
     end
 
     # Builds the object from hash

data/lib/repull/models/booking_property_listings_inner.rb

@@ -0,0 +1,244 @@
+=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
+  class BookingPropertyListingsInner < ApiModelBase
+    # Repull listing id — what `/v1/channels/booking/properties/{id}` and `/v1/channels/booking/listings/{id}/pricing` take.
+    attr_accessor :listing_id
+
+    attr_accessor :name
+
+    attr_accessor :city
+
+    # Repull-side room row id, as used by `POST /v1/connect/booking/map-rooms`.
+    attr_accessor :room_id
+
+    # Booking.com's own room id — the `roomId` an ARI write takes.
+    attr_accessor :room_booking_id
+
+    attr_accessor :room_name
+
+    # Which record carries the mapping: the room mapping written by Connect, or the legacy property-level link.
+    attr_accessor :mapped_via
+
+    class EnumAttributeValidator
+      attr_reader :datatype
+      attr_reader :allowable_values
+
+      def initialize(datatype, allowable_values)
+        @allowable_values = allowable_values.map do |value|
+          case datatype.to_s
+          when /Integer/i
+            value.to_i
+          when /Float/i
+            value.to_f
+          else
+            value
+          end
+        end
+      end
+
+      def valid?(value)
+        !value || allowable_values.include?(value)
+      end
+    end
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'listing_id' => :'listingId',
+        :'name' => :'name',
+        :'city' => :'city',
+        :'room_id' => :'roomId',
+        :'room_booking_id' => :'roomBookingId',
+        :'room_name' => :'roomName',
+        :'mapped_via' => :'mappedVia'
+      }
+    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
+      {
+        :'listing_id' => :'String',
+        :'name' => :'String',
+        :'city' => :'String',
+        :'room_id' => :'String',
+        :'room_booking_id' => :'String',
+        :'room_name' => :'String',
+        :'mapped_via' => :'String'
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+        :'name',
+        :'city',
+        :'room_id',
+        :'room_booking_id',
+        :'room_name',
+      ])
+    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::BookingPropertyListingsInner` 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::BookingPropertyListingsInner`. 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?(:'listing_id')
+        self.listing_id = attributes[:'listing_id']
+      end
+
+      if attributes.key?(:'name')
+        self.name = attributes[:'name']
+      end
+
+      if attributes.key?(:'city')
+        self.city = attributes[:'city']
+      end
+
+      if attributes.key?(:'room_id')
+        self.room_id = attributes[:'room_id']
+      end
+
+      if attributes.key?(:'room_booking_id')
+        self.room_booking_id = attributes[:'room_booking_id']
+      end
+
+      if attributes.key?(:'room_name')
+        self.room_name = attributes[:'room_name']
+      end
+
+      if attributes.key?(:'mapped_via')
+        self.mapped_via = attributes[:'mapped_via']
+      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
+      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'
+      mapped_via_validator = EnumAttributeValidator.new('String', ["room", "property"])
+      return false unless mapped_via_validator.valid?(@mapped_via)
+      true
+    end
+
+    # Custom attribute writer method checking allowed values (enum).
+    # @param [Object] mapped_via Object to be assigned
+    def mapped_via=(mapped_via)
+      validator = EnumAttributeValidator.new('String', ["room", "property"])
+      unless validator.valid?(mapped_via)
+        fail ArgumentError, "invalid value for \"mapped_via\", must be one of #{validator.allowable_values}."
+      end
+      @mapped_via = mapped_via
+    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 &&
+          listing_id == o.listing_id &&
+          name == o.name &&
+          city == o.city &&
+          room_id == o.room_id &&
+          room_booking_id == o.room_booking_id &&
+          room_name == o.room_name &&
+          mapped_via == o.mapped_via
+    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
+      [listing_id, name, city, room_id, room_booking_id, room_name, mapped_via].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