UserStore

type AuthenticateArgs struct {
	Username          string `thrift:"username,1"`
	Password          string `thrift:"password,2"`
	ConsumerKey       string `thrift:"consumerKey,3"`
	ConsumerSecret    string `thrift:"consumerSecret,4"`
	SupportsTwoFactor bool   `thrift:"supportsTwoFactor,5"`
}

type AuthenticateLongSessionArgs struct {
	Username          string `thrift:"username,1"`
	Password          string `thrift:"password,2"`
	ConsumerKey       string `thrift:"consumerKey,3"`
	ConsumerSecret    string `thrift:"consumerSecret,4"`
	DeviceIdentifier  string `thrift:"deviceIdentifier,5"`
	DeviceDescription string `thrift:"deviceDescription,6"`
	SupportsTwoFactor bool   `thrift:"supportsTwoFactor,7"`
}

type AuthenticateLongSessionResult struct {
	Success         *AuthenticationResult       `thrift:"success,0"`
	UserException   *Errors.EDAMUserException   `thrift:"userException,1"`
	SystemException *Errors.EDAMSystemException `thrift:"systemException,2"`
}

type AuthenticateResult struct {
	Success         *AuthenticationResult       `thrift:"success,0"`
	UserException   *Errors.EDAMUserException   `thrift:"userException,1"`
	SystemException *Errors.EDAMSystemException `thrift:"systemException,2"`
}

type AuthenticateToBusinessArgs struct {
	AuthenticationToken string `thrift:"authenticationToken,1"`
}

type AuthenticateToBusinessResult struct {
	Success         *AuthenticationResult       `thrift:"success,0"`
	UserException   *Errors.EDAMUserException   `thrift:"userException,1"`
	SystemException *Errors.EDAMSystemException `thrift:"systemException,2"`
}

type AuthenticationResult struct {
	CurrentTime              Types.Timestamp `thrift:"currentTime,1,required"`
	AuthenticationToken      string          `thrift:"authenticationToken,2,required"`
	Expiration               Types.Timestamp `thrift:"expiration,3,required"`
	User                     *Types.User     `thrift:"user,4"`
	PublicUserInfo           *PublicUserInfo `thrift:"publicUserInfo,5"`
	NoteStoreUrl             string          `thrift:"noteStoreUrl,6"`
	WebApiUrlPrefix          string          `thrift:"webApiUrlPrefix,7"`
	SecondFactorRequired     bool            `thrift:"secondFactorRequired,8"`
	SecondFactorDeliveryHint string          `thrift:"secondFactorDeliveryHint,9"`
}

type BootstrapInfo struct {
	Profiles []*BootstrapProfile `thrift:"profiles,1,required"`
}

type BootstrapProfile struct {
	Name     string             `thrift:"name,1,required"`
	Settings *BootstrapSettings `thrift:"settings,2,required"`
}

type BootstrapSettings struct {
	ServiceHost             string `thrift:"serviceHost,1,required"`
	MarketingUrl            string `thrift:"marketingUrl,2,required"`
	SupportUrl              string `thrift:"supportUrl,3,required"`
	AccountEmailDomain      string `thrift:"accountEmailDomain,4,required"`
	EnableFacebookSharing   bool   `thrift:"enableFacebookSharing,5"`
	EnableGiftSubscriptions bool   `thrift:"enableGiftSubscriptions,6"`
	EnableSupportTickets    bool   `thrift:"enableSupportTickets,7"`
	EnableSharedNotebooks   bool   `thrift:"enableSharedNotebooks,8"`
	EnableSingleNoteSharing bool   `thrift:"enableSingleNoteSharing,9"`
	EnableSponsoredAccounts bool   `thrift:"enableSponsoredAccounts,10"`
	EnableTwitterSharing    bool   `thrift:"enableTwitterSharing,11"`
	EnableLinkedInSharing   bool   `thrift:"enableLinkedInSharing,12"`
	EnablePublicNotebooks   bool   `thrift:"enablePublicNotebooks,13"`
}

type CheckVersionArgs struct {
	ClientName       string `thrift:"clientName,1"`
	EdamVersionMajor int16  `thrift:"edamVersionMajor,2"`
	EdamVersionMinor int16  `thrift:"edamVersionMinor,3"`
}

