dropbox_sdk/generated/sync_routes/

team.rs

// DO NOT EDIT
// This file was @generated by Stone

#![allow(
    clippy::too_many_arguments,
    clippy::large_enum_variant,
    clippy::result_large_err,
    clippy::doc_markdown,
    clippy::doc_lazy_continuation,
)]

#[allow(unused_imports)]
pub use crate::generated::types::team::*;

/// List all device sessions of a team's member.
pub fn devices_list_member_devices(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &ListMemberDevicesArg,
) -> Result<ListMemberDevicesResult, crate::Error<ListMemberDevicesError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/devices/list_member_devices",
            arg,
            None)
    )
}

/// List all device sessions of a team. Permission : Team member file access.
pub fn devices_list_members_devices(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &ListMembersDevicesArg,
) -> Result<ListMembersDevicesResult, crate::Error<ListMembersDevicesError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/devices/list_members_devices",
            arg,
            None)
    )
}

/// List all device sessions of a team. Permission : Team member file access.
#[deprecated]
pub fn devices_list_team_devices(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &ListTeamDevicesArg,
) -> Result<ListTeamDevicesResult, crate::Error<ListTeamDevicesError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/devices/list_team_devices",
            arg,
            None)
    )
}

/// Revoke a device session of a team's member.
pub fn devices_revoke_device_session(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &RevokeDeviceSessionArg,
) -> Result<(), crate::Error<RevokeDeviceSessionError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/devices/revoke_device_session",
            arg,
            None)
    )
}

/// Revoke a list of device sessions of team members.
pub fn devices_revoke_device_session_batch(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &RevokeDeviceSessionBatchArg,
) -> Result<RevokeDeviceSessionBatchResult, crate::Error<RevokeDeviceSessionBatchError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/devices/revoke_device_session_batch",
            arg,
            None)
    )
}

/// Get the values for one or more features. This route allows you to check your account's
/// capability for what feature you can access or what value you have for certain features.
/// Permission : Team information.
pub fn features_get_values(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &FeaturesGetValuesBatchArg,
) -> Result<FeaturesGetValuesBatchResult, crate::Error<FeaturesGetValuesBatchError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/features/get_values",
            arg,
            None)
    )
}

/// Retrieves information about a team.
pub fn get_info(
    client: &impl crate::client_trait::TeamAuthClient,
) -> Result<TeamGetInfoResult, crate::Error<crate::NoError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/get_info",
            &(),
            None)
    )
}

/// Creates a new, empty group, with a requested name. Permission : Team member management.
pub fn groups_create(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &GroupCreateArg,
) -> Result<GroupFullInfo, crate::Error<GroupCreateError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/groups/create",
            arg,
            None)
    )
}

/// Deletes a group. The group is deleted immediately. However the revoking of group-owned resources
/// may take additional time. Use the
/// [`groups_job_status_get()`](crate::team::groups_job_status_get) to determine whether this
/// process has completed. Permission : Team member management.
pub fn groups_delete(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &GroupSelector,
) -> Result<crate::types::dbx_async::LaunchEmptyResult, crate::Error<GroupDeleteError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/groups/delete",
            arg,
            None)
    )
}

/// Retrieves information about one or more groups. Note that the optional field
/// [`GroupFullInfo::members`](GroupFullInfo) is not returned for system-managed groups. Permission
/// : Team Information.
pub fn groups_get_info(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &GroupsSelector,
) -> Result<GroupsGetInfoResult, crate::Error<GroupsGetInfoError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/groups/get_info",
            arg,
            None)
    )
}

/// Once an async_job_id is returned from [`groups_delete()`](crate::team::groups_delete),
/// [`groups_members_add()`](crate::team::groups_members_add) , or
/// [`groups_members_remove()`](crate::team::groups_members_remove) use this method to poll the
/// status of granting/revoking group members' access to group-owned resources. Permission : Team
/// member management.
pub fn groups_job_status_get(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &crate::types::dbx_async::PollArg,
) -> Result<crate::types::dbx_async::PollEmptyResult, crate::Error<GroupsPollError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/groups/job_status/get",
            arg,
            None)
    )
}

/// Lists groups on a team. Permission : Team Information.
pub fn groups_list(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &GroupsListArg,
) -> Result<GroupsListResult, crate::Error<crate::NoError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/groups/list",
            arg,
            None)
    )
}

/// Once a cursor has been retrieved from [`groups_list()`](crate::team::groups_list), use this to
/// paginate through all groups. Permission : Team Information.
pub fn groups_list_continue(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &GroupsListContinueArg,
) -> Result<GroupsListResult, crate::Error<GroupsListContinueError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/groups/list/continue",
            arg,
            None)
    )
}

