repull 0.2.8 → 0.2.9

data/lib/repull/models/{get_studio_deployment200_response.rb → booking_availability_update_request_updates_inner.rb}

@@ -14,134 +14,91 @@ require 'date'
 require 'time'
 
 module Repull
-  class GetStudioDeployment200Response < ApiModelBase
-    attr_accessor :data
-
-    # Attribute mapping from ruby-style variable name to JSON key.
-    def self.attribute_map
-      {
-        :'data' => :'data'
-      }
-    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
-      {
-        :'data' => :'StudioDeployment'
-      }
-    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::GetStudioDeployment200Response` initialize method"
+  module BookingAvailabilityUpdateRequestUpdatesInner
+    class << self
+      # List of class defined in oneOf (OpenAPI v3)
+      def openapi_one_of
+        [
+          :'BookingAvailabilityUpdate',
+          :'BookingPricingRateUpdate'
+        ]
       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::GetStudioDeployment200Response`. Please check the name to make sure it's valid. List of attributes: " + acceptable_attribute_map.keys.inspect
+      # Builds the object
+      # @param [Mixed] Data to be matched against the list of oneOf items
+      # @return [Object] Returns the model or the data itself
+      def build(data)
+        # Go through the list of oneOf items and attempt to identify the appropriate one.
+        # Note:
+        # - We do not attempt to check whether exactly one item matches.
+        # - No advanced validation of types in some cases (e.g. "x: { type: string }" will happily match { x: 123 })
+        #   due to the way the deserialization is made in the base_object template (it just casts without verifying).
+        # - TODO: scalar values are de facto behaving as if they were nullable.
+        # - TODO: logging when debugging is set.
+        openapi_one_of.each do |klass|
+          begin
+            next if klass == :AnyType # "nullable: true"
+            return find_and_cast_into_type(klass, data)
+          rescue # rescue all errors so we keep iterating even if the current item lookup raises
+          end
         end
-        h[k.to_sym] = v
-      }
 
-      if attributes.key?(:'data')
-        self.data = attributes[:'data']
+        openapi_one_of.include?(:AnyType) ? data : 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
-      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'
-      true
-    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 &&
-          data == o.data
-    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
-      [data].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) }
+      private
+
+      SchemaMismatchError = Class.new(StandardError)
+
+      # Note: 'File' is missing here because in the regular case we get the data _after_ a call to JSON.parse.
+      def find_and_cast_into_type(klass, data)
+        return if data.nil?
+
+        case klass.to_s
+        when 'Boolean'
+          return data if data.instance_of?(TrueClass) || data.instance_of?(FalseClass)
+        when 'Float'
+          return data if data.instance_of?(Float)
+        when 'Integer'
+          return data if data.instance_of?(Integer)
+        when 'Time'
+          return Time.parse(data)
+        when 'Date'
+          return Date.iso8601(data)
+        when 'String'
+          return data if data.instance_of?(String)
+        when 'Object' # "type: object"
+          return data if data.instance_of?(Hash)
+        when /\AArray<(?<sub_type>.+)>\z/ # "type: array"
+          if data.instance_of?(Array)
+            sub_type = Regexp.last_match[:sub_type]
+            return data.map { |item| find_and_cast_into_type(sub_type, item) }
+          end
+        when /\AHash<String, (?<sub_type>.+)>\z/ # "type: object" with "additionalProperties: { ... }"
+          if data.instance_of?(Hash) && data.keys.all? { |k| k.instance_of?(Symbol) || k.instance_of?(String) }
+            sub_type = Regexp.last_match[:sub_type]
+            return data.each_with_object({}) { |(k, v), hsh| hsh[k] = find_and_cast_into_type(sub_type, v) }
+          end
+        else # model
+          const = Repull.const_get(klass)
+          if const
+            if const.respond_to?(:openapi_one_of) # nested oneOf model
+              model = const.build(data)
+              return model if model
+            else
+              # raise if data contains keys that are not known to the model
+              raise if const.respond_to?(:acceptable_attributes) && !(data.keys - const.acceptable_attributes).empty?
+              model = const.build_from_hash(data)
+              return model if model
+            end
           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)
+        raise # if no match by now, raise
+      rescue
+        raise SchemaMismatchError, "#{data} doesn't match the #{klass} type"
       end
-      hash
     end
-
   end
 
 end

data/lib/repull/models/booking_pricing_rate_update.rb

