flywheel-sdk 21.4.0__py3-none-any.whl → 21.4.0rc0__py3-none-any.whl

flywheel/api/subjects_api.py

@@ -30,11 +30,9 @@ class SubjectsApi(object):
         Create a new subject
         This method makes a synchronous HTTP request by default.
 
-        :param body:
-        :type body: SubjectInput
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: InsertedId
+        :param SubjectInput body: (required)
+        :param bool async_: Perform the request asynchronously
+        :return: InsertedId
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -58,11 +56,9 @@ class SubjectsApi(object):
         Create a new subject
         This method makes a synchronous HTTP request by default.
 
-        :param body:
-        :type body: SubjectInput
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: InsertedId
+        :param SubjectInput body: (required)
+        :param bool async_: Perform the request asynchronously
+        :return: InsertedId
         """
 
         all_params = ['body',]  # noqa: E501
@@ -142,15 +138,12 @@ class SubjectsApi(object):
         When query param \"job\" is \"true\", send JSON to create an analysis and job.  Otherwise, multipart/form-data to upload files and create an analysis.
         This method makes a synchronous HTTP request by default.
 
-        :param cid:
-        :type cid: str
-        :param body:
-        :type body: union[AdhocAnalysisInput,JobAnalysisInput]
-        :param job: returns job_id instead of analysis.id, defaults to false
-        :type job: bool, optional
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: InsertedId
+        :param str cid: (required)
+        :param union[AdhocAnalysisInput,JobAnalysisInput] body: (required)
+        :param bool job: returns job_id instead of analysis.id
+        :param bool job: returns job_id instead of analysis.id
+        :param bool async_: Perform the request asynchronously
+        :return: InsertedId
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -174,18 +167,15 @@ class SubjectsApi(object):
         When query param \"job\" is \"true\", send JSON to create an analysis and job.  Otherwise, multipart/form-data to upload files and create an analysis.
         This method makes a synchronous HTTP request by default.
 
-        :param cid:
-        :type cid: str
-        :param body:
-        :type body: union[AdhocAnalysisInput,JobAnalysisInput]
-        :param job: returns job_id instead of analysis.id, defaults to false
-        :type job: bool, optional
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: InsertedId
+        :param str cid: (required)
+        :param union[AdhocAnalysisInput,JobAnalysisInput] body: (required)
+        :param bool job: returns job_id instead of analysis.id
+        :param bool job: returns job_id instead of analysis.id
+        :param bool async_: Perform the request asynchronously
+        :return: InsertedId
         """
 
-        all_params = ['cid','body','job',]  # noqa: E501
+        all_params = ['cid','body','job','job',]  # noqa: E501
         all_params.append('async_')
         all_params.append('_return_http_data_only')
         all_params.append('_preload_content')
@@ -218,6 +208,8 @@ class SubjectsApi(object):
             path_params['cid'] = params['cid']  # noqa: E501
 
         query_params = []
+        if 'job' in params:
+            query_params.append(('job', params['job']))  # noqa: E501
         if 'job' in params:
             query_params.append(('job', params['job']))  # noqa: E501
         else:
@@ -272,15 +264,11 @@ class SubjectsApi(object):
         Add a note to a(n) subject analysis.
         This method makes a synchronous HTTP request by default.
 
-        :param container_id: 24-char hex id
-        :type container_id: str
-        :param analysis_id: 24-char hex analysis id
-        :type analysis_id: str
-        :param body:
-        :type body: NoteInput
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: Note
+        :param str container_id: 24-char hex id (required)
+        :param str analysis_id: 24-char hex analysis id (required)
+        :param NoteInput body: (required)
+        :param bool async_: Perform the request asynchronously
+        :return: Note
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -304,15 +292,11 @@ class SubjectsApi(object):
         Add a note to a(n) subject analysis.
         This method makes a synchronous HTTP request by default.
 
-        :param container_id: 24-char hex id
-        :type container_id: str
-        :param analysis_id: 24-char hex analysis id
-        :type analysis_id: str
-        :param body:
-        :type body: NoteInput
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: Note
+        :param str container_id: 24-char hex id (required)
+        :param str analysis_id: 24-char hex analysis id (required)
+        :param NoteInput body: (required)
+        :param bool async_: Perform the request asynchronously
+        :return: Note
         """
 
         all_params = ['container_id','analysis_id','body',]  # noqa: E501
@@ -404,13 +388,10 @@ class SubjectsApi(object):
         Add a note to a(n) subject.
         This method makes a synchronous HTTP request by default.
 
-        :param container_id:
-        :type container_id: str
-        :param body:
-        :type body: NoteInput
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: Note
+        :param str container_id: (required)
+        :param NoteInput body: (required)
+        :param bool async_: Perform the request asynchronously
+        :return: Note
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -434,13 +415,10 @@ class SubjectsApi(object):
         Add a note to a(n) subject.
         This method makes a synchronous HTTP request by default.
 
-        :param container_id:
-        :type container_id: str
-        :param body:
-        :type body: NoteInput
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: Note
+        :param str container_id: (required)
+        :param NoteInput body: (required)
+        :param bool async_: Perform the request asynchronously
+        :return: Note
         """
 
         all_params = ['container_id','body',]  # noqa: E501
@@ -526,13 +504,10 @@ class SubjectsApi(object):
         Propagates changes to projects, sessions and acquisitions
         This method makes a synchronous HTTP request by default.
 
-        :param cid:
-        :type cid: str
-        :param body:
-        :type body: Tag
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: ModifiedResult
+        :param str cid: (required)
+        :param Tag body: (required)
+        :param bool async_: Perform the request asynchronously
+        :return: ModifiedResult
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -556,13 +531,10 @@ class SubjectsApi(object):
         Propagates changes to projects, sessions and acquisitions
         This method makes a synchronous HTTP request by default.
 
-        :param cid:
-        :type cid: str
-        :param body:
-        :type body: Tag
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: ModifiedResult
+        :param str cid: (required)
+        :param Tag body: (required)
+        :param bool async_: Perform the request asynchronously
+        :return: ModifiedResult
         """
 
         all_params = ['cid','body',]  # noqa: E501
@@ -648,13 +620,10 @@ class SubjectsApi(object):
         Add multiple tags to a(n) subject
         This method makes a synchronous HTTP request by default.
 
-        :param cid:
-        :type cid: str
-        :param body:
-        :type body: list[str]
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: None
+        :param str cid: (required)
+        :param list[str] body: (required)
+        :param bool async_: Perform the request asynchronously
+        :return: None
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -678,13 +647,10 @@ class SubjectsApi(object):
         Add multiple tags to a(n) subject
         This method makes a synchronous HTTP request by default.
 
-        :param cid:
-        :type cid: str
-        :param body:
-        :type body: list[str]
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: None
+        :param str cid: (required)
+        :param list[str] body: (required)
+        :param bool async_: Perform the request asynchronously
+        :return: None
         """
 
         all_params = ['cid','body',]  # noqa: E501
@@ -763,11 +729,9 @@ class SubjectsApi(object):
         The workflow is the following.   - send `patient_id` (e.g., MRN) and/or `first_name`, `last_name`, `date_of_birth`   - indicate whether to use `patient_id` for identification or `first_name`, `last_name`, `date_of_birth`     by the `use_patient_id` field   - the response will contain a master subject code   - if you send the same identifying information again, you will receive the same code  Note that if you received a MSC code for example by just providing the `patient_id`, you can save more information for that MSC in a second request (`first_name`, `last_name`, `date_of_birth`). Only the missing fields will be set, so you can't update any existing field (e.g. changing the name). Since you can create multiple MSC codes with the same name and date of birth using different patient ids, you will get HTTP 400 error if you request an MSC code by name and date of birth and there are multiple matches. In this case you need to use patient id.
         This method makes a synchronous HTTP request by default.
 
-        :param body:
-        :type body: union[MasterSubjectCodeInput,MasterSubjectCodeDobInput]
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: MasterSubjectCodeOutput
+        :param union[MasterSubjectCodeInput,MasterSubjectCodeDobInput] body: (required)
+        :param bool async_: Perform the request asynchronously
+        :return: MasterSubjectCodeOutput
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -791,11 +755,9 @@ class SubjectsApi(object):
         The workflow is the following.   - send `patient_id` (e.g., MRN) and/or `first_name`, `last_name`, `date_of_birth`   - indicate whether to use `patient_id` for identification or `first_name`, `last_name`, `date_of_birth`     by the `use_patient_id` field   - the response will contain a master subject code   - if you send the same identifying information again, you will receive the same code  Note that if you received a MSC code for example by just providing the `patient_id`, you can save more information for that MSC in a second request (`first_name`, `last_name`, `date_of_birth`). Only the missing fields will be set, so you can't update any existing field (e.g. changing the name). Since you can create multiple MSC codes with the same name and date of birth using different patient ids, you will get HTTP 400 error if you request an MSC code by name and date of birth and there are multiple matches. In this case you need to use patient id.
         This method makes a synchronous HTTP request by default.
 
-        :param body:
-        :type body: union[MasterSubjectCodeInput,MasterSubjectCodeDobInput]
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: MasterSubjectCodeOutput
+        :param union[MasterSubjectCodeInput,MasterSubjectCodeDobInput] body: (required)
+        :param bool async_: Perform the request asynchronously
+        :return: MasterSubjectCodeOutput
         """
 
         all_params = ['body',]  # noqa: E501
@@ -875,13 +837,10 @@ class SubjectsApi(object):
         Read-write project permissions are required to delete a subject. Admin project permissions are required if the subject or it's acquisitions contain data uploaded by sources other than users and jobs.
         This method makes a synchronous HTTP request by default.
 
-        :param subject_id: 24-char hex subject id
-        :type subject_id: str
-        :param delete_reason:
-        :type delete_reason: ContainerDeleteReason, optional
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: DeletedResult
+        :param str subject_id: 24-char hex subject id (required)
+        :param ContainerDeleteReason delete_reason:
+        :param bool async_: Perform the request asynchronously
+        :return: DeletedResult
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -905,13 +864,10 @@ class SubjectsApi(object):
         Read-write project permissions are required to delete a subject. Admin project permissions are required if the subject or it's acquisitions contain data uploaded by sources other than users and jobs.
         This method makes a synchronous HTTP request by default.
 
-        :param subject_id: 24-char hex subject id
-        :type subject_id: str
-        :param delete_reason:
-        :type delete_reason: ContainerDeleteReason, optional
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: DeletedResult
+        :param str subject_id: 24-char hex subject id (required)
+        :param ContainerDeleteReason delete_reason:
+        :param bool async_: Perform the request asynchronously
+        :return: DeletedResult
         """
 
         all_params = ['subject_id','delete_reason',]  # noqa: E501
