aspose_words_cloud 1.0.0

data/lib/aspose_words_cloud/models/document.rb

@@ -0,0 +1,87 @@
+module AsposeWordsCloud
+  # 
+  class Document < BaseObject
+    attr_accessor :links, :file_name, :source_format, :is_encrypted, :is_signed, :document_properties
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # 
+        :'links' => :'Links',
+        
+        # 
+        :'file_name' => :'FileName',
+        
+        # 
+        :'source_format' => :'SourceFormat',
+        
+        # 
+        :'is_encrypted' => :'IsEncrypted',
+        
+        # 
+        :'is_signed' => :'IsSigned',
+        
+        # 
+        :'document_properties' => :'DocumentProperties'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'links' => :'Array<Link>',
+        :'file_name' => :'String',
+        :'source_format' => :'String',
+        :'is_encrypted' => :'BOOLEAN',
+        :'is_signed' => :'BOOLEAN',
+        :'document_properties' => :'DocumentProperties'
+        
+      }
+    end
+
+    def initialize(attributes = {})
+      return if !attributes.is_a?(Hash) || attributes.empty?
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+      
+      if attributes[:'Links']
+        if (value = attributes[:'Links']).is_a?(Array)
+          self.links = value
+        end
+      end
+      
+      if attributes[:'FileName']
+        self.file_name = attributes[:'FileName']
+      end
+      
+      if attributes[:'SourceFormat']
+        self.source_format = attributes[:'SourceFormat']
+      end
+      
+      if attributes[:'IsEncrypted']
+        self.is_encrypted = attributes[:'IsEncrypted']
+      end
+      
+      if attributes[:'IsSigned']
+        self.is_signed = attributes[:'IsSigned']
+      end
+      
+      if attributes[:'DocumentProperties']
+        self.document_properties = attributes[:'DocumentProperties']
+      end
+      
+    end
+
+    def source_format=(source_format)
+      allowed_values = ["Unknown", "Doc", "Dot", "DocPreWord97", "Docx", "Docm", "Dotx", "Dotm", "FlatOpc", "Rtf", "WordML", "Html", "Mhtml", "Epub", "Text", "Odt", "Ott", "Pdf", "Xps", "Swf", "Tiff", "Svg"]
+      if source_format && source_format.to_i >= allowed_values.size
+        fail "invalid value for 'source_format', must be one of #{allowed_values}"
+      end
+      @source_format = allowed_values[source_format.to_i]
+    end
+
+  end
+end

data/lib/aspose_words_cloud/models/document_entry.rb

@@ -0,0 +1,45 @@
+module AsposeWordsCloud
+  # 
+  class DocumentEntry < BaseObject
+    attr_accessor :href, :import_format_mode
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # 
+        :'href' => :'Href',
+        
+        # 
+        :'import_format_mode' => :'ImportFormatMode'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'href' => :'String',
+        :'import_format_mode' => :'String'
+        
+      }
+    end
+
+    def initialize(attributes = {})
+      return if !attributes.is_a?(Hash) || attributes.empty?
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+      
+      if attributes[:'Href']
+        self.href = attributes[:'Href']
+      end
+      
+      if attributes[:'ImportFormatMode']
+        self.import_format_mode = attributes[:'ImportFormatMode']
+      end
+      
+    end
+
+  end
+end

data/lib/aspose_words_cloud/models/document_entry_list.rb

@@ -0,0 +1,39 @@
+module AsposeWordsCloud
+  # 
+  class DocumentEntryList < BaseObject
+    attr_accessor :document_entries
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # 
+        :'document_entries' => :'DocumentEntries'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'document_entries' => :'Array<DocumentEntry>'
+        
+      }
+    end
+
+    def initialize(attributes = {})
+      return if !attributes.is_a?(Hash) || attributes.empty?
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+      
+      if attributes[:'DocumentEntries']
+        if (value = attributes[:'DocumentEntries']).is_a?(Array)
+          self.document_entries = value
+        end
+      end
+      
+    end
+
+  end
+end

data/lib/aspose_words_cloud/models/document_position.rb