@@ -32,6 +32,7 @@ module Repull
 
     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`).
     attr_accessor :rooms_to_sell
 
     attr_accessor :restrictions

data/lib/repull/models/booking_pricing_rate_update_restrictions.rb

@@ -14,23 +14,47 @@ require 'date'
 require 'time'
 
 module Repull
-  # Optional length-of-stay / availability restrictions for one rate update.
+  # 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.
   class BookingPricingRateUpdateRestrictions < ApiModelBase
+    # Minimum length of stay (`minimumstay`).
     attr_accessor :min_stay
 
+    # Maximum length of stay (`maximumstay`).
     attr_accessor :max_stay
 
+    # Closed-to-arrival — guests may not check in on the affected dates (`closedonarrival`).
     attr_accessor :closed_to_arrival
 
+    # Closed-to-departure — guests may not check out on the affected dates (`closedondeparture`).
     attr_accessor :closed_to_departure
 
+    # Arrival-based minimum length of stay (`minimumstay_arrival`).
+    attr_accessor :min_stay_arrival
+
+    # Arrival-based maximum length of stay (`maximumstay_arrival`).
+    attr_accessor :max_stay_arrival
+
+    # Arrival-based exact length of stay (`exactstay_arrival`).
+    attr_accessor :exact_stay_arrival
+
+    # Minimum advance-reservation window, format `XDY` (X days Y hours) — `min_advance_res`.
+    attr_accessor :min_advance_res
+
+    # Maximum advance-reservation window, format `XDY` (X days Y hours) — `max_advance_res`.
+    attr_accessor :max_advance_res
+
     # Attribute mapping from ruby-style variable name to JSON key.
     def self.attribute_map
       {
         :'min_stay' => :'minStay',
         :'max_stay' => :'maxStay',
         :'closed_to_arrival' => :'closedToArrival',
-        :'closed_to_departure' => :'closedToDeparture'
+        :'closed_to_departure' => :'closedToDeparture',
+        :'min_stay_arrival' => :'minStayArrival',
+        :'max_stay_arrival' => :'maxStayArrival',
+        :'exact_stay_arrival' => :'exactStayArrival',
+        :'min_advance_res' => :'minAdvanceRes',
+        :'max_advance_res' => :'maxAdvanceRes'
       }
     end
 
@@ -50,7 +74,12 @@ module Repull
         :'min_stay' => :'Integer',
         :'max_stay' => :'Integer',
         :'closed_to_arrival' => :'Boolean',
-        :'closed_to_departure' => :'Boolean'
+        :'closed_to_departure' => :'Boolean',
+        :'min_stay_arrival' => :'Integer',
+        :'max_stay_arrival' => :'Integer',
+        :'exact_stay_arrival' => :'Integer',
+        :'min_advance_res' => :'String',
+        :'max_advance_res' => :'String'
       }
     end
 
@@ -60,7 +89,12 @@ module Repull
         :'min_stay',
         :'max_stay',
         :'closed_to_arrival',
-        :'closed_to_departure'
+        :'closed_to_departure',
+        :'min_stay_arrival',
+        :'max_stay_arrival',
+        :'exact_stay_arrival',
+        :'min_advance_res',
+        :'max_advance_res'
       ])
     end
 
@@ -95,6 +129,26 @@ module Repull
       if attributes.key?(:'closed_to_departure')
         self.closed_to_departure = attributes[:'closed_to_departure']
       end
+
+      if attributes.key?(:'min_stay_arrival')
+        self.min_stay_arrival = attributes[:'min_stay_arrival']
+      end
+
+      if attributes.key?(:'max_stay_arrival')
+        self.max_stay_arrival = attributes[:'max_stay_arrival']
+      end
+
+      if attributes.key?(:'exact_stay_arrival')
+        self.exact_stay_arrival = attributes[:'exact_stay_arrival']
+      end
+
+      if attributes.key?(:'min_advance_res')
+        self.min_advance_res = attributes[:'min_advance_res']
+      end
+
+      if attributes.key?(:'max_advance_res')
+        self.max_advance_res = attributes[:'max_advance_res']
+      end
     end
 
     # Show invalid properties with the reasons. Usually used together with valid?
@@ -120,7 +174,12 @@ module Repull
           min_stay == o.min_stay &&
           max_stay == o.max_stay &&
           closed_to_arrival == o.closed_to_arrival &&
-          closed_to_departure == o.closed_to_departure
+          closed_to_departure == o.closed_to_departure &&
+          min_stay_arrival == o.min_stay_arrival &&
+          max_stay_arrival == o.max_stay_arrival &&
+          exact_stay_arrival == o.exact_stay_arrival &&
+          min_advance_res == o.min_advance_res &&
+          max_advance_res == o.max_advance_res
     end
 
     # @see the `==` method
@@ -132,7 +191,7 @@ module Repull
     # Calculates hash code according to all attributes.
     # @return [Integer] Hash code
     def hash
-      [min_stay, max_stay, closed_to_arrival, closed_to_departure].hash
+      [min_stay, max_stay, closed_to_arrival, closed_to_departure, min_stay_arrival, max_stay_arrival, exact_stay_arrival, min_advance_res, max_advance_res].hash
     end
 
     # Builds the object from hash

data/lib/repull/models/{get_studio_project200_response.rb → listing_content_update_request.rb}

@@ -14,13 +14,47 @@ require 'date'
 require 'time'
 
 module Repull
-  class GetStudioProject200Response < ApiModelBase
-    attr_accessor :data
+  # Canonical PMS-owned listing content. Every field is optional — this is a partial update, only the fields you send are written; absent fields are left untouched. This is a LOCAL write only: it does NOT push to Airbnb/Booking.com. Distribution is a separate explicit publish step. `photos` are ingested by URL and attached to the listing in order (full-replace by default, or append via `photosMode`).
+  class ListingContentUpdateRequest < ApiModelBase
+    # Guest-facing title. Written to the listing name and the `en` description.
+    attr_accessor :title
+
+    # Alias for `title`.
+    attr_accessor :name
+
+    # Long-form listing description.
+    attr_accessor :description
+
+    # Short summary / tagline.
+    attr_accessor :summary
+
+    attr_accessor :amenities
+
+    attr_accessor :address
+
+    attr_accessor :occupancy
+
+    attr_accessor :policies
+
+    # Photo set — full replacement by default (pass `photosMode: \"append\"` to add after existing photos, or `[]` to clear; omit to leave untouched). Each entry is a hosted image URL (string) or a structured ref. URL-ingest only: the URL is persisted and attached to the listing in order — the OTA push downloads it at publish time. Binary/multipart upload is a follow-up. A non-empty array with no valid http(s) URL is reported in `deferred` (existing photos left untouched).
+    attr_accessor :photos
+
+    # How `photos` is applied: `replace` (full replacement of the photo set) or `append` (add after the existing photos). Ignored when `photos` is absent.
+    attr_accessor :photos_mode
 
     # Attribute mapping from ruby-style variable name to JSON key.
     def self.attribute_map
       {
-        :'data' => :'data'
+        :'title' => :'title',
+        :'name' => :'name',
+        :'description' => :'description',
+        :'summary' => :'summary',
+        :'amenities' => :'amenities',
+        :'address' => :'address',
+        :'occupancy' => :'occupancy',
+        :'policies' => :'policies',
+        :'photos' => :'photos',
+        :'photos_mode' => :'photosMode'
       }
     end
 
