AccountsApi (DropBuddies Core API 1.0.0 API)

```
public interface AccountsApi
```

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`retrofit2.Call<InlineResponse2001>`	`apiAccountsAccountTypeAccountIdGet(String accountType, String accountId)` Retrieve details about an account Retrieve account details
`retrofit2.Call<Void>`	`apiAccountsAccountTypeDeactivateDelete(String accountType)` Account is temporary deactivated and finally removed after 7days Account is temporary deactivated
`retrofit2.Call<Void>`	`apiAccountsAccountTypeDeleteDelete(String accountType)` Account is temporary deleted and finally removed after 7days Account deletion
`retrofit2.Call<InlineResponse2001>`	`apiAccountsAccountTypeGet(String accountType)` Returns the account tied the JWT-Token Returns the account tied the JWT-Token.
`retrofit2.Call<Void>`	`apiAccountsAccountTypeUpdatePost(String accountType)` Update account details Update account information
`retrofit2.Call<Void>`	`apiAccountsDropbuddyApplyGet()` Account can apply as a dropbuddy Account can apply as a dropbuddy
`retrofit2.Call<InlineResponse200>`	`apiAccountsGet()` Returns the available account types Returns the available account types, the preferred account type can be appended after `/api/accounts/`to perform accounts based requests
`retrofit2.Call<Void>`	`authenticateAccountTypeActivateActivationCodeGet(String accountType, String activationCode, String email)` Activate account Activate account
`retrofit2.Call<InlineResponse2001>`	`authenticateAccountTypeCreatePost(String accountType, Account body)` Create an account of the corresponding type in the endpoint Create an account of the corresponding type in the endpoint
`retrofit2.Call<InlineResponse2007>`	`authenticateAccountTypePost(String accountType, String email, String password)` Signin a user by providing their email and password Generated jwt_token expires after one week, after which you have to call the renew api endpoint
`retrofit2.Call<Void>`	`authenticateAccountTypeResetConfirmCodePost(String accountType, String code, Account body)` Reset Account confirmation Reset Account confirmation
`retrofit2.Call<Void>`	`authenticateAccountTypeResetPost(String accountType, Account body)` Reset account Reset account
`retrofit2.Call<InlineResponse2007>`	`authenticateAccountTypeTokenRenewPost(String accountType, String accessToken, String jwtToken)` Renew a token by providing the access_token and jwt_token provided after successful login You can renew token without requesting the user to sign in again
`retrofit2.Call<InlineResponse2007>`	`authenticateDeveloperNewTokenPost(Account body, AuthenticatorLog body2)` Developer can request a new token that is tied to his account Developer can request a new token that is tied to his account

Method Detail

apiAccountsAccountTypeAccountIdGet

@GET(value="api/accounts/{account_type}/{account_id}")
retrofit2.Call<InlineResponse2001> apiAccountsAccountTypeAccountIdGet(@Path(value="account_type")
                                                                                                                             String accountType,
                                                                                                                             @Path(value="account_id")
                                                                                                                             String accountId)

Retrieve details about an account Retrieve account details

Parameters:: accountType - Account type (required); accountId - Account Id (required)
Returns:: Call<InlineResponse2001>

apiAccountsAccountTypeDeactivateDelete

@DELETE(value="api/accounts/{account_type}/deactivate")
retrofit2.Call<Void> apiAccountsAccountTypeDeactivateDelete(@Path(value="account_type")
                                                                                                                    String accountType)

Account is temporary deactivated and finally removed after 7days Account is temporary deactivated

Parameters:: accountType - Account type (required)
Returns:: Call<Void>

apiAccountsAccountTypeDeleteDelete

@DELETE(value="api/accounts/{account_type}/delete")
retrofit2.Call<Void> apiAccountsAccountTypeDeleteDelete(@Path(value="account_type")
                                                                                                            String accountType)

Account is temporary deleted and finally removed after 7days Account deletion

Parameters:: accountType - Account type (required)
Returns:: Call<Void>

apiAccountsAccountTypeGet

@GET(value="api/accounts/{account_type}")
retrofit2.Call<InlineResponse2001> apiAccountsAccountTypeGet(@Path(value="account_type")
                                                                                                       String accountType)

Returns the account tied the JWT-Token Returns the account tied the JWT-Token. Use the endpoint to get user information after successfull login

Parameters:: accountType - Account type (required)
Returns:: Call<InlineResponse2001>

apiAccountsAccountTypeUpdatePost

@POST(value="api/accounts/{account_type}/update")
retrofit2.Call<Void> apiAccountsAccountTypeUpdatePost(@Path(value="account_type")
                                                                                                        String accountType)

