docspring 3.5.0 → 4.0.0

data/lib/docspring/models/template_page_processing_status.rb

@@ -0,0 +1,275 @@
+=begin
+#DocSpring API
+
+#Use DocSpring's API to programmatically fill out PDF forms, convert HTML to PDFs, merge PDFs, or request legally binding e-signatures.
+
+The version of the OpenAPI document: v2
+
+Generated by: https://openapi-generator.tech
+Generator version: 7.26.0-DOCSPRING
+
+=end
+
+require 'date'
+require 'time'
+
+module DocSpring
+  # How processing is going on one page of a PDF template's PDF.
+  class TemplatePageProcessingStatus < ApiModelBase
+    # The page's image, which the template editor shows. `pending` until it's rendered.
+    attr_accessor :image
+
+    # Setting up the page's fields: `pending` while they're imported or detected, `naming` while AI names them, then `processed` or `failed`. `disabled` when DocSpring doesn't set up the page's fields.
+    attr_accessor :fields
+
+    # `failed` or `skipped` when AI didn't name the page's fields as asked (`ai_error` says why), and the fields kept plain names. Null otherwise.
+    attr_accessor :ai_naming
+
+    # Why AI naming failed or was skipped: `unavailable` (the AI service was unavailable: set up the fields again later), `error`, `credits` (the account had no free AI pages or credits left) or `skipped` (someone skipped AI setup in the template editor). Null when `ai_naming` is.
+    attr_accessor :ai_error
+
+    # While AI names the page's fields, the boxes field detection found: `[x, y, width, height]` in PDF points from the page's top-left corner. Null otherwise.
+    attr_accessor :detected_boxes
+
+    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
+      {
+        :'image' => :'image',
+        :'fields' => :'fields',
+        :'ai_naming' => :'ai_naming',
+        :'ai_error' => :'ai_error',
+        :'detected_boxes' => :'detected_boxes'
+      }
+    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
+      {
+        :'image' => :'TemplatePageImageStatus',
+        :'fields' => :'TemplatePageFieldsStatus',
+        :'ai_naming' => :'TemplatePageAiNamingStatus',
+        :'ai_error' => :'TemplatePageAiError',
+        :'detected_boxes' => :'Array<Array<Float>>'
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+        :'ai_naming',
+        :'ai_error',
+        :'detected_boxes'
+      ])
+    end
+
+    # Returns attribute type mapping
+    def self.acceptable_openapi_types
+      openapi_types
+    end
+
+    # Returns the nullable attributes
+    def self.acceptable_openapi_nullable
+      openapi_nullable
+    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 `DocSpring::TemplatePageProcessingStatus` 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 `DocSpring::TemplatePageProcessingStatus`. 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?(:'image')
+        self.image = attributes[:'image']
+      else
+        self.image = nil
+      end
+
+      if attributes.key?(:'fields')
+        self.fields = attributes[:'fields']
+      else
+        self.fields = nil
+      end
+
+      if attributes.key?(:'ai_naming')
+        self.ai_naming = attributes[:'ai_naming']
+      else
+        self.ai_naming = nil
+      end
+
+      if attributes.key?(:'ai_error')
+        self.ai_error = attributes[:'ai_error']
+      else
+        self.ai_error = nil
+      end
+
+      if attributes.key?(:'detected_boxes')
+        if (value = attributes[:'detected_boxes']).is_a?(Array) || value.nil?
+          self.detected_boxes = value
+        end
+      else
+        self.detected_boxes = 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 @image.nil?
+        invalid_properties.push('invalid value for "image", image cannot be nil.')
+      end
+
+      if @fields.nil?
+        invalid_properties.push('invalid value for "fields", fields 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 @image.nil?
+      return false if @fields.nil?
+      true
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] image Value to be assigned
+    def image=(image)
+      if image.nil?
+        fail ArgumentError, 'image cannot be nil'
+      end
+
+      @image = image
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] fields Value to be assigned
+    def fields=(fields)
+      if fields.nil?
+        fail ArgumentError, 'fields cannot be nil'
+      end
+
+      @fields = fields
+    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 &&
+          image == o.image &&
+          fields == o.fields &&
+          ai_naming == o.ai_naming &&
+          ai_error == o.ai_error &&
+          detected_boxes == o.detected_boxes
+    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
+      [image, fields, ai_naming, ai_error, detected_boxes].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)
+      # include attributes inherited from allOf parents (the nearest declaration wins)
+      map = acceptable_attribute_map
+      transformed_hash = {}
+      acceptable_openapi_types.each_pair do |key, type|
+        if attributes.key?(map[key]) && attributes[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[map[key]].is_a?(Array)
+            transformed_hash["#{key}"] = attributes[map[key]].map { |v| _deserialize($1, v) }
+          end
+        elsif !attributes[map[key]].nil?
+          transformed_hash["#{key}"] = _deserialize(type, attributes[map[key]])
+        end
+      end
+      # Responses can include enum values added after this client was released, so the enum setters
+      # accept any value while the model is built from a response
+      allocate.tap do |model|
+        model.instance_variable_set(:@_skip_enum_validation, true)
+        model.send(:initialize, transformed_hash)
+        model.remove_instance_variable(:@_skip_enum_validation)
+      end
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      # include attributes inherited from allOf parents (the nearest declaration wins)
+      self.class.acceptable_attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        if value.nil?
+          is_nullable = self.class.acceptable_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/docspring/models/{create_webhook_data.rb → template_source_pdf.rb}

@@ -1,12 +1,12 @@
 =begin
 #DocSpring API
 
-#Use DocSpring's API to programmatically fill out PDF forms, convert HTML to PDFs, merge PDFs, or request legally binding e-signatures. Requests are rate limited per account, and live PDFs use credits: a request over the limit returns 429 with a Retry-After header, and one your credits can't cover returns 402. See [Credits & Rate Limits](https://docspring.com/docs/api-guide/credits-and-rate-limits/).
+#Use DocSpring's API to programmatically fill out PDF forms, convert HTML to PDFs, merge PDFs, or request legally binding e-signatures.
 
-The version of the OpenAPI document: v1
+The version of the OpenAPI document: v2
 
 Generated by: https://openapi-generator.tech
-Generator version: 7.16.0-DOCSPRING
+Generator version: 7.26.0-DOCSPRING
 
 =end
 
@@ -14,13 +14,27 @@ require 'date'
 require 'time'
 
 module DocSpring
-  class CreateWebhookData
-    attr_accessor :webhook
+  # A template's PDF to merge.
+  class TemplateSourcePdf < ApiModelBase
+    # Must be `template`.
+    attr_accessor :type
+
+    # The ID of the submission, combined PDF, template or custom file.
+    attr_accessor :id
+
+    # For a `template` source, the version to use: a published version (`1.2.0`, or `1` for the latest 1.x.x), `latest` or `draft`. Default `latest` (the draft when no version has been published).
+    attr_accessor :template_version
+
+    # For a `template` source: true (the default) merges the template's processed PDF, which is the PDF submissions are filled in on (decrypted, with its form fields removed). false merges the PDF as it was uploaded.
+    attr_accessor :processed
 
     # Attribute mapping from ruby-style variable name to JSON key.
     def self.attribute_map
       {
-        :'webhook' => :'webhook'
+        :'type' => :'type',
+        :'id' => :'id',
+        :'template_version' => :'template_version',
+        :'processed' => :'processed'
       }
     end
 
@@ -37,7 +51,10 @@ module DocSpring
     # Attribute type mapping.
     def self.openapi_types
       {
-        :'webhook' => :'Object'
+        :'type' => :'String',
+        :'id' => :'String',
+        :'template_version' => :'String',
+        :'processed' => :'Boolean'
       }
     end
 
@@ -47,26 +64,50 @@ module DocSpring
       ])
     end
 
