text: """
      api.video
  
      api.video is an API that encodes on the go to facilitate immediate playback, enhancing viewer streaming experiences across multiple devices and platforms. You can stream live or on-demand online videos within minutes.  # noqa: E501
  
      Contact: ecosystem@api.video
  """
  
  import os  # noqa: F401
  import re  # noqa: F401
  import sys  # noqa: F401
  from types import MethodType
  from types import FunctionType
  
  from apivideo.api_client import ApiClient
  from apivideo.endpoint import EndPoint as _EndPoint, ChunkIO
  from apivideo.model.video_id import VideoId
  from apivideo.model_utils import (  # noqa: F401
      check_allowed_values,
      check_validations,
      date,
      datetime,
      file_type,
      none_type,
      validate_and_convert_types
  )
  from apivideo.exceptions import ApiTypeError, ApiValueError
  from apivideo.model.bad_request import BadRequest
  from apivideo.model.not_found import NotFound
  from apivideo.model.webhook import Webhook
  from apivideo.model.webhooks_creation_payload import WebhooksCreationPayload
  from apivideo.model.webhooks_list_response import WebhooksListResponse
  
  
  class WebhooksApi(_EndPoint):
  
      def create(
              self,
              webhooks_creation_payload,
              **kwargs
          ):
              """Create Webhook  # noqa: E501
  
              Webhooks can push notifications to your server, rather than polling api.video for changes. We currently offer four events:  * ```video.encoding.quality.completed``` Occurs when a new video is uploaded into your account, it will be encoded into several different HLS and mp4 qualities. When each version is encoded, your webhook will get a notification.  It will look like ```{ \"type\": \"video.encoding.quality.completed\", \"emittedAt\": \"2021-01-29T16:46:25.217+01:00\", \"videoId\": \"viXXXXXXXX\", \"encoding\": \"hls\", \"quality\": \"720p\"} ```. This request says that the 720p HLS encoding was completed. * ```live-stream.broadcast.started```  When a live stream begins broadcasting, the broadcasting parameter changes from false to true, and this webhook fires. * ```live-stream.broadcast.ended```  This event fires when the live stream has finished broadcasting, and the broadcasting parameter flips from false to true. * ```video.source.recorded```  This event occurs when a live stream is recorded and submitted for encoding.  # noqa: E501
              This method makes a synchronous HTTP request by default. To make an
              asynchronous HTTP request, please pass async_req=True
  
              >>> thread = api.create(webhooks_creation_payload, async_req=True)
              >>> result = thread.get()
  
              Args:
                  webhooks_creation_payload (WebhooksCreationPayload):
  
              Keyword Args:
                  _return_http_data_only (bool): response data without head status
                      code and headers. Default is True.
                  _preload_content (bool): if False, the urllib3.HTTPResponse object
                      will be returned without reading/decoding response data.
                      Default is True.
                  _request_timeout (float/tuple): timeout setting for this request. If one
                      number provided, it will be total request timeout. It can also
                      be a pair (tuple) of (connection, read) timeouts.
                      Default is None.
                  async_req (bool): execute request asynchronously
  
              Returns:
                  Webhook
                      If the method is called asynchronously, returns the request
                      thread.
              """
              kwargs['async_req'] = kwargs.get(
                  'async_req', False
              )
              kwargs['_return_http_data_only'] = kwargs.get(
                  '_return_http_data_only', True
              )
              kwargs['_preload_content'] = kwargs.get(
                  '_preload_content', True
              )
              kwargs['_request_timeout'] = kwargs.get(
                  '_request_timeout', None
              )
              kwargs['webhooks_creation_payload'] = \
                  webhooks_creation_payload
  
              params_map = {
                  'all': [
                      'webhooks_creation_payload',
                      'async_req',
                      '_preload_content',
                      '_request_timeout',
                      '_return_http_data_only'
                  ],
                  'required': [
                      'webhooks_creation_payload',
                  ],
                  'nullable': [
                      '_request_timeout'
                  ],
                  'enum': [
                  ],
                  'validation': [
                  ]
              }
              validations = {
              }
              allowed_values = {
              }
              openapi_types = {
                  'webhooks_creation_payload':
                      (WebhooksCreationPayload,),
                  'async_req': (bool,),
                  '_preload_content': (bool,),
                  '_request_timeout': (none_type, int, (int,), [int]),
                  '_return_http_data_only': (bool,)
              }
              attribute_map = {
              }
              location_map = {
                  'webhooks_creation_payload': 'body',
              }
              collection_format_map = {
              }
  
              for key, value in kwargs.items():
                  if key not in params_map['all']:
                      raise ApiTypeError(
                          "Got an unexpected parameter '%s'"
                          " to method `create`" %
                          (key, )
                      )
                  if (key not in params_map['nullable'] and value is None):
                      raise ApiValueError(
                          "Value may not be None for non-nullable parameter `%s`"
                          " when calling `create`" %
                          (key, )
                      )
  
              for key in params_map['required']:
                  if key not in kwargs.keys():
                      raise ApiValueError(
                          "Missing the required parameter `%s` when calling "
                          "`create`" % (key, )
                      )
  
              self._validate_inputs(kwargs, params_map, allowed_values, validations, openapi_types)
              params = self._gather_params(kwargs, location_map, attribute_map, openapi_types, collection_format_map)
              return self.api_client.call_api(
                  "/webhooks",
                  "POST",
                  params['path'],
                  params['query'],
                  params['header'],
                  body=params['body'],
                  post_params=params['form'],
                  files=params['file'],
                  response_type=(Webhook,),
                  async_req=kwargs['async_req'],
                  _return_http_data_only=kwargs['_return_http_data_only'],
                  _preload_content=kwargs['_preload_content'],
                  _request_timeout=kwargs['_request_timeout'],
                  collection_formats=params['collection_format'])
  
      def get(
              self,
              webhook_id,
              **kwargs
          ):
              """Retrieve Webhook details  # noqa: E501
  
              This call provides the same JSON information provided on Webhook creation.  # noqa: E501
              This method makes a synchronous HTTP request by default. To make an
              asynchronous HTTP request, please pass async_req=True
  
              >>> thread = api.get(webhook_id, async_req=True)
              >>> result = thread.get()
  
              Args:
                  webhook_id (str): The unique webhook you wish to retreive details on.
  
              Keyword Args:
                  _return_http_data_only (bool): response data without head status
                      code and headers. Default is True.
                  _preload_content (bool): if False, the urllib3.HTTPResponse object
                      will be returned without reading/decoding response data.
                      Default is True.
                  _request_timeout (float/tuple): timeout setting for this request. If one
                      number provided, it will be total request timeout. It can also
                      be a pair (tuple) of (connection, read) timeouts.
                      Default is None.
                  async_req (bool): execute request asynchronously
  
              Returns:
                  Webhook
                      If the method is called asynchronously, returns the request
                      thread.
              """
              kwargs['async_req'] = kwargs.get(
                  'async_req', False
              )
              kwargs['_return_http_data_only'] = kwargs.get(
                  '_return_http_data_only', True
              )
              kwargs['_preload_content'] = kwargs.get(
                  '_preload_content', True
              )
              kwargs['_request_timeout'] = kwargs.get(
                  '_request_timeout', None
              )
              kwargs['webhook_id'] = \
                  webhook_id
  
              params_map = {
                  'all': [
                      'webhook_id',
                      'async_req',
                      '_preload_content',
                      '_request_timeout',
                      '_return_http_data_only'
                  ],
                  'required': [
                      'webhook_id',
                  ],
                  'nullable': [
                      '_request_timeout'
                  ],
                  'enum': [
                  ],
                  'validation': [
                  ]
              }
              validations = {
              }
              allowed_values = {
              }
              openapi_types = {
                  'webhook_id':
                      (str,),
                  'async_req': (bool,),
                  '_preload_content': (bool,),
                  '_request_timeout': (none_type, int, (int,), [int]),
                  '_return_http_data_only': (bool,)
              }
              attribute_map = {
                  'webhook_id': 'webhookId',
              }
              location_map = {
                  'webhook_id': 'path',
              }
              collection_format_map = {
              }
  
              for key, value in kwargs.items():
                  if key not in params_map['all']:
                      raise ApiTypeError(
                          "Got an unexpected parameter '%s'"
                          " to method `get`" %
                          (key, )
                      )
                  if (key not in params_map['nullable'] and value is None):
                      raise ApiValueError(
                          "Value may not be None for non-nullable parameter `%s`"
                          " when calling `get`" %
                          (key, )
                      )
  
              for key in params_map['required']:
                  if key not in kwargs.keys():
                      raise ApiValueError(
                          "Missing the required parameter `%s` when calling "
                          "`get`" % (key, )
                      )
  
              self._validate_inputs(kwargs, params_map, allowed_values, validations, openapi_types)
              params = self._gather_params(kwargs, location_map, attribute_map, openapi_types, collection_format_map)
              return self.api_client.call_api(
                  "/webhooks/{webhookId}",
                  "GET",
                  params['path'],
                  params['query'],
                  params['header'],
                  body=params['body'],
                  post_params=params['form'],
                  files=params['file'],
                  response_type=(Webhook,),
                  async_req=kwargs['async_req'],
                  _return_http_data_only=kwargs['_return_http_data_only'],
                  _preload_content=kwargs['_preload_content'],
                  _request_timeout=kwargs['_request_timeout'],
                  collection_formats=params['collection_format'])
  
      def delete(
              self,
              webhook_id,
              **kwargs
          ):
              """Delete a Webhook  # noqa: E501
  
              This method will delete the indicated webhook.  # noqa: E501
              This method makes a synchronous HTTP request by default. To make an
              asynchronous HTTP request, please pass async_req=True
  
              >>> thread = api.delete(webhook_id, async_req=True)
              >>> result = thread.get()
  
              Args:
                  webhook_id (str): The webhook you wish to delete.
  
              Keyword Args:
                  _return_http_data_only (bool): response data without head status
                      code and headers. Default is True.
                  _preload_content (bool): if False, the urllib3.HTTPResponse object
                      will be returned without reading/decoding response data.
                      Default is True.
                  _request_timeout (float/tuple): timeout setting for this request. If one
                      number provided, it will be total request timeout. It can also
                      be a pair (tuple) of (connection, read) timeouts.
                      Default is None.
                  async_req (bool): execute request asynchronously
  
              Returns:
                  None
                      If the method is called asynchronously, returns the request
                      thread.
              """
              kwargs['async_req'] = kwargs.get(
                  'async_req', False
              )
              kwargs['_return_http_data_only'] = kwargs.get(
                  '_return_http_data_only', True
              )
              kwargs['_preload_content'] = kwargs.get(
                  '_preload_content', True
              )
              kwargs['_request_timeout'] = kwargs.get(
                  '_request_timeout', None
              )
              kwargs['webhook_id'] = \
                  webhook_id
  
              params_map = {
                  'all': [
                      'webhook_id',
                      'async_req',
                      '_preload_content',
                      '_request_timeout',
                      '_return_http_data_only'
                  ],
                  'required': [
                      'webhook_id',
                  ],
                  'nullable': [
                      '_request_timeout'
                  ],
                  'enum': [
                  ],
                  'validation': [
                  ]
              }
              validations = {
              }
              allowed_values = {
              }
              openapi_types = {
                  'webhook_id':
                      (str,),
                  'async_req': (bool,),
                  '_preload_content': (bool,),
                  '_request_timeout': (none_type, int, (int,), [int]),
                  '_return_http_data_only': (bool,)
              }
              attribute_map = {
                  'webhook_id': 'webhookId',
              }
              location_map = {
                  'webhook_id': 'path',
              }
              collection_format_map = {
              }
  
              for key, value in kwargs.items():
                  if key not in params_map['all']:
                      raise ApiTypeError(
                          "Got an unexpected parameter '%s'"
                          " to method `delete`" %
                          (key, )
                      )
                  if (key not in params_map['nullable'] and value is None):
                      raise ApiValueError(
                          "Value may not be None for non-nullable parameter `%s`"
                          " when calling `delete`" %
                          (key, )
                      )
  
              for key in params_map['required']:
                  if key not in kwargs.keys():
                      raise ApiValueError(
                          "Missing the required parameter `%s` when calling "
                          "`delete`" % (key, )
                      )
  
              self._validate_inputs(kwargs, params_map, allowed_values, validations, openapi_types)
              params = self._gather_params(kwargs, location_map, attribute_map, openapi_types, collection_format_map)
              return self.api_client.call_api(
                  "/webhooks/{webhookId}",
                  "DELETE",
                  params['path'],
                  params['query'],
                  params['header'],
                  body=params['body'],
                  post_params=params['form'],
                  files=params['file'],
                  response_type=None,
                  async_req=kwargs['async_req'],
                  _return_http_data_only=kwargs['_return_http_data_only'],
                  _preload_content=kwargs['_preload_content'],
                  _request_timeout=kwargs['_request_timeout'],
                  collection_formats=params['collection_format'])
  
      def list(
              self,
              **kwargs
          ):
              """List all webhooks  # noqa: E501
  
              Thie method returns a list of your webhooks (with all their details). 
  
  You can filter what the webhook list that the API returns using the parameters described below.  # noqa: E501
              This method makes a synchronous HTTP request by default. To make an
              asynchronous HTTP request, please pass async_req=True
  
              >>> thread = api.list(async_req=True)
              >>> result = thread.get()
  
  
              Keyword Args:
                  events (str): The webhook event that you wish to filter on.. [optional]
                  current_page (int): Choose the number of search results to return per page. Minimum value: 1. [optional] if omitted the server will use the default value of 1
                  page_size (int): Results per page. Allowed values 1-100, default is 25.. [optional] if omitted the server will use the default value of 25
                  _return_http_data_only (bool): response data without head status
                      code and headers. Default is True.
                  _preload_content (bool): if False, the urllib3.HTTPResponse object
                      will be returned without reading/decoding response data.
                      Default is True.
                  _request_timeout (float/tuple): timeout setting for this request. If one
                      number provided, it will be total request timeout. It can also
                      be a pair (tuple) of (connection, read) timeouts.
                      Default is None.
                  async_req (bool): execute request asynchronously
  
              Returns:
                  WebhooksListResponse
                      If the method is called asynchronously, returns the request
                      thread.
              """
              kwargs['async_req'] = kwargs.get(
                  'async_req', False
              )
              kwargs['_return_http_data_only'] = kwargs.get(
                  '_return_http_data_only', True
              )
              kwargs['_preload_content'] = kwargs.get(
                  '_preload_content', True
              )
              kwargs['_request_timeout'] = kwargs.get(
                  '_request_timeout', None
              )
  
              params_map = {
                  'all': [
                      'events',
                      'current_page',
                      'page_size',
                      'async_req',
                      '_preload_content',
                      '_request_timeout',
                      '_return_http_data_only'
                  ],
                  'required': [],
                  'nullable': [
                      '_request_timeout'
                  ],
                  'enum': [
                  ],
                  'validation': [
                  ]
              }
              validations = {
              }
              allowed_values = {
              }
              openapi_types = {
                  'events':
                      (str,),
                  'current_page':
                      (int,),
                  'page_size':
                      (int,),
                  'async_req': (bool,),
                  '_preload_content': (bool,),
                  '_request_timeout': (none_type, int, (int,), [int]),
                  '_return_http_data_only': (bool,)
              }
              attribute_map = {
                  'events': 'events',
                  'current_page': 'currentPage',
                  'page_size': 'pageSize',
              }
              location_map = {
                  'events': 'query',
                  'current_page': 'query',
                  'page_size': 'query',
              }
              collection_format_map = {
              }
  
              for key, value in kwargs.items():
                  if key not in params_map['all']:
                      raise ApiTypeError(
                          "Got an unexpected parameter '%s'"
                          " to method `list`" %
                          (key, )
                      )
                  if (key not in params_map['nullable'] and value is None):
                      raise ApiValueError(
                          "Value may not be None for non-nullable parameter `%s`"
                          " when calling `list`" %
                          (key, )
                      )
  
              for key in params_map['required']:
                  if key not in kwargs.keys():
                      raise ApiValueError(
                          "Missing the required parameter `%s` when calling "
                          "`list`" % (key, )
                      )
  
              self._validate_inputs(kwargs, params_map, allowed_values, validations, openapi_types)
              params = self._gather_params(kwargs, location_map, attribute_map, openapi_types, collection_format_map)
              return self.api_client.call_api(
                  "/webhooks",
                  "GET",
                  params['path'],
                  params['query'],
                  params['header'],
                  body=params['body'],
                  post_params=params['form'],
                  files=params['file'],
                  response_type=(WebhooksListResponse,),
                  async_req=kwargs['async_req'],
                  _return_http_data_only=kwargs['_return_http_data_only'],
                  _preload_content=kwargs['_preload_content'],
                  _request_timeout=kwargs['_request_timeout'],
                  collection_formats=params['collection_format'])
  
  