repull 0.2.8 → 0.2.9

data/lib/repull/models/{create_studio_project_request.rb → airbnb_availability_write_request.rb}

@@ -14,22 +14,22 @@ require 'date'
 require 'time'
 
 module Repull
-  class CreateStudioProjectRequest < ApiModelBase
-    # Human-readable project name. Used to derive the slug.
-    attr_accessor :name
+  # Body for `PUT /v1/channels/airbnb/listings/{id}/availability`. `type: \"calendar\"` carries per-date restrictions (min/max nights, closed-to-arrival/departure, stop-sell); `type: \"rules\"` carries listing-level availability rules (default min/max nights, booking lead time, turnover days).
+  class AirbnbAvailabilityWriteRequest < ApiModelBase
+    attr_accessor :type
 
-    # Initial prompt that seeds the project. Repull AI scaffolds the first generation from this.
-    attr_accessor :prompt
+    # Required when `type: \"calendar\"`. Batch of per-date restriction operations.
+    attr_accessor :operations
 
-    # Optional template to start from (e.g. `next-saas`). Omit to generate from prompt only.
-    attr_accessor :template_id
+    # Required when `type: \"rules\"`. Airbnb availability-rules object — `default_min_nights`, `default_max_nights`, `booking_lead_time`, `turnover_days`, `day_of_week_min_nights`, `seasonal_min_nights`, etc.
+    attr_accessor :rules
 
     # Attribute mapping from ruby-style variable name to JSON key.
     def self.attribute_map
       {
-        :'name' => :'name',
-        :'prompt' => :'prompt',
-        :'template_id' => :'template_id'
+        :'type' => :'type',
+        :'operations' => :'operations',
+        :'rules' => :'rules'
       }
     end
 
@@ -46,16 +46,15 @@ module Repull
     # Attribute type mapping.
     def self.openapi_types
       {
-        :'name' => :'String',
-        :'prompt' => :'String',
-        :'template_id' => :'String'
+        :'type' => :'String',
+        :'operations' => :'Array<AirbnbCalendarOperation>',
+        :'rules' => :'Hash<String, Object>'
       }
     end
 
     # List of attributes with nullable: true
     def self.openapi_nullable
       Set.new([
-        :'template_id'
       ])
     end
 