+    # Returns attribute type mapping
+    def self.acceptable_openapi_types
+      openapi_types
+    end
+
+    # Returns the nullable attributes
+    def self.acceptable_openapi_nullable
+      openapi_nullable
+    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 `DocSpring::CreateWebhookData` initialize method"
+        fail ArgumentError, "The input argument (attributes) must be a hash in `DocSpring::TemplateSourcePdf` 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 `DocSpring::CreateWebhookData`. 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 `DocSpring::TemplateSourcePdf`. 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?(:'webhook')
-        self.webhook = attributes[:'webhook']
+      if attributes.key?(:'type')
+        self.type = attributes[:'type']
+      else
+        self.type = 'template'
+      end
+
+      if attributes.key?(:'id')
+        self.id = attributes[:'id']
       else
-        self.webhook = nil
+        self.id = nil
+      end
+
+      if attributes.key?(:'template_version')
+        self.template_version = attributes[:'template_version']
+      end
+
+      if attributes.key?(:'processed')
+        self.processed = attributes[:'processed']
       end
     end
 
@@ -75,8 +116,12 @@ module DocSpring
     def list_invalid_properties
       warn '[DEPRECATED] the `list_invalid_properties` method is obsolete'
       invalid_properties = Array.new
-      if @webhook.nil?
-        invalid_properties.push('invalid value for "webhook", webhook cannot be nil.')
+      if @type.nil?
+        invalid_properties.push('invalid value for "type", type cannot be nil.')
+      end
+
+      if @id.nil?
+        invalid_properties.push('invalid value for "id", id cannot be nil.')
       end
 
       invalid_properties
@@ -86,18 +131,29 @@ module DocSpring
     # @return true if the model is valid
     def valid?
       warn '[DEPRECATED] the `valid?` method is obsolete'
