Access the Fax Twilio Domain

        :returns: Fax Twilio Domain
        :rtype: twilio.rest.fax.Fax
508286
def fax(self):
        
        if self._fax is None:
            from twilio.rest.fax import Fax
            self._fax = Fax(self)
        return self._fax
144608
def media(self):
        
        if self._media is None:
            self._media = FaxMediaList(self._version, fax_sid=self._solution['sid'], )
        return self._media
1011829
def accounts(self):
        
        if self._accounts is None:
            from twilio.rest.accounts import Accounts
            self._accounts = Accounts(self)
        return self._accounts
385990
def protection_domains(self):
        
        self.connection._check_login()
        response = self.connection._do_get("{}/{}".format(self.connection._api_url, "types/ProtectionDomain/instances")).json()
        all_pds = []
        for pd in response:
            all_pds.append(
                SIO_Protection_Domain.from_dict(pd)
            )
        return all_pds
658972
def get_domain_url(url):
    
    if "http://" not in url and "https://" not in url:
        return url
    url_header = url.split('://')[0]
    simple_url = url.split('://')[1]
    base_url = simple_url.split('/')[0]
    domain_url = url_header + '://' + base_url
    return domain_url
245131
def trunking(self):
        
        if self._trunking is None:
            from twilio.rest.trunking import Trunking
            self._trunking = Trunking(self)
        return self._trunking
383997
def all(self, domain=None):
        
        if domain is None:
            return {k: dict(v) for k, v in list(self.messages.items())}

        return dict(self.messages.get(domain, {}))
550881
@Override
    public Page<FaxMedia> previousPage(final Page<FaxMedia> page, 
                                       final TwilioRestClient client) {
        Request request = new Request(
            HttpMethod.GET,
            page.getPreviousPageUrl(
                Domains.FAX.toString(),
                client.getRegion()
            )
        );
        return pageForRequest(client, request);
    }
327762
def get_domains(custom_headers:nil)
      response = get_domains_async(custom_headers:custom_headers).value!
      response.body unless response.nil?
    end
611502
def index(self, prefix):
        
        # Any web domain will be handled by the standard URLField.
        if self.is_external_url_prefix(prefix):
            prefix = 'http'

        for i, urltype in enumerate(self._url_types):
            if urltype.prefix == prefix:
                return i
        return None
591941
def security(self, domain):
        '''
        '''
        uri = self._uris["security"].format(domain)
        return self.get_parse(uri)
317701
def lookups(self):
        
        if self._lookups is None:
            from twilio.rest.lookups import Lookups
            self._lookups = Lookups(self)
        return self._lookups
373460
def get(self, url):
        

        response = requests.get(
            self.host + url,
            headers={
                'Authorization': 'Bearer ' + self.token,
                'x-falkonry-source':self.sourceHeader
            },
            verify=False
        )
        if response.status_code == 200:
            try:
                return json.loads(response._content.decode('utf-8'))
            except Exception as error:
                return response.content
        elif response.status_code == 401:
            raise Exception(json.dumps({'message':'Unauthorized Access'}))
        else:
            raise Exception(response.content)
769595
def faxes(self):
        
        if self._faxes is None:
            self._faxes = FaxList(self)
        return self._faxes
1244937
def get_domain_info(self, domain):
        
        url = self.API_TEMPLATE + self.DOMAIN_INFO.format(domain=domain)
        return self._get_json_from_response(url)
1330392
def get_instance(self, payload):
        
        return DomainInstance(self._version, payload, account_sid=self._solution['account_sid'], )
888149
def get_identifier(self, origin=None):
        

        token = self.get().unescape()
        if not token.is_identifier():
            raise dns.exception.SyntaxError('expecting an identifier')
        return token.value