aspose_words_cloud 1.0.0

data/lib/aspose_words_cloud/models/protection_data_response.rb

@@ -0,0 +1,69 @@
+module AsposeWordsCloud
+  # 
+  class ProtectionDataResponse < BaseObject
+    attr_accessor :protection_data, :document_link, :status, :code
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # 
+        :'protection_data' => :'ProtectionData',
+        
+        # 
+        :'document_link' => :'DocumentLink',
+        
+        # 
+        :'status' => :'Status',
+        
+        # 
+        :'code' => :'Code'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'protection_data' => :'ProtectionData',
+        :'document_link' => :'Link',
+        :'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[:'ProtectionData']
+        self.protection_data = attributes[:'ProtectionData']
+      end
+      
+      if attributes[:'DocumentLink']
+        self.document_link = attributes[:'DocumentLink']
+      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/protection_request.rb

@@ -0,0 +1,53 @@
+module AsposeWordsCloud
+  # 
+  class ProtectionRequest < BaseObject
+    attr_accessor :password, :new_password, :protection_type
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # 
+        :'password' => :'Password',
+        
+        # 
+        :'new_password' => :'NewPassword',
+        
+        # 
+        :'protection_type' => :'ProtectionType'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'password' => :'String',
+        :'new_password' => :'String',
+        :'protection_type' => :'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[:'Password']
+        self.password = attributes[:'Password']
+      end
+      
+      if attributes[:'NewPassword']
+        self.new_password = attributes[:'NewPassword']
+      end
+      
+      if attributes[:'ProtectionType']
+        self.protection_type = attributes[:'ProtectionType']
+      end
+      
+    end
+
+  end
+end

data/lib/aspose_words_cloud/models/rectangle.rb

@@ -0,0 +1,61 @@
+module AsposeWordsCloud
+  # 
+  class Rectangle < BaseObject
+    attr_accessor :x, :y, :width, :height
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # 
+        :'x' => :'X',
+        
+        # 
+        :'y' => :'Y',
+        
+        # 
+        :'width' => :'Width',
+        
+        # 
+        :'height' => :'Height'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'x' => :'Integer',
+        :'y' => :'Integer',
+        :'width' => :'Integer',
+        :'height' => :'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[:'X']
+        self.x = attributes[:'X']
+      end
+      
+      if attributes[:'Y']
+        self.y = attributes[:'Y']
+      end
+      
+      if attributes[:'Width']
+        self.width = attributes[:'Width']
+      end
+      
+      if attributes[:'Height']
+        self.height = attributes[:'Height']
+      end
+      
+    end
+
+  end
+end

data/lib/aspose_words_cloud/models/replace_text_request.rb

@@ -0,0 +1,61 @@
+module AsposeWordsCloud
+  # 
+  class ReplaceTextRequest < BaseObject
+    attr_accessor :old_value, :current_value, :is_match_case, :is_match_whole_word
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # 
+        :'old_value' => :'OldValue',
+        
+        # 
+        :'current_value' => :'CurrentValue',
+        
+        # 
+        :'is_match_case' => :'IsMatchCase',
+        
+        # 
+        :'is_match_whole_word' => :'IsMatchWholeWord'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'old_value' => :'String',
+        :'current_value' => :'String',
+        :'is_match_case' => :'BOOLEAN',
+        :'is_match_whole_word' => :'BOOLEAN'
+        
+      }
+    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[:'OldValue']
+        self.old_value = attributes[:'OldValue']
+      end
+      
+      if attributes[:'CurrentValue']
+        self.current_value = attributes[:'CurrentValue']
+      end
+      
+      if attributes[:'IsMatchCase']
+        self.is_match_case = attributes[:'IsMatchCase']
+      end
+      
+      if attributes[:'IsMatchWholeWord']
+        self.is_match_whole_word = attributes[:'IsMatchWholeWord']
+      end
+      
+    end
+
+  end
+end

data/lib/aspose_words_cloud/models/replace_text_response.rb

@@ -0,0 +1,69 @@
+module AsposeWordsCloud
+  # 
+  class ReplaceTextResponse < BaseObject
+    attr_accessor :matches, :document_link, :status, :code
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # 
+        :'matches' => :'Matches',
+        
+        # 
+        :'document_link' => :'DocumentLink',
+        
+        # 
+        :'status' => :'Status',
+        
+        # 
+        :'code' => :'Code'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'matches' => :'Integer',
+        :'document_link' => :'Link',
+        :'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[:'Matches']
+        self.matches = attributes[:'Matches']
+      end
+      
+      if attributes[:'DocumentLink']
+        self.document_link = attributes[:'DocumentLink']
+      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/response_message.rb