type CheckVersionResult struct {
	Success bool `thrift:"success,0"`
}

type CompleteTwoFactorAuthenticationArgs struct {
	AuthenticationToken string `thrift:"authenticationToken,1"`
	OneTimeCode         string `thrift:"oneTimeCode,2"`
	DeviceIdentifier    string `thrift:"deviceIdentifier,3"`
	DeviceDescription   string `thrift:"deviceDescription,4"`
}

type CompleteTwoFactorAuthenticationResult struct {
	Success         *AuthenticationResult       `thrift:"success,0"`
	UserException   *Errors.EDAMUserException   `thrift:"userException,1"`
	SystemException *Errors.EDAMSystemException `thrift:"systemException,2"`
}

type GetBootstrapInfoArgs struct {
	Locale string `thrift:"locale,1"`
}

type GetBootstrapInfoResult struct {
	Success *BootstrapInfo `thrift:"success,0"`
}

type GetNoteStoreUrlArgs struct {
	AuthenticationToken string `thrift:"authenticationToken,1"`
}

type GetNoteStoreUrlResult struct {
	Success         string                      `thrift:"success,0"`
	UserException   *Errors.EDAMUserException   `thrift:"userException,1"`
	SystemException *Errors.EDAMSystemException `thrift:"systemException,2"`
}

type GetPremiumInfoArgs struct {
	AuthenticationToken string `thrift:"authenticationToken,1"`
}

type GetPremiumInfoResult struct {
	Success         *Types.PremiumInfo          `thrift:"success,0"`
	UserException   *Errors.EDAMUserException   `thrift:"userException,1"`
	SystemException *Errors.EDAMSystemException `thrift:"systemException,2"`
}

type GetPublicUserInfoArgs struct {
	Username string `thrift:"username,1"`
}

type GetPublicUserInfoResult struct {
	Success           *PublicUserInfo               `thrift:"success,0"`
	NotFoundException *Errors.EDAMNotFoundException `thrift:"notFoundException,1"`
	SystemException   *Errors.EDAMSystemException   `thrift:"systemException,2"`
	UserException     *Errors.EDAMUserException     `thrift:"userException,3"`
}

type GetUserArgs struct {
	AuthenticationToken string `thrift:"authenticationToken,1"`
}

type GetUserResult struct {
	Success         *Types.User                 `thrift:"success,0"`
	UserException   *Errors.EDAMUserException   `thrift:"userException,1"`
	SystemException *Errors.EDAMSystemException `thrift:"systemException,2"`
}

type PublicUserInfo struct {
	UserId          Types.UserID         `thrift:"userId,1,required"`
	ShardId         string               `thrift:"shardId,2,required"`
	Privilege       Types.PrivilegeLevel `thrift:"privilege,3"`
	Username        string               `thrift:"username,4"`
	NoteStoreUrl    string               `thrift:"noteStoreUrl,5"`
	WebApiUrlPrefix string               `thrift:"webApiUrlPrefix,6"`
}

type RefreshAuthenticationArgs struct {
	AuthenticationToken string `thrift:"authenticationToken,1"`
}

type RefreshAuthenticationResult struct {
	Success         *AuthenticationResult       `thrift:"success,0"`
	UserException   *Errors.EDAMUserException   `thrift:"userException,1"`
	SystemException *Errors.EDAMSystemException `thrift:"systemException,2"`
}

type RevokeLongSessionArgs struct {
	AuthenticationToken string `thrift:"authenticationToken,1"`
}

type RevokeLongSessionResult struct {
	UserException   *Errors.EDAMUserException   `thrift:"userException,1"`
	SystemException *Errors.EDAMSystemException `thrift:"systemException,2"`
}