@@ -982,15 +938,11 @@ class SubjectsApi(object):
         Delete an analysis for a container.
         This method makes a synchronous HTTP request by default.
 
-        :param cid:
-        :type cid: str
-        :param analysis_id:
-        :type analysis_id: str
-        :param delete_reason: Provide a reason for the deletion
-        :type delete_reason: ContainerDeleteReason, optional
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: DeletedResult
+        :param str cid: (required)
+        :param str analysis_id: (required)
+        :param ContainerDeleteReason delete_reason: Provide a reason for the deletion
+        :param bool async_: Perform the request asynchronously
+        :return: DeletedResult
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -1014,15 +966,11 @@ class SubjectsApi(object):
         Delete an analysis for a container.
         This method makes a synchronous HTTP request by default.
 
-        :param cid:
-        :type cid: str
-        :param analysis_id:
-        :type analysis_id: str
-        :param delete_reason: Provide a reason for the deletion
-        :type delete_reason: ContainerDeleteReason, optional
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: DeletedResult
+        :param str cid: (required)
+        :param str analysis_id: (required)
+        :param ContainerDeleteReason delete_reason: Provide a reason for the deletion
+        :param bool async_: Perform the request asynchronously
+        :return: DeletedResult
         """
 
         all_params = ['cid','analysis_id','delete_reason',]  # noqa: E501
@@ -1099,15 +1047,11 @@ class SubjectsApi(object):
         Remove a note from a(n) subject analysis.
         This method makes a synchronous HTTP request by default.
 
-        :param cid: 24-char hex id
-        :type cid: str
-        :param analysis_id: 24-char hex analysis id
-        :type analysis_id: str
-        :param note_id: 24-char hex note id
-        :type note_id: str
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: DeletedResult
+        :param str cid: 24-char hex id (required)
+        :param str analysis_id: 24-char hex analysis id (required)
+        :param str note_id: 24-char hex note id (required)
+        :param bool async_: Perform the request asynchronously
+        :return: DeletedResult
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -1131,15 +1075,11 @@ class SubjectsApi(object):
         Remove a note from a(n) subject analysis.
         This method makes a synchronous HTTP request by default.
 
-        :param cid: 24-char hex id
-        :type cid: str
-        :param analysis_id: 24-char hex analysis id
-        :type analysis_id: str
-        :param note_id: 24-char hex note id
-        :type note_id: str
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: DeletedResult
+        :param str cid: 24-char hex id (required)
+        :param str analysis_id: 24-char hex analysis id (required)
+        :param str note_id: 24-char hex note id (required)
+        :param bool async_: Perform the request asynchronously
+        :return: DeletedResult
         """
 
         all_params = ['cid','analysis_id','note_id',]  # noqa: E501
@@ -1220,17 +1160,12 @@ class SubjectsApi(object):
         A user with read-write or higher permissions on the container may delete files that were uploaded by users or were the output of jobs. (Specifically, files whose `origin.type` is either `job` or `user`.) <br/> A user with admin permissions on the container may delete any file.
         This method makes a synchronous HTTP request by default.
 
-        :param cid:
-        :type cid: str
-        :param filename:
-        :type filename: str
-        :param delete_reason: A reason for deletion when audit-trail is enabled
-        :type delete_reason: ContainerDeleteReason, optional
-        :param force: Force deletion of the file even if some checks fail. Deprecated, will be removed in a future release., defaults to false
-        :type force: bool, optional
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: DeletedResult
+        :param str cid: (required)
+        :param str filename: (required)
+        :param ContainerDeleteReason delete_reason: A reason for deletion when audit-trail is enabled
+        :param bool force: Force deletion of the file even if some checks fail. Deprecated, will be removed in a future release.
+        :param bool async_: Perform the request asynchronously
+        :return: DeletedResult
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -1254,17 +1189,12 @@ class SubjectsApi(object):
         A user with read-write or higher permissions on the container may delete files that were uploaded by users or were the output of jobs. (Specifically, files whose `origin.type` is either `job` or `user`.) <br/> A user with admin permissions on the container may delete any file.
         This method makes a synchronous HTTP request by default.
 
-        :param cid:
-        :type cid: str
-        :param filename:
-        :type filename: str
-        :param delete_reason: A reason for deletion when audit-trail is enabled
-        :type delete_reason: ContainerDeleteReason, optional
-        :param force: Force deletion of the file even if some checks fail. Deprecated, will be removed in a future release., defaults to false
-        :type force: bool, optional
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: DeletedResult
+        :param str cid: (required)
+        :param str filename: (required)
+        :param ContainerDeleteReason delete_reason: A reason for deletion when audit-trail is enabled
+        :param bool force: Force deletion of the file even if some checks fail. Deprecated, will be removed in a future release.
+        :param bool async_: Perform the request asynchronously
+        :return: DeletedResult
         """
 
         all_params = ['cid','filename','delete_reason','force',]  # noqa: E501
@@ -1343,13 +1273,10 @@ class SubjectsApi(object):
         Remove a note from a(n) subject
         This method makes a synchronous HTTP request by default.
 
-        :param cid:
-        :type cid: str
-        :param note_id:
-        :type note_id: str
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: DeletedResult
+        :param str cid: (required)
+        :param str note_id: (required)
+        :param bool async_: Perform the request asynchronously
+        :return: DeletedResult
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -1373,13 +1300,10 @@ class SubjectsApi(object):
         Remove a note from a(n) subject
         This method makes a synchronous HTTP request by default.
 
-        :param cid:
-        :type cid: str
-        :param note_id:
-        :type note_id: str
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: DeletedResult
+        :param str cid: (required)
+        :param str note_id: (required)
+        :param bool async_: Perform the request asynchronously
+        :return: DeletedResult
         """
 
         all_params = ['cid','note_id',]  # noqa: E501
@@ -1454,13 +1378,10 @@ class SubjectsApi(object):
         Delete a tag
         This method makes a synchronous HTTP request by default.
 
-        :param cid:
-        :type cid: str
-        :param value: The tag to interact with
-        :type value: str
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: DeletedResult
+        :param str cid: (required)
+        :param str value: The tag to interact with (required)
+        :param bool async_: Perform the request asynchronously
+        :return: DeletedResult
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -1484,13 +1405,10 @@ class SubjectsApi(object):
         Delete a tag
         This method makes a synchronous HTTP request by default.
 
-        :param cid:
-        :type cid: str
-        :param value: The tag to interact with
-        :type value: str
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: DeletedResult
+        :param str cid: (required)
+        :param str value: The tag to interact with (required)
+        :param bool async_: Perform the request asynchronously
+        :return: DeletedResult
         """
 
         all_params = ['cid','value',]  # noqa: E501
@@ -1565,13 +1483,10 @@ class SubjectsApi(object):
         Delete multiple tags from a(n) subject
         This method makes a synchronous HTTP request by default.
 
-        :param cid:
-        :type cid: str
-        :param body:
-        :type body: list[str]
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: None
+        :param str cid: (required)
+        :param list[str] body: (required)
+        :param bool async_: Perform the request asynchronously
+        :return: None
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -1595,13 +1510,10 @@ class SubjectsApi(object):
         Delete multiple tags from a(n) subject
         This method makes a synchronous HTTP request by default.
 
-        :param cid:
-        :type cid: str
-        :param body:
-        :type body: list[str]
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: None
+        :param str cid: (required)
+        :param list[str] body: (required)
+        :param bool async_: Perform the request asynchronously
+        :return: None
         """
 
         all_params = ['cid','body',]  # noqa: E501
@@ -1680,13 +1592,10 @@ class SubjectsApi(object):
         Delete multiple subjects by ID list
         This method makes a synchronous HTTP request by default.
 
-        :param body: List of IDs to delete
-        :type body: list[str]
-        :param delete_reason:
-        :type delete_reason: ContainerDeleteReason, optional
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: DeletedResult
+        :param list[str] body: List of IDs to delete (required)
+        :param ContainerDeleteReason delete_reason:
+        :param bool async_: Perform the request asynchronously
+        :return: DeletedResult
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -1710,13 +1619,10 @@ class SubjectsApi(object):
         Delete multiple subjects by ID list
         This method makes a synchronous HTTP request by default.
 
-        :param body: List of IDs to delete
-        :type body: list[str]
-        :param delete_reason:
-        :type delete_reason: ContainerDeleteReason, optional
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: DeletedResult
+        :param list[str] body: List of IDs to delete (required)
+        :param ContainerDeleteReason delete_reason:
+        :param bool async_: Perform the request asynchronously
+        :return: DeletedResult
         """
 
         all_params = ['body','delete_reason',]  # noqa: E501
@@ -1791,29 +1697,18 @@ class SubjectsApi(object):
         Files can be downloaded directly from this endpoint with a valid \"Authorization\" header or via a ticket id.  To generate a ticket:   - Make a request with an empty \"ticket\" parameter and a valid \"Authorization\" header. The server will respond with a generated ticket id.   - Make another request with the received ticket id in the \"ticket\" parameter. A valid \"Authorization\" header is no longer required.  When \"view\" is true, [RFC7233](https://tools.ietf.org/html/rfc7233) range request headers are supported.  When virus_scan feature is enabled the quarantined files only can be downloaded using signed urls otherwise it will return with a HTTP 400 response.
         This method makes a synchronous HTTP request by default.
 
-        :param subject_id: 24-character hex ID
-        :type subject_id: str
-        :param file_name: output file name
-        :type file_name: str
-        :param info: If the file is a zipfile, return a json response of zipfile member information, defaults to false
-        :type info: bool, optional
-        :param member: The filename of a zipfile member to download rather than the entire file
-        :type member: str, optional
-        :param view: If true, the proper \"Content-Type\" header based on the file's mimetype is set on response If false, the \"Content-Type\" header is set to \"application/octet-stream\" , defaults to false
-        :type view: bool, optional
-        :param version: version of the file to download
-        :type version: int, optional
-        :param hash: file hash for comparison
-        :type hash: str, optional
-        :param range: byte ranges to return
-        :type range: str, optional
-        :param x_accept_feature: redirect header, defaults to []
-        :type x_accept_feature: list[str], optional
-        :param dest_file: Destination file path
-        :type dest_file: str
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: union[DownloadTicketStub,ZipfileInfo]
+        :param str subject_id: 24-character hex ID (required)
+        :param str file_name: output file name (required)
+        :param bool info: If the file is a zipfile, return a json response of zipfile member information
+        :param str member: The filename of a zipfile member to download rather than the entire file
+        :param bool view: If true, the proper \"Content-Type\" header based on the file's mimetype is set on response If false, the \"Content-Type\" header is set to \"application/octet-stream\" 
+        :param int version: version of the file to download
+        :param str hash: file hash for comparison
+        :param str range: byte ranges to return
+        :param list[str] x_accept_feature: redirect header
+        :param str dest_file: Destination file path
+        :param bool async_: Perform the request asynchronously
+        :return: union[DownloadTicketStub,ZipfileInfo]
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -1836,27 +1731,17 @@ class SubjectsApi(object):
         Files can be downloaded directly from this endpoint with a valid \"Authorization\" header or via a ticket id.  To generate a ticket:   - Make a request with an empty \"ticket\" parameter and a valid \"Authorization\" header. The server will respond with a generated ticket id.   - Make another request with the received ticket id in the \"ticket\" parameter. A valid \"Authorization\" header is no longer required.  When \"view\" is true, [RFC7233](https://tools.ietf.org/html/rfc7233) range request headers are supported.  When virus_scan feature is enabled the quarantined files only can be downloaded using signed urls otherwise it will return with a HTTP 400 response.
         This method makes a synchronous HTTP request by default.
 
-        :param subject_id: 24-character hex ID
-        :type subject_id: str
-        :param file_name: output file name
-        :type file_name: str
-        :param info: If the file is a zipfile, return a json response of zipfile member information, defaults to false
-        :type info: bool, optional
-        :param member: The filename of a zipfile member to download rather than the entire file
-        :type member: str, optional
-        :param view: If true, the proper \"Content-Type\" header based on the file's mimetype is set on response If false, the \"Content-Type\" header is set to \"application/octet-stream\" , defaults to false
-        :type view: bool, optional
-        :param version: version of the file to download
-        :type version: int, optional
-        :param hash: file hash for comparison
-        :type hash: str, optional
-        :param range: byte ranges to return
-        :type range: str, optional
-        :param x_accept_feature: redirect header, defaults to []
-        :type x_accept_feature: list[str], optional
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: union[DownloadTicketStub,ZipfileInfo]
+        :param str subject_id: 24-character hex ID (required)
+        :param str file_name: output file name (required)
+        :param bool info: If the file is a zipfile, return a json response of zipfile member information
+        :param str member: The filename of a zipfile member to download rather than the entire file
+        :param bool view: If true, the proper \"Content-Type\" header based on the file's mimetype is set on response If false, the \"Content-Type\" header is set to \"application/octet-stream\" 
+        :param int version: version of the file to download
+        :param str hash: file hash for comparison
+        :param str range: byte ranges to return
+        :param list[str] x_accept_feature: redirect header
+        :param bool async_: Perform the request asynchronously
+        :return: union[DownloadTicketStub,ZipfileInfo]
         """
 
         all_params = ['subject_id','file_name','info','member','view','version','hash','range','x_accept_feature',]  # noqa: E501
