docusign_esign.apis.cloud_storage_api

  1# coding: utf-8
  2
  3"""
  4    Docusign eSignature REST API
  5
  6    The Docusign eSignature 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 sky_drive_skip_token:
534        :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.  
535        :return: ExternalFolder
536                 If the method is called asynchronously,
537                 returns the request thread.
538        """
539        kwargs['_return_http_data_only'] = True
540        if kwargs.get('callback'):
541            return self.list_with_http_info(account_id, folder_id, service_id, user_id, **kwargs)
542        else:
543            (data) = self.list_with_http_info(account_id, folder_id, service_id, user_id, **kwargs)
544            return data
545
546    def list_with_http_info(self, account_id, folder_id, service_id, user_id, **kwargs):
547        """
548        Gets a list of all the items from the specified cloud storage provider.
549        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.
550        This method makes a synchronous HTTP request by default. To make an
551        asynchronous HTTP request, please define a `callback` function
552        to be invoked when receiving the response.
553        >>> def callback_function(response):
554        >>>     pprint(response)
555        >>>
556        >>> thread = api.list_with_http_info(account_id, folder_id, service_id, user_id, callback=callback_function)
557
558        :param callback function: The callback function
559            for asynchronous request. (optional)
560        :param str account_id: The external account number (int) or account ID Guid. (required)
561        :param str folder_id: The ID of the folder being accessed. (required)
562        :param str service_id: The ID of the service to access.   Valid values are the service name (\"Box\") or the numerical serviceId (\"4136\"). (required)
563        :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)
564        :param str cloud_storage_folder_path:
565        :param str cloud_storage_folderid_plain:
566        :param str count: An optional value that sets how many items are included in the response.   The default setting for this is 25. 
567        :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 
568        :param str order_by: An optional value that sets the file attribute used to sort the item list.   Valid values are:   * modified * name  
569        :param str search_text:
570        :param str sky_drive_skip_token:
571        :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.  
572        :return: ExternalFolder
573                 If the method is called asynchronously,
574                 returns the request thread.
575        """
576
577        all_params = ['account_id', 'folder_id', 'service_id', 'user_id', 'cloud_storage_folder_path', 'cloud_storage_folderid_plain', 'count', 'order', 'order_by', 'search_text', 'sky_drive_skip_token', 'start_position']
578        all_params.append('callback')
579        all_params.append('_return_http_data_only')
580        all_params.append('_preload_content')
581        all_params.append('_request_timeout')
582
583        params = locals()
584        for key, val in iteritems(params['kwargs']):
585            if key not in all_params:
586                raise TypeError(
587                    "Got an unexpected keyword argument '%s'"
588                    " to method list" % key
589                )
590            params[key] = val
591        del params['kwargs']
592        # verify the required parameter 'account_id' is set
593        if ('account_id' not in params) or (params['account_id'] is None):
594            raise ValueError("Missing the required parameter `account_id` when calling `list`")
595        # verify the required parameter 'folder_id' is set
596        if ('folder_id' not in params) or (params['folder_id'] is None):
597            raise ValueError("Missing the required parameter `folder_id` when calling `list`")
598        # verify the required parameter 'service_id' is set
599        if ('service_id' not in params) or (params['service_id'] is None):
600            raise ValueError("Missing the required parameter `service_id` when calling `list`")
601        # verify the required parameter 'user_id' is set
602        if ('user_id' not in params) or (params['user_id'] is None):
603            raise ValueError("Missing the required parameter `user_id` when calling `list`")
604
605
606        collection_formats = {}
607
608        resource_path = '/v2.1/accounts/{accountId}/users/{userId}/cloud_storage/{serviceId}/folders/{folderId}'.replace('{format}', 'json')
609        path_params = {}
610        if 'account_id' in params:
611            path_params['accountId'] = params['account_id']
612        if 'folder_id' in params:
613            path_params['folderId'] = params['folder_id']
614        if 'service_id' in params:
615            path_params['serviceId'] = params['service_id']
616        if 'user_id' in params:
617            path_params['userId'] = params['user_id']
618
619        query_params = {}
620        if 'cloud_storage_folder_path' in params:
621            query_params['cloud_storage_folder_path'] = params['cloud_storage_folder_path']
622        if 'cloud_storage_folderid_plain' in params:
623            query_params['cloud_storage_folderid_plain'] = params['cloud_storage_folderid_plain']
624        if 'count' in params:
625            query_params['count'] = params['count']
626        if 'order' in params:
627            query_params['order'] = params['order']
628        if 'order_by' in params:
629            query_params['order_by'] = params['order_by']
630        if 'search_text' in params:
631            query_params['search_text'] = params['search_text']
632        if 'sky_drive_skip_token' in params:
633            query_params['sky_drive_skip_token'] = params['sky_drive_skip_token']
634        if 'start_position' in params:
635            query_params['start_position'] = params['start_position']
636
637        header_params = {}
638
639        form_params = []
640        local_var_files = {}
641
642        body_params = None
643        # HTTP header `Accept`
644        header_params['Accept'] = self.api_client.\
645            select_header_accept(['application/json'])
646
647        # Authentication setting
648        auth_settings = []
649
650        return self.api_client.call_api(resource_path, 'GET',
651                                        path_params,
652                                        query_params,
653                                        header_params,
654                                        body=body_params,
655                                        post_params=form_params,
656                                        files=local_var_files,
657                                        response_type='ExternalFolder',
658                                        auth_settings=auth_settings,
659                                        callback=params.get('callback'),
660                                        _return_http_data_only=params.get('_return_http_data_only'),
661                                        _preload_content=params.get('_preload_content', True),
662                                        _request_timeout=params.get('_request_timeout'),
663                                        collection_formats=collection_formats)
664
665    def list_folders(self, account_id, service_id, user_id, **kwargs):
666        """
667        Retrieves a list of all the items in a specified folder from the specified cloud storage provider.
668        Retrieves a list of all the items in a specified folder from the specified cloud storage provider. 
669        This method makes a synchronous HTTP request by default. To make an
670        asynchronous HTTP request, please define a `callback` function
671        to be invoked when receiving the response.
672        >>> def callback_function(response):
673        >>>     pprint(response)
674        >>>
675        >>> thread = api.list_folders(account_id, service_id, user_id, callback=callback_function)
676
677        :param callback function: The callback function
678            for asynchronous request. (optional)
679        :param str account_id: The external account number (int) or account ID Guid. (required)
680        :param str service_id: The ID of the service to access.   Valid values are the service name (\"Box\") or the numerical serviceId (\"4136\"). (required)
681        :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)
682        :param str cloud_storage_folder_path: A comma separated list of folder IDs included in the request. 
683        :param str count: An optional value that sets how many items are included in the response.   The default setting for this is 25. 
684        :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 
685        :param str order_by: An optional value that sets the file attribute used to sort the item list.   Valid values are:   * modified * name  
686        :param str search_text:
687        :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.  
688        :return: ExternalFolder
689                 If the method is called asynchronously,
690                 returns the request thread.
691        """
692        kwargs['_return_http_data_only'] = True
693        if kwargs.get('callback'):
694            return self.list_folders_with_http_info(account_id, service_id, user_id, **kwargs)
695        else:
696            (data) = self.list_folders_with_http_info(account_id, service_id, user_id, **kwargs)
697            return data
698
699    def list_folders_with_http_info(self, account_id, service_id, user_id, **kwargs):
700        """
701        Retrieves a list of all the items in a specified folder from the specified cloud storage provider.
702        Retrieves a list of all the items in a specified folder from the specified cloud storage provider. 
703        This method makes a synchronous HTTP request by default. To make an
704        asynchronous HTTP request, please define a `callback` function
705        to be invoked when receiving the response.
706        >>> def callback_function(response):
707        >>>     pprint(response)
708        >>>
709        >>> thread = api.list_folders_with_http_info(account_id, service_id, user_id, callback=callback_function)
710
711        :param callback function: The callback function
712            for asynchronous request. (optional)
713        :param str account_id: The external account number (int) or account ID Guid. (required)
714        :param str service_id: The ID of the service to access.   Valid values are the service name (\"Box\") or the numerical serviceId (\"4136\"). (required)
715        :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)
716        :param str cloud_storage_folder_path: A comma separated list of folder IDs included in the request. 
717        :param str count: An optional value that sets how many items are included in the response.   The default setting for this is 25. 
718        :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 
719        :param str order_by: An optional value that sets the file attribute used to sort the item list.   Valid values are:   * modified * name  
720        :param str search_text:
721        :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.  
722        :return: ExternalFolder
723                 If the method is called asynchronously,
724                 returns the request thread.
725        """
726
727        all_params = ['account_id', 'service_id', 'user_id', 'cloud_storage_folder_path', 'count', 'order', 'order_by', 'search_text', 'start_position']
728        all_params.append('callback')
729        all_params.append('_return_http_data_only')
730        all_params.append('_preload_content')
731        all_params.append('_request_timeout')
732
733        params = locals()
734        for key, val in iteritems(params['kwargs']):
735            if key not in all_params:
736                raise TypeError(
737                    "Got an unexpected keyword argument '%s'"
738                    " to method list_folders" % key
739                )
740            params[key] = val
741        del params['kwargs']
742        # verify the required parameter 'account_id' is set
743        if ('account_id' not in params) or (params['account_id'] is None):
744            raise ValueError("Missing the required parameter `account_id` when calling `list_folders`")
745        # verify the required parameter 'service_id' is set
746        if ('service_id' not in params) or (params['service_id'] is None):
747            raise ValueError("Missing the required parameter `service_id` when calling `list_folders`")
748        # verify the required parameter 'user_id' is set
749        if ('user_id' not in params) or (params['user_id'] is None):
750            raise ValueError("Missing the required parameter `user_id` when calling `list_folders`")
751
752
753        collection_formats = {}
754
755        resource_path = '/v2.1/accounts/{accountId}/users/{userId}/cloud_storage/{serviceId}/folders'.replace('{format}', 'json')
756        path_params = {}
757        if 'account_id' in params:
758            path_params['accountId'] = params['account_id']
759        if 'service_id' in params:
760            path_params['serviceId'] = params['service_id']
761        if 'user_id' in params:
762            path_params['userId'] = params['user_id']
763
764        query_params = {}
765        if 'cloud_storage_folder_path' in params:
766            query_params['cloud_storage_folder_path'] = params['cloud_storage_folder_path']
767        if 'count' in params:
768            query_params['count'] = params['count']
769        if 'order' in params:
770            query_params['order'] = params['order']
771        if 'order_by' in params:
772            query_params['order_by'] = params['order_by']
773        if 'search_text' in params:
774            query_params['search_text'] = params['search_text']
775        if 'start_position' in params:
776            query_params['start_position'] = params['start_position']
777
778        header_params = {}
779
780        form_params = []
781        local_var_files = {}
782
783        body_params = None
784        # HTTP header `Accept`
785        header_params['Accept'] = self.api_client.\
786            select_header_accept(['application/json'])
787
788        # Authentication setting
789        auth_settings = []
790
791        return self.api_client.call_api(resource_path, 'GET',
792                                        path_params,
793                                        query_params,
794                                        header_params,
795                                        body=body_params,
796                                        post_params=form_params,
797                                        files=local_var_files,
798                                        response_type='ExternalFolder',
799                                        auth_settings=auth_settings,
800                                        callback=params.get('callback'),
801                                        _return_http_data_only=params.get('_return_http_data_only'),
802                                        _preload_content=params.get('_preload_content', True),
803                                        _request_timeout=params.get('_request_timeout'),
804                                        collection_formats=collection_formats)
805
806    def list_providers(self, account_id, user_id, **kwargs):
807        """
808        Get the Cloud Storage Provider configuration for the specified user.
809        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.
810        This method makes a synchronous HTTP request by default. To make an
811        asynchronous HTTP request, please define a `callback` function
812        to be invoked when receiving the response.
813        >>> def callback_function(response):
814        >>>     pprint(response)
815        >>>
816        >>> thread = api.list_providers(account_id, user_id, callback=callback_function)
817
818        :param callback function: The callback function
819            for asynchronous request. (optional)
820        :param str account_id: The external account number (int) or account ID Guid. (required)
821        :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)
822        :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.  
823        :return: CloudStorageProviders
824                 If the method is called asynchronously,
825                 returns the request thread.
826        """
827        kwargs['_return_http_data_only'] = True
828        if kwargs.get('callback'):
829            return self.list_providers_with_http_info(account_id, user_id, **kwargs)
830        else:
831            (data) = self.list_providers_with_http_info(account_id, user_id, **kwargs)
832            return data
833
834    def list_providers_with_http_info(self, account_id, user_id, **kwargs):
835        """
836        Get the Cloud Storage Provider configuration for the specified user.
837        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.
838        This method makes a synchronous HTTP request by default. To make an
839        asynchronous HTTP request, please define a `callback` function
840        to be invoked when receiving the response.
841        >>> def callback_function(response):
842        >>>     pprint(response)
843        >>>
844        >>> thread = api.list_providers_with_http_info(account_id, user_id, callback=callback_function)
845
846        :param callback function: The callback function
847            for asynchronous request. (optional)
848        :param str account_id: The external account number (int) or account ID Guid. (required)
849        :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)
850        :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.  
851        :return: CloudStorageProviders
852                 If the method is called asynchronously,
853                 returns the request thread.
854        """
855
856        all_params = ['account_id', 'user_id', 'redirect_url']
857        all_params.append('callback')
858        all_params.append('_return_http_data_only')
859        all_params.append('_preload_content')
860        all_params.append('_request_timeout')
861
862        params = locals()
863        for key, val in iteritems(params['kwargs']):
864            if key not in all_params:
865                raise TypeError(
866                    "Got an unexpected keyword argument '%s'"
867                    " to method list_providers" % key
868                )
869            params[key] = val
870        del params['kwargs']
871        # verify the required parameter 'account_id' is set
872        if ('account_id' not in params) or (params['account_id'] is None):
873            raise ValueError("Missing the required parameter `account_id` when calling `list_providers`")
874        # verify the required parameter 'user_id' is set
875        if ('user_id' not in params) or (params['user_id'] is None):
876            raise ValueError("Missing the required parameter `user_id` when calling `list_providers`")
877
878
879        collection_formats = {}
880
881        resource_path = '/v2.1/accounts/{accountId}/users/{userId}/cloud_storage'.replace('{format}', 'json')
882        path_params = {}
883        if 'account_id' in params:
884            path_params['accountId'] = params['account_id']
885        if 'user_id' in params:
886            path_params['userId'] = params['user_id']
887
888        query_params = {}
889        if 'redirect_url' in params:
890            query_params['redirectUrl'] = params['redirect_url']
891
892        header_params = {}
893
894        form_params = []
895        local_var_files = {}
896
897        body_params = None
898        # HTTP header `Accept`
899        header_params['Accept'] = self.api_client.\
900            select_header_accept(['application/json'])
901
902        # Authentication setting
903        auth_settings = []
904
905        return self.api_client.call_api(resource_path, 'GET',
906                                        path_params,
907                                        query_params,
908                                        header_params,
909                                        body=body_params,
910                                        post_params=form_params,
911                                        files=local_var_files,
912                                        response_type='CloudStorageProviders',
913                                        auth_settings=auth_settings,
914                                        callback=params.get('callback'),
915                                        _return_http_data_only=params.get('_return_http_data_only'),
916                                        _preload_content=params.get('_preload_content', True),
917                                        _request_timeout=params.get('_request_timeout'),
918                                        collection_formats=collection_formats)