/// Adds members to a group. The members are added immediately. However the granting of group-owned
/// resources may take additional time. Use the
/// [`groups_job_status_get()`](crate::team::groups_job_status_get) to determine whether this
/// process has completed. Permission : Team member management.
pub fn groups_members_add(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &GroupMembersAddArg,
) -> Result<GroupMembersChangeResult, crate::Error<GroupMembersAddError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/groups/members/add",
            arg,
            None)
    )
}

/// Lists members of a group. Permission : Team Information.
pub fn groups_members_list(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &GroupsMembersListArg,
) -> Result<GroupsMembersListResult, crate::Error<GroupSelectorError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/groups/members/list",
            arg,
            None)
    )
}

/// Once a cursor has been retrieved from
/// [`groups_members_list()`](crate::team::groups_members_list), use this to paginate through all
/// members of the group. Permission : Team information.
pub fn groups_members_list_continue(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &GroupsMembersListContinueArg,
) -> Result<GroupsMembersListResult, crate::Error<GroupsMembersListContinueError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/groups/members/list/continue",
            arg,
            None)
    )
}

/// Removes members from a group. The members are removed immediately. However the revoking of
/// group-owned resources may take additional time. Use the
/// [`groups_job_status_get()`](crate::team::groups_job_status_get) to determine whether this
/// process has completed. This method permits removing the only owner of a group, even in cases
/// where this is not possible via the web client. Permission : Team member management.
pub fn groups_members_remove(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &GroupMembersRemoveArg,
) -> Result<GroupMembersChangeResult, crate::Error<GroupMembersRemoveError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/groups/members/remove",
            arg,
            None)
    )
}

/// Sets a member's access type in a group. Permission : Team member management.
pub fn groups_members_set_access_type(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &GroupMembersSetAccessTypeArg,
) -> Result<GroupsGetInfoResult, crate::Error<GroupMemberSetAccessTypeError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/groups/members/set_access_type",
            arg,
            None)
    )
}

/// Updates a group's name and/or external ID. Permission : Team member management.
pub fn groups_update(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &GroupUpdateArgs,
) -> Result<GroupFullInfo, crate::Error<GroupUpdateError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/groups/update",
            arg,
            None)
    )
}

/// Creates new legal hold policy. Note: Legal Holds is a paid add-on. Not all teams have the
/// feature. Permission : Team member file access.
pub fn legal_holds_create_policy(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &LegalHoldsPolicyCreateArg,
) -> Result<LegalHoldsPolicyCreateResult, crate::Error<LegalHoldsPolicyCreateError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/legal_holds/create_policy",
            arg,
            None)
    )
}

/// Gets a legal hold by Id. Note: Legal Holds is a paid add-on. Not all teams have the feature.
/// Permission : Team member file access.
pub fn legal_holds_get_policy(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &LegalHoldsGetPolicyArg,
) -> Result<LegalHoldsGetPolicyResult, crate::Error<LegalHoldsGetPolicyError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/legal_holds/get_policy",
            arg,
            None)
    )
}

/// List the file metadata that's under the hold. Note: Legal Holds is a paid add-on. Not all teams
/// have the feature. Permission : Team member file access.
pub fn legal_holds_list_held_revisions(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &LegalHoldsListHeldRevisionsArg,
) -> Result<LegalHoldsListHeldRevisionResult, crate::Error<LegalHoldsListHeldRevisionsError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/legal_holds/list_held_revisions",
            arg,
            None)
    )
}

/// Continue listing the file metadata that's under the hold. Note: Legal Holds is a paid add-on.
/// Not all teams have the feature. Permission : Team member file access.
pub fn legal_holds_list_held_revisions_continue(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &LegalHoldsListHeldRevisionsContinueArg,
) -> Result<LegalHoldsListHeldRevisionResult, crate::Error<LegalHoldsListHeldRevisionsError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/legal_holds/list_held_revisions_continue",
            arg,
            None)
    )
}

/// Lists legal holds on a team. Note: Legal Holds is a paid add-on. Not all teams have the feature.
/// Permission : Team member file access.
pub fn legal_holds_list_policies(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &LegalHoldsListPoliciesArg,
) -> Result<LegalHoldsListPoliciesResult, crate::Error<LegalHoldsListPoliciesError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/legal_holds/list_policies",
            arg,
            None)
    )
}