@@ -1946,29 +1831,18 @@ class SubjectsApi(object):
         Does not work on files whose names contain a forward slash.
         This method makes a synchronous HTTP request by default.
 
-        :param subject_id: 24-character hex ID
-        :type subject_id: str
-        :param file_name: output file name
-        :type file_name: str
-        :param ticket: The generated ticket id for the download, or present but empty to generate a ticket id
-        :type ticket: str, optional
-        :param info: If the file is a zipfile, return a json response of zipfile member information, defaults to false
-        :type info: bool, optional
-        :param member: The filename of a zipfile member to download rather than the entire file
-        :type member: str, optional
-        :param view: If true, the proper \"Content-Type\" header based on the file's mimetype is set on response If false, the \"Content-Type\" header is set to \"application/octet-stream\" , defaults to false
-        :type view: bool, optional
-        :param version: version of the file to download
-        :type version: int, optional
-        :param hash: file hash for comparison
-        :type hash: str, optional
-        :param range: byte ranges to return
-        :type range: str, optional
-        :param x_accept_feature: redirect header, defaults to []
-        :type x_accept_feature: list[str], optional
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: FileZipInfo
+        :param str subject_id: 24-character hex ID (required)
+        :param str file_name: output file name (required)
+        :param str ticket: The generated ticket id for the download, or present but empty to generate a ticket id
+        :param bool info: If the file is a zipfile, return a json response of zipfile member information
+        :param str member: The filename of a zipfile member to download rather than the entire file
+        :param bool view: If true, the proper \"Content-Type\" header based on the file's mimetype is set on response If false, the \"Content-Type\" header is set to \"application/octet-stream\" 
+        :param int version: version of the file to download
+        :param str hash: file hash for comparison
+        :param str range: byte ranges to return
+        :param list[str] x_accept_feature: redirect header
+        :param bool async_: Perform the request asynchronously
+        :return: FileZipInfo
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -1992,29 +1866,18 @@ class SubjectsApi(object):
         Does not work on files whose names contain a forward slash.
         This method makes a synchronous HTTP request by default.
 
-        :param subject_id: 24-character hex ID
-        :type subject_id: str
-        :param file_name: output file name
-        :type file_name: str
-        :param ticket: The generated ticket id for the download, or present but empty to generate a ticket id
-        :type ticket: str, optional
-        :param info: If the file is a zipfile, return a json response of zipfile member information, defaults to false
-        :type info: bool, optional
-        :param member: The filename of a zipfile member to download rather than the entire file
-        :type member: str, optional
-        :param view: If true, the proper \"Content-Type\" header based on the file's mimetype is set on response If false, the \"Content-Type\" header is set to \"application/octet-stream\" , defaults to false
-        :type view: bool, optional
-        :param version: version of the file to download
-        :type version: int, optional
-        :param hash: file hash for comparison
-        :type hash: str, optional
-        :param range: byte ranges to return
-        :type range: str, optional
-        :param x_accept_feature: redirect header, defaults to []
-        :type x_accept_feature: list[str], optional
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: FileZipInfo
+        :param str subject_id: 24-character hex ID (required)
+        :param str file_name: output file name (required)
+        :param str ticket: The generated ticket id for the download, or present but empty to generate a ticket id
+        :param bool info: If the file is a zipfile, return a json response of zipfile member information
+        :param str member: The filename of a zipfile member to download rather than the entire file
+        :param bool view: If true, the proper \"Content-Type\" header based on the file's mimetype is set on response If false, the \"Content-Type\" header is set to \"application/octet-stream\" 
+        :param int version: version of the file to download
+        :param str hash: file hash for comparison
+        :param str range: byte ranges to return
+        :param list[str] x_accept_feature: redirect header
+        :param bool async_: Perform the request asynchronously
+        :return: FileZipInfo
         """
 
         all_params = ['subject_id','file_name','ticket','info','member','view','version','hash','range','x_accept_feature',]  # noqa: E501
@@ -2107,29 +1970,18 @@ class SubjectsApi(object):
 
         This method makes a synchronous HTTP request by default.
 
-        :param subject_id: 24-character hex ID
-        :type subject_id: str
-        :param file_name: output file name
-        :type file_name: str
-        :param ticket: The generated ticket id for the download, or present but empty to generate a ticket id
-        :type ticket: str, optional
-        :param info: If the file is a zipfile, return a json response of zipfile member information, defaults to false
-        :type info: bool, optional
-        :param member: The filename of a zipfile member to download rather than the entire file
-        :type member: str, optional
-        :param view: If true, the proper \"Content-Type\" header based on the file's mimetype is set on response If false, the \"Content-Type\" header is set to \"application/octet-stream\" , defaults to false
-        :type view: bool, optional
-        :param version: version of the file to download
-        :type version: int, optional
-        :param hash: file hash for comparison
-        :type hash: str, optional
-        :param range: byte ranges to return
-        :type range: str, optional
-        :param x_accept_feature: redirect header, defaults to []
-        :type x_accept_feature: list[str], optional
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: union[DownloadTicketStub,ZipfileInfo]
+        :param str subject_id: 24-character hex ID (required)
+        :param str file_name: output file name (required)
+        :param str ticket: The generated ticket id for the download, or present but empty to generate a ticket id
+        :param bool info: If the file is a zipfile, return a json response of zipfile member information
+        :param str member: The filename of a zipfile member to download rather than the entire file
+        :param bool view: If true, the proper \"Content-Type\" header based on the file's mimetype is set on response If false, the \"Content-Type\" header is set to \"application/octet-stream\" 
+        :param int version: version of the file to download
+        :param str hash: file hash for comparison
+        :param str range: byte ranges to return
+        :param list[str] x_accept_feature: redirect header
+        :param bool async_: Perform the request asynchronously
+        :return: union[DownloadTicketStub,ZipfileInfo]
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -2152,29 +2004,18 @@ class SubjectsApi(object):
 
         This method makes a synchronous HTTP request by default.
 
-        :param subject_id: 24-character hex ID
-        :type subject_id: str
-        :param file_name: output file name
-        :type file_name: str
-        :param ticket: The generated ticket id for the download, or present but empty to generate a ticket id
-        :type ticket: str, optional
-        :param info: If the file is a zipfile, return a json response of zipfile member information, defaults to false
-        :type info: bool, optional
-        :param member: The filename of a zipfile member to download rather than the entire file
-        :type member: str, optional
-        :param view: If true, the proper \"Content-Type\" header based on the file's mimetype is set on response If false, the \"Content-Type\" header is set to \"application/octet-stream\" , defaults to false
-        :type view: bool, optional
-        :param version: version of the file to download
-        :type version: int, optional
-        :param hash: file hash for comparison
-        :type hash: str, optional
-        :param range: byte ranges to return
-        :type range: str, optional
-        :param x_accept_feature: redirect header, defaults to []
-        :type x_accept_feature: list[str], optional
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: union[DownloadTicketStub,ZipfileInfo]
+        :param str subject_id: 24-character hex ID (required)
+        :param str file_name: output file name (required)
+        :param str ticket: The generated ticket id for the download, or present but empty to generate a ticket id
+        :param bool info: If the file is a zipfile, return a json response of zipfile member information
+        :param str member: The filename of a zipfile member to download rather than the entire file
+        :param bool view: If true, the proper \"Content-Type\" header based on the file's mimetype is set on response If false, the \"Content-Type\" header is set to \"application/octet-stream\" 
+        :param int version: version of the file to download
+        :param str hash: file hash for comparison
+        :param str range: byte ranges to return
+        :param list[str] x_accept_feature: redirect header
+        :param bool async_: Perform the request asynchronously
+        :return: union[DownloadTicketStub,ZipfileInfo]
         """
 
         all_params = ['subject_id','file_name','ticket','info','member','view','version','hash','range','x_accept_feature',]  # noqa: E501
@@ -2266,27 +2107,17 @@ class SubjectsApi(object):
         If \"ticket\" query param is included and not empty, download inputs. If \"ticket\" query param is included and empty, create a ticket for matching inputs in the analysis. If no \"ticket\" query param is included, inputs will be downloaded directly.
         This method makes a synchronous HTTP request by default.
 
