TeamTeamRoutes.cs

// <auto-generated>
// Auto-generated by StoneAPI, do not modify.
// </auto-generated>

namespace Dropbox.Api.Team.Routes
{
    using sys = System;
    using io = System.IO;
    using col = System.Collections.Generic;
    using t = System.Threading.Tasks;
    using enc = Dropbox.Api.Stone;

    /// <summary>
    /// <para>The routes for the <see cref="N:Dropbox.Api.Team"/> namespace</para>
    /// </summary>
    public class TeamTeamRoutes
    {
        /// <summary>
        /// <para>Initializes a new instance of the <see cref="TeamTeamRoutes" /> class.</para>
        /// </summary>
        /// <param name="transport">The transport to use</param>
        internal TeamTeamRoutes(enc.ITransport transport)
        {
            this.Transport = transport;
        }

        /// <summary>
        /// <para>Gets the transport used for these routes</para>
        /// </summary>
        internal enc.ITransport Transport { get; private set; }

        /// <summary>
        /// <para>List all device sessions of a team's member.</para>
        /// </summary>
        /// <param name="listMemberDevicesArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="ListMemberDevicesError"/>.</exception>
        public t.Task<ListMemberDevicesResult> DevicesListMemberDevicesAsync(ListMemberDevicesArg listMemberDevicesArg)
        {
            return this.Transport.SendRpcRequestAsync<ListMemberDevicesArg, ListMemberDevicesResult, ListMemberDevicesError>(listMemberDevicesArg, "api", "/team/devices/list_member_devices", "team", global::Dropbox.Api.Team.ListMemberDevicesArg.Encoder, global::Dropbox.Api.Team.ListMemberDevicesResult.Decoder, global::Dropbox.Api.Team.ListMemberDevicesError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the devices list member devices route.</para>
        /// </summary>
        /// <param name="listMemberDevicesArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginDevicesListMemberDevices(ListMemberDevicesArg listMemberDevicesArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.DevicesListMemberDevicesAsync(listMemberDevicesArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>List all device sessions of a team's member.</para>
        /// </summary>
        /// <param name="teamMemberId">The team's member id.</param>
        /// <param name="includeWebSessions">Whether to list web sessions of the team's
        /// member.</param>
        /// <param name="includeDesktopClients">Whether to list linked desktop devices of the
        /// team's member.</param>
        /// <param name="includeMobileClients">Whether to list linked mobile devices of the
        /// team's member.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="ListMemberDevicesError"/>.</exception>
        public t.Task<ListMemberDevicesResult> DevicesListMemberDevicesAsync(string teamMemberId,
                                                                             bool includeWebSessions = true,
                                                                             bool includeDesktopClients = true,
                                                                             bool includeMobileClients = true)
        {
            var listMemberDevicesArg = new ListMemberDevicesArg(teamMemberId,
                                                                includeWebSessions,
                                                                includeDesktopClients,
                                                                includeMobileClients);

            return this.DevicesListMemberDevicesAsync(listMemberDevicesArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the devices list member devices route.</para>
        /// </summary>
        /// <param name="teamMemberId">The team's member id.</param>
        /// <param name="includeWebSessions">Whether to list web sessions of the team's
        /// member.</param>
        /// <param name="includeDesktopClients">Whether to list linked desktop devices of the
        /// team's member.</param>
        /// <param name="includeMobileClients">Whether to list linked mobile devices of the
        /// team's member.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginDevicesListMemberDevices(string teamMemberId,
                                                              bool includeWebSessions = true,
                                                              bool includeDesktopClients = true,
                                                              bool includeMobileClients = true,
                                                              sys.AsyncCallback callback = null,
                                                              object callbackState = null)
        {
            var listMemberDevicesArg = new ListMemberDevicesArg(teamMemberId,
                                                                includeWebSessions,
                                                                includeDesktopClients,
                                                                includeMobileClients);

            return this.BeginDevicesListMemberDevices(listMemberDevicesArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the devices list member devices
        /// route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="ListMemberDevicesError"/>.</exception>
        public ListMemberDevicesResult EndDevicesListMemberDevices(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<ListMemberDevicesResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>List all device sessions of a team.</para>
        /// <para>Permission : Team member file access.</para>
        /// </summary>
        /// <param name="listMembersDevicesArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="ListMembersDevicesError"/>.</exception>
        public t.Task<ListMembersDevicesResult> DevicesListMembersDevicesAsync(ListMembersDevicesArg listMembersDevicesArg)
        {
            return this.Transport.SendRpcRequestAsync<ListMembersDevicesArg, ListMembersDevicesResult, ListMembersDevicesError>(listMembersDevicesArg, "api", "/team/devices/list_members_devices", "team", global::Dropbox.Api.Team.ListMembersDevicesArg.Encoder, global::Dropbox.Api.Team.ListMembersDevicesResult.Decoder, global::Dropbox.Api.Team.ListMembersDevicesError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the devices list members devices route.</para>
        /// </summary>
        /// <param name="listMembersDevicesArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginDevicesListMembersDevices(ListMembersDevicesArg listMembersDevicesArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.DevicesListMembersDevicesAsync(listMembersDevicesArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>List all device sessions of a team.</para>
        /// <para>Permission : Team member file access.</para>
        /// </summary>
        /// <param name="cursor">At the first call to the <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.DevicesListMembersDevicesAsync" /> the
        /// cursor shouldn't be passed. Then, if the result of the call includes a cursor, the
        /// following requests should include the received cursors in order to receive the next
        /// sub list of team devices.</param>
        /// <param name="includeWebSessions">Whether to list web sessions of the team
        /// members.</param>
        /// <param name="includeDesktopClients">Whether to list desktop clients of the team
        /// members.</param>
        /// <param name="includeMobileClients">Whether to list mobile clients of the team
        /// members.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="ListMembersDevicesError"/>.</exception>
        public t.Task<ListMembersDevicesResult> DevicesListMembersDevicesAsync(string cursor = null,
                                                                               bool includeWebSessions = true,
                                                                               bool includeDesktopClients = true,
                                                                               bool includeMobileClients = true)
        {
            var listMembersDevicesArg = new ListMembersDevicesArg(cursor,
                                                                  includeWebSessions,
                                                                  includeDesktopClients,
                                                                  includeMobileClients);

            return this.DevicesListMembersDevicesAsync(listMembersDevicesArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the devices list members devices route.</para>
        /// </summary>
        /// <param name="cursor">At the first call to the <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.DevicesListMembersDevicesAsync" /> the
        /// cursor shouldn't be passed. Then, if the result of the call includes a cursor, the
        /// following requests should include the received cursors in order to receive the next
        /// sub list of team devices.</param>
        /// <param name="includeWebSessions">Whether to list web sessions of the team
        /// members.</param>
        /// <param name="includeDesktopClients">Whether to list desktop clients of the team
        /// members.</param>
        /// <param name="includeMobileClients">Whether to list mobile clients of the team
        /// members.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginDevicesListMembersDevices(string cursor = null,
                                                               bool includeWebSessions = true,
                                                               bool includeDesktopClients = true,
                                                               bool includeMobileClients = true,
                                                               sys.AsyncCallback callback = null,
                                                               object callbackState = null)
        {
            var listMembersDevicesArg = new ListMembersDevicesArg(cursor,
                                                                  includeWebSessions,
                                                                  includeDesktopClients,
                                                                  includeMobileClients);

            return this.BeginDevicesListMembersDevices(listMembersDevicesArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the devices list members devices
        /// route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="ListMembersDevicesError"/>.</exception>
        public ListMembersDevicesResult EndDevicesListMembersDevices(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<ListMembersDevicesResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>List all device sessions of a team.</para>
        /// <para>Permission : Team member file access.</para>
        /// </summary>
        /// <param name="listTeamDevicesArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="ListTeamDevicesError"/>.</exception>
        [sys.Obsolete("This function is deprecated, please use DevicesListMembersDevicesAsync instead.")]
        public t.Task<ListTeamDevicesResult> DevicesListTeamDevicesAsync(ListTeamDevicesArg listTeamDevicesArg)
        {
            return this.Transport.SendRpcRequestAsync<ListTeamDevicesArg, ListTeamDevicesResult, ListTeamDevicesError>(listTeamDevicesArg, "api", "/team/devices/list_team_devices", "team", global::Dropbox.Api.Team.ListTeamDevicesArg.Encoder, global::Dropbox.Api.Team.ListTeamDevicesResult.Decoder, global::Dropbox.Api.Team.ListTeamDevicesError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the devices list team devices route.</para>
        /// </summary>
        /// <param name="listTeamDevicesArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        [sys.Obsolete("This function is deprecated, please use BeginDevicesListMembersDevices instead.")]
        public sys.IAsyncResult BeginDevicesListTeamDevices(ListTeamDevicesArg listTeamDevicesArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.DevicesListTeamDevicesAsync(listTeamDevicesArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>List all device sessions of a team.</para>
        /// <para>Permission : Team member file access.</para>
        /// </summary>
        /// <param name="cursor">At the first call to the <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.DevicesListTeamDevicesAsync" /> the
        /// cursor shouldn't be passed. Then, if the result of the call includes a cursor, the
        /// following requests should include the received cursors in order to receive the next
        /// sub list of team devices.</param>
        /// <param name="includeWebSessions">Whether to list web sessions of the team
        /// members.</param>
        /// <param name="includeDesktopClients">Whether to list desktop clients of the team
        /// members.</param>
        /// <param name="includeMobileClients">Whether to list mobile clients of the team
        /// members.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="ListTeamDevicesError"/>.</exception>
        [sys.Obsolete("This function is deprecated, please use DevicesListMembersDevicesAsync instead.")]
        public t.Task<ListTeamDevicesResult> DevicesListTeamDevicesAsync(string cursor = null,
                                                                         bool includeWebSessions = true,
                                                                         bool includeDesktopClients = true,
                                                                         bool includeMobileClients = true)
        {
            var listTeamDevicesArg = new ListTeamDevicesArg(cursor,
                                                            includeWebSessions,
                                                            includeDesktopClients,
                                                            includeMobileClients);

            return this.DevicesListTeamDevicesAsync(listTeamDevicesArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the devices list team devices route.</para>
        /// </summary>
        /// <param name="cursor">At the first call to the <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.DevicesListTeamDevicesAsync" /> the
        /// cursor shouldn't be passed. Then, if the result of the call includes a cursor, the
        /// following requests should include the received cursors in order to receive the next
        /// sub list of team devices.</param>
        /// <param name="includeWebSessions">Whether to list web sessions of the team
        /// members.</param>
        /// <param name="includeDesktopClients">Whether to list desktop clients of the team
        /// members.</param>
        /// <param name="includeMobileClients">Whether to list mobile clients of the team
        /// members.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        [sys.Obsolete("This function is deprecated, please use BeginDevicesListMembersDevices instead.")]
        public sys.IAsyncResult BeginDevicesListTeamDevices(string cursor = null,
                                                            bool includeWebSessions = true,
                                                            bool includeDesktopClients = true,
                                                            bool includeMobileClients = true,
                                                            sys.AsyncCallback callback = null,
                                                            object callbackState = null)
        {
            var listTeamDevicesArg = new ListTeamDevicesArg(cursor,
                                                            includeWebSessions,
                                                            includeDesktopClients,
                                                            includeMobileClients);

            return this.BeginDevicesListTeamDevices(listTeamDevicesArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the devices list team devices
        /// route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="ListTeamDevicesError"/>.</exception>
        [sys.Obsolete("This function is deprecated, please use EndDevicesListMembersDevices instead.")]
        public ListTeamDevicesResult EndDevicesListTeamDevices(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<ListTeamDevicesResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Revoke a device session of a team's member.</para>
        /// </summary>
        /// <param name="revokeDeviceSessionArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="RevokeDeviceSessionError"/>.</exception>
        public t.Task DevicesRevokeDeviceSessionAsync(RevokeDeviceSessionArg revokeDeviceSessionArg)
        {
            return this.Transport.SendRpcRequestAsync<RevokeDeviceSessionArg, enc.Empty, RevokeDeviceSessionError>(revokeDeviceSessionArg, "api", "/team/devices/revoke_device_session", "team", global::Dropbox.Api.Team.RevokeDeviceSessionArg.Encoder, enc.EmptyDecoder.Instance, global::Dropbox.Api.Team.RevokeDeviceSessionError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the devices revoke device session
        /// route.</para>
        /// </summary>
        /// <param name="revokeDeviceSessionArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginDevicesRevokeDeviceSession(RevokeDeviceSessionArg revokeDeviceSessionArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.DevicesRevokeDeviceSessionAsync(revokeDeviceSessionArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the devices revoke device session
        /// route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="RevokeDeviceSessionError"/>.</exception>
        public void EndDevicesRevokeDeviceSession(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }
        }

        /// <summary>
        /// <para>Revoke a list of device sessions of team members.</para>
        /// </summary>
        /// <param name="revokeDeviceSessionBatchArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="RevokeDeviceSessionBatchError"/>.</exception>
        public t.Task<RevokeDeviceSessionBatchResult> DevicesRevokeDeviceSessionBatchAsync(RevokeDeviceSessionBatchArg revokeDeviceSessionBatchArg)
        {
            return this.Transport.SendRpcRequestAsync<RevokeDeviceSessionBatchArg, RevokeDeviceSessionBatchResult, RevokeDeviceSessionBatchError>(revokeDeviceSessionBatchArg, "api", "/team/devices/revoke_device_session_batch", "team", global::Dropbox.Api.Team.RevokeDeviceSessionBatchArg.Encoder, global::Dropbox.Api.Team.RevokeDeviceSessionBatchResult.Decoder, global::Dropbox.Api.Team.RevokeDeviceSessionBatchError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the devices revoke device session batch
        /// route.</para>
        /// </summary>
        /// <param name="revokeDeviceSessionBatchArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginDevicesRevokeDeviceSessionBatch(RevokeDeviceSessionBatchArg revokeDeviceSessionBatchArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.DevicesRevokeDeviceSessionBatchAsync(revokeDeviceSessionBatchArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Revoke a list of device sessions of team members.</para>
        /// </summary>
        /// <param name="revokeDevices">The revoke devices</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="RevokeDeviceSessionBatchError"/>.</exception>
        public t.Task<RevokeDeviceSessionBatchResult> DevicesRevokeDeviceSessionBatchAsync(col.IEnumerable<RevokeDeviceSessionArg> revokeDevices)
        {
            var revokeDeviceSessionBatchArg = new RevokeDeviceSessionBatchArg(revokeDevices);

            return this.DevicesRevokeDeviceSessionBatchAsync(revokeDeviceSessionBatchArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the devices revoke device session batch
        /// route.</para>
        /// </summary>
        /// <param name="revokeDevices">The revoke devices</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginDevicesRevokeDeviceSessionBatch(col.IEnumerable<RevokeDeviceSessionArg> revokeDevices,
                                                                     sys.AsyncCallback callback,
                                                                     object callbackState = null)
        {
            var revokeDeviceSessionBatchArg = new RevokeDeviceSessionBatchArg(revokeDevices);

            return this.BeginDevicesRevokeDeviceSessionBatch(revokeDeviceSessionBatchArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the devices revoke device session
        /// batch route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="RevokeDeviceSessionBatchError"/>.</exception>
        public RevokeDeviceSessionBatchResult EndDevicesRevokeDeviceSessionBatch(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<RevokeDeviceSessionBatchResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Get the values for one or more featues. This route allows you to check your
        /// account's capability for what feature you can access or what value you have for
        /// certain features.</para>
        /// <para>Permission : Team information.</para>
        /// </summary>
        /// <param name="featuresGetValuesBatchArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="FeaturesGetValuesBatchError"/>.</exception>
        public t.Task<FeaturesGetValuesBatchResult> FeaturesGetValuesAsync(FeaturesGetValuesBatchArg featuresGetValuesBatchArg)
        {
            return this.Transport.SendRpcRequestAsync<FeaturesGetValuesBatchArg, FeaturesGetValuesBatchResult, FeaturesGetValuesBatchError>(featuresGetValuesBatchArg, "api", "/team/features/get_values", "team", global::Dropbox.Api.Team.FeaturesGetValuesBatchArg.Encoder, global::Dropbox.Api.Team.FeaturesGetValuesBatchResult.Decoder, global::Dropbox.Api.Team.FeaturesGetValuesBatchError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the features get values route.</para>
        /// </summary>
        /// <param name="featuresGetValuesBatchArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginFeaturesGetValues(FeaturesGetValuesBatchArg featuresGetValuesBatchArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.FeaturesGetValuesAsync(featuresGetValuesBatchArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Get the values for one or more featues. This route allows you to check your
        /// account's capability for what feature you can access or what value you have for
        /// certain features.</para>
        /// <para>Permission : Team information.</para>
        /// </summary>
        /// <param name="features">A list of features in <see cref="Feature" />. If the list is
        /// empty, this route will return <see cref="FeaturesGetValuesBatchError" />.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="FeaturesGetValuesBatchError"/>.</exception>
        public t.Task<FeaturesGetValuesBatchResult> FeaturesGetValuesAsync(col.IEnumerable<Feature> features)
        {
            var featuresGetValuesBatchArg = new FeaturesGetValuesBatchArg(features);

            return this.FeaturesGetValuesAsync(featuresGetValuesBatchArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the features get values route.</para>
        /// </summary>
        /// <param name="features">A list of features in <see cref="Feature" />. If the list is
        /// empty, this route will return <see cref="FeaturesGetValuesBatchError" />.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginFeaturesGetValues(col.IEnumerable<Feature> features,
                                                       sys.AsyncCallback callback,
                                                       object callbackState = null)
        {
            var featuresGetValuesBatchArg = new FeaturesGetValuesBatchArg(features);

            return this.BeginFeaturesGetValues(featuresGetValuesBatchArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the features get values route to
        /// complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="FeaturesGetValuesBatchError"/>.</exception>
        public FeaturesGetValuesBatchResult EndFeaturesGetValues(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<FeaturesGetValuesBatchResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Retrieves information about a team.</para>
        /// </summary>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        public t.Task<TeamGetInfoResult> GetInfoAsync()
        {
            return this.Transport.SendRpcRequestAsync<enc.Empty, TeamGetInfoResult, enc.Empty>(enc.Empty.Instance, "api", "/team/get_info", "team", enc.EmptyEncoder.Instance, global::Dropbox.Api.Team.TeamGetInfoResult.Decoder, enc.EmptyDecoder.Instance);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the get info route.</para>
        /// </summary>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginGetInfo(sys.AsyncCallback callback, object state = null)
        {
            var task = this.GetInfoAsync();

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the get info route to
        /// complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        public TeamGetInfoResult EndGetInfo(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<TeamGetInfoResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Creates a new, empty group, with a requested name.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <param name="groupCreateArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="GroupCreateError"/>.</exception>
        public t.Task<GroupFullInfo> GroupsCreateAsync(GroupCreateArg groupCreateArg)
        {
            return this.Transport.SendRpcRequestAsync<GroupCreateArg, GroupFullInfo, GroupCreateError>(groupCreateArg, "api", "/team/groups/create", "team", global::Dropbox.Api.Team.GroupCreateArg.Encoder, global::Dropbox.Api.Team.GroupFullInfo.Decoder, global::Dropbox.Api.Team.GroupCreateError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the groups create route.</para>
        /// </summary>
        /// <param name="groupCreateArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginGroupsCreate(GroupCreateArg groupCreateArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.GroupsCreateAsync(groupCreateArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Creates a new, empty group, with a requested name.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <param name="groupName">Group name.</param>
        /// <param name="addCreatorAsOwner">Automatically add the creator of the group.</param>
        /// <param name="groupExternalId">The creator of a team can associate an arbitrary
        /// external ID to the group.</param>
        /// <param name="groupManagementType">Whether the team can be managed by selected
        /// users, or only by team admins.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="GroupCreateError"/>.</exception>
        public t.Task<GroupFullInfo> GroupsCreateAsync(string groupName,
                                                       bool addCreatorAsOwner = false,
                                                       string groupExternalId = null,
                                                       global::Dropbox.Api.TeamCommon.GroupManagementType groupManagementType = null)
        {
            var groupCreateArg = new GroupCreateArg(groupName,
                                                    addCreatorAsOwner,
                                                    groupExternalId,
                                                    groupManagementType);

            return this.GroupsCreateAsync(groupCreateArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the groups create route.</para>
        /// </summary>
        /// <param name="groupName">Group name.</param>
        /// <param name="addCreatorAsOwner">Automatically add the creator of the group.</param>
        /// <param name="groupExternalId">The creator of a team can associate an arbitrary
        /// external ID to the group.</param>
        /// <param name="groupManagementType">Whether the team can be managed by selected
        /// users, or only by team admins.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginGroupsCreate(string groupName,
                                                  bool addCreatorAsOwner = false,
                                                  string groupExternalId = null,
                                                  global::Dropbox.Api.TeamCommon.GroupManagementType groupManagementType = null,
                                                  sys.AsyncCallback callback = null,
                                                  object callbackState = null)
        {
            var groupCreateArg = new GroupCreateArg(groupName,
                                                    addCreatorAsOwner,
                                                    groupExternalId,
                                                    groupManagementType);

            return this.BeginGroupsCreate(groupCreateArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the groups create route to
        /// complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="GroupCreateError"/>.</exception>
        public GroupFullInfo EndGroupsCreate(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<GroupFullInfo>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Deletes a group.</para>
        /// <para>The group is deleted immediately. However the revoking of group-owned
        /// resources may take additional time. Use the <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.GroupsJobStatusGetAsync" /> to
        /// determine whether this process has completed.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <param name="groupSelector">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="GroupDeleteError"/>.</exception>
        public t.Task<global::Dropbox.Api.Async.LaunchEmptyResult> GroupsDeleteAsync(GroupSelector groupSelector)
        {
            return this.Transport.SendRpcRequestAsync<GroupSelector, global::Dropbox.Api.Async.LaunchEmptyResult, GroupDeleteError>(groupSelector, "api", "/team/groups/delete", "team", global::Dropbox.Api.Team.GroupSelector.Encoder, global::Dropbox.Api.Async.LaunchEmptyResult.Decoder, global::Dropbox.Api.Team.GroupDeleteError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the groups delete route.</para>
        /// </summary>
        /// <param name="groupSelector">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginGroupsDelete(GroupSelector groupSelector, sys.AsyncCallback callback, object state = null)
        {
            var task = this.GroupsDeleteAsync(groupSelector);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the groups delete route to
        /// complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="GroupDeleteError"/>.</exception>
        public global::Dropbox.Api.Async.LaunchEmptyResult EndGroupsDelete(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<global::Dropbox.Api.Async.LaunchEmptyResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Retrieves information about one or more groups. Note that the optional field
        /// <see cref="Dropbox.Api.Team.GroupFullInfo.Members" /> is not returned for
        /// system-managed groups.</para>
        /// <para>Permission : Team Information.</para>
        /// </summary>
        /// <param name="groupsSelector">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="GroupsGetInfoError"/>.</exception>
        public t.Task<col.List<GroupsGetInfoItem>> GroupsGetInfoAsync(GroupsSelector groupsSelector)
        {
            return this.Transport.SendRpcRequestAsync<GroupsSelector, col.List<GroupsGetInfoItem>, GroupsGetInfoError>(groupsSelector, "api", "/team/groups/get_info", "team", global::Dropbox.Api.Team.GroupsSelector.Encoder, enc.Decoder.CreateListDecoder(global::Dropbox.Api.Team.GroupsGetInfoItem.Decoder), global::Dropbox.Api.Team.GroupsGetInfoError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the groups get info route.</para>
        /// </summary>
        /// <param name="groupsSelector">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginGroupsGetInfo(GroupsSelector groupsSelector, sys.AsyncCallback callback, object state = null)
        {
            var task = this.GroupsGetInfoAsync(groupsSelector);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the groups get info route to
        /// complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="GroupsGetInfoError"/>.</exception>
        public col.List<GroupsGetInfoItem> EndGroupsGetInfo(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<col.List<GroupsGetInfoItem>>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Once an async_job_id is returned from <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.GroupsDeleteAsync" />, <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.GroupsMembersAddAsync" /> , or <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.GroupsMembersRemoveAsync" /> use this
        /// method to poll the status of granting/revoking group members' access to group-owned
        /// resources.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <param name="pollArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="GroupsPollError"/>.</exception>
        public t.Task<global::Dropbox.Api.Async.PollEmptyResult> GroupsJobStatusGetAsync(global::Dropbox.Api.Async.PollArg pollArg)
        {
            return this.Transport.SendRpcRequestAsync<global::Dropbox.Api.Async.PollArg, global::Dropbox.Api.Async.PollEmptyResult, GroupsPollError>(pollArg, "api", "/team/groups/job_status/get", "team", global::Dropbox.Api.Async.PollArg.Encoder, global::Dropbox.Api.Async.PollEmptyResult.Decoder, global::Dropbox.Api.Team.GroupsPollError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the groups job status get route.</para>
        /// </summary>
        /// <param name="pollArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginGroupsJobStatusGet(global::Dropbox.Api.Async.PollArg pollArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.GroupsJobStatusGetAsync(pollArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Once an async_job_id is returned from <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.GroupsDeleteAsync" />, <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.GroupsMembersAddAsync" /> , or <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.GroupsMembersRemoveAsync" /> use this
        /// method to poll the status of granting/revoking group members' access to group-owned
        /// resources.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <param name="asyncJobId">Id of the asynchronous job. This is the value of a
        /// response returned from the method that launched the job.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="GroupsPollError"/>.</exception>
        public t.Task<global::Dropbox.Api.Async.PollEmptyResult> GroupsJobStatusGetAsync(string asyncJobId)
        {
            var pollArg = new global::Dropbox.Api.Async.PollArg(asyncJobId);

            return this.GroupsJobStatusGetAsync(pollArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the groups job status get route.</para>
        /// </summary>
        /// <param name="asyncJobId">Id of the asynchronous job. This is the value of a
        /// response returned from the method that launched the job.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginGroupsJobStatusGet(string asyncJobId,
                                                        sys.AsyncCallback callback,
                                                        object callbackState = null)
        {
            var pollArg = new global::Dropbox.Api.Async.PollArg(asyncJobId);

            return this.BeginGroupsJobStatusGet(pollArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the groups job status get route to
        /// complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="GroupsPollError"/>.</exception>
        public global::Dropbox.Api.Async.PollEmptyResult EndGroupsJobStatusGet(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<global::Dropbox.Api.Async.PollEmptyResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Lists groups on a team.</para>
        /// <para>Permission : Team Information.</para>
        /// </summary>
        /// <param name="groupsListArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        public t.Task<GroupsListResult> GroupsListAsync(GroupsListArg groupsListArg)
        {
            return this.Transport.SendRpcRequestAsync<GroupsListArg, GroupsListResult, enc.Empty>(groupsListArg, "api", "/team/groups/list", "team", global::Dropbox.Api.Team.GroupsListArg.Encoder, global::Dropbox.Api.Team.GroupsListResult.Decoder, enc.EmptyDecoder.Instance);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the groups list route.</para>
        /// </summary>
        /// <param name="groupsListArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginGroupsList(GroupsListArg groupsListArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.GroupsListAsync(groupsListArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Lists groups on a team.</para>
        /// <para>Permission : Team Information.</para>
        /// </summary>
        /// <param name="limit">Number of results to return per call.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        public t.Task<GroupsListResult> GroupsListAsync(uint limit = 1000)
        {
            var groupsListArg = new GroupsListArg(limit);

            return this.GroupsListAsync(groupsListArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the groups list route.</para>
        /// </summary>
        /// <param name="limit">Number of results to return per call.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginGroupsList(uint limit = 1000,
                                                sys.AsyncCallback callback = null,
                                                object callbackState = null)
        {
            var groupsListArg = new GroupsListArg(limit);

            return this.BeginGroupsList(groupsListArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the groups list route to
        /// complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        public GroupsListResult EndGroupsList(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<GroupsListResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Once a cursor has been retrieved from <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.GroupsListAsync" />, use this to
        /// paginate through all groups.</para>
        /// <para>Permission : Team Information.</para>
        /// </summary>
        /// <param name="groupsListContinueArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="GroupsListContinueError"/>.</exception>
        public t.Task<GroupsListResult> GroupsListContinueAsync(GroupsListContinueArg groupsListContinueArg)
        {
            return this.Transport.SendRpcRequestAsync<GroupsListContinueArg, GroupsListResult, GroupsListContinueError>(groupsListContinueArg, "api", "/team/groups/list/continue", "team", global::Dropbox.Api.Team.GroupsListContinueArg.Encoder, global::Dropbox.Api.Team.GroupsListResult.Decoder, global::Dropbox.Api.Team.GroupsListContinueError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the groups list continue route.</para>
        /// </summary>
        /// <param name="groupsListContinueArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginGroupsListContinue(GroupsListContinueArg groupsListContinueArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.GroupsListContinueAsync(groupsListContinueArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Once a cursor has been retrieved from <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.GroupsListAsync" />, use this to
        /// paginate through all groups.</para>
        /// <para>Permission : Team Information.</para>
        /// </summary>
        /// <param name="cursor">Indicates from what point to get the next set of
        /// groups.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="GroupsListContinueError"/>.</exception>
        public t.Task<GroupsListResult> GroupsListContinueAsync(string cursor)
        {
            var groupsListContinueArg = new GroupsListContinueArg(cursor);

            return this.GroupsListContinueAsync(groupsListContinueArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the groups list continue route.</para>
        /// </summary>
        /// <param name="cursor">Indicates from what point to get the next set of
        /// groups.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginGroupsListContinue(string cursor,
                                                        sys.AsyncCallback callback,
                                                        object callbackState = null)
        {
            var groupsListContinueArg = new GroupsListContinueArg(cursor);

            return this.BeginGroupsListContinue(groupsListContinueArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the groups list continue route to
        /// complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="GroupsListContinueError"/>.</exception>
        public GroupsListResult EndGroupsListContinue(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<GroupsListResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Adds members to a group.</para>
        /// <para>The members are added immediately. However the granting of group-owned
        /// resources may take additional time. Use the <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.GroupsJobStatusGetAsync" /> to
        /// determine whether this process has completed.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <param name="groupMembersAddArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="GroupMembersAddError"/>.</exception>
        public t.Task<GroupMembersChangeResult> GroupsMembersAddAsync(GroupMembersAddArg groupMembersAddArg)
        {
            return this.Transport.SendRpcRequestAsync<GroupMembersAddArg, GroupMembersChangeResult, GroupMembersAddError>(groupMembersAddArg, "api", "/team/groups/members/add", "team", global::Dropbox.Api.Team.GroupMembersAddArg.Encoder, global::Dropbox.Api.Team.GroupMembersChangeResult.Decoder, global::Dropbox.Api.Team.GroupMembersAddError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the groups members add route.</para>
        /// </summary>
        /// <param name="groupMembersAddArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginGroupsMembersAdd(GroupMembersAddArg groupMembersAddArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.GroupsMembersAddAsync(groupMembersAddArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Adds members to a group.</para>
        /// <para>The members are added immediately. However the granting of group-owned
        /// resources may take additional time. Use the <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.GroupsJobStatusGetAsync" /> to
        /// determine whether this process has completed.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <param name="group">Group to which users will be added.</param>
        /// <param name="members">List of users to be added to the group.</param>
        /// <param name="returnMembers">Whether to return the list of members in the group.
        /// Note that the default value will cause all the group members  to be returned in the
        /// response. This may take a long time for large groups.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="GroupMembersAddError"/>.</exception>
        public t.Task<GroupMembersChangeResult> GroupsMembersAddAsync(GroupSelector @group,
                                                                      col.IEnumerable<MemberAccess> members,
                                                                      bool returnMembers = true)
        {
            var groupMembersAddArg = new GroupMembersAddArg(@group,
                                                            members,
                                                            returnMembers);

            return this.GroupsMembersAddAsync(groupMembersAddArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the groups members add route.</para>
        /// </summary>
        /// <param name="group">Group to which users will be added.</param>
        /// <param name="members">List of users to be added to the group.</param>
        /// <param name="returnMembers">Whether to return the list of members in the group.
        /// Note that the default value will cause all the group members  to be returned in the
        /// response. This may take a long time for large groups.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginGroupsMembersAdd(GroupSelector @group,
                                                      col.IEnumerable<MemberAccess> members,
                                                      bool returnMembers = true,
                                                      sys.AsyncCallback callback = null,
                                                      object callbackState = null)
        {
            var groupMembersAddArg = new GroupMembersAddArg(@group,
                                                            members,
                                                            returnMembers);

            return this.BeginGroupsMembersAdd(groupMembersAddArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the groups members add route to
        /// complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="GroupMembersAddError"/>.</exception>
        public GroupMembersChangeResult EndGroupsMembersAdd(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<GroupMembersChangeResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Lists members of a group.</para>
        /// <para>Permission : Team Information.</para>
        /// </summary>
        /// <param name="groupsMembersListArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="GroupSelectorError"/>.</exception>
        public t.Task<GroupsMembersListResult> GroupsMembersListAsync(GroupsMembersListArg groupsMembersListArg)
        {
            return this.Transport.SendRpcRequestAsync<GroupsMembersListArg, GroupsMembersListResult, GroupSelectorError>(groupsMembersListArg, "api", "/team/groups/members/list", "team", global::Dropbox.Api.Team.GroupsMembersListArg.Encoder, global::Dropbox.Api.Team.GroupsMembersListResult.Decoder, global::Dropbox.Api.Team.GroupSelectorError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the groups members list route.</para>
        /// </summary>
        /// <param name="groupsMembersListArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginGroupsMembersList(GroupsMembersListArg groupsMembersListArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.GroupsMembersListAsync(groupsMembersListArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Lists members of a group.</para>
        /// <para>Permission : Team Information.</para>
        /// </summary>
        /// <param name="group">The group whose members are to be listed.</param>
        /// <param name="limit">Number of results to return per call.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="GroupSelectorError"/>.</exception>
        public t.Task<GroupsMembersListResult> GroupsMembersListAsync(GroupSelector @group,
                                                                      uint limit = 1000)
        {
            var groupsMembersListArg = new GroupsMembersListArg(@group,
                                                                limit);

            return this.GroupsMembersListAsync(groupsMembersListArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the groups members list route.</para>
        /// </summary>
        /// <param name="group">The group whose members are to be listed.</param>
        /// <param name="limit">Number of results to return per call.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginGroupsMembersList(GroupSelector @group,
                                                       uint limit = 1000,
                                                       sys.AsyncCallback callback = null,
                                                       object callbackState = null)
        {
            var groupsMembersListArg = new GroupsMembersListArg(@group,
                                                                limit);

            return this.BeginGroupsMembersList(groupsMembersListArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the groups members list route to
        /// complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="GroupSelectorError"/>.</exception>
        public GroupsMembersListResult EndGroupsMembersList(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<GroupsMembersListResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Once a cursor has been retrieved from <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.GroupsMembersListAsync" />, use this
        /// to paginate through all members of the group.</para>
        /// <para>Permission : Team information.</para>
        /// </summary>
        /// <param name="groupsMembersListContinueArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="GroupsMembersListContinueError"/>.</exception>
        public t.Task<GroupsMembersListResult> GroupsMembersListContinueAsync(GroupsMembersListContinueArg groupsMembersListContinueArg)
        {
            return this.Transport.SendRpcRequestAsync<GroupsMembersListContinueArg, GroupsMembersListResult, GroupsMembersListContinueError>(groupsMembersListContinueArg, "api", "/team/groups/members/list/continue", "team", global::Dropbox.Api.Team.GroupsMembersListContinueArg.Encoder, global::Dropbox.Api.Team.GroupsMembersListResult.Decoder, global::Dropbox.Api.Team.GroupsMembersListContinueError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the groups members list continue route.</para>
        /// </summary>
        /// <param name="groupsMembersListContinueArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginGroupsMembersListContinue(GroupsMembersListContinueArg groupsMembersListContinueArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.GroupsMembersListContinueAsync(groupsMembersListContinueArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Once a cursor has been retrieved from <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.GroupsMembersListAsync" />, use this
        /// to paginate through all members of the group.</para>
        /// <para>Permission : Team information.</para>
        /// </summary>
        /// <param name="cursor">Indicates from what point to get the next set of
        /// groups.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="GroupsMembersListContinueError"/>.</exception>
        public t.Task<GroupsMembersListResult> GroupsMembersListContinueAsync(string cursor)
        {
            var groupsMembersListContinueArg = new GroupsMembersListContinueArg(cursor);

            return this.GroupsMembersListContinueAsync(groupsMembersListContinueArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the groups members list continue route.</para>
        /// </summary>
        /// <param name="cursor">Indicates from what point to get the next set of
        /// groups.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginGroupsMembersListContinue(string cursor,
                                                               sys.AsyncCallback callback,
                                                               object callbackState = null)
        {
            var groupsMembersListContinueArg = new GroupsMembersListContinueArg(cursor);

            return this.BeginGroupsMembersListContinue(groupsMembersListContinueArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the groups members list continue
        /// route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="GroupsMembersListContinueError"/>.</exception>
        public GroupsMembersListResult EndGroupsMembersListContinue(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<GroupsMembersListResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Removes members from a group.</para>
        /// <para>The members are removed immediately. However the revoking of group-owned
        /// resources may take additional time. Use the <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.GroupsJobStatusGetAsync" /> to
        /// determine whether this process has completed.</para>
        /// <para>This method permits removing the only owner of a group, even in cases where
        /// this is not possible via the web client.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <param name="groupMembersRemoveArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="GroupMembersRemoveError"/>.</exception>
        public t.Task<GroupMembersChangeResult> GroupsMembersRemoveAsync(GroupMembersRemoveArg groupMembersRemoveArg)
        {
            return this.Transport.SendRpcRequestAsync<GroupMembersRemoveArg, GroupMembersChangeResult, GroupMembersRemoveError>(groupMembersRemoveArg, "api", "/team/groups/members/remove", "team", global::Dropbox.Api.Team.GroupMembersRemoveArg.Encoder, global::Dropbox.Api.Team.GroupMembersChangeResult.Decoder, global::Dropbox.Api.Team.GroupMembersRemoveError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the groups members remove route.</para>
        /// </summary>
        /// <param name="groupMembersRemoveArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginGroupsMembersRemove(GroupMembersRemoveArg groupMembersRemoveArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.GroupsMembersRemoveAsync(groupMembersRemoveArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Removes members from a group.</para>
        /// <para>The members are removed immediately. However the revoking of group-owned
        /// resources may take additional time. Use the <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.GroupsJobStatusGetAsync" /> to
        /// determine whether this process has completed.</para>
        /// <para>This method permits removing the only owner of a group, even in cases where
        /// this is not possible via the web client.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <param name="group">Group from which users will be removed.</param>
        /// <param name="users">List of users to be removed from the group.</param>
        /// <param name="returnMembers">Whether to return the list of members in the group.
        /// Note that the default value will cause all the group members  to be returned in the
        /// response. This may take a long time for large groups.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="GroupMembersRemoveError"/>.</exception>
        public t.Task<GroupMembersChangeResult> GroupsMembersRemoveAsync(GroupSelector @group,
                                                                         col.IEnumerable<UserSelectorArg> users,
                                                                         bool returnMembers = true)
        {
            var groupMembersRemoveArg = new GroupMembersRemoveArg(@group,
                                                                  users,
                                                                  returnMembers);

            return this.GroupsMembersRemoveAsync(groupMembersRemoveArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the groups members remove route.</para>
        /// </summary>
        /// <param name="group">Group from which users will be removed.</param>
        /// <param name="users">List of users to be removed from the group.</param>
        /// <param name="returnMembers">Whether to return the list of members in the group.
        /// Note that the default value will cause all the group members  to be returned in the
        /// response. This may take a long time for large groups.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginGroupsMembersRemove(GroupSelector @group,
                                                         col.IEnumerable<UserSelectorArg> users,
                                                         bool returnMembers = true,
                                                         sys.AsyncCallback callback = null,
                                                         object callbackState = null)
        {
            var groupMembersRemoveArg = new GroupMembersRemoveArg(@group,
                                                                  users,
                                                                  returnMembers);

            return this.BeginGroupsMembersRemove(groupMembersRemoveArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the groups members remove route to
        /// complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="GroupMembersRemoveError"/>.</exception>
        public GroupMembersChangeResult EndGroupsMembersRemove(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<GroupMembersChangeResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Sets a member's access type in a group.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <param name="groupMembersSetAccessTypeArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="GroupMemberSetAccessTypeError"/>.</exception>
        public t.Task<col.List<GroupsGetInfoItem>> GroupsMembersSetAccessTypeAsync(GroupMembersSetAccessTypeArg groupMembersSetAccessTypeArg)
        {
            return this.Transport.SendRpcRequestAsync<GroupMembersSetAccessTypeArg, col.List<GroupsGetInfoItem>, GroupMemberSetAccessTypeError>(groupMembersSetAccessTypeArg, "api", "/team/groups/members/set_access_type", "team", global::Dropbox.Api.Team.GroupMembersSetAccessTypeArg.Encoder, enc.Decoder.CreateListDecoder(global::Dropbox.Api.Team.GroupsGetInfoItem.Decoder), global::Dropbox.Api.Team.GroupMemberSetAccessTypeError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the groups members set access type
        /// route.</para>
        /// </summary>
        /// <param name="groupMembersSetAccessTypeArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginGroupsMembersSetAccessType(GroupMembersSetAccessTypeArg groupMembersSetAccessTypeArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.GroupsMembersSetAccessTypeAsync(groupMembersSetAccessTypeArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Sets a member's access type in a group.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <param name="group">Specify a group.</param>
        /// <param name="user">Identity of a user that is a member of <paramref name="group"
        /// />.</param>
        /// <param name="accessType">New group access type the user will have.</param>
        /// <param name="returnMembers">Whether to return the list of members in the group.
        /// Note that the default value will cause all the group members  to be returned in the
        /// response. This may take a long time for large groups.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="GroupMemberSetAccessTypeError"/>.</exception>
        public t.Task<col.List<GroupsGetInfoItem>> GroupsMembersSetAccessTypeAsync(GroupSelector @group,
                                                                                   UserSelectorArg user,
                                                                                   GroupAccessType accessType,
                                                                                   bool returnMembers = true)
        {
            var groupMembersSetAccessTypeArg = new GroupMembersSetAccessTypeArg(@group,
                                                                                user,
                                                                                accessType,
                                                                                returnMembers);

            return this.GroupsMembersSetAccessTypeAsync(groupMembersSetAccessTypeArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the groups members set access type
        /// route.</para>
        /// </summary>
        /// <param name="group">Specify a group.</param>
        /// <param name="user">Identity of a user that is a member of <paramref name="group"
        /// />.</param>
        /// <param name="accessType">New group access type the user will have.</param>
        /// <param name="returnMembers">Whether to return the list of members in the group.
        /// Note that the default value will cause all the group members  to be returned in the
        /// response. This may take a long time for large groups.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginGroupsMembersSetAccessType(GroupSelector @group,
                                                                UserSelectorArg user,
                                                                GroupAccessType accessType,
                                                                bool returnMembers = true,
                                                                sys.AsyncCallback callback = null,
                                                                object callbackState = null)
        {
            var groupMembersSetAccessTypeArg = new GroupMembersSetAccessTypeArg(@group,
                                                                                user,
                                                                                accessType,
                                                                                returnMembers);

            return this.BeginGroupsMembersSetAccessType(groupMembersSetAccessTypeArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the groups members set access type
        /// route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="GroupMemberSetAccessTypeError"/>.</exception>
        public col.List<GroupsGetInfoItem> EndGroupsMembersSetAccessType(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<col.List<GroupsGetInfoItem>>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Updates a group's name and/or external ID.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <param name="groupUpdateArgs">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="GroupUpdateError"/>.</exception>
        public t.Task<GroupFullInfo> GroupsUpdateAsync(GroupUpdateArgs groupUpdateArgs)
        {
            return this.Transport.SendRpcRequestAsync<GroupUpdateArgs, GroupFullInfo, GroupUpdateError>(groupUpdateArgs, "api", "/team/groups/update", "team", global::Dropbox.Api.Team.GroupUpdateArgs.Encoder, global::Dropbox.Api.Team.GroupFullInfo.Decoder, global::Dropbox.Api.Team.GroupUpdateError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the groups update route.</para>
        /// </summary>
        /// <param name="groupUpdateArgs">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginGroupsUpdate(GroupUpdateArgs groupUpdateArgs, sys.AsyncCallback callback, object state = null)
        {
            var task = this.GroupsUpdateAsync(groupUpdateArgs);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Updates a group's name and/or external ID.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <param name="group">Specify a group.</param>
        /// <param name="returnMembers">Whether to return the list of members in the group.
        /// Note that the default value will cause all the group members  to be returned in the
        /// response. This may take a long time for large groups.</param>
        /// <param name="newGroupName">Optional argument. Set group name to this if
        /// provided.</param>
        /// <param name="newGroupExternalId">Optional argument. New group external ID. If the
        /// argument is None, the group's external_id won't be updated. If the argument is
        /// empty string, the group's external id will be cleared.</param>
        /// <param name="newGroupManagementType">Set new group management type, if
        /// provided.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="GroupUpdateError"/>.</exception>
        public t.Task<GroupFullInfo> GroupsUpdateAsync(GroupSelector @group,
                                                       bool returnMembers = true,
                                                       string newGroupName = null,
                                                       string newGroupExternalId = null,
                                                       global::Dropbox.Api.TeamCommon.GroupManagementType newGroupManagementType = null)
        {
            var groupUpdateArgs = new GroupUpdateArgs(@group,
                                                      returnMembers,
                                                      newGroupName,
                                                      newGroupExternalId,
                                                      newGroupManagementType);

            return this.GroupsUpdateAsync(groupUpdateArgs);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the groups update route.</para>
        /// </summary>
        /// <param name="group">Specify a group.</param>
        /// <param name="returnMembers">Whether to return the list of members in the group.
        /// Note that the default value will cause all the group members  to be returned in the
        /// response. This may take a long time for large groups.</param>
        /// <param name="newGroupName">Optional argument. Set group name to this if
        /// provided.</param>
        /// <param name="newGroupExternalId">Optional argument. New group external ID. If the
        /// argument is None, the group's external_id won't be updated. If the argument is
        /// empty string, the group's external id will be cleared.</param>
        /// <param name="newGroupManagementType">Set new group management type, if
        /// provided.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginGroupsUpdate(GroupSelector @group,
                                                  bool returnMembers = true,
                                                  string newGroupName = null,
                                                  string newGroupExternalId = null,
                                                  global::Dropbox.Api.TeamCommon.GroupManagementType newGroupManagementType = null,
                                                  sys.AsyncCallback callback = null,
                                                  object callbackState = null)
        {
            var groupUpdateArgs = new GroupUpdateArgs(@group,
                                                      returnMembers,
                                                      newGroupName,
                                                      newGroupExternalId,
                                                      newGroupManagementType);

            return this.BeginGroupsUpdate(groupUpdateArgs, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the groups update route to
        /// complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="GroupUpdateError"/>.</exception>
        public GroupFullInfo EndGroupsUpdate(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<GroupFullInfo>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Creates new legal hold policy. Note: Legal Holds is a paid add-on. Not all
        /// teams have the feature.</para>
        /// <para>Permission : Team member file access.</para>
        /// </summary>
        /// <param name="legalHoldsPolicyCreateArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="LegalHoldsPolicyCreateError"/>.</exception>
        public t.Task<LegalHoldPolicy> LegalHoldsCreatePolicyAsync(LegalHoldsPolicyCreateArg legalHoldsPolicyCreateArg)
        {
            return this.Transport.SendRpcRequestAsync<LegalHoldsPolicyCreateArg, LegalHoldPolicy, LegalHoldsPolicyCreateError>(legalHoldsPolicyCreateArg, "api", "/team/legal_holds/create_policy", "team", global::Dropbox.Api.Team.LegalHoldsPolicyCreateArg.Encoder, global::Dropbox.Api.Team.LegalHoldPolicy.Decoder, global::Dropbox.Api.Team.LegalHoldsPolicyCreateError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the legal holds create policy route.</para>
        /// </summary>
        /// <param name="legalHoldsPolicyCreateArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginLegalHoldsCreatePolicy(LegalHoldsPolicyCreateArg legalHoldsPolicyCreateArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.LegalHoldsCreatePolicyAsync(legalHoldsPolicyCreateArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Creates new legal hold policy. Note: Legal Holds is a paid add-on. Not all
        /// teams have the feature.</para>
        /// <para>Permission : Team member file access.</para>
        /// </summary>
        /// <param name="name">Policy name.</param>
        /// <param name="members">List of team member IDs added to the hold.</param>
        /// <param name="description">A description of the legal hold policy.</param>
        /// <param name="startDate">start date of the legal hold policy.</param>
        /// <param name="endDate">end date of the legal hold policy.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="LegalHoldsPolicyCreateError"/>.</exception>
        public t.Task<LegalHoldPolicy> LegalHoldsCreatePolicyAsync(string name,
                                                                   col.IEnumerable<string> members,
                                                                   string description = null,
                                                                   sys.DateTime? startDate = null,
                                                                   sys.DateTime? endDate = null)
        {
            var legalHoldsPolicyCreateArg = new LegalHoldsPolicyCreateArg(name,
                                                                          members,
                                                                          description,
                                                                          startDate,
                                                                          endDate);

            return this.LegalHoldsCreatePolicyAsync(legalHoldsPolicyCreateArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the legal holds create policy route.</para>
        /// </summary>
        /// <param name="name">Policy name.</param>
        /// <param name="members">List of team member IDs added to the hold.</param>
        /// <param name="description">A description of the legal hold policy.</param>
        /// <param name="startDate">start date of the legal hold policy.</param>
        /// <param name="endDate">end date of the legal hold policy.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginLegalHoldsCreatePolicy(string name,
                                                            col.IEnumerable<string> members,
                                                            string description = null,
                                                            sys.DateTime? startDate = null,
                                                            sys.DateTime? endDate = null,
                                                            sys.AsyncCallback callback = null,
                                                            object callbackState = null)
        {
            var legalHoldsPolicyCreateArg = new LegalHoldsPolicyCreateArg(name,
                                                                          members,
                                                                          description,
                                                                          startDate,
                                                                          endDate);

            return this.BeginLegalHoldsCreatePolicy(legalHoldsPolicyCreateArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the legal holds create policy
        /// route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="LegalHoldsPolicyCreateError"/>.</exception>
        public LegalHoldPolicy EndLegalHoldsCreatePolicy(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<LegalHoldPolicy>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Gets a legal hold by Id. Note: Legal Holds is a paid add-on. Not all teams
        /// have the feature.</para>
        /// <para>Permission : Team member file access.</para>
        /// </summary>
        /// <param name="legalHoldsGetPolicyArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="LegalHoldsGetPolicyError"/>.</exception>
        public t.Task<LegalHoldPolicy> LegalHoldsGetPolicyAsync(LegalHoldsGetPolicyArg legalHoldsGetPolicyArg)
        {
            return this.Transport.SendRpcRequestAsync<LegalHoldsGetPolicyArg, LegalHoldPolicy, LegalHoldsGetPolicyError>(legalHoldsGetPolicyArg, "api", "/team/legal_holds/get_policy", "team", global::Dropbox.Api.Team.LegalHoldsGetPolicyArg.Encoder, global::Dropbox.Api.Team.LegalHoldPolicy.Decoder, global::Dropbox.Api.Team.LegalHoldsGetPolicyError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the legal holds get policy route.</para>
        /// </summary>
        /// <param name="legalHoldsGetPolicyArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginLegalHoldsGetPolicy(LegalHoldsGetPolicyArg legalHoldsGetPolicyArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.LegalHoldsGetPolicyAsync(legalHoldsGetPolicyArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Gets a legal hold by Id. Note: Legal Holds is a paid add-on. Not all teams
        /// have the feature.</para>
        /// <para>Permission : Team member file access.</para>
        /// </summary>
        /// <param name="id">The legal hold Id.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="LegalHoldsGetPolicyError"/>.</exception>
        public t.Task<LegalHoldPolicy> LegalHoldsGetPolicyAsync(string id)
        {
            var legalHoldsGetPolicyArg = new LegalHoldsGetPolicyArg(id);

            return this.LegalHoldsGetPolicyAsync(legalHoldsGetPolicyArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the legal holds get policy route.</para>
        /// </summary>
        /// <param name="id">The legal hold Id.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginLegalHoldsGetPolicy(string id,
                                                         sys.AsyncCallback callback,
                                                         object callbackState = null)
        {
            var legalHoldsGetPolicyArg = new LegalHoldsGetPolicyArg(id);

            return this.BeginLegalHoldsGetPolicy(legalHoldsGetPolicyArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the legal holds get policy route
        /// to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="LegalHoldsGetPolicyError"/>.</exception>
        public LegalHoldPolicy EndLegalHoldsGetPolicy(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<LegalHoldPolicy>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>List the file metadata that's under the hold. Note: Legal Holds is a paid
        /// add-on. Not all teams have the feature.</para>
        /// <para>Permission : Team member file access.</para>
        /// </summary>
        /// <param name="legalHoldsListHeldRevisionsArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="LegalHoldsListHeldRevisionsError"/>.</exception>
        public t.Task<LegalHoldsListHeldRevisionResult> LegalHoldsListHeldRevisionsAsync(LegalHoldsListHeldRevisionsArg legalHoldsListHeldRevisionsArg)
        {
            return this.Transport.SendRpcRequestAsync<LegalHoldsListHeldRevisionsArg, LegalHoldsListHeldRevisionResult, LegalHoldsListHeldRevisionsError>(legalHoldsListHeldRevisionsArg, "api", "/team/legal_holds/list_held_revisions", "team", global::Dropbox.Api.Team.LegalHoldsListHeldRevisionsArg.Encoder, global::Dropbox.Api.Team.LegalHoldsListHeldRevisionResult.Decoder, global::Dropbox.Api.Team.LegalHoldsListHeldRevisionsError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the legal holds list held revisions
        /// route.</para>
        /// </summary>
        /// <param name="legalHoldsListHeldRevisionsArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginLegalHoldsListHeldRevisions(LegalHoldsListHeldRevisionsArg legalHoldsListHeldRevisionsArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.LegalHoldsListHeldRevisionsAsync(legalHoldsListHeldRevisionsArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>List the file metadata that's under the hold. Note: Legal Holds is a paid
        /// add-on. Not all teams have the feature.</para>
        /// <para>Permission : Team member file access.</para>
        /// </summary>
        /// <param name="id">The legal hold Id.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="LegalHoldsListHeldRevisionsError"/>.</exception>
        public t.Task<LegalHoldsListHeldRevisionResult> LegalHoldsListHeldRevisionsAsync(string id)
        {
            var legalHoldsListHeldRevisionsArg = new LegalHoldsListHeldRevisionsArg(id);

            return this.LegalHoldsListHeldRevisionsAsync(legalHoldsListHeldRevisionsArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the legal holds list held revisions
        /// route.</para>
        /// </summary>
        /// <param name="id">The legal hold Id.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginLegalHoldsListHeldRevisions(string id,
                                                                 sys.AsyncCallback callback,
                                                                 object callbackState = null)
        {
            var legalHoldsListHeldRevisionsArg = new LegalHoldsListHeldRevisionsArg(id);

            return this.BeginLegalHoldsListHeldRevisions(legalHoldsListHeldRevisionsArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the legal holds list held
        /// revisions route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="LegalHoldsListHeldRevisionsError"/>.</exception>
        public LegalHoldsListHeldRevisionResult EndLegalHoldsListHeldRevisions(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<LegalHoldsListHeldRevisionResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Continue listing the file metadata that's under the hold. Note: Legal Holds
        /// is a paid add-on. Not all teams have the feature.</para>
        /// <para>Permission : Team member file access.</para>
        /// </summary>
        /// <param name="legalHoldsListHeldRevisionsContinueArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="LegalHoldsListHeldRevisionsError"/>.</exception>
        public t.Task<LegalHoldsListHeldRevisionResult> LegalHoldsListHeldRevisionsContinueAsync(LegalHoldsListHeldRevisionsContinueArg legalHoldsListHeldRevisionsContinueArg)
        {
            return this.Transport.SendRpcRequestAsync<LegalHoldsListHeldRevisionsContinueArg, LegalHoldsListHeldRevisionResult, LegalHoldsListHeldRevisionsError>(legalHoldsListHeldRevisionsContinueArg, "api", "/team/legal_holds/list_held_revisions_continue", "team", global::Dropbox.Api.Team.LegalHoldsListHeldRevisionsContinueArg.Encoder, global::Dropbox.Api.Team.LegalHoldsListHeldRevisionResult.Decoder, global::Dropbox.Api.Team.LegalHoldsListHeldRevisionsError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the legal holds list held revisions continue
        /// route.</para>
        /// </summary>
        /// <param name="legalHoldsListHeldRevisionsContinueArg">The request
        /// parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginLegalHoldsListHeldRevisionsContinue(LegalHoldsListHeldRevisionsContinueArg legalHoldsListHeldRevisionsContinueArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.LegalHoldsListHeldRevisionsContinueAsync(legalHoldsListHeldRevisionsContinueArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Continue listing the file metadata that's under the hold. Note: Legal Holds
        /// is a paid add-on. Not all teams have the feature.</para>
        /// <para>Permission : Team member file access.</para>
        /// </summary>
        /// <param name="id">The legal hold Id.</param>
        /// <param name="cursor">The cursor idicates where to continue reading file metadata
        /// entries for the next API call. When there are no more entries, the cursor will
        /// return none.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="LegalHoldsListHeldRevisionsError"/>.</exception>
        public t.Task<LegalHoldsListHeldRevisionResult> LegalHoldsListHeldRevisionsContinueAsync(string id,
                                                                                                 string cursor = null)
        {
            var legalHoldsListHeldRevisionsContinueArg = new LegalHoldsListHeldRevisionsContinueArg(id,
                                                                                                    cursor);

            return this.LegalHoldsListHeldRevisionsContinueAsync(legalHoldsListHeldRevisionsContinueArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the legal holds list held revisions continue
        /// route.</para>
        /// </summary>
        /// <param name="id">The legal hold Id.</param>
        /// <param name="cursor">The cursor idicates where to continue reading file metadata
        /// entries for the next API call. When there are no more entries, the cursor will
        /// return none.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginLegalHoldsListHeldRevisionsContinue(string id,
                                                                         string cursor = null,
                                                                         sys.AsyncCallback callback = null,
                                                                         object callbackState = null)
        {
            var legalHoldsListHeldRevisionsContinueArg = new LegalHoldsListHeldRevisionsContinueArg(id,
                                                                                                    cursor);

            return this.BeginLegalHoldsListHeldRevisionsContinue(legalHoldsListHeldRevisionsContinueArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the legal holds list held
        /// revisions continue route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="LegalHoldsListHeldRevisionsError"/>.</exception>
        public LegalHoldsListHeldRevisionResult EndLegalHoldsListHeldRevisionsContinue(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<LegalHoldsListHeldRevisionResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Lists legal holds on a team. Note: Legal Holds is a paid add-on. Not all
        /// teams have the feature.</para>
        /// <para>Permission : Team member file access.</para>
        /// </summary>
        /// <param name="legalHoldsListPoliciesArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="LegalHoldsListPoliciesError"/>.</exception>
        public t.Task<LegalHoldsListPoliciesResult> LegalHoldsListPoliciesAsync(LegalHoldsListPoliciesArg legalHoldsListPoliciesArg)
        {
            return this.Transport.SendRpcRequestAsync<LegalHoldsListPoliciesArg, LegalHoldsListPoliciesResult, LegalHoldsListPoliciesError>(legalHoldsListPoliciesArg, "api", "/team/legal_holds/list_policies", "team", global::Dropbox.Api.Team.LegalHoldsListPoliciesArg.Encoder, global::Dropbox.Api.Team.LegalHoldsListPoliciesResult.Decoder, global::Dropbox.Api.Team.LegalHoldsListPoliciesError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the legal holds list policies route.</para>
        /// </summary>
        /// <param name="legalHoldsListPoliciesArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginLegalHoldsListPolicies(LegalHoldsListPoliciesArg legalHoldsListPoliciesArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.LegalHoldsListPoliciesAsync(legalHoldsListPoliciesArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Lists legal holds on a team. Note: Legal Holds is a paid add-on. Not all
        /// teams have the feature.</para>
        /// <para>Permission : Team member file access.</para>
        /// </summary>
        /// <param name="includeReleased">Whether to return holds that were released.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="LegalHoldsListPoliciesError"/>.</exception>
        public t.Task<LegalHoldsListPoliciesResult> LegalHoldsListPoliciesAsync(bool includeReleased = false)
        {
            var legalHoldsListPoliciesArg = new LegalHoldsListPoliciesArg(includeReleased);

            return this.LegalHoldsListPoliciesAsync(legalHoldsListPoliciesArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the legal holds list policies route.</para>
        /// </summary>
        /// <param name="includeReleased">Whether to return holds that were released.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginLegalHoldsListPolicies(bool includeReleased = false,
                                                            sys.AsyncCallback callback = null,
                                                            object callbackState = null)
        {
            var legalHoldsListPoliciesArg = new LegalHoldsListPoliciesArg(includeReleased);

            return this.BeginLegalHoldsListPolicies(legalHoldsListPoliciesArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the legal holds list policies
        /// route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="LegalHoldsListPoliciesError"/>.</exception>
        public LegalHoldsListPoliciesResult EndLegalHoldsListPolicies(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<LegalHoldsListPoliciesResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Releases a legal hold by Id. Note: Legal Holds is a paid add-on. Not all
        /// teams have the feature.</para>
        /// <para>Permission : Team member file access.</para>
        /// </summary>
        /// <param name="legalHoldsPolicyReleaseArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="LegalHoldsPolicyReleaseError"/>.</exception>
        public t.Task LegalHoldsReleasePolicyAsync(LegalHoldsPolicyReleaseArg legalHoldsPolicyReleaseArg)
        {
            return this.Transport.SendRpcRequestAsync<LegalHoldsPolicyReleaseArg, enc.Empty, LegalHoldsPolicyReleaseError>(legalHoldsPolicyReleaseArg, "api", "/team/legal_holds/release_policy", "team", global::Dropbox.Api.Team.LegalHoldsPolicyReleaseArg.Encoder, enc.EmptyDecoder.Instance, global::Dropbox.Api.Team.LegalHoldsPolicyReleaseError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the legal holds release policy route.</para>
        /// </summary>
        /// <param name="legalHoldsPolicyReleaseArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginLegalHoldsReleasePolicy(LegalHoldsPolicyReleaseArg legalHoldsPolicyReleaseArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.LegalHoldsReleasePolicyAsync(legalHoldsPolicyReleaseArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Releases a legal hold by Id. Note: Legal Holds is a paid add-on. Not all
        /// teams have the feature.</para>
        /// <para>Permission : Team member file access.</para>
        /// </summary>
        /// <param name="id">The legal hold Id.</param>
        /// <returns>The task that represents the asynchronous send operation.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="LegalHoldsPolicyReleaseError"/>.</exception>
        public t.Task LegalHoldsReleasePolicyAsync(string id)
        {
            var legalHoldsPolicyReleaseArg = new LegalHoldsPolicyReleaseArg(id);

            return this.LegalHoldsReleasePolicyAsync(legalHoldsPolicyReleaseArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the legal holds release policy route.</para>
        /// </summary>
        /// <param name="id">The legal hold Id.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginLegalHoldsReleasePolicy(string id,
                                                             sys.AsyncCallback callback,
                                                             object callbackState = null)
        {
            var legalHoldsPolicyReleaseArg = new LegalHoldsPolicyReleaseArg(id);

            return this.BeginLegalHoldsReleasePolicy(legalHoldsPolicyReleaseArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the legal holds release policy
        /// route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="LegalHoldsPolicyReleaseError"/>.</exception>
        public void EndLegalHoldsReleasePolicy(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }
        }

        /// <summary>
        /// <para>Updates a legal hold. Note: Legal Holds is a paid add-on. Not all teams have
        /// the feature.</para>
        /// <para>Permission : Team member file access.</para>
        /// </summary>
        /// <param name="legalHoldsPolicyUpdateArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="LegalHoldsPolicyUpdateError"/>.</exception>
        public t.Task<LegalHoldPolicy> LegalHoldsUpdatePolicyAsync(LegalHoldsPolicyUpdateArg legalHoldsPolicyUpdateArg)
        {
            return this.Transport.SendRpcRequestAsync<LegalHoldsPolicyUpdateArg, LegalHoldPolicy, LegalHoldsPolicyUpdateError>(legalHoldsPolicyUpdateArg, "api", "/team/legal_holds/update_policy", "team", global::Dropbox.Api.Team.LegalHoldsPolicyUpdateArg.Encoder, global::Dropbox.Api.Team.LegalHoldPolicy.Decoder, global::Dropbox.Api.Team.LegalHoldsPolicyUpdateError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the legal holds update policy route.</para>
        /// </summary>
        /// <param name="legalHoldsPolicyUpdateArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginLegalHoldsUpdatePolicy(LegalHoldsPolicyUpdateArg legalHoldsPolicyUpdateArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.LegalHoldsUpdatePolicyAsync(legalHoldsPolicyUpdateArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Updates a legal hold. Note: Legal Holds is a paid add-on. Not all teams have
        /// the feature.</para>
        /// <para>Permission : Team member file access.</para>
        /// </summary>
        /// <param name="id">The legal hold Id.</param>
        /// <param name="name">Policy new name.</param>
        /// <param name="description">Policy new description.</param>
        /// <param name="members">List of team member IDs to apply the policy on.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="LegalHoldsPolicyUpdateError"/>.</exception>
        public t.Task<LegalHoldPolicy> LegalHoldsUpdatePolicyAsync(string id,
                                                                   string name = null,
                                                                   string description = null,
                                                                   col.IEnumerable<string> members = null)
        {
            var legalHoldsPolicyUpdateArg = new LegalHoldsPolicyUpdateArg(id,
                                                                          name,
                                                                          description,
                                                                          members);

            return this.LegalHoldsUpdatePolicyAsync(legalHoldsPolicyUpdateArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the legal holds update policy route.</para>
        /// </summary>
        /// <param name="id">The legal hold Id.</param>
        /// <param name="name">Policy new name.</param>
        /// <param name="description">Policy new description.</param>
        /// <param name="members">List of team member IDs to apply the policy on.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginLegalHoldsUpdatePolicy(string id,
                                                            string name = null,
                                                            string description = null,
                                                            col.IEnumerable<string> members = null,
                                                            sys.AsyncCallback callback = null,
                                                            object callbackState = null)
        {
            var legalHoldsPolicyUpdateArg = new LegalHoldsPolicyUpdateArg(id,
                                                                          name,
                                                                          description,
                                                                          members);

            return this.BeginLegalHoldsUpdatePolicy(legalHoldsPolicyUpdateArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the legal holds update policy
        /// route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="LegalHoldsPolicyUpdateError"/>.</exception>
        public LegalHoldPolicy EndLegalHoldsUpdatePolicy(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<LegalHoldPolicy>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>List all linked applications of the team member.</para>
        /// <para>Note, this endpoint does not list any team-linked applications.</para>
        /// </summary>
        /// <param name="listMemberAppsArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="ListMemberAppsError"/>.</exception>
        public t.Task<ListMemberAppsResult> LinkedAppsListMemberLinkedAppsAsync(ListMemberAppsArg listMemberAppsArg)
        {
            return this.Transport.SendRpcRequestAsync<ListMemberAppsArg, ListMemberAppsResult, ListMemberAppsError>(listMemberAppsArg, "api", "/team/linked_apps/list_member_linked_apps", "team", global::Dropbox.Api.Team.ListMemberAppsArg.Encoder, global::Dropbox.Api.Team.ListMemberAppsResult.Decoder, global::Dropbox.Api.Team.ListMemberAppsError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the linked apps list member linked apps
        /// route.</para>
        /// </summary>
        /// <param name="listMemberAppsArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginLinkedAppsListMemberLinkedApps(ListMemberAppsArg listMemberAppsArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.LinkedAppsListMemberLinkedAppsAsync(listMemberAppsArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>List all linked applications of the team member.</para>
        /// <para>Note, this endpoint does not list any team-linked applications.</para>
        /// </summary>
        /// <param name="teamMemberId">The team member id.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="ListMemberAppsError"/>.</exception>
        public t.Task<ListMemberAppsResult> LinkedAppsListMemberLinkedAppsAsync(string teamMemberId)
        {
            var listMemberAppsArg = new ListMemberAppsArg(teamMemberId);

            return this.LinkedAppsListMemberLinkedAppsAsync(listMemberAppsArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the linked apps list member linked apps
        /// route.</para>
        /// </summary>
        /// <param name="teamMemberId">The team member id.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginLinkedAppsListMemberLinkedApps(string teamMemberId,
                                                                    sys.AsyncCallback callback,
                                                                    object callbackState = null)
        {
            var listMemberAppsArg = new ListMemberAppsArg(teamMemberId);

            return this.BeginLinkedAppsListMemberLinkedApps(listMemberAppsArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the linked apps list member linked
        /// apps route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="ListMemberAppsError"/>.</exception>
        public ListMemberAppsResult EndLinkedAppsListMemberLinkedApps(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<ListMemberAppsResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>List all applications linked to the team members' accounts.</para>
        /// <para>Note, this endpoint does not list any team-linked applications.</para>
        /// </summary>
        /// <param name="listMembersAppsArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="ListMembersAppsError"/>.</exception>
        public t.Task<ListMembersAppsResult> LinkedAppsListMembersLinkedAppsAsync(ListMembersAppsArg listMembersAppsArg)
        {
            return this.Transport.SendRpcRequestAsync<ListMembersAppsArg, ListMembersAppsResult, ListMembersAppsError>(listMembersAppsArg, "api", "/team/linked_apps/list_members_linked_apps", "team", global::Dropbox.Api.Team.ListMembersAppsArg.Encoder, global::Dropbox.Api.Team.ListMembersAppsResult.Decoder, global::Dropbox.Api.Team.ListMembersAppsError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the linked apps list members linked apps
        /// route.</para>
        /// </summary>
        /// <param name="listMembersAppsArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginLinkedAppsListMembersLinkedApps(ListMembersAppsArg listMembersAppsArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.LinkedAppsListMembersLinkedAppsAsync(listMembersAppsArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>List all applications linked to the team members' accounts.</para>
        /// <para>Note, this endpoint does not list any team-linked applications.</para>
        /// </summary>
        /// <param name="cursor">At the first call to the <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.LinkedAppsListMembersLinkedAppsAsync"
        /// /> the cursor shouldn't be passed. Then, if the result of the call includes a
        /// cursor, the following requests should include the received cursors in order to
        /// receive the next sub list of the team applications.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="ListMembersAppsError"/>.</exception>
        public t.Task<ListMembersAppsResult> LinkedAppsListMembersLinkedAppsAsync(string cursor = null)
        {
            var listMembersAppsArg = new ListMembersAppsArg(cursor);

            return this.LinkedAppsListMembersLinkedAppsAsync(listMembersAppsArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the linked apps list members linked apps
        /// route.</para>
        /// </summary>
        /// <param name="cursor">At the first call to the <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.LinkedAppsListMembersLinkedAppsAsync"
        /// /> the cursor shouldn't be passed. Then, if the result of the call includes a
        /// cursor, the following requests should include the received cursors in order to
        /// receive the next sub list of the team applications.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginLinkedAppsListMembersLinkedApps(string cursor = null,
                                                                     sys.AsyncCallback callback = null,
                                                                     object callbackState = null)
        {
            var listMembersAppsArg = new ListMembersAppsArg(cursor);

            return this.BeginLinkedAppsListMembersLinkedApps(listMembersAppsArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the linked apps list members
        /// linked apps route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="ListMembersAppsError"/>.</exception>
        public ListMembersAppsResult EndLinkedAppsListMembersLinkedApps(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<ListMembersAppsResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>List all applications linked to the team members' accounts.</para>
        /// <para>Note, this endpoint doesn't list any team-linked applications.</para>
        /// </summary>
        /// <param name="listTeamAppsArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="ListTeamAppsError"/>.</exception>
        [sys.Obsolete("This function is deprecated, please use LinkedAppsListMembersLinkedAppsAsync instead.")]
        public t.Task<ListTeamAppsResult> LinkedAppsListTeamLinkedAppsAsync(ListTeamAppsArg listTeamAppsArg)
        {
            return this.Transport.SendRpcRequestAsync<ListTeamAppsArg, ListTeamAppsResult, ListTeamAppsError>(listTeamAppsArg, "api", "/team/linked_apps/list_team_linked_apps", "team", global::Dropbox.Api.Team.ListTeamAppsArg.Encoder, global::Dropbox.Api.Team.ListTeamAppsResult.Decoder, global::Dropbox.Api.Team.ListTeamAppsError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the linked apps list team linked apps
        /// route.</para>
        /// </summary>
        /// <param name="listTeamAppsArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        [sys.Obsolete("This function is deprecated, please use BeginLinkedAppsListMembersLinkedApps instead.")]
        public sys.IAsyncResult BeginLinkedAppsListTeamLinkedApps(ListTeamAppsArg listTeamAppsArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.LinkedAppsListTeamLinkedAppsAsync(listTeamAppsArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>List all applications linked to the team members' accounts.</para>
        /// <para>Note, this endpoint doesn't list any team-linked applications.</para>
        /// </summary>
        /// <param name="cursor">At the first call to the <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.LinkedAppsListTeamLinkedAppsAsync" />
        /// the cursor shouldn't be passed. Then, if the result of the call includes a cursor,
        /// the following requests should include the received cursors in order to receive the
        /// next sub list of the team applications.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="ListTeamAppsError"/>.</exception>
        [sys.Obsolete("This function is deprecated, please use LinkedAppsListMembersLinkedAppsAsync instead.")]
        public t.Task<ListTeamAppsResult> LinkedAppsListTeamLinkedAppsAsync(string cursor = null)
        {
            var listTeamAppsArg = new ListTeamAppsArg(cursor);

            return this.LinkedAppsListTeamLinkedAppsAsync(listTeamAppsArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the linked apps list team linked apps
        /// route.</para>
        /// </summary>
        /// <param name="cursor">At the first call to the <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.LinkedAppsListTeamLinkedAppsAsync" />
        /// the cursor shouldn't be passed. Then, if the result of the call includes a cursor,
        /// the following requests should include the received cursors in order to receive the
        /// next sub list of the team applications.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        [sys.Obsolete("This function is deprecated, please use BeginLinkedAppsListMembersLinkedApps instead.")]
        public sys.IAsyncResult BeginLinkedAppsListTeamLinkedApps(string cursor = null,
                                                                  sys.AsyncCallback callback = null,
                                                                  object callbackState = null)
        {
            var listTeamAppsArg = new ListTeamAppsArg(cursor);

            return this.BeginLinkedAppsListTeamLinkedApps(listTeamAppsArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the linked apps list team linked
        /// apps route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="ListTeamAppsError"/>.</exception>
        [sys.Obsolete("This function is deprecated, please use EndLinkedAppsListMembersLinkedApps instead.")]
        public ListTeamAppsResult EndLinkedAppsListTeamLinkedApps(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<ListTeamAppsResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Revoke a linked application of the team member.</para>
        /// </summary>
        /// <param name="revokeLinkedApiAppArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="RevokeLinkedAppError"/>.</exception>
        public t.Task LinkedAppsRevokeLinkedAppAsync(RevokeLinkedApiAppArg revokeLinkedApiAppArg)
        {
            return this.Transport.SendRpcRequestAsync<RevokeLinkedApiAppArg, enc.Empty, RevokeLinkedAppError>(revokeLinkedApiAppArg, "api", "/team/linked_apps/revoke_linked_app", "team", global::Dropbox.Api.Team.RevokeLinkedApiAppArg.Encoder, enc.EmptyDecoder.Instance, global::Dropbox.Api.Team.RevokeLinkedAppError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the linked apps revoke linked app
        /// route.</para>
        /// </summary>
        /// <param name="revokeLinkedApiAppArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginLinkedAppsRevokeLinkedApp(RevokeLinkedApiAppArg revokeLinkedApiAppArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.LinkedAppsRevokeLinkedAppAsync(revokeLinkedApiAppArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Revoke a linked application of the team member.</para>
        /// </summary>
        /// <param name="appId">The application's unique id.</param>
        /// <param name="teamMemberId">The unique id of the member owning the device.</param>
        /// <param name="keepAppFolder">This flag is not longer supported, the application
        /// dedicated folder (in case the application uses  one) will be kept.</param>
        /// <returns>The task that represents the asynchronous send operation.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="RevokeLinkedAppError"/>.</exception>
        public t.Task LinkedAppsRevokeLinkedAppAsync(string appId,
                                                     string teamMemberId,
                                                     bool keepAppFolder = true)
        {
            var revokeLinkedApiAppArg = new RevokeLinkedApiAppArg(appId,
                                                                  teamMemberId,
                                                                  keepAppFolder);

            return this.LinkedAppsRevokeLinkedAppAsync(revokeLinkedApiAppArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the linked apps revoke linked app
        /// route.</para>
        /// </summary>
        /// <param name="appId">The application's unique id.</param>
        /// <param name="teamMemberId">The unique id of the member owning the device.</param>
        /// <param name="keepAppFolder">This flag is not longer supported, the application
        /// dedicated folder (in case the application uses  one) will be kept.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginLinkedAppsRevokeLinkedApp(string appId,
                                                               string teamMemberId,
                                                               bool keepAppFolder = true,
                                                               sys.AsyncCallback callback = null,
                                                               object callbackState = null)
        {
            var revokeLinkedApiAppArg = new RevokeLinkedApiAppArg(appId,
                                                                  teamMemberId,
                                                                  keepAppFolder);

            return this.BeginLinkedAppsRevokeLinkedApp(revokeLinkedApiAppArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the linked apps revoke linked app
        /// route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="RevokeLinkedAppError"/>.</exception>
        public void EndLinkedAppsRevokeLinkedApp(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }
        }

        /// <summary>
        /// <para>Revoke a list of linked applications of the team members.</para>
        /// </summary>
        /// <param name="revokeLinkedApiAppBatchArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="RevokeLinkedAppBatchError"/>.</exception>
        public t.Task<RevokeLinkedAppBatchResult> LinkedAppsRevokeLinkedAppBatchAsync(RevokeLinkedApiAppBatchArg revokeLinkedApiAppBatchArg)
        {
            return this.Transport.SendRpcRequestAsync<RevokeLinkedApiAppBatchArg, RevokeLinkedAppBatchResult, RevokeLinkedAppBatchError>(revokeLinkedApiAppBatchArg, "api", "/team/linked_apps/revoke_linked_app_batch", "team", global::Dropbox.Api.Team.RevokeLinkedApiAppBatchArg.Encoder, global::Dropbox.Api.Team.RevokeLinkedAppBatchResult.Decoder, global::Dropbox.Api.Team.RevokeLinkedAppBatchError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the linked apps revoke linked app batch
        /// route.</para>
        /// </summary>
        /// <param name="revokeLinkedApiAppBatchArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginLinkedAppsRevokeLinkedAppBatch(RevokeLinkedApiAppBatchArg revokeLinkedApiAppBatchArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.LinkedAppsRevokeLinkedAppBatchAsync(revokeLinkedApiAppBatchArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Revoke a list of linked applications of the team members.</para>
        /// </summary>
        /// <param name="revokeLinkedApp">The revoke linked app</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="RevokeLinkedAppBatchError"/>.</exception>
        public t.Task<RevokeLinkedAppBatchResult> LinkedAppsRevokeLinkedAppBatchAsync(col.IEnumerable<RevokeLinkedApiAppArg> revokeLinkedApp)
        {
            var revokeLinkedApiAppBatchArg = new RevokeLinkedApiAppBatchArg(revokeLinkedApp);

            return this.LinkedAppsRevokeLinkedAppBatchAsync(revokeLinkedApiAppBatchArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the linked apps revoke linked app batch
        /// route.</para>
        /// </summary>
        /// <param name="revokeLinkedApp">The revoke linked app</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginLinkedAppsRevokeLinkedAppBatch(col.IEnumerable<RevokeLinkedApiAppArg> revokeLinkedApp,
                                                                    sys.AsyncCallback callback,
                                                                    object callbackState = null)
        {
            var revokeLinkedApiAppBatchArg = new RevokeLinkedApiAppBatchArg(revokeLinkedApp);

            return this.BeginLinkedAppsRevokeLinkedAppBatch(revokeLinkedApiAppBatchArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the linked apps revoke linked app
        /// batch route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="RevokeLinkedAppBatchError"/>.</exception>
        public RevokeLinkedAppBatchResult EndLinkedAppsRevokeLinkedAppBatch(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<RevokeLinkedAppBatchResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Add users to member space limits excluded users list.</para>
        /// </summary>
        /// <param name="excludedUsersUpdateArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="ExcludedUsersUpdateError"/>.</exception>
        public t.Task<ExcludedUsersUpdateResult> MemberSpaceLimitsExcludedUsersAddAsync(ExcludedUsersUpdateArg excludedUsersUpdateArg)
        {
            return this.Transport.SendRpcRequestAsync<ExcludedUsersUpdateArg, ExcludedUsersUpdateResult, ExcludedUsersUpdateError>(excludedUsersUpdateArg, "api", "/team/member_space_limits/excluded_users/add", "team", global::Dropbox.Api.Team.ExcludedUsersUpdateArg.Encoder, global::Dropbox.Api.Team.ExcludedUsersUpdateResult.Decoder, global::Dropbox.Api.Team.ExcludedUsersUpdateError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the member space limits excluded users add
        /// route.</para>
        /// </summary>
        /// <param name="excludedUsersUpdateArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMemberSpaceLimitsExcludedUsersAdd(ExcludedUsersUpdateArg excludedUsersUpdateArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.MemberSpaceLimitsExcludedUsersAddAsync(excludedUsersUpdateArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Add users to member space limits excluded users list.</para>
        /// </summary>
        /// <param name="users">List of users to be added/removed.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="ExcludedUsersUpdateError"/>.</exception>
        public t.Task<ExcludedUsersUpdateResult> MemberSpaceLimitsExcludedUsersAddAsync(col.IEnumerable<UserSelectorArg> users = null)
        {
            var excludedUsersUpdateArg = new ExcludedUsersUpdateArg(users);

            return this.MemberSpaceLimitsExcludedUsersAddAsync(excludedUsersUpdateArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the member space limits excluded users add
        /// route.</para>
        /// </summary>
        /// <param name="users">List of users to be added/removed.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMemberSpaceLimitsExcludedUsersAdd(col.IEnumerable<UserSelectorArg> users = null,
                                                                       sys.AsyncCallback callback = null,
                                                                       object callbackState = null)
        {
            var excludedUsersUpdateArg = new ExcludedUsersUpdateArg(users);

            return this.BeginMemberSpaceLimitsExcludedUsersAdd(excludedUsersUpdateArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the member space limits excluded
        /// users add route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="ExcludedUsersUpdateError"/>.</exception>
        public ExcludedUsersUpdateResult EndMemberSpaceLimitsExcludedUsersAdd(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<ExcludedUsersUpdateResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>List member space limits excluded users.</para>
        /// </summary>
        /// <param name="excludedUsersListArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="ExcludedUsersListError"/>.</exception>
        public t.Task<ExcludedUsersListResult> MemberSpaceLimitsExcludedUsersListAsync(ExcludedUsersListArg excludedUsersListArg)
        {
            return this.Transport.SendRpcRequestAsync<ExcludedUsersListArg, ExcludedUsersListResult, ExcludedUsersListError>(excludedUsersListArg, "api", "/team/member_space_limits/excluded_users/list", "team", global::Dropbox.Api.Team.ExcludedUsersListArg.Encoder, global::Dropbox.Api.Team.ExcludedUsersListResult.Decoder, global::Dropbox.Api.Team.ExcludedUsersListError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the member space limits excluded users list
        /// route.</para>
        /// </summary>
        /// <param name="excludedUsersListArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMemberSpaceLimitsExcludedUsersList(ExcludedUsersListArg excludedUsersListArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.MemberSpaceLimitsExcludedUsersListAsync(excludedUsersListArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>List member space limits excluded users.</para>
        /// </summary>
        /// <param name="limit">Number of results to return per call.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="ExcludedUsersListError"/>.</exception>
        public t.Task<ExcludedUsersListResult> MemberSpaceLimitsExcludedUsersListAsync(uint limit = 1000)
        {
            var excludedUsersListArg = new ExcludedUsersListArg(limit);

            return this.MemberSpaceLimitsExcludedUsersListAsync(excludedUsersListArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the member space limits excluded users list
        /// route.</para>
        /// </summary>
        /// <param name="limit">Number of results to return per call.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMemberSpaceLimitsExcludedUsersList(uint limit = 1000,
                                                                        sys.AsyncCallback callback = null,
                                                                        object callbackState = null)
        {
            var excludedUsersListArg = new ExcludedUsersListArg(limit);

            return this.BeginMemberSpaceLimitsExcludedUsersList(excludedUsersListArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the member space limits excluded
        /// users list route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="ExcludedUsersListError"/>.</exception>
        public ExcludedUsersListResult EndMemberSpaceLimitsExcludedUsersList(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<ExcludedUsersListResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Continue listing member space limits excluded users.</para>
        /// </summary>
        /// <param name="excludedUsersListContinueArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="ExcludedUsersListContinueError"/>.</exception>
        public t.Task<ExcludedUsersListResult> MemberSpaceLimitsExcludedUsersListContinueAsync(ExcludedUsersListContinueArg excludedUsersListContinueArg)
        {
            return this.Transport.SendRpcRequestAsync<ExcludedUsersListContinueArg, ExcludedUsersListResult, ExcludedUsersListContinueError>(excludedUsersListContinueArg, "api", "/team/member_space_limits/excluded_users/list/continue", "team", global::Dropbox.Api.Team.ExcludedUsersListContinueArg.Encoder, global::Dropbox.Api.Team.ExcludedUsersListResult.Decoder, global::Dropbox.Api.Team.ExcludedUsersListContinueError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the member space limits excluded users list
        /// continue route.</para>
        /// </summary>
        /// <param name="excludedUsersListContinueArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMemberSpaceLimitsExcludedUsersListContinue(ExcludedUsersListContinueArg excludedUsersListContinueArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.MemberSpaceLimitsExcludedUsersListContinueAsync(excludedUsersListContinueArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Continue listing member space limits excluded users.</para>
        /// </summary>
        /// <param name="cursor">Indicates from what point to get the next set of
        /// users.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="ExcludedUsersListContinueError"/>.</exception>
        public t.Task<ExcludedUsersListResult> MemberSpaceLimitsExcludedUsersListContinueAsync(string cursor)
        {
            var excludedUsersListContinueArg = new ExcludedUsersListContinueArg(cursor);

            return this.MemberSpaceLimitsExcludedUsersListContinueAsync(excludedUsersListContinueArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the member space limits excluded users list
        /// continue route.</para>
        /// </summary>
        /// <param name="cursor">Indicates from what point to get the next set of
        /// users.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMemberSpaceLimitsExcludedUsersListContinue(string cursor,
                                                                                sys.AsyncCallback callback,
                                                                                object callbackState = null)
        {
            var excludedUsersListContinueArg = new ExcludedUsersListContinueArg(cursor);

            return this.BeginMemberSpaceLimitsExcludedUsersListContinue(excludedUsersListContinueArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the member space limits excluded
        /// users list continue route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="ExcludedUsersListContinueError"/>.</exception>
        public ExcludedUsersListResult EndMemberSpaceLimitsExcludedUsersListContinue(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<ExcludedUsersListResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Remove users from member space limits excluded users list.</para>
        /// </summary>
        /// <param name="excludedUsersUpdateArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="ExcludedUsersUpdateError"/>.</exception>
        public t.Task<ExcludedUsersUpdateResult> MemberSpaceLimitsExcludedUsersRemoveAsync(ExcludedUsersUpdateArg excludedUsersUpdateArg)
        {
            return this.Transport.SendRpcRequestAsync<ExcludedUsersUpdateArg, ExcludedUsersUpdateResult, ExcludedUsersUpdateError>(excludedUsersUpdateArg, "api", "/team/member_space_limits/excluded_users/remove", "team", global::Dropbox.Api.Team.ExcludedUsersUpdateArg.Encoder, global::Dropbox.Api.Team.ExcludedUsersUpdateResult.Decoder, global::Dropbox.Api.Team.ExcludedUsersUpdateError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the member space limits excluded users remove
        /// route.</para>
        /// </summary>
        /// <param name="excludedUsersUpdateArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMemberSpaceLimitsExcludedUsersRemove(ExcludedUsersUpdateArg excludedUsersUpdateArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.MemberSpaceLimitsExcludedUsersRemoveAsync(excludedUsersUpdateArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Remove users from member space limits excluded users list.</para>
        /// </summary>
        /// <param name="users">List of users to be added/removed.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="ExcludedUsersUpdateError"/>.</exception>
        public t.Task<ExcludedUsersUpdateResult> MemberSpaceLimitsExcludedUsersRemoveAsync(col.IEnumerable<UserSelectorArg> users = null)
        {
            var excludedUsersUpdateArg = new ExcludedUsersUpdateArg(users);

            return this.MemberSpaceLimitsExcludedUsersRemoveAsync(excludedUsersUpdateArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the member space limits excluded users remove
        /// route.</para>
        /// </summary>
        /// <param name="users">List of users to be added/removed.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMemberSpaceLimitsExcludedUsersRemove(col.IEnumerable<UserSelectorArg> users = null,
                                                                          sys.AsyncCallback callback = null,
                                                                          object callbackState = null)
        {
            var excludedUsersUpdateArg = new ExcludedUsersUpdateArg(users);

            return this.BeginMemberSpaceLimitsExcludedUsersRemove(excludedUsersUpdateArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the member space limits excluded
        /// users remove route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="ExcludedUsersUpdateError"/>.</exception>
        public ExcludedUsersUpdateResult EndMemberSpaceLimitsExcludedUsersRemove(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<ExcludedUsersUpdateResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Get users custom quota. Returns none as the custom quota if none was set. A
        /// maximum of 1000 members can be specified in a single call.</para>
        /// </summary>
        /// <param name="customQuotaUsersArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="CustomQuotaError"/>.</exception>
        public t.Task<col.List<CustomQuotaResult>> MemberSpaceLimitsGetCustomQuotaAsync(CustomQuotaUsersArg customQuotaUsersArg)
        {
            return this.Transport.SendRpcRequestAsync<CustomQuotaUsersArg, col.List<CustomQuotaResult>, CustomQuotaError>(customQuotaUsersArg, "api", "/team/member_space_limits/get_custom_quota", "team", global::Dropbox.Api.Team.CustomQuotaUsersArg.Encoder, enc.Decoder.CreateListDecoder(global::Dropbox.Api.Team.CustomQuotaResult.Decoder), global::Dropbox.Api.Team.CustomQuotaError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the member space limits get custom quota
        /// route.</para>
        /// </summary>
        /// <param name="customQuotaUsersArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMemberSpaceLimitsGetCustomQuota(CustomQuotaUsersArg customQuotaUsersArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.MemberSpaceLimitsGetCustomQuotaAsync(customQuotaUsersArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Get users custom quota. Returns none as the custom quota if none was set. A
        /// maximum of 1000 members can be specified in a single call.</para>
        /// </summary>
        /// <param name="users">List of users.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="CustomQuotaError"/>.</exception>
        public t.Task<col.List<CustomQuotaResult>> MemberSpaceLimitsGetCustomQuotaAsync(col.IEnumerable<UserSelectorArg> users)
        {
            var customQuotaUsersArg = new CustomQuotaUsersArg(users);

            return this.MemberSpaceLimitsGetCustomQuotaAsync(customQuotaUsersArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the member space limits get custom quota
        /// route.</para>
        /// </summary>
        /// <param name="users">List of users.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMemberSpaceLimitsGetCustomQuota(col.IEnumerable<UserSelectorArg> users,
                                                                     sys.AsyncCallback callback,
                                                                     object callbackState = null)
        {
            var customQuotaUsersArg = new CustomQuotaUsersArg(users);

            return this.BeginMemberSpaceLimitsGetCustomQuota(customQuotaUsersArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the member space limits get custom
        /// quota route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="CustomQuotaError"/>.</exception>
        public col.List<CustomQuotaResult> EndMemberSpaceLimitsGetCustomQuota(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<col.List<CustomQuotaResult>>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Remove users custom quota. A maximum of 1000 members can be specified in a
        /// single call.</para>
        /// </summary>
        /// <param name="customQuotaUsersArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="CustomQuotaError"/>.</exception>
        public t.Task<col.List<RemoveCustomQuotaResult>> MemberSpaceLimitsRemoveCustomQuotaAsync(CustomQuotaUsersArg customQuotaUsersArg)
        {
            return this.Transport.SendRpcRequestAsync<CustomQuotaUsersArg, col.List<RemoveCustomQuotaResult>, CustomQuotaError>(customQuotaUsersArg, "api", "/team/member_space_limits/remove_custom_quota", "team", global::Dropbox.Api.Team.CustomQuotaUsersArg.Encoder, enc.Decoder.CreateListDecoder(global::Dropbox.Api.Team.RemoveCustomQuotaResult.Decoder), global::Dropbox.Api.Team.CustomQuotaError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the member space limits remove custom quota
        /// route.</para>
        /// </summary>
        /// <param name="customQuotaUsersArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMemberSpaceLimitsRemoveCustomQuota(CustomQuotaUsersArg customQuotaUsersArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.MemberSpaceLimitsRemoveCustomQuotaAsync(customQuotaUsersArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Remove users custom quota. A maximum of 1000 members can be specified in a
        /// single call.</para>
        /// </summary>
        /// <param name="users">List of users.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="CustomQuotaError"/>.</exception>
        public t.Task<col.List<RemoveCustomQuotaResult>> MemberSpaceLimitsRemoveCustomQuotaAsync(col.IEnumerable<UserSelectorArg> users)
        {
            var customQuotaUsersArg = new CustomQuotaUsersArg(users);

            return this.MemberSpaceLimitsRemoveCustomQuotaAsync(customQuotaUsersArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the member space limits remove custom quota
        /// route.</para>
        /// </summary>
        /// <param name="users">List of users.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMemberSpaceLimitsRemoveCustomQuota(col.IEnumerable<UserSelectorArg> users,
                                                                        sys.AsyncCallback callback,
                                                                        object callbackState = null)
        {
            var customQuotaUsersArg = new CustomQuotaUsersArg(users);

            return this.BeginMemberSpaceLimitsRemoveCustomQuota(customQuotaUsersArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the member space limits remove
        /// custom quota route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="CustomQuotaError"/>.</exception>
        public col.List<RemoveCustomQuotaResult> EndMemberSpaceLimitsRemoveCustomQuota(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<col.List<RemoveCustomQuotaResult>>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Set users custom quota. Custom quota has to be at least 15GB. A maximum of
        /// 1000 members can be specified in a single call.</para>
        /// </summary>
        /// <param name="setCustomQuotaArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="SetCustomQuotaError"/>.</exception>
        public t.Task<col.List<CustomQuotaResult>> MemberSpaceLimitsSetCustomQuotaAsync(SetCustomQuotaArg setCustomQuotaArg)
        {
            return this.Transport.SendRpcRequestAsync<SetCustomQuotaArg, col.List<CustomQuotaResult>, SetCustomQuotaError>(setCustomQuotaArg, "api", "/team/member_space_limits/set_custom_quota", "team", global::Dropbox.Api.Team.SetCustomQuotaArg.Encoder, enc.Decoder.CreateListDecoder(global::Dropbox.Api.Team.CustomQuotaResult.Decoder), global::Dropbox.Api.Team.SetCustomQuotaError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the member space limits set custom quota
        /// route.</para>
        /// </summary>
        /// <param name="setCustomQuotaArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMemberSpaceLimitsSetCustomQuota(SetCustomQuotaArg setCustomQuotaArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.MemberSpaceLimitsSetCustomQuotaAsync(setCustomQuotaArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Set users custom quota. Custom quota has to be at least 15GB. A maximum of
        /// 1000 members can be specified in a single call.</para>
        /// </summary>
        /// <param name="usersAndQuotas">List of users and their custom quotas.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="SetCustomQuotaError"/>.</exception>
        public t.Task<col.List<CustomQuotaResult>> MemberSpaceLimitsSetCustomQuotaAsync(col.IEnumerable<UserCustomQuotaArg> usersAndQuotas)
        {
            var setCustomQuotaArg = new SetCustomQuotaArg(usersAndQuotas);

            return this.MemberSpaceLimitsSetCustomQuotaAsync(setCustomQuotaArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the member space limits set custom quota
        /// route.</para>
        /// </summary>
        /// <param name="usersAndQuotas">List of users and their custom quotas.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMemberSpaceLimitsSetCustomQuota(col.IEnumerable<UserCustomQuotaArg> usersAndQuotas,
                                                                     sys.AsyncCallback callback,
                                                                     object callbackState = null)
        {
            var setCustomQuotaArg = new SetCustomQuotaArg(usersAndQuotas);

            return this.BeginMemberSpaceLimitsSetCustomQuota(setCustomQuotaArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the member space limits set custom
        /// quota route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="SetCustomQuotaError"/>.</exception>
        public col.List<CustomQuotaResult> EndMemberSpaceLimitsSetCustomQuota(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<col.List<CustomQuotaResult>>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Adds members to a team.</para>
        /// <para>Permission : Team member management</para>
        /// <para>A maximum of 20 members can be specified in a single call.</para>
        /// <para>If no Dropbox account exists with the email address specified, a new Dropbox
        /// account will be created with the given email address, and that account will be
        /// invited to the team.</para>
        /// <para>If a personal Dropbox account exists with the email address specified in the
        /// call, this call will create a placeholder Dropbox account for the user on the team
        /// and send an email inviting the user to migrate their existing personal account onto
        /// the team.</para>
        /// <para>Team member management apps are required to set an initial given_name and
        /// surname for a user to use in the team invitation and for 'Perform as team member'
        /// actions taken on the user before they become 'active'.</para>
        /// </summary>
        /// <param name="membersAddV2Arg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        public t.Task<MembersAddLaunchV2Result> MembersAddV2Async(MembersAddV2Arg membersAddV2Arg)
        {
            return this.Transport.SendRpcRequestAsync<MembersAddV2Arg, MembersAddLaunchV2Result, enc.Empty>(membersAddV2Arg, "api", "/team/members/add_v2", "team", global::Dropbox.Api.Team.MembersAddV2Arg.Encoder, global::Dropbox.Api.Team.MembersAddLaunchV2Result.Decoder, enc.EmptyDecoder.Instance);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members add route.</para>
        /// </summary>
        /// <param name="membersAddV2Arg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersAddV2(MembersAddV2Arg membersAddV2Arg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.MembersAddV2Async(membersAddV2Arg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Adds members to a team.</para>
        /// <para>Permission : Team member management</para>
        /// <para>A maximum of 20 members can be specified in a single call.</para>
        /// <para>If no Dropbox account exists with the email address specified, a new Dropbox
        /// account will be created with the given email address, and that account will be
        /// invited to the team.</para>
        /// <para>If a personal Dropbox account exists with the email address specified in the
        /// call, this call will create a placeholder Dropbox account for the user on the team
        /// and send an email inviting the user to migrate their existing personal account onto
        /// the team.</para>
        /// <para>Team member management apps are required to set an initial given_name and
        /// surname for a user to use in the team invitation and for 'Perform as team member'
        /// actions taken on the user before they become 'active'.</para>
        /// </summary>
        /// <param name="newMembers">Details of new members to be added to the team.</param>
        /// <param name="forceAsync">Whether to force the add to happen asynchronously.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        public t.Task<MembersAddLaunchV2Result> MembersAddV2Async(col.IEnumerable<MemberAddV2Arg> newMembers,
                                                                  bool forceAsync = false)
        {
            var membersAddV2Arg = new MembersAddV2Arg(newMembers,
                                                      forceAsync);

            return this.MembersAddV2Async(membersAddV2Arg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members add route.</para>
        /// </summary>
        /// <param name="newMembers">Details of new members to be added to the team.</param>
        /// <param name="forceAsync">Whether to force the add to happen asynchronously.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersAddV2(col.IEnumerable<MemberAddV2Arg> newMembers,
                                                  bool forceAsync = false,
                                                  sys.AsyncCallback callback = null,
                                                  object callbackState = null)
        {
            var membersAddV2Arg = new MembersAddV2Arg(newMembers,
                                                      forceAsync);

            return this.BeginMembersAddV2(membersAddV2Arg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the members add route to
        /// complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        public MembersAddLaunchV2Result EndMembersAddV2(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<MembersAddLaunchV2Result>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Adds members to a team.</para>
        /// <para>Permission : Team member management</para>
        /// <para>A maximum of 20 members can be specified in a single call.</para>
        /// <para>If no Dropbox account exists with the email address specified, a new Dropbox
        /// account will be created with the given email address, and that account will be
        /// invited to the team.</para>
        /// <para>If a personal Dropbox account exists with the email address specified in the
        /// call, this call will create a placeholder Dropbox account for the user on the team
        /// and send an email inviting the user to migrate their existing personal account onto
        /// the team.</para>
        /// <para>Team member management apps are required to set an initial given_name and
        /// surname for a user to use in the team invitation and for 'Perform as team member'
        /// actions taken on the user before they become 'active'.</para>
        /// </summary>
        /// <param name="membersAddArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        public t.Task<MembersAddLaunch> MembersAddAsync(MembersAddArg membersAddArg)
        {
            return this.Transport.SendRpcRequestAsync<MembersAddArg, MembersAddLaunch, enc.Empty>(membersAddArg, "api", "/team/members/add", "team", global::Dropbox.Api.Team.MembersAddArg.Encoder, global::Dropbox.Api.Team.MembersAddLaunch.Decoder, enc.EmptyDecoder.Instance);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members add route.</para>
        /// </summary>
        /// <param name="membersAddArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersAdd(MembersAddArg membersAddArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.MembersAddAsync(membersAddArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Adds members to a team.</para>
        /// <para>Permission : Team member management</para>
        /// <para>A maximum of 20 members can be specified in a single call.</para>
        /// <para>If no Dropbox account exists with the email address specified, a new Dropbox
        /// account will be created with the given email address, and that account will be
        /// invited to the team.</para>
        /// <para>If a personal Dropbox account exists with the email address specified in the
        /// call, this call will create a placeholder Dropbox account for the user on the team
        /// and send an email inviting the user to migrate their existing personal account onto
        /// the team.</para>
        /// <para>Team member management apps are required to set an initial given_name and
        /// surname for a user to use in the team invitation and for 'Perform as team member'
        /// actions taken on the user before they become 'active'.</para>
        /// </summary>
        /// <param name="newMembers">Details of new members to be added to the team.</param>
        /// <param name="forceAsync">Whether to force the add to happen asynchronously.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        public t.Task<MembersAddLaunch> MembersAddAsync(col.IEnumerable<MemberAddArg> newMembers,
                                                        bool forceAsync = false)
        {
            var membersAddArg = new MembersAddArg(newMembers,
                                                  forceAsync);

            return this.MembersAddAsync(membersAddArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members add route.</para>
        /// </summary>
        /// <param name="newMembers">Details of new members to be added to the team.</param>
        /// <param name="forceAsync">Whether to force the add to happen asynchronously.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersAdd(col.IEnumerable<MemberAddArg> newMembers,
                                                bool forceAsync = false,
                                                sys.AsyncCallback callback = null,
                                                object callbackState = null)
        {
            var membersAddArg = new MembersAddArg(newMembers,
                                                  forceAsync);

            return this.BeginMembersAdd(membersAddArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the members add route to
        /// complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        public MembersAddLaunch EndMembersAdd(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<MembersAddLaunch>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Once an async_job_id is returned from <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.MembersAddV2Async" /> , use this to
        /// poll the status of the asynchronous request.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <param name="pollArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="global::Dropbox.Api.Async.PollError"/>.</exception>
        public t.Task<MembersAddJobStatusV2Result> MembersAddJobStatusGetV2Async(global::Dropbox.Api.Async.PollArg pollArg)
        {
            return this.Transport.SendRpcRequestAsync<global::Dropbox.Api.Async.PollArg, MembersAddJobStatusV2Result, global::Dropbox.Api.Async.PollError>(pollArg, "api", "/team/members/add/job_status/get_v2", "team", global::Dropbox.Api.Async.PollArg.Encoder, global::Dropbox.Api.Team.MembersAddJobStatusV2Result.Decoder, global::Dropbox.Api.Async.PollError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members add job status get route.</para>
        /// </summary>
        /// <param name="pollArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersAddJobStatusGetV2(global::Dropbox.Api.Async.PollArg pollArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.MembersAddJobStatusGetV2Async(pollArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Once an async_job_id is returned from <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.MembersAddV2Async" /> , use this to
        /// poll the status of the asynchronous request.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <param name="asyncJobId">Id of the asynchronous job. This is the value of a
        /// response returned from the method that launched the job.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="global::Dropbox.Api.Async.PollError"/>.</exception>
        public t.Task<MembersAddJobStatusV2Result> MembersAddJobStatusGetV2Async(string asyncJobId)
        {
            var pollArg = new global::Dropbox.Api.Async.PollArg(asyncJobId);

            return this.MembersAddJobStatusGetV2Async(pollArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members add job status get route.</para>
        /// </summary>
        /// <param name="asyncJobId">Id of the asynchronous job. This is the value of a
        /// response returned from the method that launched the job.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersAddJobStatusGetV2(string asyncJobId,
                                                              sys.AsyncCallback callback,
                                                              object callbackState = null)
        {
            var pollArg = new global::Dropbox.Api.Async.PollArg(asyncJobId);

            return this.BeginMembersAddJobStatusGetV2(pollArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the members add job status get
        /// route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="global::Dropbox.Api.Async.PollError"/>.</exception>
        public MembersAddJobStatusV2Result EndMembersAddJobStatusGetV2(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<MembersAddJobStatusV2Result>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Once an async_job_id is returned from <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.MembersAddAsync" /> , use this to poll
        /// the status of the asynchronous request.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <param name="pollArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="global::Dropbox.Api.Async.PollError"/>.</exception>
        public t.Task<MembersAddJobStatus> MembersAddJobStatusGetAsync(global::Dropbox.Api.Async.PollArg pollArg)
        {
            return this.Transport.SendRpcRequestAsync<global::Dropbox.Api.Async.PollArg, MembersAddJobStatus, global::Dropbox.Api.Async.PollError>(pollArg, "api", "/team/members/add/job_status/get", "team", global::Dropbox.Api.Async.PollArg.Encoder, global::Dropbox.Api.Team.MembersAddJobStatus.Decoder, global::Dropbox.Api.Async.PollError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members add job status get route.</para>
        /// </summary>
        /// <param name="pollArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersAddJobStatusGet(global::Dropbox.Api.Async.PollArg pollArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.MembersAddJobStatusGetAsync(pollArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Once an async_job_id is returned from <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.MembersAddAsync" /> , use this to poll
        /// the status of the asynchronous request.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <param name="asyncJobId">Id of the asynchronous job. This is the value of a
        /// response returned from the method that launched the job.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="global::Dropbox.Api.Async.PollError"/>.</exception>
        public t.Task<MembersAddJobStatus> MembersAddJobStatusGetAsync(string asyncJobId)
        {
            var pollArg = new global::Dropbox.Api.Async.PollArg(asyncJobId);

            return this.MembersAddJobStatusGetAsync(pollArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members add job status get route.</para>
        /// </summary>
        /// <param name="asyncJobId">Id of the asynchronous job. This is the value of a
        /// response returned from the method that launched the job.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersAddJobStatusGet(string asyncJobId,
                                                            sys.AsyncCallback callback,
                                                            object callbackState = null)
        {
            var pollArg = new global::Dropbox.Api.Async.PollArg(asyncJobId);

            return this.BeginMembersAddJobStatusGet(pollArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the members add job status get
        /// route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="global::Dropbox.Api.Async.PollError"/>.</exception>
        public MembersAddJobStatus EndMembersAddJobStatusGet(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<MembersAddJobStatus>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Deletes a team member's profile photo.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <param name="membersDeleteProfilePhotoArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersDeleteProfilePhotoError"/>.</exception>
        public t.Task<TeamMemberInfoV2Result> MembersDeleteProfilePhotoV2Async(MembersDeleteProfilePhotoArg membersDeleteProfilePhotoArg)
        {
            return this.Transport.SendRpcRequestAsync<MembersDeleteProfilePhotoArg, TeamMemberInfoV2Result, MembersDeleteProfilePhotoError>(membersDeleteProfilePhotoArg, "api", "/team/members/delete_profile_photo_v2", "team", global::Dropbox.Api.Team.MembersDeleteProfilePhotoArg.Encoder, global::Dropbox.Api.Team.TeamMemberInfoV2Result.Decoder, global::Dropbox.Api.Team.MembersDeleteProfilePhotoError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members delete profile photo route.</para>
        /// </summary>
        /// <param name="membersDeleteProfilePhotoArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersDeleteProfilePhotoV2(MembersDeleteProfilePhotoArg membersDeleteProfilePhotoArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.MembersDeleteProfilePhotoV2Async(membersDeleteProfilePhotoArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Deletes a team member's profile photo.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <param name="user">Identity of the user whose profile photo will be
        /// deleted.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersDeleteProfilePhotoError"/>.</exception>
        public t.Task<TeamMemberInfoV2Result> MembersDeleteProfilePhotoV2Async(UserSelectorArg user)
        {
            var membersDeleteProfilePhotoArg = new MembersDeleteProfilePhotoArg(user);

            return this.MembersDeleteProfilePhotoV2Async(membersDeleteProfilePhotoArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members delete profile photo route.</para>
        /// </summary>
        /// <param name="user">Identity of the user whose profile photo will be
        /// deleted.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersDeleteProfilePhotoV2(UserSelectorArg user,
                                                                 sys.AsyncCallback callback,
                                                                 object callbackState = null)
        {
            var membersDeleteProfilePhotoArg = new MembersDeleteProfilePhotoArg(user);

            return this.BeginMembersDeleteProfilePhotoV2(membersDeleteProfilePhotoArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the members delete profile photo
        /// route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersDeleteProfilePhotoError"/>.</exception>
        public TeamMemberInfoV2Result EndMembersDeleteProfilePhotoV2(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<TeamMemberInfoV2Result>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Deletes a team member's profile photo.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <param name="membersDeleteProfilePhotoArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersDeleteProfilePhotoError"/>.</exception>
        public t.Task<TeamMemberInfo> MembersDeleteProfilePhotoAsync(MembersDeleteProfilePhotoArg membersDeleteProfilePhotoArg)
        {
            return this.Transport.SendRpcRequestAsync<MembersDeleteProfilePhotoArg, TeamMemberInfo, MembersDeleteProfilePhotoError>(membersDeleteProfilePhotoArg, "api", "/team/members/delete_profile_photo", "team", global::Dropbox.Api.Team.MembersDeleteProfilePhotoArg.Encoder, global::Dropbox.Api.Team.TeamMemberInfo.Decoder, global::Dropbox.Api.Team.MembersDeleteProfilePhotoError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members delete profile photo route.</para>
        /// </summary>
        /// <param name="membersDeleteProfilePhotoArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersDeleteProfilePhoto(MembersDeleteProfilePhotoArg membersDeleteProfilePhotoArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.MembersDeleteProfilePhotoAsync(membersDeleteProfilePhotoArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Deletes a team member's profile photo.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <param name="user">Identity of the user whose profile photo will be
        /// deleted.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersDeleteProfilePhotoError"/>.</exception>
        public t.Task<TeamMemberInfo> MembersDeleteProfilePhotoAsync(UserSelectorArg user)
        {
            var membersDeleteProfilePhotoArg = new MembersDeleteProfilePhotoArg(user);

            return this.MembersDeleteProfilePhotoAsync(membersDeleteProfilePhotoArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members delete profile photo route.</para>
        /// </summary>
        /// <param name="user">Identity of the user whose profile photo will be
        /// deleted.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersDeleteProfilePhoto(UserSelectorArg user,
                                                               sys.AsyncCallback callback,
                                                               object callbackState = null)
        {
            var membersDeleteProfilePhotoArg = new MembersDeleteProfilePhotoArg(user);

            return this.BeginMembersDeleteProfilePhoto(membersDeleteProfilePhotoArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the members delete profile photo
        /// route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersDeleteProfilePhotoError"/>.</exception>
        public TeamMemberInfo EndMembersDeleteProfilePhoto(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<TeamMemberInfo>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Get available TeamMemberRoles for the connected team. To be used with <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.MembersSetAdminPermissionsV2Async"
        /// />.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        public t.Task<MembersGetAvailableTeamMemberRolesResult> MembersGetAvailableTeamMemberRolesAsync()
        {
            return this.Transport.SendRpcRequestAsync<enc.Empty, MembersGetAvailableTeamMemberRolesResult, enc.Empty>(enc.Empty.Instance, "api", "/team/members/get_available_team_member_roles", "team", enc.EmptyEncoder.Instance, global::Dropbox.Api.Team.MembersGetAvailableTeamMemberRolesResult.Decoder, enc.EmptyDecoder.Instance);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members get available team member roles
        /// route.</para>
        /// </summary>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersGetAvailableTeamMemberRoles(sys.AsyncCallback callback, object state = null)
        {
            var task = this.MembersGetAvailableTeamMemberRolesAsync();

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the members get available team
        /// member roles route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        public MembersGetAvailableTeamMemberRolesResult EndMembersGetAvailableTeamMemberRoles(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<MembersGetAvailableTeamMemberRolesResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Returns information about multiple team members.</para>
        /// <para>Permission : Team information</para>
        /// <para>This endpoint will return <see
        /// cref="Dropbox.Api.Team.MembersGetInfoItem.IdNotFound" />, for IDs (or emails) that
        /// cannot be matched to a valid team member.</para>
        /// </summary>
        /// <param name="membersGetInfoV2Arg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersGetInfoError"/>.</exception>
        public t.Task<MembersGetInfoV2Result> MembersGetInfoV2Async(MembersGetInfoV2Arg membersGetInfoV2Arg)
        {
            return this.Transport.SendRpcRequestAsync<MembersGetInfoV2Arg, MembersGetInfoV2Result, MembersGetInfoError>(membersGetInfoV2Arg, "api", "/team/members/get_info_v2", "team", global::Dropbox.Api.Team.MembersGetInfoV2Arg.Encoder, global::Dropbox.Api.Team.MembersGetInfoV2Result.Decoder, global::Dropbox.Api.Team.MembersGetInfoError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members get info route.</para>
        /// </summary>
        /// <param name="membersGetInfoV2Arg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersGetInfoV2(MembersGetInfoV2Arg membersGetInfoV2Arg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.MembersGetInfoV2Async(membersGetInfoV2Arg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Returns information about multiple team members.</para>
        /// <para>Permission : Team information</para>
        /// <para>This endpoint will return <see
        /// cref="Dropbox.Api.Team.MembersGetInfoItem.IdNotFound" />, for IDs (or emails) that
        /// cannot be matched to a valid team member.</para>
        /// </summary>
        /// <param name="members">List of team members.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersGetInfoError"/>.</exception>
        public t.Task<MembersGetInfoV2Result> MembersGetInfoV2Async(col.IEnumerable<UserSelectorArg> members)
        {
            var membersGetInfoV2Arg = new MembersGetInfoV2Arg(members);

            return this.MembersGetInfoV2Async(membersGetInfoV2Arg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members get info route.</para>
        /// </summary>
        /// <param name="members">List of team members.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersGetInfoV2(col.IEnumerable<UserSelectorArg> members,
                                                      sys.AsyncCallback callback,
                                                      object callbackState = null)
        {
            var membersGetInfoV2Arg = new MembersGetInfoV2Arg(members);

            return this.BeginMembersGetInfoV2(membersGetInfoV2Arg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the members get info route to
        /// complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersGetInfoError"/>.</exception>
        public MembersGetInfoV2Result EndMembersGetInfoV2(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<MembersGetInfoV2Result>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Returns information about multiple team members.</para>
        /// <para>Permission : Team information</para>
        /// <para>This endpoint will return <see
        /// cref="Dropbox.Api.Team.MembersGetInfoItem.IdNotFound" />, for IDs (or emails) that
        /// cannot be matched to a valid team member.</para>
        /// </summary>
        /// <param name="membersGetInfoArgs">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersGetInfoError"/>.</exception>
        public t.Task<col.List<MembersGetInfoItem>> MembersGetInfoAsync(MembersGetInfoArgs membersGetInfoArgs)
        {
            return this.Transport.SendRpcRequestAsync<MembersGetInfoArgs, col.List<MembersGetInfoItem>, MembersGetInfoError>(membersGetInfoArgs, "api", "/team/members/get_info", "team", global::Dropbox.Api.Team.MembersGetInfoArgs.Encoder, enc.Decoder.CreateListDecoder(global::Dropbox.Api.Team.MembersGetInfoItem.Decoder), global::Dropbox.Api.Team.MembersGetInfoError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members get info route.</para>
        /// </summary>
        /// <param name="membersGetInfoArgs">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersGetInfo(MembersGetInfoArgs membersGetInfoArgs, sys.AsyncCallback callback, object state = null)
        {
            var task = this.MembersGetInfoAsync(membersGetInfoArgs);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Returns information about multiple team members.</para>
        /// <para>Permission : Team information</para>
        /// <para>This endpoint will return <see
        /// cref="Dropbox.Api.Team.MembersGetInfoItem.IdNotFound" />, for IDs (or emails) that
        /// cannot be matched to a valid team member.</para>
        /// </summary>
        /// <param name="members">List of team members.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersGetInfoError"/>.</exception>
        public t.Task<col.List<MembersGetInfoItem>> MembersGetInfoAsync(col.IEnumerable<UserSelectorArg> members)
        {
            var membersGetInfoArgs = new MembersGetInfoArgs(members);

            return this.MembersGetInfoAsync(membersGetInfoArgs);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members get info route.</para>
        /// </summary>
        /// <param name="members">List of team members.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersGetInfo(col.IEnumerable<UserSelectorArg> members,
                                                    sys.AsyncCallback callback,
                                                    object callbackState = null)
        {
            var membersGetInfoArgs = new MembersGetInfoArgs(members);

            return this.BeginMembersGetInfo(membersGetInfoArgs, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the members get info route to
        /// complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersGetInfoError"/>.</exception>
        public col.List<MembersGetInfoItem> EndMembersGetInfo(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<col.List<MembersGetInfoItem>>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Lists members of a team.</para>
        /// <para>Permission : Team information.</para>
        /// </summary>
        /// <param name="membersListArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersListError"/>.</exception>
        public t.Task<MembersListV2Result> MembersListV2Async(MembersListArg membersListArg)
        {
            return this.Transport.SendRpcRequestAsync<MembersListArg, MembersListV2Result, MembersListError>(membersListArg, "api", "/team/members/list_v2", "team", global::Dropbox.Api.Team.MembersListArg.Encoder, global::Dropbox.Api.Team.MembersListV2Result.Decoder, global::Dropbox.Api.Team.MembersListError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members list route.</para>
        /// </summary>
        /// <param name="membersListArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersListV2(MembersListArg membersListArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.MembersListV2Async(membersListArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Lists members of a team.</para>
        /// <para>Permission : Team information.</para>
        /// </summary>
        /// <param name="limit">Number of results to return per call.</param>
        /// <param name="includeRemoved">Whether to return removed members.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersListError"/>.</exception>
        public t.Task<MembersListV2Result> MembersListV2Async(uint limit = 1000,
                                                              bool includeRemoved = false)
        {
            var membersListArg = new MembersListArg(limit,
                                                    includeRemoved);

            return this.MembersListV2Async(membersListArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members list route.</para>
        /// </summary>
        /// <param name="limit">Number of results to return per call.</param>
        /// <param name="includeRemoved">Whether to return removed members.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersListV2(uint limit = 1000,
                                                   bool includeRemoved = false,
                                                   sys.AsyncCallback callback = null,
                                                   object callbackState = null)
        {
            var membersListArg = new MembersListArg(limit,
                                                    includeRemoved);

            return this.BeginMembersListV2(membersListArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the members list route to
        /// complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersListError"/>.</exception>
        public MembersListV2Result EndMembersListV2(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<MembersListV2Result>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Lists members of a team.</para>
        /// <para>Permission : Team information.</para>
        /// </summary>
        /// <param name="membersListArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersListError"/>.</exception>
        public t.Task<MembersListResult> MembersListAsync(MembersListArg membersListArg)
        {
            return this.Transport.SendRpcRequestAsync<MembersListArg, MembersListResult, MembersListError>(membersListArg, "api", "/team/members/list", "team", global::Dropbox.Api.Team.MembersListArg.Encoder, global::Dropbox.Api.Team.MembersListResult.Decoder, global::Dropbox.Api.Team.MembersListError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members list route.</para>
        /// </summary>
        /// <param name="membersListArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersList(MembersListArg membersListArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.MembersListAsync(membersListArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Lists members of a team.</para>
        /// <para>Permission : Team information.</para>
        /// </summary>
        /// <param name="limit">Number of results to return per call.</param>
        /// <param name="includeRemoved">Whether to return removed members.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersListError"/>.</exception>
        public t.Task<MembersListResult> MembersListAsync(uint limit = 1000,
                                                          bool includeRemoved = false)
        {
            var membersListArg = new MembersListArg(limit,
                                                    includeRemoved);

            return this.MembersListAsync(membersListArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members list route.</para>
        /// </summary>
        /// <param name="limit">Number of results to return per call.</param>
        /// <param name="includeRemoved">Whether to return removed members.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersList(uint limit = 1000,
                                                 bool includeRemoved = false,
                                                 sys.AsyncCallback callback = null,
                                                 object callbackState = null)
        {
            var membersListArg = new MembersListArg(limit,
                                                    includeRemoved);

            return this.BeginMembersList(membersListArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the members list route to
        /// complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersListError"/>.</exception>
        public MembersListResult EndMembersList(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<MembersListResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Once a cursor has been retrieved from <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.MembersListV2Async" />, use this to
        /// paginate through all team members.</para>
        /// <para>Permission : Team information.</para>
        /// </summary>
        /// <param name="membersListContinueArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersListContinueError"/>.</exception>
        public t.Task<MembersListV2Result> MembersListContinueV2Async(MembersListContinueArg membersListContinueArg)
        {
            return this.Transport.SendRpcRequestAsync<MembersListContinueArg, MembersListV2Result, MembersListContinueError>(membersListContinueArg, "api", "/team/members/list/continue_v2", "team", global::Dropbox.Api.Team.MembersListContinueArg.Encoder, global::Dropbox.Api.Team.MembersListV2Result.Decoder, global::Dropbox.Api.Team.MembersListContinueError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members list continue route.</para>
        /// </summary>
        /// <param name="membersListContinueArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersListContinueV2(MembersListContinueArg membersListContinueArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.MembersListContinueV2Async(membersListContinueArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Once a cursor has been retrieved from <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.MembersListV2Async" />, use this to
        /// paginate through all team members.</para>
        /// <para>Permission : Team information.</para>
        /// </summary>
        /// <param name="cursor">Indicates from what point to get the next set of
        /// members.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersListContinueError"/>.</exception>
        public t.Task<MembersListV2Result> MembersListContinueV2Async(string cursor)
        {
            var membersListContinueArg = new MembersListContinueArg(cursor);

            return this.MembersListContinueV2Async(membersListContinueArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members list continue route.</para>
        /// </summary>
        /// <param name="cursor">Indicates from what point to get the next set of
        /// members.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersListContinueV2(string cursor,
                                                           sys.AsyncCallback callback,
                                                           object callbackState = null)
        {
            var membersListContinueArg = new MembersListContinueArg(cursor);

            return this.BeginMembersListContinueV2(membersListContinueArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the members list continue route to
        /// complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersListContinueError"/>.</exception>
        public MembersListV2Result EndMembersListContinueV2(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<MembersListV2Result>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Once a cursor has been retrieved from <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.MembersListAsync" />, use this to
        /// paginate through all team members.</para>
        /// <para>Permission : Team information.</para>
        /// </summary>
        /// <param name="membersListContinueArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersListContinueError"/>.</exception>
        public t.Task<MembersListResult> MembersListContinueAsync(MembersListContinueArg membersListContinueArg)
        {
            return this.Transport.SendRpcRequestAsync<MembersListContinueArg, MembersListResult, MembersListContinueError>(membersListContinueArg, "api", "/team/members/list/continue", "team", global::Dropbox.Api.Team.MembersListContinueArg.Encoder, global::Dropbox.Api.Team.MembersListResult.Decoder, global::Dropbox.Api.Team.MembersListContinueError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members list continue route.</para>
        /// </summary>
        /// <param name="membersListContinueArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersListContinue(MembersListContinueArg membersListContinueArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.MembersListContinueAsync(membersListContinueArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Once a cursor has been retrieved from <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.MembersListAsync" />, use this to
        /// paginate through all team members.</para>
        /// <para>Permission : Team information.</para>
        /// </summary>
        /// <param name="cursor">Indicates from what point to get the next set of
        /// members.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersListContinueError"/>.</exception>
        public t.Task<MembersListResult> MembersListContinueAsync(string cursor)
        {
            var membersListContinueArg = new MembersListContinueArg(cursor);

            return this.MembersListContinueAsync(membersListContinueArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members list continue route.</para>
        /// </summary>
        /// <param name="cursor">Indicates from what point to get the next set of
        /// members.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersListContinue(string cursor,
                                                         sys.AsyncCallback callback,
                                                         object callbackState = null)
        {
            var membersListContinueArg = new MembersListContinueArg(cursor);

            return this.BeginMembersListContinue(membersListContinueArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the members list continue route to
        /// complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersListContinueError"/>.</exception>
        public MembersListResult EndMembersListContinue(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<MembersListResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Moves removed member's files to a different member. This endpoint initiates
        /// an asynchronous job. To obtain the final result of the job, the client should
        /// periodically poll <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.MembersMoveFormerMemberFilesJobStatusCheckAsync"
        /// />.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <param name="membersDataTransferArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersTransferFormerMembersFilesError"/>.</exception>
        public t.Task<global::Dropbox.Api.Async.LaunchEmptyResult> MembersMoveFormerMemberFilesAsync(MembersDataTransferArg membersDataTransferArg)
        {
            return this.Transport.SendRpcRequestAsync<MembersDataTransferArg, global::Dropbox.Api.Async.LaunchEmptyResult, MembersTransferFormerMembersFilesError>(membersDataTransferArg, "api", "/team/members/move_former_member_files", "team", global::Dropbox.Api.Team.MembersDataTransferArg.Encoder, global::Dropbox.Api.Async.LaunchEmptyResult.Decoder, global::Dropbox.Api.Team.MembersTransferFormerMembersFilesError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members move former member files
        /// route.</para>
        /// </summary>
        /// <param name="membersDataTransferArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersMoveFormerMemberFiles(MembersDataTransferArg membersDataTransferArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.MembersMoveFormerMemberFilesAsync(membersDataTransferArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Moves removed member's files to a different member. This endpoint initiates
        /// an asynchronous job. To obtain the final result of the job, the client should
        /// periodically poll <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.MembersMoveFormerMemberFilesJobStatusCheckAsync"
        /// />.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <param name="user">Identity of user to remove/suspend/have their files
        /// moved.</param>
        /// <param name="transferDestId">Files from the deleted member account will be
        /// transferred to this user.</param>
        /// <param name="transferAdminId">Errors during the transfer process will be sent via
        /// email to this user.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersTransferFormerMembersFilesError"/>.</exception>
        public t.Task<global::Dropbox.Api.Async.LaunchEmptyResult> MembersMoveFormerMemberFilesAsync(UserSelectorArg user,
                                                                                                     UserSelectorArg transferDestId,
                                                                                                     UserSelectorArg transferAdminId)
        {
            var membersDataTransferArg = new MembersDataTransferArg(user,
                                                                    transferDestId,
                                                                    transferAdminId);

            return this.MembersMoveFormerMemberFilesAsync(membersDataTransferArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members move former member files
        /// route.</para>
        /// </summary>
        /// <param name="user">Identity of user to remove/suspend/have their files
        /// moved.</param>
        /// <param name="transferDestId">Files from the deleted member account will be
        /// transferred to this user.</param>
        /// <param name="transferAdminId">Errors during the transfer process will be sent via
        /// email to this user.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersMoveFormerMemberFiles(UserSelectorArg user,
                                                                  UserSelectorArg transferDestId,
                                                                  UserSelectorArg transferAdminId,
                                                                  sys.AsyncCallback callback,
                                                                  object callbackState = null)
        {
            var membersDataTransferArg = new MembersDataTransferArg(user,
                                                                    transferDestId,
                                                                    transferAdminId);

            return this.BeginMembersMoveFormerMemberFiles(membersDataTransferArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the members move former member
        /// files route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersTransferFormerMembersFilesError"/>.</exception>
        public global::Dropbox.Api.Async.LaunchEmptyResult EndMembersMoveFormerMemberFiles(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<global::Dropbox.Api.Async.LaunchEmptyResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Once an async_job_id is returned from <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.MembersMoveFormerMemberFilesAsync" />
        /// , use this to poll the status of the asynchronous request.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <param name="pollArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="global::Dropbox.Api.Async.PollError"/>.</exception>
        public t.Task<global::Dropbox.Api.Async.PollEmptyResult> MembersMoveFormerMemberFilesJobStatusCheckAsync(global::Dropbox.Api.Async.PollArg pollArg)
        {
            return this.Transport.SendRpcRequestAsync<global::Dropbox.Api.Async.PollArg, global::Dropbox.Api.Async.PollEmptyResult, global::Dropbox.Api.Async.PollError>(pollArg, "api", "/team/members/move_former_member_files/job_status/check", "team", global::Dropbox.Api.Async.PollArg.Encoder, global::Dropbox.Api.Async.PollEmptyResult.Decoder, global::Dropbox.Api.Async.PollError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members move former member files job
        /// status check route.</para>
        /// </summary>
        /// <param name="pollArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersMoveFormerMemberFilesJobStatusCheck(global::Dropbox.Api.Async.PollArg pollArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.MembersMoveFormerMemberFilesJobStatusCheckAsync(pollArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Once an async_job_id is returned from <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.MembersMoveFormerMemberFilesAsync" />
        /// , use this to poll the status of the asynchronous request.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <param name="asyncJobId">Id of the asynchronous job. This is the value of a
        /// response returned from the method that launched the job.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="global::Dropbox.Api.Async.PollError"/>.</exception>
        public t.Task<global::Dropbox.Api.Async.PollEmptyResult> MembersMoveFormerMemberFilesJobStatusCheckAsync(string asyncJobId)
        {
            var pollArg = new global::Dropbox.Api.Async.PollArg(asyncJobId);

            return this.MembersMoveFormerMemberFilesJobStatusCheckAsync(pollArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members move former member files job
        /// status check route.</para>
        /// </summary>
        /// <param name="asyncJobId">Id of the asynchronous job. This is the value of a
        /// response returned from the method that launched the job.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersMoveFormerMemberFilesJobStatusCheck(string asyncJobId,
                                                                                sys.AsyncCallback callback,
                                                                                object callbackState = null)
        {
            var pollArg = new global::Dropbox.Api.Async.PollArg(asyncJobId);

            return this.BeginMembersMoveFormerMemberFilesJobStatusCheck(pollArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the members move former member
        /// files job status check route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="global::Dropbox.Api.Async.PollError"/>.</exception>
        public global::Dropbox.Api.Async.PollEmptyResult EndMembersMoveFormerMemberFilesJobStatusCheck(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<global::Dropbox.Api.Async.PollEmptyResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Recover a deleted member.</para>
        /// <para>Permission : Team member management</para>
        /// <para>Exactly one of team_member_id, email, or external_id must be provided to
        /// identify the user account.</para>
        /// </summary>
        /// <param name="membersRecoverArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersRecoverError"/>.</exception>
        public t.Task MembersRecoverAsync(MembersRecoverArg membersRecoverArg)
        {
            return this.Transport.SendRpcRequestAsync<MembersRecoverArg, enc.Empty, MembersRecoverError>(membersRecoverArg, "api", "/team/members/recover", "team", global::Dropbox.Api.Team.MembersRecoverArg.Encoder, enc.EmptyDecoder.Instance, global::Dropbox.Api.Team.MembersRecoverError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members recover route.</para>
        /// </summary>
        /// <param name="membersRecoverArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersRecover(MembersRecoverArg membersRecoverArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.MembersRecoverAsync(membersRecoverArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Recover a deleted member.</para>
        /// <para>Permission : Team member management</para>
        /// <para>Exactly one of team_member_id, email, or external_id must be provided to
        /// identify the user account.</para>
        /// </summary>
        /// <param name="user">Identity of user to recover.</param>
        /// <returns>The task that represents the asynchronous send operation.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersRecoverError"/>.</exception>
        public t.Task MembersRecoverAsync(UserSelectorArg user)
        {
            var membersRecoverArg = new MembersRecoverArg(user);

            return this.MembersRecoverAsync(membersRecoverArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members recover route.</para>
        /// </summary>
        /// <param name="user">Identity of user to recover.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersRecover(UserSelectorArg user,
                                                    sys.AsyncCallback callback,
                                                    object callbackState = null)
        {
            var membersRecoverArg = new MembersRecoverArg(user);

            return this.BeginMembersRecover(membersRecoverArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the members recover route to
        /// complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersRecoverError"/>.</exception>
        public void EndMembersRecover(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }
        }

        /// <summary>
        /// <para>Removes a member from a team.</para>
        /// <para>Permission : Team member management</para>
        /// <para>Exactly one of team_member_id, email, or external_id must be provided to
        /// identify the user account.</para>
        /// <para>Accounts can be recovered via <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.MembersRecoverAsync" /> for a 7 day
        /// period or until the account has been permanently deleted or transferred to another
        /// account (whichever comes first). Calling <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.MembersAddAsync" /> while a user is
        /// still recoverable on your team will return with <see
        /// cref="Dropbox.Api.Team.MemberAddResult.UserAlreadyOnTeam" />.</para>
        /// <para>Accounts can have their files transferred via the admin console for a limited
        /// time, based on the version history length associated with the team (180 days for
        /// most teams).</para>
        /// <para>This endpoint may initiate an asynchronous job. To obtain the final result of
        /// the job, the client should periodically poll <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.MembersRemoveJobStatusGetAsync"
        /// />.</para>
        /// </summary>
        /// <param name="membersRemoveArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersRemoveError"/>.</exception>
        public t.Task<global::Dropbox.Api.Async.LaunchEmptyResult> MembersRemoveAsync(MembersRemoveArg membersRemoveArg)
        {
            return this.Transport.SendRpcRequestAsync<MembersRemoveArg, global::Dropbox.Api.Async.LaunchEmptyResult, MembersRemoveError>(membersRemoveArg, "api", "/team/members/remove", "team", global::Dropbox.Api.Team.MembersRemoveArg.Encoder, global::Dropbox.Api.Async.LaunchEmptyResult.Decoder, global::Dropbox.Api.Team.MembersRemoveError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members remove route.</para>
        /// </summary>
        /// <param name="membersRemoveArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersRemove(MembersRemoveArg membersRemoveArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.MembersRemoveAsync(membersRemoveArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Removes a member from a team.</para>
        /// <para>Permission : Team member management</para>
        /// <para>Exactly one of team_member_id, email, or external_id must be provided to
        /// identify the user account.</para>
        /// <para>Accounts can be recovered via <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.MembersRecoverAsync" /> for a 7 day
        /// period or until the account has been permanently deleted or transferred to another
        /// account (whichever comes first). Calling <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.MembersAddAsync" /> while a user is
        /// still recoverable on your team will return with <see
        /// cref="Dropbox.Api.Team.MemberAddResult.UserAlreadyOnTeam" />.</para>
        /// <para>Accounts can have their files transferred via the admin console for a limited
        /// time, based on the version history length associated with the team (180 days for
        /// most teams).</para>
        /// <para>This endpoint may initiate an asynchronous job. To obtain the final result of
        /// the job, the client should periodically poll <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.MembersRemoveJobStatusGetAsync"
        /// />.</para>
        /// </summary>
        /// <param name="user">Identity of user to remove/suspend/have their files
        /// moved.</param>
        /// <param name="wipeData">If provided, controls if the user's data will be deleted on
        /// their linked devices.</param>
        /// <param name="transferDestId">If provided, files from the deleted member account
        /// will be transferred to this user.</param>
        /// <param name="transferAdminId">If provided, errors during the transfer process will
        /// be sent via email to this user. If the transfer_dest_id argument was provided, then
        /// this argument must be provided as well.</param>
        /// <param name="keepAccount">Downgrade the member to a Basic account. The user will
        /// retain the email address associated with their Dropbox  account and data in their
        /// account that is not restricted to team members. In order to keep the account the
        /// argument <paramref name="wipeData" /> should be set to <c>false</c>.</param>
        /// <param name="retainTeamShares">If provided, allows removed users to keep access to
        /// Dropbox folders (not Dropbox Paper folders) already explicitly shared with them
        /// (not via a group) when they are downgraded to a Basic account. Users will not
        /// retain access to folders that do not allow external sharing. In order to keep the
        /// sharing relationships, the arguments <paramref name="wipeData" /> should be set to
        /// <c>false</c> and <paramref name="keepAccount" /> should be set to
        /// <c>true</c>.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersRemoveError"/>.</exception>
        public t.Task<global::Dropbox.Api.Async.LaunchEmptyResult> MembersRemoveAsync(UserSelectorArg user,
                                                                                      bool wipeData = true,
                                                                                      UserSelectorArg transferDestId = null,
                                                                                      UserSelectorArg transferAdminId = null,
                                                                                      bool keepAccount = false,
                                                                                      bool retainTeamShares = false)
        {
            var membersRemoveArg = new MembersRemoveArg(user,
                                                        wipeData,
                                                        transferDestId,
                                                        transferAdminId,
                                                        keepAccount,
                                                        retainTeamShares);

            return this.MembersRemoveAsync(membersRemoveArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members remove route.</para>
        /// </summary>
        /// <param name="user">Identity of user to remove/suspend/have their files
        /// moved.</param>
        /// <param name="wipeData">If provided, controls if the user's data will be deleted on
        /// their linked devices.</param>
        /// <param name="transferDestId">If provided, files from the deleted member account
        /// will be transferred to this user.</param>
        /// <param name="transferAdminId">If provided, errors during the transfer process will
        /// be sent via email to this user. If the transfer_dest_id argument was provided, then
        /// this argument must be provided as well.</param>
        /// <param name="keepAccount">Downgrade the member to a Basic account. The user will
        /// retain the email address associated with their Dropbox  account and data in their
        /// account that is not restricted to team members. In order to keep the account the
        /// argument <paramref name="wipeData" /> should be set to <c>false</c>.</param>
        /// <param name="retainTeamShares">If provided, allows removed users to keep access to
        /// Dropbox folders (not Dropbox Paper folders) already explicitly shared with them
        /// (not via a group) when they are downgraded to a Basic account. Users will not
        /// retain access to folders that do not allow external sharing. In order to keep the
        /// sharing relationships, the arguments <paramref name="wipeData" /> should be set to
        /// <c>false</c> and <paramref name="keepAccount" /> should be set to
        /// <c>true</c>.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersRemove(UserSelectorArg user,
                                                   bool wipeData = true,
                                                   UserSelectorArg transferDestId = null,
                                                   UserSelectorArg transferAdminId = null,
                                                   bool keepAccount = false,
                                                   bool retainTeamShares = false,
                                                   sys.AsyncCallback callback = null,
                                                   object callbackState = null)
        {
            var membersRemoveArg = new MembersRemoveArg(user,
                                                        wipeData,
                                                        transferDestId,
                                                        transferAdminId,
                                                        keepAccount,
                                                        retainTeamShares);

            return this.BeginMembersRemove(membersRemoveArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the members remove route to
        /// complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersRemoveError"/>.</exception>
        public global::Dropbox.Api.Async.LaunchEmptyResult EndMembersRemove(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<global::Dropbox.Api.Async.LaunchEmptyResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Once an async_job_id is returned from <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.MembersRemoveAsync" /> , use this to
        /// poll the status of the asynchronous request.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <param name="pollArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="global::Dropbox.Api.Async.PollError"/>.</exception>
        public t.Task<global::Dropbox.Api.Async.PollEmptyResult> MembersRemoveJobStatusGetAsync(global::Dropbox.Api.Async.PollArg pollArg)
        {
            return this.Transport.SendRpcRequestAsync<global::Dropbox.Api.Async.PollArg, global::Dropbox.Api.Async.PollEmptyResult, global::Dropbox.Api.Async.PollError>(pollArg, "api", "/team/members/remove/job_status/get", "team", global::Dropbox.Api.Async.PollArg.Encoder, global::Dropbox.Api.Async.PollEmptyResult.Decoder, global::Dropbox.Api.Async.PollError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members remove job status get
        /// route.</para>
        /// </summary>
        /// <param name="pollArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersRemoveJobStatusGet(global::Dropbox.Api.Async.PollArg pollArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.MembersRemoveJobStatusGetAsync(pollArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Once an async_job_id is returned from <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.MembersRemoveAsync" /> , use this to
        /// poll the status of the asynchronous request.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <param name="asyncJobId">Id of the asynchronous job. This is the value of a
        /// response returned from the method that launched the job.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="global::Dropbox.Api.Async.PollError"/>.</exception>
        public t.Task<global::Dropbox.Api.Async.PollEmptyResult> MembersRemoveJobStatusGetAsync(string asyncJobId)
        {
            var pollArg = new global::Dropbox.Api.Async.PollArg(asyncJobId);

            return this.MembersRemoveJobStatusGetAsync(pollArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members remove job status get
        /// route.</para>
        /// </summary>
        /// <param name="asyncJobId">Id of the asynchronous job. This is the value of a
        /// response returned from the method that launched the job.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersRemoveJobStatusGet(string asyncJobId,
                                                               sys.AsyncCallback callback,
                                                               object callbackState = null)
        {
            var pollArg = new global::Dropbox.Api.Async.PollArg(asyncJobId);

            return this.BeginMembersRemoveJobStatusGet(pollArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the members remove job status get
        /// route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="global::Dropbox.Api.Async.PollError"/>.</exception>
        public global::Dropbox.Api.Async.PollEmptyResult EndMembersRemoveJobStatusGet(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<global::Dropbox.Api.Async.PollEmptyResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Add secondary emails to users.</para>
        /// <para>Permission : Team member management.</para>
        /// <para>Emails that are on verified domains will be verified automatically. For each
        /// email address not on a verified domain a verification email will be sent.</para>
        /// </summary>
        /// <param name="addSecondaryEmailsArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="AddSecondaryEmailsError"/>.</exception>
        public t.Task<AddSecondaryEmailsResult> MembersSecondaryEmailsAddAsync(AddSecondaryEmailsArg addSecondaryEmailsArg)
        {
            return this.Transport.SendRpcRequestAsync<AddSecondaryEmailsArg, AddSecondaryEmailsResult, AddSecondaryEmailsError>(addSecondaryEmailsArg, "api", "/team/members/secondary_emails/add", "team", global::Dropbox.Api.Team.AddSecondaryEmailsArg.Encoder, global::Dropbox.Api.Team.AddSecondaryEmailsResult.Decoder, global::Dropbox.Api.Team.AddSecondaryEmailsError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members secondary emails add route.</para>
        /// </summary>
        /// <param name="addSecondaryEmailsArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersSecondaryEmailsAdd(AddSecondaryEmailsArg addSecondaryEmailsArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.MembersSecondaryEmailsAddAsync(addSecondaryEmailsArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Add secondary emails to users.</para>
        /// <para>Permission : Team member management.</para>
        /// <para>Emails that are on verified domains will be verified automatically. For each
        /// email address not on a verified domain a verification email will be sent.</para>
        /// </summary>
        /// <param name="newSecondaryEmails">List of users and secondary emails to add.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="AddSecondaryEmailsError"/>.</exception>
        public t.Task<AddSecondaryEmailsResult> MembersSecondaryEmailsAddAsync(col.IEnumerable<UserSecondaryEmailsArg> newSecondaryEmails)
        {
            var addSecondaryEmailsArg = new AddSecondaryEmailsArg(newSecondaryEmails);

            return this.MembersSecondaryEmailsAddAsync(addSecondaryEmailsArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members secondary emails add route.</para>
        /// </summary>
        /// <param name="newSecondaryEmails">List of users and secondary emails to add.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersSecondaryEmailsAdd(col.IEnumerable<UserSecondaryEmailsArg> newSecondaryEmails,
                                                               sys.AsyncCallback callback,
                                                               object callbackState = null)
        {
            var addSecondaryEmailsArg = new AddSecondaryEmailsArg(newSecondaryEmails);

            return this.BeginMembersSecondaryEmailsAdd(addSecondaryEmailsArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the members secondary emails add
        /// route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="AddSecondaryEmailsError"/>.</exception>
        public AddSecondaryEmailsResult EndMembersSecondaryEmailsAdd(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<AddSecondaryEmailsResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Delete secondary emails from users</para>
        /// <para>Permission : Team member management.</para>
        /// <para>Users will be notified of deletions of verified secondary emails at both the
        /// secondary email and their primary email.</para>
        /// </summary>
        /// <param name="deleteSecondaryEmailsArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        public t.Task<DeleteSecondaryEmailsResult> MembersSecondaryEmailsDeleteAsync(DeleteSecondaryEmailsArg deleteSecondaryEmailsArg)
        {
            return this.Transport.SendRpcRequestAsync<DeleteSecondaryEmailsArg, DeleteSecondaryEmailsResult, enc.Empty>(deleteSecondaryEmailsArg, "api", "/team/members/secondary_emails/delete", "team", global::Dropbox.Api.Team.DeleteSecondaryEmailsArg.Encoder, global::Dropbox.Api.Team.DeleteSecondaryEmailsResult.Decoder, enc.EmptyDecoder.Instance);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members secondary emails delete
        /// route.</para>
        /// </summary>
        /// <param name="deleteSecondaryEmailsArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersSecondaryEmailsDelete(DeleteSecondaryEmailsArg deleteSecondaryEmailsArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.MembersSecondaryEmailsDeleteAsync(deleteSecondaryEmailsArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Delete secondary emails from users</para>
        /// <para>Permission : Team member management.</para>
        /// <para>Users will be notified of deletions of verified secondary emails at both the
        /// secondary email and their primary email.</para>
        /// </summary>
        /// <param name="emailsToDelete">List of users and their secondary emails to
        /// delete.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        public t.Task<DeleteSecondaryEmailsResult> MembersSecondaryEmailsDeleteAsync(col.IEnumerable<UserSecondaryEmailsArg> emailsToDelete)
        {
            var deleteSecondaryEmailsArg = new DeleteSecondaryEmailsArg(emailsToDelete);

            return this.MembersSecondaryEmailsDeleteAsync(deleteSecondaryEmailsArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members secondary emails delete
        /// route.</para>
        /// </summary>
        /// <param name="emailsToDelete">List of users and their secondary emails to
        /// delete.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersSecondaryEmailsDelete(col.IEnumerable<UserSecondaryEmailsArg> emailsToDelete,
                                                                  sys.AsyncCallback callback,
                                                                  object callbackState = null)
        {
            var deleteSecondaryEmailsArg = new DeleteSecondaryEmailsArg(emailsToDelete);

            return this.BeginMembersSecondaryEmailsDelete(deleteSecondaryEmailsArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the members secondary emails
        /// delete route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        public DeleteSecondaryEmailsResult EndMembersSecondaryEmailsDelete(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<DeleteSecondaryEmailsResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Resend secondary email verification emails.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <param name="resendVerificationEmailArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        public t.Task<ResendVerificationEmailResult> MembersSecondaryEmailsResendVerificationEmailsAsync(ResendVerificationEmailArg resendVerificationEmailArg)
        {
            return this.Transport.SendRpcRequestAsync<ResendVerificationEmailArg, ResendVerificationEmailResult, enc.Empty>(resendVerificationEmailArg, "api", "/team/members/secondary_emails/resend_verification_emails", "team", global::Dropbox.Api.Team.ResendVerificationEmailArg.Encoder, global::Dropbox.Api.Team.ResendVerificationEmailResult.Decoder, enc.EmptyDecoder.Instance);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members secondary emails resend
        /// verification emails route.</para>
        /// </summary>
        /// <param name="resendVerificationEmailArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersSecondaryEmailsResendVerificationEmails(ResendVerificationEmailArg resendVerificationEmailArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.MembersSecondaryEmailsResendVerificationEmailsAsync(resendVerificationEmailArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Resend secondary email verification emails.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <param name="emailsToResend">List of users and secondary emails to resend
        /// verification emails to.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        public t.Task<ResendVerificationEmailResult> MembersSecondaryEmailsResendVerificationEmailsAsync(col.IEnumerable<UserSecondaryEmailsArg> emailsToResend)
        {
            var resendVerificationEmailArg = new ResendVerificationEmailArg(emailsToResend);

            return this.MembersSecondaryEmailsResendVerificationEmailsAsync(resendVerificationEmailArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members secondary emails resend
        /// verification emails route.</para>
        /// </summary>
        /// <param name="emailsToResend">List of users and secondary emails to resend
        /// verification emails to.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersSecondaryEmailsResendVerificationEmails(col.IEnumerable<UserSecondaryEmailsArg> emailsToResend,
                                                                                    sys.AsyncCallback callback,
                                                                                    object callbackState = null)
        {
            var resendVerificationEmailArg = new ResendVerificationEmailArg(emailsToResend);

            return this.BeginMembersSecondaryEmailsResendVerificationEmails(resendVerificationEmailArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the members secondary emails
        /// resend verification emails route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        public ResendVerificationEmailResult EndMembersSecondaryEmailsResendVerificationEmails(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<ResendVerificationEmailResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Sends welcome email to pending team member.</para>
        /// <para>Permission : Team member management</para>
        /// <para>Exactly one of team_member_id, email, or external_id must be provided to
        /// identify the user account.</para>
        /// <para>No-op if team member is not pending.</para>
        /// </summary>
        /// <param name="userSelectorArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersSendWelcomeError"/>.</exception>
        public t.Task MembersSendWelcomeEmailAsync(UserSelectorArg userSelectorArg)
        {
            return this.Transport.SendRpcRequestAsync<UserSelectorArg, enc.Empty, MembersSendWelcomeError>(userSelectorArg, "api", "/team/members/send_welcome_email", "team", global::Dropbox.Api.Team.UserSelectorArg.Encoder, enc.EmptyDecoder.Instance, global::Dropbox.Api.Team.MembersSendWelcomeError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members send welcome email route.</para>
        /// </summary>
        /// <param name="userSelectorArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersSendWelcomeEmail(UserSelectorArg userSelectorArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.MembersSendWelcomeEmailAsync(userSelectorArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the members send welcome email
        /// route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersSendWelcomeError"/>.</exception>
        public void EndMembersSendWelcomeEmail(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }
        }

        /// <summary>
        /// <para>Updates a team member's permissions.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <param name="membersSetPermissions2Arg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersSetPermissions2Error"/>.</exception>
        public t.Task<MembersSetPermissions2Result> MembersSetAdminPermissionsV2Async(MembersSetPermissions2Arg membersSetPermissions2Arg)
        {
            return this.Transport.SendRpcRequestAsync<MembersSetPermissions2Arg, MembersSetPermissions2Result, MembersSetPermissions2Error>(membersSetPermissions2Arg, "api", "/team/members/set_admin_permissions_v2", "team", global::Dropbox.Api.Team.MembersSetPermissions2Arg.Encoder, global::Dropbox.Api.Team.MembersSetPermissions2Result.Decoder, global::Dropbox.Api.Team.MembersSetPermissions2Error.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members set admin permissions
        /// route.</para>
        /// </summary>
        /// <param name="membersSetPermissions2Arg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersSetAdminPermissionsV2(MembersSetPermissions2Arg membersSetPermissions2Arg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.MembersSetAdminPermissionsV2Async(membersSetPermissions2Arg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Updates a team member's permissions.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <param name="user">Identity of user whose role will be set.</param>
        /// <param name="newRoles">The new roles for the member. Send empty list to make user
        /// member only. For now, only up to one role is allowed.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersSetPermissions2Error"/>.</exception>
        public t.Task<MembersSetPermissions2Result> MembersSetAdminPermissionsV2Async(UserSelectorArg user,
                                                                                      col.IEnumerable<string> newRoles = null)
        {
            var membersSetPermissions2Arg = new MembersSetPermissions2Arg(user,
                                                                          newRoles);

            return this.MembersSetAdminPermissionsV2Async(membersSetPermissions2Arg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members set admin permissions
        /// route.</para>
        /// </summary>
        /// <param name="user">Identity of user whose role will be set.</param>
        /// <param name="newRoles">The new roles for the member. Send empty list to make user
        /// member only. For now, only up to one role is allowed.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersSetAdminPermissionsV2(UserSelectorArg user,
                                                                  col.IEnumerable<string> newRoles = null,
                                                                  sys.AsyncCallback callback = null,
                                                                  object callbackState = null)
        {
            var membersSetPermissions2Arg = new MembersSetPermissions2Arg(user,
                                                                          newRoles);

            return this.BeginMembersSetAdminPermissionsV2(membersSetPermissions2Arg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the members set admin permissions
        /// route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersSetPermissions2Error"/>.</exception>
        public MembersSetPermissions2Result EndMembersSetAdminPermissionsV2(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<MembersSetPermissions2Result>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Updates a team member's permissions.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <param name="membersSetPermissionsArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersSetPermissionsError"/>.</exception>
        public t.Task<MembersSetPermissionsResult> MembersSetAdminPermissionsAsync(MembersSetPermissionsArg membersSetPermissionsArg)
        {
            return this.Transport.SendRpcRequestAsync<MembersSetPermissionsArg, MembersSetPermissionsResult, MembersSetPermissionsError>(membersSetPermissionsArg, "api", "/team/members/set_admin_permissions", "team", global::Dropbox.Api.Team.MembersSetPermissionsArg.Encoder, global::Dropbox.Api.Team.MembersSetPermissionsResult.Decoder, global::Dropbox.Api.Team.MembersSetPermissionsError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members set admin permissions
        /// route.</para>
        /// </summary>
        /// <param name="membersSetPermissionsArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersSetAdminPermissions(MembersSetPermissionsArg membersSetPermissionsArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.MembersSetAdminPermissionsAsync(membersSetPermissionsArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Updates a team member's permissions.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <param name="user">Identity of user whose role will be set.</param>
        /// <param name="newRole">The new role of the member.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersSetPermissionsError"/>.</exception>
        public t.Task<MembersSetPermissionsResult> MembersSetAdminPermissionsAsync(UserSelectorArg user,
                                                                                   AdminTier newRole)
        {
            var membersSetPermissionsArg = new MembersSetPermissionsArg(user,
                                                                        newRole);

            return this.MembersSetAdminPermissionsAsync(membersSetPermissionsArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members set admin permissions
        /// route.</para>
        /// </summary>
        /// <param name="user">Identity of user whose role will be set.</param>
        /// <param name="newRole">The new role of the member.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersSetAdminPermissions(UserSelectorArg user,
                                                                AdminTier newRole,
                                                                sys.AsyncCallback callback,
                                                                object callbackState = null)
        {
            var membersSetPermissionsArg = new MembersSetPermissionsArg(user,
                                                                        newRole);

            return this.BeginMembersSetAdminPermissions(membersSetPermissionsArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the members set admin permissions
        /// route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersSetPermissionsError"/>.</exception>
        public MembersSetPermissionsResult EndMembersSetAdminPermissions(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<MembersSetPermissionsResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Updates a team member's profile.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <param name="membersSetProfileArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersSetProfileError"/>.</exception>
        public t.Task<TeamMemberInfoV2Result> MembersSetProfileV2Async(MembersSetProfileArg membersSetProfileArg)
        {
            return this.Transport.SendRpcRequestAsync<MembersSetProfileArg, TeamMemberInfoV2Result, MembersSetProfileError>(membersSetProfileArg, "api", "/team/members/set_profile_v2", "team", global::Dropbox.Api.Team.MembersSetProfileArg.Encoder, global::Dropbox.Api.Team.TeamMemberInfoV2Result.Decoder, global::Dropbox.Api.Team.MembersSetProfileError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members set profile route.</para>
        /// </summary>
        /// <param name="membersSetProfileArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersSetProfileV2(MembersSetProfileArg membersSetProfileArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.MembersSetProfileV2Async(membersSetProfileArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Updates a team member's profile.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <param name="user">Identity of user whose profile will be set.</param>
        /// <param name="newEmail">New email for member.</param>
        /// <param name="newExternalId">New external ID for member.</param>
        /// <param name="newGivenName">New given name for member.</param>
        /// <param name="newSurname">New surname for member.</param>
        /// <param name="newPersistentId">New persistent ID. This field only available to teams
        /// using persistent ID SAML configuration.</param>
        /// <param name="newIsDirectoryRestricted">New value for whether the user is a
        /// directory restricted user.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersSetProfileError"/>.</exception>
        public t.Task<TeamMemberInfoV2Result> MembersSetProfileV2Async(UserSelectorArg user,
                                                                       string newEmail = null,
                                                                       string newExternalId = null,
                                                                       string newGivenName = null,
                                                                       string newSurname = null,
                                                                       string newPersistentId = null,
                                                                       bool? newIsDirectoryRestricted = null)
        {
            var membersSetProfileArg = new MembersSetProfileArg(user,
                                                                newEmail,
                                                                newExternalId,
                                                                newGivenName,
                                                                newSurname,
                                                                newPersistentId,
                                                                newIsDirectoryRestricted);

            return this.MembersSetProfileV2Async(membersSetProfileArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members set profile route.</para>
        /// </summary>
        /// <param name="user">Identity of user whose profile will be set.</param>
        /// <param name="newEmail">New email for member.</param>
        /// <param name="newExternalId">New external ID for member.</param>
        /// <param name="newGivenName">New given name for member.</param>
        /// <param name="newSurname">New surname for member.</param>
        /// <param name="newPersistentId">New persistent ID. This field only available to teams
        /// using persistent ID SAML configuration.</param>
        /// <param name="newIsDirectoryRestricted">New value for whether the user is a
        /// directory restricted user.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersSetProfileV2(UserSelectorArg user,
                                                         string newEmail = null,
                                                         string newExternalId = null,
                                                         string newGivenName = null,
                                                         string newSurname = null,
                                                         string newPersistentId = null,
                                                         bool? newIsDirectoryRestricted = null,
                                                         sys.AsyncCallback callback = null,
                                                         object callbackState = null)
        {
            var membersSetProfileArg = new MembersSetProfileArg(user,
                                                                newEmail,
                                                                newExternalId,
                                                                newGivenName,
                                                                newSurname,
                                                                newPersistentId,
                                                                newIsDirectoryRestricted);

            return this.BeginMembersSetProfileV2(membersSetProfileArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the members set profile route to
        /// complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersSetProfileError"/>.</exception>
        public TeamMemberInfoV2Result EndMembersSetProfileV2(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<TeamMemberInfoV2Result>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Updates a team member's profile.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <param name="membersSetProfileArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersSetProfileError"/>.</exception>
        public t.Task<TeamMemberInfo> MembersSetProfileAsync(MembersSetProfileArg membersSetProfileArg)
        {
            return this.Transport.SendRpcRequestAsync<MembersSetProfileArg, TeamMemberInfo, MembersSetProfileError>(membersSetProfileArg, "api", "/team/members/set_profile", "team", global::Dropbox.Api.Team.MembersSetProfileArg.Encoder, global::Dropbox.Api.Team.TeamMemberInfo.Decoder, global::Dropbox.Api.Team.MembersSetProfileError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members set profile route.</para>
        /// </summary>
        /// <param name="membersSetProfileArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersSetProfile(MembersSetProfileArg membersSetProfileArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.MembersSetProfileAsync(membersSetProfileArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Updates a team member's profile.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <param name="user">Identity of user whose profile will be set.</param>
        /// <param name="newEmail">New email for member.</param>
        /// <param name="newExternalId">New external ID for member.</param>
        /// <param name="newGivenName">New given name for member.</param>
        /// <param name="newSurname">New surname for member.</param>
        /// <param name="newPersistentId">New persistent ID. This field only available to teams
        /// using persistent ID SAML configuration.</param>
        /// <param name="newIsDirectoryRestricted">New value for whether the user is a
        /// directory restricted user.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersSetProfileError"/>.</exception>
        public t.Task<TeamMemberInfo> MembersSetProfileAsync(UserSelectorArg user,
                                                             string newEmail = null,
                                                             string newExternalId = null,
                                                             string newGivenName = null,
                                                             string newSurname = null,
                                                             string newPersistentId = null,
                                                             bool? newIsDirectoryRestricted = null)
        {
            var membersSetProfileArg = new MembersSetProfileArg(user,
                                                                newEmail,
                                                                newExternalId,
                                                                newGivenName,
                                                                newSurname,
                                                                newPersistentId,
                                                                newIsDirectoryRestricted);

            return this.MembersSetProfileAsync(membersSetProfileArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members set profile route.</para>
        /// </summary>
        /// <param name="user">Identity of user whose profile will be set.</param>
        /// <param name="newEmail">New email for member.</param>
        /// <param name="newExternalId">New external ID for member.</param>
        /// <param name="newGivenName">New given name for member.</param>
        /// <param name="newSurname">New surname for member.</param>
        /// <param name="newPersistentId">New persistent ID. This field only available to teams
        /// using persistent ID SAML configuration.</param>
        /// <param name="newIsDirectoryRestricted">New value for whether the user is a
        /// directory restricted user.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersSetProfile(UserSelectorArg user,
                                                       string newEmail = null,
                                                       string newExternalId = null,
                                                       string newGivenName = null,
                                                       string newSurname = null,
                                                       string newPersistentId = null,
                                                       bool? newIsDirectoryRestricted = null,
                                                       sys.AsyncCallback callback = null,
                                                       object callbackState = null)
        {
            var membersSetProfileArg = new MembersSetProfileArg(user,
                                                                newEmail,
                                                                newExternalId,
                                                                newGivenName,
                                                                newSurname,
                                                                newPersistentId,
                                                                newIsDirectoryRestricted);

            return this.BeginMembersSetProfile(membersSetProfileArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the members set profile route to
        /// complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersSetProfileError"/>.</exception>
        public TeamMemberInfo EndMembersSetProfile(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<TeamMemberInfo>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Updates a team member's profile photo.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <param name="membersSetProfilePhotoArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersSetProfilePhotoError"/>.</exception>
        public t.Task<TeamMemberInfoV2Result> MembersSetProfilePhotoV2Async(MembersSetProfilePhotoArg membersSetProfilePhotoArg)
        {
            return this.Transport.SendRpcRequestAsync<MembersSetProfilePhotoArg, TeamMemberInfoV2Result, MembersSetProfilePhotoError>(membersSetProfilePhotoArg, "api", "/team/members/set_profile_photo_v2", "team", global::Dropbox.Api.Team.MembersSetProfilePhotoArg.Encoder, global::Dropbox.Api.Team.TeamMemberInfoV2Result.Decoder, global::Dropbox.Api.Team.MembersSetProfilePhotoError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members set profile photo route.</para>
        /// </summary>
        /// <param name="membersSetProfilePhotoArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersSetProfilePhotoV2(MembersSetProfilePhotoArg membersSetProfilePhotoArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.MembersSetProfilePhotoV2Async(membersSetProfilePhotoArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Updates a team member's profile photo.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <param name="user">Identity of the user whose profile photo will be set.</param>
        /// <param name="photo">Image to set as the member's new profile photo.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersSetProfilePhotoError"/>.</exception>
        public t.Task<TeamMemberInfoV2Result> MembersSetProfilePhotoV2Async(UserSelectorArg user,
                                                                            global::Dropbox.Api.Account.PhotoSourceArg photo)
        {
            var membersSetProfilePhotoArg = new MembersSetProfilePhotoArg(user,
                                                                          photo);

            return this.MembersSetProfilePhotoV2Async(membersSetProfilePhotoArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members set profile photo route.</para>
        /// </summary>
        /// <param name="user">Identity of the user whose profile photo will be set.</param>
        /// <param name="photo">Image to set as the member's new profile photo.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersSetProfilePhotoV2(UserSelectorArg user,
                                                              global::Dropbox.Api.Account.PhotoSourceArg photo,
                                                              sys.AsyncCallback callback,
                                                              object callbackState = null)
        {
            var membersSetProfilePhotoArg = new MembersSetProfilePhotoArg(user,
                                                                          photo);

            return this.BeginMembersSetProfilePhotoV2(membersSetProfilePhotoArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the members set profile photo
        /// route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersSetProfilePhotoError"/>.</exception>
        public TeamMemberInfoV2Result EndMembersSetProfilePhotoV2(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<TeamMemberInfoV2Result>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Updates a team member's profile photo.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <param name="membersSetProfilePhotoArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersSetProfilePhotoError"/>.</exception>
        public t.Task<TeamMemberInfo> MembersSetProfilePhotoAsync(MembersSetProfilePhotoArg membersSetProfilePhotoArg)
        {
            return this.Transport.SendRpcRequestAsync<MembersSetProfilePhotoArg, TeamMemberInfo, MembersSetProfilePhotoError>(membersSetProfilePhotoArg, "api", "/team/members/set_profile_photo", "team", global::Dropbox.Api.Team.MembersSetProfilePhotoArg.Encoder, global::Dropbox.Api.Team.TeamMemberInfo.Decoder, global::Dropbox.Api.Team.MembersSetProfilePhotoError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members set profile photo route.</para>
        /// </summary>
        /// <param name="membersSetProfilePhotoArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersSetProfilePhoto(MembersSetProfilePhotoArg membersSetProfilePhotoArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.MembersSetProfilePhotoAsync(membersSetProfilePhotoArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Updates a team member's profile photo.</para>
        /// <para>Permission : Team member management.</para>
        /// </summary>
        /// <param name="user">Identity of the user whose profile photo will be set.</param>
        /// <param name="photo">Image to set as the member's new profile photo.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersSetProfilePhotoError"/>.</exception>
        public t.Task<TeamMemberInfo> MembersSetProfilePhotoAsync(UserSelectorArg user,
                                                                  global::Dropbox.Api.Account.PhotoSourceArg photo)
        {
            var membersSetProfilePhotoArg = new MembersSetProfilePhotoArg(user,
                                                                          photo);

            return this.MembersSetProfilePhotoAsync(membersSetProfilePhotoArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members set profile photo route.</para>
        /// </summary>
        /// <param name="user">Identity of the user whose profile photo will be set.</param>
        /// <param name="photo">Image to set as the member's new profile photo.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersSetProfilePhoto(UserSelectorArg user,
                                                            global::Dropbox.Api.Account.PhotoSourceArg photo,
                                                            sys.AsyncCallback callback,
                                                            object callbackState = null)
        {
            var membersSetProfilePhotoArg = new MembersSetProfilePhotoArg(user,
                                                                          photo);

            return this.BeginMembersSetProfilePhoto(membersSetProfilePhotoArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the members set profile photo
        /// route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersSetProfilePhotoError"/>.</exception>
        public TeamMemberInfo EndMembersSetProfilePhoto(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<TeamMemberInfo>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Suspend a member from a team.</para>
        /// <para>Permission : Team member management</para>
        /// <para>Exactly one of team_member_id, email, or external_id must be provided to
        /// identify the user account.</para>
        /// </summary>
        /// <param name="membersDeactivateArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersSuspendError"/>.</exception>
        public t.Task MembersSuspendAsync(MembersDeactivateArg membersDeactivateArg)
        {
            return this.Transport.SendRpcRequestAsync<MembersDeactivateArg, enc.Empty, MembersSuspendError>(membersDeactivateArg, "api", "/team/members/suspend", "team", global::Dropbox.Api.Team.MembersDeactivateArg.Encoder, enc.EmptyDecoder.Instance, global::Dropbox.Api.Team.MembersSuspendError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members suspend route.</para>
        /// </summary>
        /// <param name="membersDeactivateArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersSuspend(MembersDeactivateArg membersDeactivateArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.MembersSuspendAsync(membersDeactivateArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Suspend a member from a team.</para>
        /// <para>Permission : Team member management</para>
        /// <para>Exactly one of team_member_id, email, or external_id must be provided to
        /// identify the user account.</para>
        /// </summary>
        /// <param name="user">Identity of user to remove/suspend/have their files
        /// moved.</param>
        /// <param name="wipeData">If provided, controls if the user's data will be deleted on
        /// their linked devices.</param>
        /// <returns>The task that represents the asynchronous send operation.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersSuspendError"/>.</exception>
        public t.Task MembersSuspendAsync(UserSelectorArg user,
                                          bool wipeData = true)
        {
            var membersDeactivateArg = new MembersDeactivateArg(user,
                                                                wipeData);

            return this.MembersSuspendAsync(membersDeactivateArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members suspend route.</para>
        /// </summary>
        /// <param name="user">Identity of user to remove/suspend/have their files
        /// moved.</param>
        /// <param name="wipeData">If provided, controls if the user's data will be deleted on
        /// their linked devices.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersSuspend(UserSelectorArg user,
                                                    bool wipeData = true,
                                                    sys.AsyncCallback callback = null,
                                                    object callbackState = null)
        {
            var membersDeactivateArg = new MembersDeactivateArg(user,
                                                                wipeData);

            return this.BeginMembersSuspend(membersDeactivateArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the members suspend route to
        /// complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersSuspendError"/>.</exception>
        public void EndMembersSuspend(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }
        }

        /// <summary>
        /// <para>Unsuspend a member from a team.</para>
        /// <para>Permission : Team member management</para>
        /// <para>Exactly one of team_member_id, email, or external_id must be provided to
        /// identify the user account.</para>
        /// </summary>
        /// <param name="membersUnsuspendArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersUnsuspendError"/>.</exception>
        public t.Task MembersUnsuspendAsync(MembersUnsuspendArg membersUnsuspendArg)
        {
            return this.Transport.SendRpcRequestAsync<MembersUnsuspendArg, enc.Empty, MembersUnsuspendError>(membersUnsuspendArg, "api", "/team/members/unsuspend", "team", global::Dropbox.Api.Team.MembersUnsuspendArg.Encoder, enc.EmptyDecoder.Instance, global::Dropbox.Api.Team.MembersUnsuspendError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members unsuspend route.</para>
        /// </summary>
        /// <param name="membersUnsuspendArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersUnsuspend(MembersUnsuspendArg membersUnsuspendArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.MembersUnsuspendAsync(membersUnsuspendArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Unsuspend a member from a team.</para>
        /// <para>Permission : Team member management</para>
        /// <para>Exactly one of team_member_id, email, or external_id must be provided to
        /// identify the user account.</para>
        /// </summary>
        /// <param name="user">Identity of user to unsuspend.</param>
        /// <returns>The task that represents the asynchronous send operation.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersUnsuspendError"/>.</exception>
        public t.Task MembersUnsuspendAsync(UserSelectorArg user)
        {
            var membersUnsuspendArg = new MembersUnsuspendArg(user);

            return this.MembersUnsuspendAsync(membersUnsuspendArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the members unsuspend route.</para>
        /// </summary>
        /// <param name="user">Identity of user to unsuspend.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginMembersUnsuspend(UserSelectorArg user,
                                                      sys.AsyncCallback callback,
                                                      object callbackState = null)
        {
            var membersUnsuspendArg = new MembersUnsuspendArg(user);

            return this.BeginMembersUnsuspend(membersUnsuspendArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the members unsuspend route to
        /// complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="MembersUnsuspendError"/>.</exception>
        public void EndMembersUnsuspend(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }
        }

        /// <summary>
        /// <para>Returns a list of all team-accessible namespaces. This list includes team
        /// folders, shared folders containing team members, team members' home namespaces, and
        /// team members' app folders. Home namespaces and app folders are always owned by this
        /// team or members of the team, but shared folders may be owned by other users or
        /// other teams. Duplicates may occur in the list.</para>
        /// </summary>
        /// <param name="teamNamespacesListArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="TeamNamespacesListError"/>.</exception>
        public t.Task<TeamNamespacesListResult> NamespacesListAsync(TeamNamespacesListArg teamNamespacesListArg)
        {
            return this.Transport.SendRpcRequestAsync<TeamNamespacesListArg, TeamNamespacesListResult, TeamNamespacesListError>(teamNamespacesListArg, "api", "/team/namespaces/list", "team", global::Dropbox.Api.Team.TeamNamespacesListArg.Encoder, global::Dropbox.Api.Team.TeamNamespacesListResult.Decoder, global::Dropbox.Api.Team.TeamNamespacesListError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the namespaces list route.</para>
        /// </summary>
        /// <param name="teamNamespacesListArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginNamespacesList(TeamNamespacesListArg teamNamespacesListArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.NamespacesListAsync(teamNamespacesListArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Returns a list of all team-accessible namespaces. This list includes team
        /// folders, shared folders containing team members, team members' home namespaces, and
        /// team members' app folders. Home namespaces and app folders are always owned by this
        /// team or members of the team, but shared folders may be owned by other users or
        /// other teams. Duplicates may occur in the list.</para>
        /// </summary>
        /// <param name="limit">Specifying a value here has no effect.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="TeamNamespacesListError"/>.</exception>
        public t.Task<TeamNamespacesListResult> NamespacesListAsync(uint limit = 1000)
        {
            var teamNamespacesListArg = new TeamNamespacesListArg(limit);

            return this.NamespacesListAsync(teamNamespacesListArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the namespaces list route.</para>
        /// </summary>
        /// <param name="limit">Specifying a value here has no effect.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginNamespacesList(uint limit = 1000,
                                                    sys.AsyncCallback callback = null,
                                                    object callbackState = null)
        {
            var teamNamespacesListArg = new TeamNamespacesListArg(limit);

            return this.BeginNamespacesList(teamNamespacesListArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the namespaces list route to
        /// complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="TeamNamespacesListError"/>.</exception>
        public TeamNamespacesListResult EndNamespacesList(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<TeamNamespacesListResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Once a cursor has been retrieved from <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.NamespacesListAsync" />, use this to
        /// paginate through all team-accessible namespaces. Duplicates may occur in the
        /// list.</para>
        /// </summary>
        /// <param name="teamNamespacesListContinueArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="TeamNamespacesListContinueError"/>.</exception>
        public t.Task<TeamNamespacesListResult> NamespacesListContinueAsync(TeamNamespacesListContinueArg teamNamespacesListContinueArg)
        {
            return this.Transport.SendRpcRequestAsync<TeamNamespacesListContinueArg, TeamNamespacesListResult, TeamNamespacesListContinueError>(teamNamespacesListContinueArg, "api", "/team/namespaces/list/continue", "team", global::Dropbox.Api.Team.TeamNamespacesListContinueArg.Encoder, global::Dropbox.Api.Team.TeamNamespacesListResult.Decoder, global::Dropbox.Api.Team.TeamNamespacesListContinueError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the namespaces list continue route.</para>
        /// </summary>
        /// <param name="teamNamespacesListContinueArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginNamespacesListContinue(TeamNamespacesListContinueArg teamNamespacesListContinueArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.NamespacesListContinueAsync(teamNamespacesListContinueArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Once a cursor has been retrieved from <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.NamespacesListAsync" />, use this to
        /// paginate through all team-accessible namespaces. Duplicates may occur in the
        /// list.</para>
        /// </summary>
        /// <param name="cursor">Indicates from what point to get the next set of
        /// team-accessible namespaces.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="TeamNamespacesListContinueError"/>.</exception>
        public t.Task<TeamNamespacesListResult> NamespacesListContinueAsync(string cursor)
        {
            var teamNamespacesListContinueArg = new TeamNamespacesListContinueArg(cursor);

            return this.NamespacesListContinueAsync(teamNamespacesListContinueArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the namespaces list continue route.</para>
        /// </summary>
        /// <param name="cursor">Indicates from what point to get the next set of
        /// team-accessible namespaces.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginNamespacesListContinue(string cursor,
                                                            sys.AsyncCallback callback,
                                                            object callbackState = null)
        {
            var teamNamespacesListContinueArg = new TeamNamespacesListContinueArg(cursor);

            return this.BeginNamespacesListContinue(teamNamespacesListContinueArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the namespaces list continue route
        /// to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="TeamNamespacesListContinueError"/>.</exception>
        public TeamNamespacesListResult EndNamespacesListContinue(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<TeamNamespacesListResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Permission : Team member file access.</para>
        /// </summary>
        /// <param name="addTemplateArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="global::Dropbox.Api.FileProperties.ModifyTemplateError"/>.</exception>
        [sys.Obsolete("This function is deprecated")]
        public t.Task<global::Dropbox.Api.FileProperties.AddTemplateResult> PropertiesTemplateAddAsync(global::Dropbox.Api.FileProperties.AddTemplateArg addTemplateArg)
        {
            return this.Transport.SendRpcRequestAsync<global::Dropbox.Api.FileProperties.AddTemplateArg, global::Dropbox.Api.FileProperties.AddTemplateResult, global::Dropbox.Api.FileProperties.ModifyTemplateError>(addTemplateArg, "api", "/team/properties/template/add", "team", global::Dropbox.Api.FileProperties.AddTemplateArg.Encoder, global::Dropbox.Api.FileProperties.AddTemplateResult.Decoder, global::Dropbox.Api.FileProperties.ModifyTemplateError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the properties template add route.</para>
        /// </summary>
        /// <param name="addTemplateArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        [sys.Obsolete("This function is deprecated")]
        public sys.IAsyncResult BeginPropertiesTemplateAdd(global::Dropbox.Api.FileProperties.AddTemplateArg addTemplateArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.PropertiesTemplateAddAsync(addTemplateArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Permission : Team member file access.</para>
        /// </summary>
        /// <param name="name">Display name for the template. Template names can be up to 256
        /// bytes.</param>
        /// <param name="description">Description for the template. Template descriptions can
        /// be up to 1024 bytes.</param>
        /// <param name="fields">Definitions of the property fields associated with this
        /// template. There can be up to 32 properties in a single template.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="global::Dropbox.Api.FileProperties.ModifyTemplateError"/>.</exception>
        [sys.Obsolete("This function is deprecated")]
        public t.Task<global::Dropbox.Api.FileProperties.AddTemplateResult> PropertiesTemplateAddAsync(string name,
                                                                                                       string description,
                                                                                                       col.IEnumerable<global::Dropbox.Api.FileProperties.PropertyFieldTemplate> fields)
        {
            var addTemplateArg = new global::Dropbox.Api.FileProperties.AddTemplateArg(name,
                                                                                       description,
                                                                                       fields);

            return this.PropertiesTemplateAddAsync(addTemplateArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the properties template add route.</para>
        /// </summary>
        /// <param name="name">Display name for the template. Template names can be up to 256
        /// bytes.</param>
        /// <param name="description">Description for the template. Template descriptions can
        /// be up to 1024 bytes.</param>
        /// <param name="fields">Definitions of the property fields associated with this
        /// template. There can be up to 32 properties in a single template.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        [sys.Obsolete("This function is deprecated")]
        public sys.IAsyncResult BeginPropertiesTemplateAdd(string name,
                                                           string description,
                                                           col.IEnumerable<global::Dropbox.Api.FileProperties.PropertyFieldTemplate> fields,
                                                           sys.AsyncCallback callback,
                                                           object callbackState = null)
        {
            var addTemplateArg = new global::Dropbox.Api.FileProperties.AddTemplateArg(name,
                                                                                       description,
                                                                                       fields);

            return this.BeginPropertiesTemplateAdd(addTemplateArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the properties template add route
        /// to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="global::Dropbox.Api.FileProperties.ModifyTemplateError"/>.</exception>
        [sys.Obsolete("This function is deprecated")]
        public global::Dropbox.Api.FileProperties.AddTemplateResult EndPropertiesTemplateAdd(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<global::Dropbox.Api.FileProperties.AddTemplateResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Permission : Team member file access. The scope for the route is
        /// files.team_metadata.write.</para>
        /// </summary>
        /// <param name="getTemplateArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="global::Dropbox.Api.FileProperties.TemplateError"/>.</exception>
        [sys.Obsolete("This function is deprecated")]
        public t.Task<global::Dropbox.Api.FileProperties.GetTemplateResult> PropertiesTemplateGetAsync(global::Dropbox.Api.FileProperties.GetTemplateArg getTemplateArg)
        {
            return this.Transport.SendRpcRequestAsync<global::Dropbox.Api.FileProperties.GetTemplateArg, global::Dropbox.Api.FileProperties.GetTemplateResult, global::Dropbox.Api.FileProperties.TemplateError>(getTemplateArg, "api", "/team/properties/template/get", "team", global::Dropbox.Api.FileProperties.GetTemplateArg.Encoder, global::Dropbox.Api.FileProperties.GetTemplateResult.Decoder, global::Dropbox.Api.FileProperties.TemplateError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the properties template get route.</para>
        /// </summary>
        /// <param name="getTemplateArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        [sys.Obsolete("This function is deprecated")]
        public sys.IAsyncResult BeginPropertiesTemplateGet(global::Dropbox.Api.FileProperties.GetTemplateArg getTemplateArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.PropertiesTemplateGetAsync(getTemplateArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Permission : Team member file access. The scope for the route is
        /// files.team_metadata.write.</para>
        /// </summary>
        /// <param name="templateId">An identifier for template added by route  See <see
        /// cref="Dropbox.Api.FileProperties.Routes.FilePropertiesUserRoutes.TemplatesAddForUserAsync"
        /// /> or <see
        /// cref="Dropbox.Api.FileProperties.Routes.FilePropertiesTeamRoutes.TemplatesAddForTeamAsync"
        /// />.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="global::Dropbox.Api.FileProperties.TemplateError"/>.</exception>
        [sys.Obsolete("This function is deprecated")]
        public t.Task<global::Dropbox.Api.FileProperties.GetTemplateResult> PropertiesTemplateGetAsync(string templateId)
        {
            var getTemplateArg = new global::Dropbox.Api.FileProperties.GetTemplateArg(templateId);

            return this.PropertiesTemplateGetAsync(getTemplateArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the properties template get route.</para>
        /// </summary>
        /// <param name="templateId">An identifier for template added by route  See <see
        /// cref="Dropbox.Api.FileProperties.Routes.FilePropertiesUserRoutes.TemplatesAddForUserAsync"
        /// /> or <see
        /// cref="Dropbox.Api.FileProperties.Routes.FilePropertiesTeamRoutes.TemplatesAddForTeamAsync"
        /// />.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        [sys.Obsolete("This function is deprecated")]
        public sys.IAsyncResult BeginPropertiesTemplateGet(string templateId,
                                                           sys.AsyncCallback callback,
                                                           object callbackState = null)
        {
            var getTemplateArg = new global::Dropbox.Api.FileProperties.GetTemplateArg(templateId);

            return this.BeginPropertiesTemplateGet(getTemplateArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the properties template get route
        /// to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="global::Dropbox.Api.FileProperties.TemplateError"/>.</exception>
        [sys.Obsolete("This function is deprecated")]
        public global::Dropbox.Api.FileProperties.GetTemplateResult EndPropertiesTemplateGet(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<global::Dropbox.Api.FileProperties.GetTemplateResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Permission : Team member file access. The scope for the route is
        /// files.team_metadata.write.</para>
        /// </summary>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="global::Dropbox.Api.FileProperties.TemplateError"/>.</exception>
        [sys.Obsolete("This function is deprecated")]
        public t.Task<global::Dropbox.Api.FileProperties.ListTemplateResult> PropertiesTemplateListAsync()
        {
            return this.Transport.SendRpcRequestAsync<enc.Empty, global::Dropbox.Api.FileProperties.ListTemplateResult, global::Dropbox.Api.FileProperties.TemplateError>(enc.Empty.Instance, "api", "/team/properties/template/list", "team", enc.EmptyEncoder.Instance, global::Dropbox.Api.FileProperties.ListTemplateResult.Decoder, global::Dropbox.Api.FileProperties.TemplateError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the properties template list route.</para>
        /// </summary>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        [sys.Obsolete("This function is deprecated")]
        public sys.IAsyncResult BeginPropertiesTemplateList(sys.AsyncCallback callback, object state = null)
        {
            var task = this.PropertiesTemplateListAsync();

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the properties template list route
        /// to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="global::Dropbox.Api.FileProperties.TemplateError"/>.</exception>
        [sys.Obsolete("This function is deprecated")]
        public global::Dropbox.Api.FileProperties.ListTemplateResult EndPropertiesTemplateList(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<global::Dropbox.Api.FileProperties.ListTemplateResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Permission : Team member file access.</para>
        /// </summary>
        /// <param name="updateTemplateArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="global::Dropbox.Api.FileProperties.ModifyTemplateError"/>.</exception>
        [sys.Obsolete("This function is deprecated")]
        public t.Task<global::Dropbox.Api.FileProperties.UpdateTemplateResult> PropertiesTemplateUpdateAsync(global::Dropbox.Api.FileProperties.UpdateTemplateArg updateTemplateArg)
        {
            return this.Transport.SendRpcRequestAsync<global::Dropbox.Api.FileProperties.UpdateTemplateArg, global::Dropbox.Api.FileProperties.UpdateTemplateResult, global::Dropbox.Api.FileProperties.ModifyTemplateError>(updateTemplateArg, "api", "/team/properties/template/update", "team", global::Dropbox.Api.FileProperties.UpdateTemplateArg.Encoder, global::Dropbox.Api.FileProperties.UpdateTemplateResult.Decoder, global::Dropbox.Api.FileProperties.ModifyTemplateError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the properties template update route.</para>
        /// </summary>
        /// <param name="updateTemplateArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        [sys.Obsolete("This function is deprecated")]
        public sys.IAsyncResult BeginPropertiesTemplateUpdate(global::Dropbox.Api.FileProperties.UpdateTemplateArg updateTemplateArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.PropertiesTemplateUpdateAsync(updateTemplateArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Permission : Team member file access.</para>
        /// </summary>
        /// <param name="templateId">An identifier for template added by  See <see
        /// cref="Dropbox.Api.FileProperties.Routes.FilePropertiesUserRoutes.TemplatesAddForUserAsync"
        /// /> or <see
        /// cref="Dropbox.Api.FileProperties.Routes.FilePropertiesTeamRoutes.TemplatesAddForTeamAsync"
        /// />.</param>
        /// <param name="name">A display name for the template. template names can be up to 256
        /// bytes.</param>
        /// <param name="description">Description for the new template. Template descriptions
        /// can be up to 1024 bytes.</param>
        /// <param name="addFields">Property field templates to be added to the group template.
        /// There can be up to 32 properties in a single template.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="global::Dropbox.Api.FileProperties.ModifyTemplateError"/>.</exception>
        [sys.Obsolete("This function is deprecated")]
        public t.Task<global::Dropbox.Api.FileProperties.UpdateTemplateResult> PropertiesTemplateUpdateAsync(string templateId,
                                                                                                             string name = null,
                                                                                                             string description = null,
                                                                                                             col.IEnumerable<global::Dropbox.Api.FileProperties.PropertyFieldTemplate> addFields = null)
        {
            var updateTemplateArg = new global::Dropbox.Api.FileProperties.UpdateTemplateArg(templateId,
                                                                                             name,
                                                                                             description,
                                                                                             addFields);

            return this.PropertiesTemplateUpdateAsync(updateTemplateArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the properties template update route.</para>
        /// </summary>
        /// <param name="templateId">An identifier for template added by  See <see
        /// cref="Dropbox.Api.FileProperties.Routes.FilePropertiesUserRoutes.TemplatesAddForUserAsync"
        /// /> or <see
        /// cref="Dropbox.Api.FileProperties.Routes.FilePropertiesTeamRoutes.TemplatesAddForTeamAsync"
        /// />.</param>
        /// <param name="name">A display name for the template. template names can be up to 256
        /// bytes.</param>
        /// <param name="description">Description for the new template. Template descriptions
        /// can be up to 1024 bytes.</param>
        /// <param name="addFields">Property field templates to be added to the group template.
        /// There can be up to 32 properties in a single template.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        [sys.Obsolete("This function is deprecated")]
        public sys.IAsyncResult BeginPropertiesTemplateUpdate(string templateId,
                                                              string name = null,
                                                              string description = null,
                                                              col.IEnumerable<global::Dropbox.Api.FileProperties.PropertyFieldTemplate> addFields = null,
                                                              sys.AsyncCallback callback = null,
                                                              object callbackState = null)
        {
            var updateTemplateArg = new global::Dropbox.Api.FileProperties.UpdateTemplateArg(templateId,
                                                                                             name,
                                                                                             description,
                                                                                             addFields);

            return this.BeginPropertiesTemplateUpdate(updateTemplateArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the properties template update
        /// route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="global::Dropbox.Api.FileProperties.ModifyTemplateError"/>.</exception>
        [sys.Obsolete("This function is deprecated")]
        public global::Dropbox.Api.FileProperties.UpdateTemplateResult EndPropertiesTemplateUpdate(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<global::Dropbox.Api.FileProperties.UpdateTemplateResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Retrieves reporting data about a team's user activity. Deprecated: Will be
        /// removed on July 1st 2021.</para>
        /// </summary>
        /// <param name="dateRange">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="DateRangeError"/>.</exception>
        [sys.Obsolete("This function is deprecated")]
        public t.Task<GetActivityReport> ReportsGetActivityAsync(DateRange dateRange)
        {
            return this.Transport.SendRpcRequestAsync<DateRange, GetActivityReport, DateRangeError>(dateRange, "api", "/team/reports/get_activity", "team", global::Dropbox.Api.Team.DateRange.Encoder, global::Dropbox.Api.Team.GetActivityReport.Decoder, global::Dropbox.Api.Team.DateRangeError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the reports get activity route.</para>
        /// </summary>
        /// <param name="dateRange">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        [sys.Obsolete("This function is deprecated")]
        public sys.IAsyncResult BeginReportsGetActivity(DateRange dateRange, sys.AsyncCallback callback, object state = null)
        {
            var task = this.ReportsGetActivityAsync(dateRange);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Retrieves reporting data about a team's user activity. Deprecated: Will be
        /// removed on July 1st 2021.</para>
        /// </summary>
        /// <param name="startDate">Optional starting date (inclusive). If start_date is None
        /// or too long ago, this field will  be set to 6 months ago.</param>
        /// <param name="endDate">Optional ending date (exclusive).</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="DateRangeError"/>.</exception>
        [sys.Obsolete("This function is deprecated")]
        public t.Task<GetActivityReport> ReportsGetActivityAsync(sys.DateTime? startDate = null,
                                                                 sys.DateTime? endDate = null)
        {
            var dateRange = new DateRange(startDate,
                                          endDate);

            return this.ReportsGetActivityAsync(dateRange);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the reports get activity route.</para>
        /// </summary>
        /// <param name="startDate">Optional starting date (inclusive). If start_date is None
        /// or too long ago, this field will  be set to 6 months ago.</param>
        /// <param name="endDate">Optional ending date (exclusive).</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        [sys.Obsolete("This function is deprecated")]
        public sys.IAsyncResult BeginReportsGetActivity(sys.DateTime? startDate = null,
                                                        sys.DateTime? endDate = null,
                                                        sys.AsyncCallback callback = null,
                                                        object callbackState = null)
        {
            var dateRange = new DateRange(startDate,
                                          endDate);

            return this.BeginReportsGetActivity(dateRange, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the reports get activity route to
        /// complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="DateRangeError"/>.</exception>
        [sys.Obsolete("This function is deprecated")]
        public GetActivityReport EndReportsGetActivity(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<GetActivityReport>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Retrieves reporting data about a team's linked devices. Deprecated: Will be
        /// removed on July 1st 2021.</para>
        /// </summary>
        /// <param name="dateRange">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="DateRangeError"/>.</exception>
        [sys.Obsolete("This function is deprecated")]
        public t.Task<GetDevicesReport> ReportsGetDevicesAsync(DateRange dateRange)
        {
            return this.Transport.SendRpcRequestAsync<DateRange, GetDevicesReport, DateRangeError>(dateRange, "api", "/team/reports/get_devices", "team", global::Dropbox.Api.Team.DateRange.Encoder, global::Dropbox.Api.Team.GetDevicesReport.Decoder, global::Dropbox.Api.Team.DateRangeError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the reports get devices route.</para>
        /// </summary>
        /// <param name="dateRange">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        [sys.Obsolete("This function is deprecated")]
        public sys.IAsyncResult BeginReportsGetDevices(DateRange dateRange, sys.AsyncCallback callback, object state = null)
        {
            var task = this.ReportsGetDevicesAsync(dateRange);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Retrieves reporting data about a team's linked devices. Deprecated: Will be
        /// removed on July 1st 2021.</para>
        /// </summary>
        /// <param name="startDate">Optional starting date (inclusive). If start_date is None
        /// or too long ago, this field will  be set to 6 months ago.</param>
        /// <param name="endDate">Optional ending date (exclusive).</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="DateRangeError"/>.</exception>
        [sys.Obsolete("This function is deprecated")]
        public t.Task<GetDevicesReport> ReportsGetDevicesAsync(sys.DateTime? startDate = null,
                                                               sys.DateTime? endDate = null)
        {
            var dateRange = new DateRange(startDate,
                                          endDate);

            return this.ReportsGetDevicesAsync(dateRange);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the reports get devices route.</para>
        /// </summary>
        /// <param name="startDate">Optional starting date (inclusive). If start_date is None
        /// or too long ago, this field will  be set to 6 months ago.</param>
        /// <param name="endDate">Optional ending date (exclusive).</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        [sys.Obsolete("This function is deprecated")]
        public sys.IAsyncResult BeginReportsGetDevices(sys.DateTime? startDate = null,
                                                       sys.DateTime? endDate = null,
                                                       sys.AsyncCallback callback = null,
                                                       object callbackState = null)
        {
            var dateRange = new DateRange(startDate,
                                          endDate);

            return this.BeginReportsGetDevices(dateRange, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the reports get devices route to
        /// complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="DateRangeError"/>.</exception>
        [sys.Obsolete("This function is deprecated")]
        public GetDevicesReport EndReportsGetDevices(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<GetDevicesReport>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Retrieves reporting data about a team's membership. Deprecated: Will be
        /// removed on July 1st 2021.</para>
        /// </summary>
        /// <param name="dateRange">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="DateRangeError"/>.</exception>
        [sys.Obsolete("This function is deprecated")]
        public t.Task<GetMembershipReport> ReportsGetMembershipAsync(DateRange dateRange)
        {
            return this.Transport.SendRpcRequestAsync<DateRange, GetMembershipReport, DateRangeError>(dateRange, "api", "/team/reports/get_membership", "team", global::Dropbox.Api.Team.DateRange.Encoder, global::Dropbox.Api.Team.GetMembershipReport.Decoder, global::Dropbox.Api.Team.DateRangeError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the reports get membership route.</para>
        /// </summary>
        /// <param name="dateRange">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        [sys.Obsolete("This function is deprecated")]
        public sys.IAsyncResult BeginReportsGetMembership(DateRange dateRange, sys.AsyncCallback callback, object state = null)
        {
            var task = this.ReportsGetMembershipAsync(dateRange);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Retrieves reporting data about a team's membership. Deprecated: Will be
        /// removed on July 1st 2021.</para>
        /// </summary>
        /// <param name="startDate">Optional starting date (inclusive). If start_date is None
        /// or too long ago, this field will  be set to 6 months ago.</param>
        /// <param name="endDate">Optional ending date (exclusive).</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="DateRangeError"/>.</exception>
        [sys.Obsolete("This function is deprecated")]
        public t.Task<GetMembershipReport> ReportsGetMembershipAsync(sys.DateTime? startDate = null,
                                                                     sys.DateTime? endDate = null)
        {
            var dateRange = new DateRange(startDate,
                                          endDate);

            return this.ReportsGetMembershipAsync(dateRange);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the reports get membership route.</para>
        /// </summary>
        /// <param name="startDate">Optional starting date (inclusive). If start_date is None
        /// or too long ago, this field will  be set to 6 months ago.</param>
        /// <param name="endDate">Optional ending date (exclusive).</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        [sys.Obsolete("This function is deprecated")]
        public sys.IAsyncResult BeginReportsGetMembership(sys.DateTime? startDate = null,
                                                          sys.DateTime? endDate = null,
                                                          sys.AsyncCallback callback = null,
                                                          object callbackState = null)
        {
            var dateRange = new DateRange(startDate,
                                          endDate);

            return this.BeginReportsGetMembership(dateRange, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the reports get membership route
        /// to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="DateRangeError"/>.</exception>
        [sys.Obsolete("This function is deprecated")]
        public GetMembershipReport EndReportsGetMembership(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<GetMembershipReport>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Retrieves reporting data about a team's storage usage. Deprecated: Will be
        /// removed on July 1st 2021.</para>
        /// </summary>
        /// <param name="dateRange">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="DateRangeError"/>.</exception>
        [sys.Obsolete("This function is deprecated")]
        public t.Task<GetStorageReport> ReportsGetStorageAsync(DateRange dateRange)
        {
            return this.Transport.SendRpcRequestAsync<DateRange, GetStorageReport, DateRangeError>(dateRange, "api", "/team/reports/get_storage", "team", global::Dropbox.Api.Team.DateRange.Encoder, global::Dropbox.Api.Team.GetStorageReport.Decoder, global::Dropbox.Api.Team.DateRangeError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the reports get storage route.</para>
        /// </summary>
        /// <param name="dateRange">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        [sys.Obsolete("This function is deprecated")]
        public sys.IAsyncResult BeginReportsGetStorage(DateRange dateRange, sys.AsyncCallback callback, object state = null)
        {
            var task = this.ReportsGetStorageAsync(dateRange);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Retrieves reporting data about a team's storage usage. Deprecated: Will be
        /// removed on July 1st 2021.</para>
        /// </summary>
        /// <param name="startDate">Optional starting date (inclusive). If start_date is None
        /// or too long ago, this field will  be set to 6 months ago.</param>
        /// <param name="endDate">Optional ending date (exclusive).</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="DateRangeError"/>.</exception>
        [sys.Obsolete("This function is deprecated")]
        public t.Task<GetStorageReport> ReportsGetStorageAsync(sys.DateTime? startDate = null,
                                                               sys.DateTime? endDate = null)
        {
            var dateRange = new DateRange(startDate,
                                          endDate);

            return this.ReportsGetStorageAsync(dateRange);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the reports get storage route.</para>
        /// </summary>
        /// <param name="startDate">Optional starting date (inclusive). If start_date is None
        /// or too long ago, this field will  be set to 6 months ago.</param>
        /// <param name="endDate">Optional ending date (exclusive).</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        [sys.Obsolete("This function is deprecated")]
        public sys.IAsyncResult BeginReportsGetStorage(sys.DateTime? startDate = null,
                                                       sys.DateTime? endDate = null,
                                                       sys.AsyncCallback callback = null,
                                                       object callbackState = null)
        {
            var dateRange = new DateRange(startDate,
                                          endDate);

            return this.BeginReportsGetStorage(dateRange, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the reports get storage route to
        /// complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="DateRangeError"/>.</exception>
        [sys.Obsolete("This function is deprecated")]
        public GetStorageReport EndReportsGetStorage(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<GetStorageReport>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Sets an archived team folder's status to active.</para>
        /// <para>Permission : Team member file access.</para>
        /// </summary>
        /// <param name="teamFolderIdArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="TeamFolderActivateError"/>.</exception>
        public t.Task<TeamFolderMetadata> TeamFolderActivateAsync(TeamFolderIdArg teamFolderIdArg)
        {
            return this.Transport.SendRpcRequestAsync<TeamFolderIdArg, TeamFolderMetadata, TeamFolderActivateError>(teamFolderIdArg, "api", "/team/team_folder/activate", "team", global::Dropbox.Api.Team.TeamFolderIdArg.Encoder, global::Dropbox.Api.Team.TeamFolderMetadata.Decoder, global::Dropbox.Api.Team.TeamFolderActivateError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the team folder activate route.</para>
        /// </summary>
        /// <param name="teamFolderIdArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginTeamFolderActivate(TeamFolderIdArg teamFolderIdArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.TeamFolderActivateAsync(teamFolderIdArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Sets an archived team folder's status to active.</para>
        /// <para>Permission : Team member file access.</para>
        /// </summary>
        /// <param name="teamFolderId">The ID of the team folder.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="TeamFolderActivateError"/>.</exception>
        public t.Task<TeamFolderMetadata> TeamFolderActivateAsync(string teamFolderId)
        {
            var teamFolderIdArg = new TeamFolderIdArg(teamFolderId);

            return this.TeamFolderActivateAsync(teamFolderIdArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the team folder activate route.</para>
        /// </summary>
        /// <param name="teamFolderId">The ID of the team folder.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginTeamFolderActivate(string teamFolderId,
                                                        sys.AsyncCallback callback,
                                                        object callbackState = null)
        {
            var teamFolderIdArg = new TeamFolderIdArg(teamFolderId);

            return this.BeginTeamFolderActivate(teamFolderIdArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the team folder activate route to
        /// complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="TeamFolderActivateError"/>.</exception>
        public TeamFolderMetadata EndTeamFolderActivate(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<TeamFolderMetadata>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Sets an active team folder's status to archived and removes all folder and
        /// file members. This endpoint cannot be used for teams that have a shared team
        /// space.</para>
        /// <para>Permission : Team member file access.</para>
        /// </summary>
        /// <param name="teamFolderArchiveArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="TeamFolderArchiveError"/>.</exception>
        public t.Task<TeamFolderArchiveLaunch> TeamFolderArchiveAsync(TeamFolderArchiveArg teamFolderArchiveArg)
        {
            return this.Transport.SendRpcRequestAsync<TeamFolderArchiveArg, TeamFolderArchiveLaunch, TeamFolderArchiveError>(teamFolderArchiveArg, "api", "/team/team_folder/archive", "team", global::Dropbox.Api.Team.TeamFolderArchiveArg.Encoder, global::Dropbox.Api.Team.TeamFolderArchiveLaunch.Decoder, global::Dropbox.Api.Team.TeamFolderArchiveError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the team folder archive route.</para>
        /// </summary>
        /// <param name="teamFolderArchiveArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginTeamFolderArchive(TeamFolderArchiveArg teamFolderArchiveArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.TeamFolderArchiveAsync(teamFolderArchiveArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Sets an active team folder's status to archived and removes all folder and
        /// file members. This endpoint cannot be used for teams that have a shared team
        /// space.</para>
        /// <para>Permission : Team member file access.</para>
        /// </summary>
        /// <param name="teamFolderId">The ID of the team folder.</param>
        /// <param name="forceAsyncOff">Whether to force the archive to happen
        /// synchronously.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="TeamFolderArchiveError"/>.</exception>
        public t.Task<TeamFolderArchiveLaunch> TeamFolderArchiveAsync(string teamFolderId,
                                                                      bool forceAsyncOff = false)
        {
            var teamFolderArchiveArg = new TeamFolderArchiveArg(teamFolderId,
                                                                forceAsyncOff);

            return this.TeamFolderArchiveAsync(teamFolderArchiveArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the team folder archive route.</para>
        /// </summary>
        /// <param name="teamFolderId">The ID of the team folder.</param>
        /// <param name="forceAsyncOff">Whether to force the archive to happen
        /// synchronously.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginTeamFolderArchive(string teamFolderId,
                                                       bool forceAsyncOff = false,
                                                       sys.AsyncCallback callback = null,
                                                       object callbackState = null)
        {
            var teamFolderArchiveArg = new TeamFolderArchiveArg(teamFolderId,
                                                                forceAsyncOff);

            return this.BeginTeamFolderArchive(teamFolderArchiveArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the team folder archive route to
        /// complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="TeamFolderArchiveError"/>.</exception>
        public TeamFolderArchiveLaunch EndTeamFolderArchive(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<TeamFolderArchiveLaunch>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Returns the status of an asynchronous job for archiving a team folder.</para>
        /// <para>Permission : Team member file access.</para>
        /// </summary>
        /// <param name="pollArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="global::Dropbox.Api.Async.PollError"/>.</exception>
        public t.Task<TeamFolderArchiveJobStatus> TeamFolderArchiveCheckAsync(global::Dropbox.Api.Async.PollArg pollArg)
        {
            return this.Transport.SendRpcRequestAsync<global::Dropbox.Api.Async.PollArg, TeamFolderArchiveJobStatus, global::Dropbox.Api.Async.PollError>(pollArg, "api", "/team/team_folder/archive/check", "team", global::Dropbox.Api.Async.PollArg.Encoder, global::Dropbox.Api.Team.TeamFolderArchiveJobStatus.Decoder, global::Dropbox.Api.Async.PollError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the team folder archive check route.</para>
        /// </summary>
        /// <param name="pollArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginTeamFolderArchiveCheck(global::Dropbox.Api.Async.PollArg pollArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.TeamFolderArchiveCheckAsync(pollArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Returns the status of an asynchronous job for archiving a team folder.</para>
        /// <para>Permission : Team member file access.</para>
        /// </summary>
        /// <param name="asyncJobId">Id of the asynchronous job. This is the value of a
        /// response returned from the method that launched the job.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="global::Dropbox.Api.Async.PollError"/>.</exception>
        public t.Task<TeamFolderArchiveJobStatus> TeamFolderArchiveCheckAsync(string asyncJobId)
        {
            var pollArg = new global::Dropbox.Api.Async.PollArg(asyncJobId);

            return this.TeamFolderArchiveCheckAsync(pollArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the team folder archive check route.</para>
        /// </summary>
        /// <param name="asyncJobId">Id of the asynchronous job. This is the value of a
        /// response returned from the method that launched the job.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginTeamFolderArchiveCheck(string asyncJobId,
                                                            sys.AsyncCallback callback,
                                                            object callbackState = null)
        {
            var pollArg = new global::Dropbox.Api.Async.PollArg(asyncJobId);

            return this.BeginTeamFolderArchiveCheck(pollArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the team folder archive check
        /// route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="global::Dropbox.Api.Async.PollError"/>.</exception>
        public TeamFolderArchiveJobStatus EndTeamFolderArchiveCheck(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<TeamFolderArchiveJobStatus>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Creates a new, active, team folder with no members. This endpoint can only be
        /// used for teams that do not already have a shared team space.</para>
        /// <para>Permission : Team member file access.</para>
        /// </summary>
        /// <param name="teamFolderCreateArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="TeamFolderCreateError"/>.</exception>
        public t.Task<TeamFolderMetadata> TeamFolderCreateAsync(TeamFolderCreateArg teamFolderCreateArg)
        {
            return this.Transport.SendRpcRequestAsync<TeamFolderCreateArg, TeamFolderMetadata, TeamFolderCreateError>(teamFolderCreateArg, "api", "/team/team_folder/create", "team", global::Dropbox.Api.Team.TeamFolderCreateArg.Encoder, global::Dropbox.Api.Team.TeamFolderMetadata.Decoder, global::Dropbox.Api.Team.TeamFolderCreateError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the team folder create route.</para>
        /// </summary>
        /// <param name="teamFolderCreateArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginTeamFolderCreate(TeamFolderCreateArg teamFolderCreateArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.TeamFolderCreateAsync(teamFolderCreateArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Creates a new, active, team folder with no members. This endpoint can only be
        /// used for teams that do not already have a shared team space.</para>
        /// <para>Permission : Team member file access.</para>
        /// </summary>
        /// <param name="name">Name for the new team folder.</param>
        /// <param name="syncSetting">The sync setting to apply to this team folder. Only
        /// permitted if the team has team selective sync enabled.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="TeamFolderCreateError"/>.</exception>
        public t.Task<TeamFolderMetadata> TeamFolderCreateAsync(string name,
                                                                global::Dropbox.Api.Files.SyncSettingArg syncSetting = null)
        {
            var teamFolderCreateArg = new TeamFolderCreateArg(name,
                                                              syncSetting);

            return this.TeamFolderCreateAsync(teamFolderCreateArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the team folder create route.</para>
        /// </summary>
        /// <param name="name">Name for the new team folder.</param>
        /// <param name="syncSetting">The sync setting to apply to this team folder. Only
        /// permitted if the team has team selective sync enabled.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginTeamFolderCreate(string name,
                                                      global::Dropbox.Api.Files.SyncSettingArg syncSetting = null,
                                                      sys.AsyncCallback callback = null,
                                                      object callbackState = null)
        {
            var teamFolderCreateArg = new TeamFolderCreateArg(name,
                                                              syncSetting);

            return this.BeginTeamFolderCreate(teamFolderCreateArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the team folder create route to
        /// complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="TeamFolderCreateError"/>.</exception>
        public TeamFolderMetadata EndTeamFolderCreate(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<TeamFolderMetadata>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Retrieves metadata for team folders.</para>
        /// <para>Permission : Team member file access.</para>
        /// </summary>
        /// <param name="teamFolderIdListArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        public t.Task<col.List<TeamFolderGetInfoItem>> TeamFolderGetInfoAsync(TeamFolderIdListArg teamFolderIdListArg)
        {
            return this.Transport.SendRpcRequestAsync<TeamFolderIdListArg, col.List<TeamFolderGetInfoItem>, enc.Empty>(teamFolderIdListArg, "api", "/team/team_folder/get_info", "team", global::Dropbox.Api.Team.TeamFolderIdListArg.Encoder, enc.Decoder.CreateListDecoder(global::Dropbox.Api.Team.TeamFolderGetInfoItem.Decoder), enc.EmptyDecoder.Instance);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the team folder get info route.</para>
        /// </summary>
        /// <param name="teamFolderIdListArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginTeamFolderGetInfo(TeamFolderIdListArg teamFolderIdListArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.TeamFolderGetInfoAsync(teamFolderIdListArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Retrieves metadata for team folders.</para>
        /// <para>Permission : Team member file access.</para>
        /// </summary>
        /// <param name="teamFolderIds">The list of team folder IDs.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        public t.Task<col.List<TeamFolderGetInfoItem>> TeamFolderGetInfoAsync(col.IEnumerable<string> teamFolderIds)
        {
            var teamFolderIdListArg = new TeamFolderIdListArg(teamFolderIds);

            return this.TeamFolderGetInfoAsync(teamFolderIdListArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the team folder get info route.</para>
        /// </summary>
        /// <param name="teamFolderIds">The list of team folder IDs.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginTeamFolderGetInfo(col.IEnumerable<string> teamFolderIds,
                                                       sys.AsyncCallback callback,
                                                       object callbackState = null)
        {
            var teamFolderIdListArg = new TeamFolderIdListArg(teamFolderIds);

            return this.BeginTeamFolderGetInfo(teamFolderIdListArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the team folder get info route to
        /// complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        public col.List<TeamFolderGetInfoItem> EndTeamFolderGetInfo(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<col.List<TeamFolderGetInfoItem>>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Lists all team folders.</para>
        /// <para>Permission : Team member file access.</para>
        /// </summary>
        /// <param name="teamFolderListArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="TeamFolderListError"/>.</exception>
        public t.Task<TeamFolderListResult> TeamFolderListAsync(TeamFolderListArg teamFolderListArg)
        {
            return this.Transport.SendRpcRequestAsync<TeamFolderListArg, TeamFolderListResult, TeamFolderListError>(teamFolderListArg, "api", "/team/team_folder/list", "team", global::Dropbox.Api.Team.TeamFolderListArg.Encoder, global::Dropbox.Api.Team.TeamFolderListResult.Decoder, global::Dropbox.Api.Team.TeamFolderListError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the team folder list route.</para>
        /// </summary>
        /// <param name="teamFolderListArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginTeamFolderList(TeamFolderListArg teamFolderListArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.TeamFolderListAsync(teamFolderListArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Lists all team folders.</para>
        /// <para>Permission : Team member file access.</para>
        /// </summary>
        /// <param name="limit">The maximum number of results to return per request.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="TeamFolderListError"/>.</exception>
        public t.Task<TeamFolderListResult> TeamFolderListAsync(uint limit = 1000)
        {
            var teamFolderListArg = new TeamFolderListArg(limit);

            return this.TeamFolderListAsync(teamFolderListArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the team folder list route.</para>
        /// </summary>
        /// <param name="limit">The maximum number of results to return per request.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginTeamFolderList(uint limit = 1000,
                                                    sys.AsyncCallback callback = null,
                                                    object callbackState = null)
        {
            var teamFolderListArg = new TeamFolderListArg(limit);

            return this.BeginTeamFolderList(teamFolderListArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the team folder list route to
        /// complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="TeamFolderListError"/>.</exception>
        public TeamFolderListResult EndTeamFolderList(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<TeamFolderListResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Once a cursor has been retrieved from <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.TeamFolderListAsync" />, use this to
        /// paginate through all team folders.</para>
        /// <para>Permission : Team member file access.</para>
        /// </summary>
        /// <param name="teamFolderListContinueArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="TeamFolderListContinueError"/>.</exception>
        public t.Task<TeamFolderListResult> TeamFolderListContinueAsync(TeamFolderListContinueArg teamFolderListContinueArg)
        {
            return this.Transport.SendRpcRequestAsync<TeamFolderListContinueArg, TeamFolderListResult, TeamFolderListContinueError>(teamFolderListContinueArg, "api", "/team/team_folder/list/continue", "team", global::Dropbox.Api.Team.TeamFolderListContinueArg.Encoder, global::Dropbox.Api.Team.TeamFolderListResult.Decoder, global::Dropbox.Api.Team.TeamFolderListContinueError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the team folder list continue route.</para>
        /// </summary>
        /// <param name="teamFolderListContinueArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginTeamFolderListContinue(TeamFolderListContinueArg teamFolderListContinueArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.TeamFolderListContinueAsync(teamFolderListContinueArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Once a cursor has been retrieved from <see
        /// cref="Dropbox.Api.Team.Routes.TeamTeamRoutes.TeamFolderListAsync" />, use this to
        /// paginate through all team folders.</para>
        /// <para>Permission : Team member file access.</para>
        /// </summary>
        /// <param name="cursor">Indicates from what point to get the next set of team
        /// folders.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="TeamFolderListContinueError"/>.</exception>
        public t.Task<TeamFolderListResult> TeamFolderListContinueAsync(string cursor)
        {
            var teamFolderListContinueArg = new TeamFolderListContinueArg(cursor);

            return this.TeamFolderListContinueAsync(teamFolderListContinueArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the team folder list continue route.</para>
        /// </summary>
        /// <param name="cursor">Indicates from what point to get the next set of team
        /// folders.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginTeamFolderListContinue(string cursor,
                                                            sys.AsyncCallback callback,
                                                            object callbackState = null)
        {
            var teamFolderListContinueArg = new TeamFolderListContinueArg(cursor);

            return this.BeginTeamFolderListContinue(teamFolderListContinueArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the team folder list continue
        /// route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="TeamFolderListContinueError"/>.</exception>
        public TeamFolderListResult EndTeamFolderListContinue(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<TeamFolderListResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Permanently deletes an archived team folder. This endpoint cannot be used for
        /// teams that have a shared team space.</para>
        /// <para>Permission : Team member file access.</para>
        /// </summary>
        /// <param name="teamFolderIdArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="TeamFolderPermanentlyDeleteError"/>.</exception>
        public t.Task TeamFolderPermanentlyDeleteAsync(TeamFolderIdArg teamFolderIdArg)
        {
            return this.Transport.SendRpcRequestAsync<TeamFolderIdArg, enc.Empty, TeamFolderPermanentlyDeleteError>(teamFolderIdArg, "api", "/team/team_folder/permanently_delete", "team", global::Dropbox.Api.Team.TeamFolderIdArg.Encoder, enc.EmptyDecoder.Instance, global::Dropbox.Api.Team.TeamFolderPermanentlyDeleteError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the team folder permanently delete
        /// route.</para>
        /// </summary>
        /// <param name="teamFolderIdArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginTeamFolderPermanentlyDelete(TeamFolderIdArg teamFolderIdArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.TeamFolderPermanentlyDeleteAsync(teamFolderIdArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Permanently deletes an archived team folder. This endpoint cannot be used for
        /// teams that have a shared team space.</para>
        /// <para>Permission : Team member file access.</para>
        /// </summary>
        /// <param name="teamFolderId">The ID of the team folder.</param>
        /// <returns>The task that represents the asynchronous send operation.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="TeamFolderPermanentlyDeleteError"/>.</exception>
        public t.Task TeamFolderPermanentlyDeleteAsync(string teamFolderId)
        {
            var teamFolderIdArg = new TeamFolderIdArg(teamFolderId);

            return this.TeamFolderPermanentlyDeleteAsync(teamFolderIdArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the team folder permanently delete
        /// route.</para>
        /// </summary>
        /// <param name="teamFolderId">The ID of the team folder.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginTeamFolderPermanentlyDelete(string teamFolderId,
                                                                 sys.AsyncCallback callback,
                                                                 object callbackState = null)
        {
            var teamFolderIdArg = new TeamFolderIdArg(teamFolderId);

            return this.BeginTeamFolderPermanentlyDelete(teamFolderIdArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the team folder permanently delete
        /// route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="TeamFolderPermanentlyDeleteError"/>.</exception>
        public void EndTeamFolderPermanentlyDelete(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }
        }

        /// <summary>
        /// <para>Changes an active team folder's name.</para>
        /// <para>Permission : Team member file access.</para>
        /// </summary>
        /// <param name="teamFolderRenameArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="TeamFolderRenameError"/>.</exception>
        public t.Task<TeamFolderMetadata> TeamFolderRenameAsync(TeamFolderRenameArg teamFolderRenameArg)
        {
            return this.Transport.SendRpcRequestAsync<TeamFolderRenameArg, TeamFolderMetadata, TeamFolderRenameError>(teamFolderRenameArg, "api", "/team/team_folder/rename", "team", global::Dropbox.Api.Team.TeamFolderRenameArg.Encoder, global::Dropbox.Api.Team.TeamFolderMetadata.Decoder, global::Dropbox.Api.Team.TeamFolderRenameError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the team folder rename route.</para>
        /// </summary>
        /// <param name="teamFolderRenameArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginTeamFolderRename(TeamFolderRenameArg teamFolderRenameArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.TeamFolderRenameAsync(teamFolderRenameArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Changes an active team folder's name.</para>
        /// <para>Permission : Team member file access.</para>
        /// </summary>
        /// <param name="teamFolderId">The ID of the team folder.</param>
        /// <param name="name">New team folder name.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="TeamFolderRenameError"/>.</exception>
        public t.Task<TeamFolderMetadata> TeamFolderRenameAsync(string teamFolderId,
                                                                string name)
        {
            var teamFolderRenameArg = new TeamFolderRenameArg(teamFolderId,
                                                              name);

            return this.TeamFolderRenameAsync(teamFolderRenameArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the team folder rename route.</para>
        /// </summary>
        /// <param name="teamFolderId">The ID of the team folder.</param>
        /// <param name="name">New team folder name.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginTeamFolderRename(string teamFolderId,
                                                      string name,
                                                      sys.AsyncCallback callback,
                                                      object callbackState = null)
        {
            var teamFolderRenameArg = new TeamFolderRenameArg(teamFolderId,
                                                              name);

            return this.BeginTeamFolderRename(teamFolderRenameArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the team folder rename route to
        /// complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="TeamFolderRenameError"/>.</exception>
        public TeamFolderMetadata EndTeamFolderRename(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<TeamFolderMetadata>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Updates the sync settings on a team folder or its contents.  Use of this
        /// endpoint requires that the team has team selective sync enabled.</para>
        /// </summary>
        /// <param name="teamFolderUpdateSyncSettingsArg">The request parameters</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="TeamFolderUpdateSyncSettingsError"/>.</exception>
        public t.Task<TeamFolderMetadata> TeamFolderUpdateSyncSettingsAsync(TeamFolderUpdateSyncSettingsArg teamFolderUpdateSyncSettingsArg)
        {
            return this.Transport.SendRpcRequestAsync<TeamFolderUpdateSyncSettingsArg, TeamFolderMetadata, TeamFolderUpdateSyncSettingsError>(teamFolderUpdateSyncSettingsArg, "api", "/team/team_folder/update_sync_settings", "team", global::Dropbox.Api.Team.TeamFolderUpdateSyncSettingsArg.Encoder, global::Dropbox.Api.Team.TeamFolderMetadata.Decoder, global::Dropbox.Api.Team.TeamFolderUpdateSyncSettingsError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the team folder update sync settings
        /// route.</para>
        /// </summary>
        /// <param name="teamFolderUpdateSyncSettingsArg">The request parameters.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginTeamFolderUpdateSyncSettings(TeamFolderUpdateSyncSettingsArg teamFolderUpdateSyncSettingsArg, sys.AsyncCallback callback, object state = null)
        {
            var task = this.TeamFolderUpdateSyncSettingsAsync(teamFolderUpdateSyncSettingsArg);

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Updates the sync settings on a team folder or its contents.  Use of this
        /// endpoint requires that the team has team selective sync enabled.</para>
        /// </summary>
        /// <param name="teamFolderId">The ID of the team folder.</param>
        /// <param name="syncSetting">Sync setting to apply to the team folder itself. Only
        /// meaningful if the team folder is not a shared team root.</param>
        /// <param name="contentSyncSettings">Sync settings to apply to contents of this team
        /// folder.</param>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="TeamFolderUpdateSyncSettingsError"/>.</exception>
        public t.Task<TeamFolderMetadata> TeamFolderUpdateSyncSettingsAsync(string teamFolderId,
                                                                            global::Dropbox.Api.Files.SyncSettingArg syncSetting = null,
                                                                            col.IEnumerable<global::Dropbox.Api.Files.ContentSyncSettingArg> contentSyncSettings = null)
        {
            var teamFolderUpdateSyncSettingsArg = new TeamFolderUpdateSyncSettingsArg(teamFolderId,
                                                                                      syncSetting,
                                                                                      contentSyncSettings);

            return this.TeamFolderUpdateSyncSettingsAsync(teamFolderUpdateSyncSettingsArg);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the team folder update sync settings
        /// route.</para>
        /// </summary>
        /// <param name="teamFolderId">The ID of the team folder.</param>
        /// <param name="syncSetting">Sync setting to apply to the team folder itself. Only
        /// meaningful if the team folder is not a shared team root.</param>
        /// <param name="contentSyncSettings">Sync settings to apply to contents of this team
        /// folder.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginTeamFolderUpdateSyncSettings(string teamFolderId,
                                                                  global::Dropbox.Api.Files.SyncSettingArg syncSetting = null,
                                                                  col.IEnumerable<global::Dropbox.Api.Files.ContentSyncSettingArg> contentSyncSettings = null,
                                                                  sys.AsyncCallback callback = null,
                                                                  object callbackState = null)
        {
            var teamFolderUpdateSyncSettingsArg = new TeamFolderUpdateSyncSettingsArg(teamFolderId,
                                                                                      syncSetting,
                                                                                      contentSyncSettings);

            return this.BeginTeamFolderUpdateSyncSettings(teamFolderUpdateSyncSettingsArg, callback, callbackState);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the team folder update sync
        /// settings route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="TeamFolderUpdateSyncSettingsError"/>.</exception>
        public TeamFolderMetadata EndTeamFolderUpdateSyncSettings(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<TeamFolderMetadata>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }

        /// <summary>
        /// <para>Returns the member profile of the admin who generated the team access token
        /// used to make the call.</para>
        /// </summary>
        /// <returns>The task that represents the asynchronous send operation. The TResult
        /// parameter contains the response from the server.</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="TokenGetAuthenticatedAdminError"/>.</exception>
        public t.Task<TokenGetAuthenticatedAdminResult> TokenGetAuthenticatedAdminAsync()
        {
            return this.Transport.SendRpcRequestAsync<enc.Empty, TokenGetAuthenticatedAdminResult, TokenGetAuthenticatedAdminError>(enc.Empty.Instance, "api", "/team/token/get_authenticated_admin", "team", enc.EmptyEncoder.Instance, global::Dropbox.Api.Team.TokenGetAuthenticatedAdminResult.Decoder, global::Dropbox.Api.Team.TokenGetAuthenticatedAdminError.Decoder);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the token get authenticated admin
        /// route.</para>
        /// </summary>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="state">A user provided object that distinguished this send from other
        /// send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginTokenGetAuthenticatedAdmin(sys.AsyncCallback callback, object state = null)
        {
            var task = this.TokenGetAuthenticatedAdminAsync();

            return enc.Util.ToApm(task, callback, state);
        }

        /// <summary>
        /// <para>Waits for the pending asynchronous send to the token get authenticated admin
        /// route to complete</para>
        /// </summary>
        /// <param name="asyncResult">The reference to the pending asynchronous send
        /// request</param>
        /// <returns>The response to the send request</returns>
        /// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
        /// processing the request; This will contain a <see
        /// cref="TokenGetAuthenticatedAdminError"/>.</exception>
        public TokenGetAuthenticatedAdminResult EndTokenGetAuthenticatedAdmin(sys.IAsyncResult asyncResult)
        {
            var task = asyncResult as t.Task<TokenGetAuthenticatedAdminResult>;
            if (task == null)
            {
                throw new sys.InvalidOperationException();
            }

            return task.Result;
        }
    }
}