docusign_esign.apis.cloud_storage_api

  1# coding: utf-8
  2
  3"""
  4    DocuSign REST API
  5
  6    The DocuSign REST API provides you with a powerful, convenient, and simple Web services API for interacting with DocuSign.  # noqa: E501
  7
  8    OpenAPI spec version: v2.1
  9    Contact: devcenter@docusign.com
 10    Generated by: https://github.com/swagger-api/swagger-codegen.git
 11"""
 12
 13
 14from __future__ import absolute_import
 15
 16import sys
 17import os
 18import re
 19
 20# python 2 and python 3 compatibility library
 21from six import iteritems
 22
 23from ..client.configuration import Configuration
 24from ..client.api_client import ApiClient
 25
 26
 27class CloudStorageApi(object):
 28    """
 29    NOTE: This class is auto generated by the swagger code generator program.
 30    Do not edit the class manually.
 31    Ref: https://github.com/swagger-api/swagger-codegen
 32    """
 33
 34    def __init__(self, api_client=None):
 35        config = Configuration()
 36        if api_client:
 37            self.api_client = api_client
 38        else:
 39            if not config.api_client:
 40                config.api_client = ApiClient()
 41            self.api_client = config.api_client
 42
 43    def create_provider(self, account_id, user_id, **kwargs):
 44        """
 45        Configures the redirect URL information  for one or more cloud storage providers for the specified user.
 46        Configures the redirect URL information  for one or more cloud storage providers for the specified user. The redirect URL is added to the authentication URL to complete the return route.
 47        This method makes a synchronous HTTP request by default. To make an
 48        asynchronous HTTP request, please define a `callback` function
 49        to be invoked when receiving the response.
 50        >>> def callback_function(response):
 51        >>>     pprint(response)
 52        >>>
 53        >>> thread = api.create_provider(account_id, user_id, callback=callback_function)
 54
 55        :param callback function: The callback function
 56            for asynchronous request. (optional)
 57        :param str account_id: The external account number (int) or account ID Guid. (required)
 58        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
 59        :param CloudStorageProviders cloud_storage_providers:
 60        :return: CloudStorageProviders
 61                 If the method is called asynchronously,
 62                 returns the request thread.
 63        """
 64        kwargs['_return_http_data_only'] = True
 65        if kwargs.get('callback'):
 66            return self.create_provider_with_http_info(account_id, user_id, **kwargs)
 67        else:
 68            (data) = self.create_provider_with_http_info(account_id, user_id, **kwargs)
 69            return data
 70
 71    def create_provider_with_http_info(self, account_id, user_id, **kwargs):
 72        """
 73        Configures the redirect URL information  for one or more cloud storage providers for the specified user.
 74        Configures the redirect URL information  for one or more cloud storage providers for the specified user. The redirect URL is added to the authentication URL to complete the return route.
 75        This method makes a synchronous HTTP request by default. To make an
 76        asynchronous HTTP request, please define a `callback` function
 77        to be invoked when receiving the response.
 78        >>> def callback_function(response):
 79        >>>     pprint(response)
 80        >>>
 81        >>> thread = api.create_provider_with_http_info(account_id, user_id, callback=callback_function)
 82
 83        :param callback function: The callback function
 84            for asynchronous request. (optional)
 85        :param str account_id: The external account number (int) or account ID Guid. (required)
 86        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
 87        :param CloudStorageProviders cloud_storage_providers:
 88        :return: CloudStorageProviders
 89                 If the method is called asynchronously,
 90                 returns the request thread.
 91        """
 92
 93        all_params = ['account_id', 'user_id', 'cloud_storage_providers']
 94        all_params.append('callback')
 95        all_params.append('_return_http_data_only')
 96        all_params.append('_preload_content')
 97        all_params.append('_request_timeout')
 98
 99        params = locals()