-        :param subject_id: 24-character hex ID
-        :type subject_id: str
-        :param analysis_id: 24-char hex analysis id
-        :type analysis_id: str
-        :param filename: filename to download (get tar of all if empty)
-        :type filename: str
-        :param info: get file info only, defaults to false
-        :type info: bool, optional
-        :param member: get zipfile member
-        :type member: str, optional
-        :param view: feature flag for view/download, defaults to false
-        :type view: bool, optional
-        :param range: byte ranges to return
-        :type range: str, optional
-        :param x_accept_feature: redirect header, defaults to []
-        :type x_accept_feature: list[str], optional
-        :param dest_file: Destination file path
-        :type dest_file: str
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: union[DownloadTicketStub,ZipfileInfo]
+        :param str subject_id: 24-character hex ID (required)
+        :param str analysis_id: 24-char hex analysis id (required)
+        :param str filename: filename to download (get tar of all if empty) (required)
+        :param bool info: get file info only
+        :param str member: get zipfile member
+        :param bool view: feature flag for view/download
+        :param str range: byte ranges to return
+        :param list[str] x_accept_feature: redirect header
+        :param str dest_file: Destination file path
+        :param bool async_: Perform the request asynchronously
+        :return: union[DownloadTicketStub,ZipfileInfo]
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -2309,25 +2140,16 @@ class SubjectsApi(object):
         If \"ticket\" query param is included and not empty, download inputs. If \"ticket\" query param is included and empty, create a ticket for matching inputs in the analysis. If no \"ticket\" query param is included, inputs will be downloaded directly.
         This method makes a synchronous HTTP request by default.
 
-        :param subject_id: 24-character hex ID
-        :type subject_id: str
-        :param analysis_id: 24-char hex analysis id
-        :type analysis_id: str
-        :param filename: filename to download (get tar of all if empty)
-        :type filename: str
-        :param info: get file info only, defaults to false
-        :type info: bool, optional
-        :param member: get zipfile member
-        :type member: str, optional
-        :param view: feature flag for view/download, defaults to false
-        :type view: bool, optional
-        :param range: byte ranges to return
-        :type range: str, optional
-        :param x_accept_feature: redirect header, defaults to []
-        :type x_accept_feature: list[str], optional
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: union[DownloadTicketStub,ZipfileInfo]
+        :param str subject_id: 24-character hex ID (required)
+        :param str analysis_id: 24-char hex analysis id (required)
+        :param str filename: filename to download (get tar of all if empty) (required)
+        :param bool info: get file info only
+        :param str member: get zipfile member
+        :param bool view: feature flag for view/download
+        :param str range: byte ranges to return
+        :param list[str] x_accept_feature: redirect header
+        :param bool async_: Perform the request asynchronously
+        :return: union[DownloadTicketStub,ZipfileInfo]
         """
 
         all_params = ['subject_id','analysis_id','filename','info','member','view','range','x_accept_feature',]  # noqa: E501
@@ -2419,27 +2241,17 @@ class SubjectsApi(object):
         Does not work on files whose names contain a forward slash.
         This method makes a synchronous HTTP request by default.
 
-        :param subject_id: 24-character hex ID
-        :type subject_id: str
-        :param analysis_id: 24-char hex analysis id
-        :type analysis_id: str
-        :param filename: filename to download (get tar of all if empty)
-        :type filename: str
-        :param ticket: 24-char hex ticket id
-        :type ticket: str, optional
-        :param info: get file info only, defaults to false
-        :type info: bool, optional
-        :param member: get zipfile member
-        :type member: str, optional
-        :param view: feature flag for view/download, defaults to false
-        :type view: bool, optional
-        :param range: byte ranges to return
-        :type range: str, optional
-        :param x_accept_feature: redirect header, defaults to []
-        :type x_accept_feature: list[str], optional
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: FileZipInfo
+        :param str subject_id: 24-character hex ID (required)
+        :param str analysis_id: 24-char hex analysis id (required)
+        :param str filename: filename to download (get tar of all if empty) (required)
+        :param str ticket: 24-char hex ticket id
+        :param bool info: get file info only
+        :param str member: get zipfile member
+        :param bool view: feature flag for view/download
+        :param str range: byte ranges to return
+        :param list[str] x_accept_feature: redirect header
+        :param bool async_: Perform the request asynchronously
+        :return: FileZipInfo
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -2463,27 +2275,17 @@ class SubjectsApi(object):
         Does not work on files whose names contain a forward slash.
         This method makes a synchronous HTTP request by default.
 
-        :param subject_id: 24-character hex ID
-        :type subject_id: str
-        :param analysis_id: 24-char hex analysis id
-        :type analysis_id: str
-        :param filename: filename to download (get tar of all if empty)
-        :type filename: str
-        :param ticket: 24-char hex ticket id
-        :type ticket: str, optional
-        :param info: get file info only, defaults to false
-        :type info: bool, optional
-        :param member: get zipfile member
-        :type member: str, optional
-        :param view: feature flag for view/download, defaults to false
-        :type view: bool, optional
-        :param range: byte ranges to return
-        :type range: str, optional
-        :param x_accept_feature: redirect header, defaults to []
-        :type x_accept_feature: list[str], optional
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: FileZipInfo
+        :param str subject_id: 24-character hex ID (required)
+        :param str analysis_id: 24-char hex analysis id (required)
+        :param str filename: filename to download (get tar of all if empty) (required)
+        :param str ticket: 24-char hex ticket id
+        :param bool info: get file info only
+        :param str member: get zipfile member
+        :param bool view: feature flag for view/download
+        :param str range: byte ranges to return
+        :param list[str] x_accept_feature: redirect header
+        :param bool async_: Perform the request asynchronously
+        :return: FileZipInfo
         """
 
         all_params = ['subject_id','analysis_id','filename','ticket','info','member','view','range','x_accept_feature',]  # noqa: E501
@@ -2578,27 +2380,17 @@ class SubjectsApi(object):
 
         This method makes a synchronous HTTP request by default.
 
-        :param subject_id: 24-character hex ID
-        :type subject_id: str
-        :param analysis_id: 24-char hex analysis id
-        :type analysis_id: str
-        :param filename: filename to download (get tar of all if empty)
-        :type filename: str
-        :param ticket: 24-char hex ticket id
-        :type ticket: str, optional
-        :param info: get file info only, defaults to false
-        :type info: bool, optional
-        :param member: get zipfile member
-        :type member: str, optional
-        :param view: feature flag for view/download, defaults to false
-        :type view: bool, optional
-        :param range: byte ranges to return
-        :type range: str, optional
-        :param x_accept_feature: redirect header, defaults to []
-        :type x_accept_feature: list[str], optional
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: union[DownloadTicketStub,ZipfileInfo]
+        :param str subject_id: 24-character hex ID (required)
+        :param str analysis_id: 24-char hex analysis id (required)
+        :param str filename: filename to download (get tar of all if empty) (required)
+        :param str ticket: 24-char hex ticket id
+        :param bool info: get file info only
+        :param str member: get zipfile member
+        :param bool view: feature flag for view/download
+        :param str range: byte ranges to return
+        :param list[str] x_accept_feature: redirect header
+        :param bool async_: Perform the request asynchronously
+        :return: union[DownloadTicketStub,ZipfileInfo]
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -2621,27 +2413,17 @@ class SubjectsApi(object):
 
         This method makes a synchronous HTTP request by default.
 
-        :param subject_id: 24-character hex ID
-        :type subject_id: str
-        :param analysis_id: 24-char hex analysis id
-        :type analysis_id: str
-        :param filename: filename to download (get tar of all if empty)
-        :type filename: str
-        :param ticket: 24-char hex ticket id
-        :type ticket: str, optional
-        :param info: get file info only, defaults to false
-        :type info: bool, optional
-        :param member: get zipfile member
-        :type member: str, optional
-        :param view: feature flag for view/download, defaults to false
-        :type view: bool, optional
-        :param range: byte ranges to return
-        :type range: str, optional
-        :param x_accept_feature: redirect header, defaults to []
-        :type x_accept_feature: list[str], optional
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: union[DownloadTicketStub,ZipfileInfo]
+        :param str subject_id: 24-character hex ID (required)
+        :param str analysis_id: 24-char hex analysis id (required)
+        :param str filename: filename to download (get tar of all if empty) (required)
+        :param str ticket: 24-char hex ticket id
+        :param bool info: get file info only
+        :param str member: get zipfile member
+        :param bool view: feature flag for view/download
+        :param str range: byte ranges to return
+        :param list[str] x_accept_feature: redirect header
+        :param bool async_: Perform the request asynchronously
+        :return: union[DownloadTicketStub,ZipfileInfo]
         """
 
         all_params = ['subject_id','analysis_id','filename','ticket','info','member','view','range','x_accept_feature',]  # noqa: E501
@@ -2735,27 +2517,17 @@ class SubjectsApi(object):
         If \"ticket\" query param is included and not empty, download outputs. If \"ticket\" query param is included and empty, create a ticket for matching outputs in the analysis. If no \"ticket\" query param is included, outputs will be downloaded directly.
         This method makes a synchronous HTTP request by default.
 
-        :param subject_id: 24-character hex ID
-        :type subject_id: str
-        :param analysis_id: 24-char hex analysis id
-        :type analysis_id: str
-        :param filename: filename to download (get tar of all if empty)
-        :type filename: str
-        :param info: If the file is a zipfile, return a json response of zipfile member information, defaults to false
-        :type info: bool, optional
-        :param member: The filename of a zipfile member to download rather than the entire file
-        :type member: str, optional
-        :param view: feature flag for view/download, defaults to false
-        :type view: bool, optional
-        :param range: byte ranges to return
-        :type range: str, optional
-        :param x_accept_feature: redirect header, defaults to []
-        :type x_accept_feature: list[str], optional
-        :param dest_file: Destination file path
-        :type dest_file: str
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: union[DownloadTicketStub,ZipfileInfo]
+        :param str subject_id: 24-character hex ID (required)
+        :param str analysis_id: 24-char hex analysis id (required)
+        :param str filename: filename to download (get tar of all if empty) (required)
+        :param bool info: If the file is a zipfile, return a json response of zipfile member information
+        :param str member: The filename of a zipfile member to download rather than the entire file
+        :param bool view: feature flag for view/download
+        :param str range: byte ranges to return
+        :param list[str] x_accept_feature: redirect header
+        :param str dest_file: Destination file path
+        :param bool async_: Perform the request asynchronously
+        :return: union[DownloadTicketStub,ZipfileInfo]
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -2778,25 +2550,16 @@ class SubjectsApi(object):
         If \"ticket\" query param is included and not empty, download outputs. If \"ticket\" query param is included and empty, create a ticket for matching outputs in the analysis. If no \"ticket\" query param is included, outputs will be downloaded directly.
         This method makes a synchronous HTTP request by default.
 
-        :param subject_id: 24-character hex ID
-        :type subject_id: str
-        :param analysis_id: 24-char hex analysis id
-        :type analysis_id: str
-        :param filename: filename to download (get tar of all if empty)
-        :type filename: str
-        :param info: If the file is a zipfile, return a json response of zipfile member information, defaults to false
-        :type info: bool, optional
-        :param member: The filename of a zipfile member to download rather than the entire file
-        :type member: str, optional
-        :param view: feature flag for view/download, defaults to false
-        :type view: bool, optional
-        :param range: byte ranges to return
-        :type range: str, optional
-        :param x_accept_feature: redirect header, defaults to []
-        :type x_accept_feature: list[str], optional
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: union[DownloadTicketStub,ZipfileInfo]
+        :param str subject_id: 24-character hex ID (required)
+        :param str analysis_id: 24-char hex analysis id (required)
+        :param str filename: filename to download (get tar of all if empty) (required)
+        :param bool info: If the file is a zipfile, return a json response of zipfile member information
+        :param str member: The filename of a zipfile member to download rather than the entire file
+        :param bool view: feature flag for view/download
+        :param str range: byte ranges to return
+        :param list[str] x_accept_feature: redirect header
+        :param bool async_: Perform the request asynchronously
+        :return: union[DownloadTicketStub,ZipfileInfo]
         """
 
         all_params = ['subject_id','analysis_id','filename','info','member','view','range','x_accept_feature',]  # noqa: E501