@@ -37,13 +71,26 @@ module Repull
     # Attribute type mapping.
     def self.openapi_types
       {
-        :'data' => :'StudioProject'
+        :'title' => :'String',
+        :'name' => :'String',
+        :'description' => :'String',
+        :'summary' => :'String',
+        :'amenities' => :'ListingContentUpdateRequestAmenities',
+        :'address' => :'ListingContentUpdateRequestAddress',
+        :'occupancy' => :'ListingContentUpdateRequestOccupancy',
+        :'policies' => :'ListingContentUpdateRequestPolicies',
+        :'photos' => :'Array<ListingContentUpdateRequestPhotosInner>',
+        :'photos_mode' => :'String'
       }
     end
 
     # List of attributes with nullable: true
     def self.openapi_nullable
       Set.new([
+        :'title',
+        :'name',
+        :'description',
+        :'summary',
       ])
     end
 
@@ -51,20 +98,60 @@ module Repull
     # @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::GetStudioProject200Response` initialize method"
+        fail ArgumentError, "The input argument (attributes) must be a hash in `Repull::ListingContentUpdateRequest` 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::GetStudioProject200Response`. Please check the name to make sure it's valid. List of attributes: " + acceptable_attribute_map.keys.inspect
+          fail ArgumentError, "`#{k}` is not a valid attribute in `Repull::ListingContentUpdateRequest`. 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?(:'data')
-        self.data = attributes[:'data']
+      if attributes.key?(:'title')
+        self.title = attributes[:'title']
+      end
+
+      if attributes.key?(:'name')
+        self.name = attributes[:'name']
+      end
+
+      if attributes.key?(:'description')
+        self.description = attributes[:'description']
+      end
+
+      if attributes.key?(:'summary')
+        self.summary = attributes[:'summary']
+      end
+
+      if attributes.key?(:'amenities')
+        self.amenities = attributes[:'amenities']
+      end
+
+      if attributes.key?(:'address')
+        self.address = attributes[:'address']
+      end
+
+      if attributes.key?(:'occupancy')
+        self.occupancy = attributes[:'occupancy']
+      end
+
+      if attributes.key?(:'policies')
+        self.policies = attributes[:'policies']
+      end
+
+      if attributes.key?(:'photos')
+        if (value = attributes[:'photos']).is_a?(Array)
+          self.photos = value
+        end
+      end
+
+      if attributes.key?(:'photos_mode')
+        self.photos_mode = attributes[:'photos_mode']
+      else
+        self.photos_mode = 'replace'
       end
     end
 