@@ -0,0 +1,45 @@
+module AsposeWordsCloud
+  # 
+  class ResponseMessage < BaseObject
+    attr_accessor :code, :message
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # 
+        :'code' => :'Code',
+        
+        # 
+        :'message' => :'Message'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'code' => :'Integer',
+        :'message' => :'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[:'Code']
+        self.code = attributes[:'Code']
+      end
+      
+      if attributes[:'Message']
+        self.message = attributes[:'Message']
+      end
+      
+    end
+
+  end
+end

data/lib/aspose_words_cloud/models/revisions_modification_response.rb

@@ -0,0 +1,61 @@
+module AsposeWordsCloud
+  # 
+  class RevisionsModificationResponse < BaseObject
+    attr_accessor :result, :status, :code
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # 
+        :'result' => :'Result',
+        
+        # 
+        :'status' => :'Status',
+        
+        # 
+        :'code' => :'Code'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'result' => :'ModificationOperationResult',
+        :'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[:'Result']
+        self.result = attributes[:'Result']
+      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/run.rb

@@ -0,0 +1,53 @@
+module AsposeWordsCloud
+  # 
+  class Run < BaseObject
+    attr_accessor :text, :node_id, :link
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # 
+        :'text' => :'Text',
+        
+        # 
+        :'node_id' => :'NodeId',
+        
+        # 
+        :'link' => :'link'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'text' => :'String',
+        :'node_id' => :'String',
+        :'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[:'Text']
+        self.text = attributes[:'Text']
+      end
+      
+      if attributes[:'NodeId']
+        self.node_id = attributes[:'NodeId']
+      end
+      
+      if attributes[:'link']
+        self.link = attributes[:'link']
+      end
+      
+    end
+
+  end
+end

data/lib/aspose_words_cloud/models/run_response.rb

@@ -0,0 +1,61 @@
+module AsposeWordsCloud
+  # 
+  class RunResponse < BaseObject
+    attr_accessor :run, :status, :code
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # 
+        :'run' => :'Run',
+        
+        # 
+        :'status' => :'Status',
+        
+        # 
+        :'code' => :'Code'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'run' => :'Run',
+        :'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[:'Run']
+        self.run = attributes[:'Run']
+      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/save_options_data.rb

@@ -0,0 +1,69 @@
+module AsposeWordsCloud
+  # 
+  class SaveOptionsData < BaseObject
+    attr_accessor :save_format, :file_name, :dml_rendering_mode, :dml_effects_rendering_mode, :zip_output
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # 
+        :'save_format' => :'SaveFormat',
+        
+        # 
+        :'file_name' => :'FileName',
+        
+        # 
+        :'dml_rendering_mode' => :'DmlRenderingMode',
+        
+        # 
+        :'dml_effects_rendering_mode' => :'DmlEffectsRenderingMode',
+        
+        # 
+        :'zip_output' => :'ZipOutput'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'save_format' => :'String',
+        :'file_name' => :'String',
+        :'dml_rendering_mode' => :'String',
+        :'dml_effects_rendering_mode' => :'String',
+        :'zip_output' => :'BOOLEAN'
+        
+      }
+    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[:'SaveFormat']
+        self.save_format = attributes[:'SaveFormat']
+      end
+      
+      if attributes[:'FileName']
+        self.file_name = attributes[:'FileName']
+      end
+      
+      if attributes[:'DmlRenderingMode']
+        self.dml_rendering_mode = attributes[:'DmlRenderingMode']
+      end
+      
+      if attributes[:'DmlEffectsRenderingMode']
+        self.dml_effects_rendering_mode = attributes[:'DmlEffectsRenderingMode']
+      end
+      
+      if attributes[:'ZipOutput']
+        self.zip_output = attributes[:'ZipOutput']
+      end
+      
+    end
+
+  end
+end

data/lib/aspose_words_cloud/models/save_response.rb

@@ -0,0 +1,61 @@
+module AsposeWordsCloud
+  # 
+  class SaveResponse < BaseObject
+    attr_accessor :save_result, :status, :code
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # 
+        :'save_result' => :'SaveResult',
+        
+        # 
+        :'status' => :'Status',
+        
+        # 
+        :'code' => :'Code'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'save_result' => :'SaveResult',
+        :'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[:'SaveResult']
+        self.save_result = attributes[:'SaveResult']
+      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