/// Releases a legal hold by Id. Note: Legal Holds is a paid add-on. Not all teams have the feature.
/// Permission : Team member file access.
pub fn legal_holds_release_policy(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &LegalHoldsPolicyReleaseArg,
) -> Result<(), crate::Error<LegalHoldsPolicyReleaseError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/legal_holds/release_policy",
            arg,
            None)
    )
}

/// Updates a legal hold. Note: Legal Holds is a paid add-on. Not all teams have the feature.
/// Permission : Team member file access.
pub fn legal_holds_update_policy(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &LegalHoldsPolicyUpdateArg,
) -> Result<LegalHoldsPolicyUpdateResult, crate::Error<LegalHoldsPolicyUpdateError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/legal_holds/update_policy",
            arg,
            None)
    )
}

/// List all linked applications of the team member. Note, this endpoint does not list any
/// team-linked applications.
pub fn linked_apps_list_member_linked_apps(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &ListMemberAppsArg,
) -> Result<ListMemberAppsResult, crate::Error<ListMemberAppsError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/linked_apps/list_member_linked_apps",
            arg,
            None)
    )
}

/// List all applications linked to the team members' accounts. Note, this endpoint does not list
/// any team-linked applications.
pub fn linked_apps_list_members_linked_apps(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &ListMembersAppsArg,
) -> Result<ListMembersAppsResult, crate::Error<ListMembersAppsError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/linked_apps/list_members_linked_apps",
            arg,
            None)
    )
}

/// List all applications linked to the team members' accounts. Note, this endpoint doesn't list any
/// team-linked applications.
#[deprecated]
pub fn linked_apps_list_team_linked_apps(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &ListTeamAppsArg,
) -> Result<ListTeamAppsResult, crate::Error<ListTeamAppsError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/linked_apps/list_team_linked_apps",
            arg,
            None)
    )
}

/// Revoke a linked application of the team member.
pub fn linked_apps_revoke_linked_app(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &RevokeLinkedApiAppArg,
) -> Result<(), crate::Error<RevokeLinkedAppError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/linked_apps/revoke_linked_app",
            arg,
            None)
    )
}

/// Revoke a list of linked applications of the team members.
pub fn linked_apps_revoke_linked_app_batch(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &RevokeLinkedApiAppBatchArg,
) -> Result<RevokeLinkedAppBatchResult, crate::Error<RevokeLinkedAppBatchError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/linked_apps/revoke_linked_app_batch",
            arg,
            None)
    )
}

/// Add users to member space limits excluded users list.
pub fn member_space_limits_excluded_users_add(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &ExcludedUsersUpdateArg,
) -> Result<ExcludedUsersUpdateResult, crate::Error<ExcludedUsersUpdateError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/member_space_limits/excluded_users/add",
            arg,
            None)
    )
}

/// List member space limits excluded users.
pub fn member_space_limits_excluded_users_list(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &ExcludedUsersListArg,
) -> Result<ExcludedUsersListResult, crate::Error<ExcludedUsersListError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/member_space_limits/excluded_users/list",
            arg,
            None)
    )
}

/// Continue listing member space limits excluded users.
pub fn member_space_limits_excluded_users_list_continue(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &ExcludedUsersListContinueArg,
) -> Result<ExcludedUsersListResult, crate::Error<ExcludedUsersListContinueError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/member_space_limits/excluded_users/list/continue",
            arg,
            None)
    )
}

/// Remove users from member space limits excluded users list.
pub fn member_space_limits_excluded_users_remove(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &ExcludedUsersUpdateArg,
) -> Result<ExcludedUsersUpdateResult, crate::Error<ExcludedUsersUpdateError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/member_space_limits/excluded_users/remove",
            arg,
            None)
    )
}

/// Get users custom quota. A maximum of 1000 members can be specified in a single call. Note: to
/// apply a custom space limit, a team admin needs to set a member space limit for the team first.
/// (the team admin can check the settings here: https://www.dropbox.com/team/admin/settings/space).
pub fn member_space_limits_get_custom_quota(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &CustomQuotaUsersArg,
) -> Result<Vec<CustomQuotaResult>, crate::Error<CustomQuotaError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/member_space_limits/get_custom_quota",
            arg,
            None)
    )
}

/// Remove users custom quota. A maximum of 1000 members can be specified in a single call. Note: to
/// apply a custom space limit, a team admin needs to set a member space limit for the team first.
/// (the team admin can check the settings here: https://www.dropbox.com/team/admin/settings/space).
pub fn member_space_limits_remove_custom_quota(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &CustomQuotaUsersArg,
) -> Result<Vec<RemoveCustomQuotaResult>, crate::Error<CustomQuotaError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/member_space_limits/remove_custom_quota",
            arg,
            None)
    )
}