@@ -63,32 +62,34 @@ 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::CreateStudioProjectRequest` initialize method"
+        fail ArgumentError, "The input argument (attributes) must be a hash in `Repull::AirbnbAvailabilityWriteRequest` 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::CreateStudioProjectRequest`. 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::AirbnbAvailabilityWriteRequest`. 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?(:'name')
-        self.name = attributes[:'name']
+      if attributes.key?(:'type')
+        self.type = attributes[:'type']
       else
-        self.name = nil
+        self.type = nil
       end
 
-      if attributes.key?(:'prompt')
-        self.prompt = attributes[:'prompt']
-      else
-        self.prompt = nil
+      if attributes.key?(:'operations')
+        if (value = attributes[:'operations']).is_a?(Array)
+          self.operations = value
+        end
       end
 
-      if attributes.key?(:'template_id')
-        self.template_id = attributes[:'template_id']
+      if attributes.key?(:'rules')
+        if (value = attributes[:'rules']).is_a?(Hash)
+          self.rules = value
+        end
       end
     end
 
@@ -97,12 +98,8 @@ module Repull
     def list_invalid_properties
       warn '[DEPRECATED] the `list_invalid_properties` method is obsolete'
       invalid_properties = Array.new
-      if @name.nil?
-        invalid_properties.push('invalid value for "name", name cannot be nil.')
-      end
-
-      if @prompt.nil?
-        invalid_properties.push('invalid value for "prompt", prompt cannot be nil.')
+      if @type.nil?
+        invalid_properties.push('invalid value for "type", type cannot be nil.')
       end
 
       invalid_properties
@@ -112,29 +109,18 @@ module Repull
     # @return true if the model is valid
     def valid?
       warn '[DEPRECATED] the `valid?` method is obsolete'
-      return false if @name.nil?
-      return false if @prompt.nil?
+      return false if @type.nil?
       true
     end
 
     # Custom attribute writer method with validation
-    # @param [Object] name Value to be assigned
-    def name=(name)
-      if name.nil?
-        fail ArgumentError, 'name cannot be nil'
-      end
-
-      @name = name
-    end
-
-    # Custom attribute writer method with validation
-    # @param [Object] prompt Value to be assigned
-    def prompt=(prompt)
-      if prompt.nil?
-        fail ArgumentError, 'prompt cannot be nil'
+    # @param [Object] type Value to be assigned
+    def type=(type)
+      if type.nil?
+        fail ArgumentError, 'type cannot be nil'
       end
 
-      @prompt = prompt
+      @type = type
     end
 
     # Checks equality by comparing each attribute.
@@ -142,9 +128,9 @@ module Repull
     def ==(o)
       return true if self.equal?(o)
       self.class == o.class &&
-          name == o.name &&
-          prompt == o.prompt &&
-          template_id == o.template_id
+          type == o.type &&
+          operations == o.operations &&
+          rules == o.rules
     end
 
     # @see the `==` method
@@ -156,7 +142,7 @@ module Repull
     # Calculates hash code according to all attributes.
     # @return [Integer] Hash code
     def hash
-      [name, prompt, template_id].hash
+      [type, operations, rules].hash
     end
 
     # Builds the object from hash

data/lib/repull/models/{create_studio_deployment201_response_data.rb → airbnb_calendar_operation.rb}

@@ -14,41 +14,50 @@ require 'date'
 require 'time'
 
 module Repull
-  class CreateStudioDeployment201ResponseData < ApiModelBase
-    attr_accessor :deployment_id
-
-    attr_accessor :subdomain
-
-    attr_accessor :status
-
-    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
+  # One calendar operation. Supply either `start_date` + `end_date` OR a `dates` array. Every restriction here is forwarded verbatim to Airbnb's batch calendar API.
+  class AirbnbCalendarOperation < ApiModelBase
+    # Inclusive range start (pair with `end_date`).
+    attr_accessor :start_date
 
-      def valid?(value)
-        !value || allowable_values.include?(value)
-      end
-    end
+    # Inclusive range end (pair with `start_date`).
+    attr_accessor :end_date
+
+    # Explicit date or `start:end` range strings, as an alternative to `start_date`/`end_date`.
+    attr_accessor :dates
+
+    # Nightly price override.
+    attr_accessor :daily_price
+
+    # Stop-sell is expressed here: `unavailable` blocks the date(s); `available` re-opens; `default` reverts to rule-based availability.
+    attr_accessor :availability
+
+    # Minimum length of stay for the date(s).
+    attr_accessor :min_nights
+
+    # Maximum length of stay for the date(s).
+    attr_accessor :max_nights
+
+    # Closed-to-arrival — no check-ins on the affected date(s).
+    attr_accessor :closed_to_arrival
+
+    # Closed-to-departure — no check-outs on the affected date(s).
+    attr_accessor :closed_to_departure
+
+    attr_accessor :notes
 
     # Attribute mapping from ruby-style variable name to JSON key.
     def self.attribute_map
       {
-        :'deployment_id' => :'deployment_id',
-        :'subdomain' => :'subdomain',
-        :'status' => :'status'
+        :'start_date' => :'start_date',
+        :'end_date' => :'end_date',
+        :'dates' => :'dates',
+        :'daily_price' => :'daily_price',
+        :'availability' => :'availability',
+        :'min_nights' => :'min_nights',
+        :'max_nights' => :'max_nights',
+        :'closed_to_arrival' => :'closed_to_arrival',
+        :'closed_to_departure' => :'closed_to_departure',
+        :'notes' => :'notes'
       }
     end
 
@@ -65,15 +74,32 @@ module Repull
     # Attribute type mapping.
     def self.openapi_types
       {
-        :'deployment_id' => :'String',
-        :'subdomain' => :'String',
-        :'status' => :'String'
+        :'start_date' => :'Date',
+        :'end_date' => :'Date',
+        :'dates' => :'Array<String>',
+        :'daily_price' => :'Float',
+        :'availability' => :'String',
+        :'min_nights' => :'Integer',
+        :'max_nights' => :'Integer',
+        :'closed_to_arrival' => :'Boolean',
+        :'closed_to_departure' => :'Boolean',
+        :'notes' => :'String'
       }
     end
 
     # List of attributes with nullable: true
     def self.openapi_nullable
       Set.new([
+        :'start_date',
+        :'end_date',
+        :'dates',
+        :'daily_price',
+        :'availability',
+        :'min_nights',
+        :'max_nights',
+        :'closed_to_arrival',
+        :'closed_to_departure',
+        :'notes'
       ])
     end
 
@@ -81,28 +107,58 @@ 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::CreateStudioDeployment201ResponseData` initialize method"
+        fail ArgumentError, "The input argument (attributes) must be a hash in `Repull::AirbnbCalendarOperation` 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::CreateStudioDeployment201ResponseData`. 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::AirbnbCalendarOperation`. 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?(:'deployment_id')
-        self.deployment_id = attributes[:'deployment_id']
+      if attributes.key?(:'start_date')
+        self.start_date = attributes[:'start_date']
+      end
+
+      if attributes.key?(:'end_date')
+        self.end_date = attributes[:'end_date']
       end
 
