Access the webhooks

        :returns: twilio.rest.chat.v2.service.channel.webhook.WebhookList
        :rtype: twilio.rest.chat.v2.service.channel.webhook.WebhookList
510333
def webhooks(self):
        
        if self._webhooks is None:
            self._webhooks = WebhookList(
                self._version,
                service_sid=self._solution['service_sid'],
                channel_sid=self._solution['sid'],
            )
        return self._webhooks
572866
public List<Webhook> list() throws OpenpayServiceException, ServiceUnavailableException {
		String path = String.format(BASE_PATH, this.getMerchantId());
		return this.getJsonClient().list(path, new HashMap<String, String>(), Webhook.class);
	}
474725
def list(self):
        
        response = self._swimlane.request('get', 'app')
        return [App(self._swimlane, item) for item in response.json()]
844335
def get(self, request, bot_id, format=None):
        
        return super(TelegramBotList, self).get(request, bot_id, format)
703506
def invoke_webhook_handlers(self):
		

		webhooks.call_handlers(event=self)

		signal = WEBHOOK_SIGNALS.get(self.type)
		if signal:
			return signal.send(sender=Event, event=self)
1002624
def get(self, request, bot_id, format=None):
        
        return super(HookList, self).get(request, bot_id, format)
407212
def list(cls, params=None, custom_headers=None):
        

        if params is None:
            params = {}

        if custom_headers is None:
            custom_headers = {}

        api_client = client.ApiClient(cls._get_api_context())
        endpoint_url = cls._ENDPOINT_URL_LISTING.format(
            cls._determine_user_id())
        response_raw = api_client.get(endpoint_url, params, custom_headers)

        return BunqResponseOauthClientList.cast_from_bunq_response(
            cls._from_json_list(response_raw, cls._OBJECT_TYPE_GET)
        )
1365065
def to_array(self):
        
        array = super(WebhookInfo, self).to_array()
        array['url'] = u(self.url)  # py2: type unicode, py3: type str
        array['has_custom_certificate'] = bool(self.has_custom_certificate)  # type bool
        array['pending_update_count'] = int(self.pending_update_count)  # type int
        if self.last_error_date is not None:
            array['last_error_date'] = int(self.last_error_date)  # type int
        if self.last_error_message is not None:
            array['last_error_message'] = u(self.last_error_message)  # py2: type unicode, py3: type str
        if self.max_connections is not None:
            array['max_connections'] = int(self.max_connections)  # type int
        if self.allowed_updates is not None:
            array['allowed_updates'] = self._as_array(self.allowed_updates)  # type list of str
        return array
319275
def webhooks
      webhooks = JSON.parse(API::Server.webhooks(@bot.token, @id))
      webhooks.map { |webhook| Webhook.new(webhook, @bot) }
    end
1318587
def get_all(self, request, notifications, mark_as_read=False):
        
        return self.list(request, notifications)
878504
def url(self) -> str:
        
        if self.chat.type not in [ChatType.SUPER_GROUP, ChatType.CHANNEL]:
            raise TypeError('Invalid chat type!')
        elif not self.chat.username:
            raise TypeError('This chat does not have @username')

        return f"https://t.me/{self.chat.username}/{self.message_id}"
360344
def get(self, request, bot_id, format=None):
        
        return super(TelegramChatStateList, self).get(request, bot_id, format)
694036
def get_hooks(self):
        
        return github.PaginatedList.PaginatedList(
            github.Hook.Hook,
            self._requester,
            self.url + "/hooks",
            None
        )
107563
def tokens(self):
        
        if self._tokens is None:
            self._tokens = TokenList(self._version, account_sid=self._solution['sid'], )
        return self._tokens
796024
def get_by_id(self, webhook, params={}, **options): 
        
        path = "/webhooks/%s" % (webhook)
        return self.client.get(path, params, **options)
743518
def announce_urls(self):
        
        urls = self._struct.get('announce-list')

        if not urls:
            urls = self._struct.get('announce')
            if not urls:
                return []
            urls = [[urls]]

        return urls
1082454
def get_webhook(webhook_id)
      response = self.class.get("#{@api.webhook_config[:url]}/#{URI::escape(webhook_id)}",
                                :query => {
                                  :auth_token => @token
                                },
                                :headers => @api.headers
      )

      ErrorHandler.response_code_to_exception_for :webhook, webhook_id, response
      response.body
    end