/// Set users custom quota. Custom quota has to be at least 2GB. A maximum of 1000 members can be
/// specified in a single call. Note: to apply a custom space limit, a team admin needs to set a
/// member space limit for the team first. (the team admin can check the settings here:
/// https://www.dropbox.com/team/admin/settings/space).
pub fn member_space_limits_set_custom_quota(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &SetCustomQuotaArg,
) -> Result<Vec<CustomQuotaResult>, crate::Error<SetCustomQuotaError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/member_space_limits/set_custom_quota",
            arg,
            None)
    )
}

/// Adds members to a team. Permission : Team member management A maximum of 20 members can be
/// specified in a single call. 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. 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. 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'.
pub fn members_add(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &MembersAddArg,
) -> Result<MembersAddLaunch, crate::Error<crate::NoError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/members/add",
            arg,
            None)
    )
}

/// Adds members to a team. Permission : Team member management A maximum of 20 members can be
/// specified in a single call. 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. 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.
pub fn members_add_v2(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &MembersAddV2Arg,
) -> Result<MembersAddLaunchV2Result, crate::Error<crate::NoError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/members/add_v2",
            arg,
            None)
    )
}

/// Once an async_job_id is returned from [`members_add()`](crate::team::members_add) , use this to
/// poll the status of the asynchronous request. Permission : Team member management.
pub fn members_add_job_status_get(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &crate::types::dbx_async::PollArg,
) -> Result<MembersAddJobStatus, crate::Error<crate::types::dbx_async::PollError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/members/add/job_status/get",
            arg,
            None)
    )
}

/// Once an async_job_id is returned from [`members_add_v2()`](crate::team::members_add_v2) , use
/// this to poll the status of the asynchronous request. Permission : Team member management.
pub fn members_add_job_status_get_v2(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &crate::types::dbx_async::PollArg,
) -> Result<MembersAddJobStatusV2Result, crate::Error<crate::types::dbx_async::PollError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/members/add/job_status/get_v2",
            arg,
            None)
    )
}

/// Launch a bulk suspend job. The server enforces a maximum of 500 members.
pub fn members_bulk_suspend(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &BulkSuspendArg,
) -> Result<crate::types::dbx_async::LaunchResultBase, crate::Error<BulkSuspendError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/members/bulk_suspend",
            arg,
            None)
    )
}

/// Poll a previously launched bulk suspend job.
pub fn members_bulk_suspend_job_status_check(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &crate::types::dbx_async::PollArg,
) -> Result<BulkSuspendJobStatus, crate::Error<crate::types::dbx_async::PollError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/members/bulk_suspend/job_status/check",
            arg,
            None)
    )
}

/// Permanently delete the files of a user who has been removed from the team. After permanent
/// deletion, those files will not be available to be transferred to another team member. Permission
/// : Team member management Exactly one of team_member_id, email, or external_id must be provided
/// to identify the user account.
pub fn members_delete_former_member_files(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &MembersFormerMemberArg,
) -> Result<(), crate::Error<MembersDeleteFormerMemberFilesError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/members/delete_former_member_files",
            arg,
            None)
    )
}

/// Deletes a team member's profile photo. Permission : Team member management.
pub fn members_delete_profile_photo(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &MembersDeleteProfilePhotoArg,
) -> Result<TeamMemberInfo, crate::Error<MembersDeleteProfilePhotoError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/members/delete_profile_photo",
            arg,
            None)
    )
}

/// Deletes a team member's profile photo. Permission : Team member management.
pub fn members_delete_profile_photo_v2(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &MembersDeleteProfilePhotoArg,
) -> Result<TeamMemberInfoV2Result, crate::Error<MembersDeleteProfilePhotoError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/members/delete_profile_photo_v2",
            arg,
            None)
    )
}

/// Get available TeamMemberRoles for the connected team. To be used with
/// [`members_set_admin_permissions_v2()`](crate::team::members_set_admin_permissions_v2).
/// Permission : Team member management.
pub fn members_get_available_team_member_roles(
    client: &impl crate::client_trait::TeamAuthClient,
) -> Result<MembersGetAvailableTeamMemberRolesResult, crate::Error<crate::NoError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/members/get_available_team_member_roles",
            &(),
            None)
    )
}