@@ -2888,27 +2651,17 @@ class SubjectsApi(object):
         Does not work on files whose names contain a forward slash.
         This method makes a synchronous HTTP request by default.
 
-        :param subject_id: 24-character hex ID
-        :type subject_id: str
-        :param analysis_id: 24-char hex analysis id
-        :type analysis_id: str
-        :param filename: filename to download (get tar of all if empty)
-        :type filename: str
-        :param ticket: ticket id of the outputs to download
-        :type ticket: str, optional
-        :param info: If the file is a zipfile, return a json response of zipfile member information, defaults to false
-        :type info: bool, optional
-        :param member: The filename of a zipfile member to download rather than the entire file
-        :type member: str, optional
-        :param view: feature flag for view/download, defaults to false
-        :type view: bool, optional
-        :param range: byte ranges to return
-        :type range: str, optional
-        :param x_accept_feature: redirect header, defaults to []
-        :type x_accept_feature: list[str], optional
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: FileZipInfo
+        :param str subject_id: 24-character hex ID (required)
+        :param str analysis_id: 24-char hex analysis id (required)
+        :param str filename: filename to download (get tar of all if empty) (required)
+        :param str ticket: ticket id of the outputs to download
+        :param bool info: If the file is a zipfile, return a json response of zipfile member information
+        :param str member: The filename of a zipfile member to download rather than the entire file
+        :param bool view: feature flag for view/download
+        :param str range: byte ranges to return
+        :param list[str] x_accept_feature: redirect header
+        :param bool async_: Perform the request asynchronously
+        :return: FileZipInfo
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -2932,27 +2685,17 @@ class SubjectsApi(object):
         Does not work on files whose names contain a forward slash.
         This method makes a synchronous HTTP request by default.
 
-        :param subject_id: 24-character hex ID
-        :type subject_id: str
-        :param analysis_id: 24-char hex analysis id
-        :type analysis_id: str
-        :param filename: filename to download (get tar of all if empty)
-        :type filename: str
-        :param ticket: ticket id of the outputs to download
-        :type ticket: str, optional
-        :param info: If the file is a zipfile, return a json response of zipfile member information, defaults to false
-        :type info: bool, optional
-        :param member: The filename of a zipfile member to download rather than the entire file
-        :type member: str, optional
-        :param view: feature flag for view/download, defaults to false
-        :type view: bool, optional
-        :param range: byte ranges to return
-        :type range: str, optional
-        :param x_accept_feature: redirect header, defaults to []
-        :type x_accept_feature: list[str], optional
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: FileZipInfo
+        :param str subject_id: 24-character hex ID (required)
+        :param str analysis_id: 24-char hex analysis id (required)
+        :param str filename: filename to download (get tar of all if empty) (required)
+        :param str ticket: ticket id of the outputs to download
+        :param bool info: If the file is a zipfile, return a json response of zipfile member information
+        :param str member: The filename of a zipfile member to download rather than the entire file
+        :param bool view: feature flag for view/download
+        :param str range: byte ranges to return
+        :param list[str] x_accept_feature: redirect header
+        :param bool async_: Perform the request asynchronously
+        :return: FileZipInfo
         """
 
         all_params = ['subject_id','analysis_id','filename','ticket','info','member','view','range','x_accept_feature',]  # noqa: E501
@@ -3047,27 +2790,17 @@ class SubjectsApi(object):
 
         This method makes a synchronous HTTP request by default.
 
-        :param subject_id: 24-character hex ID
-        :type subject_id: str
-        :param analysis_id: 24-char hex analysis id
-        :type analysis_id: str
-        :param filename: filename to download (get tar of all if empty)
-        :type filename: str
-        :param ticket: ticket id of the outputs to download
-        :type ticket: str, optional
-        :param info: If the file is a zipfile, return a json response of zipfile member information, defaults to false
-        :type info: bool, optional
-        :param member: The filename of a zipfile member to download rather than the entire file
-        :type member: str, optional
-        :param view: feature flag for view/download, defaults to false
-        :type view: bool, optional
-        :param range: byte ranges to return
-        :type range: str, optional
-        :param x_accept_feature: redirect header, defaults to []
-        :type x_accept_feature: list[str], optional
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: union[DownloadTicketStub,ZipfileInfo]
+        :param str subject_id: 24-character hex ID (required)
+        :param str analysis_id: 24-char hex analysis id (required)
+        :param str filename: filename to download (get tar of all if empty) (required)
+        :param str ticket: ticket id of the outputs to download
+        :param bool info: If the file is a zipfile, return a json response of zipfile member information
+        :param str member: The filename of a zipfile member to download rather than the entire file
+        :param bool view: feature flag for view/download
+        :param str range: byte ranges to return
+        :param list[str] x_accept_feature: redirect header
+        :param bool async_: Perform the request asynchronously
+        :return: union[DownloadTicketStub,ZipfileInfo]
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -3090,27 +2823,17 @@ class SubjectsApi(object):
 
         This method makes a synchronous HTTP request by default.
 
-        :param subject_id: 24-character hex ID
-        :type subject_id: str
-        :param analysis_id: 24-char hex analysis id
-        :type analysis_id: str
-        :param filename: filename to download (get tar of all if empty)
-        :type filename: str
-        :param ticket: ticket id of the outputs to download
-        :type ticket: str, optional
-        :param info: If the file is a zipfile, return a json response of zipfile member information, defaults to false
-        :type info: bool, optional
-        :param member: The filename of a zipfile member to download rather than the entire file
-        :type member: str, optional
-        :param view: feature flag for view/download, defaults to false
-        :type view: bool, optional
-        :param range: byte ranges to return
-        :type range: str, optional
-        :param x_accept_feature: redirect header, defaults to []
-        :type x_accept_feature: list[str], optional
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: union[DownloadTicketStub,ZipfileInfo]
+        :param str subject_id: 24-character hex ID (required)
+        :param str analysis_id: 24-char hex analysis id (required)
+        :param str filename: filename to download (get tar of all if empty) (required)
+        :param str ticket: ticket id of the outputs to download
+        :param bool info: If the file is a zipfile, return a json response of zipfile member information
+        :param str member: The filename of a zipfile member to download rather than the entire file
+        :param bool view: feature flag for view/download
+        :param str range: byte ranges to return
+        :param list[str] x_accept_feature: redirect header
+        :param bool async_: Perform the request asynchronously
+        :return: union[DownloadTicketStub,ZipfileInfo]
         """
 
         all_params = ['subject_id','analysis_id','filename','ticket','info','member','view','range','x_accept_feature',]  # noqa: E501
@@ -3204,31 +2927,19 @@ class SubjectsApi(object):
         Get a list of subjects
         This method makes a synchronous HTTP request by default.
 
-        :param exhaustive: Set to return a complete list regardless of permissions, defaults to false
-        :type exhaustive: bool, optional
-        :param join: join file origins
-        :type join: JoinType, optional
-        :param join_avatars: add name and avatar to notes, defaults to false
-        :type join_avatars: bool, optional
-        :param include_all_info: Include all info in returned objects, defaults to false
-        :type include_all_info: bool, optional
-        :param filter: Comma separated filters to apply. Commas not used as separators must be escaped with backslash '\\'. (e.g. label=my-label,created>2018-09-22)
-        :type filter: str, optional
-        :param sort: The sort fields and order. (e.g. label:asc,created:desc)
-        :type sort: str, optional
-        :param limit: The maximum number of entries to return.
-        :type limit: int, optional
-        :param skip: The number of entries to skip., defaults to 0
-        :type skip: int, optional
-        :param page: The page number (i.e. skip limit*page entries)
-        :type page: int, optional
-        :param after_id: Paginate after the given id. (Cannot be used with sort, page or skip)
-        :type after_id: str, optional
-        :param x_accept_feature:, defaults to []
-        :type x_accept_feature: list[union[HeaderFeature,str]], optional
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: union[Page,list[SubjectOutputForList]]
+        :param bool exhaustive: Set to return a complete list regardless of permissions
+        :param JoinType join: join file origins
+        :param bool join_avatars: add name and avatar to notes
+        :param bool include_all_info: Include all info in returned objects
+        :param str filter: Comma separated filters to apply. Commas not used as separators must be escaped with backslash '\\'. (e.g. label=my-label,created>2018-09-22)
+        :param str sort: The sort fields and order. (e.g. label:asc,created:desc)
+        :param int limit: The maximum number of entries to return.
+        :param int skip: The number of entries to skip.
+        :param int page: The page number (i.e. skip limit*page entries)
+        :param str after_id: Paginate after the given id. (Cannot be used with sort, page or skip)
+        :param list[union[HeaderFeature,str]] x_accept_feature:
+        :param bool async_: Perform the request asynchronously
+        :return: union[Page,list[SubjectOutputForList]]
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -3252,31 +2963,19 @@ class SubjectsApi(object):
         Get a list of subjects
         This method makes a synchronous HTTP request by default.
 
