public Account(int accountNumber, string name, AccountType accountAccountType)
 {
     AccountNumber = accountNumber;
     Name = name;
     Type = accountAccountType;
     _transactions = new List<ITransaction>();
 }

 public SignedInUser(AccountType accountType, int userId, string userName, bool isAuthenticated)
 {
     AccountType = accountType;
     AccountId = userId;
     UserName = userName;
     IsAuthenticated = isAuthenticated;
 }

 public TinyPicUploader(string id, string key, AccountType accountType = AccountType.Anonymous, string shuk = null)
 {
     TinyPicID = id;
     TinyPicKey = key;
     AccountType = accountType;
     Shuk = shuk;
 }

        public void CreditAccount(AccountType accountType, Money amount)
        {
            GuardPortfolioState();

            var account = Get<Account>(new AccountId(accountType));
            account.Credit(amount);
        }

 public Account( int num, AccountType type )
 {
     Number = num;
     Amount = 0;
     Type = type;
     History = new List<HistoryEntry>();
 }

 public Account(string email, string name, AccountType role)
 {
     id = -1;
     this.Email = email;
     this.Name = name;
     this.Role = role;
 }

 public SteamAccount(string username, string password)
 {
     this.name = username;
     this.username = username;
     this.password = password;
     this.type = AccountType.Main;
 }

 internal AdalAccountSession(
     IDictionary<string, string> authenticationResponseValues,
     string clientId = null,
     AccountType accountType = AccountType.None)
     : base(authenticationResponseValues, clientId, accountType)
 {
 }

 public Account(AccountType type, Customer accountCustumer, decimal balance, decimal interestRate)
 {
     this.Type = type;
     this.AccountCustomer = accountCustumer;
     this.Balance = balance;
     this.InterestRate = interestRate;
 }

 public AccountAlreadyOpened(AccountType type, Int64 number, Decimal balance, AccountStatus status)
 {
     AccountType = type;
     AccountNumber = number;
     Balance = balance;
     Status = status;
 }

 internal Account(AccountTypeEnum accountType, Money initialDeposit)
 {
     this.accountType = accountType;
     ledger = new Ledger(accountType);
     this.accountType.ValidateBalance(initialDeposit);
     ledger.DepositMoney(initialDeposit);
 }

        public static bool CanFindAccount(this Cmdlet command, AccountIdentity account, AccountType accountType)
        {
            if (account == null)
            {
                return false;
            }
            var name = account.Name;
            var error = $"Cannot find an account with identity '{name}'.";

            if (accountType == AccountType.Role && !Role.Exists(name))
            {
                command.WriteError(new ErrorRecord(new ObjectNotFoundException(error), ErrorIds.AccountNotFound.ToString(),
                    ErrorCategory.ObjectNotFound, account));
                return false;
            }

            if (accountType == AccountType.User && !User.Exists(name))
            {
                command.WriteError(new ErrorRecord(new ObjectNotFoundException(error), ErrorIds.AccountNotFound.ToString(),
                    ErrorCategory.ObjectNotFound, account));
                return false;
            }

            return true;
        }

 /// <summary>
 /// Factory method to assemble and return an account based on passed account type.
 /// </summary>
 /// <param name="accountType">Type of the account.</param>
 /// <returns>
 /// new account
 /// </returns>
 /// <exception cref="System.ArgumentException"></exception>
 public Account CreateAccount(AccountType accountType)
 {
     Func<IDateProvider, Account> f;
     if (!accMap.TryGetValue(accountType, out f))
         throw new ArgumentException(string.Format("Cannot instantiate account of type {0}", accountType));
     return f(dateProvider);
 }

 public void SetAccountType(AccountType type)
 {
     if ((Application.platform != RuntimePlatform.OSXEditor) && (Application.platform != RuntimePlatform.WindowsEditor))
     {
         _tdgaSetAccountType((int) type);
     }
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="Account"/> class.
 /// </summary>
 /// <param name="accountType">Type of the account.</param>
 /// <param name="interestCalculator">The interest calculator.</param>
 /// <param name="dateProvider">The date provider.</param>
 public Account(AccountType accountType,IInterestCalculator interestCalculator,IDateProvider dateProvider)
 {
     AccountType = accountType;
     transactionsList = new List<Transaction>();
     this.interestCalculator = interestCalculator;
     this.dateProvider = dateProvider;
 }

 protected Account(string avatarUrl, string bio, string blog, int collaborators, string company, DateTimeOffset createdAt, int diskUsage, string email, int followers, int following, bool? hireable, string htmlUrl, int totalPrivateRepos, int id, string location, string login, string name, int ownedPrivateRepos, Plan plan, int privateGists, int publicGists, int publicRepos, AccountType type, string url)
 {
     AvatarUrl = avatarUrl;
     Bio = bio;
     Blog = blog;
     Collaborators = collaborators;
     Company = company;
     CreatedAt = createdAt;
     DiskUsage = diskUsage;
     Email = email;
     Followers = followers;
     Following = following;
     Hireable = hireable;
     HtmlUrl = htmlUrl;
     TotalPrivateRepos = totalPrivateRepos;
     Id = id;
     Location = location;
     Login = login;
     Name = name;
     OwnedPrivateRepos = ownedPrivateRepos;
     Plan = plan;
     PrivateGists = privateGists;
     PublicGists = publicGists;
     PublicRepos = publicRepos;
     Type = type;
     Url = url;
 }

 /// <summary>
 /// Internal constructor.
 /// </summary>
 protected Account(AccountType accountType, BalanceType defaultBalanceType)
     : base()
 {
     this.AccountID = Guid.NewGuid();
     this.AccountType = accountType;
     this.DefaultBalanceType = defaultBalanceType;
 }

        private static Account CreateAccount(string name, AccountType accountType)
        {
            var account = new Account(name, accountType);
            account.Id = Regex.Replace(account.Name.ToLower(), "[^a-z0-9-/]", "");

            return account;
        }

 public WindowsAccount(string name, bool? enabled, string accountSID, AccountType type)
 {
     this.Name = name;
     this.Enabled = enabled;// ?? true;
     this.AccountSID = accountSID;
     this.AccountType = type;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="RateEndpoints"/> class.
 /// </summary>
 /// <param name="key">The key.</param>
 /// <param name="accountType">Type of the account.</param>
 /// <param name="accountId">The account identifier.</param>
 public RateEndpoints(string key, AccountType accountType, int accountId)
     : base(key, accountType)
 {
     _accountId = accountId;
     _key = key;
     _accountType = accountType;
 }