@@ -0,0 +1,45 @@
+module AsposeWordsCloud
+  # 
+  class DocumentPosition < BaseObject
+    attr_accessor :node, :offset
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # 
+        :'node' => :'Node',
+        
+        # 
+        :'offset' => :'Offset'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'node' => :'NodeLink',
+        :'offset' => :'Integer'
+        
+      }
+    end
+
+    def initialize(attributes = {})
+      return if !attributes.is_a?(Hash) || attributes.empty?
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+      
+      if attributes[:'Node']
+        self.node = attributes[:'Node']
+      end
+      
+      if attributes[:'Offset']
+        self.offset = attributes[:'Offset']
+      end
+      
+    end
+
+  end
+end

data/lib/aspose_words_cloud/models/document_properties.rb

@@ -0,0 +1,47 @@
+module AsposeWordsCloud
+  # 
+  class DocumentProperties < BaseObject
+    attr_accessor :list, :link
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # 
+        :'list' => :'List',
+        
+        # 
+        :'link' => :'link'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'list' => :'Array<DocumentProperty>',
+        :'link' => :'Link'
+        
+      }
+    end
+
+    def initialize(attributes = {})
+      return if !attributes.is_a?(Hash) || attributes.empty?
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+      
+      if attributes[:'List']
+        if (value = attributes[:'List']).is_a?(Array)
+          self.list = value
+        end
+      end
+      
+      if attributes[:'link']
+        self.link = attributes[:'link']
+      end
+      
+    end
+
+  end
+end

data/lib/aspose_words_cloud/models/document_properties_response.rb

@@ -0,0 +1,61 @@
+module AsposeWordsCloud
+  # 
+  class DocumentPropertiesResponse < BaseObject
+    attr_accessor :document_properties, :status, :code
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # 
+        :'document_properties' => :'DocumentProperties',
+        
+        # 
+        :'status' => :'Status',
+        
+        # 
+        :'code' => :'Code'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'document_properties' => :'DocumentProperties',
+        :'status' => :'String',
+        :'code' => :'String'
+        
+      }
+    end
+
+    def initialize(attributes = {})
+      return if !attributes.is_a?(Hash) || attributes.empty?
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+      
+      if attributes[:'DocumentProperties']
+        self.document_properties = attributes[:'DocumentProperties']
+      end
+      
+      if attributes[:'Status']
+        self.status = attributes[:'Status']
+      end
+      
+      if attributes[:'Code']
+        self.code = attributes[:'Code']
+      end
+      
+    end
+
+    def status=(status)
+      allowed_values = ["Continue", "SwitchingProtocols", "OK", "Created", "Accepted", "NonAuthoritativeInformation", "NoContent", "ResetContent", "PartialContent", "MultipleChoices", "Ambiguous", "MovedPermanently", "Moved", "Found", "Redirect", "SeeOther", "RedirectMethod", "NotModified", "UseProxy", "Unused", "TemporaryRedirect", "RedirectKeepVerb", "BadRequest", "Unauthorized", "PaymentRequired", "Forbidden", "NotFound", "MethodNotAllowed", "NotAcceptable", "ProxyAuthenticationRequired", "RequestTimeout", "Conflict", "Gone", "LengthRequired", "PreconditionFailed", "RequestEntityTooLarge", "RequestUriTooLong", "UnsupportedMediaType", "RequestedRangeNotSatisfiable", "ExpectationFailed", "UpgradeRequired", "InternalServerError", "NotImplemented", "BadGateway", "ServiceUnavailable", "GatewayTimeout", "HttpVersionNotSupported"]
+      if status && !allowed_values.include?(status)
+        fail "invalid value for 'status', must be one of #{allowed_values}"
+      end
+      @status = status
+    end
+
+  end
+end

data/lib/aspose_words_cloud/models/document_property.rb