-      if attributes.key?(:'subdomain')
-        self.subdomain = attributes[:'subdomain']
+      if attributes.key?(:'dates')
+        if (value = attributes[:'dates']).is_a?(Array)
+          self.dates = value
+        end
       end
 
-      if attributes.key?(:'status')
-        self.status = attributes[:'status']
+      if attributes.key?(:'daily_price')
+        self.daily_price = attributes[:'daily_price']
+      end
+
+      if attributes.key?(:'availability')
+        self.availability = attributes[:'availability']
+      end
+
+      if attributes.key?(:'min_nights')
+        self.min_nights = attributes[:'min_nights']
+      end
+
+      if attributes.key?(:'max_nights')
+        self.max_nights = attributes[:'max_nights']
+      end
+
+      if attributes.key?(:'closed_to_arrival')
+        self.closed_to_arrival = attributes[:'closed_to_arrival']
+      end
+
+      if attributes.key?(:'closed_to_departure')
+        self.closed_to_departure = attributes[:'closed_to_departure']
+      end
+
+      if attributes.key?(:'notes')
+        self.notes = attributes[:'notes']
       end
     end
 
@@ -118,29 +174,24 @@ module Repull
     # @return true if the model is valid
     def valid?
       warn '[DEPRECATED] the `valid?` method is obsolete'
-      status_validator = EnumAttributeValidator.new('String', ["provisioning"])
-      return false unless status_validator.valid?(@status)
       true
     end
 
-    # Custom attribute writer method checking allowed values (enum).
-    # @param [Object] status Object to be assigned
-    def status=(status)
-      validator = EnumAttributeValidator.new('String', ["provisioning"])
-      unless validator.valid?(status)
-        fail ArgumentError, "invalid value for \"status\", must be one of #{validator.allowable_values}."
-      end
-      @status = status
-    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 &&
-          deployment_id == o.deployment_id &&
-          subdomain == o.subdomain &&
-          status == o.status
+          start_date == o.start_date &&
+          end_date == o.end_date &&
+          dates == o.dates &&
+          daily_price == o.daily_price &&
+          availability == o.availability &&
+          min_nights == o.min_nights &&
+          max_nights == o.max_nights &&
+          closed_to_arrival == o.closed_to_arrival &&
+          closed_to_departure == o.closed_to_departure &&
+          notes == o.notes
     end
 
     # @see the `==` method
@@ -152,7 +203,7 @@ module Repull
     # Calculates hash code according to all attributes.
     # @return [Integer] Hash code
     def hash
-      [deployment_id, subdomain, status].hash
+      [start_date, end_date, dates, daily_price, availability, min_nights, max_nights, closed_to_arrival, closed_to_departure, notes].hash
     end
 
     # Builds the object from hash

data/lib/repull/models/{update_studio_project_request.rb → airbnb_listing_action_request.rb}

@@ -14,38 +14,27 @@ require 'date'
 require 'time'
 
 module Repull
-  class UpdateStudioProjectRequest < ApiModelBase
-    attr_accessor :name
-
-    attr_accessor :status
-
-    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
+  # Body for `POST /v1/channels/airbnb/listings/{id}`.
+  class AirbnbListingActionRequest < ApiModelBase
+    # `delete` deactivates the Repull record. `push`/`publish` push content to Airbnb.
+    attr_accessor :action
 