-      return false if @webhook.nil?
+      return false if @type.nil?
+      return false if @id.nil?
       true
     end
 
     # Custom attribute writer method with validation
-    # @param [Object] webhook Value to be assigned
-    def webhook=(webhook)
-      if webhook.nil?
-        fail ArgumentError, 'webhook cannot be nil'
+    # @param [Object] type Value to be assigned
+    def type=(type)
+      if type.nil?
+        fail ArgumentError, 'type cannot be nil'
       end
 
-      @webhook = webhook
+      @type = type
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] id Value to be assigned
+    def id=(id)
+      if id.nil?
+        fail ArgumentError, 'id cannot be nil'
+      end
+
+      @id = id
     end
 
     # Checks equality by comparing each attribute.
@@ -105,7 +161,10 @@ module DocSpring
     def ==(o)
       return true if self.equal?(o)
       self.class == o.class &&
-          webhook == o.webhook
+          type == o.type &&
+          id == o.id &&
+          template_version == o.template_version &&
+          processed == o.processed
     end
 
     # @see the `==` method
@@ -117,7 +176,7 @@ module DocSpring
     # Calculates hash code according to all attributes.
     # @return [Integer] Hash code
     def hash
-      [webhook].hash
+      [type, id, template_version, processed].hash
     end
 
     # Builds the object from hash
@@ -126,18 +185,20 @@ module DocSpring
     def self.build_from_hash(attributes)
       return nil unless attributes.is_a?(Hash)
       attributes = attributes.transform_keys(&:to_sym)
+      # include attributes inherited from allOf parents (the nearest declaration wins)
+      map = acceptable_attribute_map
       transformed_hash = {}
-      openapi_types.each_pair do |key, type|
-        if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
+      acceptable_openapi_types.each_pair do |key, type|
+        if attributes.key?(map[key]) && attributes[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) }
+          if attributes[map[key]].is_a?(Array)
+            transformed_hash["#{key}"] = attributes[map[key]].map { |v| _deserialize($1, v) }
           end
-        elsif !attributes[attribute_map[key]].nil?
-          transformed_hash["#{key}"] = _deserialize(type, attributes[attribute_map[key]])
+        elsif !attributes[map[key]].nil?
+          transformed_hash["#{key}"] = _deserialize(type, attributes[map[key]])
         end
       end
       # Responses can include enum values added after this client was released, so the enum setters
@@ -149,69 +210,15 @@ module DocSpring
       end
     end
 
-    # Deserializes the data based on type
-    # @param string type Data type
-    # @param string value Value to be deserialized
-    # @return [Object] Deserialized data
-    def self._deserialize(type, value)
-      case type.to_sym
-      when :Time
-        Time.parse(value)
-      when :Date
-        Date.parse(value)
-      when :String
-        value.to_s
-      when :Integer
-        value.to_i
-      when :Float
-        value.to_f
-      when :Boolean
-        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
-          true
-        else
-          false
-        end
-      when :Object
-        # generic object (usually a Hash), return directly
-        value
-      when /\AArray<(?<inner_type>.+)>\z/
-        inner_type = Regexp.last_match[:inner_type]
-        value.map { |v| _deserialize(inner_type, v) }
-      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
-        k_type = Regexp.last_match[:k_type]
-        v_type = Regexp.last_match[:v_type]
-        {}.tap do |hash|
-          value.each do |k, v|
-            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
-          end
-        end
-      else # model
-        # models (e.g. Pet) or oneOf
-        klass = DocSpring.const_get(type)
-        klass.respond_to?(:openapi_any_of) || klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
-      end
-    end
-
-    # Returns the string representation of the object
-    # @return [String] String presentation of the object
-    def to_s
-      to_hash.to_s
-    end
-
-    # to_body is an alias to to_hash (backward compatibility)
-    # @return [Hash] Returns the object in the form of hash
-    def to_body
-      to_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|
+      # include attributes inherited from allOf parents (the nearest declaration wins)
+      self.class.acceptable_attribute_map.each_pair do |attr, param|
         value = self.send(attr)
         if value.nil?
-          is_nullable = self.class.openapi_nullable.include?(attr)
+          is_nullable = self.class.acceptable_openapi_nullable.include?(attr)
           next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
         end
 
@@ -220,24 +227,6 @@ module DocSpring
       hash
     end
 
-    # Outputs non-array value in the form of hash
-    # For object, use to_hash. Otherwise, just return the value
-    # @param [Object] value Any valid value
-    # @return [Hash] Returns the value in the form of hash
-    def _to_hash(value)
-      if value.is_a?(Array)
-        value.compact.map { |v| _to_hash(v) }
-      elsif value.is_a?(Hash)
-        {}.tap do |hash|
-          value.each { |k, v| hash[k] = _to_hash(v) }
-        end
-      elsif value.respond_to? :to_hash
-        value.to_hash
-      else
-        value
-      end
-    end
-
   end
 
 end