/// Returns information about multiple team members. Permission : Team information This endpoint
/// will return [`MembersGetInfoItem::IdNotFound`], for IDs (or emails) that cannot be matched to a
/// valid team member.
pub fn members_get_info(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &MembersGetInfoArgs,
) -> Result<MembersGetInfoResult, crate::Error<MembersGetInfoError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/members/get_info",
            arg,
            None)
    )
}

/// Returns information about multiple team members. Permission : Team information This endpoint
/// will return [`MembersGetInfoItem::IdNotFound`], for IDs (or emails) that cannot be matched to a
/// valid team member.
pub fn members_get_info_v2(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &MembersGetInfoV2Arg,
) -> Result<MembersGetInfoV2Result, crate::Error<MembersGetInfoError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/members/get_info_v2",
            arg,
            None)
    )
}

/// Lists members of a team. Permission : Team information.
pub fn members_list(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &MembersListArg,
) -> Result<MembersListResult, crate::Error<MembersListError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/members/list",
            arg,
            None)
    )
}

/// Lists members of a team. Permission : Team information.
pub fn members_list_v2(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &MembersListArg,
) -> Result<MembersListV2Result, crate::Error<MembersListError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/members/list_v2",
            arg,
            None)
    )
}

/// Once a cursor has been retrieved from [`members_list()`](crate::team::members_list), use this to
/// paginate through all team members. Permission : Team information.
pub fn members_list_continue(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &MembersListContinueArg,
) -> Result<MembersListResult, crate::Error<MembersListContinueError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/members/list/continue",
            arg,
            None)
    )
}

/// Once a cursor has been retrieved from [`members_list_v2()`](crate::team::members_list_v2), use
/// this to paginate through all team members. Permission : Team information.
pub fn members_list_continue_v2(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &MembersListContinueArg,
) -> Result<MembersListV2Result, crate::Error<MembersListContinueError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/members/list/continue_v2",
            arg,
            None)
    )
}

/// 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
/// [`members_move_former_member_files_job_status_check()`](crate::team::members_move_former_member_files_job_status_check).
/// Permission : Team member management.
pub fn members_move_former_member_files(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &MembersDataTransferArg,
) -> Result<crate::types::dbx_async::LaunchEmptyResult, crate::Error<MembersTransferFormerMembersFilesError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/members/move_former_member_files",
            arg,
            None)
    )
}

/// Once an async_job_id is returned from
/// [`members_move_former_member_files()`](crate::team::members_move_former_member_files) , use this
/// to poll the status of the asynchronous request. Permission : Team member management.
pub fn members_move_former_member_files_job_status_check(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &crate::types::dbx_async::PollArg,
) -> Result<crate::types::dbx_async::PollEmptyResult, crate::Error<crate::types::dbx_async::PollError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/members/move_former_member_files/job_status/check",
            arg,
            None)
    )
}

/// Recover a deleted member. Permission : Team member management Exactly one of team_member_id,
/// email, or external_id must be provided to identify the user account.
pub fn members_recover(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &MembersRecoverArg,
) -> Result<(), crate::Error<MembersRecoverError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/members/recover",
            arg,
            None)
    )
}

/// Removes a member from a team. Permission : Team member management Exactly one of team_member_id,
/// email, or external_id must be provided to identify the user account. Accounts can be recovered
/// via [`members_recover()`](crate::team::members_recover) for a 7 day period or until the account
/// has been permanently deleted or transferred to another account (whichever comes first). Calling
/// [`members_add()`](crate::team::members_add) while a user is still recoverable on your team will
/// return with [`MemberAddResult::UserAlreadyOnTeam`]. 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). Accounts can have their stacks transferred through the admin
/// console. This only transfers stacks that they have created. This endpoint may initiate an
/// asynchronous job. To obtain the final result of the job, the client should periodically poll
/// [`members_remove_job_status_get()`](crate::team::members_remove_job_status_get).
pub fn members_remove(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &MembersRemoveArg,
) -> Result<crate::types::dbx_async::LaunchEmptyResult, crate::Error<MembersRemoveError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/members/remove",
            arg,
            None)
    )
}

/// Once an async_job_id is returned from [`members_remove()`](crate::team::members_remove) , use
/// this to poll the status of the asynchronous request. Permission : Team member management.
pub fn members_remove_job_status_get(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &crate::types::dbx_async::PollArg,
) -> Result<crate::types::dbx_async::PollEmptyResult, crate::Error<crate::types::dbx_async::PollError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/members/remove/job_status/get",
            arg,
            None)
    )
}

/// Add secondary emails to users. Permission : Team member management. 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.
pub fn members_secondary_emails_add(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &AddSecondaryEmailsArg,
) -> Result<AddSecondaryEmailsResult, crate::Error<AddSecondaryEmailsError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/members/secondary_emails/add",
            arg,
            None)
    )
}