-        :param exhaustive: Set to return a complete list regardless of permissions, defaults to false
-        :type exhaustive: bool, optional
-        :param join: join file origins
-        :type join: JoinType, optional
-        :param join_avatars: add name and avatar to notes, defaults to false
-        :type join_avatars: bool, optional
-        :param include_all_info: Include all info in returned objects, defaults to false
-        :type include_all_info: bool, optional
-        :param filter: Comma separated filters to apply. Commas not used as separators must be escaped with backslash '\\'. (e.g. label=my-label,created>2018-09-22)
-        :type filter: str, optional
-        :param sort: The sort fields and order. (e.g. label:asc,created:desc)
-        :type sort: str, optional
-        :param limit: The maximum number of entries to return.
-        :type limit: int, optional
-        :param skip: The number of entries to skip., defaults to 0
-        :type skip: int, optional
-        :param page: The page number (i.e. skip limit*page entries)
-        :type page: int, optional
-        :param after_id: Paginate after the given id. (Cannot be used with sort, page or skip)
-        :type after_id: str, optional
-        :param x_accept_feature:, defaults to []
-        :type x_accept_feature: list[union[HeaderFeature,str]], optional
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: union[Page,list[SubjectOutputForList]]
+        :param bool exhaustive: Set to return a complete list regardless of permissions
+        :param JoinType join: join file origins
+        :param bool join_avatars: add name and avatar to notes
+        :param bool include_all_info: Include all info in returned objects
+        :param str filter: Comma separated filters to apply. Commas not used as separators must be escaped with backslash '\\'. (e.g. label=my-label,created>2018-09-22)
+        :param str sort: The sort fields and order. (e.g. label:asc,created:desc)
+        :param int limit: The maximum number of entries to return.
+        :param int skip: The number of entries to skip.
+        :param int page: The page number (i.e. skip limit*page entries)
+        :param str after_id: Paginate after the given id. (Cannot be used with sort, page or skip)
+        :param list[union[HeaderFeature,str]] x_accept_feature:
+        :param bool async_: Perform the request asynchronously
+        :return: union[Page,list[SubjectOutputForList]]
         """
 
         all_params = ['exhaustive','join','join_avatars','include_all_info','filter','sort','limit','skip','page','after_id','x_accept_feature',]  # noqa: E501
@@ -3362,17 +3061,12 @@ class SubjectsApi(object):
         Get an subject by its id  Args:     subject_id: The id of the subject     join: Attribute to join on     join_avatars: Join the user avatars for permissions     auth_session: The auth session  Returns:     SubjectOutput
         This method makes a synchronous HTTP request by default.
 
-        :param subject_id: 24-char hex subject id
-        :type subject_id: str
-        :param join: join file origins
-        :type join: JoinType, optional
-        :param join_avatars: add name and avatar to notes, defaults to false
-        :type join_avatars: bool, optional
-        :param x_accept_feature:, defaults to []
-        :type x_accept_feature: list[union[HeaderFeature,str]], optional
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: SubjectOutput
+        :param str subject_id: 24-char hex subject id (required)
+        :param JoinType join: join file origins
+        :param bool join_avatars: add name and avatar to notes
+        :param list[union[HeaderFeature,str]] x_accept_feature:
+        :param bool async_: Perform the request asynchronously
+        :return: SubjectOutput
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -3396,17 +3090,12 @@ class SubjectsApi(object):
         Get an subject by its id  Args:     subject_id: The id of the subject     join: Attribute to join on     join_avatars: Join the user avatars for permissions     auth_session: The auth session  Returns:     SubjectOutput
         This method makes a synchronous HTTP request by default.
 
-        :param subject_id: 24-char hex subject id
-        :type subject_id: str
-        :param join: join file origins
-        :type join: JoinType, optional
-        :param join_avatars: add name and avatar to notes, defaults to false
-        :type join_avatars: bool, optional
-        :param x_accept_feature:, defaults to []
-        :type x_accept_feature: list[union[HeaderFeature,str]], optional
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: SubjectOutput
+        :param str subject_id: 24-char hex subject id (required)
+        :param JoinType join: join file origins
+        :param bool join_avatars: add name and avatar to notes
+        :param list[union[HeaderFeature,str]] x_accept_feature:
+        :param bool async_: Perform the request asynchronously
+        :return: SubjectOutput
         """
 
         all_params = ['subject_id','join','join_avatars','x_accept_feature',]  # noqa: E501
@@ -3482,33 +3171,20 @@ class SubjectsApi(object):
         Returns analyses that directly belong to this resource.
         This method makes a synchronous HTTP request by default.
 
-        :param cid:
-        :type cid: str
-        :param inflate_job:, defaults to false
-        :type inflate_job: bool, optional
-        :param join_avatars:, defaults to false
-        :type join_avatars: bool, optional
-        :param join:
-        :type join: JoinType, optional
-        :param include_all_info: Include all info in returned objects, defaults to false
-        :type include_all_info: bool, optional
-        :param filter: Comma separated filters to apply. Commas not used as separators must be escaped with backslash '\\'. (e.g. label=my-label,created>2018-09-22)
-        :type filter: str, optional
-        :param sort: The sort fields and order. (e.g. label:asc,created:desc)
-        :type sort: str, optional
-        :param limit: The maximum number of entries to return.
-        :type limit: int, optional
-        :param skip: The number of entries to skip., defaults to 0
-        :type skip: int, optional
-        :param page: The page number (i.e. skip limit*page entries)
-        :type page: int, optional
-        :param after_id: Paginate after the given id. (Cannot be used with sort, page or skip)
-        :type after_id: str, optional
-        :param x_accept_feature:, defaults to []
-        :type x_accept_feature: list[str], optional
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: union[Page,list[union[AnalysisListOutput,AnalysisListOutputInflatedJob]]]
+        :param str cid: (required)
+        :param bool inflate_job:
+        :param bool join_avatars:
+        :param JoinType join:
+        :param bool include_all_info: Include all info in returned objects
+        :param str filter: Comma separated filters to apply. Commas not used as separators must be escaped with backslash '\\'. (e.g. label=my-label,created>2018-09-22)
+        :param str sort: The sort fields and order. (e.g. label:asc,created:desc)
+        :param int limit: The maximum number of entries to return.
+        :param int skip: The number of entries to skip.
+        :param int page: The page number (i.e. skip limit*page entries)
+        :param str after_id: Paginate after the given id. (Cannot be used with sort, page or skip)
+        :param list[str] x_accept_feature:
+        :param bool async_: Perform the request asynchronously
+        :return: union[Page,list[union[AnalysisListOutput,AnalysisListOutputInflatedJob]]]
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -3532,33 +3208,20 @@ class SubjectsApi(object):
         Returns analyses that directly belong to this resource.
         This method makes a synchronous HTTP request by default.
 
-        :param cid:
-        :type cid: str
-        :param inflate_job:, defaults to false
-        :type inflate_job: bool, optional
-        :param join_avatars:, defaults to false
-        :type join_avatars: bool, optional
-        :param join:
-        :type join: JoinType, optional
-        :param include_all_info: Include all info in returned objects, defaults to false
-        :type include_all_info: bool, optional
-        :param filter: Comma separated filters to apply. Commas not used as separators must be escaped with backslash '\\'. (e.g. label=my-label,created>2018-09-22)
-        :type filter: str, optional
-        :param sort: The sort fields and order. (e.g. label:asc,created:desc)
-        :type sort: str, optional
-        :param limit: The maximum number of entries to return.
-        :type limit: int, optional
-        :param skip: The number of entries to skip., defaults to 0
-        :type skip: int, optional
-        :param page: The page number (i.e. skip limit*page entries)
-        :type page: int, optional
-        :param after_id: Paginate after the given id. (Cannot be used with sort, page or skip)
-        :type after_id: str, optional
-        :param x_accept_feature:, defaults to []
-        :type x_accept_feature: list[str], optional
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: union[Page,list[union[AnalysisListOutput,AnalysisListOutputInflatedJob]]]
+        :param str cid: (required)
+        :param bool inflate_job:
+        :param bool join_avatars:
+        :param JoinType join:
+        :param bool include_all_info: Include all info in returned objects
+        :param str filter: Comma separated filters to apply. Commas not used as separators must be escaped with backslash '\\'. (e.g. label=my-label,created>2018-09-22)
+        :param str sort: The sort fields and order. (e.g. label:asc,created:desc)
+        :param int limit: The maximum number of entries to return.
+        :param int skip: The number of entries to skip.
+        :param int page: The page number (i.e. skip limit*page entries)
+        :param str after_id: Paginate after the given id. (Cannot be used with sort, page or skip)
+        :param list[str] x_accept_feature:
+        :param bool async_: Perform the request asynchronously
+        :return: union[Page,list[union[AnalysisListOutput,AnalysisListOutputInflatedJob]]]
         """
 
         all_params = ['cid','inflate_job','join_avatars','join','include_all_info','filter','sort','limit','skip','page','after_id','x_accept_feature',]  # noqa: E501
@@ -3650,19 +3313,13 @@ class SubjectsApi(object):
         Get an analysis.
         This method makes a synchronous HTTP request by default.
 
-        :param cid:
-        :type cid: str
-        :param analysis_id:
-        :type analysis_id: str
-        :param inflate_job: Return job as an object instead of an id, defaults to false
-        :type inflate_job: bool, optional
-        :param join_avatars:, defaults to false
-        :type join_avatars: bool, optional
-        :param join:
-        :type join: JoinType, optional
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: union[AnalysisOutputInflatedJob,AnalysisOutput]
+        :param str cid: (required)
+        :param str analysis_id: (required)
+        :param bool inflate_job: Return job as an object instead of an id
+        :param bool join_avatars:
+        :param JoinType join:
+        :param bool async_: Perform the request asynchronously
+        :return: union[AnalysisOutputInflatedJob,AnalysisOutput]
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -3686,19 +3343,13 @@ class SubjectsApi(object):
         Get an analysis.
         This method makes a synchronous HTTP request by default.
 
-        :param cid:
-        :type cid: str
-        :param analysis_id:
-        :type analysis_id: str
-        :param inflate_job: Return job as an object instead of an id, defaults to false
-        :type inflate_job: bool, optional
-        :param join_avatars:, defaults to false
-        :type join_avatars: bool, optional
-        :param join:
-        :type join: JoinType, optional
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: union[AnalysisOutputInflatedJob,AnalysisOutput]
+        :param str cid: (required)
+        :param str analysis_id: (required)
+        :param bool inflate_job: Return job as an object instead of an id
+        :param bool join_avatars:
+        :param JoinType join:
+        :param bool async_: Perform the request asynchronously
+        :return: union[AnalysisOutputInflatedJob,AnalysisOutput]
         """
 
         all_params = ['cid','analysis_id','inflate_job','join_avatars','join',]  # noqa: E501
@@ -3779,13 +3430,10 @@ class SubjectsApi(object):
         Get info for a particular file.
         This method makes a synchronous HTTP request by default.
 
-        :param cid: Container Id
-        :type cid: str
-        :param filename:
-        :type filename: str
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: FileOutput
+        :param str cid: Container Id (required)
+        :param str filename: (required)
+        :param bool async_: Perform the request asynchronously
+        :return: FileOutput
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -3809,13 +3457,10 @@ class SubjectsApi(object):
         Get info for a particular file.
         This method makes a synchronous HTTP request by default.
 