-      def valid?(value)
-        !value || allowable_values.include?(value)
-      end
-    end
+    # For `push`/`publish`: the Airbnb connection to update (from `GET /v1/channels/airbnb/listings/{id}`). Pass this OR `hostId`.
+    attr_accessor :airbnb_connection_id
+
+    # For `push`/`publish`: create + publish a new Airbnb listing under this host. Pass this OR `airbnbConnectionId`.
+    attr_accessor :host_id
+
+    # For `push`/`publish`: re-push every field, ignoring dirty-field tracking.
+    attr_accessor :force
 
     # Attribute mapping from ruby-style variable name to JSON key.
     def self.attribute_map
       {
-        :'name' => :'name',
-        :'status' => :'status'
+        :'action' => :'action',
+        :'airbnb_connection_id' => :'airbnbConnectionId',
+        :'host_id' => :'hostId',
+        :'force' => :'force'
       }
     end
 
@@ -62,8 +51,10 @@ module Repull
     # Attribute type mapping.
     def self.openapi_types
       {
-        :'name' => :'String',
-        :'status' => :'String'
+        :'action' => :'String',
+        :'airbnb_connection_id' => :'String',
+        :'host_id' => :'String',
+        :'force' => :'Boolean'
       }
     end
 
@@ -77,24 +68,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::UpdateStudioProjectRequest` initialize method"
+        fail ArgumentError, "The input argument (attributes) must be a hash in `Repull::AirbnbListingActionRequest` 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::UpdateStudioProjectRequest`. 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::AirbnbListingActionRequest`. 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?(:'name')
-        self.name = attributes[:'name']
+      if attributes.key?(:'action')
+        self.action = attributes[:'action']
+      else
+        self.action = nil
       end
 
-      if attributes.key?(:'status')
-        self.status = attributes[:'status']
+      if attributes.key?(:'airbnb_connection_id')
+        self.airbnb_connection_id = attributes[:'airbnb_connection_id']
+      end
+
+      if attributes.key?(:'host_id')
+        self.host_id = attributes[:'host_id']
+      end
+
+      if attributes.key?(:'force')
+        self.force = attributes[:'force']
+      else
+        self.force = false
       end
     end
 
@@ -103,6 +106,10 @@ module Repull
     def list_invalid_properties
       warn '[DEPRECATED] the `list_invalid_properties` method is obsolete'
       invalid_properties = Array.new
+      if @action.nil?
+        invalid_properties.push('invalid value for "action", action cannot be nil.')
+      end
+
       invalid_properties
     end
 
@@ -110,19 +117,18 @@ module Repull
     # @return true if the model is valid
     def valid?
       warn '[DEPRECATED] the `valid?` method is obsolete'
-      status_validator = EnumAttributeValidator.new('String', ["draft", "building", "live", "archived"])
-      return false unless status_validator.valid?(@status)
+      return false if @action.nil?
       true
     end
 
-    # Custom attribute writer method checking allowed values (enum).
-    # @param [Object] status Object to be assigned
-    def status=(status)
-      validator = EnumAttributeValidator.new('String', ["draft", "building", "live", "archived"])
-      unless validator.valid?(status)
-        fail ArgumentError, "invalid value for \"status\", must be one of #{validator.allowable_values}."
+    # Custom attribute writer method with validation
+    # @param [Object] action Value to be assigned
+    def action=(action)
+      if action.nil?
+        fail ArgumentError, 'action cannot be nil'
       end
-      @status = status
+
+      @action = action
     end
 
     # Checks equality by comparing each attribute.
@@ -130,8 +136,10 @@ module Repull
     def ==(o)
       return true if self.equal?(o)
       self.class == o.class &&
-          name == o.name &&
-          status == o.status
+          action == o.action &&
+          airbnb_connection_id == o.airbnb_connection_id &&
+          host_id == o.host_id &&
+          force == o.force
     end
 
     # @see the `==` method
@@ -143,7 +151,7 @@ module Repull
     # Calculates hash code according to all attributes.
     # @return [Integer] Hash code
     def hash
-      [name, status].hash
+      [action, airbnb_connection_id, host_id, force].hash
     end
 
     # Builds the object from hash