/// Delete secondary emails from users Permission : Team member management. Users will be notified
/// of deletions of verified secondary emails at both the secondary email and their primary email.
pub fn members_secondary_emails_delete(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &DeleteSecondaryEmailsArg,
) -> Result<DeleteSecondaryEmailsResult, crate::Error<crate::NoError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/members/secondary_emails/delete",
            arg,
            None)
    )
}

/// Resend secondary email verification emails. Permission : Team member management.
pub fn members_secondary_emails_resend_verification_emails(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &ResendVerificationEmailArg,
) -> Result<ResendVerificationEmailResult, crate::Error<crate::NoError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/members/secondary_emails/resend_verification_emails",
            arg,
            None)
    )
}

/// Sends welcome email to pending team member. Permission : Team member management Exactly one of
/// team_member_id, email, or external_id must be provided to identify the user account. No-op if
/// team member is not pending.
pub fn members_send_welcome_email(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &UserSelectorArg,
) -> Result<(), crate::Error<MembersSendWelcomeError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/members/send_welcome_email",
            arg,
            None)
    )
}

/// Updates a team member's permissions. Permission : Team member management.
pub fn members_set_admin_permissions(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &MembersSetPermissionsArg,
) -> Result<MembersSetPermissionsResult, crate::Error<MembersSetPermissionsError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/members/set_admin_permissions",
            arg,
            None)
    )
}

/// Updates a team member's permissions. Permission : Team member management.
pub fn members_set_admin_permissions_v2(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &MembersSetPermissions2Arg,
) -> Result<MembersSetPermissions2Result, crate::Error<MembersSetPermissions2Error>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/members/set_admin_permissions_v2",
            arg,
            None)
    )
}

/// Updates a team member's profile. Permission : Team member management.
pub fn members_set_profile(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &MembersSetProfileArg,
) -> Result<TeamMemberInfo, crate::Error<MembersSetProfileError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/members/set_profile",
            arg,
            None)
    )
}

/// Updates a team member's profile. Permission : Team member management.
pub fn members_set_profile_v2(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &MembersSetProfileArg,
) -> Result<TeamMemberInfoV2Result, crate::Error<MembersSetProfileError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/members/set_profile_v2",
            arg,
            None)
    )
}

/// Updates a team member's profile photo. Permission : Team member management.
pub fn members_set_profile_photo(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &MembersSetProfilePhotoArg,
) -> Result<TeamMemberInfo, crate::Error<MembersSetProfilePhotoError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/members/set_profile_photo",
            arg,
            None)
    )
}

/// Updates a team member's profile photo. Permission : Team member management.
pub fn members_set_profile_photo_v2(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &MembersSetProfilePhotoArg,
) -> Result<TeamMemberInfoV2Result, crate::Error<MembersSetProfilePhotoError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/members/set_profile_photo_v2",
            arg,
            None)
    )
}

/// Suspend a member from a team. Permission : Team member management Exactly one of team_member_id,
/// email, or external_id must be provided to identify the user account.
pub fn members_suspend(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &MembersDeactivateArg,
) -> Result<(), crate::Error<MembersSuspendError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/members/suspend",
            arg,
            None)
    )
}

/// Unsuspend a member from a team. Permission : Team member management Exactly one of
/// team_member_id, email, or external_id must be provided to identify the user account.
pub fn members_unsuspend(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &MembersUnsuspendArg,
) -> Result<(), crate::Error<MembersUnsuspendError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/members/unsuspend",
            arg,
            None)
    )
}

/// 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.
pub fn namespaces_list(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &TeamNamespacesListArg,
) -> Result<TeamNamespacesListResult, crate::Error<TeamNamespacesListError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/namespaces/list",
            arg,
            None)
    )
}

/// Once a cursor has been retrieved from [`namespaces_list()`](crate::team::namespaces_list), use
/// this to paginate through all team-accessible namespaces. Duplicates may occur in the list.
pub fn namespaces_list_continue(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &TeamNamespacesListContinueArg,
) -> Result<TeamNamespacesListResult, crate::Error<TeamNamespacesListContinueError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/namespaces/list/continue",
            arg,
            None)
    )
}

/// Permission : Team member file access.
#[deprecated]
pub fn properties_template_add(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &crate::types::file_properties::AddTemplateArg,
) -> Result<crate::types::file_properties::AddTemplateResult, crate::Error<crate::types::file_properties::ModifyTemplateError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/properties/template/add",
            arg,
            None)
    )
}