@@ -0,0 +1,61 @@
+module AsposeWordsCloud
+  # 
+  class DocumentProperty < BaseObject
+    attr_accessor :name, :value, :built_in, :link
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # 
+        :'name' => :'Name',
+        
+        # 
+        :'value' => :'Value',
+        
+        # 
+        :'built_in' => :'BuiltIn',
+        
+        # 
+        :'link' => :'link'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'name' => :'String',
+        :'value' => :'String',
+        :'built_in' => :'BOOLEAN',
+        :'link' => :'Link'
+        
+      }
+    end
+
+    def initialize(attributes = {})
+      return if !attributes.is_a?(Hash) || attributes.empty?
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+      
+      if attributes[:'Name']
+        self.name = attributes[:'Name']
+      end
+      
+      if attributes[:'Value']
+        self.value = attributes[:'Value']
+      end
+      
+      if attributes[:'BuiltIn']
+        self.built_in = attributes[:'BuiltIn']
+      end
+      
+      if attributes[:'link']
+        self.link = attributes[:'link']
+      end
+      
+    end
+
+  end
+end

data/lib/aspose_words_cloud/models/document_property_response.rb

@@ -0,0 +1,61 @@
+module AsposeWordsCloud
+  # 
+  class DocumentPropertyResponse < BaseObject
+    attr_accessor :document_property, :status, :code
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # 
+        :'document_property' => :'DocumentProperty',
+        
+        # 
+        :'status' => :'Status',
+        
+        # 
+        :'code' => :'Code'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'document_property' => :'DocumentProperty',
+        :'status' => :'String',
+        :'code' => :'String'
+        
+      }
+    end
+
+    def initialize(attributes = {})
+      return if !attributes.is_a?(Hash) || attributes.empty?
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+      
+      if attributes[:'DocumentProperty']
+        self.document_property = attributes[:'DocumentProperty']
+      end
+      
+      if attributes[:'Status']
+        self.status = attributes[:'Status']
+      end
+      
+      if attributes[:'Code']
+        self.code = attributes[:'Code']
+      end
+      
+    end
+
+    def status=(status)
+      allowed_values = ["Continue", "SwitchingProtocols", "OK", "Created", "Accepted", "NonAuthoritativeInformation", "NoContent", "ResetContent", "PartialContent", "MultipleChoices", "Ambiguous", "MovedPermanently", "Moved", "Found", "Redirect", "SeeOther", "RedirectMethod", "NotModified", "UseProxy", "Unused", "TemporaryRedirect", "RedirectKeepVerb", "BadRequest", "Unauthorized", "PaymentRequired", "Forbidden", "NotFound", "MethodNotAllowed", "NotAcceptable", "ProxyAuthenticationRequired", "RequestTimeout", "Conflict", "Gone", "LengthRequired", "PreconditionFailed", "RequestEntityTooLarge", "RequestUriTooLong", "UnsupportedMediaType", "RequestedRangeNotSatisfiable", "ExpectationFailed", "UpgradeRequired", "InternalServerError", "NotImplemented", "BadGateway", "ServiceUnavailable", "GatewayTimeout", "HttpVersionNotSupported"]
+      if status && !allowed_values.include?(status)
+        fail "invalid value for 'status', must be one of #{allowed_values}"
+      end
+      @status = status
+    end
+
+  end
+end

data/lib/aspose_words_cloud/models/document_response.rb

@@ -0,0 +1,61 @@
+module AsposeWordsCloud
+  # 
+  class DocumentResponse < BaseObject
+    attr_accessor :document, :status, :code
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # 
+        :'document' => :'Document',
+        
+        # 
+        :'status' => :'Status',
+        
+        # 
+        :'code' => :'Code'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'document' => :'Document',
+        :'status' => :'String',
+        :'code' => :'String'
+        
+      }
+    end
+
+    def initialize(attributes = {})
+      return if !attributes.is_a?(Hash) || attributes.empty?
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+      
+      if attributes[:'Document']
+        self.document = attributes[:'Document']
+      end
+      
+      if attributes[:'Status']
+        self.status = attributes[:'Status']
+      end
+      
+      if attributes[:'Code']
+        self.code = attributes[:'Code']
+      end
+      
+    end
+
+    def status=(status)
+      allowed_values = ["Continue", "SwitchingProtocols", "OK", "Created", "Accepted", "NonAuthoritativeInformation", "NoContent", "ResetContent", "PartialContent", "MultipleChoices", "Ambiguous", "MovedPermanently", "Moved", "Found", "Redirect", "SeeOther", "RedirectMethod", "NotModified", "UseProxy", "Unused", "TemporaryRedirect", "RedirectKeepVerb", "BadRequest", "Unauthorized", "PaymentRequired", "Forbidden", "NotFound", "MethodNotAllowed", "NotAcceptable", "ProxyAuthenticationRequired", "RequestTimeout", "Conflict", "Gone", "LengthRequired", "PreconditionFailed", "RequestEntityTooLarge", "RequestUriTooLong", "UnsupportedMediaType", "RequestedRangeNotSatisfiable", "ExpectationFailed", "UpgradeRequired", "InternalServerError", "NotImplemented", "BadGateway", "ServiceUnavailable", "GatewayTimeout", "HttpVersionNotSupported"]
+      if status && !allowed_values.include?(status)
+        fail "invalid value for 'status', must be one of #{allowed_values}"
+      end
+      @status = status
+    end
+
+  end
+end