type UserStore interface {

	// This should be the first call made by a client to the EDAM service.  It
	// tells the service what protocol version is used by the client.  The
	// service will then return true if the client is capable of talking to
	// the service, and false if the client's protocol version is incompatible
	// with the service, so the client must upgrade.  If a client receives a
	// false value, it should report the incompatibility to the user and not
	// continue with any more EDAM requests (UserStore or NoteStore).
	//
	// @param clientName
	//   This string provides some information about the client for
	//   tracking/logging on the service.  It should provide information about
	//   the client's software and platform. The structure should be:
	//   application/version; platform/version; [ device/version ]
	//   E.g. "Evernote Windows/3.0.1; Windows/XP SP3".
	//
	// @param edamVersionMajor
	//   This should be the major protocol version that was compiled by the
	//   client.  This should be the current value of the EDAM_VERSION_MAJOR
	//   constant for the client.
	//
	// @param edamVersionMinor
	//   This should be the major protocol version that was compiled by the
	//   client.  This should be the current value of the EDAM_VERSION_MINOR
	//   constant for the client.
	//
	// Parameters:
	//  - ClientName
	//  - EdamVersionMajor
	//  - EdamVersionMinor
	CheckVersion(clientName string, edamVersionMajor int16, edamVersionMinor int16) (r bool, err error)
	// This provides bootstrap information to the client. Various bootstrap
	// profiles and settings may be used by the client to configure itself.
	//
	// @param locale
	//   The client's current locale, expressed in language[_country]
	//   format. E.g., "en_US". See ISO-639 and ISO-3166 for valid
	//   language and country codes.
	//
	// @return
	//   The bootstrap information suitable for this client.
	//
	// Parameters:
	//  - Locale
	GetBootstrapInfo(locale string) (r *BootstrapInfo, err error)
	// This is used to check a username and password in order to create a
	// short-lived authentication session that can be used for further actions.
	//
	// This function is only available to Evernote's internal applications.
	// Third party applications must authenticate using OAuth as
	// described at
	// <a href="http://dev.evernote.com/documentation/cloud/">dev.evernote.com</a>.
	//
	// @param username
	//   The username (not numeric user ID) for the account to
	//   authenticate against.  This function will also accept the user's
	//   registered email address in this parameter.
	//
	// @param password
	//   The plaintext password to check against the account.  Since
	//   this is not protected by the EDAM protocol, this information must be
	//   provided over a protected transport (e.g. SSL).
	//
	// @param consumerKey
	//   The "consumer key" portion of the API key issued to the client application
	//   by Evernote.
	//
	// @param consumerSecret
	//   The "consumer secret" portion of the API key issued to the client application
	//   by Evernote.
	//
	// @param supportsTwoFactor
	//   Whether the calling application supports two-factor authentication. If this
	//   parameter is false, this method will fail with the error code INVALID_AUTH and the
	//   parameter "password" when called for a user who has enabled two-factor
	//   authentication.
	//
	// @return
	//   <p>The result of the authentication.  If the authentication was successful,
	//   the AuthenticationResult.user field will be set with the full information
	//   about the User.</p>
	//   <p>If the user has two-factor authentication enabled,
	//   AuthenticationResult.secondFactorRequired will be set and
	//   AuthenticationResult.authenticationToken will contain a short-lived token
	//   that may only be used to complete the two-factor authentication process by calling
	//   UserStore.completeTwoFactorAuthentication.</p>
	//
	// @throws EDAMUserException <ul>
	//   <li> DATA_REQUIRED "username" - username is empty
	//   <li> DATA_REQUIRED "password" - password is empty
	//   <li> DATA_REQUIRED "consumerKey" - consumerKey is empty
	//   <li> INVALID_AUTH "username" - username not found
	//   <li> INVALID_AUTH "password" - password did not match
	//   <li> INVALID_AUTH "consumerKey" - consumerKey is not authorized
	//   <li> INVALID_AUTH "consumerSecret" - consumerSecret is incorrect
	//   <li> PERMISSION_DENIED "User.active" - user account is closed
	//   <li> PERMISSION_DENIED "User.tooManyFailuresTryAgainLater" - user has
	//     failed authentication too often
	// </ul>
	//
	// Parameters:
	//  - Username
	//  - Password
	//  - ConsumerKey
	//  - ConsumerSecret
	//  - SupportsTwoFactor
	Authenticate(ctx context.Context, username string, password string, consumerKey string, consumerSecret string, supportsTwoFactor bool) (r *AuthenticationResult, userException *Errors.EDAMUserException, systemException *Errors.EDAMSystemException, err error)
	// This is used to check a username and password in order to create a
	// long-lived authentication token that can be used for further actions.
	//
	// This function is not available to most third party applications,
	// which typically authenticate using OAuth as
	// described at
	// <a href="http://dev.evernote.com/documentation/cloud/">dev.evernote.com</a>.
	// If you believe that your application requires permission to authenticate
	// using username and password instead of OAuth, please contact Evernote
	// developer support by visiting
	// <a href="http://dev.evernote.com">dev.evernote.com</a>.
	//
	// @param username
	//   The username or registered email address of the account to
	//   authenticate against.
	//
	// @param password
	//   The plaintext password to check against the account.  Since
	//   this is not protected by the EDAM protocol, this information must be
	//   provided over a protected transport (i.e. SSL).
	//
	// @param consumerKey
	//   The "consumer key" portion of the API key issued to the client application
	//   by Evernote.
	//
	// @param consumerSecret
	//   The "consumer secret" portion of the API key issued to the client application
	//   by Evernote.
	//
	// @param deviceIdentifier
	//   An optional string, no more than 32 characters in length, that uniquely identifies
	//   the device from which the authentication is being performed. This string allows
	//   the service to return the same authentication token when a given application
	//   requests authentication repeatedly from the same device. This may happen when the
	//   user logs out of an application and then logs back in, or when the application is
	//   uninstalled and later reinstalled. If no reliable device identifier can be created,
	//   this value should be omitted. If set, the device identifier must be between
	//   1 and EDAM_DEVICE_ID_LEN_MAX characters long and must match the regular expression
	//   EDAM_DEVICE_ID_REGEX.
	//
	// @param deviceDescription
	//   A description of the device from which the authentication is being performed.
	//   This field is displayed to the user in a list of authorized applications to
	//   allow them to distinguish between multiple tokens issued to the same client
	//   application on different devices. For example, the Evernote iOS client on
	//   a user's iPhone and iPad might pass the iOS device names "Bob's iPhone" and
	//   "Bob's iPad". The device description must be between 1 and
	//   EDAM_DEVICE_DESCRIPTION_LEN_MAX characters long and must match the regular
	//   expression EDAM_DEVICE_DESCRIPTION_REGEX.
	//
	// @param supportsTwoFactor
	//   Whether the calling application supports two-factor authentication. If this
	//   parameter is false, this method will fail with the error code INVALID_AUTH and the
	//   parameter "password" when called for a user who has enabled two-factor
	//   authentication.
	//
	// @return
	//   <p>The result of the authentication. The level of detail provided in the returned
	//   AuthenticationResult.User structure depends on the access level granted by
	//   calling application's API key.</p>
	//   <p>If the user has two-factor authentication enabled,
	//   AuthenticationResult.secondFactorRequired will be set and
	//   AuthenticationResult.authenticationToken will contain a short-lived token
	//   that may only be used to complete the two-factor authentication process by calling
	//   UserStore.completeTwoFactorAuthentication.</p>
	//
	// @throws EDAMUserException <ul>
	//   <li> DATA_REQUIRED "username" - username is empty
	//   <li> DATA_REQUIRED "password" - password is empty
	//   <li> DATA_REQUIRED "consumerKey" - consumerKey is empty
	//   <li> DATA_REQUIRED "consumerSecret" - consumerSecret is empty
	//   <li> DATA_REQUIRED "deviceDescription" - deviceDescription is empty
	//   <li> BAD_DATA_FORMAT "deviceDescription" - deviceDescription is not valid.
	//   <li> BAD_DATA_FORMAT "deviceIdentifier" - deviceIdentifier is not valid.
	//   <li> INVALID_AUTH "username" - username not found
	//   <li> INVALID_AUTH "password" - password did not match
	//   <li> INVALID_AUTH "consumerKey" - consumerKey is not authorized
	//   <li> INVALID_AUTH "consumerSecret" - consumerSecret is incorrect
	//   <li> PERMISSION_DENIED "User.active" - user account is closed
	//   <li> PERMISSION_DENIED "User.tooManyFailuresTryAgainLater" - user has
	//     failed authentication too often
	// </ul>
	//
	// Parameters:
	//  - Username
	//  - Password
	//  - ConsumerKey
	//  - ConsumerSecret
	//  - DeviceIdentifier
	//  - DeviceDescription
	//  - SupportsTwoFactor
	AuthenticateLongSession(ctx context.Context, username string, password string, consumerKey string, consumerSecret string, deviceIdentifier string, deviceDescription string, supportsTwoFactor bool) (r *AuthenticationResult, userException *Errors.EDAMUserException, systemException *Errors.EDAMSystemException, err error)
	// Complete the authentication process when a second factor is required. This
	// call is made after a successful call to authenticate or authenticateLongSession
	// when the authenticating user has enabled two-factor authentication.
	//
	// @param authenticationToken An authentication token returned by a previous
	//   call to UserStore.authenticate or UserStore.authenticateLongSession that
	//   could not be completed in a single call because a second factor was required.
	//
	// @param oneTimeCode The one time code entered by the user. This value is delivered
	//   out-of-band, typically via SMS or an authenticator application.
	//
	// @param deviceIdentifier See the corresponding parameter in authenticateLongSession.
	//
	// @param deviceDescription See the corresponding parameter in authenticateLongSession.
	//
	// @return
	//   The result of the authentication. The level of detail provided in the returned
	//   AuthenticationResult.User structure depends on the access level granted by the
	//   calling application's API key. If the initial authentication call was made to
	//   authenticateLongSession, the AuthenticationResult will contain a long-lived
	//   authentication token.
	//
	// @throws EDAMUserException <ul>
	//   <li> DATA_REQUIRED "authenticationToken" - authenticationToken is empty
	//   <li> DATA_REQUIRED "oneTimeCode" - oneTimeCode is empty
	//   <li> BAD_DATA_FORMAT "authenticationToken" - authenticationToken is not well formed
	//   <li> INVALID_AUTH "oneTimeCode" - oneTimeCode did not match
	//   <li> AUTH_EXPIRED "authenticationToken" - authenticationToken has expired
	//   <li> PERMISSION_DENIED "authenticationToken" - authenticationToken is not valid
	//   <li> PERMISSION_DENIED "User.active" - user account is closed
	//   <li> PERMISSION_DENIED "User.tooManyFailuresTryAgainLater" - user has
	//     failed authentication too often
	//   <li> DATA_CONFLICT "User.twoFactorAuthentication" - The user has not enabled
	//      two-factor authentication.</li>
	// </ul>
	//
	// Parameters:
	//  - AuthenticationToken
	//  - OneTimeCode
	//  - DeviceIdentifier
	//  - DeviceDescription
	CompleteTwoFactorAuthentication(ctx context.Context, authenticationToken string, oneTimeCode string, deviceIdentifier string, deviceDescription string) (r *AuthenticationResult, userException *Errors.EDAMUserException, systemException *Errors.EDAMSystemException, err error)
	// Revoke an existing long lived authentication token. This can be used to
	// revoke OAuth tokens or tokens created by calling authenticateLongSession,
	// and allows a user to effectively log out of Evernote from the perspective
	// of the application that holds the token. The authentication token that is
	// passed is immediately revoked and may not be used to call any authenticated
	// EDAM function.
	//
	// @param authenticationToken the authentication token to revoke.
	//
	// @throws EDAMUserException <ul>
	//   <li> DATA_REQUIRED "authenticationToken" - no authentication token provided
	//   <li> BAD_DATA_FORMAT "authenticationToken" - the authentication token is not well formed
	//   <li> INVALID_AUTH "authenticationToken" - the authentication token is invalid
	//   <li> AUTH_EXPIRED "authenticationToken" - the authentication token is expired or
	//     is already revoked.
	// </ul>
	//
	// Parameters:
	//  - AuthenticationToken
	RevokeLongSession(ctx context.Context, authenticationToken string) (userException *Errors.EDAMUserException, systemException *Errors.EDAMSystemException, err error)
	// This is used to take an existing authentication token that grants access
	// to an individual user account (returned from 'authenticate',
	// 'authenticateLongSession' or an OAuth authorization) and obtain an additional
	// authentication token that may be used to access business notebooks if the user
	// is a member of an Evernote Business account.
	//
	// The resulting authentication token may be used to make NoteStore API calls
	// against the business using the NoteStore URL returned in the result.
	//
	// @param authenticationToken
	//   The authentication token for the user. This may not be a shared authentication
	//   token (returned by NoteStore.authenticateToSharedNotebook or
	//   NoteStore.authenticateToSharedNote) or a business authentication token.
	//
	// @return
	//   The result of the authentication, with the token granting access to the
	//   business in the result's 'authenticationToken' field. The URL that must
	//   be used to access the business account NoteStore will be returned in the
	//   result's 'noteStoreUrl' field.  The 'User' field will
	//   not be set in the result.
	//
	// @throws EDAMUserException <ul>
	//   <li> PERMISSION_DENIED "authenticationToken" - the provided authentication token
	//        is a shared or business authentication token. </li>
	//   <li> PERMISSION_DENIED "Business" - the user identified by the provided
	//        authentication token is not currently a member of a business. </li>
	//   <li> PERMISSION_DENIED "Business.status" - the business that the user is a
	//        member of is not currently in an active status. </li>
	// </ul>
	//
	// Parameters:
	//  - AuthenticationToken
	AuthenticateToBusiness(ctx context.Context, authenticationToken string) (r *AuthenticationResult, userException *Errors.EDAMUserException, systemException *Errors.EDAMSystemException, err error)
	// This is used to take an existing authentication token (returned from
	// 'authenticate') and exchange it for a newer token which will not expire
	// as soon.  This must be invoked before the previous token expires.
	//
	// This function is only availabe to Evernote's internal applications.
	//
	// @param authenticationToken
	//   The previous authentication token from the authenticate() result.
	//
	// @return
	//   The result of the authentication, with the new token in
	//   the result's 'authenticationToken' field.  The 'User' field will
	//   not be set in the result.
	//
	// Parameters:
	//  - AuthenticationToken
	RefreshAuthentication(ctx context.Context, authenticationToken string) (r *AuthenticationResult, userException *Errors.EDAMUserException, systemException *Errors.EDAMSystemException, err error)
	// Returns the User corresponding to the provided authentication token,
	// or throws an exception if this token is not valid.
	// The level of detail provided in the returned User structure depends on
	// the access level granted by the token, so a web service client may receive
	// fewer fields than an integrated desktop client.
	//
	// Parameters:
	//  - AuthenticationToken
	GetUser(ctx context.Context, authenticationToken string) (r *Types.User, userException *Errors.EDAMUserException, systemException *Errors.EDAMSystemException, err error)
	// Asks the UserStore about the publicly available location information for
	// a particular username.
	//
	// @throws EDAMUserException <ul>
	//   <li> DATA_REQUIRED "username" - username is empty
	// </ul>
	//
	// Parameters:
	//  - Username
	GetPublicUserInfo(ctx context.Context, username string) (r *PublicUserInfo, notFoundException *Errors.EDAMNotFoundException, systemException *Errors.EDAMSystemException, userException *Errors.EDAMUserException, err error)
	// Returns information regarding a user's Premium account corresponding to the
	// provided authentication token, or throws an exception if this token is not
	// valid.
	//
	// Parameters:
	//  - AuthenticationToken
	GetPremiumInfo(ctx context.Context, authenticationToken string) (r *Types.PremiumInfo, userException *Errors.EDAMUserException, systemException *Errors.EDAMSystemException, err error)
	// Returns the URL that should be used to talk to the NoteStore for the
	// account represented by the provided authenticationToken.
	// This method isn't needed by most clients, who can retrieve the correct
	// NoteStore URL from the AuthenticationResult returned from the authenticate
	// or refreshAuthentication calls. This method is typically only needed
	// to look up the correct URL for a long-lived session token (e.g. for an
	// OAuth web service).
	//
	// Parameters:
	//  - AuthenticationToken
	GetNoteStoreUrl(ctx context.Context, authenticationToken string) (r string, userException *Errors.EDAMUserException, systemException *Errors.EDAMSystemException, err error)
}

type UserStoreClient struct {
	Transport       thrift.TTransport
	ProtocolFactory thrift.TProtocolFactory
	InputProtocol   thrift.TProtocol
	OutputProtocol  thrift.TProtocol
	SeqId           int32
}

type UserStoreProcessor struct {
	// contains filtered or unexported fields
}