Find usage on APIs / RestAPIs, and resources that are limited per-API.
        Update `self.limits`.

def _find_usage_apis(self):
        """
        Find usage on APIs / RestAPIs, and resources that are limited per-API.
        Update `self.limits`.
        """
        api_ids = []
        logger.debug('Finding usage for APIs')
        regional_count = 0
        private_count = 0
        edge_count = 0
        paginator = self.conn.get_paginator('get_rest_apis')
        for resp in paginator.paginate():
            for api in resp['items']:
                api_ids.append(api['id'])
                epconf = api.get('endpointConfiguration', {}).get('types', [])
                if epconf == ['PRIVATE']:
                    private_count += 1
                elif epconf == ['EDGE']:
                    edge_count += 1
                else:
                    regional_count += 1
        self.limits['Regional APIs per account']._add_current_usage(
            regional_count, aws_type='AWS::ApiGateway::RestApi'
        )
        self.limits['Private APIs per account']._add_current_usage(
            private_count, aws_type='AWS::ApiGateway::RestApi'
        )
        self.limits['Edge APIs per account']._add_current_usage(
            edge_count, aws_type='AWS::ApiGateway::RestApi'
        )
        logger.debug('Found %d APIs', len(api_ids))
        # now the per-API limits...
        warn_stages_paginated = None
        logger.debug('Finding usage for per-API limits')
        for api_id in api_ids:
            res_count = 0
            paginator = self.conn.get_paginator('get_resources')
            for resp in paginator.paginate(restApiId=api_id):
                res_count += len(resp['items'])
            self.limits['Resources per API']._add_current_usage(
                res_count, resource_id=api_id,
                aws_type='AWS::ApiGateway::Resource'
            )
            doc_parts = paginate_dict(
                self.conn.get_documentation_parts,
                restApiId=api_id,
                alc_marker_path=['position'],
                alc_data_path=['items'],
                alc_marker_param='position'
            )
            self.limits['Documentation parts per API']._add_current_usage(
                len(doc_parts), resource_id=api_id,
                aws_type='AWS::ApiGateway::DocumentationPart'
            )
            # note that per the boto3 docs, there's no pagination of this...
            stages = self.conn.get_stages(restApiId=api_id)
            if len(set(stages.keys()) - set(['item', 'ResponseMetadata'])) > 0:
                warn_stages_paginated = stages.keys()
            self.limits['Stages per API']._add_current_usage(
                len(stages['item']), resource_id=api_id,
                aws_type='AWS::ApiGateway::Stage'
            )
            authorizers = paginate_dict(
                self.conn.get_authorizers,
                restApiId=api_id,
                alc_marker_path=['position'],
                alc_data_path=['items'],
                alc_marker_param='position'
            )
            self.limits['Custom authorizers per API']._add_current_usage(
                len(authorizers), resource_id=api_id,
                aws_type='AWS::ApiGateway::Authorizer'
            )
        if warn_stages_paginated is not None:
            logger.warning(
                'APIGateway get_stages returned more keys than present in '
                'boto3 docs: %s', sorted(warn_stages_paginated)
            )