data/lib/aspose_words_cloud/models/document_stat_data.rb

@@ -0,0 +1,63 @@
+module AsposeWordsCloud
+  # 
+  class DocumentStatData < BaseObject
+    attr_accessor :word_count, :paragraph_count, :page_count, :page_stat_data
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # 
+        :'word_count' => :'WordCount',
+        
+        # 
+        :'paragraph_count' => :'ParagraphCount',
+        
+        # 
+        :'page_count' => :'PageCount',
+        
+        # 
+        :'page_stat_data' => :'PageStatData'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'word_count' => :'Integer',
+        :'paragraph_count' => :'Integer',
+        :'page_count' => :'Integer',
+        :'page_stat_data' => :'Array<PageStatData>'
+        
+      }
+    end
+
+    def initialize(attributes = {})
+      return if !attributes.is_a?(Hash) || attributes.empty?
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+      
+      if attributes[:'WordCount']
+        self.word_count = attributes[:'WordCount']
+      end
+      
+      if attributes[:'ParagraphCount']
+        self.paragraph_count = attributes[:'ParagraphCount']
+      end
+      
+      if attributes[:'PageCount']
+        self.page_count = attributes[:'PageCount']
+      end
+      
+      if attributes[:'PageStatData']
+        if (value = attributes[:'PageStatData']).is_a?(Array)
+          self.page_stat_data = value
+        end
+      end
+      
+    end
+
+  end
+end

data/lib/aspose_words_cloud/models/drawing_object.rb

@@ -0,0 +1,79 @@
+module AsposeWordsCloud
+  # 
+  class DrawingObject < BaseObject
+    attr_accessor :render_links, :width, :height, :ole_data_link, :image_data_link, :link
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # 
+        :'render_links' => :'RenderLinks',
+        
+        # 
+        :'width' => :'Width',
+        
+        # 
+        :'height' => :'Height',
+        
+        # 
+        :'ole_data_link' => :'OleDataLink',
+        
+        # 
+        :'image_data_link' => :'ImageDataLink',
+        
+        # 
+        :'link' => :'link'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'render_links' => :'Array<Link>',
+        :'width' => :'Integer',
+        :'height' => :'Integer',
+        :'ole_data_link' => :'Link',
+        :'image_data_link' => :'Link',
+        :'link' => :'Link'
+        
+      }
+    end
+
+    def initialize(attributes = {})
+      return if !attributes.is_a?(Hash) || attributes.empty?
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+      
+      if attributes[:'RenderLinks']
+        if (value = attributes[:'RenderLinks']).is_a?(Array)
+          self.render_links = value
+        end
+      end
+      
+      if attributes[:'Width']
+        self.width = attributes[:'Width']
+      end
+      
+      if attributes[:'Height']
+        self.height = attributes[:'Height']
+      end
+      
+      if attributes[:'OleDataLink']
+        self.ole_data_link = attributes[:'OleDataLink']
+      end
+      
+      if attributes[:'ImageDataLink']
+        self.image_data_link = attributes[:'ImageDataLink']
+      end
+      
+      if attributes[:'link']
+        self.link = attributes[:'link']
+      end
+      
+    end
+
+  end
+end