@@ -88,7 +175,16 @@ module Repull
     def ==(o)
       return true if self.equal?(o)
       self.class == o.class &&
-          data == o.data
+          title == o.title &&
+          name == o.name &&
+          description == o.description &&
+          summary == o.summary &&
+          amenities == o.amenities &&
+          address == o.address &&
+          occupancy == o.occupancy &&
+          policies == o.policies &&
+          photos == o.photos &&
+          photos_mode == o.photos_mode
     end
 
     # @see the `==` method
@@ -100,7 +196,7 @@ module Repull
     # Calculates hash code according to all attributes.
     # @return [Integer] Hash code
     def hash
-      [data].hash
+      [title, name, description, summary, amenities, address, occupancy, policies, photos, photos_mode].hash
     end
 
     # Builds the object from hash

data/lib/repull/models/{upsert_studio_project_file200_response.rb → listing_content_update_request_address.rb}

@@ -14,13 +14,27 @@ require 'date'
 require 'time'
 
 module Repull
-  class UpsertStudioProjectFile200Response < ApiModelBase
-    attr_accessor :data
+  # Partial address. Only provided sub-fields are written.
+  class ListingContentUpdateRequestAddress < ApiModelBase
+    attr_accessor :street
+
+    attr_accessor :city
+
+    # ISO-3166 alpha-2 country code.
+    attr_accessor :country_code
+
+    attr_accessor :lat
+
+    attr_accessor :lng
 
     # Attribute mapping from ruby-style variable name to JSON key.
     def self.attribute_map
       {
-        :'data' => :'data'
+        :'street' => :'street',
+        :'city' => :'city',
+        :'country_code' => :'countryCode',
+        :'lat' => :'lat',
+        :'lng' => :'lng'
       }
     end
 
@@ -37,13 +51,22 @@ module Repull
     # Attribute type mapping.
     def self.openapi_types
       {
-        :'data' => :'UpsertStudioProjectFile200ResponseData'
+        :'street' => :'String',
+        :'city' => :'String',
+        :'country_code' => :'String',
+        :'lat' => :'Float',
+        :'lng' => :'Float'
       }
     end
 
     # List of attributes with nullable: true
     def self.openapi_nullable
       Set.new([
+        :'street',
+        :'city',
+        :'country_code',
+        :'lat',
+        :'lng'
       ])
     end
 
@@ -51,20 +74,36 @@ module Repull
     # @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::UpsertStudioProjectFile200Response` initialize method"
+        fail ArgumentError, "The input argument (attributes) must be a hash in `Repull::ListingContentUpdateRequestAddress` 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::UpsertStudioProjectFile200Response`. Please check the name to make sure it's valid. List of attributes: " + acceptable_attribute_map.keys.inspect
+          fail ArgumentError, "`#{k}` is not a valid attribute in `Repull::ListingContentUpdateRequestAddress`. 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?(:'data')
-        self.data = attributes[:'data']
+      if attributes.key?(:'street')
+        self.street = attributes[:'street']
+      end
+
+      if attributes.key?(:'city')
+        self.city = attributes[:'city']
+      end
+
+      if attributes.key?(:'country_code')
+        self.country_code = attributes[:'country_code']
+      end
+
+      if attributes.key?(:'lat')
+        self.lat = attributes[:'lat']
+      end
+
+      if attributes.key?(:'lng')
+        self.lng = attributes[:'lng']
       end
     end
 
@@ -88,7 +127,11 @@ module Repull
     def ==(o)
       return true if self.equal?(o)
       self.class == o.class &&
-          data == o.data
+          street == o.street &&
+          city == o.city &&
+          country_code == o.country_code &&
+          lat == o.lat &&
+          lng == o.lng
     end
 
     # @see the `==` method
@@ -100,7 +143,7 @@ module Repull
     # Calculates hash code according to all attributes.
     # @return [Integer] Hash code
     def hash
-      [data].hash
+      [street, city, country_code, lat, lng].hash
     end
 
     # Builds the object from hash