-        :param cid: Container Id
-        :type cid: str
-        :param filename:
-        :type filename: str
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: FileOutput
+        :param str cid: Container Id (required)
+        :param str filename: (required)
+        :param bool async_: Perform the request asynchronously
+        :return: FileOutput
         """
 
         all_params = ['cid','filename',]  # noqa: E501
@@ -3890,13 +3535,10 @@ class SubjectsApi(object):
         Get a note of a(n) subject
         This method makes a synchronous HTTP request by default.
 
-        :param cid:
-        :type cid: str
-        :param note_id:
-        :type note_id: str
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: Note
+        :param str cid: (required)
+        :param str note_id: (required)
+        :param bool async_: Perform the request asynchronously
+        :return: Note
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -3920,13 +3562,10 @@ class SubjectsApi(object):
         Get a note of a(n) subject
         This method makes a synchronous HTTP request by default.
 
-        :param cid:
-        :type cid: str
-        :param note_id:
-        :type note_id: str
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: Note
+        :param str cid: (required)
+        :param str note_id: (required)
+        :param bool async_: Perform the request asynchronously
+        :return: Note
         """
 
         all_params = ['cid','note_id',]  # noqa: E501
@@ -4001,29 +3640,18 @@ class SubjectsApi(object):
         List sessions of a subject
         This method makes a synchronous HTTP request by default.
 
-        :param subject_id: 24-char hex subject id
-        :type subject_id: str
-        :param join: join file origins
-        :type join: JoinType, optional
-        :param include_all_info: Include all info in returned objects, defaults to false
-        :type include_all_info: bool, optional
-        :param filter: Comma separated filters to apply. Commas not used as separators must be escaped with backslash '\\'. (e.g. label=my-label,created>2018-09-22)
-        :type filter: str, optional
-        :param sort: The sort fields and order. (e.g. label:asc,created:desc)
-        :type sort: str, optional
-        :param limit: The maximum number of entries to return.
-        :type limit: int, optional
-        :param skip: The number of entries to skip., defaults to 0
-        :type skip: int, optional
-        :param page: The page number (i.e. skip limit*page entries)
-        :type page: int, optional
-        :param after_id: Paginate after the given id. (Cannot be used with sort, page or skip)
-        :type after_id: str, optional
-        :param x_accept_feature:, defaults to []
-        :type x_accept_feature: list[union[HeaderFeature,str]], optional
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: union[Page,list[SessionListOutput]]
+        :param str subject_id: 24-char hex subject id (required)
+        :param JoinType join: join file origins
+        :param bool include_all_info: Include all info in returned objects
+        :param str filter: Comma separated filters to apply. Commas not used as separators must be escaped with backslash '\\'. (e.g. label=my-label,created>2018-09-22)
+        :param str sort: The sort fields and order. (e.g. label:asc,created:desc)
+        :param int limit: The maximum number of entries to return.
+        :param int skip: The number of entries to skip.
+        :param int page: The page number (i.e. skip limit*page entries)
+        :param str after_id: Paginate after the given id. (Cannot be used with sort, page or skip)
+        :param list[union[HeaderFeature,str]] x_accept_feature:
+        :param bool async_: Perform the request asynchronously
+        :return: union[Page,list[SessionListOutput]]
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -4047,29 +3675,18 @@ class SubjectsApi(object):
         List sessions of a subject
         This method makes a synchronous HTTP request by default.
 
-        :param subject_id: 24-char hex subject id
-        :type subject_id: str
-        :param join: join file origins
-        :type join: JoinType, optional
-        :param include_all_info: Include all info in returned objects, defaults to false
-        :type include_all_info: bool, optional
-        :param filter: Comma separated filters to apply. Commas not used as separators must be escaped with backslash '\\'. (e.g. label=my-label,created>2018-09-22)
-        :type filter: str, optional
-        :param sort: The sort fields and order. (e.g. label:asc,created:desc)
-        :type sort: str, optional
-        :param limit: The maximum number of entries to return.
-        :type limit: int, optional
-        :param skip: The number of entries to skip., defaults to 0
-        :type skip: int, optional
-        :param page: The page number (i.e. skip limit*page entries)
-        :type page: int, optional
-        :param after_id: Paginate after the given id. (Cannot be used with sort, page or skip)
-        :type after_id: str, optional
-        :param x_accept_feature:, defaults to []
-        :type x_accept_feature: list[union[HeaderFeature,str]], optional
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: union[Page,list[SessionListOutput]]
+        :param str subject_id: 24-char hex subject id (required)
+        :param JoinType join: join file origins
+        :param bool include_all_info: Include all info in returned objects
+        :param str filter: Comma separated filters to apply. Commas not used as separators must be escaped with backslash '\\'. (e.g. label=my-label,created>2018-09-22)
+        :param str sort: The sort fields and order. (e.g. label:asc,created:desc)
+        :param int limit: The maximum number of entries to return.
+        :param int skip: The number of entries to skip.
+        :param int page: The page number (i.e. skip limit*page entries)
+        :param str after_id: Paginate after the given id. (Cannot be used with sort, page or skip)
+        :param list[union[HeaderFeature,str]] x_accept_feature:
+        :param bool async_: Perform the request asynchronously
+        :return: union[Page,list[SessionListOutput]]
         """
 
         all_params = ['subject_id','join','include_all_info','filter','sort','limit','skip','page','after_id','x_accept_feature',]  # noqa: E501
@@ -4157,13 +3774,10 @@ class SubjectsApi(object):
         Get the value of a tag, by name
         This method makes a synchronous HTTP request by default.
 
-        :param cid:
-        :type cid: str
-        :param value: The tag to interact with
-        :type value: str
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: str
+        :param str cid: (required)
+        :param str value: The tag to interact with (required)
+        :param bool async_: Perform the request asynchronously
+        :return: str
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -4187,13 +3801,10 @@ class SubjectsApi(object):
         Get the value of a tag, by name
         This method makes a synchronous HTTP request by default.
 
-        :param cid:
-        :type cid: str
-        :param value: The tag to interact with
-        :type value: str
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: str
+        :param str cid: (required)
+        :param str value: The tag to interact with (required)
+        :param bool async_: Perform the request asynchronously
+        :return: str
         """
 
         all_params = ['cid','value',]  # noqa: E501
@@ -4268,13 +3879,10 @@ class SubjectsApi(object):
         Update a subject
         This method makes a synchronous HTTP request by default.
 
-        :param subject_id: 24-char hex subject id
-        :type subject_id: str
-        :param body:
-        :type body: SubjectModify
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: ModifiedResult
+        :param str subject_id: 24-char hex subject id (required)
+        :param SubjectModify body: (required)
+        :param bool async_: Perform the request asynchronously
+        :return: ModifiedResult
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -4298,13 +3906,10 @@ class SubjectsApi(object):
         Update a subject
         This method makes a synchronous HTTP request by default.
 
-        :param subject_id: 24-char hex subject id
-        :type subject_id: str
-        :param body:
-        :type body: SubjectModify
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: ModifiedResult
+        :param str subject_id: 24-char hex subject id (required)
+        :param SubjectModify body: (required)
+        :param bool async_: Perform the request asynchronously
+        :return: ModifiedResult
         """
 
         all_params = ['subject_id','body',]  # noqa: E501
@@ -4390,15 +3995,11 @@ class SubjectsApi(object):
         Modify an analysis.
         This method makes a synchronous HTTP request by default.
 
-        :param cid:
-        :type cid: str
-        :param analysis_id:
-        :type analysis_id: str
-        :param body:
-        :type body: AnalysisModifyInput
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: ModifiedResult
+        :param str cid: (required)
+        :param str analysis_id: (required)
+        :param AnalysisModifyInput body: (required)
+        :param bool async_: Perform the request asynchronously
+        :return: ModifiedResult
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -4422,15 +4023,11 @@ class SubjectsApi(object):
         Modify an analysis.
         This method makes a synchronous HTTP request by default.
 
-        :param cid:
-        :type cid: str
-        :param analysis_id:
-        :type analysis_id: str
-        :param body:
-        :type body: AnalysisModifyInput
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: ModifiedResult
+        :param str cid: (required)
+        :param str analysis_id: (required)
+        :param AnalysisModifyInput body: (required)
+        :param bool async_: Perform the request asynchronously
+        :return: ModifiedResult
         """
 
         all_params = ['cid','analysis_id','body',]  # noqa: E501
@@ -4522,15 +4119,11 @@ class SubjectsApi(object):
         Note: If modifying a file's modality, the current classification will be cleared (except for items in the \"Custom\" list)
         This method makes a synchronous HTTP request by default.
 
-        :param cid:
-        :type cid: str
-        :param filename:
-        :type filename: str
-        :param body:
-        :type body: FileModifyInput
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: ModifiedResult
+        :param str cid: (required)
+        :param str filename: (required)
+        :param FileModifyInput body: (required)
+        :param bool async_: Perform the request asynchronously
+        :return: ModifiedResult
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -4554,15 +4147,11 @@ class SubjectsApi(object):
         Note: If modifying a file's modality, the current classification will be cleared (except for items in the \"Custom\" list)
         This method makes a synchronous HTTP request by default.
 
-        :param cid:
-        :type cid: str
-        :param filename:
-        :type filename: str
-        :param body:
-        :type body: FileModifyInput
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: ModifiedResult
+        :param str cid: (required)
+        :param str filename: (required)
+        :param FileModifyInput body: (required)
+        :param bool async_: Perform the request asynchronously
+        :return: ModifiedResult
         """
 
         all_params = ['cid','filename','body',]  # noqa: E501
@@ -4654,15 +4243,11 @@ class SubjectsApi(object):
         If replacing a file's classification, the modality can optionally be modified as well.
         This method makes a synchronous HTTP request by default.
 
-        :param cid:
-        :type cid: str
-        :param filename:
-        :type filename: str
-        :param body:
-        :type body: FileClassificationDelta
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: ModifiedResult
+        :param str cid: (required)
+        :param str filename: (required)
+        :param FileClassificationDelta body: (required)
+        :param bool async_: Perform the request asynchronously
+        :return: ModifiedResult
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -4686,15 +4271,11 @@ class SubjectsApi(object):
         If replacing a file's classification, the modality can optionally be modified as well.
         This method makes a synchronous HTTP request by default.
 
-        :param cid:
-        :type cid: str
-        :param filename:
-        :type filename: str
-        :param body:
-        :type body: FileClassificationDelta
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: ModifiedResult
+        :param str cid: (required)
+        :param str filename: (required)
+        :param FileClassificationDelta body: (required)
+        :param bool async_: Perform the request asynchronously
+        :return: ModifiedResult
         """
 
         all_params = ['cid','filename','body',]  # noqa: E501