Update account details Update account information

Parameters:: accountType - Account type (required)
Returns:: Call<Void>

apiAccountsDropbuddyApplyGet
```
@GET(value="api/accounts/dropbuddy/apply")
retrofit2.Call<Void> apiAccountsDropbuddyApplyGet()
```
Account can apply as a dropbuddy Account can apply as a dropbuddy

Returns:

Call<Void>

apiAccountsGet
```
@GET(value="api/accounts")
retrofit2.Call<InlineResponse200> apiAccountsGet()
```
Returns the available account types Returns the available account types, the preferred account type can be appended after `/api/accounts/`to perform accounts based requests

Returns:

Call<InlineResponse200>

authenticateAccountTypeActivateActivationCodeGet

@GET(value="authenticate/{account_type}/activate/{activation_code}")
retrofit2.Call<Void> authenticateAccountTypeActivateActivationCodeGet(@Path(value="account_type")
                                                                                                                                           String accountType,
                                                                                                                                           @Path(value="activation_code")
                                                                                                                                           String activationCode,
                                                                                                                                           @Query(value="email")
                                                                                                                                           String email)

Activate account Activate account

Parameters:: accountType - Account type (required); activationCode - Activation code sent to users email (required); email - Email address (required)
Returns:: Call<Void>

authenticateAccountTypeCreatePost

@POST(value="authenticate/{account_type}/create")
retrofit2.Call<InlineResponse2001> authenticateAccountTypeCreatePost(@Path(value="account_type")
                                                                                                                       String accountType,
                                                                                                                       @Body
                                                                                                                       Account body)

Create an account of the corresponding type in the endpoint Create an account of the corresponding type in the endpoint

Parameters:: accountType - Account type (required); body - Should be sent as body of the request (required)
Returns:: Call<InlineResponse2001>

authenticateAccountTypePost

@POST(value="authenticate/{account_type}")
retrofit2.Call<InlineResponse2007> authenticateAccountTypePost(@Path(value="account_type")
                                                                                                          String accountType,
                                                                                                          @Body
                                                                                                          String email,
                                                                                                          @Body
                                                                                                          String password)

Signin a user by providing their email and password Generated jwt_token expires after one week, after which you have to call the renew api endpoint

Parameters:: accountType - Account type (required); email - (required); password - (required)
Returns:: Call<InlineResponse2007>

authenticateAccountTypeResetConfirmCodePost

@POST(value="authenticate/{account_type}/reset/confirm/{code}")
retrofit2.Call<Void> authenticateAccountTypeResetConfirmCodePost(@Path(value="account_type")
                                                                                                                                 String accountType,
                                                                                                                                 @Path(value="code")
                                                                                                                                 String code,
                                                                                                                                 @Body
                                                                                                                                 Account body)

Reset Account confirmation Reset Account confirmation

Parameters:: accountType - Account type (required); code - Reset code sent via email (required); body - Properties of account that needs to be change. Mostly password or email (required)
Returns:: Call<Void>

authenticateAccountTypeResetPost

@POST(value="authenticate/{account_type}/reset")
retrofit2.Call<Void> authenticateAccountTypeResetPost(@Path(value="account_type")
                                                                                                       String accountType,
                                                                                                       @Body
                                                                                                       Account body)

Reset account Reset account

Parameters:: accountType - Account type (required); body - Should be sent as body of the request (required)
Returns:: Call<Void>

authenticateAccountTypeTokenRenewPost

@POST(value="authenticate/{account_type}/token/renew")
retrofit2.Call<InlineResponse2007> authenticateAccountTypeTokenRenewPost(@Path(value="account_type")
                                                                                                                                String accountType,
                                                                                                                                @Body
                                                                                                                                String accessToken,
                                                                                                                                @Body
                                                                                                                                String jwtToken)

Renew a token by providing the access_token and jwt_token provided after successful login You can renew token without requesting the user to sign in again

Parameters:: accountType - Account type (required); accessToken - (required); jwtToken - (required)
Returns:: Call<InlineResponse2007>

authenticateDeveloperNewTokenPost

@POST(value="authenticate/developer/new-token")
retrofit2.Call<InlineResponse2007> authenticateDeveloperNewTokenPost(@Body
                                                                                                                     Account body,
                                                                                                                     @Body
                                                                                                                     AuthenticatorLog body2)

Developer can request a new token that is tied to his account Developer can request a new token that is tied to his account

Parameters:: body - Some parameters from Account are allowed (required); body2 - Some parameters from AuthenticatorLog are allowed (required)
Returns:: Call<InlineResponse2007>

Interface AccountsApi