/// Permission : Team member file access. The scope for the route is files.team_metadata.write.
#[deprecated]
pub fn properties_template_get(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &crate::types::file_properties::GetTemplateArg,
) -> Result<crate::types::file_properties::GetTemplateResult, crate::Error<crate::types::file_properties::TemplateError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/properties/template/get",
            arg,
            None)
    )
}

/// Retrieves reporting data about a team's user activity. Deprecated: Will be removed on July 1st
/// 2021.
#[deprecated]
pub fn reports_get_activity(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &DateRange,
) -> Result<GetActivityReport, crate::Error<DateRangeError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/reports/get_activity",
            arg,
            None)
    )
}

/// Retrieves reporting data about a team's linked devices. Deprecated: Will be removed on July 1st
/// 2021.
#[deprecated]
pub fn reports_get_devices(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &DateRange,
) -> Result<GetDevicesReport, crate::Error<DateRangeError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/reports/get_devices",
            arg,
            None)
    )
}

/// Retrieves reporting data about a team's membership. Deprecated: Will be removed on July 1st
/// 2021.
#[deprecated]
pub fn reports_get_membership(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &DateRange,
) -> Result<GetMembershipReport, crate::Error<DateRangeError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/reports/get_membership",
            arg,
            None)
    )
}

/// Retrieves reporting data about a team's storage usage. Deprecated: Will be removed on July 1st
/// 2021.
#[deprecated]
pub fn reports_get_storage(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &DateRange,
) -> Result<GetStorageReport, crate::Error<DateRangeError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/reports/get_storage",
            arg,
            None)
    )
}

/// Endpoint adds Approve List entries. Changes are effective immediately. Changes are committed in
/// transaction. In case of single validation error - all entries are rejected. Valid domains
/// (RFC-1034/5) and emails (RFC-5322/822) are accepted. Added entries cannot overflow limit of
/// 10000 entries per team. Maximum 100 entries per call is allowed.
///
/// # Stability
/// *PREVIEW*: This function may change or disappear without notice.
#[cfg(feature = "unstable")]
#[cfg_attr(docsrs, doc(cfg(feature = "unstable")))]
pub fn sharing_allowlist_add(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &SharingAllowlistAddArgs,
) -> Result<SharingAllowlistAddResponse, crate::Error<SharingAllowlistAddError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/sharing_allowlist/add",
            arg,
            None)
    )
}

/// Lists Approve List entries for given team, from newest to oldest, returning up to `limit`
/// entries at a time. If there are more than `limit` entries associated with the current team, more
/// can be fetched by passing the returned `cursor` to
/// [`sharing_allowlist_list_continue()`](crate::team::sharing_allowlist_list_continue).
///
/// # Stability
/// *PREVIEW*: This function may change or disappear without notice.
#[cfg(feature = "unstable")]
#[cfg_attr(docsrs, doc(cfg(feature = "unstable")))]
pub fn sharing_allowlist_list(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &SharingAllowlistListArg,
) -> Result<SharingAllowlistListResponse, crate::Error<SharingAllowlistListError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/sharing_allowlist/list",
            arg,
            None)
    )
}

/// Lists entries associated with given team, starting from a the cursor. See
/// [`sharing_allowlist_list()`](crate::team::sharing_allowlist_list).
///
/// # Stability
/// *PREVIEW*: This function may change or disappear without notice.
#[cfg(feature = "unstable")]
#[cfg_attr(docsrs, doc(cfg(feature = "unstable")))]
pub fn sharing_allowlist_list_continue(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &SharingAllowlistListContinueArg,
) -> Result<SharingAllowlistListResponse, crate::Error<SharingAllowlistListContinueError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/sharing_allowlist/list/continue",
            arg,
            None)
    )
}

/// Endpoint removes Approve List entries. Changes are effective immediately. Changes are committed
/// in transaction. In case of single validation error - all entries are rejected. Valid domains
/// (RFC-1034/5) and emails (RFC-5322/822) are accepted. Entries being removed have to be present on
/// the list. Maximum 1000 entries per call is allowed.
///
/// # Stability
/// *PREVIEW*: This function may change or disappear without notice.
#[cfg(feature = "unstable")]
#[cfg_attr(docsrs, doc(cfg(feature = "unstable")))]
pub fn sharing_allowlist_remove(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &SharingAllowlistRemoveArgs,
) -> Result<SharingAllowlistRemoveResponse, crate::Error<SharingAllowlistRemoveError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/sharing_allowlist/remove",
            arg,
            None)
    )
}