100        for key, val in iteritems(params['kwargs']):
101            if key not in all_params:
102                raise TypeError(
103                    "Got an unexpected keyword argument '%s'"
104                    " to method create_provider" % key
105                )
106            params[key] = val
107        del params['kwargs']
108        # verify the required parameter 'account_id' is set
109        if ('account_id' not in params) or (params['account_id'] is None):
110            raise ValueError("Missing the required parameter `account_id` when calling `create_provider`")
111        # verify the required parameter 'user_id' is set
112        if ('user_id' not in params) or (params['user_id'] is None):
113            raise ValueError("Missing the required parameter `user_id` when calling `create_provider`")
114
115
116        collection_formats = {}
117
118        resource_path = '/v2.1/accounts/{accountId}/users/{userId}/cloud_storage'.replace('{format}', 'json')
119        path_params = {}
120        if 'account_id' in params:
121            path_params['accountId'] = params['account_id']
122        if 'user_id' in params:
123            path_params['userId'] = params['user_id']
124
125        query_params = {}
126
127        header_params = {}
128
129        form_params = []
130        local_var_files = {}
131
132        body_params = None
133        if 'cloud_storage_providers' in params:
134            body_params = params['cloud_storage_providers']
135        # HTTP header `Accept`
136        header_params['Accept'] = self.api_client.\
137            select_header_accept(['application/json'])
138
139        # Authentication setting
140        auth_settings = []
141
142        return self.api_client.call_api(resource_path, 'POST',
143                                        path_params,
144                                        query_params,
145                                        header_params,
146                                        body=body_params,
147                                        post_params=form_params,
148                                        files=local_var_files,
149                                        response_type='CloudStorageProviders',
150                                        auth_settings=auth_settings,
151                                        callback=params.get('callback'),
152                                        _return_http_data_only=params.get('_return_http_data_only'),
153                                        _preload_content=params.get('_preload_content', True),
154                                        _request_timeout=params.get('_request_timeout'),
155                                        collection_formats=collection_formats)
156
157    def delete_provider(self, account_id, service_id, user_id, **kwargs):
158        """
159        Deletes the user authentication information for the specified cloud storage provider.
160        Deletes the user authentication information for the specified cloud storage provider. The next time the user tries to access the cloud storage provider, they must pass normal authentication for this cloud storage provider.
161        This method makes a synchronous HTTP request by default. To make an
162        asynchronous HTTP request, please define a `callback` function
163        to be invoked when receiving the response.
164        >>> def callback_function(response):
165        >>>     pprint(response)
166        >>>
167        >>> thread = api.delete_provider(account_id, service_id, user_id, callback=callback_function)
168
169        :param callback function: The callback function
170            for asynchronous request. (optional)
171        :param str account_id: The external account number (int) or account ID Guid. (required)
172        :param str service_id: The ID of the service to access.   Valid values are the service name (\"Box\") or the numerical serviceId (\"4136\"). (required)
173        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
174        :return: CloudStorageProviders
175                 If the method is called asynchronously,
176                 returns the request thread.
177        """
178        kwargs['_return_http_data_only'] = True
179        if kwargs.get('callback'):
180            return self.delete_provider_with_http_info(account_id, service_id, user_id, **kwargs)
181        else:
182            (data) = self.delete_provider_with_http_info(account_id, service_id, user_id, **kwargs)
183            return data
184
185    def delete_provider_with_http_info(self, account_id, service_id, user_id, **kwargs):
186        """
187        Deletes the user authentication information for the specified cloud storage provider.
188        Deletes the user authentication information for the specified cloud storage provider. The next time the user tries to access the cloud storage provider, they must pass normal authentication for this cloud storage provider.
189        This method makes a synchronous HTTP request by default. To make an
190        asynchronous HTTP request, please define a `callback` function
191        to be invoked when receiving the response.
192        >>> def callback_function(response):
193        >>>     pprint(response)
194        >>>
195        >>> thread = api.delete_provider_with_http_info(account_id, service_id, user_id, callback=callback_function)
196
197        :param callback function: The callback function
198            for asynchronous request. (optional)
199        :param str account_id: The external account number (int) or account ID Guid. (required)
200        :param str service_id: The ID of the service to access.   Valid values are the service name (\"Box\") or the numerical serviceId (\"4136\"). (required)
201        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
202        :return: CloudStorageProviders
203                 If the method is called asynchronously,
204                 returns the request thread.
205        """
206
207        all_params = ['account_id', 'service_id', 'user_id']
208        all_params.append('callback')
209        all_params.append('_return_http_data_only')
210        all_params.append('_preload_content')
211        all_params.append('_request_timeout')
212
213        params = locals()
214        for key, val in iteritems(params['kwargs']):
215            if key not in all_params:
216                raise TypeError(
217                    "Got an unexpected keyword argument '%s'"
218                    " to method delete_provider" % key
219                )
220            params[key] = val
221        del params['kwargs']
222        # verify the required parameter 'account_id' is set
223        if ('account_id' not in params) or (params['account_id'] is None):
224            raise ValueError("Missing the required parameter `account_id` when calling `delete_provider`")
225        # verify the required parameter 'service_id' is set
226        if ('service_id' not in params) or (params['service_id'] is None):
227            raise ValueError("Missing the required parameter `service_id` when calling `delete_provider`")
228        # verify the required parameter 'user_id' is set
229        if ('user_id' not in params) or (params['user_id'] is None):
230            raise ValueError("Missing the required parameter `user_id` when calling `delete_provider`")
231
232
233        collection_formats = {}
234
235        resource_path = '/v2.1/accounts/{accountId}/users/{userId}/cloud_storage/{serviceId}'.replace('{format}', 'json')
236        path_params = {}
237        if 'account_id' in params:
238            path_params['accountId'] = params['account_id']
239        if 'service_id' in params:
240            path_params['serviceId'] = params['service_id']
241        if 'user_id' in params:
242            path_params['userId'] = params['user_id']
243
244        query_params = {}
245
246        header_params = {}
247
248        form_params = []
249        local_var_files = {}
250
251        body_params = None
252        # HTTP header `Accept`
253        header_params['Accept'] = self.api_client.\
254            select_header_accept(['application/json'])
255
256        # Authentication setting
257        auth_settings = []
258
259        return self.api_client.call_api(resource_path, 'DELETE',
260                                        path_params,
261                                        query_params,
262                                        header_params,
263                                        body=body_params,
264                                        post_params=form_params,
265                                        files=local_var_files,
266                                        response_type='CloudStorageProviders',
267                                        auth_settings=auth_settings,
268                                        callback=params.get('callback'),
269                                        _return_http_data_only=params.get('_return_http_data_only'),
270                                        _preload_content=params.get('_preload_content', True),
271                                        _request_timeout=params.get('_request_timeout'),
272                                        collection_formats=collection_formats)
273
274    def delete_providers(self, account_id, user_id, **kwargs):
275        """
276        Deletes the user authentication information for one or more cloud storage providers.
277        Deletes the user authentication information for one or more cloud storage providers. The next time the user tries to access the cloud storage provider, they must pass normal authentication.
278        This method makes a synchronous HTTP request by default. To make an
279        asynchronous HTTP request, please define a `callback` function
280        to be invoked when receiving the response.
281        >>> def callback_function(response):
282        >>>     pprint(response)
283        >>>
284        >>> thread = api.delete_providers(account_id, user_id, callback=callback_function)
285
286        :param callback function: The callback function
287            for asynchronous request. (optional)
288        :param str account_id: The external account number (int) or account ID Guid. (required)
289        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
290        :param CloudStorageProviders cloud_storage_providers:
291        :return: CloudStorageProviders
292                 If the method is called asynchronously,
293                 returns the request thread.
294        """
295        kwargs['_return_http_data_only'] = True
296        if kwargs.get('callback'):
297            return self.delete_providers_with_http_info(account_id, user_id, **kwargs)
298        else:
299            (data) = self.delete_providers_with_http_info(account_id, user_id, **kwargs)
300            return data
301
302    def delete_providers_with_http_info(self, account_id, user_id, **kwargs):
303        """
304        Deletes the user authentication information for one or more cloud storage providers.
305        Deletes the user authentication information for one or more cloud storage providers. The next time the user tries to access the cloud storage provider, they must pass normal authentication.
306        This method makes a synchronous HTTP request by default. To make an
307        asynchronous HTTP request, please define a `callback` function
308        to be invoked when receiving the response.
309        >>> def callback_function(response):
310        >>>     pprint(response)
311        >>>
312        >>> thread = api.delete_providers_with_http_info(account_id, user_id, callback=callback_function)
313
314        :param callback function: The callback function
315            for asynchronous request. (optional)
316        :param str account_id: The external account number (int) or account ID Guid. (required)
317        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
318        :param CloudStorageProviders cloud_storage_providers:
319        :return: CloudStorageProviders
320                 If the method is called asynchronously,
321                 returns the request thread.
322        """
323
324        all_params = ['account_id', 'user_id', 'cloud_storage_providers']
325        all_params.append('callback')
326        all_params.append('_return_http_data_only')
327        all_params.append('_preload_content')
328        all_params.append('_request_timeout')
329
330        params = locals()
331        for key, val in iteritems(params['kwargs']):
332            if key not in all_params:
333                raise TypeError(
334                    "Got an unexpected keyword argument '%s'"
335                    " to method delete_providers" % key
336                )
337            params[key] = val
338        del params['kwargs']
339        # verify the required parameter 'account_id' is set
340        if ('account_id' not in params) or (params['account_id'] is None):
341            raise ValueError("Missing the required parameter `account_id` when calling `delete_providers`")
342        # verify the required parameter 'user_id' is set
343        if ('user_id' not in params) or (params['user_id'] is None):
344            raise ValueError("Missing the required parameter `user_id` when calling `delete_providers`")
345
346
347        collection_formats = {}
348
349        resource_path = '/v2.1/accounts/{accountId}/users/{userId}/cloud_storage'.replace('{format}', 'json')
350        path_params = {}
351        if 'account_id' in params:
352            path_params['accountId'] = params['account_id']
353        if 'user_id' in params:
354            path_params['userId'] = params['user_id']
355
356        query_params = {}
357
358        header_params = {}
359
360        form_params = []
361        local_var_files = {}
362
363        body_params = None
364        if 'cloud_storage_providers' in params:
365            body_params = params['cloud_storage_providers']
366        # HTTP header `Accept`
367        header_params['Accept'] = self.api_client.\
368            select_header_accept(['application/json'])
369
370        # Authentication setting
371        auth_settings = []
372
373        return self.api_client.call_api(resource_path, 'DELETE',
374                                        path_params,
375                                        query_params,
376                                        header_params,
377                                        body=body_params,
378                                        post_params=form_params,
379                                        files=local_var_files,
380                                        response_type='CloudStorageProviders',
381                                        auth_settings=auth_settings,
382                                        callback=params.get('callback'),
383                                        _return_http_data_only=params.get('_return_http_data_only'),
384                                        _preload_content=params.get('_preload_content', True),
385                                        _request_timeout=params.get('_request_timeout'),
386                                        collection_formats=collection_formats)
387
388    def get_provider(self, account_id, service_id, user_id, **kwargs):
389        """
390        Gets the specified Cloud Storage Provider configuration for the User.
391        Retrieves the list of cloud storage providers enabled for the account and the configuration information for the user.
392        This method makes a synchronous HTTP request by default. To make an
393        asynchronous HTTP request, please define a `callback` function
394        to be invoked when receiving the response.
395        >>> def callback_function(response):
396        >>>     pprint(response)
397        >>>
398        >>> thread = api.get_provider(account_id, service_id, user_id, callback=callback_function)
399
400        :param callback function: The callback function
401            for asynchronous request. (optional)
402        :param str account_id: The external account number (int) or account ID Guid. (required)
403        :param str service_id: The ID of the service to access.   Valid values are the service name (\"Box\") or the numerical serviceId (\"4136\"). (required)
404        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
405        :param str redirect_url:  The URL the user is redirected to after the cloud storage provider authenticates the user. Using this will append the redirectUrl to the authenticationUrl.  The redirectUrl is restricted to URLs in the docusign.com or docusign.net domains.  
406        :return: CloudStorageProviders
407                 If the method is called asynchronously,
408                 returns the request thread.
409        """
410        kwargs['_return_http_data_only'] = True
411        if kwargs.get('callback'):
412            return self.get_provider_with_http_info(account_id, service_id, user_id, **kwargs)
413        else:
414            (data) = self.get_provider_with_http_info(account_id, service_id, user_id, **kwargs)
415            return data
416
417    def get_provider_with_http_info(self, account_id, service_id, user_id, **kwargs):
418        """
419        Gets the specified Cloud Storage Provider configuration for the User.
420        Retrieves the list of cloud storage providers enabled for the account and the configuration information for the user.
421        This method makes a synchronous HTTP request by default. To make an
422        asynchronous HTTP request, please define a `callback` function
423        to be invoked when receiving the response.
424        >>> def callback_function(response):
425        >>>     pprint(response)
426        >>>
427        >>> thread = api.get_provider_with_http_info(account_id, service_id, user_id, callback=callback_function)
428
429        :param callback function: The callback function
430            for asynchronous request. (optional)
431        :param str account_id: The external account number (int) or account ID Guid. (required)
432        :param str service_id: The ID of the service to access.   Valid values are the service name (\"Box\") or the numerical serviceId (\"4136\"). (required)
433        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
434        :param str redirect_url:  The URL the user is redirected to after the cloud storage provider authenticates the user. Using this will append the redirectUrl to the authenticationUrl.  The redirectUrl is restricted to URLs in the docusign.com or docusign.net domains.  
435        :return: CloudStorageProviders
436                 If the method is called asynchronously,
437                 returns the request thread.
438        """
439
440        all_params = ['account_id', 'service_id', 'user_id', 'redirect_url']
441        all_params.append('callback')
442        all_params.append('_return_http_data_only')
443        all_params.append('_preload_content')
444        all_params.append('_request_timeout')
445
446        params = locals()
447        for key, val in iteritems(params['kwargs']):
448            if key not in all_params:
449                raise TypeError(
450                    "Got an unexpected keyword argument '%s'"
451                    " to method get_provider" % key
452                )
453            params[key] = val
454        del params['kwargs']
455        # verify the required parameter 'account_id' is set
456        if ('account_id' not in params) or (params['account_id'] is None):
457            raise ValueError("Missing the required parameter `account_id` when calling `get_provider`")
458        # verify the required parameter 'service_id' is set
459        if ('service_id' not in params) or (params['service_id'] is None):
460            raise ValueError("Missing the required parameter `service_id` when calling `get_provider`")
461        # verify the required parameter 'user_id' is set
462        if ('user_id' not in params) or (params['user_id'] is None):
463            raise ValueError("Missing the required parameter `user_id` when calling `get_provider`")
464
465
466        collection_formats = {}
467
468        resource_path = '/v2.1/accounts/{accountId}/users/{userId}/cloud_storage/{serviceId}'.replace('{format}', 'json')
469        path_params = {}
470        if 'account_id' in params:
471            path_params['accountId'] = params['account_id']
472        if 'service_id' in params:
473            path_params['serviceId'] = params['service_id']
474        if 'user_id' in params:
475            path_params['userId'] = params['user_id']
476
477        query_params = {}
478        if 'redirect_url' in params:
479            query_params['redirectUrl'] = params['redirect_url']
480
481        header_params = {}
482
483        form_params = []
484        local_var_files = {}
485
486        body_params = None
487        # HTTP header `Accept`
488        header_params['Accept'] = self.api_client.\
489            select_header_accept(['application/json'])
490
491        # Authentication setting
492        auth_settings = []
493
494        return self.api_client.call_api(resource_path, 'GET',
495                                        path_params,
496                                        query_params,
497                                        header_params,
498                                        body=body_params,
499                                        post_params=form_params,
500                                        files=local_var_files,
501                                        response_type='CloudStorageProviders',
502                                        auth_settings=auth_settings,
503                                        callback=params.get('callback'),
504                                        _return_http_data_only=params.get('_return_http_data_only'),
505                                        _preload_content=params.get('_preload_content', True),
506                                        _request_timeout=params.get('_request_timeout'),
507                                        collection_formats=collection_formats)
508
509    def list(self, account_id, folder_id, service_id, user_id, **kwargs):
510        """
511        Gets a list of all the items from the specified cloud storage provider.
512        Retrieves a list of all the items in all  the folders associated with the user from the specified cloud storage provider. You can limit the scope of the returned items by providing a comma separated list of folder IDs in the request.
513        This method makes a synchronous HTTP request by default. To make an
514        asynchronous HTTP request, please define a `callback` function
515        to be invoked when receiving the response.
516        >>> def callback_function(response):
517        >>>     pprint(response)
518        >>>
519        >>> thread = api.list(account_id, folder_id, service_id, user_id, callback=callback_function)
520
521        :param callback function: The callback function
522            for asynchronous request. (optional)
523        :param str account_id: The external account number (int) or account ID Guid. (required)
524        :param str folder_id: The ID of the folder being accessed. (required)
525        :param str service_id: The ID of the service to access.   Valid values are the service name (\"Box\") or the numerical serviceId (\"4136\"). (required)
526        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
527        :param str cloud_storage_folder_path:
528        :param str cloud_storage_folderid_plain:
529        :param str count: An optional value that sets how many items are included in the response.   The default setting for this is 25. 
530        :param str order: An optional value that sets the direction order used to sort the item list.   Valid values are:   * asc = ascending sort order * desc = descending sort order 
531        :param str order_by: An optional value that sets the file attribute used to sort the item list.   Valid values are:   * modified * name  
532        :param str search_text:
533        :param str start_position: Indicates the starting point of the first item included in the response set. It uses a 0-based index. The default setting for this is 0.  
534        :return: ExternalFolder
535                 If the method is called asynchronously,
536                 returns the request thread.
537        """
538        kwargs['_return_http_data_only'] = True
539        if kwargs.get('callback'):
540            return self.list_with_http_info(account_id, folder_id, service_id, user_id, **kwargs)
541        else:
542            (data) = self.list_with_http_info(account_id, folder_id, service_id, user_id, **kwargs)
543            return data
544
545    def list_with_http_info(self, account_id, folder_id, service_id, user_id, **kwargs):
546        """
547        Gets a list of all the items from the specified cloud storage provider.
548        Retrieves a list of all the items in all  the folders associated with the user from the specified cloud storage provider. You can limit the scope of the returned items by providing a comma separated list of folder IDs in the request.
549        This method makes a synchronous HTTP request by default. To make an
550        asynchronous HTTP request, please define a `callback` function
551        to be invoked when receiving the response.
552        >>> def callback_function(response):
553        >>>     pprint(response)
554        >>>
555        >>> thread = api.list_with_http_info(account_id, folder_id, service_id, user_id, callback=callback_function)
556
557        :param callback function: The callback function
558            for asynchronous request. (optional)
559        :param str account_id: The external account number (int) or account ID Guid. (required)
560        :param str folder_id: The ID of the folder being accessed. (required)
561        :param str service_id: The ID of the service to access.   Valid values are the service name (\"Box\") or the numerical serviceId (\"4136\"). (required)
562        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
563        :param str cloud_storage_folder_path:
564        :param str cloud_storage_folderid_plain:
565        :param str count: An optional value that sets how many items are included in the response.   The default setting for this is 25. 
566        :param str order: An optional value that sets the direction order used to sort the item list.   Valid values are:   * asc = ascending sort order * desc = descending sort order 
567        :param str order_by: An optional value that sets the file attribute used to sort the item list.   Valid values are:   * modified * name  
568        :param str search_text:
569        :param str start_position: Indicates the starting point of the first item included in the response set. It uses a 0-based index. The default setting for this is 0.  
570        :return: ExternalFolder
571                 If the method is called asynchronously,
572                 returns the request thread.
573        """
574
575        all_params = ['account_id', 'folder_id', 'service_id', 'user_id', 'cloud_storage_folder_path', 'cloud_storage_folderid_plain', 'count', 'order', 'order_by', 'search_text', 'start_position']
576        all_params.append('callback')
577        all_params.append('_return_http_data_only')
578        all_params.append('_preload_content')
579        all_params.append('_request_timeout')
580
581        params = locals()
582        for key, val in iteritems(params['kwargs']):
583            if key not in all_params:
584                raise TypeError(
585                    "Got an unexpected keyword argument '%s'"
586                    " to method list" % key
587                )
588            params[key] = val
589        del params['kwargs']
590        # verify the required parameter 'account_id' is set
591        if ('account_id' not in params) or (params['account_id'] is None):
592            raise ValueError("Missing the required parameter `account_id` when calling `list`")
593        # verify the required parameter 'folder_id' is set
594        if ('folder_id' not in params) or (params['folder_id'] is None):
595            raise ValueError("Missing the required parameter `folder_id` when calling `list`")
596        # verify the required parameter 'service_id' is set
597        if ('service_id' not in params) or (params['service_id'] is None):
598            raise ValueError("Missing the required parameter `service_id` when calling `list`")
599        # verify the required parameter 'user_id' is set
600        if ('user_id' not in params) or (params['user_id'] is None):
601            raise ValueError("Missing the required parameter `user_id` when calling `list`")
602
603
604        collection_formats = {}
605
606        resource_path = '/v2.1/accounts/{accountId}/users/{userId}/cloud_storage/{serviceId}/folders/{folderId}'.replace('{format}', 'json')
607        path_params = {}
608        if 'account_id' in params:
609            path_params['accountId'] = params['account_id']
610        if 'folder_id' in params:
611            path_params['folderId'] = params['folder_id']
612        if 'service_id' in params:
613            path_params['serviceId'] = params['service_id']
614        if 'user_id' in params:
615            path_params['userId'] = params['user_id']
616
617        query_params = {}
618        if 'cloud_storage_folder_path' in params:
619            query_params['cloud_storage_folder_path'] = params['cloud_storage_folder_path']
620        if 'cloud_storage_folderid_plain' in params:
621            query_params['cloud_storage_folderid_plain'] = params['cloud_storage_folderid_plain']
622        if 'count' in params:
623            query_params['count'] = params['count']
624        if 'order' in params:
625            query_params['order'] = params['order']
626        if 'order_by' in params:
627            query_params['order_by'] = params['order_by']
628        if 'search_text' in params:
629            query_params['search_text'] = params['search_text']
630        if 'start_position' in params:
631            query_params['start_position'] = params['start_position']
632
633        header_params = {}
634
635        form_params = []
636        local_var_files = {}
637
638        body_params = None
639        # HTTP header `Accept`
640        header_params['Accept'] = self.api_client.\
641            select_header_accept(['application/json'])
642
643        # Authentication setting
644        auth_settings = []
645
646        return self.api_client.call_api(resource_path, 'GET',
647                                        path_params,
648                                        query_params,
649                                        header_params,
650                                        body=body_params,
651                                        post_params=form_params,
652                                        files=local_var_files,
653                                        response_type='ExternalFolder',
654                                        auth_settings=auth_settings,
655                                        callback=params.get('callback'),
656                                        _return_http_data_only=params.get('_return_http_data_only'),
657                                        _preload_content=params.get('_preload_content', True),
658                                        _request_timeout=params.get('_request_timeout'),
659                                        collection_formats=collection_formats)
660
661    def list_folders(self, account_id, service_id, user_id, **kwargs):
662        """
663        Retrieves a list of all the items in a specified folder from the specified cloud storage provider.
664        Retrieves a list of all the items in a specified folder from the specified cloud storage provider. 
665        This method makes a synchronous HTTP request by default. To make an
666        asynchronous HTTP request, please define a `callback` function
667        to be invoked when receiving the response.
668        >>> def callback_function(response):
669        >>>     pprint(response)
670        >>>
671        >>> thread = api.list_folders(account_id, service_id, user_id, callback=callback_function)
672
673        :param callback function: The callback function
674            for asynchronous request. (optional)
675        :param str account_id: The external account number (int) or account ID Guid. (required)
676        :param str service_id: The ID of the service to access.   Valid values are the service name (\"Box\") or the numerical serviceId (\"4136\"). (required)
677        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
678        :param str cloud_storage_folder_path: A comma separated list of folder IDs included in the request. 
679        :param str count: An optional value that sets how many items are included in the response.   The default setting for this is 25. 
680        :param str order: An optional value that sets the direction order used to sort the item list.   Valid values are:   * asc = ascending sort order * desc = descending sort order 
681        :param str order_by: An optional value that sets the file attribute used to sort the item list.   Valid values are:   * modified * name  
682        :param str search_text:
683        :param str start_position: Indicates the starting point of the first item included in the response set. It uses a 0-based index. The default setting for this is 0.  
684        :return: ExternalFolder
685                 If the method is called asynchronously,
686                 returns the request thread.
687        """
688        kwargs['_return_http_data_only'] = True
689        if kwargs.get('callback'):
690            return self.list_folders_with_http_info(account_id, service_id, user_id, **kwargs)
691        else:
692            (data) = self.list_folders_with_http_info(account_id, service_id, user_id, **kwargs)
693            return data
694
695    def list_folders_with_http_info(self, account_id, service_id, user_id, **kwargs):
696        """
697        Retrieves a list of all the items in a specified folder from the specified cloud storage provider.
698        Retrieves a list of all the items in a specified folder from the specified cloud storage provider. 
699        This method makes a synchronous HTTP request by default. To make an
700        asynchronous HTTP request, please define a `callback` function
701        to be invoked when receiving the response.
702        >>> def callback_function(response):
703        >>>     pprint(response)
704        >>>
705        >>> thread = api.list_folders_with_http_info(account_id, service_id, user_id, callback=callback_function)
706
707        :param callback function: The callback function
708            for asynchronous request. (optional)
709        :param str account_id: The external account number (int) or account ID Guid. (required)
710        :param str service_id: The ID of the service to access.   Valid values are the service name (\"Box\") or the numerical serviceId (\"4136\"). (required)
711        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
712        :param str cloud_storage_folder_path: A comma separated list of folder IDs included in the request. 
713        :param str count: An optional value that sets how many items are included in the response.   The default setting for this is 25. 
714        :param str order: An optional value that sets the direction order used to sort the item list.   Valid values are:   * asc = ascending sort order * desc = descending sort order 
715        :param str order_by: An optional value that sets the file attribute used to sort the item list.   Valid values are:   * modified * name  
716        :param str search_text:
717        :param str start_position: Indicates the starting point of the first item included in the response set. It uses a 0-based index. The default setting for this is 0.  
718        :return: ExternalFolder
719                 If the method is called asynchronously,
720                 returns the request thread.
721        """
722
723        all_params = ['account_id', 'service_id', 'user_id', 'cloud_storage_folder_path', 'count', 'order', 'order_by', 'search_text', 'start_position']
724        all_params.append('callback')
725        all_params.append('_return_http_data_only')
726        all_params.append('_preload_content')
727        all_params.append('_request_timeout')
728
729        params = locals()
730        for key, val in iteritems(params['kwargs']):
731            if key not in all_params:
732                raise TypeError(
733                    "Got an unexpected keyword argument '%s'"
734                    " to method list_folders" % key
735                )
736            params[key] = val
737        del params['kwargs']
738        # verify the required parameter 'account_id' is set
739        if ('account_id' not in params) or (params['account_id'] is None):
740            raise ValueError("Missing the required parameter `account_id` when calling `list_folders`")
741        # verify the required parameter 'service_id' is set
742        if ('service_id' not in params) or (params['service_id'] is None):
743            raise ValueError("Missing the required parameter `service_id` when calling `list_folders`")
744        # verify the required parameter 'user_id' is set
745        if ('user_id' not in params) or (params['user_id'] is None):
746            raise ValueError("Missing the required parameter `user_id` when calling `list_folders`")
747
748
749        collection_formats = {}
750
751        resource_path = '/v2.1/accounts/{accountId}/users/{userId}/cloud_storage/{serviceId}/folders'.replace('{format}', 'json')
752        path_params = {}
753        if 'account_id' in params:
754            path_params['accountId'] = params['account_id']
755        if 'service_id' in params:
756            path_params['serviceId'] = params['service_id']
757        if 'user_id' in params:
758            path_params['userId'] = params['user_id']
759
760        query_params = {}
761        if 'cloud_storage_folder_path' in params:
762            query_params['cloud_storage_folder_path'] = params['cloud_storage_folder_path']
763        if 'count' in params:
764            query_params['count'] = params['count']
765        if 'order' in params:
766            query_params['order'] = params['order']
767        if 'order_by' in params:
768            query_params['order_by'] = params['order_by']
769        if 'search_text' in params:
770            query_params['search_text'] = params['search_text']
771        if 'start_position' in params:
772            query_params['start_position'] = params['start_position']
773
774        header_params = {}
775
776        form_params = []
777        local_var_files = {}
778
779        body_params = None
780        # HTTP header `Accept`
781        header_params['Accept'] = self.api_client.\
782            select_header_accept(['application/json'])
783
784        # Authentication setting
785        auth_settings = []
786
787        return self.api_client.call_api(resource_path, 'GET',
788                                        path_params,
789                                        query_params,
790                                        header_params,
791                                        body=body_params,
792                                        post_params=form_params,
793                                        files=local_var_files,
794                                        response_type='ExternalFolder',
795                                        auth_settings=auth_settings,
796                                        callback=params.get('callback'),
797                                        _return_http_data_only=params.get('_return_http_data_only'),
798                                        _preload_content=params.get('_preload_content', True),
799                                        _request_timeout=params.get('_request_timeout'),
800                                        collection_formats=collection_formats)
801
802    def list_providers(self, account_id, user_id, **kwargs):
803        """
804        Get the Cloud Storage Provider configuration for the specified user.
805        Retrieves the list of cloud storage providers enabled for the account and the configuration information for the user.  The {serviceId} parameter can be either the service name or serviceId.
806        This method makes a synchronous HTTP request by default. To make an
807        asynchronous HTTP request, please define a `callback` function
808        to be invoked when receiving the response.
809        >>> def callback_function(response):
810        >>>     pprint(response)
811        >>>
812        >>> thread = api.list_providers(account_id, user_id, callback=callback_function)
813
814        :param callback function: The callback function
815            for asynchronous request. (optional)
816        :param str account_id: The external account number (int) or account ID Guid. (required)
817        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
818        :param str redirect_url:  The URL the user is redirected to after the cloud storage provider authenticates the user. Using this will append the redirectUrl to the authenticationUrl.  The redirectUrl is restricted to URLs in the docusign.com or docusign.net domains.  
819        :return: CloudStorageProviders
820                 If the method is called asynchronously,
821                 returns the request thread.
822        """
823        kwargs['_return_http_data_only'] = True
824        if kwargs.get('callback'):
825            return self.list_providers_with_http_info(account_id, user_id, **kwargs)
826        else:
827            (data) = self.list_providers_with_http_info(account_id, user_id, **kwargs)
828            return data
829
830    def list_providers_with_http_info(self, account_id, user_id, **kwargs):
831        """
832        Get the Cloud Storage Provider configuration for the specified user.
833        Retrieves the list of cloud storage providers enabled for the account and the configuration information for the user.  The {serviceId} parameter can be either the service name or serviceId.
834        This method makes a synchronous HTTP request by default. To make an
835        asynchronous HTTP request, please define a `callback` function
836        to be invoked when receiving the response.
837        >>> def callback_function(response):
838        >>>     pprint(response)
839        >>>
840        >>> thread = api.list_providers_with_http_info(account_id, user_id, callback=callback_function)
841
842        :param callback function: The callback function
843            for asynchronous request. (optional)
844        :param str account_id: The external account number (int) or account ID Guid. (required)
845        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
846        :param str redirect_url:  The URL the user is redirected to after the cloud storage provider authenticates the user. Using this will append the redirectUrl to the authenticationUrl.  The redirectUrl is restricted to URLs in the docusign.com or docusign.net domains.  
847        :return: CloudStorageProviders
848                 If the method is called asynchronously,
849                 returns the request thread.
850        """
851
852        all_params = ['account_id', 'user_id', 'redirect_url']
853        all_params.append('callback')
854        all_params.append('_return_http_data_only')
855        all_params.append('_preload_content')
856        all_params.append('_request_timeout')
857
858        params = locals()
859        for key, val in iteritems(params['kwargs']):
860            if key not in all_params:
861                raise TypeError(
862                    "Got an unexpected keyword argument '%s'"
863                    " to method list_providers" % key
864                )
865            params[key] = val
866        del params['kwargs']
867        # verify the required parameter 'account_id' is set
868        if ('account_id' not in params) or (params['account_id'] is None):
869            raise ValueError("Missing the required parameter `account_id` when calling `list_providers`")
870        # verify the required parameter 'user_id' is set
871        if ('user_id' not in params) or (params['user_id'] is None):
872            raise ValueError("Missing the required parameter `user_id` when calling `list_providers`")
873
874
875        collection_formats = {}
876
877        resource_path = '/v2.1/accounts/{accountId}/users/{userId}/cloud_storage'.replace('{format}', 'json')
878        path_params = {}
879        if 'account_id' in params:
880            path_params['accountId'] = params['account_id']
881        if 'user_id' in params:
882            path_params['userId'] = params['user_id']
883
884        query_params = {}
885        if 'redirect_url' in params:
886            query_params['redirectUrl'] = params['redirect_url']
887
888        header_params = {}
889
890        form_params = []
891        local_var_files = {}
892
893        body_params = None
894        # HTTP header `Accept`
895        header_params['Accept'] = self.api_client.\
896            select_header_accept(['application/json'])
897
898        # Authentication setting
899        auth_settings = []
900
901        return self.api_client.call_api(resource_path, 'GET',
902                                        path_params,
903                                        query_params,
904                                        header_params,
905                                        body=body_params,
906                                        post_params=form_params,
907                                        files=local_var_files,
908                                        response_type='CloudStorageProviders',
909                                        auth_settings=auth_settings,
910                                        callback=params.get('callback'),
911                                        _return_http_data_only=params.get('_return_http_data_only'),
912                                        _preload_content=params.get('_preload_content', True),
913                                        _request_timeout=params.get('_request_timeout'),
914                                        collection_formats=collection_formats)