├── .swagger-codegen └── VERSION ├── runLinter.sh ├── lib └── docusign_maestro │ ├── version.rb │ ├── models │ ├── ds_workflow_step_types_loop.rb │ ├── ds_workflow_step_types_ds_idv.rb │ ├── ds_workflow_step_types_ds_sign.rb │ ├── http_types.rb │ ├── deploy_status.rb │ ├── ds_workflow_step_types_do_until.rb │ ├── ds_workflow_step_types_ds_doc_gen.rb │ ├── ds_workflow_step_types_ds_if_else.rb │ ├── ds_workflow_step_types_parallel.rb │ ├── ds_workflow_trigger_types.rb │ ├── ds_workflow_step_types_ds_web_forms.rb │ ├── ds_workflow_variable_source_types_step.rb │ ├── ds_workflow_logical_operator_types.rb │ ├── ds_workflow_doc_gen_doc_output_format.rb │ ├── e_sign_document_types_from_ds_template.rb │ ├── access_token_token_types.rb │ ├── ds_workflow_variable_source_types_variable.rb │ ├── e_sign_document_types_from_previous_step.rb │ ├── ds_workflow_step_types_ds_transformation.rb │ ├── ds_workflow_variable_source_types_participant.rb │ ├── participant_keys.rb │ ├── ds_workflow_expression_types_boolean_expression.rb │ ├── ds_workflow_expression_types_parallel_expression.rb │ ├── workflow_step_history_state.rb │ ├── ds_workflow_expression_types_comparison_expression.rb │ ├── workflow_instance_state.rb │ ├── ds_workflow_transformation_expression_types_concat_expression.rb │ ├── ds_workflow_transformation_expression_types_index_of_expression.rb │ ├── ds_workflow_transformation_expression_types_replace_expression.rb │ ├── ds_workflow_transformation_expression_types_to_lower_expression.rb │ ├── ds_workflow_transformation_expression_types_to_upper_expression.rb │ ├── workflow_metadata_status.rb │ ├── ds_workflow_transformation_expression_types_substring_expression.rb │ ├── ds_workflow_transformation_expression_types_last_index_of_expression.rb │ ├── deployment_status.rb │ ├── ds_workflow_comparison_operator_types.rb │ ├── error_codes.rb │ ├── replication_status.rb │ ├── event_types.rb │ ├── aow_uuid.rb │ ├── aow_uuid_string.rb │ ├── record_to_never.rb │ ├── version_string.rb │ ├── last_deployed_id.rb │ ├── e_sign_locale_policy.rb │ ├── workflow_date_time.rb │ ├── account_id.rb │ ├── record_string_boolean.rb │ ├── user_id.rb │ ├── workflow_instance_map.rb │ ├── ds_step_id.rb │ ├── ds_workflow_lanes_record.rb │ ├── template_id.rb │ ├── ds_workflow_variable.rb │ ├── workflow_instance_id.rb │ ├── ds_workflow_variable_record.rb │ ├── workflow_instances_list.rb │ ├── ds_workflow_participant_record.rb │ ├── workflow_step_history_list.rb │ ├── workflow_creator_id.rb │ ├── record_string_or_variable_or_transformation.rb │ ├── ds_workflow_variable_from_participant.rb │ ├── number_or_variable.rb │ ├── e_sign_documents.rb │ └── ds_service_step.rb │ ├── client │ └── api_error.rb │ └── api │ └── workflow_trigger_api.rb ├── CHANGELOG.md ├── .swagger-codegen-ignore ├── docusign_maestro.gemspec ├── .rubocop.yml └── README.md /.swagger-codegen/VERSION: -------------------------------------------------------------------------------- 1 | 2.4.21 -------------------------------------------------------------------------------- /runLinter.sh: -------------------------------------------------------------------------------- 1 | ./vendor/bundle/ruby/2.6.0/bin/rubocop -a -------------------------------------------------------------------------------- /lib/docusign_maestro/version.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | module DocuSign_Maestro 13 | VERSION = '3.0.0' 14 | end 15 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/ds_workflow_step_types_loop.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class DSWorkflowStepTypesLoop 16 | 17 | DS_LOOP = 'DS-Loop'.freeze 18 | 19 | # Builds the enum from string 20 | # @param [String] The enum value in the form of the string 21 | # @return [String] The enum value 22 | def build_from_hash(value) 23 | constantValues = DSWorkflowStepTypesLoop.constants.select { |c| DSWorkflowStepTypesLoop::const_get(c) == value } 24 | raise "Invalid ENUM value #{value} for class #DSWorkflowStepTypesLoop" if constantValues.empty? 25 | value 26 | end 27 | end 28 | end 29 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/ds_workflow_step_types_ds_idv.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class DSWorkflowStepTypesDSIdv 16 | 17 | DS_IDV = 'DS-IDV'.freeze 18 | 19 | # Builds the enum from string 20 | # @param [String] The enum value in the form of the string 21 | # @return [String] The enum value 22 | def build_from_hash(value) 23 | constantValues = DSWorkflowStepTypesDSIdv.constants.select { |c| DSWorkflowStepTypesDSIdv::const_get(c) == value } 24 | raise "Invalid ENUM value #{value} for class #DSWorkflowStepTypesDSIdv" if constantValues.empty? 25 | value 26 | end 27 | end 28 | end 29 | -------------------------------------------------------------------------------- /CHANGELOG.md: -------------------------------------------------------------------------------- 1 | ## [v3.0.0] - Maestro API v1.0.0-1.0.5 - 2025-05-22 2 | ⚠️ Deprecated – Maestro is now available as part of the new IAM SDK: https://developers.docusign.com/docs/sdks/ 3 | 4 | ## [v2.0.0] - Maestro API v1.0.0-1.0.5 - 2024-07-30 5 | ### Changed 6 | - Added support for version v1.0.0-1.0.5 of the DocuSign Maestro API. 7 | - Updated the SDK release version. 8 | 9 | ## [v2.0.0.rc1] - Maestro API v1.0.0-1.0.5 - 2024-06-07 10 | ### Changed 11 | - Added support for version v1.0.0-1.0.5 of the DocuSign Maestro API. 12 | - Updated the SDK release version. 13 | 14 | ## [v1.0.0] - Maestro API v1.0.0-1.0.4 - 2024-04-22 15 | ## Version 1.0.0 (Initial Release) 16 | - Announcing the SDK built on the OpenAPI specification for DocuSign Maestro APIs. 17 | - This release signifies the initial launch of the SDK, offering developers the essential tools for seamless interaction with DocuSign Maestro APIs. 18 | 19 | ## [v1.0.0.rc1] - Maestro API v1.0.0-1.0.3 - 2024-04-03 20 | - Announcing the Release Candidate SDK built on the OpenAPI specification for DocuSign Maestro APIs. 21 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/ds_workflow_step_types_ds_sign.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class DSWorkflowStepTypesDSSign 16 | 17 | DS_SIGN = 'DS-Sign'.freeze 18 | 19 | # Builds the enum from string 20 | # @param [String] The enum value in the form of the string 21 | # @return [String] The enum value 22 | def build_from_hash(value) 23 | constantValues = DSWorkflowStepTypesDSSign.constants.select { |c| DSWorkflowStepTypesDSSign::const_get(c) == value } 24 | raise "Invalid ENUM value #{value} for class #DSWorkflowStepTypesDSSign" if constantValues.empty? 25 | value 26 | end 27 | end 28 | end 29 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/http_types.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class HttpTypes 16 | 17 | GET = 'Get'.freeze 18 | POST = 'Post'.freeze 19 | PUT = 'Put'.freeze 20 | DELETE = 'Delete'.freeze 21 | 22 | # Builds the enum from string 23 | # @param [String] The enum value in the form of the string 24 | # @return [String] The enum value 25 | def build_from_hash(value) 26 | constantValues = HttpTypes.constants.select { |c| HttpTypes::const_get(c) == value } 27 | raise "Invalid ENUM value #{value} for class #HttpTypes" if constantValues.empty? 28 | value 29 | end 30 | end 31 | end 32 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/deploy_status.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class DeployStatus 16 | 17 | PUBLISH = 'Publish'.freeze 18 | UN_PUBLISH = 'UnPublish'.freeze 19 | DISABLE = 'Disable'.freeze 20 | 21 | # Builds the enum from string 22 | # @param [String] The enum value in the form of the string 23 | # @return [String] The enum value 24 | def build_from_hash(value) 25 | constantValues = DeployStatus.constants.select { |c| DeployStatus::const_get(c) == value } 26 | raise "Invalid ENUM value #{value} for class #DeployStatus" if constantValues.empty? 27 | value 28 | end 29 | end 30 | end 31 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/ds_workflow_step_types_do_until.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class DSWorkflowStepTypesDoUntil 16 | 17 | DS_DO_UNTIL = 'DS-DoUntil'.freeze 18 | 19 | # Builds the enum from string 20 | # @param [String] The enum value in the form of the string 21 | # @return [String] The enum value 22 | def build_from_hash(value) 23 | constantValues = DSWorkflowStepTypesDoUntil.constants.select { |c| DSWorkflowStepTypesDoUntil::const_get(c) == value } 24 | raise "Invalid ENUM value #{value} for class #DSWorkflowStepTypesDoUntil" if constantValues.empty? 25 | value 26 | end 27 | end 28 | end 29 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/ds_workflow_step_types_ds_doc_gen.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class DSWorkflowStepTypesDSDocGen 16 | 17 | DS_DOC_GEN = 'DS-DocGen'.freeze 18 | 19 | # Builds the enum from string 20 | # @param [String] The enum value in the form of the string 21 | # @return [String] The enum value 22 | def build_from_hash(value) 23 | constantValues = DSWorkflowStepTypesDSDocGen.constants.select { |c| DSWorkflowStepTypesDSDocGen::const_get(c) == value } 24 | raise "Invalid ENUM value #{value} for class #DSWorkflowStepTypesDSDocGen" if constantValues.empty? 25 | value 26 | end 27 | end 28 | end 29 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/ds_workflow_step_types_ds_if_else.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class DSWorkflowStepTypesDSIfElse 16 | 17 | DS_IF_ELSE = 'DS-IfElse'.freeze 18 | 19 | # Builds the enum from string 20 | # @param [String] The enum value in the form of the string 21 | # @return [String] The enum value 22 | def build_from_hash(value) 23 | constantValues = DSWorkflowStepTypesDSIfElse.constants.select { |c| DSWorkflowStepTypesDSIfElse::const_get(c) == value } 24 | raise "Invalid ENUM value #{value} for class #DSWorkflowStepTypesDSIfElse" if constantValues.empty? 25 | value 26 | end 27 | end 28 | end 29 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/ds_workflow_step_types_parallel.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class DSWorkflowStepTypesParallel 16 | 17 | DS_PARALLEL = 'DS-Parallel'.freeze 18 | 19 | # Builds the enum from string 20 | # @param [String] The enum value in the form of the string 21 | # @return [String] The enum value 22 | def build_from_hash(value) 23 | constantValues = DSWorkflowStepTypesParallel.constants.select { |c| DSWorkflowStepTypesParallel::const_get(c) == value } 24 | raise "Invalid ENUM value #{value} for class #DSWorkflowStepTypesParallel" if constantValues.empty? 25 | value 26 | end 27 | end 28 | end 29 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/ds_workflow_trigger_types.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class DSWorkflowTriggerTypes 16 | 17 | HTTP = 'Http'.freeze 18 | HTTP_API = 'Http-API'.freeze 19 | 20 | # Builds the enum from string 21 | # @param [String] The enum value in the form of the string 22 | # @return [String] The enum value 23 | def build_from_hash(value) 24 | constantValues = DSWorkflowTriggerTypes.constants.select { |c| DSWorkflowTriggerTypes::const_get(c) == value } 25 | raise "Invalid ENUM value #{value} for class #DSWorkflowTriggerTypes" if constantValues.empty? 26 | value 27 | end 28 | end 29 | end 30 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/ds_workflow_step_types_ds_web_forms.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class DSWorkflowStepTypesDSWebForms 16 | 17 | DS_WEB_FORMS = 'DS-WebForms'.freeze 18 | 19 | # Builds the enum from string 20 | # @param [String] The enum value in the form of the string 21 | # @return [String] The enum value 22 | def build_from_hash(value) 23 | constantValues = DSWorkflowStepTypesDSWebForms.constants.select { |c| DSWorkflowStepTypesDSWebForms::const_get(c) == value } 24 | raise "Invalid ENUM value #{value} for class #DSWorkflowStepTypesDSWebForms" if constantValues.empty? 25 | value 26 | end 27 | end 28 | end 29 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/ds_workflow_variable_source_types_step.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class DSWorkflowVariableSourceTypesStep 16 | 17 | STEP = 'step'.freeze 18 | 19 | # Builds the enum from string 20 | # @param [String] The enum value in the form of the string 21 | # @return [String] The enum value 22 | def build_from_hash(value) 23 | constantValues = DSWorkflowVariableSourceTypesStep.constants.select { |c| DSWorkflowVariableSourceTypesStep::const_get(c) == value } 24 | raise "Invalid ENUM value #{value} for class #DSWorkflowVariableSourceTypesStep" if constantValues.empty? 25 | value 26 | end 27 | end 28 | end 29 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/ds_workflow_logical_operator_types.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class DSWorkflowLogicalOperatorTypes 16 | 17 | AND = 'And'.freeze 18 | OR = 'Or'.freeze 19 | 20 | # Builds the enum from string 21 | # @param [String] The enum value in the form of the string 22 | # @return [String] The enum value 23 | def build_from_hash(value) 24 | constantValues = DSWorkflowLogicalOperatorTypes.constants.select { |c| DSWorkflowLogicalOperatorTypes::const_get(c) == value } 25 | raise "Invalid ENUM value #{value} for class #DSWorkflowLogicalOperatorTypes" if constantValues.empty? 26 | value 27 | end 28 | end 29 | end 30 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/ds_workflow_doc_gen_doc_output_format.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class DSWorkflowDocGenDocOutputFormat 16 | 17 | PDF = 'pdf'.freeze 18 | DOCX = 'docx'.freeze 19 | 20 | # Builds the enum from string 21 | # @param [String] The enum value in the form of the string 22 | # @return [String] The enum value 23 | def build_from_hash(value) 24 | constantValues = DSWorkflowDocGenDocOutputFormat.constants.select { |c| DSWorkflowDocGenDocOutputFormat::const_get(c) == value } 25 | raise "Invalid ENUM value #{value} for class #DSWorkflowDocGenDocOutputFormat" if constantValues.empty? 26 | value 27 | end 28 | end 29 | end 30 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/e_sign_document_types_from_ds_template.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class ESignDocumentTypesFromDSTemplate 16 | 17 | FROM_DS_TEMPLATE = 'FromDSTemplate'.freeze 18 | 19 | # Builds the enum from string 20 | # @param [String] The enum value in the form of the string 21 | # @return [String] The enum value 22 | def build_from_hash(value) 23 | constantValues = ESignDocumentTypesFromDSTemplate.constants.select { |c| ESignDocumentTypesFromDSTemplate::const_get(c) == value } 24 | raise "Invalid ENUM value #{value} for class #ESignDocumentTypesFromDSTemplate" if constantValues.empty? 25 | value 26 | end 27 | end 28 | end 29 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/access_token_token_types.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class AccessTokenTokenTypes 16 | 17 | BEARER = 'Bearer'.freeze 18 | APPLICATION = 'Application'.freeze 19 | RESOURCE = 'Resource'.freeze 20 | 21 | # Builds the enum from string 22 | # @param [String] The enum value in the form of the string 23 | # @return [String] The enum value 24 | def build_from_hash(value) 25 | constantValues = AccessTokenTokenTypes.constants.select { |c| AccessTokenTokenTypes::const_get(c) == value } 26 | raise "Invalid ENUM value #{value} for class #AccessTokenTokenTypes" if constantValues.empty? 27 | value 28 | end 29 | end 30 | end 31 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/ds_workflow_variable_source_types_variable.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class DSWorkflowVariableSourceTypesVariable 16 | 17 | VARIABLE = 'variable'.freeze 18 | 19 | # Builds the enum from string 20 | # @param [String] The enum value in the form of the string 21 | # @return [String] The enum value 22 | def build_from_hash(value) 23 | constantValues = DSWorkflowVariableSourceTypesVariable.constants.select { |c| DSWorkflowVariableSourceTypesVariable::const_get(c) == value } 24 | raise "Invalid ENUM value #{value} for class #DSWorkflowVariableSourceTypesVariable" if constantValues.empty? 25 | value 26 | end 27 | end 28 | end 29 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/e_sign_document_types_from_previous_step.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class ESignDocumentTypesFromPreviousStep 16 | 17 | FROM_PREVIOUS_STEP = 'FromPreviousStep'.freeze 18 | 19 | # Builds the enum from string 20 | # @param [String] The enum value in the form of the string 21 | # @return [String] The enum value 22 | def build_from_hash(value) 23 | constantValues = ESignDocumentTypesFromPreviousStep.constants.select { |c| ESignDocumentTypesFromPreviousStep::const_get(c) == value } 24 | raise "Invalid ENUM value #{value} for class #ESignDocumentTypesFromPreviousStep" if constantValues.empty? 25 | value 26 | end 27 | end 28 | end 29 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/ds_workflow_step_types_ds_transformation.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class DSWorkflowStepTypesDSTransformation 16 | 17 | DS_TRANSFORMATION = 'DS-Transformation'.freeze 18 | 19 | # Builds the enum from string 20 | # @param [String] The enum value in the form of the string 21 | # @return [String] The enum value 22 | def build_from_hash(value) 23 | constantValues = DSWorkflowStepTypesDSTransformation.constants.select { |c| DSWorkflowStepTypesDSTransformation::const_get(c) == value } 24 | raise "Invalid ENUM value #{value} for class #DSWorkflowStepTypesDSTransformation" if constantValues.empty? 25 | value 26 | end 27 | end 28 | end 29 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/ds_workflow_variable_source_types_participant.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class DSWorkflowVariableSourceTypesParticipant 16 | 17 | PARTICIPANT = 'participant'.freeze 18 | 19 | # Builds the enum from string 20 | # @param [String] The enum value in the form of the string 21 | # @return [String] The enum value 22 | def build_from_hash(value) 23 | constantValues = DSWorkflowVariableSourceTypesParticipant.constants.select { |c| DSWorkflowVariableSourceTypesParticipant::const_get(c) == value } 24 | raise "Invalid ENUM value #{value} for class #DSWorkflowVariableSourceTypesParticipant" if constantValues.empty? 25 | value 26 | end 27 | end 28 | end 29 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/participant_keys.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class ParticipantKeys 16 | 17 | PARTICIPANT_EMAIL = 'participantEmail'.freeze 18 | PARTICIPANT_FIRST_NAME = 'participantFirstName'.freeze 19 | PARTICIPANT_LAST_NAME = 'participantLastName'.freeze 20 | 21 | # Builds the enum from string 22 | # @param [String] The enum value in the form of the string 23 | # @return [String] The enum value 24 | def build_from_hash(value) 25 | constantValues = ParticipantKeys.constants.select { |c| ParticipantKeys::const_get(c) == value } 26 | raise "Invalid ENUM value #{value} for class #ParticipantKeys" if constantValues.empty? 27 | value 28 | end 29 | end 30 | end 31 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/ds_workflow_expression_types_boolean_expression.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class DSWorkflowExpressionTypesBooleanExpression 16 | 17 | BOOLEAN_EXPRESSION = 'BooleanExpression'.freeze 18 | 19 | # Builds the enum from string 20 | # @param [String] The enum value in the form of the string 21 | # @return [String] The enum value 22 | def build_from_hash(value) 23 | constantValues = DSWorkflowExpressionTypesBooleanExpression.constants.select { |c| DSWorkflowExpressionTypesBooleanExpression::const_get(c) == value } 24 | raise "Invalid ENUM value #{value} for class #DSWorkflowExpressionTypesBooleanExpression" if constantValues.empty? 25 | value 26 | end 27 | end 28 | end 29 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/ds_workflow_expression_types_parallel_expression.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class DSWorkflowExpressionTypesParallelExpression 16 | 17 | PARALLEL_EXPRESSION = 'ParallelExpression'.freeze 18 | 19 | # Builds the enum from string 20 | # @param [String] The enum value in the form of the string 21 | # @return [String] The enum value 22 | def build_from_hash(value) 23 | constantValues = DSWorkflowExpressionTypesParallelExpression.constants.select { |c| DSWorkflowExpressionTypesParallelExpression::const_get(c) == value } 24 | raise "Invalid ENUM value #{value} for class #DSWorkflowExpressionTypesParallelExpression" if constantValues.empty? 25 | value 26 | end 27 | end 28 | end 29 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/workflow_step_history_state.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class WorkflowStepHistoryState 16 | 17 | IN_PROGRESS = 'In Progress'.freeze 18 | COMPLETED = 'Completed'.freeze 19 | FAILED = 'Failed'.freeze 20 | CANCELED = 'Canceled'.freeze 21 | 22 | # Builds the enum from string 23 | # @param [String] The enum value in the form of the string 24 | # @return [String] The enum value 25 | def build_from_hash(value) 26 | constantValues = WorkflowStepHistoryState.constants.select { |c| WorkflowStepHistoryState::const_get(c) == value } 27 | raise "Invalid ENUM value #{value} for class #WorkflowStepHistoryState" if constantValues.empty? 28 | value 29 | end 30 | end 31 | end 32 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/ds_workflow_expression_types_comparison_expression.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class DSWorkflowExpressionTypesComparisonExpression 16 | 17 | COMPARISON_EXPRESSION = 'ComparisonExpression'.freeze 18 | 19 | # Builds the enum from string 20 | # @param [String] The enum value in the form of the string 21 | # @return [String] The enum value 22 | def build_from_hash(value) 23 | constantValues = DSWorkflowExpressionTypesComparisonExpression.constants.select { |c| DSWorkflowExpressionTypesComparisonExpression::const_get(c) == value } 24 | raise "Invalid ENUM value #{value} for class #DSWorkflowExpressionTypesComparisonExpression" if constantValues.empty? 25 | value 26 | end 27 | end 28 | end 29 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/workflow_instance_state.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class WorkflowInstanceState 16 | 17 | CREATED = 'Created'.freeze 18 | IN_PROGRESS = 'In Progress'.freeze 19 | COMPLETED = 'Completed'.freeze 20 | FAILED = 'Failed'.freeze 21 | CANCELED = 'Canceled'.freeze 22 | 23 | # Builds the enum from string 24 | # @param [String] The enum value in the form of the string 25 | # @return [String] The enum value 26 | def build_from_hash(value) 27 | constantValues = WorkflowInstanceState.constants.select { |c| WorkflowInstanceState::const_get(c) == value } 28 | raise "Invalid ENUM value #{value} for class #WorkflowInstanceState" if constantValues.empty? 29 | value 30 | end 31 | end 32 | end 33 | -------------------------------------------------------------------------------- /lib/docusign_maestro/client/api_error.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | module DocuSign_Maestro 13 | class ApiError < StandardError 14 | attr_reader :code, :response_headers, :response_body 15 | 16 | # Usage examples: 17 | # ApiError.new 18 | # ApiError.new("message") 19 | # ApiError.new(:code => 500, :response_headers => {}, :response_body => "") 20 | # ApiError.new(:code => 404, :message => "Not Found") 21 | def initialize(arg = nil) 22 | if arg.is_a? Hash 23 | if arg.key?(:message) || arg.key?('message') 24 | super(arg[:message] || arg['message']) 25 | else 26 | super arg 27 | end 28 | 29 | arg.each do |k, v| 30 | instance_variable_set "@#{k}", v 31 | end 32 | else 33 | super arg 34 | end 35 | end 36 | end 37 | end 38 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/ds_workflow_transformation_expression_types_concat_expression.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class DSWorkflowTransformationExpressionTypesConcatExpression 16 | 17 | CONCAT_EXPRESSION = 'ConcatExpression'.freeze 18 | 19 | # Builds the enum from string 20 | # @param [String] The enum value in the form of the string 21 | # @return [String] The enum value 22 | def build_from_hash(value) 23 | constantValues = DSWorkflowTransformationExpressionTypesConcatExpression.constants.select { |c| DSWorkflowTransformationExpressionTypesConcatExpression::const_get(c) == value } 24 | raise "Invalid ENUM value #{value} for class #DSWorkflowTransformationExpressionTypesConcatExpression" if constantValues.empty? 25 | value 26 | end 27 | end 28 | end 29 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/ds_workflow_transformation_expression_types_index_of_expression.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class DSWorkflowTransformationExpressionTypesIndexOfExpression 16 | 17 | INDEX_OF_EXPRESSION = 'IndexOfExpression'.freeze 18 | 19 | # Builds the enum from string 20 | # @param [String] The enum value in the form of the string 21 | # @return [String] The enum value 22 | def build_from_hash(value) 23 | constantValues = DSWorkflowTransformationExpressionTypesIndexOfExpression.constants.select { |c| DSWorkflowTransformationExpressionTypesIndexOfExpression::const_get(c) == value } 24 | raise "Invalid ENUM value #{value} for class #DSWorkflowTransformationExpressionTypesIndexOfExpression" if constantValues.empty? 25 | value 26 | end 27 | end 28 | end 29 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/ds_workflow_transformation_expression_types_replace_expression.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class DSWorkflowTransformationExpressionTypesReplaceExpression 16 | 17 | REPLACE_EXPRESSION = 'ReplaceExpression'.freeze 18 | 19 | # Builds the enum from string 20 | # @param [String] The enum value in the form of the string 21 | # @return [String] The enum value 22 | def build_from_hash(value) 23 | constantValues = DSWorkflowTransformationExpressionTypesReplaceExpression.constants.select { |c| DSWorkflowTransformationExpressionTypesReplaceExpression::const_get(c) == value } 24 | raise "Invalid ENUM value #{value} for class #DSWorkflowTransformationExpressionTypesReplaceExpression" if constantValues.empty? 25 | value 26 | end 27 | end 28 | end 29 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/ds_workflow_transformation_expression_types_to_lower_expression.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class DSWorkflowTransformationExpressionTypesToLowerExpression 16 | 17 | TO_LOWER_EXPRESSION = 'ToLowerExpression'.freeze 18 | 19 | # Builds the enum from string 20 | # @param [String] The enum value in the form of the string 21 | # @return [String] The enum value 22 | def build_from_hash(value) 23 | constantValues = DSWorkflowTransformationExpressionTypesToLowerExpression.constants.select { |c| DSWorkflowTransformationExpressionTypesToLowerExpression::const_get(c) == value } 24 | raise "Invalid ENUM value #{value} for class #DSWorkflowTransformationExpressionTypesToLowerExpression" if constantValues.empty? 25 | value 26 | end 27 | end 28 | end 29 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/ds_workflow_transformation_expression_types_to_upper_expression.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class DSWorkflowTransformationExpressionTypesToUpperExpression 16 | 17 | TO_UPPER_EXPRESSION = 'ToUpperExpression'.freeze 18 | 19 | # Builds the enum from string 20 | # @param [String] The enum value in the form of the string 21 | # @return [String] The enum value 22 | def build_from_hash(value) 23 | constantValues = DSWorkflowTransformationExpressionTypesToUpperExpression.constants.select { |c| DSWorkflowTransformationExpressionTypesToUpperExpression::const_get(c) == value } 24 | raise "Invalid ENUM value #{value} for class #DSWorkflowTransformationExpressionTypesToUpperExpression" if constantValues.empty? 25 | value 26 | end 27 | end 28 | end 29 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/workflow_metadata_status.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class WorkflowMetadataStatus 16 | 17 | ACTIVE = 'active'.freeze 18 | INACTIVE = 'inactive'.freeze 19 | PUBLISHING = 'publishing'.freeze 20 | UNPUBLISHING = 'unpublishing'.freeze 21 | ARCHIVED = 'archived'.freeze 22 | ARCHIVING = 'archiving'.freeze 23 | 24 | # Builds the enum from string 25 | # @param [String] The enum value in the form of the string 26 | # @return [String] The enum value 27 | def build_from_hash(value) 28 | constantValues = WorkflowMetadataStatus.constants.select { |c| WorkflowMetadataStatus::const_get(c) == value } 29 | raise "Invalid ENUM value #{value} for class #WorkflowMetadataStatus" if constantValues.empty? 30 | value 31 | end 32 | end 33 | end 34 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/ds_workflow_transformation_expression_types_substring_expression.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class DSWorkflowTransformationExpressionTypesSubstringExpression 16 | 17 | SUBSTRING_EXPRESSION = 'SubstringExpression'.freeze 18 | 19 | # Builds the enum from string 20 | # @param [String] The enum value in the form of the string 21 | # @return [String] The enum value 22 | def build_from_hash(value) 23 | constantValues = DSWorkflowTransformationExpressionTypesSubstringExpression.constants.select { |c| DSWorkflowTransformationExpressionTypesSubstringExpression::const_get(c) == value } 24 | raise "Invalid ENUM value #{value} for class #DSWorkflowTransformationExpressionTypesSubstringExpression" if constantValues.empty? 25 | value 26 | end 27 | end 28 | end 29 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/ds_workflow_transformation_expression_types_last_index_of_expression.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class DSWorkflowTransformationExpressionTypesLastIndexOfExpression 16 | 17 | LAST_INDEX_OF_EXPRESSION = 'LastIndexOfExpression'.freeze 18 | 19 | # Builds the enum from string 20 | # @param [String] The enum value in the form of the string 21 | # @return [String] The enum value 22 | def build_from_hash(value) 23 | constantValues = DSWorkflowTransformationExpressionTypesLastIndexOfExpression.constants.select { |c| DSWorkflowTransformationExpressionTypesLastIndexOfExpression::const_get(c) == value } 24 | raise "Invalid ENUM value #{value} for class #DSWorkflowTransformationExpressionTypesLastIndexOfExpression" if constantValues.empty? 25 | value 26 | end 27 | end 28 | end 29 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/deployment_status.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class DeploymentStatus 16 | 17 | DEPLOYMENT_IN_PROGRESS = 'Deployment In Progress'.freeze 18 | DEPLOYED = 'Deployed'.freeze 19 | FAILED = 'Failed'.freeze 20 | DELETE_IN_PROGRESS = 'Delete in Progress'.freeze 21 | DELETED = 'Deleted'.freeze 22 | NOT_DEPLOYED = 'Not Deployed'.freeze 23 | UNPUBLISH_IN_PROGRESS = 'Unpublish in Progress'.freeze 24 | UNPUBLISHED = 'Unpublished'.freeze 25 | 26 | # Builds the enum from string 27 | # @param [String] The enum value in the form of the string 28 | # @return [String] The enum value 29 | def build_from_hash(value) 30 | constantValues = DeploymentStatus.constants.select { |c| DeploymentStatus::const_get(c) == value } 31 | raise "Invalid ENUM value #{value} for class #DeploymentStatus" if constantValues.empty? 32 | value 33 | end 34 | end 35 | end 36 | -------------------------------------------------------------------------------- /.swagger-codegen-ignore: -------------------------------------------------------------------------------- 1 | # Swagger Codegen Ignore 2 | # Generated by swagger-codegen https://github.com/swagger-api/swagger-codegen 3 | 4 | # Use this file to prevent files from being overwritten by the generator. 5 | # The patterns follow closely to .gitignore or .dockerignore. 6 | 7 | # As an example, the C# client generator defines ApiClient.cs. 8 | # You can make changes and tell Swagger Codgen to ignore just this file by uncommenting the following line: 9 | #ApiClient.cs 10 | 11 | # You can match any string of characters against a directory, file or extension with a single asterisk (*): 12 | #foo/*/qux 13 | # The above matches foo/bar/qux and foo/baz/qux, but not foo/bar/baz/qux 14 | 15 | # You can recursively match patterns against a directory, file or extension with a double asterisk (**): 16 | #foo/**/qux 17 | # This matches foo/bar/qux, foo/baz/qux, and foo/bar/baz/qux 18 | 19 | # You can also negate patterns with an exclamation (!). 20 | # For example, you can ignore all files in a docs folder with the file extension .md: 21 | #docs/*.md 22 | # Then explicitly reverse the ignore rule for a single file: 23 | #!docs/README.md 24 | 25 | 26 | # Swagger and Git files 27 | .swagger-codegen-ignore 28 | git_push.sh 29 | .gitignore 30 | CHANGELOG.md 31 | 32 | 33 | # Project files 34 | LICENSE 35 | .travis.yml 36 | Gemfile 37 | Gemfile.lock 38 | Rakefile 39 | 40 | # Specific src and test files 41 | .rspec 42 | docs/ 43 | spec/ 44 | tests/ -------------------------------------------------------------------------------- /lib/docusign_maestro/models/ds_workflow_comparison_operator_types.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class DSWorkflowComparisonOperatorTypes 16 | 17 | CONTAINS = 'Contains'.freeze 18 | NOT_CONTAINS = 'NotContains'.freeze 19 | EQUAL = 'Equal'.freeze 20 | NOT_EQUAL = 'NotEqual'.freeze 21 | GREATER_THAN = 'GreaterThan'.freeze 22 | GREATER_THAN_OR_EQUAL = 'GreaterThanOrEqual'.freeze 23 | LESS_THAN = 'LessThan'.freeze 24 | LESS_THAN_OR_EQUAL = 'LessThanOrEqual'.freeze 25 | STARTS_WITH = 'StartsWith'.freeze 26 | NOT_STARTS_WITH = 'NotStartsWith'.freeze 27 | ENDS_WITH = 'EndsWith'.freeze 28 | NOT_ENDS_WITH = 'NotEndsWith'.freeze 29 | 30 | # Builds the enum from string 31 | # @param [String] The enum value in the form of the string 32 | # @return [String] The enum value 33 | def build_from_hash(value) 34 | constantValues = DSWorkflowComparisonOperatorTypes.constants.select { |c| DSWorkflowComparisonOperatorTypes::const_get(c) == value } 35 | raise "Invalid ENUM value #{value} for class #DSWorkflowComparisonOperatorTypes" if constantValues.empty? 36 | value 37 | end 38 | end 39 | end 40 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/error_codes.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class ErrorCodes 16 | 17 | N10001 = 'ERR_10001'.freeze 18 | N10002 = 'ERR_10002'.freeze 19 | N10003 = 'ERR_10003'.freeze 20 | N10004 = 'ERR_10004'.freeze 21 | N10005 = 'ERR_10005'.freeze 22 | N10006 = 'ERR_10006'.freeze 23 | N10007 = 'ERR_10007'.freeze 24 | N10008 = 'ERR_10008'.freeze 25 | N10009 = 'ERR_10009'.freeze 26 | N10101 = 'ERR_10101'.freeze 27 | N10201 = 'ERR_10201'.freeze 28 | N10202 = 'ERR_10202'.freeze 29 | N10301 = 'ERR_10301'.freeze 30 | N10302 = 'ERR_10302'.freeze 31 | N10401 = 'ERR_10401'.freeze 32 | N10801 = 'ERR_10801'.freeze 33 | N10802 = 'ERR_10802'.freeze 34 | N10999 = 'ERR_10999'.freeze 35 | 36 | # Builds the enum from string 37 | # @param [String] The enum value in the form of the string 38 | # @return [String] The enum value 39 | def build_from_hash(value) 40 | constantValues = ErrorCodes.constants.select { |c| ErrorCodes::const_get(c) == value } 41 | raise "Invalid ENUM value #{value} for class #ErrorCodes" if constantValues.empty? 42 | value 43 | end 44 | end 45 | end 46 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/replication_status.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class ReplicationStatus 16 | 17 | DEPLOY_REPLICATION_IN_PROGRESS = 'Deploy Replication In Progress'.freeze 18 | DEPLOY_REPLICATED = 'Deploy Replicated'.freeze 19 | DEPLOY_REPLICATION_FAILED = 'Deploy Replication Failed'.freeze 20 | NOT_REPLICATED = 'Not Replicated'.freeze 21 | DELETE_REPLICATION_IN_PROGRESS = 'Delete Replication in Progress'.freeze 22 | DELETE_REPLICATED = 'Delete Replicated'.freeze 23 | DELETE_REPLICATION_FAILED = 'Delete Replication Failed'.freeze 24 | UNPUBLISH_REPLICATION_IN_PROGRESS = 'Unpublish replication in Progress'.freeze 25 | UNPUBLISH_REPLICATED = 'Unpublish Replicated'.freeze 26 | UNPUBLISH_REPLICATION_FAILED = 'Unpublish Replication Failed'.freeze 27 | 28 | # Builds the enum from string 29 | # @param [String] The enum value in the form of the string 30 | # @return [String] The enum value 31 | def build_from_hash(value) 32 | constantValues = ReplicationStatus.constants.select { |c| ReplicationStatus::const_get(c) == value } 33 | raise "Invalid ENUM value #{value} for class #ReplicationStatus" if constantValues.empty? 34 | value 35 | end 36 | end 37 | end 38 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/event_types.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class EventTypes 16 | 17 | ENVELOPE_SENT = 'envelope-sent'.freeze 18 | ENVELOPE_DELIVERED = 'envelope-delivered'.freeze 19 | ENVELOPE_COMPLETED = 'envelope-completed'.freeze 20 | ENVELOPE_DECLINED = 'envelope-declined'.freeze 21 | ENVELOPE_VOIDED = 'envelope-voided'.freeze 22 | ENVELOPE_CREATED = 'envelope-created'.freeze 23 | ENVELOPE_RESENT = 'envelope-resent'.freeze 24 | ENVELOPE_CORRECTED = 'envelope-corrected'.freeze 25 | ENVELOPE_PURGE = 'envelope-purge'.freeze 26 | ENVELOPE_DELETED = 'envelope-deleted'.freeze 27 | ENVELOPE_DISCARD = 'envelope-discard'.freeze 28 | DELIVERY_FAILED = 'Delivery Failed'.freeze 29 | AUTHENTICATION_FAILED = 'Authentication Failed'.freeze 30 | SENT = 'Sent'.freeze 31 | DELIVERED = 'Delivered'.freeze 32 | SIGNED = 'Signed'.freeze 33 | COMPLETED = 'Completed'.freeze 34 | 35 | # Builds the enum from string 36 | # @param [String] The enum value in the form of the string 37 | # @return [String] The enum value 38 | def build_from_hash(value) 39 | constantValues = EventTypes.constants.select { |c| EventTypes::const_get(c) == value } 40 | raise "Invalid ENUM value #{value} for class #EventTypes" if constantValues.empty? 41 | value 42 | end 43 | end 44 | end 45 | -------------------------------------------------------------------------------- /docusign_maestro.gemspec: -------------------------------------------------------------------------------- 1 | # -*- encoding: utf-8 -*- 2 | 3 | =begin 4 | #Maestro API 5 | 6 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 7 | 8 | OpenAPI spec version: 1.0.0 9 | Contact: devcenter@docusign.com 10 | Generated by: https://github.com/swagger-api/swagger-codegen.git 11 | 12 | =end 13 | 14 | $:.push File.expand_path("../lib", __FILE__) 15 | require "docusign_maestro/version" 16 | 17 | Gem::Specification.new do |s| 18 | s.name = "docusign_maestro" 19 | s.version = DocuSign_Maestro::VERSION 20 | s.platform = Gem::Platform::RUBY 21 | s.authors = ["DocuSign"] 22 | s.email = ["devcenter@docusign.com"] 23 | s.homepage = "https://github.com/docusign/docusign-maestro-ruby-client" 24 | s.summary = "Maestro API Ruby Gem" 25 | s.description = "The Docusign package makes integrating Docusign into your apps and websites a super fast and painless process. The library is open sourced on GitHub, look for the docusign-maestro-ruby-client repository." 26 | s.license = "MIT" 27 | s.required_ruby_version = ">= 1.9" 28 | 29 | s.add_runtime_dependency 'jwt', '~> 2.2', '>= 2.2.1' 30 | s.add_runtime_dependency 'addressable', '~> 2.7', '>= 2.7.0' 31 | s.add_runtime_dependency 'typhoeus', '~> 1.0', '>= 1.0.1' 32 | s.add_runtime_dependency 'json', '~> 2.1', '>= 2.1.0' 33 | 34 | s.add_development_dependency 'rspec-mocks', '~> 3.8', '>= 3.8.0' 35 | s.add_development_dependency 'rspec-expectations', '~> 3.8', '>= 3.8.0' 36 | s.add_development_dependency 'rspec', '~> 3.4', '>= 3.4.0' 37 | s.add_development_dependency 'vcr', '~> 3.0', '>= 3.0.1' 38 | s.add_development_dependency 'webmock', '~> 1.24', '>= 1.24.3' 39 | s.add_development_dependency 'autotest', '~> 4.4', '>= 4.4.6' 40 | s.add_development_dependency 'autotest-rails-pure', '~> 4.1', '>= 4.1.2' 41 | s.add_development_dependency 'autotest-growl', '~> 0.2', '>= 0.2.16' 42 | s.add_development_dependency 'autotest-fsevent', '~> 0.2', '>= 0.2.11' 43 | 44 | s.files = `find *`.split("\n").uniq.sort.select{|f| !f.empty? } 45 | s.test_files = `find spec/*`.split("\n") 46 | s.executables = [] 47 | s.require_paths = ["lib"] 48 | end -------------------------------------------------------------------------------- /.rubocop.yml: -------------------------------------------------------------------------------- 1 | # This file is based on https://github.com/rails/rails/blob/master/.rubocop.yml (MIT license) 2 | # Automatically generated by Swagger Codegen (https://github.com/swagger-api/swagger-codegen) 3 | AllCops: 4 | TargetRubyVersion: 2.6 5 | # RuboCop has a bunch of cops enabled by default. This setting tells RuboCop 6 | # to ignore them, so only the ones explicitly set in this file are enabled. 7 | DisabledByDefault: true 8 | Exclude: 9 | - '**/templates/**/*' 10 | - '**/vendor/**/*' 11 | - 'actionpack/lib/action_dispatch/journey/parser.rb' 12 | 13 | # Prefer &&/|| over and/or. 14 | Style/AndOr: 15 | Enabled: true 16 | 17 | # Align `when` with `case`. 18 | Layout/CaseIndentation: 19 | Enabled: true 20 | 21 | # Align comments with method definitions. 22 | Layout/CommentIndentation: 23 | Enabled: true 24 | 25 | Layout/ElseAlignment: 26 | Enabled: true 27 | 28 | Layout/EmptyLineAfterMagicComment: 29 | Enabled: true 30 | 31 | # In a regular class definition, no empty lines around the body. 32 | Layout/EmptyLinesAroundClassBody: 33 | Enabled: true 34 | 35 | # In a regular method definition, no empty lines around the body. 36 | Layout/EmptyLinesAroundMethodBody: 37 | Enabled: true 38 | 39 | # In a regular module definition, no empty lines around the body. 40 | Layout/EmptyLinesAroundModuleBody: 41 | Enabled: true 42 | 43 | Layout/FirstParameterIndentation: 44 | Enabled: true 45 | 46 | # Use Ruby >= 1.9 syntax for hashes. Prefer { a: :b } over { :a => :b }. 47 | Style/HashSyntax: 48 | Enabled: false 49 | 50 | # Method definitions after `private` or `protected` isolated calls need one 51 | # extra level of indentation. 52 | Layout/IndentationConsistency: 53 | Enabled: true 54 | EnforcedStyle: indented_internal_methods 55 | 56 | # Two spaces, no tabs (for indentation). 57 | Layout/IndentationWidth: 58 | Enabled: true 59 | 60 | Layout/LeadingCommentSpace: 61 | Enabled: true 62 | 63 | Layout/SpaceAfterColon: 64 | Enabled: true 65 | 66 | Layout/SpaceAfterComma: 67 | Enabled: true 68 | 69 | Layout/SpaceAroundEqualsInParameterDefault: 70 | Enabled: true 71 | 72 | Layout/SpaceAroundKeyword: 73 | Enabled: true 74 | 75 | Layout/SpaceAroundOperators: 76 | Enabled: true 77 | 78 | Layout/SpaceBeforeComma: 79 | Enabled: true 80 | 81 | Layout/SpaceBeforeFirstArg: 82 | Enabled: true 83 | 84 | Style/DefWithParentheses: 85 | Enabled: true 86 | 87 | # Defining a method with parameters needs parentheses. 88 | Style/MethodDefParentheses: 89 | Enabled: true 90 | 91 | Style/FrozenStringLiteralComment: 92 | Enabled: false 93 | EnforcedStyle: always 94 | 95 | # Use `foo {}` not `foo{}`. 96 | Layout/SpaceBeforeBlockBraces: 97 | Enabled: true 98 | 99 | # Use `foo { bar }` not `foo {bar}`. 100 | Layout/SpaceInsideBlockBraces: 101 | Enabled: true 102 | 103 | # Use `{ a: 1 }` not `{a:1}`. 104 | Layout/SpaceInsideHashLiteralBraces: 105 | Enabled: true 106 | 107 | Layout/SpaceInsideParens: 108 | Enabled: true 109 | 110 | # Check quotes usage according to lint rule below. 111 | #Style/StringLiterals: 112 | # Enabled: true 113 | # EnforcedStyle: single_quotes 114 | 115 | # Detect hard tabs, no hard tabs. 116 | Layout/IndentationStyle: 117 | Enabled: true 118 | 119 | # Blank lines should not have any spaces. 120 | Layout/TrailingEmptyLines: 121 | Enabled: true 122 | 123 | # No trailing whitespace. 124 | Layout/TrailingWhitespace: 125 | Enabled: false 126 | 127 | # Use quotes for string literals when they are enough. 128 | Style/RedundantPercentQ: 129 | Enabled: true 130 | 131 | # Align `end` with the matching keyword or starting expression except for 132 | # assignments, where it should be aligned with the LHS. 133 | Lint/EndAlignment: 134 | Enabled: true 135 | EnforcedStyleAlignWith: variable 136 | AutoCorrect: true 137 | 138 | # Use my_method(my_arg) not my_method( my_arg ) or my_method my_arg. 139 | Lint/RequireParentheses: 140 | Enabled: true 141 | 142 | Style/RedundantReturn: 143 | Enabled: true 144 | AllowMultipleReturnValues: true 145 | 146 | Style/Semicolon: 147 | Enabled: true 148 | AllowAsExpressionSeparator: true 149 | -------------------------------------------------------------------------------- /lib/docusign_maestro/api/workflow_trigger_api.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require "uri" 13 | 14 | # @deprecated Maestro is now available as part of the new IAM SDK: https://developers.docusign.com/docs/sdks/ . 15 | module DocuSign_Maestro 16 | 17 | # @deprecated Maestro is now available as part of the new IAM SDK: https://developers.docusign.com/docs/sdks/ . 18 | class TriggerWorkflowOptions 19 | # Managed Token Id registered with DS Account Server 20 | attr_accessor :mtid 21 | 22 | # Managed Token Secret registered with DS Account Server 23 | attr_accessor :mtsec 24 | 25 | def self.default 26 | @@default ||= TriggerWorkflowOptions.new 27 | end 28 | end 29 | 30 | 31 | class WorkflowTriggerApi 32 | attr_accessor :api_client 33 | 34 | def initialize(api_client = WorkflowTriggerApi.default) 35 | @api_client = api_client 36 | end 37 | 38 | # Creates a new workflow instance after authenticating with DS Account Server 39 | # Creates a new workflow instance after authenticating with DS Account Server 40 | # @param account_id Account ID 41 | # @param workflow_definition_id Workflow Definition ID 42 | # @param body JSON payload that will be passed to the triggered workflow 43 | # @param DocuSign_Maestro::TriggerWorkflowOptions Options for modifying the behavior of the function. 44 | # @return [TriggerWorkflowViaPostResponse] 45 | def trigger_workflow(account_id, workflow_definition_id, body, options = DocuSign_Maestro::TriggerWorkflowOptions.default) 46 | data, _status_code, _headers = trigger_workflow_with_http_info(account_id, workflow_definition_id, body, options) 47 | return data 48 | end 49 | 50 | # Creates a new workflow instance after authenticating with DS Account Server 51 | # Creates a new workflow instance after authenticating with DS Account Server 52 | # @param account_id Account ID 53 | # @param workflow_definition_id Workflow Definition ID 54 | # @param body JSON payload that will be passed to the triggered workflow 55 | # @param DocuSign_Maestro::TriggerWorkflowOptions Options for modifying the behavior of the function. 56 | # @return [Array<(TriggerWorkflowViaPostResponse, Fixnum, Hash)>] TriggerWorkflowViaPostResponse data, response status code and response headers 57 | def trigger_workflow_with_http_info(account_id, workflow_definition_id, body, options = DocuSign_Maestro::TriggerWorkflowOptions.default) 58 | if @api_client.config.debugging 59 | @api_client.config.logger.debug "Calling API: WorkflowTriggerApi.trigger_workflow ..." 60 | end 61 | # verify the required parameter 'account_id' is set 62 | fail ArgumentError, "Missing the required parameter 'account_id' when calling WorkflowTriggerApi.trigger_workflow" if account_id.nil? 63 | # verify the required parameter 'workflow_definition_id' is set 64 | fail ArgumentError, "Missing the required parameter 'workflow_definition_id' when calling WorkflowTriggerApi.trigger_workflow" if workflow_definition_id.nil? 65 | # verify the required parameter 'body' is set 66 | fail ArgumentError, "Missing the required parameter 'body' when calling WorkflowTriggerApi.trigger_workflow" if body.nil? 67 | # resource path 68 | local_var_path = "/v1/accounts/{accountId}/workflow_definitions/{workflowDefinitionId}/trigger".sub('{format}','json').sub('{' + 'accountId' + '}', account_id.to_s).sub('{' + 'workflowDefinitionId' + '}', workflow_definition_id.to_s) 69 | 70 | # query parameters 71 | query_params = {} 72 | query_params[:'mtid'] = options.mtid if !options.mtid.nil? 73 | query_params[:'mtsec'] = options.mtsec if !options.mtsec.nil? 74 | 75 | # header parameters 76 | header_params = {} 77 | # HTTP header 'Accept' (if needed) 78 | header_params['Accept'] = @api_client.select_header_accept(['application/json']) 79 | # HTTP header 'Content-Type' 80 | header_params['Content-Type'] = @api_client.select_header_content_type(['application/json']) 81 | 82 | # form parameters 83 | form_params = {} 84 | 85 | # http body (model) 86 | post_body = @api_client.object_to_http_body(body) 87 | auth_names = [] 88 | data, status_code, headers = @api_client.call_api(:POST, local_var_path, 89 | :header_params => header_params, 90 | :query_params => query_params, 91 | :form_params => form_params, 92 | :body => post_body, 93 | :auth_names => auth_names, 94 | :return_type => 'TriggerWorkflowViaPostResponse') 95 | if @api_client.config.debugging 96 | @api_client.config.logger.debug "API called: WorkflowTriggerApi#trigger_workflow\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}" 97 | end 98 | return data, status_code, headers 99 | end 100 | end 101 | end -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | 2 | ## ⚠️ Deprecation Notice 3 | This SDK is deprecated and no longer actively maintained. 4 | 5 | Docusign has launched a new IAM SDK, which includes support for Maestro, Navigator and Connected Fields API families in a single, unified package. 6 | 7 | 👉 We recommend migrating to the IAM SDK for the latest updates, support, and a streamlined developer experience. 8 | 9 | 🔗 [Learn more and get started](https://developers.docusign.com/docs/sdks/) 10 | 11 | # The Official Docusign Maestro Ruby Client SDK (Deprecated) 12 | 13 | ![Deprecated](https://img.shields.io/badge/status-deprecated-red.svg) 14 | 15 | The Docusign SDK makes integrating Docusign into your apps and websites a seamless experience. 16 | 17 | ## Table of Contents 18 | - [The Official Docusign Maestro Ruby Client SDK (Deprecated)](#the-official-docusign-maestro-ruby-client-sdk-deprecated) 19 | - [Table of Contents](#table-of-contents) 20 | - [Introduction](#introduction) 21 | - [Installation](#installation) 22 | - [Version Information](#version-information) 23 | - [Requirements](#requirements) 24 | - [Compatibility](#compatibility) 25 | - [Installation via your application's Gemfile:](#installation-via-your-applications-gemfile) 26 | - [Manual Installation:](#manual-installation) 27 | - [SDK Dependencies](#sdk-dependencies) 28 | - [API Reference](#api-reference) 29 | - [Code examples](#code-examples) 30 | - [OAuth implementations](#oauth-implementations) 31 | - [Changelog](#changelog) 32 | - [Support](#support) 33 | - [License](#license) 34 | - [Additional resources](#additional-resources) 35 | 36 | 37 | ## Introduction 38 | Leverage the power of Docusign workflows. Enjoy greater flexibility to manage your agreements using your own code in concert with the Maestro Workflow Designer. 39 | 40 | 41 | ## Installation 42 | This client SDK is provided as open source, which enables you to customize its functionality to suit your particular use case. To do so, download or clone the repository. If the SDK’s given functionality meets your integration needs, or if you’re working through our [code examples](https://developers.docusign.com/docs/maestro-api/how-to/) from the [Docusign Developer Center](https://developers.docusign.com/), you merely need to install it by following the instructions below. 43 | 44 | 45 | ### Version Information 46 | - **API version**: 1.0.0 47 | - **Latest SDK version**: 3.0.0 48 | 49 | 50 | ## Requirements 51 | * Ruby 1.9+ 52 | * Free [developer account](https://go.docusign.com/o/sandbox/?postActivateUrl=https://developers.docusign.com/) 53 | 54 | 55 | ## Compatibility 56 | * Ruby 1.9+ 57 | 58 | 59 | ### Installation via your application's Gemfile: 60 | 1. In your application's Gemfile, add: 61 | `gem 'docusign_maestro'` 62 | 2. Open your preferred console. 63 | 3. In your project directory, execute the installer by typing: **bundle install** 64 | 65 | 66 | ### Manual Installation: 67 | 1. Open your preferred console. 68 | 2. In the console, type: **gem install docusign_maestro** 69 | 70 | 71 | ### SDK Dependencies 72 | This client has the following external dependencies: 73 | * Jwt v2.2.1 74 | * Json v2.1.0 75 | * addressable v2.7.0 76 | * Typhoeus v1.0.1 77 | 78 | 79 | ## API Reference 80 | You can refer to the API reference [here](https://developers.docusign.com/docs/maestro-api/reference/). 81 | 82 | 83 | ## Code examples 84 | Explore our GitHub repository for the [Launcher](https://github.com/docusign/code-examples-ruby/), a self-executing package housing code examples for the Maestro Ruby SDK. This package showcases several common use cases and their respective source files. Additionally, you can download a version preconfigured for your Docusign developer account from [Quickstart](https://developers.docusign.com/docs/esign-rest-api/quickstart/). These examples support both the [Authorization Code Grant](https://developers.docusign.com/platform/auth/authcode/) and [JSON Web Token (JWT)](https://developers.docusign.com/platform/auth/jwt/) authentication workflows. 85 | 86 | 87 | ## OAuth implementations 88 | For details regarding which type of OAuth grant will work best for your Docusign integration, see [Choose OAuth Type](https://developers.docusign.com/platform/auth/choose/) in the [Docusign Developer Center](https://developers.docusign.com/). 89 | 90 | For security purposes, Docusign recommends using the [Authorization Code Grant](https://developers.docusign.com/platform/auth/authcode/) flow. 91 | 92 | 93 | ## Changelog 94 | You can refer to the complete changelog [here](https://github.com/docusign/docusign-maestro-ruby-client/blob/master/CHANGELOG.md). 95 | 96 | 97 | ## Support 98 | Log issues against this client SDK through GitHub. You can also reach out to us through [Docusign Community](https://community.docusign.com/developer-59) and [Stack Overflow](https://stackoverflow.com/questions/tagged/docusignapi). 99 | 100 | 101 | ## License 102 | The Docusign Maestro Ruby Client SDK is licensed under the [MIT License](https://github.com/docusign/docusign-maestro-ruby-client/blob/master/LICENSE). 103 | 104 | 105 | ### Additional resources 106 | * [Docusign Developer Center](https://developers.docusign.com/) 107 | * [Docusign API on Twitter](https://twitter.com/docusignapi) 108 | * [Docusign For Developers on LinkedIn](https://www.linkedin.com/showcase/docusign-for-developers/) 109 | * [Docusign For Developers on YouTube](https://www.youtube.com/channel/UCJSJ2kMs_qeQotmw4-lX2NQ) -------------------------------------------------------------------------------- /lib/docusign_maestro/models/aow_uuid.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class AowUUID 16 | # Attribute mapping from ruby-style variable name to JSON key. 17 | def self.attribute_map 18 | { 19 | } 20 | end 21 | 22 | # Attribute type mapping. 23 | def self.swagger_types 24 | { 25 | } 26 | end 27 | 28 | # Initializes the object 29 | # @param [Hash] attributes Model attributes in the form of hash 30 | def initialize(attributes = {}) 31 | return unless attributes.is_a?(Hash) 32 | 33 | # convert string to symbol for hash key 34 | attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v } 35 | end 36 | 37 | # Show invalid properties with the reasons. Usually used together with valid? 38 | # @return Array for valid properties with the reasons 39 | def list_invalid_properties 40 | invalid_properties = Array.new 41 | invalid_properties 42 | end 43 | 44 | # Check to see if the all the properties in the model are valid 45 | # @return true if the model is valid 46 | def valid? 47 | true 48 | end 49 | 50 | # Checks equality by comparing each attribute. 51 | # @param [Object] Object to be compared 52 | def ==(o) 53 | return true if self.equal?(o) 54 | self.class == o.class 55 | end 56 | 57 | # @see the `==` method 58 | # @param [Object] Object to be compared 59 | def eql?(o) 60 | self == o 61 | end 62 | 63 | # Calculates hash code according to all attributes. 64 | # @return [Fixnum] Hash code 65 | def hash 66 | [].hash 67 | end 68 | 69 | # Builds the object from hash 70 | # @param [Hash] attributes Model attributes in the form of hash 71 | # @return [Object] Returns the model itself 72 | def build_from_hash(attributes) 73 | return nil unless attributes.is_a?(Hash) 74 | self.class.swagger_types.each_pair do |key, type| 75 | if type =~ /\AArray<(.*)>/i 76 | # check to ensure the input is an array given that the attribute 77 | # is documented as an array but the input is not 78 | if attributes[self.class.attribute_map[key]].is_a?(Array) 79 | self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) }) 80 | end 81 | elsif !attributes[self.class.attribute_map[key]].nil? 82 | self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]])) 83 | end # or else data not found in attributes(hash), not an issue as the data can be optional 84 | end 85 | 86 | self 87 | end 88 | 89 | # Deserializes the data based on type 90 | # @param string type Data type 91 | # @param string value Value to be deserialized 92 | # @return [Object] Deserialized data 93 | def _deserialize(type, value) 94 | case type.to_sym 95 | when :DateTime 96 | DateTime.parse(value) 97 | when :Date 98 | Date.parse(value) 99 | when :String 100 | value.to_s 101 | when :Integer 102 | value.to_i 103 | when :Float 104 | value.to_f 105 | when :BOOLEAN 106 | if value.to_s =~ /\A(true|t|yes|y|1)\z/i 107 | true 108 | else 109 | false 110 | end 111 | when :Object 112 | # generic object (usually a Hash), return directly 113 | value 114 | when /\AArray<(?.+)>\z/ 115 | inner_type = Regexp.last_match[:inner_type] 116 | value.map { |v| _deserialize(inner_type, v) } 117 | when /\AHash<(?.+?), (?.+)>\z/ 118 | k_type = Regexp.last_match[:k_type] 119 | v_type = Regexp.last_match[:v_type] 120 | {}.tap do |hash| 121 | value.each do |k, v| 122 | hash[_deserialize(k_type, k)] = _deserialize(v_type, v) 123 | end 124 | end 125 | else # model 126 | temp_model = DocuSign_Maestro.const_get(type).new 127 | temp_model.build_from_hash(value) 128 | end 129 | end 130 | 131 | # Returns the string representation of the object 132 | # @return [String] String presentation of the object 133 | def to_s 134 | to_hash.to_s 135 | end 136 | 137 | # to_body is an alias to to_hash (backward compatibility) 138 | # @return [Hash] Returns the object in the form of hash 139 | def to_body 140 | to_hash 141 | end 142 | 143 | # Returns the object in the form of hash 144 | # @return [Hash] Returns the object in the form of hash 145 | def to_hash 146 | hash = {} 147 | self.class.attribute_map.each_pair do |attr, param| 148 | value = self.send(attr) 149 | next if value.nil? 150 | hash[param] = _to_hash(value) 151 | end 152 | hash 153 | end 154 | 155 | # Outputs non-array value in the form of hash 156 | # For object, use to_hash. Otherwise, just return the value 157 | # @param [Object] value Any valid value 158 | # @return [Hash] Returns the value in the form of hash 159 | def _to_hash(value) 160 | if value.is_a?(Array) 161 | value.compact.map { |v| _to_hash(v) } 162 | elsif value.is_a?(Hash) 163 | {}.tap do |hash| 164 | value.each { |k, v| hash[k] = _to_hash(v) } 165 | end 166 | elsif value.respond_to? :to_hash 167 | value.to_hash 168 | else 169 | value 170 | end 171 | end 172 | 173 | end 174 | end 175 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/aow_uuid_string.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class AowUUIDString 16 | # Attribute mapping from ruby-style variable name to JSON key. 17 | def self.attribute_map 18 | { 19 | } 20 | end 21 | 22 | # Attribute type mapping. 23 | def self.swagger_types 24 | { 25 | } 26 | end 27 | 28 | # Initializes the object 29 | # @param [Hash] attributes Model attributes in the form of hash 30 | def initialize(attributes = {}) 31 | return unless attributes.is_a?(Hash) 32 | 33 | # convert string to symbol for hash key 34 | attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v } 35 | end 36 | 37 | # Show invalid properties with the reasons. Usually used together with valid? 38 | # @return Array for valid properties with the reasons 39 | def list_invalid_properties 40 | invalid_properties = Array.new 41 | invalid_properties 42 | end 43 | 44 | # Check to see if the all the properties in the model are valid 45 | # @return true if the model is valid 46 | def valid? 47 | true 48 | end 49 | 50 | # Checks equality by comparing each attribute. 51 | # @param [Object] Object to be compared 52 | def ==(o) 53 | return true if self.equal?(o) 54 | self.class == o.class 55 | end 56 | 57 | # @see the `==` method 58 | # @param [Object] Object to be compared 59 | def eql?(o) 60 | self == o 61 | end 62 | 63 | # Calculates hash code according to all attributes. 64 | # @return [Fixnum] Hash code 65 | def hash 66 | [].hash 67 | end 68 | 69 | # Builds the object from hash 70 | # @param [Hash] attributes Model attributes in the form of hash 71 | # @return [Object] Returns the model itself 72 | def build_from_hash(attributes) 73 | return nil unless attributes.is_a?(Hash) 74 | self.class.swagger_types.each_pair do |key, type| 75 | if type =~ /\AArray<(.*)>/i 76 | # check to ensure the input is an array given that the attribute 77 | # is documented as an array but the input is not 78 | if attributes[self.class.attribute_map[key]].is_a?(Array) 79 | self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) }) 80 | end 81 | elsif !attributes[self.class.attribute_map[key]].nil? 82 | self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]])) 83 | end # or else data not found in attributes(hash), not an issue as the data can be optional 84 | end 85 | 86 | self 87 | end 88 | 89 | # Deserializes the data based on type 90 | # @param string type Data type 91 | # @param string value Value to be deserialized 92 | # @return [Object] Deserialized data 93 | def _deserialize(type, value) 94 | case type.to_sym 95 | when :DateTime 96 | DateTime.parse(value) 97 | when :Date 98 | Date.parse(value) 99 | when :String 100 | value.to_s 101 | when :Integer 102 | value.to_i 103 | when :Float 104 | value.to_f 105 | when :BOOLEAN 106 | if value.to_s =~ /\A(true|t|yes|y|1)\z/i 107 | true 108 | else 109 | false 110 | end 111 | when :Object 112 | # generic object (usually a Hash), return directly 113 | value 114 | when /\AArray<(?.+)>\z/ 115 | inner_type = Regexp.last_match[:inner_type] 116 | value.map { |v| _deserialize(inner_type, v) } 117 | when /\AHash<(?.+?), (?.+)>\z/ 118 | k_type = Regexp.last_match[:k_type] 119 | v_type = Regexp.last_match[:v_type] 120 | {}.tap do |hash| 121 | value.each do |k, v| 122 | hash[_deserialize(k_type, k)] = _deserialize(v_type, v) 123 | end 124 | end 125 | else # model 126 | temp_model = DocuSign_Maestro.const_get(type).new 127 | temp_model.build_from_hash(value) 128 | end 129 | end 130 | 131 | # Returns the string representation of the object 132 | # @return [String] String presentation of the object 133 | def to_s 134 | to_hash.to_s 135 | end 136 | 137 | # to_body is an alias to to_hash (backward compatibility) 138 | # @return [Hash] Returns the object in the form of hash 139 | def to_body 140 | to_hash 141 | end 142 | 143 | # Returns the object in the form of hash 144 | # @return [Hash] Returns the object in the form of hash 145 | def to_hash 146 | hash = {} 147 | self.class.attribute_map.each_pair do |attr, param| 148 | value = self.send(attr) 149 | next if value.nil? 150 | hash[param] = _to_hash(value) 151 | end 152 | hash 153 | end 154 | 155 | # Outputs non-array value in the form of hash 156 | # For object, use to_hash. Otherwise, just return the value 157 | # @param [Object] value Any valid value 158 | # @return [Hash] Returns the value in the form of hash 159 | def _to_hash(value) 160 | if value.is_a?(Array) 161 | value.compact.map { |v| _to_hash(v) } 162 | elsif value.is_a?(Hash) 163 | {}.tap do |hash| 164 | value.each { |k, v| hash[k] = _to_hash(v) } 165 | end 166 | elsif value.respond_to? :to_hash 167 | value.to_hash 168 | else 169 | value 170 | end 171 | end 172 | 173 | end 174 | end 175 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/record_to_never.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class RecordToNever 16 | # Attribute mapping from ruby-style variable name to JSON key. 17 | def self.attribute_map 18 | { 19 | } 20 | end 21 | 22 | # Attribute type mapping. 23 | def self.swagger_types 24 | { 25 | } 26 | end 27 | 28 | # Initializes the object 29 | # @param [Hash] attributes Model attributes in the form of hash 30 | def initialize(attributes = {}) 31 | return unless attributes.is_a?(Hash) 32 | 33 | # convert string to symbol for hash key 34 | attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v } 35 | end 36 | 37 | # Show invalid properties with the reasons. Usually used together with valid? 38 | # @return Array for valid properties with the reasons 39 | def list_invalid_properties 40 | invalid_properties = Array.new 41 | invalid_properties 42 | end 43 | 44 | # Check to see if the all the properties in the model are valid 45 | # @return true if the model is valid 46 | def valid? 47 | true 48 | end 49 | 50 | # Checks equality by comparing each attribute. 51 | # @param [Object] Object to be compared 52 | def ==(o) 53 | return true if self.equal?(o) 54 | self.class == o.class 55 | end 56 | 57 | # @see the `==` method 58 | # @param [Object] Object to be compared 59 | def eql?(o) 60 | self == o 61 | end 62 | 63 | # Calculates hash code according to all attributes. 64 | # @return [Fixnum] Hash code 65 | def hash 66 | [].hash 67 | end 68 | 69 | # Builds the object from hash 70 | # @param [Hash] attributes Model attributes in the form of hash 71 | # @return [Object] Returns the model itself 72 | def build_from_hash(attributes) 73 | return nil unless attributes.is_a?(Hash) 74 | self.class.swagger_types.each_pair do |key, type| 75 | if type =~ /\AArray<(.*)>/i 76 | # check to ensure the input is an array given that the attribute 77 | # is documented as an array but the input is not 78 | if attributes[self.class.attribute_map[key]].is_a?(Array) 79 | self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) }) 80 | end 81 | elsif !attributes[self.class.attribute_map[key]].nil? 82 | self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]])) 83 | end # or else data not found in attributes(hash), not an issue as the data can be optional 84 | end 85 | 86 | self 87 | end 88 | 89 | # Deserializes the data based on type 90 | # @param string type Data type 91 | # @param string value Value to be deserialized 92 | # @return [Object] Deserialized data 93 | def _deserialize(type, value) 94 | case type.to_sym 95 | when :DateTime 96 | DateTime.parse(value) 97 | when :Date 98 | Date.parse(value) 99 | when :String 100 | value.to_s 101 | when :Integer 102 | value.to_i 103 | when :Float 104 | value.to_f 105 | when :BOOLEAN 106 | if value.to_s =~ /\A(true|t|yes|y|1)\z/i 107 | true 108 | else 109 | false 110 | end 111 | when :Object 112 | # generic object (usually a Hash), return directly 113 | value 114 | when /\AArray<(?.+)>\z/ 115 | inner_type = Regexp.last_match[:inner_type] 116 | value.map { |v| _deserialize(inner_type, v) } 117 | when /\AHash<(?.+?), (?.+)>\z/ 118 | k_type = Regexp.last_match[:k_type] 119 | v_type = Regexp.last_match[:v_type] 120 | {}.tap do |hash| 121 | value.each do |k, v| 122 | hash[_deserialize(k_type, k)] = _deserialize(v_type, v) 123 | end 124 | end 125 | else # model 126 | temp_model = DocuSign_Maestro.const_get(type).new 127 | temp_model.build_from_hash(value) 128 | end 129 | end 130 | 131 | # Returns the string representation of the object 132 | # @return [String] String presentation of the object 133 | def to_s 134 | to_hash.to_s 135 | end 136 | 137 | # to_body is an alias to to_hash (backward compatibility) 138 | # @return [Hash] Returns the object in the form of hash 139 | def to_body 140 | to_hash 141 | end 142 | 143 | # Returns the object in the form of hash 144 | # @return [Hash] Returns the object in the form of hash 145 | def to_hash 146 | hash = {} 147 | self.class.attribute_map.each_pair do |attr, param| 148 | value = self.send(attr) 149 | next if value.nil? 150 | hash[param] = _to_hash(value) 151 | end 152 | hash 153 | end 154 | 155 | # Outputs non-array value in the form of hash 156 | # For object, use to_hash. Otherwise, just return the value 157 | # @param [Object] value Any valid value 158 | # @return [Hash] Returns the value in the form of hash 159 | def _to_hash(value) 160 | if value.is_a?(Array) 161 | value.compact.map { |v| _to_hash(v) } 162 | elsif value.is_a?(Hash) 163 | {}.tap do |hash| 164 | value.each { |k, v| hash[k] = _to_hash(v) } 165 | end 166 | elsif value.respond_to? :to_hash 167 | value.to_hash 168 | else 169 | value 170 | end 171 | end 172 | 173 | end 174 | end 175 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/version_string.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class VersionString 16 | # Attribute mapping from ruby-style variable name to JSON key. 17 | def self.attribute_map 18 | { 19 | } 20 | end 21 | 22 | # Attribute type mapping. 23 | def self.swagger_types 24 | { 25 | } 26 | end 27 | 28 | # Initializes the object 29 | # @param [Hash] attributes Model attributes in the form of hash 30 | def initialize(attributes = {}) 31 | return unless attributes.is_a?(Hash) 32 | 33 | # convert string to symbol for hash key 34 | attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v } 35 | end 36 | 37 | # Show invalid properties with the reasons. Usually used together with valid? 38 | # @return Array for valid properties with the reasons 39 | def list_invalid_properties 40 | invalid_properties = Array.new 41 | invalid_properties 42 | end 43 | 44 | # Check to see if the all the properties in the model are valid 45 | # @return true if the model is valid 46 | def valid? 47 | true 48 | end 49 | 50 | # Checks equality by comparing each attribute. 51 | # @param [Object] Object to be compared 52 | def ==(o) 53 | return true if self.equal?(o) 54 | self.class == o.class 55 | end 56 | 57 | # @see the `==` method 58 | # @param [Object] Object to be compared 59 | def eql?(o) 60 | self == o 61 | end 62 | 63 | # Calculates hash code according to all attributes. 64 | # @return [Fixnum] Hash code 65 | def hash 66 | [].hash 67 | end 68 | 69 | # Builds the object from hash 70 | # @param [Hash] attributes Model attributes in the form of hash 71 | # @return [Object] Returns the model itself 72 | def build_from_hash(attributes) 73 | return nil unless attributes.is_a?(Hash) 74 | self.class.swagger_types.each_pair do |key, type| 75 | if type =~ /\AArray<(.*)>/i 76 | # check to ensure the input is an array given that the attribute 77 | # is documented as an array but the input is not 78 | if attributes[self.class.attribute_map[key]].is_a?(Array) 79 | self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) }) 80 | end 81 | elsif !attributes[self.class.attribute_map[key]].nil? 82 | self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]])) 83 | end # or else data not found in attributes(hash), not an issue as the data can be optional 84 | end 85 | 86 | self 87 | end 88 | 89 | # Deserializes the data based on type 90 | # @param string type Data type 91 | # @param string value Value to be deserialized 92 | # @return [Object] Deserialized data 93 | def _deserialize(type, value) 94 | case type.to_sym 95 | when :DateTime 96 | DateTime.parse(value) 97 | when :Date 98 | Date.parse(value) 99 | when :String 100 | value.to_s 101 | when :Integer 102 | value.to_i 103 | when :Float 104 | value.to_f 105 | when :BOOLEAN 106 | if value.to_s =~ /\A(true|t|yes|y|1)\z/i 107 | true 108 | else 109 | false 110 | end 111 | when :Object 112 | # generic object (usually a Hash), return directly 113 | value 114 | when /\AArray<(?.+)>\z/ 115 | inner_type = Regexp.last_match[:inner_type] 116 | value.map { |v| _deserialize(inner_type, v) } 117 | when /\AHash<(?.+?), (?.+)>\z/ 118 | k_type = Regexp.last_match[:k_type] 119 | v_type = Regexp.last_match[:v_type] 120 | {}.tap do |hash| 121 | value.each do |k, v| 122 | hash[_deserialize(k_type, k)] = _deserialize(v_type, v) 123 | end 124 | end 125 | else # model 126 | temp_model = DocuSign_Maestro.const_get(type).new 127 | temp_model.build_from_hash(value) 128 | end 129 | end 130 | 131 | # Returns the string representation of the object 132 | # @return [String] String presentation of the object 133 | def to_s 134 | to_hash.to_s 135 | end 136 | 137 | # to_body is an alias to to_hash (backward compatibility) 138 | # @return [Hash] Returns the object in the form of hash 139 | def to_body 140 | to_hash 141 | end 142 | 143 | # Returns the object in the form of hash 144 | # @return [Hash] Returns the object in the form of hash 145 | def to_hash 146 | hash = {} 147 | self.class.attribute_map.each_pair do |attr, param| 148 | value = self.send(attr) 149 | next if value.nil? 150 | hash[param] = _to_hash(value) 151 | end 152 | hash 153 | end 154 | 155 | # Outputs non-array value in the form of hash 156 | # For object, use to_hash. Otherwise, just return the value 157 | # @param [Object] value Any valid value 158 | # @return [Hash] Returns the value in the form of hash 159 | def _to_hash(value) 160 | if value.is_a?(Array) 161 | value.compact.map { |v| _to_hash(v) } 162 | elsif value.is_a?(Hash) 163 | {}.tap do |hash| 164 | value.each { |k, v| hash[k] = _to_hash(v) } 165 | end 166 | elsif value.respond_to? :to_hash 167 | value.to_hash 168 | else 169 | value 170 | end 171 | end 172 | 173 | end 174 | end 175 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/last_deployed_id.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class LastDeployedId 16 | # Attribute mapping from ruby-style variable name to JSON key. 17 | def self.attribute_map 18 | { 19 | } 20 | end 21 | 22 | # Attribute type mapping. 23 | def self.swagger_types 24 | { 25 | } 26 | end 27 | 28 | # Initializes the object 29 | # @param [Hash] attributes Model attributes in the form of hash 30 | def initialize(attributes = {}) 31 | return unless attributes.is_a?(Hash) 32 | 33 | # convert string to symbol for hash key 34 | attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v } 35 | end 36 | 37 | # Show invalid properties with the reasons. Usually used together with valid? 38 | # @return Array for valid properties with the reasons 39 | def list_invalid_properties 40 | invalid_properties = Array.new 41 | invalid_properties 42 | end 43 | 44 | # Check to see if the all the properties in the model are valid 45 | # @return true if the model is valid 46 | def valid? 47 | true 48 | end 49 | 50 | # Checks equality by comparing each attribute. 51 | # @param [Object] Object to be compared 52 | def ==(o) 53 | return true if self.equal?(o) 54 | self.class == o.class 55 | end 56 | 57 | # @see the `==` method 58 | # @param [Object] Object to be compared 59 | def eql?(o) 60 | self == o 61 | end 62 | 63 | # Calculates hash code according to all attributes. 64 | # @return [Fixnum] Hash code 65 | def hash 66 | [].hash 67 | end 68 | 69 | # Builds the object from hash 70 | # @param [Hash] attributes Model attributes in the form of hash 71 | # @return [Object] Returns the model itself 72 | def build_from_hash(attributes) 73 | return nil unless attributes.is_a?(Hash) 74 | self.class.swagger_types.each_pair do |key, type| 75 | if type =~ /\AArray<(.*)>/i 76 | # check to ensure the input is an array given that the attribute 77 | # is documented as an array but the input is not 78 | if attributes[self.class.attribute_map[key]].is_a?(Array) 79 | self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) }) 80 | end 81 | elsif !attributes[self.class.attribute_map[key]].nil? 82 | self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]])) 83 | end # or else data not found in attributes(hash), not an issue as the data can be optional 84 | end 85 | 86 | self 87 | end 88 | 89 | # Deserializes the data based on type 90 | # @param string type Data type 91 | # @param string value Value to be deserialized 92 | # @return [Object] Deserialized data 93 | def _deserialize(type, value) 94 | case type.to_sym 95 | when :DateTime 96 | DateTime.parse(value) 97 | when :Date 98 | Date.parse(value) 99 | when :String 100 | value.to_s 101 | when :Integer 102 | value.to_i 103 | when :Float 104 | value.to_f 105 | when :BOOLEAN 106 | if value.to_s =~ /\A(true|t|yes|y|1)\z/i 107 | true 108 | else 109 | false 110 | end 111 | when :Object 112 | # generic object (usually a Hash), return directly 113 | value 114 | when /\AArray<(?.+)>\z/ 115 | inner_type = Regexp.last_match[:inner_type] 116 | value.map { |v| _deserialize(inner_type, v) } 117 | when /\AHash<(?.+?), (?.+)>\z/ 118 | k_type = Regexp.last_match[:k_type] 119 | v_type = Regexp.last_match[:v_type] 120 | {}.tap do |hash| 121 | value.each do |k, v| 122 | hash[_deserialize(k_type, k)] = _deserialize(v_type, v) 123 | end 124 | end 125 | else # model 126 | temp_model = DocuSign_Maestro.const_get(type).new 127 | temp_model.build_from_hash(value) 128 | end 129 | end 130 | 131 | # Returns the string representation of the object 132 | # @return [String] String presentation of the object 133 | def to_s 134 | to_hash.to_s 135 | end 136 | 137 | # to_body is an alias to to_hash (backward compatibility) 138 | # @return [Hash] Returns the object in the form of hash 139 | def to_body 140 | to_hash 141 | end 142 | 143 | # Returns the object in the form of hash 144 | # @return [Hash] Returns the object in the form of hash 145 | def to_hash 146 | hash = {} 147 | self.class.attribute_map.each_pair do |attr, param| 148 | value = self.send(attr) 149 | next if value.nil? 150 | hash[param] = _to_hash(value) 151 | end 152 | hash 153 | end 154 | 155 | # Outputs non-array value in the form of hash 156 | # For object, use to_hash. Otherwise, just return the value 157 | # @param [Object] value Any valid value 158 | # @return [Hash] Returns the value in the form of hash 159 | def _to_hash(value) 160 | if value.is_a?(Array) 161 | value.compact.map { |v| _to_hash(v) } 162 | elsif value.is_a?(Hash) 163 | {}.tap do |hash| 164 | value.each { |k, v| hash[k] = _to_hash(v) } 165 | end 166 | elsif value.respond_to? :to_hash 167 | value.to_hash 168 | else 169 | value 170 | end 171 | end 172 | 173 | end 174 | end 175 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/e_sign_locale_policy.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class ESignLocalePolicy 16 | # Attribute mapping from ruby-style variable name to JSON key. 17 | def self.attribute_map 18 | { 19 | } 20 | end 21 | 22 | # Attribute type mapping. 23 | def self.swagger_types 24 | { 25 | } 26 | end 27 | 28 | # Initializes the object 29 | # @param [Hash] attributes Model attributes in the form of hash 30 | def initialize(attributes = {}) 31 | return unless attributes.is_a?(Hash) 32 | 33 | # convert string to symbol for hash key 34 | attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v } 35 | end 36 | 37 | # Show invalid properties with the reasons. Usually used together with valid? 38 | # @return Array for valid properties with the reasons 39 | def list_invalid_properties 40 | invalid_properties = Array.new 41 | invalid_properties 42 | end 43 | 44 | # Check to see if the all the properties in the model are valid 45 | # @return true if the model is valid 46 | def valid? 47 | true 48 | end 49 | 50 | # Checks equality by comparing each attribute. 51 | # @param [Object] Object to be compared 52 | def ==(o) 53 | return true if self.equal?(o) 54 | self.class == o.class 55 | end 56 | 57 | # @see the `==` method 58 | # @param [Object] Object to be compared 59 | def eql?(o) 60 | self == o 61 | end 62 | 63 | # Calculates hash code according to all attributes. 64 | # @return [Fixnum] Hash code 65 | def hash 66 | [].hash 67 | end 68 | 69 | # Builds the object from hash 70 | # @param [Hash] attributes Model attributes in the form of hash 71 | # @return [Object] Returns the model itself 72 | def build_from_hash(attributes) 73 | return nil unless attributes.is_a?(Hash) 74 | self.class.swagger_types.each_pair do |key, type| 75 | if type =~ /\AArray<(.*)>/i 76 | # check to ensure the input is an array given that the attribute 77 | # is documented as an array but the input is not 78 | if attributes[self.class.attribute_map[key]].is_a?(Array) 79 | self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) }) 80 | end 81 | elsif !attributes[self.class.attribute_map[key]].nil? 82 | self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]])) 83 | end # or else data not found in attributes(hash), not an issue as the data can be optional 84 | end 85 | 86 | self 87 | end 88 | 89 | # Deserializes the data based on type 90 | # @param string type Data type 91 | # @param string value Value to be deserialized 92 | # @return [Object] Deserialized data 93 | def _deserialize(type, value) 94 | case type.to_sym 95 | when :DateTime 96 | DateTime.parse(value) 97 | when :Date 98 | Date.parse(value) 99 | when :String 100 | value.to_s 101 | when :Integer 102 | value.to_i 103 | when :Float 104 | value.to_f 105 | when :BOOLEAN 106 | if value.to_s =~ /\A(true|t|yes|y|1)\z/i 107 | true 108 | else 109 | false 110 | end 111 | when :Object 112 | # generic object (usually a Hash), return directly 113 | value 114 | when /\AArray<(?.+)>\z/ 115 | inner_type = Regexp.last_match[:inner_type] 116 | value.map { |v| _deserialize(inner_type, v) } 117 | when /\AHash<(?.+?), (?.+)>\z/ 118 | k_type = Regexp.last_match[:k_type] 119 | v_type = Regexp.last_match[:v_type] 120 | {}.tap do |hash| 121 | value.each do |k, v| 122 | hash[_deserialize(k_type, k)] = _deserialize(v_type, v) 123 | end 124 | end 125 | else # model 126 | temp_model = DocuSign_Maestro.const_get(type).new 127 | temp_model.build_from_hash(value) 128 | end 129 | end 130 | 131 | # Returns the string representation of the object 132 | # @return [String] String presentation of the object 133 | def to_s 134 | to_hash.to_s 135 | end 136 | 137 | # to_body is an alias to to_hash (backward compatibility) 138 | # @return [Hash] Returns the object in the form of hash 139 | def to_body 140 | to_hash 141 | end 142 | 143 | # Returns the object in the form of hash 144 | # @return [Hash] Returns the object in the form of hash 145 | def to_hash 146 | hash = {} 147 | self.class.attribute_map.each_pair do |attr, param| 148 | value = self.send(attr) 149 | next if value.nil? 150 | hash[param] = _to_hash(value) 151 | end 152 | hash 153 | end 154 | 155 | # Outputs non-array value in the form of hash 156 | # For object, use to_hash. Otherwise, just return the value 157 | # @param [Object] value Any valid value 158 | # @return [Hash] Returns the value in the form of hash 159 | def _to_hash(value) 160 | if value.is_a?(Array) 161 | value.compact.map { |v| _to_hash(v) } 162 | elsif value.is_a?(Hash) 163 | {}.tap do |hash| 164 | value.each { |k, v| hash[k] = _to_hash(v) } 165 | end 166 | elsif value.respond_to? :to_hash 167 | value.to_hash 168 | else 169 | value 170 | end 171 | end 172 | 173 | end 174 | end 175 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/workflow_date_time.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class WorkflowDateTime 16 | # Attribute mapping from ruby-style variable name to JSON key. 17 | def self.attribute_map 18 | { 19 | } 20 | end 21 | 22 | # Attribute type mapping. 23 | def self.swagger_types 24 | { 25 | } 26 | end 27 | 28 | # Initializes the object 29 | # @param [Hash] attributes Model attributes in the form of hash 30 | def initialize(attributes = {}) 31 | return unless attributes.is_a?(Hash) 32 | 33 | # convert string to symbol for hash key 34 | attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v } 35 | end 36 | 37 | # Show invalid properties with the reasons. Usually used together with valid? 38 | # @return Array for valid properties with the reasons 39 | def list_invalid_properties 40 | invalid_properties = Array.new 41 | invalid_properties 42 | end 43 | 44 | # Check to see if the all the properties in the model are valid 45 | # @return true if the model is valid 46 | def valid? 47 | true 48 | end 49 | 50 | # Checks equality by comparing each attribute. 51 | # @param [Object] Object to be compared 52 | def ==(o) 53 | return true if self.equal?(o) 54 | self.class == o.class 55 | end 56 | 57 | # @see the `==` method 58 | # @param [Object] Object to be compared 59 | def eql?(o) 60 | self == o 61 | end 62 | 63 | # Calculates hash code according to all attributes. 64 | # @return [Fixnum] Hash code 65 | def hash 66 | [].hash 67 | end 68 | 69 | # Builds the object from hash 70 | # @param [Hash] attributes Model attributes in the form of hash 71 | # @return [Object] Returns the model itself 72 | def build_from_hash(attributes) 73 | return nil unless attributes.is_a?(Hash) 74 | self.class.swagger_types.each_pair do |key, type| 75 | if type =~ /\AArray<(.*)>/i 76 | # check to ensure the input is an array given that the attribute 77 | # is documented as an array but the input is not 78 | if attributes[self.class.attribute_map[key]].is_a?(Array) 79 | self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) }) 80 | end 81 | elsif !attributes[self.class.attribute_map[key]].nil? 82 | self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]])) 83 | end # or else data not found in attributes(hash), not an issue as the data can be optional 84 | end 85 | 86 | self 87 | end 88 | 89 | # Deserializes the data based on type 90 | # @param string type Data type 91 | # @param string value Value to be deserialized 92 | # @return [Object] Deserialized data 93 | def _deserialize(type, value) 94 | case type.to_sym 95 | when :DateTime 96 | DateTime.parse(value) 97 | when :Date 98 | Date.parse(value) 99 | when :String 100 | value.to_s 101 | when :Integer 102 | value.to_i 103 | when :Float 104 | value.to_f 105 | when :BOOLEAN 106 | if value.to_s =~ /\A(true|t|yes|y|1)\z/i 107 | true 108 | else 109 | false 110 | end 111 | when :Object 112 | # generic object (usually a Hash), return directly 113 | value 114 | when /\AArray<(?.+)>\z/ 115 | inner_type = Regexp.last_match[:inner_type] 116 | value.map { |v| _deserialize(inner_type, v) } 117 | when /\AHash<(?.+?), (?.+)>\z/ 118 | k_type = Regexp.last_match[:k_type] 119 | v_type = Regexp.last_match[:v_type] 120 | {}.tap do |hash| 121 | value.each do |k, v| 122 | hash[_deserialize(k_type, k)] = _deserialize(v_type, v) 123 | end 124 | end 125 | else # model 126 | temp_model = DocuSign_Maestro.const_get(type).new 127 | temp_model.build_from_hash(value) 128 | end 129 | end 130 | 131 | # Returns the string representation of the object 132 | # @return [String] String presentation of the object 133 | def to_s 134 | to_hash.to_s 135 | end 136 | 137 | # to_body is an alias to to_hash (backward compatibility) 138 | # @return [Hash] Returns the object in the form of hash 139 | def to_body 140 | to_hash 141 | end 142 | 143 | # Returns the object in the form of hash 144 | # @return [Hash] Returns the object in the form of hash 145 | def to_hash 146 | hash = {} 147 | self.class.attribute_map.each_pair do |attr, param| 148 | value = self.send(attr) 149 | next if value.nil? 150 | hash[param] = _to_hash(value) 151 | end 152 | hash 153 | end 154 | 155 | # Outputs non-array value in the form of hash 156 | # For object, use to_hash. Otherwise, just return the value 157 | # @param [Object] value Any valid value 158 | # @return [Hash] Returns the value in the form of hash 159 | def _to_hash(value) 160 | if value.is_a?(Array) 161 | value.compact.map { |v| _to_hash(v) } 162 | elsif value.is_a?(Hash) 163 | {}.tap do |hash| 164 | value.each { |k, v| hash[k] = _to_hash(v) } 165 | end 166 | elsif value.respond_to? :to_hash 167 | value.to_hash 168 | else 169 | value 170 | end 171 | end 172 | 173 | end 174 | end 175 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/account_id.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | # Account Id 16 | class AccountId 17 | # Attribute mapping from ruby-style variable name to JSON key. 18 | def self.attribute_map 19 | { 20 | } 21 | end 22 | 23 | # Attribute type mapping. 24 | def self.swagger_types 25 | { 26 | } 27 | end 28 | 29 | # Initializes the object 30 | # @param [Hash] attributes Model attributes in the form of hash 31 | def initialize(attributes = {}) 32 | return unless attributes.is_a?(Hash) 33 | 34 | # convert string to symbol for hash key 35 | attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v } 36 | end 37 | 38 | # Show invalid properties with the reasons. Usually used together with valid? 39 | # @return Array for valid properties with the reasons 40 | def list_invalid_properties 41 | invalid_properties = Array.new 42 | invalid_properties 43 | end 44 | 45 | # Check to see if the all the properties in the model are valid 46 | # @return true if the model is valid 47 | def valid? 48 | true 49 | end 50 | 51 | # Checks equality by comparing each attribute. 52 | # @param [Object] Object to be compared 53 | def ==(o) 54 | return true if self.equal?(o) 55 | self.class == o.class 56 | end 57 | 58 | # @see the `==` method 59 | # @param [Object] Object to be compared 60 | def eql?(o) 61 | self == o 62 | end 63 | 64 | # Calculates hash code according to all attributes. 65 | # @return [Fixnum] Hash code 66 | def hash 67 | [].hash 68 | end 69 | 70 | # Builds the object from hash 71 | # @param [Hash] attributes Model attributes in the form of hash 72 | # @return [Object] Returns the model itself 73 | def build_from_hash(attributes) 74 | return nil unless attributes.is_a?(Hash) 75 | self.class.swagger_types.each_pair do |key, type| 76 | if type =~ /\AArray<(.*)>/i 77 | # check to ensure the input is an array given that the attribute 78 | # is documented as an array but the input is not 79 | if attributes[self.class.attribute_map[key]].is_a?(Array) 80 | self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) }) 81 | end 82 | elsif !attributes[self.class.attribute_map[key]].nil? 83 | self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]])) 84 | end # or else data not found in attributes(hash), not an issue as the data can be optional 85 | end 86 | 87 | self 88 | end 89 | 90 | # Deserializes the data based on type 91 | # @param string type Data type 92 | # @param string value Value to be deserialized 93 | # @return [Object] Deserialized data 94 | def _deserialize(type, value) 95 | case type.to_sym 96 | when :DateTime 97 | DateTime.parse(value) 98 | when :Date 99 | Date.parse(value) 100 | when :String 101 | value.to_s 102 | when :Integer 103 | value.to_i 104 | when :Float 105 | value.to_f 106 | when :BOOLEAN 107 | if value.to_s =~ /\A(true|t|yes|y|1)\z/i 108 | true 109 | else 110 | false 111 | end 112 | when :Object 113 | # generic object (usually a Hash), return directly 114 | value 115 | when /\AArray<(?.+)>\z/ 116 | inner_type = Regexp.last_match[:inner_type] 117 | value.map { |v| _deserialize(inner_type, v) } 118 | when /\AHash<(?.+?), (?.+)>\z/ 119 | k_type = Regexp.last_match[:k_type] 120 | v_type = Regexp.last_match[:v_type] 121 | {}.tap do |hash| 122 | value.each do |k, v| 123 | hash[_deserialize(k_type, k)] = _deserialize(v_type, v) 124 | end 125 | end 126 | else # model 127 | temp_model = DocuSign_Maestro.const_get(type).new 128 | temp_model.build_from_hash(value) 129 | end 130 | end 131 | 132 | # Returns the string representation of the object 133 | # @return [String] String presentation of the object 134 | def to_s 135 | to_hash.to_s 136 | end 137 | 138 | # to_body is an alias to to_hash (backward compatibility) 139 | # @return [Hash] Returns the object in the form of hash 140 | def to_body 141 | to_hash 142 | end 143 | 144 | # Returns the object in the form of hash 145 | # @return [Hash] Returns the object in the form of hash 146 | def to_hash 147 | hash = {} 148 | self.class.attribute_map.each_pair do |attr, param| 149 | value = self.send(attr) 150 | next if value.nil? 151 | hash[param] = _to_hash(value) 152 | end 153 | hash 154 | end 155 | 156 | # Outputs non-array value in the form of hash 157 | # For object, use to_hash. Otherwise, just return the value 158 | # @param [Object] value Any valid value 159 | # @return [Hash] Returns the value in the form of hash 160 | def _to_hash(value) 161 | if value.is_a?(Array) 162 | value.compact.map { |v| _to_hash(v) } 163 | elsif value.is_a?(Hash) 164 | {}.tap do |hash| 165 | value.each { |k, v| hash[k] = _to_hash(v) } 166 | end 167 | elsif value.respond_to? :to_hash 168 | value.to_hash 169 | else 170 | value 171 | end 172 | end 173 | 174 | end 175 | end 176 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/record_string_boolean.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class RecordStringBoolean 16 | # Attribute mapping from ruby-style variable name to JSON key. 17 | def self.attribute_map 18 | { 19 | } 20 | end 21 | 22 | # Attribute type mapping. 23 | def self.swagger_types 24 | { 25 | } 26 | end 27 | 28 | # Initializes the object 29 | # @param [Hash] attributes Model attributes in the form of hash 30 | def initialize(attributes = {}) 31 | return unless attributes.is_a?(Hash) 32 | 33 | # convert string to symbol for hash key 34 | attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v } 35 | end 36 | 37 | # Show invalid properties with the reasons. Usually used together with valid? 38 | # @return Array for valid properties with the reasons 39 | def list_invalid_properties 40 | invalid_properties = Array.new 41 | invalid_properties 42 | end 43 | 44 | # Check to see if the all the properties in the model are valid 45 | # @return true if the model is valid 46 | def valid? 47 | true 48 | end 49 | 50 | # Checks equality by comparing each attribute. 51 | # @param [Object] Object to be compared 52 | def ==(o) 53 | return true if self.equal?(o) 54 | self.class == o.class 55 | end 56 | 57 | # @see the `==` method 58 | # @param [Object] Object to be compared 59 | def eql?(o) 60 | self == o 61 | end 62 | 63 | # Calculates hash code according to all attributes. 64 | # @return [Fixnum] Hash code 65 | def hash 66 | [].hash 67 | end 68 | 69 | # Builds the object from hash 70 | # @param [Hash] attributes Model attributes in the form of hash 71 | # @return [Object] Returns the model itself 72 | def build_from_hash(attributes) 73 | return nil unless attributes.is_a?(Hash) 74 | self.class.swagger_types.each_pair do |key, type| 75 | if type =~ /\AArray<(.*)>/i 76 | # check to ensure the input is an array given that the attribute 77 | # is documented as an array but the input is not 78 | if attributes[self.class.attribute_map[key]].is_a?(Array) 79 | self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) }) 80 | end 81 | elsif !attributes[self.class.attribute_map[key]].nil? 82 | self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]])) 83 | end # or else data not found in attributes(hash), not an issue as the data can be optional 84 | end 85 | 86 | self 87 | end 88 | 89 | # Deserializes the data based on type 90 | # @param string type Data type 91 | # @param string value Value to be deserialized 92 | # @return [Object] Deserialized data 93 | def _deserialize(type, value) 94 | case type.to_sym 95 | when :DateTime 96 | DateTime.parse(value) 97 | when :Date 98 | Date.parse(value) 99 | when :String 100 | value.to_s 101 | when :Integer 102 | value.to_i 103 | when :Float 104 | value.to_f 105 | when :BOOLEAN 106 | if value.to_s =~ /\A(true|t|yes|y|1)\z/i 107 | true 108 | else 109 | false 110 | end 111 | when :Object 112 | # generic object (usually a Hash), return directly 113 | value 114 | when /\AArray<(?.+)>\z/ 115 | inner_type = Regexp.last_match[:inner_type] 116 | value.map { |v| _deserialize(inner_type, v) } 117 | when /\AHash<(?.+?), (?.+)>\z/ 118 | k_type = Regexp.last_match[:k_type] 119 | v_type = Regexp.last_match[:v_type] 120 | {}.tap do |hash| 121 | value.each do |k, v| 122 | hash[_deserialize(k_type, k)] = _deserialize(v_type, v) 123 | end 124 | end 125 | else # model 126 | temp_model = DocuSign_Maestro.const_get(type).new 127 | temp_model.build_from_hash(value) 128 | end 129 | end 130 | 131 | # Returns the string representation of the object 132 | # @return [String] String presentation of the object 133 | def to_s 134 | to_hash.to_s 135 | end 136 | 137 | # to_body is an alias to to_hash (backward compatibility) 138 | # @return [Hash] Returns the object in the form of hash 139 | def to_body 140 | to_hash 141 | end 142 | 143 | # Returns the object in the form of hash 144 | # @return [Hash] Returns the object in the form of hash 145 | def to_hash 146 | hash = {} 147 | self.class.attribute_map.each_pair do |attr, param| 148 | value = self.send(attr) 149 | next if value.nil? 150 | hash[param] = _to_hash(value) 151 | end 152 | hash 153 | end 154 | 155 | # Outputs non-array value in the form of hash 156 | # For object, use to_hash. Otherwise, just return the value 157 | # @param [Object] value Any valid value 158 | # @return [Hash] Returns the value in the form of hash 159 | def _to_hash(value) 160 | if value.is_a?(Array) 161 | value.compact.map { |v| _to_hash(v) } 162 | elsif value.is_a?(Hash) 163 | {}.tap do |hash| 164 | value.each { |k, v| hash[k] = _to_hash(v) } 165 | end 166 | elsif value.respond_to? :to_hash 167 | value.to_hash 168 | else 169 | value 170 | end 171 | end 172 | 173 | end 174 | end 175 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/user_id.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | # Participant User ID 16 | class UserId 17 | # Attribute mapping from ruby-style variable name to JSON key. 18 | def self.attribute_map 19 | { 20 | } 21 | end 22 | 23 | # Attribute type mapping. 24 | def self.swagger_types 25 | { 26 | } 27 | end 28 | 29 | # Initializes the object 30 | # @param [Hash] attributes Model attributes in the form of hash 31 | def initialize(attributes = {}) 32 | return unless attributes.is_a?(Hash) 33 | 34 | # convert string to symbol for hash key 35 | attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v } 36 | end 37 | 38 | # Show invalid properties with the reasons. Usually used together with valid? 39 | # @return Array for valid properties with the reasons 40 | def list_invalid_properties 41 | invalid_properties = Array.new 42 | invalid_properties 43 | end 44 | 45 | # Check to see if the all the properties in the model are valid 46 | # @return true if the model is valid 47 | def valid? 48 | true 49 | end 50 | 51 | # Checks equality by comparing each attribute. 52 | # @param [Object] Object to be compared 53 | def ==(o) 54 | return true if self.equal?(o) 55 | self.class == o.class 56 | end 57 | 58 | # @see the `==` method 59 | # @param [Object] Object to be compared 60 | def eql?(o) 61 | self == o 62 | end 63 | 64 | # Calculates hash code according to all attributes. 65 | # @return [Fixnum] Hash code 66 | def hash 67 | [].hash 68 | end 69 | 70 | # Builds the object from hash 71 | # @param [Hash] attributes Model attributes in the form of hash 72 | # @return [Object] Returns the model itself 73 | def build_from_hash(attributes) 74 | return nil unless attributes.is_a?(Hash) 75 | self.class.swagger_types.each_pair do |key, type| 76 | if type =~ /\AArray<(.*)>/i 77 | # check to ensure the input is an array given that the attribute 78 | # is documented as an array but the input is not 79 | if attributes[self.class.attribute_map[key]].is_a?(Array) 80 | self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) }) 81 | end 82 | elsif !attributes[self.class.attribute_map[key]].nil? 83 | self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]])) 84 | end # or else data not found in attributes(hash), not an issue as the data can be optional 85 | end 86 | 87 | self 88 | end 89 | 90 | # Deserializes the data based on type 91 | # @param string type Data type 92 | # @param string value Value to be deserialized 93 | # @return [Object] Deserialized data 94 | def _deserialize(type, value) 95 | case type.to_sym 96 | when :DateTime 97 | DateTime.parse(value) 98 | when :Date 99 | Date.parse(value) 100 | when :String 101 | value.to_s 102 | when :Integer 103 | value.to_i 104 | when :Float 105 | value.to_f 106 | when :BOOLEAN 107 | if value.to_s =~ /\A(true|t|yes|y|1)\z/i 108 | true 109 | else 110 | false 111 | end 112 | when :Object 113 | # generic object (usually a Hash), return directly 114 | value 115 | when /\AArray<(?.+)>\z/ 116 | inner_type = Regexp.last_match[:inner_type] 117 | value.map { |v| _deserialize(inner_type, v) } 118 | when /\AHash<(?.+?), (?.+)>\z/ 119 | k_type = Regexp.last_match[:k_type] 120 | v_type = Regexp.last_match[:v_type] 121 | {}.tap do |hash| 122 | value.each do |k, v| 123 | hash[_deserialize(k_type, k)] = _deserialize(v_type, v) 124 | end 125 | end 126 | else # model 127 | temp_model = DocuSign_Maestro.const_get(type).new 128 | temp_model.build_from_hash(value) 129 | end 130 | end 131 | 132 | # Returns the string representation of the object 133 | # @return [String] String presentation of the object 134 | def to_s 135 | to_hash.to_s 136 | end 137 | 138 | # to_body is an alias to to_hash (backward compatibility) 139 | # @return [Hash] Returns the object in the form of hash 140 | def to_body 141 | to_hash 142 | end 143 | 144 | # Returns the object in the form of hash 145 | # @return [Hash] Returns the object in the form of hash 146 | def to_hash 147 | hash = {} 148 | self.class.attribute_map.each_pair do |attr, param| 149 | value = self.send(attr) 150 | next if value.nil? 151 | hash[param] = _to_hash(value) 152 | end 153 | hash 154 | end 155 | 156 | # Outputs non-array value in the form of hash 157 | # For object, use to_hash. Otherwise, just return the value 158 | # @param [Object] value Any valid value 159 | # @return [Hash] Returns the value in the form of hash 160 | def _to_hash(value) 161 | if value.is_a?(Array) 162 | value.compact.map { |v| _to_hash(v) } 163 | elsif value.is_a?(Hash) 164 | {}.tap do |hash| 165 | value.each { |k, v| hash[k] = _to_hash(v) } 166 | end 167 | elsif value.respond_to? :to_hash 168 | value.to_hash 169 | else 170 | value 171 | end 172 | end 173 | 174 | end 175 | end 176 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/workflow_instance_map.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class WorkflowInstanceMap 16 | # Attribute mapping from ruby-style variable name to JSON key. 17 | def self.attribute_map 18 | { 19 | } 20 | end 21 | 22 | # Attribute type mapping. 23 | def self.swagger_types 24 | { 25 | } 26 | end 27 | 28 | # Initializes the object 29 | # @param [Hash] attributes Model attributes in the form of hash 30 | def initialize(attributes = {}) 31 | return unless attributes.is_a?(Hash) 32 | 33 | # convert string to symbol for hash key 34 | attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v } 35 | end 36 | 37 | # Show invalid properties with the reasons. Usually used together with valid? 38 | # @return Array for valid properties with the reasons 39 | def list_invalid_properties 40 | invalid_properties = Array.new 41 | invalid_properties 42 | end 43 | 44 | # Check to see if the all the properties in the model are valid 45 | # @return true if the model is valid 46 | def valid? 47 | true 48 | end 49 | 50 | # Checks equality by comparing each attribute. 51 | # @param [Object] Object to be compared 52 | def ==(o) 53 | return true if self.equal?(o) 54 | self.class == o.class 55 | end 56 | 57 | # @see the `==` method 58 | # @param [Object] Object to be compared 59 | def eql?(o) 60 | self == o 61 | end 62 | 63 | # Calculates hash code according to all attributes. 64 | # @return [Fixnum] Hash code 65 | def hash 66 | [].hash 67 | end 68 | 69 | # Builds the object from hash 70 | # @param [Hash] attributes Model attributes in the form of hash 71 | # @return [Object] Returns the model itself 72 | def build_from_hash(attributes) 73 | return nil unless attributes.is_a?(Hash) 74 | self.class.swagger_types.each_pair do |key, type| 75 | if type =~ /\AArray<(.*)>/i 76 | # check to ensure the input is an array given that the attribute 77 | # is documented as an array but the input is not 78 | if attributes[self.class.attribute_map[key]].is_a?(Array) 79 | self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) }) 80 | end 81 | elsif !attributes[self.class.attribute_map[key]].nil? 82 | self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]])) 83 | end # or else data not found in attributes(hash), not an issue as the data can be optional 84 | end 85 | 86 | self 87 | end 88 | 89 | # Deserializes the data based on type 90 | # @param string type Data type 91 | # @param string value Value to be deserialized 92 | # @return [Object] Deserialized data 93 | def _deserialize(type, value) 94 | case type.to_sym 95 | when :DateTime 96 | DateTime.parse(value) 97 | when :Date 98 | Date.parse(value) 99 | when :String 100 | value.to_s 101 | when :Integer 102 | value.to_i 103 | when :Float 104 | value.to_f 105 | when :BOOLEAN 106 | if value.to_s =~ /\A(true|t|yes|y|1)\z/i 107 | true 108 | else 109 | false 110 | end 111 | when :Object 112 | # generic object (usually a Hash), return directly 113 | value 114 | when /\AArray<(?.+)>\z/ 115 | inner_type = Regexp.last_match[:inner_type] 116 | value.map { |v| _deserialize(inner_type, v) } 117 | when /\AHash<(?.+?), (?.+)>\z/ 118 | k_type = Regexp.last_match[:k_type] 119 | v_type = Regexp.last_match[:v_type] 120 | {}.tap do |hash| 121 | value.each do |k, v| 122 | hash[_deserialize(k_type, k)] = _deserialize(v_type, v) 123 | end 124 | end 125 | else # model 126 | temp_model = DocuSign_Maestro.const_get(type).new 127 | temp_model.build_from_hash(value) 128 | end 129 | end 130 | 131 | # Returns the string representation of the object 132 | # @return [String] String presentation of the object 133 | def to_s 134 | to_hash.to_s 135 | end 136 | 137 | # to_body is an alias to to_hash (backward compatibility) 138 | # @return [Hash] Returns the object in the form of hash 139 | def to_body 140 | to_hash 141 | end 142 | 143 | # Returns the object in the form of hash 144 | # @return [Hash] Returns the object in the form of hash 145 | def to_hash 146 | hash = {} 147 | self.class.attribute_map.each_pair do |attr, param| 148 | value = self.send(attr) 149 | next if value.nil? 150 | hash[param] = _to_hash(value) 151 | end 152 | hash 153 | end 154 | 155 | # Outputs non-array value in the form of hash 156 | # For object, use to_hash. Otherwise, just return the value 157 | # @param [Object] value Any valid value 158 | # @return [Hash] Returns the value in the form of hash 159 | def _to_hash(value) 160 | if value.is_a?(Array) 161 | value.compact.map { |v| _to_hash(v) } 162 | elsif value.is_a?(Hash) 163 | {}.tap do |hash| 164 | value.each { |k, v| hash[k] = _to_hash(v) } 165 | end 166 | elsif value.respond_to? :to_hash 167 | value.to_hash 168 | else 169 | value 170 | end 171 | end 172 | 173 | end 174 | end 175 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/ds_step_id.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | # DS Step Id 16 | class DsStepId 17 | # Attribute mapping from ruby-style variable name to JSON key. 18 | def self.attribute_map 19 | { 20 | } 21 | end 22 | 23 | # Attribute type mapping. 24 | def self.swagger_types 25 | { 26 | } 27 | end 28 | 29 | # Initializes the object 30 | # @param [Hash] attributes Model attributes in the form of hash 31 | def initialize(attributes = {}) 32 | return unless attributes.is_a?(Hash) 33 | 34 | # convert string to symbol for hash key 35 | attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v } 36 | end 37 | 38 | # Show invalid properties with the reasons. Usually used together with valid? 39 | # @return Array for valid properties with the reasons 40 | def list_invalid_properties 41 | invalid_properties = Array.new 42 | invalid_properties 43 | end 44 | 45 | # Check to see if the all the properties in the model are valid 46 | # @return true if the model is valid 47 | def valid? 48 | true 49 | end 50 | 51 | # Checks equality by comparing each attribute. 52 | # @param [Object] Object to be compared 53 | def ==(o) 54 | return true if self.equal?(o) 55 | self.class == o.class 56 | end 57 | 58 | # @see the `==` method 59 | # @param [Object] Object to be compared 60 | def eql?(o) 61 | self == o 62 | end 63 | 64 | # Calculates hash code according to all attributes. 65 | # @return [Fixnum] Hash code 66 | def hash 67 | [].hash 68 | end 69 | 70 | # Builds the object from hash 71 | # @param [Hash] attributes Model attributes in the form of hash 72 | # @return [Object] Returns the model itself 73 | def build_from_hash(attributes) 74 | return nil unless attributes.is_a?(Hash) 75 | self.class.swagger_types.each_pair do |key, type| 76 | if type =~ /\AArray<(.*)>/i 77 | # check to ensure the input is an array given that the attribute 78 | # is documented as an array but the input is not 79 | if attributes[self.class.attribute_map[key]].is_a?(Array) 80 | self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) }) 81 | end 82 | elsif !attributes[self.class.attribute_map[key]].nil? 83 | self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]])) 84 | end # or else data not found in attributes(hash), not an issue as the data can be optional 85 | end 86 | 87 | self 88 | end 89 | 90 | # Deserializes the data based on type 91 | # @param string type Data type 92 | # @param string value Value to be deserialized 93 | # @return [Object] Deserialized data 94 | def _deserialize(type, value) 95 | case type.to_sym 96 | when :DateTime 97 | DateTime.parse(value) 98 | when :Date 99 | Date.parse(value) 100 | when :String 101 | value.to_s 102 | when :Integer 103 | value.to_i 104 | when :Float 105 | value.to_f 106 | when :BOOLEAN 107 | if value.to_s =~ /\A(true|t|yes|y|1)\z/i 108 | true 109 | else 110 | false 111 | end 112 | when :Object 113 | # generic object (usually a Hash), return directly 114 | value 115 | when /\AArray<(?.+)>\z/ 116 | inner_type = Regexp.last_match[:inner_type] 117 | value.map { |v| _deserialize(inner_type, v) } 118 | when /\AHash<(?.+?), (?.+)>\z/ 119 | k_type = Regexp.last_match[:k_type] 120 | v_type = Regexp.last_match[:v_type] 121 | {}.tap do |hash| 122 | value.each do |k, v| 123 | hash[_deserialize(k_type, k)] = _deserialize(v_type, v) 124 | end 125 | end 126 | else # model 127 | temp_model = DocuSign_Maestro.const_get(type).new 128 | temp_model.build_from_hash(value) 129 | end 130 | end 131 | 132 | # Returns the string representation of the object 133 | # @return [String] String presentation of the object 134 | def to_s 135 | to_hash.to_s 136 | end 137 | 138 | # to_body is an alias to to_hash (backward compatibility) 139 | # @return [Hash] Returns the object in the form of hash 140 | def to_body 141 | to_hash 142 | end 143 | 144 | # Returns the object in the form of hash 145 | # @return [Hash] Returns the object in the form of hash 146 | def to_hash 147 | hash = {} 148 | self.class.attribute_map.each_pair do |attr, param| 149 | value = self.send(attr) 150 | next if value.nil? 151 | hash[param] = _to_hash(value) 152 | end 153 | hash 154 | end 155 | 156 | # Outputs non-array value in the form of hash 157 | # For object, use to_hash. Otherwise, just return the value 158 | # @param [Object] value Any valid value 159 | # @return [Hash] Returns the value in the form of hash 160 | def _to_hash(value) 161 | if value.is_a?(Array) 162 | value.compact.map { |v| _to_hash(v) } 163 | elsif value.is_a?(Hash) 164 | {}.tap do |hash| 165 | value.each { |k, v| hash[k] = _to_hash(v) } 166 | end 167 | elsif value.respond_to? :to_hash 168 | value.to_hash 169 | else 170 | value 171 | end 172 | end 173 | 174 | end 175 | end 176 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/ds_workflow_lanes_record.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | class DSWorkflowLanesRecord 16 | # Attribute mapping from ruby-style variable name to JSON key. 17 | def self.attribute_map 18 | { 19 | } 20 | end 21 | 22 | # Attribute type mapping. 23 | def self.swagger_types 24 | { 25 | } 26 | end 27 | 28 | # Initializes the object 29 | # @param [Hash] attributes Model attributes in the form of hash 30 | def initialize(attributes = {}) 31 | return unless attributes.is_a?(Hash) 32 | 33 | # convert string to symbol for hash key 34 | attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v } 35 | end 36 | 37 | # Show invalid properties with the reasons. Usually used together with valid? 38 | # @return Array for valid properties with the reasons 39 | def list_invalid_properties 40 | invalid_properties = Array.new 41 | invalid_properties 42 | end 43 | 44 | # Check to see if the all the properties in the model are valid 45 | # @return true if the model is valid 46 | def valid? 47 | true 48 | end 49 | 50 | # Checks equality by comparing each attribute. 51 | # @param [Object] Object to be compared 52 | def ==(o) 53 | return true if self.equal?(o) 54 | self.class == o.class 55 | end 56 | 57 | # @see the `==` method 58 | # @param [Object] Object to be compared 59 | def eql?(o) 60 | self == o 61 | end 62 | 63 | # Calculates hash code according to all attributes. 64 | # @return [Fixnum] Hash code 65 | def hash 66 | [].hash 67 | end 68 | 69 | # Builds the object from hash 70 | # @param [Hash] attributes Model attributes in the form of hash 71 | # @return [Object] Returns the model itself 72 | def build_from_hash(attributes) 73 | return nil unless attributes.is_a?(Hash) 74 | self.class.swagger_types.each_pair do |key, type| 75 | if type =~ /\AArray<(.*)>/i 76 | # check to ensure the input is an array given that the attribute 77 | # is documented as an array but the input is not 78 | if attributes[self.class.attribute_map[key]].is_a?(Array) 79 | self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) }) 80 | end 81 | elsif !attributes[self.class.attribute_map[key]].nil? 82 | self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]])) 83 | end # or else data not found in attributes(hash), not an issue as the data can be optional 84 | end 85 | 86 | self 87 | end 88 | 89 | # Deserializes the data based on type 90 | # @param string type Data type 91 | # @param string value Value to be deserialized 92 | # @return [Object] Deserialized data 93 | def _deserialize(type, value) 94 | case type.to_sym 95 | when :DateTime 96 | DateTime.parse(value) 97 | when :Date 98 | Date.parse(value) 99 | when :String 100 | value.to_s 101 | when :Integer 102 | value.to_i 103 | when :Float 104 | value.to_f 105 | when :BOOLEAN 106 | if value.to_s =~ /\A(true|t|yes|y|1)\z/i 107 | true 108 | else 109 | false 110 | end 111 | when :Object 112 | # generic object (usually a Hash), return directly 113 | value 114 | when /\AArray<(?.+)>\z/ 115 | inner_type = Regexp.last_match[:inner_type] 116 | value.map { |v| _deserialize(inner_type, v) } 117 | when /\AHash<(?.+?), (?.+)>\z/ 118 | k_type = Regexp.last_match[:k_type] 119 | v_type = Regexp.last_match[:v_type] 120 | {}.tap do |hash| 121 | value.each do |k, v| 122 | hash[_deserialize(k_type, k)] = _deserialize(v_type, v) 123 | end 124 | end 125 | else # model 126 | temp_model = DocuSign_Maestro.const_get(type).new 127 | temp_model.build_from_hash(value) 128 | end 129 | end 130 | 131 | # Returns the string representation of the object 132 | # @return [String] String presentation of the object 133 | def to_s 134 | to_hash.to_s 135 | end 136 | 137 | # to_body is an alias to to_hash (backward compatibility) 138 | # @return [Hash] Returns the object in the form of hash 139 | def to_body 140 | to_hash 141 | end 142 | 143 | # Returns the object in the form of hash 144 | # @return [Hash] Returns the object in the form of hash 145 | def to_hash 146 | hash = {} 147 | self.class.attribute_map.each_pair do |attr, param| 148 | value = self.send(attr) 149 | next if value.nil? 150 | hash[param] = _to_hash(value) 151 | end 152 | hash 153 | end 154 | 155 | # Outputs non-array value in the form of hash 156 | # For object, use to_hash. Otherwise, just return the value 157 | # @param [Object] value Any valid value 158 | # @return [Hash] Returns the value in the form of hash 159 | def _to_hash(value) 160 | if value.is_a?(Array) 161 | value.compact.map { |v| _to_hash(v) } 162 | elsif value.is_a?(Hash) 163 | {}.tap do |hash| 164 | value.each { |k, v| hash[k] = _to_hash(v) } 165 | end 166 | elsif value.respond_to? :to_hash 167 | value.to_hash 168 | else 169 | value 170 | end 171 | end 172 | 173 | end 174 | end 175 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/template_id.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | # Workflow Definition Id 16 | class TemplateId 17 | # Attribute mapping from ruby-style variable name to JSON key. 18 | def self.attribute_map 19 | { 20 | } 21 | end 22 | 23 | # Attribute type mapping. 24 | def self.swagger_types 25 | { 26 | } 27 | end 28 | 29 | # Initializes the object 30 | # @param [Hash] attributes Model attributes in the form of hash 31 | def initialize(attributes = {}) 32 | return unless attributes.is_a?(Hash) 33 | 34 | # convert string to symbol for hash key 35 | attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v } 36 | end 37 | 38 | # Show invalid properties with the reasons. Usually used together with valid? 39 | # @return Array for valid properties with the reasons 40 | def list_invalid_properties 41 | invalid_properties = Array.new 42 | invalid_properties 43 | end 44 | 45 | # Check to see if the all the properties in the model are valid 46 | # @return true if the model is valid 47 | def valid? 48 | true 49 | end 50 | 51 | # Checks equality by comparing each attribute. 52 | # @param [Object] Object to be compared 53 | def ==(o) 54 | return true if self.equal?(o) 55 | self.class == o.class 56 | end 57 | 58 | # @see the `==` method 59 | # @param [Object] Object to be compared 60 | def eql?(o) 61 | self == o 62 | end 63 | 64 | # Calculates hash code according to all attributes. 65 | # @return [Fixnum] Hash code 66 | def hash 67 | [].hash 68 | end 69 | 70 | # Builds the object from hash 71 | # @param [Hash] attributes Model attributes in the form of hash 72 | # @return [Object] Returns the model itself 73 | def build_from_hash(attributes) 74 | return nil unless attributes.is_a?(Hash) 75 | self.class.swagger_types.each_pair do |key, type| 76 | if type =~ /\AArray<(.*)>/i 77 | # check to ensure the input is an array given that the attribute 78 | # is documented as an array but the input is not 79 | if attributes[self.class.attribute_map[key]].is_a?(Array) 80 | self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) }) 81 | end 82 | elsif !attributes[self.class.attribute_map[key]].nil? 83 | self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]])) 84 | end # or else data not found in attributes(hash), not an issue as the data can be optional 85 | end 86 | 87 | self 88 | end 89 | 90 | # Deserializes the data based on type 91 | # @param string type Data type 92 | # @param string value Value to be deserialized 93 | # @return [Object] Deserialized data 94 | def _deserialize(type, value) 95 | case type.to_sym 96 | when :DateTime 97 | DateTime.parse(value) 98 | when :Date 99 | Date.parse(value) 100 | when :String 101 | value.to_s 102 | when :Integer 103 | value.to_i 104 | when :Float 105 | value.to_f 106 | when :BOOLEAN 107 | if value.to_s =~ /\A(true|t|yes|y|1)\z/i 108 | true 109 | else 110 | false 111 | end 112 | when :Object 113 | # generic object (usually a Hash), return directly 114 | value 115 | when /\AArray<(?.+)>\z/ 116 | inner_type = Regexp.last_match[:inner_type] 117 | value.map { |v| _deserialize(inner_type, v) } 118 | when /\AHash<(?.+?), (?.+)>\z/ 119 | k_type = Regexp.last_match[:k_type] 120 | v_type = Regexp.last_match[:v_type] 121 | {}.tap do |hash| 122 | value.each do |k, v| 123 | hash[_deserialize(k_type, k)] = _deserialize(v_type, v) 124 | end 125 | end 126 | else # model 127 | temp_model = DocuSign_Maestro.const_get(type).new 128 | temp_model.build_from_hash(value) 129 | end 130 | end 131 | 132 | # Returns the string representation of the object 133 | # @return [String] String presentation of the object 134 | def to_s 135 | to_hash.to_s 136 | end 137 | 138 | # to_body is an alias to to_hash (backward compatibility) 139 | # @return [Hash] Returns the object in the form of hash 140 | def to_body 141 | to_hash 142 | end 143 | 144 | # Returns the object in the form of hash 145 | # @return [Hash] Returns the object in the form of hash 146 | def to_hash 147 | hash = {} 148 | self.class.attribute_map.each_pair do |attr, param| 149 | value = self.send(attr) 150 | next if value.nil? 151 | hash[param] = _to_hash(value) 152 | end 153 | hash 154 | end 155 | 156 | # Outputs non-array value in the form of hash 157 | # For object, use to_hash. Otherwise, just return the value 158 | # @param [Object] value Any valid value 159 | # @return [Hash] Returns the value in the form of hash 160 | def _to_hash(value) 161 | if value.is_a?(Array) 162 | value.compact.map { |v| _to_hash(v) } 163 | elsif value.is_a?(Hash) 164 | {}.tap do |hash| 165 | value.each { |k, v| hash[k] = _to_hash(v) } 166 | end 167 | elsif value.respond_to? :to_hash 168 | value.to_hash 169 | else 170 | value 171 | end 172 | end 173 | 174 | end 175 | end 176 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/ds_workflow_variable.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | # DS Workflow Variables 16 | class DSWorkflowVariable 17 | # Attribute mapping from ruby-style variable name to JSON key. 18 | def self.attribute_map 19 | { 20 | } 21 | end 22 | 23 | # Attribute type mapping. 24 | def self.swagger_types 25 | { 26 | } 27 | end 28 | 29 | # Initializes the object 30 | # @param [Hash] attributes Model attributes in the form of hash 31 | def initialize(attributes = {}) 32 | return unless attributes.is_a?(Hash) 33 | 34 | # convert string to symbol for hash key 35 | attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v } 36 | end 37 | 38 | # Show invalid properties with the reasons. Usually used together with valid? 39 | # @return Array for valid properties with the reasons 40 | def list_invalid_properties 41 | invalid_properties = Array.new 42 | invalid_properties 43 | end 44 | 45 | # Check to see if the all the properties in the model are valid 46 | # @return true if the model is valid 47 | def valid? 48 | true 49 | end 50 | 51 | # Checks equality by comparing each attribute. 52 | # @param [Object] Object to be compared 53 | def ==(o) 54 | return true if self.equal?(o) 55 | self.class == o.class 56 | end 57 | 58 | # @see the `==` method 59 | # @param [Object] Object to be compared 60 | def eql?(o) 61 | self == o 62 | end 63 | 64 | # Calculates hash code according to all attributes. 65 | # @return [Fixnum] Hash code 66 | def hash 67 | [].hash 68 | end 69 | 70 | # Builds the object from hash 71 | # @param [Hash] attributes Model attributes in the form of hash 72 | # @return [Object] Returns the model itself 73 | def build_from_hash(attributes) 74 | return nil unless attributes.is_a?(Hash) 75 | self.class.swagger_types.each_pair do |key, type| 76 | if type =~ /\AArray<(.*)>/i 77 | # check to ensure the input is an array given that the attribute 78 | # is documented as an array but the input is not 79 | if attributes[self.class.attribute_map[key]].is_a?(Array) 80 | self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) }) 81 | end 82 | elsif !attributes[self.class.attribute_map[key]].nil? 83 | self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]])) 84 | end # or else data not found in attributes(hash), not an issue as the data can be optional 85 | end 86 | 87 | self 88 | end 89 | 90 | # Deserializes the data based on type 91 | # @param string type Data type 92 | # @param string value Value to be deserialized 93 | # @return [Object] Deserialized data 94 | def _deserialize(type, value) 95 | case type.to_sym 96 | when :DateTime 97 | DateTime.parse(value) 98 | when :Date 99 | Date.parse(value) 100 | when :String 101 | value.to_s 102 | when :Integer 103 | value.to_i 104 | when :Float 105 | value.to_f 106 | when :BOOLEAN 107 | if value.to_s =~ /\A(true|t|yes|y|1)\z/i 108 | true 109 | else 110 | false 111 | end 112 | when :Object 113 | # generic object (usually a Hash), return directly 114 | value 115 | when /\AArray<(?.+)>\z/ 116 | inner_type = Regexp.last_match[:inner_type] 117 | value.map { |v| _deserialize(inner_type, v) } 118 | when /\AHash<(?.+?), (?.+)>\z/ 119 | k_type = Regexp.last_match[:k_type] 120 | v_type = Regexp.last_match[:v_type] 121 | {}.tap do |hash| 122 | value.each do |k, v| 123 | hash[_deserialize(k_type, k)] = _deserialize(v_type, v) 124 | end 125 | end 126 | else # model 127 | temp_model = DocuSign_Maestro.const_get(type).new 128 | temp_model.build_from_hash(value) 129 | end 130 | end 131 | 132 | # Returns the string representation of the object 133 | # @return [String] String presentation of the object 134 | def to_s 135 | to_hash.to_s 136 | end 137 | 138 | # to_body is an alias to to_hash (backward compatibility) 139 | # @return [Hash] Returns the object in the form of hash 140 | def to_body 141 | to_hash 142 | end 143 | 144 | # Returns the object in the form of hash 145 | # @return [Hash] Returns the object in the form of hash 146 | def to_hash 147 | hash = {} 148 | self.class.attribute_map.each_pair do |attr, param| 149 | value = self.send(attr) 150 | next if value.nil? 151 | hash[param] = _to_hash(value) 152 | end 153 | hash 154 | end 155 | 156 | # Outputs non-array value in the form of hash 157 | # For object, use to_hash. Otherwise, just return the value 158 | # @param [Object] value Any valid value 159 | # @return [Hash] Returns the value in the form of hash 160 | def _to_hash(value) 161 | if value.is_a?(Array) 162 | value.compact.map { |v| _to_hash(v) } 163 | elsif value.is_a?(Hash) 164 | {}.tap do |hash| 165 | value.each { |k, v| hash[k] = _to_hash(v) } 166 | end 167 | elsif value.respond_to? :to_hash 168 | value.to_hash 169 | else 170 | value 171 | end 172 | end 173 | 174 | end 175 | end 176 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/workflow_instance_id.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | # Workflow Instance Id 16 | class WorkflowInstanceId 17 | # Attribute mapping from ruby-style variable name to JSON key. 18 | def self.attribute_map 19 | { 20 | } 21 | end 22 | 23 | # Attribute type mapping. 24 | def self.swagger_types 25 | { 26 | } 27 | end 28 | 29 | # Initializes the object 30 | # @param [Hash] attributes Model attributes in the form of hash 31 | def initialize(attributes = {}) 32 | return unless attributes.is_a?(Hash) 33 | 34 | # convert string to symbol for hash key 35 | attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v } 36 | end 37 | 38 | # Show invalid properties with the reasons. Usually used together with valid? 39 | # @return Array for valid properties with the reasons 40 | def list_invalid_properties 41 | invalid_properties = Array.new 42 | invalid_properties 43 | end 44 | 45 | # Check to see if the all the properties in the model are valid 46 | # @return true if the model is valid 47 | def valid? 48 | true 49 | end 50 | 51 | # Checks equality by comparing each attribute. 52 | # @param [Object] Object to be compared 53 | def ==(o) 54 | return true if self.equal?(o) 55 | self.class == o.class 56 | end 57 | 58 | # @see the `==` method 59 | # @param [Object] Object to be compared 60 | def eql?(o) 61 | self == o 62 | end 63 | 64 | # Calculates hash code according to all attributes. 65 | # @return [Fixnum] Hash code 66 | def hash 67 | [].hash 68 | end 69 | 70 | # Builds the object from hash 71 | # @param [Hash] attributes Model attributes in the form of hash 72 | # @return [Object] Returns the model itself 73 | def build_from_hash(attributes) 74 | return nil unless attributes.is_a?(Hash) 75 | self.class.swagger_types.each_pair do |key, type| 76 | if type =~ /\AArray<(.*)>/i 77 | # check to ensure the input is an array given that the attribute 78 | # is documented as an array but the input is not 79 | if attributes[self.class.attribute_map[key]].is_a?(Array) 80 | self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) }) 81 | end 82 | elsif !attributes[self.class.attribute_map[key]].nil? 83 | self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]])) 84 | end # or else data not found in attributes(hash), not an issue as the data can be optional 85 | end 86 | 87 | self 88 | end 89 | 90 | # Deserializes the data based on type 91 | # @param string type Data type 92 | # @param string value Value to be deserialized 93 | # @return [Object] Deserialized data 94 | def _deserialize(type, value) 95 | case type.to_sym 96 | when :DateTime 97 | DateTime.parse(value) 98 | when :Date 99 | Date.parse(value) 100 | when :String 101 | value.to_s 102 | when :Integer 103 | value.to_i 104 | when :Float 105 | value.to_f 106 | when :BOOLEAN 107 | if value.to_s =~ /\A(true|t|yes|y|1)\z/i 108 | true 109 | else 110 | false 111 | end 112 | when :Object 113 | # generic object (usually a Hash), return directly 114 | value 115 | when /\AArray<(?.+)>\z/ 116 | inner_type = Regexp.last_match[:inner_type] 117 | value.map { |v| _deserialize(inner_type, v) } 118 | when /\AHash<(?.+?), (?.+)>\z/ 119 | k_type = Regexp.last_match[:k_type] 120 | v_type = Regexp.last_match[:v_type] 121 | {}.tap do |hash| 122 | value.each do |k, v| 123 | hash[_deserialize(k_type, k)] = _deserialize(v_type, v) 124 | end 125 | end 126 | else # model 127 | temp_model = DocuSign_Maestro.const_get(type).new 128 | temp_model.build_from_hash(value) 129 | end 130 | end 131 | 132 | # Returns the string representation of the object 133 | # @return [String] String presentation of the object 134 | def to_s 135 | to_hash.to_s 136 | end 137 | 138 | # to_body is an alias to to_hash (backward compatibility) 139 | # @return [Hash] Returns the object in the form of hash 140 | def to_body 141 | to_hash 142 | end 143 | 144 | # Returns the object in the form of hash 145 | # @return [Hash] Returns the object in the form of hash 146 | def to_hash 147 | hash = {} 148 | self.class.attribute_map.each_pair do |attr, param| 149 | value = self.send(attr) 150 | next if value.nil? 151 | hash[param] = _to_hash(value) 152 | end 153 | hash 154 | end 155 | 156 | # Outputs non-array value in the form of hash 157 | # For object, use to_hash. Otherwise, just return the value 158 | # @param [Object] value Any valid value 159 | # @return [Hash] Returns the value in the form of hash 160 | def _to_hash(value) 161 | if value.is_a?(Array) 162 | value.compact.map { |v| _to_hash(v) } 163 | elsif value.is_a?(Hash) 164 | {}.tap do |hash| 165 | value.each { |k, v| hash[k] = _to_hash(v) } 166 | end 167 | elsif value.respond_to? :to_hash 168 | value.to_hash 169 | else 170 | value 171 | end 172 | end 173 | 174 | end 175 | end 176 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/ds_workflow_variable_record.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | # A DS Workflow variable record 16 | class DSWorkflowVariableRecord 17 | # Attribute mapping from ruby-style variable name to JSON key. 18 | def self.attribute_map 19 | { 20 | } 21 | end 22 | 23 | # Attribute type mapping. 24 | def self.swagger_types 25 | { 26 | } 27 | end 28 | 29 | # Initializes the object 30 | # @param [Hash] attributes Model attributes in the form of hash 31 | def initialize(attributes = {}) 32 | return unless attributes.is_a?(Hash) 33 | 34 | # convert string to symbol for hash key 35 | attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v } 36 | end 37 | 38 | # Show invalid properties with the reasons. Usually used together with valid? 39 | # @return Array for valid properties with the reasons 40 | def list_invalid_properties 41 | invalid_properties = Array.new 42 | invalid_properties 43 | end 44 | 45 | # Check to see if the all the properties in the model are valid 46 | # @return true if the model is valid 47 | def valid? 48 | true 49 | end 50 | 51 | # Checks equality by comparing each attribute. 52 | # @param [Object] Object to be compared 53 | def ==(o) 54 | return true if self.equal?(o) 55 | self.class == o.class 56 | end 57 | 58 | # @see the `==` method 59 | # @param [Object] Object to be compared 60 | def eql?(o) 61 | self == o 62 | end 63 | 64 | # Calculates hash code according to all attributes. 65 | # @return [Fixnum] Hash code 66 | def hash 67 | [].hash 68 | end 69 | 70 | # Builds the object from hash 71 | # @param [Hash] attributes Model attributes in the form of hash 72 | # @return [Object] Returns the model itself 73 | def build_from_hash(attributes) 74 | return nil unless attributes.is_a?(Hash) 75 | self.class.swagger_types.each_pair do |key, type| 76 | if type =~ /\AArray<(.*)>/i 77 | # check to ensure the input is an array given that the attribute 78 | # is documented as an array but the input is not 79 | if attributes[self.class.attribute_map[key]].is_a?(Array) 80 | self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) }) 81 | end 82 | elsif !attributes[self.class.attribute_map[key]].nil? 83 | self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]])) 84 | end # or else data not found in attributes(hash), not an issue as the data can be optional 85 | end 86 | 87 | self 88 | end 89 | 90 | # Deserializes the data based on type 91 | # @param string type Data type 92 | # @param string value Value to be deserialized 93 | # @return [Object] Deserialized data 94 | def _deserialize(type, value) 95 | case type.to_sym 96 | when :DateTime 97 | DateTime.parse(value) 98 | when :Date 99 | Date.parse(value) 100 | when :String 101 | value.to_s 102 | when :Integer 103 | value.to_i 104 | when :Float 105 | value.to_f 106 | when :BOOLEAN 107 | if value.to_s =~ /\A(true|t|yes|y|1)\z/i 108 | true 109 | else 110 | false 111 | end 112 | when :Object 113 | # generic object (usually a Hash), return directly 114 | value 115 | when /\AArray<(?.+)>\z/ 116 | inner_type = Regexp.last_match[:inner_type] 117 | value.map { |v| _deserialize(inner_type, v) } 118 | when /\AHash<(?.+?), (?.+)>\z/ 119 | k_type = Regexp.last_match[:k_type] 120 | v_type = Regexp.last_match[:v_type] 121 | {}.tap do |hash| 122 | value.each do |k, v| 123 | hash[_deserialize(k_type, k)] = _deserialize(v_type, v) 124 | end 125 | end 126 | else # model 127 | temp_model = DocuSign_Maestro.const_get(type).new 128 | temp_model.build_from_hash(value) 129 | end 130 | end 131 | 132 | # Returns the string representation of the object 133 | # @return [String] String presentation of the object 134 | def to_s 135 | to_hash.to_s 136 | end 137 | 138 | # to_body is an alias to to_hash (backward compatibility) 139 | # @return [Hash] Returns the object in the form of hash 140 | def to_body 141 | to_hash 142 | end 143 | 144 | # Returns the object in the form of hash 145 | # @return [Hash] Returns the object in the form of hash 146 | def to_hash 147 | hash = {} 148 | self.class.attribute_map.each_pair do |attr, param| 149 | value = self.send(attr) 150 | next if value.nil? 151 | hash[param] = _to_hash(value) 152 | end 153 | hash 154 | end 155 | 156 | # Outputs non-array value in the form of hash 157 | # For object, use to_hash. Otherwise, just return the value 158 | # @param [Object] value Any valid value 159 | # @return [Hash] Returns the value in the form of hash 160 | def _to_hash(value) 161 | if value.is_a?(Array) 162 | value.compact.map { |v| _to_hash(v) } 163 | elsif value.is_a?(Hash) 164 | {}.tap do |hash| 165 | value.each { |k, v| hash[k] = _to_hash(v) } 166 | end 167 | elsif value.respond_to? :to_hash 168 | value.to_hash 169 | else 170 | value 171 | end 172 | end 173 | 174 | end 175 | end 176 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/workflow_instances_list.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | # A list of workflow instances (0 or more). 16 | class WorkflowInstancesList 17 | # Attribute mapping from ruby-style variable name to JSON key. 18 | def self.attribute_map 19 | { 20 | } 21 | end 22 | 23 | # Attribute type mapping. 24 | def self.swagger_types 25 | { 26 | } 27 | end 28 | 29 | # Initializes the object 30 | # @param [Hash] attributes Model attributes in the form of hash 31 | def initialize(attributes = {}) 32 | return unless attributes.is_a?(Hash) 33 | 34 | # convert string to symbol for hash key 35 | attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v } 36 | end 37 | 38 | # Show invalid properties with the reasons. Usually used together with valid? 39 | # @return Array for valid properties with the reasons 40 | def list_invalid_properties 41 | invalid_properties = Array.new 42 | invalid_properties 43 | end 44 | 45 | # Check to see if the all the properties in the model are valid 46 | # @return true if the model is valid 47 | def valid? 48 | true 49 | end 50 | 51 | # Checks equality by comparing each attribute. 52 | # @param [Object] Object to be compared 53 | def ==(o) 54 | return true if self.equal?(o) 55 | self.class == o.class 56 | end 57 | 58 | # @see the `==` method 59 | # @param [Object] Object to be compared 60 | def eql?(o) 61 | self == o 62 | end 63 | 64 | # Calculates hash code according to all attributes. 65 | # @return [Fixnum] Hash code 66 | def hash 67 | [].hash 68 | end 69 | 70 | # Builds the object from hash 71 | # @param [Hash] attributes Model attributes in the form of hash 72 | # @return [Object] Returns the model itself 73 | def build_from_hash(attributes) 74 | return nil unless attributes.is_a?(Hash) 75 | self.class.swagger_types.each_pair do |key, type| 76 | if type =~ /\AArray<(.*)>/i 77 | # check to ensure the input is an array given that the attribute 78 | # is documented as an array but the input is not 79 | if attributes[self.class.attribute_map[key]].is_a?(Array) 80 | self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) }) 81 | end 82 | elsif !attributes[self.class.attribute_map[key]].nil? 83 | self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]])) 84 | end # or else data not found in attributes(hash), not an issue as the data can be optional 85 | end 86 | 87 | self 88 | end 89 | 90 | # Deserializes the data based on type 91 | # @param string type Data type 92 | # @param string value Value to be deserialized 93 | # @return [Object] Deserialized data 94 | def _deserialize(type, value) 95 | case type.to_sym 96 | when :DateTime 97 | DateTime.parse(value) 98 | when :Date 99 | Date.parse(value) 100 | when :String 101 | value.to_s 102 | when :Integer 103 | value.to_i 104 | when :Float 105 | value.to_f 106 | when :BOOLEAN 107 | if value.to_s =~ /\A(true|t|yes|y|1)\z/i 108 | true 109 | else 110 | false 111 | end 112 | when :Object 113 | # generic object (usually a Hash), return directly 114 | value 115 | when /\AArray<(?.+)>\z/ 116 | inner_type = Regexp.last_match[:inner_type] 117 | value.map { |v| _deserialize(inner_type, v) } 118 | when /\AHash<(?.+?), (?.+)>\z/ 119 | k_type = Regexp.last_match[:k_type] 120 | v_type = Regexp.last_match[:v_type] 121 | {}.tap do |hash| 122 | value.each do |k, v| 123 | hash[_deserialize(k_type, k)] = _deserialize(v_type, v) 124 | end 125 | end 126 | else # model 127 | temp_model = DocuSign_Maestro.const_get(type).new 128 | temp_model.build_from_hash(value) 129 | end 130 | end 131 | 132 | # Returns the string representation of the object 133 | # @return [String] String presentation of the object 134 | def to_s 135 | to_hash.to_s 136 | end 137 | 138 | # to_body is an alias to to_hash (backward compatibility) 139 | # @return [Hash] Returns the object in the form of hash 140 | def to_body 141 | to_hash 142 | end 143 | 144 | # Returns the object in the form of hash 145 | # @return [Hash] Returns the object in the form of hash 146 | def to_hash 147 | hash = {} 148 | self.class.attribute_map.each_pair do |attr, param| 149 | value = self.send(attr) 150 | next if value.nil? 151 | hash[param] = _to_hash(value) 152 | end 153 | hash 154 | end 155 | 156 | # Outputs non-array value in the form of hash 157 | # For object, use to_hash. Otherwise, just return the value 158 | # @param [Object] value Any valid value 159 | # @return [Hash] Returns the value in the form of hash 160 | def _to_hash(value) 161 | if value.is_a?(Array) 162 | value.compact.map { |v| _to_hash(v) } 163 | elsif value.is_a?(Hash) 164 | {}.tap do |hash| 165 | value.each { |k, v| hash[k] = _to_hash(v) } 166 | end 167 | elsif value.respond_to? :to_hash 168 | value.to_hash 169 | else 170 | value 171 | end 172 | end 173 | 174 | end 175 | end 176 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/ds_workflow_participant_record.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | # A DS Workflow participant record 16 | class DSWorkflowParticipantRecord 17 | # Attribute mapping from ruby-style variable name to JSON key. 18 | def self.attribute_map 19 | { 20 | } 21 | end 22 | 23 | # Attribute type mapping. 24 | def self.swagger_types 25 | { 26 | } 27 | end 28 | 29 | # Initializes the object 30 | # @param [Hash] attributes Model attributes in the form of hash 31 | def initialize(attributes = {}) 32 | return unless attributes.is_a?(Hash) 33 | 34 | # convert string to symbol for hash key 35 | attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v } 36 | end 37 | 38 | # Show invalid properties with the reasons. Usually used together with valid? 39 | # @return Array for valid properties with the reasons 40 | def list_invalid_properties 41 | invalid_properties = Array.new 42 | invalid_properties 43 | end 44 | 45 | # Check to see if the all the properties in the model are valid 46 | # @return true if the model is valid 47 | def valid? 48 | true 49 | end 50 | 51 | # Checks equality by comparing each attribute. 52 | # @param [Object] Object to be compared 53 | def ==(o) 54 | return true if self.equal?(o) 55 | self.class == o.class 56 | end 57 | 58 | # @see the `==` method 59 | # @param [Object] Object to be compared 60 | def eql?(o) 61 | self == o 62 | end 63 | 64 | # Calculates hash code according to all attributes. 65 | # @return [Fixnum] Hash code 66 | def hash 67 | [].hash 68 | end 69 | 70 | # Builds the object from hash 71 | # @param [Hash] attributes Model attributes in the form of hash 72 | # @return [Object] Returns the model itself 73 | def build_from_hash(attributes) 74 | return nil unless attributes.is_a?(Hash) 75 | self.class.swagger_types.each_pair do |key, type| 76 | if type =~ /\AArray<(.*)>/i 77 | # check to ensure the input is an array given that the attribute 78 | # is documented as an array but the input is not 79 | if attributes[self.class.attribute_map[key]].is_a?(Array) 80 | self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) }) 81 | end 82 | elsif !attributes[self.class.attribute_map[key]].nil? 83 | self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]])) 84 | end # or else data not found in attributes(hash), not an issue as the data can be optional 85 | end 86 | 87 | self 88 | end 89 | 90 | # Deserializes the data based on type 91 | # @param string type Data type 92 | # @param string value Value to be deserialized 93 | # @return [Object] Deserialized data 94 | def _deserialize(type, value) 95 | case type.to_sym 96 | when :DateTime 97 | DateTime.parse(value) 98 | when :Date 99 | Date.parse(value) 100 | when :String 101 | value.to_s 102 | when :Integer 103 | value.to_i 104 | when :Float 105 | value.to_f 106 | when :BOOLEAN 107 | if value.to_s =~ /\A(true|t|yes|y|1)\z/i 108 | true 109 | else 110 | false 111 | end 112 | when :Object 113 | # generic object (usually a Hash), return directly 114 | value 115 | when /\AArray<(?.+)>\z/ 116 | inner_type = Regexp.last_match[:inner_type] 117 | value.map { |v| _deserialize(inner_type, v) } 118 | when /\AHash<(?.+?), (?.+)>\z/ 119 | k_type = Regexp.last_match[:k_type] 120 | v_type = Regexp.last_match[:v_type] 121 | {}.tap do |hash| 122 | value.each do |k, v| 123 | hash[_deserialize(k_type, k)] = _deserialize(v_type, v) 124 | end 125 | end 126 | else # model 127 | temp_model = DocuSign_Maestro.const_get(type).new 128 | temp_model.build_from_hash(value) 129 | end 130 | end 131 | 132 | # Returns the string representation of the object 133 | # @return [String] String presentation of the object 134 | def to_s 135 | to_hash.to_s 136 | end 137 | 138 | # to_body is an alias to to_hash (backward compatibility) 139 | # @return [Hash] Returns the object in the form of hash 140 | def to_body 141 | to_hash 142 | end 143 | 144 | # Returns the object in the form of hash 145 | # @return [Hash] Returns the object in the form of hash 146 | def to_hash 147 | hash = {} 148 | self.class.attribute_map.each_pair do |attr, param| 149 | value = self.send(attr) 150 | next if value.nil? 151 | hash[param] = _to_hash(value) 152 | end 153 | hash 154 | end 155 | 156 | # Outputs non-array value in the form of hash 157 | # For object, use to_hash. Otherwise, just return the value 158 | # @param [Object] value Any valid value 159 | # @return [Hash] Returns the value in the form of hash 160 | def _to_hash(value) 161 | if value.is_a?(Array) 162 | value.compact.map { |v| _to_hash(v) } 163 | elsif value.is_a?(Hash) 164 | {}.tap do |hash| 165 | value.each { |k, v| hash[k] = _to_hash(v) } 166 | end 167 | elsif value.respond_to? :to_hash 168 | value.to_hash 169 | else 170 | value 171 | end 172 | end 173 | 174 | end 175 | end 176 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/workflow_step_history_list.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | # Returns Array of Workflow Step History. 16 | class WorkflowStepHistoryList 17 | # Attribute mapping from ruby-style variable name to JSON key. 18 | def self.attribute_map 19 | { 20 | } 21 | end 22 | 23 | # Attribute type mapping. 24 | def self.swagger_types 25 | { 26 | } 27 | end 28 | 29 | # Initializes the object 30 | # @param [Hash] attributes Model attributes in the form of hash 31 | def initialize(attributes = {}) 32 | return unless attributes.is_a?(Hash) 33 | 34 | # convert string to symbol for hash key 35 | attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v } 36 | end 37 | 38 | # Show invalid properties with the reasons. Usually used together with valid? 39 | # @return Array for valid properties with the reasons 40 | def list_invalid_properties 41 | invalid_properties = Array.new 42 | invalid_properties 43 | end 44 | 45 | # Check to see if the all the properties in the model are valid 46 | # @return true if the model is valid 47 | def valid? 48 | true 49 | end 50 | 51 | # Checks equality by comparing each attribute. 52 | # @param [Object] Object to be compared 53 | def ==(o) 54 | return true if self.equal?(o) 55 | self.class == o.class 56 | end 57 | 58 | # @see the `==` method 59 | # @param [Object] Object to be compared 60 | def eql?(o) 61 | self == o 62 | end 63 | 64 | # Calculates hash code according to all attributes. 65 | # @return [Fixnum] Hash code 66 | def hash 67 | [].hash 68 | end 69 | 70 | # Builds the object from hash 71 | # @param [Hash] attributes Model attributes in the form of hash 72 | # @return [Object] Returns the model itself 73 | def build_from_hash(attributes) 74 | return nil unless attributes.is_a?(Hash) 75 | self.class.swagger_types.each_pair do |key, type| 76 | if type =~ /\AArray<(.*)>/i 77 | # check to ensure the input is an array given that the attribute 78 | # is documented as an array but the input is not 79 | if attributes[self.class.attribute_map[key]].is_a?(Array) 80 | self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) }) 81 | end 82 | elsif !attributes[self.class.attribute_map[key]].nil? 83 | self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]])) 84 | end # or else data not found in attributes(hash), not an issue as the data can be optional 85 | end 86 | 87 | self 88 | end 89 | 90 | # Deserializes the data based on type 91 | # @param string type Data type 92 | # @param string value Value to be deserialized 93 | # @return [Object] Deserialized data 94 | def _deserialize(type, value) 95 | case type.to_sym 96 | when :DateTime 97 | DateTime.parse(value) 98 | when :Date 99 | Date.parse(value) 100 | when :String 101 | value.to_s 102 | when :Integer 103 | value.to_i 104 | when :Float 105 | value.to_f 106 | when :BOOLEAN 107 | if value.to_s =~ /\A(true|t|yes|y|1)\z/i 108 | true 109 | else 110 | false 111 | end 112 | when :Object 113 | # generic object (usually a Hash), return directly 114 | value 115 | when /\AArray<(?.+)>\z/ 116 | inner_type = Regexp.last_match[:inner_type] 117 | value.map { |v| _deserialize(inner_type, v) } 118 | when /\AHash<(?.+?), (?.+)>\z/ 119 | k_type = Regexp.last_match[:k_type] 120 | v_type = Regexp.last_match[:v_type] 121 | {}.tap do |hash| 122 | value.each do |k, v| 123 | hash[_deserialize(k_type, k)] = _deserialize(v_type, v) 124 | end 125 | end 126 | else # model 127 | temp_model = DocuSign_Maestro.const_get(type).new 128 | temp_model.build_from_hash(value) 129 | end 130 | end 131 | 132 | # Returns the string representation of the object 133 | # @return [String] String presentation of the object 134 | def to_s 135 | to_hash.to_s 136 | end 137 | 138 | # to_body is an alias to to_hash (backward compatibility) 139 | # @return [Hash] Returns the object in the form of hash 140 | def to_body 141 | to_hash 142 | end 143 | 144 | # Returns the object in the form of hash 145 | # @return [Hash] Returns the object in the form of hash 146 | def to_hash 147 | hash = {} 148 | self.class.attribute_map.each_pair do |attr, param| 149 | value = self.send(attr) 150 | next if value.nil? 151 | hash[param] = _to_hash(value) 152 | end 153 | hash 154 | end 155 | 156 | # Outputs non-array value in the form of hash 157 | # For object, use to_hash. Otherwise, just return the value 158 | # @param [Object] value Any valid value 159 | # @return [Hash] Returns the value in the form of hash 160 | def _to_hash(value) 161 | if value.is_a?(Array) 162 | value.compact.map { |v| _to_hash(v) } 163 | elsif value.is_a?(Hash) 164 | {}.tap do |hash| 165 | value.each { |k, v| hash[k] = _to_hash(v) } 166 | end 167 | elsif value.respond_to? :to_hash 168 | value.to_hash 169 | else 170 | value 171 | end 172 | end 173 | 174 | end 175 | end 176 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/workflow_creator_id.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | # The DocuSign Admin user Id who has the ability to create workflow definitions. 16 | class WorkflowCreatorId 17 | # Attribute mapping from ruby-style variable name to JSON key. 18 | def self.attribute_map 19 | { 20 | } 21 | end 22 | 23 | # Attribute type mapping. 24 | def self.swagger_types 25 | { 26 | } 27 | end 28 | 29 | # Initializes the object 30 | # @param [Hash] attributes Model attributes in the form of hash 31 | def initialize(attributes = {}) 32 | return unless attributes.is_a?(Hash) 33 | 34 | # convert string to symbol for hash key 35 | attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v } 36 | end 37 | 38 | # Show invalid properties with the reasons. Usually used together with valid? 39 | # @return Array for valid properties with the reasons 40 | def list_invalid_properties 41 | invalid_properties = Array.new 42 | invalid_properties 43 | end 44 | 45 | # Check to see if the all the properties in the model are valid 46 | # @return true if the model is valid 47 | def valid? 48 | true 49 | end 50 | 51 | # Checks equality by comparing each attribute. 52 | # @param [Object] Object to be compared 53 | def ==(o) 54 | return true if self.equal?(o) 55 | self.class == o.class 56 | end 57 | 58 | # @see the `==` method 59 | # @param [Object] Object to be compared 60 | def eql?(o) 61 | self == o 62 | end 63 | 64 | # Calculates hash code according to all attributes. 65 | # @return [Fixnum] Hash code 66 | def hash 67 | [].hash 68 | end 69 | 70 | # Builds the object from hash 71 | # @param [Hash] attributes Model attributes in the form of hash 72 | # @return [Object] Returns the model itself 73 | def build_from_hash(attributes) 74 | return nil unless attributes.is_a?(Hash) 75 | self.class.swagger_types.each_pair do |key, type| 76 | if type =~ /\AArray<(.*)>/i 77 | # check to ensure the input is an array given that the attribute 78 | # is documented as an array but the input is not 79 | if attributes[self.class.attribute_map[key]].is_a?(Array) 80 | self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) }) 81 | end 82 | elsif !attributes[self.class.attribute_map[key]].nil? 83 | self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]])) 84 | end # or else data not found in attributes(hash), not an issue as the data can be optional 85 | end 86 | 87 | self 88 | end 89 | 90 | # Deserializes the data based on type 91 | # @param string type Data type 92 | # @param string value Value to be deserialized 93 | # @return [Object] Deserialized data 94 | def _deserialize(type, value) 95 | case type.to_sym 96 | when :DateTime 97 | DateTime.parse(value) 98 | when :Date 99 | Date.parse(value) 100 | when :String 101 | value.to_s 102 | when :Integer 103 | value.to_i 104 | when :Float 105 | value.to_f 106 | when :BOOLEAN 107 | if value.to_s =~ /\A(true|t|yes|y|1)\z/i 108 | true 109 | else 110 | false 111 | end 112 | when :Object 113 | # generic object (usually a Hash), return directly 114 | value 115 | when /\AArray<(?.+)>\z/ 116 | inner_type = Regexp.last_match[:inner_type] 117 | value.map { |v| _deserialize(inner_type, v) } 118 | when /\AHash<(?.+?), (?.+)>\z/ 119 | k_type = Regexp.last_match[:k_type] 120 | v_type = Regexp.last_match[:v_type] 121 | {}.tap do |hash| 122 | value.each do |k, v| 123 | hash[_deserialize(k_type, k)] = _deserialize(v_type, v) 124 | end 125 | end 126 | else # model 127 | temp_model = DocuSign_Maestro.const_get(type).new 128 | temp_model.build_from_hash(value) 129 | end 130 | end 131 | 132 | # Returns the string representation of the object 133 | # @return [String] String presentation of the object 134 | def to_s 135 | to_hash.to_s 136 | end 137 | 138 | # to_body is an alias to to_hash (backward compatibility) 139 | # @return [Hash] Returns the object in the form of hash 140 | def to_body 141 | to_hash 142 | end 143 | 144 | # Returns the object in the form of hash 145 | # @return [Hash] Returns the object in the form of hash 146 | def to_hash 147 | hash = {} 148 | self.class.attribute_map.each_pair do |attr, param| 149 | value = self.send(attr) 150 | next if value.nil? 151 | hash[param] = _to_hash(value) 152 | end 153 | hash 154 | end 155 | 156 | # Outputs non-array value in the form of hash 157 | # For object, use to_hash. Otherwise, just return the value 158 | # @param [Object] value Any valid value 159 | # @return [Hash] Returns the value in the form of hash 160 | def _to_hash(value) 161 | if value.is_a?(Array) 162 | value.compact.map { |v| _to_hash(v) } 163 | elsif value.is_a?(Hash) 164 | {}.tap do |hash| 165 | value.each { |k, v| hash[k] = _to_hash(v) } 166 | end 167 | elsif value.respond_to? :to_hash 168 | value.to_hash 169 | else 170 | value 171 | end 172 | end 173 | 174 | end 175 | end 176 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/record_string_or_variable_or_transformation.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | # A Record of strings to Strings, Variables, or Transformation Expressions 16 | class RecordStringOrVariableOrTransformation 17 | # Attribute mapping from ruby-style variable name to JSON key. 18 | def self.attribute_map 19 | { 20 | } 21 | end 22 | 23 | # Attribute type mapping. 24 | def self.swagger_types 25 | { 26 | } 27 | end 28 | 29 | # Initializes the object 30 | # @param [Hash] attributes Model attributes in the form of hash 31 | def initialize(attributes = {}) 32 | return unless attributes.is_a?(Hash) 33 | 34 | # convert string to symbol for hash key 35 | attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v } 36 | end 37 | 38 | # Show invalid properties with the reasons. Usually used together with valid? 39 | # @return Array for valid properties with the reasons 40 | def list_invalid_properties 41 | invalid_properties = Array.new 42 | invalid_properties 43 | end 44 | 45 | # Check to see if the all the properties in the model are valid 46 | # @return true if the model is valid 47 | def valid? 48 | true 49 | end 50 | 51 | # Checks equality by comparing each attribute. 52 | # @param [Object] Object to be compared 53 | def ==(o) 54 | return true if self.equal?(o) 55 | self.class == o.class 56 | end 57 | 58 | # @see the `==` method 59 | # @param [Object] Object to be compared 60 | def eql?(o) 61 | self == o 62 | end 63 | 64 | # Calculates hash code according to all attributes. 65 | # @return [Fixnum] Hash code 66 | def hash 67 | [].hash 68 | end 69 | 70 | # Builds the object from hash 71 | # @param [Hash] attributes Model attributes in the form of hash 72 | # @return [Object] Returns the model itself 73 | def build_from_hash(attributes) 74 | return nil unless attributes.is_a?(Hash) 75 | self.class.swagger_types.each_pair do |key, type| 76 | if type =~ /\AArray<(.*)>/i 77 | # check to ensure the input is an array given that the attribute 78 | # is documented as an array but the input is not 79 | if attributes[self.class.attribute_map[key]].is_a?(Array) 80 | self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) }) 81 | end 82 | elsif !attributes[self.class.attribute_map[key]].nil? 83 | self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]])) 84 | end # or else data not found in attributes(hash), not an issue as the data can be optional 85 | end 86 | 87 | self 88 | end 89 | 90 | # Deserializes the data based on type 91 | # @param string type Data type 92 | # @param string value Value to be deserialized 93 | # @return [Object] Deserialized data 94 | def _deserialize(type, value) 95 | case type.to_sym 96 | when :DateTime 97 | DateTime.parse(value) 98 | when :Date 99 | Date.parse(value) 100 | when :String 101 | value.to_s 102 | when :Integer 103 | value.to_i 104 | when :Float 105 | value.to_f 106 | when :BOOLEAN 107 | if value.to_s =~ /\A(true|t|yes|y|1)\z/i 108 | true 109 | else 110 | false 111 | end 112 | when :Object 113 | # generic object (usually a Hash), return directly 114 | value 115 | when /\AArray<(?.+)>\z/ 116 | inner_type = Regexp.last_match[:inner_type] 117 | value.map { |v| _deserialize(inner_type, v) } 118 | when /\AHash<(?.+?), (?.+)>\z/ 119 | k_type = Regexp.last_match[:k_type] 120 | v_type = Regexp.last_match[:v_type] 121 | {}.tap do |hash| 122 | value.each do |k, v| 123 | hash[_deserialize(k_type, k)] = _deserialize(v_type, v) 124 | end 125 | end 126 | else # model 127 | temp_model = DocuSign_Maestro.const_get(type).new 128 | temp_model.build_from_hash(value) 129 | end 130 | end 131 | 132 | # Returns the string representation of the object 133 | # @return [String] String presentation of the object 134 | def to_s 135 | to_hash.to_s 136 | end 137 | 138 | # to_body is an alias to to_hash (backward compatibility) 139 | # @return [Hash] Returns the object in the form of hash 140 | def to_body 141 | to_hash 142 | end 143 | 144 | # Returns the object in the form of hash 145 | # @return [Hash] Returns the object in the form of hash 146 | def to_hash 147 | hash = {} 148 | self.class.attribute_map.each_pair do |attr, param| 149 | value = self.send(attr) 150 | next if value.nil? 151 | hash[param] = _to_hash(value) 152 | end 153 | hash 154 | end 155 | 156 | # Outputs non-array value in the form of hash 157 | # For object, use to_hash. Otherwise, just return the value 158 | # @param [Object] value Any valid value 159 | # @return [Hash] Returns the value in the form of hash 160 | def _to_hash(value) 161 | if value.is_a?(Array) 162 | value.compact.map { |v| _to_hash(v) } 163 | elsif value.is_a?(Hash) 164 | {}.tap do |hash| 165 | value.each { |k, v| hash[k] = _to_hash(v) } 166 | end 167 | elsif value.respond_to? :to_hash 168 | value.to_hash 169 | else 170 | value 171 | end 172 | end 173 | 174 | end 175 | end 176 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/ds_workflow_variable_from_participant.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | # DS Workflow Variable from a Participant object. The definition is flexible based on the workflow definition. 16 | class DSWorkflowVariableFromParticipant 17 | # Attribute mapping from ruby-style variable name to JSON key. 18 | def self.attribute_map 19 | { 20 | } 21 | end 22 | 23 | # Attribute type mapping. 24 | def self.swagger_types 25 | { 26 | } 27 | end 28 | 29 | # Initializes the object 30 | # @param [Hash] attributes Model attributes in the form of hash 31 | def initialize(attributes = {}) 32 | return unless attributes.is_a?(Hash) 33 | 34 | # convert string to symbol for hash key 35 | attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v } 36 | end 37 | 38 | # Show invalid properties with the reasons. Usually used together with valid? 39 | # @return Array for valid properties with the reasons 40 | def list_invalid_properties 41 | invalid_properties = Array.new 42 | invalid_properties 43 | end 44 | 45 | # Check to see if the all the properties in the model are valid 46 | # @return true if the model is valid 47 | def valid? 48 | true 49 | end 50 | 51 | # Checks equality by comparing each attribute. 52 | # @param [Object] Object to be compared 53 | def ==(o) 54 | return true if self.equal?(o) 55 | self.class == o.class 56 | end 57 | 58 | # @see the `==` method 59 | # @param [Object] Object to be compared 60 | def eql?(o) 61 | self == o 62 | end 63 | 64 | # Calculates hash code according to all attributes. 65 | # @return [Fixnum] Hash code 66 | def hash 67 | [].hash 68 | end 69 | 70 | # Builds the object from hash 71 | # @param [Hash] attributes Model attributes in the form of hash 72 | # @return [Object] Returns the model itself 73 | def build_from_hash(attributes) 74 | return nil unless attributes.is_a?(Hash) 75 | self.class.swagger_types.each_pair do |key, type| 76 | if type =~ /\AArray<(.*)>/i 77 | # check to ensure the input is an array given that the attribute 78 | # is documented as an array but the input is not 79 | if attributes[self.class.attribute_map[key]].is_a?(Array) 80 | self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) }) 81 | end 82 | elsif !attributes[self.class.attribute_map[key]].nil? 83 | self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]])) 84 | end # or else data not found in attributes(hash), not an issue as the data can be optional 85 | end 86 | 87 | self 88 | end 89 | 90 | # Deserializes the data based on type 91 | # @param string type Data type 92 | # @param string value Value to be deserialized 93 | # @return [Object] Deserialized data 94 | def _deserialize(type, value) 95 | case type.to_sym 96 | when :DateTime 97 | DateTime.parse(value) 98 | when :Date 99 | Date.parse(value) 100 | when :String 101 | value.to_s 102 | when :Integer 103 | value.to_i 104 | when :Float 105 | value.to_f 106 | when :BOOLEAN 107 | if value.to_s =~ /\A(true|t|yes|y|1)\z/i 108 | true 109 | else 110 | false 111 | end 112 | when :Object 113 | # generic object (usually a Hash), return directly 114 | value 115 | when /\AArray<(?.+)>\z/ 116 | inner_type = Regexp.last_match[:inner_type] 117 | value.map { |v| _deserialize(inner_type, v) } 118 | when /\AHash<(?.+?), (?.+)>\z/ 119 | k_type = Regexp.last_match[:k_type] 120 | v_type = Regexp.last_match[:v_type] 121 | {}.tap do |hash| 122 | value.each do |k, v| 123 | hash[_deserialize(k_type, k)] = _deserialize(v_type, v) 124 | end 125 | end 126 | else # model 127 | temp_model = DocuSign_Maestro.const_get(type).new 128 | temp_model.build_from_hash(value) 129 | end 130 | end 131 | 132 | # Returns the string representation of the object 133 | # @return [String] String presentation of the object 134 | def to_s 135 | to_hash.to_s 136 | end 137 | 138 | # to_body is an alias to to_hash (backward compatibility) 139 | # @return [Hash] Returns the object in the form of hash 140 | def to_body 141 | to_hash 142 | end 143 | 144 | # Returns the object in the form of hash 145 | # @return [Hash] Returns the object in the form of hash 146 | def to_hash 147 | hash = {} 148 | self.class.attribute_map.each_pair do |attr, param| 149 | value = self.send(attr) 150 | next if value.nil? 151 | hash[param] = _to_hash(value) 152 | end 153 | hash 154 | end 155 | 156 | # Outputs non-array value in the form of hash 157 | # For object, use to_hash. Otherwise, just return the value 158 | # @param [Object] value Any valid value 159 | # @return [Hash] Returns the value in the form of hash 160 | def _to_hash(value) 161 | if value.is_a?(Array) 162 | value.compact.map { |v| _to_hash(v) } 163 | elsif value.is_a?(Hash) 164 | {}.tap do |hash| 165 | value.each { |k, v| hash[k] = _to_hash(v) } 166 | end 167 | elsif value.respond_to? :to_hash 168 | value.to_hash 169 | else 170 | value 171 | end 172 | end 173 | 174 | end 175 | end 176 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/number_or_variable.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | # Object stands for a number or a Variable. This object should be any of the following object models or types: [number, #/definitions/DSWorkflowVariable] 16 | class NumberOrVariable 17 | # Attribute mapping from ruby-style variable name to JSON key. 18 | def self.attribute_map 19 | { 20 | } 21 | end 22 | 23 | # Attribute type mapping. 24 | def self.swagger_types 25 | { 26 | } 27 | end 28 | 29 | # Initializes the object 30 | # @param [Hash] attributes Model attributes in the form of hash 31 | def initialize(attributes = {}) 32 | return unless attributes.is_a?(Hash) 33 | 34 | # convert string to symbol for hash key 35 | attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v } 36 | end 37 | 38 | # Show invalid properties with the reasons. Usually used together with valid? 39 | # @return Array for valid properties with the reasons 40 | def list_invalid_properties 41 | invalid_properties = Array.new 42 | invalid_properties 43 | end 44 | 45 | # Check to see if the all the properties in the model are valid 46 | # @return true if the model is valid 47 | def valid? 48 | true 49 | end 50 | 51 | # Checks equality by comparing each attribute. 52 | # @param [Object] Object to be compared 53 | def ==(o) 54 | return true if self.equal?(o) 55 | self.class == o.class 56 | end 57 | 58 | # @see the `==` method 59 | # @param [Object] Object to be compared 60 | def eql?(o) 61 | self == o 62 | end 63 | 64 | # Calculates hash code according to all attributes. 65 | # @return [Fixnum] Hash code 66 | def hash 67 | [].hash 68 | end 69 | 70 | # Builds the object from hash 71 | # @param [Hash] attributes Model attributes in the form of hash 72 | # @return [Object] Returns the model itself 73 | def build_from_hash(attributes) 74 | return nil unless attributes.is_a?(Hash) 75 | self.class.swagger_types.each_pair do |key, type| 76 | if type =~ /\AArray<(.*)>/i 77 | # check to ensure the input is an array given that the attribute 78 | # is documented as an array but the input is not 79 | if attributes[self.class.attribute_map[key]].is_a?(Array) 80 | self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) }) 81 | end 82 | elsif !attributes[self.class.attribute_map[key]].nil? 83 | self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]])) 84 | end # or else data not found in attributes(hash), not an issue as the data can be optional 85 | end 86 | 87 | self 88 | end 89 | 90 | # Deserializes the data based on type 91 | # @param string type Data type 92 | # @param string value Value to be deserialized 93 | # @return [Object] Deserialized data 94 | def _deserialize(type, value) 95 | case type.to_sym 96 | when :DateTime 97 | DateTime.parse(value) 98 | when :Date 99 | Date.parse(value) 100 | when :String 101 | value.to_s 102 | when :Integer 103 | value.to_i 104 | when :Float 105 | value.to_f 106 | when :BOOLEAN 107 | if value.to_s =~ /\A(true|t|yes|y|1)\z/i 108 | true 109 | else 110 | false 111 | end 112 | when :Object 113 | # generic object (usually a Hash), return directly 114 | value 115 | when /\AArray<(?.+)>\z/ 116 | inner_type = Regexp.last_match[:inner_type] 117 | value.map { |v| _deserialize(inner_type, v) } 118 | when /\AHash<(?.+?), (?.+)>\z/ 119 | k_type = Regexp.last_match[:k_type] 120 | v_type = Regexp.last_match[:v_type] 121 | {}.tap do |hash| 122 | value.each do |k, v| 123 | hash[_deserialize(k_type, k)] = _deserialize(v_type, v) 124 | end 125 | end 126 | else # model 127 | temp_model = DocuSign_Maestro.const_get(type).new 128 | temp_model.build_from_hash(value) 129 | end 130 | end 131 | 132 | # Returns the string representation of the object 133 | # @return [String] String presentation of the object 134 | def to_s 135 | to_hash.to_s 136 | end 137 | 138 | # to_body is an alias to to_hash (backward compatibility) 139 | # @return [Hash] Returns the object in the form of hash 140 | def to_body 141 | to_hash 142 | end 143 | 144 | # Returns the object in the form of hash 145 | # @return [Hash] Returns the object in the form of hash 146 | def to_hash 147 | hash = {} 148 | self.class.attribute_map.each_pair do |attr, param| 149 | value = self.send(attr) 150 | next if value.nil? 151 | hash[param] = _to_hash(value) 152 | end 153 | hash 154 | end 155 | 156 | # Outputs non-array value in the form of hash 157 | # For object, use to_hash. Otherwise, just return the value 158 | # @param [Object] value Any valid value 159 | # @return [Hash] Returns the value in the form of hash 160 | def _to_hash(value) 161 | if value.is_a?(Array) 162 | value.compact.map { |v| _to_hash(v) } 163 | elsif value.is_a?(Hash) 164 | {}.tap do |hash| 165 | value.each { |k, v| hash[k] = _to_hash(v) } 166 | end 167 | elsif value.respond_to? :to_hash 168 | value.to_hash 169 | else 170 | value 171 | end 172 | end 173 | 174 | end 175 | end 176 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/e_sign_documents.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | # ESignDocument Object. This object should be any of the following object models: [#/definitions/ESignDocumentFromPreviousStep, #/definitions/ESignDocumentFromESignTemplate] 16 | class ESignDocuments 17 | # Attribute mapping from ruby-style variable name to JSON key. 18 | def self.attribute_map 19 | { 20 | } 21 | end 22 | 23 | # Attribute type mapping. 24 | def self.swagger_types 25 | { 26 | } 27 | end 28 | 29 | # Initializes the object 30 | # @param [Hash] attributes Model attributes in the form of hash 31 | def initialize(attributes = {}) 32 | return unless attributes.is_a?(Hash) 33 | 34 | # convert string to symbol for hash key 35 | attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v } 36 | end 37 | 38 | # Show invalid properties with the reasons. Usually used together with valid? 39 | # @return Array for valid properties with the reasons 40 | def list_invalid_properties 41 | invalid_properties = Array.new 42 | invalid_properties 43 | end 44 | 45 | # Check to see if the all the properties in the model are valid 46 | # @return true if the model is valid 47 | def valid? 48 | true 49 | end 50 | 51 | # Checks equality by comparing each attribute. 52 | # @param [Object] Object to be compared 53 | def ==(o) 54 | return true if self.equal?(o) 55 | self.class == o.class 56 | end 57 | 58 | # @see the `==` method 59 | # @param [Object] Object to be compared 60 | def eql?(o) 61 | self == o 62 | end 63 | 64 | # Calculates hash code according to all attributes. 65 | # @return [Fixnum] Hash code 66 | def hash 67 | [].hash 68 | end 69 | 70 | # Builds the object from hash 71 | # @param [Hash] attributes Model attributes in the form of hash 72 | # @return [Object] Returns the model itself 73 | def build_from_hash(attributes) 74 | return nil unless attributes.is_a?(Hash) 75 | self.class.swagger_types.each_pair do |key, type| 76 | if type =~ /\AArray<(.*)>/i 77 | # check to ensure the input is an array given that the attribute 78 | # is documented as an array but the input is not 79 | if attributes[self.class.attribute_map[key]].is_a?(Array) 80 | self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) }) 81 | end 82 | elsif !attributes[self.class.attribute_map[key]].nil? 83 | self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]])) 84 | end # or else data not found in attributes(hash), not an issue as the data can be optional 85 | end 86 | 87 | self 88 | end 89 | 90 | # Deserializes the data based on type 91 | # @param string type Data type 92 | # @param string value Value to be deserialized 93 | # @return [Object] Deserialized data 94 | def _deserialize(type, value) 95 | case type.to_sym 96 | when :DateTime 97 | DateTime.parse(value) 98 | when :Date 99 | Date.parse(value) 100 | when :String 101 | value.to_s 102 | when :Integer 103 | value.to_i 104 | when :Float 105 | value.to_f 106 | when :BOOLEAN 107 | if value.to_s =~ /\A(true|t|yes|y|1)\z/i 108 | true 109 | else 110 | false 111 | end 112 | when :Object 113 | # generic object (usually a Hash), return directly 114 | value 115 | when /\AArray<(?.+)>\z/ 116 | inner_type = Regexp.last_match[:inner_type] 117 | value.map { |v| _deserialize(inner_type, v) } 118 | when /\AHash<(?.+?), (?.+)>\z/ 119 | k_type = Regexp.last_match[:k_type] 120 | v_type = Regexp.last_match[:v_type] 121 | {}.tap do |hash| 122 | value.each do |k, v| 123 | hash[_deserialize(k_type, k)] = _deserialize(v_type, v) 124 | end 125 | end 126 | else # model 127 | temp_model = DocuSign_Maestro.const_get(type).new 128 | temp_model.build_from_hash(value) 129 | end 130 | end 131 | 132 | # Returns the string representation of the object 133 | # @return [String] String presentation of the object 134 | def to_s 135 | to_hash.to_s 136 | end 137 | 138 | # to_body is an alias to to_hash (backward compatibility) 139 | # @return [Hash] Returns the object in the form of hash 140 | def to_body 141 | to_hash 142 | end 143 | 144 | # Returns the object in the form of hash 145 | # @return [Hash] Returns the object in the form of hash 146 | def to_hash 147 | hash = {} 148 | self.class.attribute_map.each_pair do |attr, param| 149 | value = self.send(attr) 150 | next if value.nil? 151 | hash[param] = _to_hash(value) 152 | end 153 | hash 154 | end 155 | 156 | # Outputs non-array value in the form of hash 157 | # For object, use to_hash. Otherwise, just return the value 158 | # @param [Object] value Any valid value 159 | # @return [Hash] Returns the value in the form of hash 160 | def _to_hash(value) 161 | if value.is_a?(Array) 162 | value.compact.map { |v| _to_hash(v) } 163 | elsif value.is_a?(Hash) 164 | {}.tap do |hash| 165 | value.each { |k, v| hash[k] = _to_hash(v) } 166 | end 167 | elsif value.respond_to? :to_hash 168 | value.to_hash 169 | else 170 | value 171 | end 172 | end 173 | 174 | end 175 | end 176 | -------------------------------------------------------------------------------- /lib/docusign_maestro/models/ds_service_step.rb: -------------------------------------------------------------------------------- 1 | =begin 2 | #Maestro API 3 | 4 | #Maestro authors and executes experiences that allow non-coders the ability to define Simple Business Process without having to write code and to deploy them seamlessly without having to have development expertise 5 | 6 | OpenAPI spec version: 1.0.0 7 | Contact: devcenter@docusign.com 8 | Generated by: https://github.com/swagger-api/swagger-codegen.git 9 | 10 | =end 11 | 12 | require 'date' 13 | 14 | module DocuSign_Maestro 15 | # A DS Workflow Service Step. This object should be any of the following object models: [#/definitions/DSWebFormsStep, #/definitions/DSIdvStep, #/definitions/DSDocGenStep, #/definitions/DSSignStep] 16 | class DSServiceStep 17 | # Attribute mapping from ruby-style variable name to JSON key. 18 | def self.attribute_map 19 | { 20 | } 21 | end 22 | 23 | # Attribute type mapping. 24 | def self.swagger_types 25 | { 26 | } 27 | end 28 | 29 | # Initializes the object 30 | # @param [Hash] attributes Model attributes in the form of hash 31 | def initialize(attributes = {}) 32 | return unless attributes.is_a?(Hash) 33 | 34 | # convert string to symbol for hash key 35 | attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v } 36 | end 37 | 38 | # Show invalid properties with the reasons. Usually used together with valid? 39 | # @return Array for valid properties with the reasons 40 | def list_invalid_properties 41 | invalid_properties = Array.new 42 | invalid_properties 43 | end 44 | 45 | # Check to see if the all the properties in the model are valid 46 | # @return true if the model is valid 47 | def valid? 48 | true 49 | end 50 | 51 | # Checks equality by comparing each attribute. 52 | # @param [Object] Object to be compared 53 | def ==(o) 54 | return true if self.equal?(o) 55 | self.class == o.class 56 | end 57 | 58 | # @see the `==` method 59 | # @param [Object] Object to be compared 60 | def eql?(o) 61 | self == o 62 | end 63 | 64 | # Calculates hash code according to all attributes. 65 | # @return [Fixnum] Hash code 66 | def hash 67 | [].hash 68 | end 69 | 70 | # Builds the object from hash 71 | # @param [Hash] attributes Model attributes in the form of hash 72 | # @return [Object] Returns the model itself 73 | def build_from_hash(attributes) 74 | return nil unless attributes.is_a?(Hash) 75 | self.class.swagger_types.each_pair do |key, type| 76 | if type =~ /\AArray<(.*)>/i 77 | # check to ensure the input is an array given that the attribute 78 | # is documented as an array but the input is not 79 | if attributes[self.class.attribute_map[key]].is_a?(Array) 80 | self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) }) 81 | end 82 | elsif !attributes[self.class.attribute_map[key]].nil? 83 | self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]])) 84 | end # or else data not found in attributes(hash), not an issue as the data can be optional 85 | end 86 | 87 | self 88 | end 89 | 90 | # Deserializes the data based on type 91 | # @param string type Data type 92 | # @param string value Value to be deserialized 93 | # @return [Object] Deserialized data 94 | def _deserialize(type, value) 95 | case type.to_sym 96 | when :DateTime 97 | DateTime.parse(value) 98 | when :Date 99 | Date.parse(value) 100 | when :String 101 | value.to_s 102 | when :Integer 103 | value.to_i 104 | when :Float 105 | value.to_f 106 | when :BOOLEAN 107 | if value.to_s =~ /\A(true|t|yes|y|1)\z/i 108 | true 109 | else 110 | false 111 | end 112 | when :Object 113 | # generic object (usually a Hash), return directly 114 | value 115 | when /\AArray<(?.+)>\z/ 116 | inner_type = Regexp.last_match[:inner_type] 117 | value.map { |v| _deserialize(inner_type, v) } 118 | when /\AHash<(?.+?), (?.+)>\z/ 119 | k_type = Regexp.last_match[:k_type] 120 | v_type = Regexp.last_match[:v_type] 121 | {}.tap do |hash| 122 | value.each do |k, v| 123 | hash[_deserialize(k_type, k)] = _deserialize(v_type, v) 124 | end 125 | end 126 | else # model 127 | temp_model = DocuSign_Maestro.const_get(type).new 128 | temp_model.build_from_hash(value) 129 | end 130 | end 131 | 132 | # Returns the string representation of the object 133 | # @return [String] String presentation of the object 134 | def to_s 135 | to_hash.to_s 136 | end 137 | 138 | # to_body is an alias to to_hash (backward compatibility) 139 | # @return [Hash] Returns the object in the form of hash 140 | def to_body 141 | to_hash 142 | end 143 | 144 | # Returns the object in the form of hash 145 | # @return [Hash] Returns the object in the form of hash 146 | def to_hash 147 | hash = {} 148 | self.class.attribute_map.each_pair do |attr, param| 149 | value = self.send(attr) 150 | next if value.nil? 151 | hash[param] = _to_hash(value) 152 | end 153 | hash 154 | end 155 | 156 | # Outputs non-array value in the form of hash 157 | # For object, use to_hash. Otherwise, just return the value 158 | # @param [Object] value Any valid value 159 | # @return [Hash] Returns the value in the form of hash 160 | def _to_hash(value) 161 | if value.is_a?(Array) 162 | value.compact.map { |v| _to_hash(v) } 163 | elsif value.is_a?(Hash) 164 | {}.tap do |hash| 165 | value.each { |k, v| hash[k] = _to_hash(v) } 166 | end 167 | elsif value.respond_to? :to_hash 168 | value.to_hash 169 | else 170 | value 171 | end 172 | end 173 | 174 | end 175 | end 176 | --------------------------------------------------------------------------------