@@ -4786,15 +4367,11 @@ class SubjectsApi(object):
         Modify and return the file 'info' field
         This method makes a synchronous HTTP request by default.
 
-        :param cid:
-        :type cid: str
-        :param filename:
-        :type filename: str
-        :param body:
-        :type body: Info
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: ModifiedResult
+        :param str cid: (required)
+        :param str filename: (required)
+        :param Info body: (required)
+        :param bool async_: Perform the request asynchronously
+        :return: ModifiedResult
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -4818,15 +4395,11 @@ class SubjectsApi(object):
         Modify and return the file 'info' field
         This method makes a synchronous HTTP request by default.
 
-        :param cid:
-        :type cid: str
-        :param filename:
-        :type filename: str
-        :param body:
-        :type body: Info
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: ModifiedResult
+        :param str cid: (required)
+        :param str filename: (required)
+        :param Info body: (required)
+        :param bool async_: Perform the request asynchronously
+        :return: ModifiedResult
         """
 
         all_params = ['cid','filename','body',]  # noqa: E501
@@ -4918,13 +4491,10 @@ class SubjectsApi(object):
         Update or replace info for a(n) subject. Keys that contain '$' or '.' will be sanitized in the process of being updated on the container.
         This method makes a synchronous HTTP request by default.
 
-        :param cid:
-        :type cid: str
-        :param body:
-        :type body: Info
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: ModifiedResult
+        :param str cid: (required)
+        :param Info body: (required)
+        :param bool async_: Perform the request asynchronously
+        :return: ModifiedResult
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -4948,13 +4518,10 @@ class SubjectsApi(object):
         Update or replace info for a(n) subject. Keys that contain '$' or '.' will be sanitized in the process of being updated on the container.
         This method makes a synchronous HTTP request by default.
 
-        :param cid:
-        :type cid: str
-        :param body:
-        :type body: Info
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: ModifiedResult
+        :param str cid: (required)
+        :param Info body: (required)
+        :param bool async_: Perform the request asynchronously
+        :return: ModifiedResult
         """
 
         all_params = ['cid','body',]  # noqa: E501
@@ -5040,15 +4607,11 @@ class SubjectsApi(object):
         Update a note of a(n) subject
         This method makes a synchronous HTTP request by default.
 
-        :param cid:
-        :type cid: str
-        :param note_id:
-        :type note_id: str
-        :param body:
-        :type body: NoteInput
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: int
+        :param str cid: (required)
+        :param str note_id: (required)
+        :param NoteInput body: (required)
+        :param bool async_: Perform the request asynchronously
+        :return: int
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -5072,15 +4635,11 @@ class SubjectsApi(object):
         Update a note of a(n) subject
         This method makes a synchronous HTTP request by default.
 
-        :param cid:
-        :type cid: str
-        :param note_id:
-        :type note_id: str
-        :param body:
-        :type body: NoteInput
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: int
+        :param str cid: (required)
+        :param str note_id: (required)
+        :param NoteInput body: (required)
+        :param bool async_: Perform the request asynchronously
+        :return: int
         """
 
         all_params = ['cid','note_id','body',]  # noqa: E501
@@ -5172,15 +4731,11 @@ class SubjectsApi(object):
         Rename a tag
         This method makes a synchronous HTTP request by default.
 
-        :param cid:
-        :type cid: str
-        :param value: The tag to interact with
-        :type value: str
-        :param body:
-        :type body: Tag
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: str
+        :param str cid: (required)
+        :param str value: The tag to interact with (required)
+        :param Tag body: (required)
+        :param bool async_: Perform the request asynchronously
+        :return: str
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -5204,15 +4759,11 @@ class SubjectsApi(object):
         Rename a tag
         This method makes a synchronous HTTP request by default.
 
-        :param cid:
-        :type cid: str
-        :param value: The tag to interact with
-        :type value: str
-        :param body:
-        :type body: Tag
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: str
+        :param str cid: (required)
+        :param str value: The tag to interact with (required)
+        :param Tag body: (required)
+        :param bool async_: Perform the request asynchronously
+        :return: str
         """
 
         all_params = ['cid','value','body',]  # noqa: E501
@@ -5304,13 +4855,10 @@ class SubjectsApi(object):
         Smart copy a subject
         This method makes a synchronous HTTP request by default.
 
-        :param subject_id:
-        :type subject_id: str
-        :param body:
-        :type body: SubjectCopyInput
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: Subject
+        :param str subject_id: (required)
+        :param SubjectCopyInput body: (required)
+        :param bool async_: Perform the request asynchronously
+        :return: Subject
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -5334,13 +4882,10 @@ class SubjectsApi(object):
         Smart copy a subject
         This method makes a synchronous HTTP request by default.
 
-        :param subject_id:
-        :type subject_id: str
-        :param body:
-        :type body: SubjectCopyInput
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: Subject
+        :param str subject_id: (required)
+        :param SubjectCopyInput body: (required)
+        :param bool async_: Perform the request asynchronously
+        :return: Subject
         """
 
         all_params = ['subject_id','body',]  # noqa: E501
@@ -5426,29 +4971,18 @@ class SubjectsApi(object):
         Upload a file to a(n) subject.
         This method makes a synchronous HTTP request by default.
 
-        :param container_id:
-        :type container_id: str
-        :param file: The file to upload
-        :type file: str
-        :param preserve_metadata:, defaults to false
-        :type preserve_metadata: bool, optional
-        :param ticket:
-        :type ticket: str, optional
-        :param id:
-        :type id: str, optional
-        :param level:
-        :type level: ContainerType, optional
-        :param job:
-        :type job: str, optional
-        :param metadata: Dictionary of file metadata (type, modality, info, etc.)
-        :type metadata: object, optional
-        :param x_accept_feature: redirect header, defaults to []
-        :type x_accept_feature: list[str], optional
-        :param content_type:
-        :type content_type: str, optional
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: union[list[FileOutput],UploadTicketOutput]
+        :param str container_id: (required)
+        :param str file: The file to upload (required)
+        :param bool preserve_metadata:
+        :param str ticket:
+        :param str id:
+        :param ContainerType level:
+        :param str job:
+        :param object metadata: Dictionary of file metadata (type, modality, info, etc.)
+        :param list[str] x_accept_feature: redirect header
+        :param str content_type:
+        :param bool async_: Perform the request asynchronously
+        :return: union[list[FileOutput],UploadTicketOutput]
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -5472,29 +5006,18 @@ class SubjectsApi(object):
         Upload a file to a(n) subject.
         This method makes a synchronous HTTP request by default.
 
-        :param container_id:
-        :type container_id: str
-        :param file: The file to upload
-        :type file: str
-        :param preserve_metadata:, defaults to false
-        :type preserve_metadata: bool, optional
-        :param ticket:
-        :type ticket: str, optional
-        :param id:
-        :type id: str, optional
-        :param level:
-        :type level: ContainerType, optional
-        :param job:
-        :type job: str, optional
-        :param metadata: Dictionary of file metadata (type, modality, info, etc.)
-        :type metadata: object, optional
-        :param x_accept_feature: redirect header, defaults to []
-        :type x_accept_feature: list[str], optional
-        :param content_type:
-        :type content_type: str, optional
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: union[list[FileOutput],UploadTicketOutput]
+        :param str container_id: (required)
+        :param str file: The file to upload (required)
+        :param bool preserve_metadata:
+        :param str ticket:
+        :param str id:
+        :param ContainerType level:
+        :param str job:
+        :param object metadata: Dictionary of file metadata (type, modality, info, etc.)
+        :param list[str] x_accept_feature: redirect header
+        :param str content_type:
+        :param bool async_: Perform the request asynchronously
+        :return: union[list[FileOutput],UploadTicketOutput]
         """
 
         all_params = ['container_id','file','preserve_metadata','ticket','id','level','job','metadata','x_accept_feature','content_type',]  # noqa: E501
@@ -5590,25 +5113,16 @@ class SubjectsApi(object):
         Upload an output file to an analysis
         This method makes a synchronous HTTP request by default.
 
-        :param cid:
-        :type cid: str
-        :param analysis_id:
-        :type analysis_id: str
-        :param file: The file to upload
-        :type file: str
-        :param ticket:
-        :type ticket: str, optional
-        :param id:
-        :type id: str, optional
-        :param level:
-        :type level: ContainerType, optional
-        :param job:
-        :type job: str, optional
-        :param content_type:
-        :type content_type: str, optional
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: list[FileOutput]
+        :param str cid: (required)
+        :param str analysis_id: (required)
+        :param str file: The file to upload (required)
+        :param str ticket:
+        :param str id:
+        :param ContainerType level:
+        :param str job:
+        :param str content_type:
+        :param bool async_: Perform the request asynchronously
+        :return: list[FileOutput]
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -5632,25 +5146,16 @@ class SubjectsApi(object):
         Upload an output file to an analysis
         This method makes a synchronous HTTP request by default.
 
-        :param cid:
-        :type cid: str
-        :param analysis_id:
-        :type analysis_id: str
-        :param file: The file to upload
-        :type file: str
-        :param ticket:
-        :type ticket: str, optional
-        :param id:
-        :type id: str, optional
-        :param level:
-        :type level: ContainerType, optional
-        :param job:
-        :type job: str, optional
-        :param content_type:
-        :type content_type: str, optional
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: list[FileOutput]
+        :param str cid: (required)
+        :param str analysis_id: (required)
+        :param str file: The file to upload (required)
+        :param str ticket:
+        :param str id:
+        :param ContainerType level:
+        :param str job:
+        :param str content_type:
+        :param bool async_: Perform the request asynchronously
+        :return: list[FileOutput]
         """
 
         all_params = ['cid','analysis_id','file','ticket','id','level','job','content_type',]  # noqa: E501
@@ -5745,11 +5250,9 @@ class SubjectsApi(object):
         Verify that the given master subject code exists or not
         This method makes a synchronous HTTP request by default.
 
-        :param code: code id
-        :type code: str
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: MasterSubjectCodeOutput
+        :param str code: code id (required)
+        :param bool async_: Perform the request asynchronously
+        :return: MasterSubjectCodeOutput
         """
         ignore_simplified_return_value = kwargs.pop('_ignore_simplified_return_value', False)
         kwargs['_return_http_data_only'] = True
@@ -5773,11 +5276,9 @@ class SubjectsApi(object):
         Verify that the given master subject code exists or not
         This method makes a synchronous HTTP request by default.
 
-        :param code: code id
-        :type code: str
-        :param async_: Perform the request asynchronously
-        :type async_: bool, optional
-        :rtype: MasterSubjectCodeOutput
+        :param str code: code id (required)
+        :param bool async_: Perform the request asynchronously
+        :return: MasterSubjectCodeOutput
         """
 
         all_params = ['code',]  # noqa: E501