/// Sets an archived team folder's status to active. Permission : Team member file access.
pub fn team_folder_activate(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &TeamFolderIdArg,
) -> Result<TeamFolderMetadata, crate::Error<TeamFolderActivateError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/team_folder/activate",
            arg,
            None)
    )
}

/// 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. This route will either finish
/// synchronously, or return a job ID and do the async archive job in background. Please use
/// team_folder/archive/check to check the job status. Permission : Team member file access.
pub fn team_folder_archive(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &TeamFolderArchiveArg,
) -> Result<TeamFolderArchiveLaunch, crate::Error<TeamFolderArchiveError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/team_folder/archive",
            arg,
            None)
    )
}

/// Returns the status of an asynchronous job for archiving a team folder. The job may show '.tag'
/// as complete, but the team folder could still be in the process of archiving (indicated by
/// [`TeamFolderMetadata::status`](TeamFolderMetadata) with 'archive_in_progress'). To confirm that
/// the team folder is fully archived, check the field
/// [`TeamFolderMetadata::status`](TeamFolderMetadata) in the response for the value 'archived'.
/// Permission : Team member file access.
pub fn team_folder_archive_check(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &crate::types::dbx_async::PollArg,
) -> Result<TeamFolderArchiveJobStatus, crate::Error<crate::types::dbx_async::PollError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/team_folder/archive/check",
            arg,
            None)
    )
}

/// 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. Permission : Team member file access.
pub fn team_folder_create(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &TeamFolderCreateArg,
) -> Result<TeamFolderMetadata, crate::Error<TeamFolderCreateError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/team_folder/create",
            arg,
            None)
    )
}

/// Retrieves metadata for team folders. Permission : Team member file access.
pub fn team_folder_get_info(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &TeamFolderIdListArg,
) -> Result<Vec<TeamFolderGetInfoItem>, crate::Error<crate::NoError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/team_folder/get_info",
            arg,
            None)
    )
}

/// Lists all team folders. Permission : Team member file access.
pub fn team_folder_list(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &TeamFolderListArg,
) -> Result<TeamFolderListResult, crate::Error<TeamFolderListError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/team_folder/list",
            arg,
            None)
    )
}

/// Once a cursor has been retrieved from [`team_folder_list()`](crate::team::team_folder_list), use
/// this to paginate through all team folders. Permission : Team member file access.
pub fn team_folder_list_continue(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &TeamFolderListContinueArg,
) -> Result<TeamFolderListResult, crate::Error<TeamFolderListContinueError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/team_folder/list/continue",
            arg,
            None)
    )
}

/// Permanently deletes an archived team folder. This endpoint cannot be used for teams that have a
/// shared team space. Permission : Team member file access.
pub fn team_folder_permanently_delete(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &TeamFolderIdArg,
) -> Result<(), crate::Error<TeamFolderPermanentlyDeleteError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/team_folder/permanently_delete",
            arg,
            None)
    )
}

/// Changes an active team folder's name. Permission : Team member file access.
pub fn team_folder_rename(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &TeamFolderRenameArg,
) -> Result<TeamFolderMetadata, crate::Error<TeamFolderRenameError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/team_folder/rename",
            arg,
            None)
    )
}

/// Sets an inactive team folder's status to active. Permission: Team member file access.
///
/// # Stability
/// *PREVIEW*: This function may change or disappear without notice.
#[cfg(feature = "unstable")]
#[cfg_attr(docsrs, doc(cfg(feature = "unstable")))]
pub fn team_folder_restore(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &TeamFolderIdArg,
) -> Result<TeamFolderMetadata, crate::Error<TeamFolderRestoreError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/team_folder/restore",
            arg,
            None)
    )
}

/// Updates the sync settings on a team folder or its contents.  Use of this endpoint requires that
/// the team has team selective sync enabled.
pub fn team_folder_update_sync_settings(
    client: &impl crate::client_trait::TeamAuthClient,
    arg: &TeamFolderUpdateSyncSettingsArg,
) -> Result<TeamFolderMetadata, crate::Error<TeamFolderUpdateSyncSettingsError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/team_folder/update_sync_settings",
            arg,
            None)
    )
}

/// Returns the member profile of the admin who generated the team access token used to make the
/// call.
pub fn token_get_authenticated_admin(
    client: &impl crate::client_trait::TeamAuthClient,
) -> Result<TokenGetAuthenticatedAdminResult, crate::Error<TokenGetAuthenticatedAdminError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "team/token/get_authenticated_admin",
            &(),
            None)
    )
}