:param account:  an account object to be used as a selector
        :param alias:     email alias address
        :returns:         None (the API itself returns nothing)
427453
def remove_account_alias(self, account, alias):
        
        self.request('RemoveAccountAlias', {
            'id': self._get_or_fetch_id(account, self.get_account),
            'alias': alias,
        })
1048364
def GetAlias(session=None):
        
        if session is not None:
            return session['alias']

        if not clc.ALIAS:  clc.v2.API._Login()
        return(clc.ALIAS)
1341985
public OvhResponder domain_responder_account_GET(String domain, String account) throws IOException {
		String qPath = "/email/domain/{domain}/responder/{account}";
		StringBuilder sb = path(qPath, domain, account);
		String resp = exec(qPath, "GET", sb.toString(), null);
		return convertTo(resp, OvhResponder.class);
	}
1198572
def account(self, key=None, address=None, name=None):
        """"""
        if key:
            return self.client.account(key, wallet=self)
        if address:
            q = dict(address=address)
        elif name:
            q = dict(name=name)
        else:
            raise TypeError("Missing param: key, address, or name is required.")

        return Account(
            self.resource.account_query(q).get(), self.client, wallet=self)
91695
def get_account(self, account_id, **kwargs):
        

        if 'mask' not in kwargs:
            kwargs['mask'] = 'status'

        return self.account.getObject(id=account_id, **kwargs)
110718
def set_alias(cls, domain, login, aliases):
        """"""
        return cls.call('domain.mailbox.alias.set', domain, login, aliases)
418168
def accounts(self, id=None):
        
        return Account.load(self, id) if id else Account.all(self)
421269
def get_account_tokens(self, address):
        
        cur = self.db.cursor()
        return namedb_get_account_tokens(cur, address)
993805
def _get(self, target, alias):
        
        if target not in self._aliases:
            return
        return self._aliases[target].get(alias)
1117411
def GetUsers(alias=None):
		
		if alias is None:  alias = clc.v1.Account.GetAlias()
		r = clc.v1.API.Call('post','User/GetUsers',{'AccountAlias': alias})
		if int(r['StatusCode']) == 0:  
			return(r['Users'])
430220
def account(self):
        
        if self._account is None:
            self._account = AccountContext(self, self.domain.twilio.account_sid)
        return self._account
192730
def using(self, alias):
        
        clone = self._clone()
        clone._index = alias
        return clone
85295
def get_info(self, account, params={}):
        
        res = self.invoke(zconstant.NS_ZIMBRA_ADMIN_URL,
                          sconstant.GetInfoRequest,
                          params)

        return res
580180
def account(self):
        
        data = self.query(Account.key)
        return Account(self, data)
403796
def get_account_item(address, param)
      address = Utils.normalize_address address, allow_blank: true
      return @caches[param][address] if @caches[param].has_key?(address)

      account = get_account address
      v = account.send param
      @caches[param][address] = v
      v
    end
229233
def account_activation(data = {})
      @data = {
          user: nil,
          client_ip: '0.0.0.0'
      }.merge(data || {})
      raise unless data[:user]
      mail to: data[:user].email, subject: 'Account activation'
    end
1185491
def namedb_get_account_at(cur, address, block_number):
    
    query = 'SELECT * FROM accounts WHERE address = ? AND block_id = ? ORDER BY block_id DESC, vtxindex DESC'
    args = (address, block_number)
    history_rows = namedb_query_execute(cur, query, args)
    ret = []

    for row in history_rows:
        tmp = {}
        tmp.update(row)
        ret.append(tmp)

    if len(ret) > 0:
        # account changed in this block
        return ret
    
    # if the account did not change in this block, then find the latest version of this account at this block
    query = 'SELECT * from accounts WHERE address = ? AND block_id < ? ORDER BY block_id DESC,vtxindex DESC LIMIT 1'
    args = (address, block_number)
    history_rows = namedb_query_execute(cur, query, args)

    for row in history_rows:
        tmp = {}
        tmp.update(row)
        ret.append(tmp)

    return ret