# NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
# https://openapi-generator.tech
# Do not edit the class manually.

defmodule MailSlurpAPI.Api.WebhookController do
  @moduledoc """
  API calls for all endpoints tagged `WebhookController`.
  """

  alias MailSlurpAPI.Connection
  import MailSlurpAPI.RequestBuilder


  @doc """
  Attach a WebHook URL to an inbox
  Get notified of account level events such as bounce and bounce recipient.

  ## Parameters

  - connection (MailSlurpAPI.Connection): Connection to server
  - create_webhook_options (CreateWebhookOptions): 
  - opts (KeywordList): [optional] Optional parameters
  ## Returns

  {:ok, %MailSlurpAPI.Model.WebhookDto{}} on success
  {:error, info} on failure
  """
  @spec create_account_webhook(Tesla.Env.client, MailSlurpAPI.Model.CreateWebhookOptions.t, keyword()) :: {:ok, MailSlurpAPI.Model.WebhookDto.t} | {:error, Tesla.Env.t}
  def create_account_webhook(connection, create_webhook_options, _opts \\ []) do
    %{}
    |> method(:post)
    |> url("/webhooks")
    |> add_param(:body, :body, create_webhook_options)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> evaluate_response([
      { 201, %MailSlurpAPI.Model.WebhookDto{}}
    ])
  end

  @doc """
  Attach a WebHook URL to an inbox
  Get notified whenever an inbox receives an email via a WebHook URL. An emailID will be posted to this URL every time an email is received for this inbox. The URL must be publicly reachable by the MailSlurp server. You can provide basicAuth values if you wish to secure this endpoint.

  ## Parameters

  - connection (MailSlurpAPI.Connection): Connection to server
  - inbox_id (String.t): 
  - create_webhook_options (CreateWebhookOptions): 
  - opts (KeywordList): [optional] Optional parameters
  ## Returns

  {:ok, %MailSlurpAPI.Model.WebhookDto{}} on success
  {:error, info} on failure
  """
  @spec create_webhook(Tesla.Env.client, String.t, MailSlurpAPI.Model.CreateWebhookOptions.t, keyword()) :: {:ok, MailSlurpAPI.Model.WebhookDto.t} | {:error, Tesla.Env.t}
  def create_webhook(connection, inbox_id, create_webhook_options, _opts \\ []) do
    %{}
    |> method(:post)
    |> url("/inboxes/#{inbox_id}/webhooks")
    |> add_param(:body, :body, create_webhook_options)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> evaluate_response([
      { 201, %MailSlurpAPI.Model.WebhookDto{}}
    ])
  end

  @doc """
  Attach a WebHook URL to a phone number
  Get notified whenever a phone number receives an SMS via a WebHook URL.

  ## Parameters

  - connection (MailSlurpAPI.Connection): Connection to server
  - phone_number_id (String.t): 
  - create_webhook_options (CreateWebhookOptions): 
  - opts (KeywordList): [optional] Optional parameters
  ## Returns

  {:ok, %MailSlurpAPI.Model.WebhookDto{}} on success
  {:error, info} on failure
  """
  @spec create_webhook_for_phone_number(Tesla.Env.client, String.t, MailSlurpAPI.Model.CreateWebhookOptions.t, keyword()) :: {:ok, MailSlurpAPI.Model.WebhookDto.t} | {:error, Tesla.Env.t}
  def create_webhook_for_phone_number(connection, phone_number_id, create_webhook_options, _opts \\ []) do
    %{}
    |> method(:post)
    |> url("/phone/numbers/#{phone_number_id}/webhooks")
    |> add_param(:body, :body, create_webhook_options)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> evaluate_response([
      { 201, %MailSlurpAPI.Model.WebhookDto{}}
    ])
  end

  @doc """
  Delete all webhooks

  ## Parameters

  - connection (MailSlurpAPI.Connection): Connection to server
  - opts (KeywordList): [optional] Optional parameters
    - :before (DateTime.t): before
  ## Returns

  {:ok, %{}} on success
  {:error, info} on failure
  """
  @spec delete_all_webhooks(Tesla.Env.client, keyword()) :: {:ok, nil} | {:error, Tesla.Env.t}
  def delete_all_webhooks(connection, opts \\ []) do
    optional_params = %{
      :"before" => :query
    }
    %{}
    |> method(:delete)
    |> url("/webhooks")
    |> add_optional_params(optional_params, opts)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> evaluate_response([
      { 204, false}
    ])
  end

  @doc """
  Delete and disable a Webhook for an Inbox

  ## Parameters

  - connection (MailSlurpAPI.Connection): Connection to server
  - inbox_id (String.t): 
  - webhook_id (String.t): 
  - opts (KeywordList): [optional] Optional parameters
  ## Returns

  {:ok, %{}} on success
  {:error, info} on failure
  """
  @spec delete_webhook(Tesla.Env.client, String.t, String.t, keyword()) :: {:ok, nil} | {:error, Tesla.Env.t}
  def delete_webhook(connection, inbox_id, webhook_id, _opts \\ []) do
    %{}
    |> method(:delete)
    |> url("/inboxes/#{inbox_id}/webhooks/#{webhook_id}")
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> evaluate_response([
      { 204, false}
    ])
  end

  @doc """
  Delete a webhook

  ## Parameters

  - connection (MailSlurpAPI.Connection): Connection to server
  - webhook_id (String.t): 
  - opts (KeywordList): [optional] Optional parameters
  ## Returns

  {:ok, %{}} on success
  {:error, info} on failure
  """
  @spec delete_webhook_by_id(Tesla.Env.client, String.t, keyword()) :: {:ok, nil} | {:error, Tesla.Env.t}
  def delete_webhook_by_id(connection, webhook_id, _opts \\ []) do
    %{}
    |> method(:delete)
    |> url("/webhooks/#{webhook_id}")
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> evaluate_response([
      { 200, false}
    ])
  end

  @doc """
  List account webhooks Paginated
  List account webhooks in paginated form. Allows for page index, page size, and sort direction.

  ## Parameters

  - connection (MailSlurpAPI.Connection): Connection to server
  - opts (KeywordList): [optional] Optional parameters
    - :page (integer()): Optional page index in list pagination
    - :size (integer()): Optional page size for paginated result list.
    - :sort (String.t): Optional createdAt sort direction ASC or DESC
    - :event_type (String.t): Optional event type
    - :since (DateTime.t): Filter by created at after the given timestamp
    - :before (DateTime.t): Filter by created at before the given timestamp
  ## Returns

  {:ok, %MailSlurpAPI.Model.PageWebhookProjection{}} on success
  {:error, info} on failure
  """
  @spec get_all_account_webhooks(Tesla.Env.client, keyword()) :: {:ok, MailSlurpAPI.Model.PageWebhookProjection.t} | {:error, Tesla.Env.t}
  def get_all_account_webhooks(connection, opts \\ []) do
    optional_params = %{
      :"page" => :query,
      :"size" => :query,
      :"sort" => :query,
      :"eventType" => :query,
      :"since" => :query,
      :"before" => :query
    }
    %{}
    |> method(:get)
    |> url("/webhooks/account/paginated")
    |> add_optional_params(optional_params, opts)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> evaluate_response([
      { 200, %MailSlurpAPI.Model.PageWebhookProjection{}}
    ])
  end

  @doc """
  Get results for all webhooks

  ## Parameters

  - connection (MailSlurpAPI.Connection): Connection to server
  - opts (KeywordList): [optional] Optional parameters
    - :page (integer()): Optional page index in list pagination
    - :size (integer()): Optional page size in list pagination
    - :sort (String.t): Optional createdAt sort direction ASC or DESC
    - :search_filter (String.t): Optional search filter
    - :since (DateTime.t): Filter by created at after the given timestamp
    - :before (DateTime.t): Filter by created at before the given timestamp
    - :unseen_only (boolean()): Filter for unseen exceptions only
  ## Returns

  {:ok, %MailSlurpAPI.Model.PageWebhookResult{}} on success
  {:error, info} on failure
  """
  @spec get_all_webhook_results(Tesla.Env.client, keyword()) :: {:ok, MailSlurpAPI.Model.PageWebhookResult.t} | {:error, Tesla.Env.t}
  def get_all_webhook_results(connection, opts \\ []) do
    optional_params = %{
      :"page" => :query,
      :"size" => :query,
      :"sort" => :query,
      :"searchFilter" => :query,
      :"since" => :query,
      :"before" => :query,
      :"unseenOnly" => :query
    }
    %{}
    |> method(:get)
    |> url("/webhooks/results")
    |> add_optional_params(optional_params, opts)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> evaluate_response([
      { 200, %MailSlurpAPI.Model.PageWebhookResult{}}
    ])
  end

  @doc """
  List Webhooks Paginated
  List webhooks in paginated form. Allows for page index, page size, and sort direction.

  ## Parameters

  - connection (MailSlurpAPI.Connection): Connection to server
  - opts (KeywordList): [optional] Optional parameters
    - :page (integer()): Optional page index in list pagination
    - :size (integer()): Optional page size for paginated result list.
    - :sort (String.t): Optional createdAt sort direction ASC or DESC
    - :search_filter (String.t): Optional search filter
    - :since (DateTime.t): Filter by created at after the given timestamp
    - :inbox_id (String.t): Filter by inboxId
    - :phone_id (String.t): Filter by phoneId
    - :before (DateTime.t): Filter by created at before the given timestamp
  ## Returns

  {:ok, %MailSlurpAPI.Model.PageWebhookProjection{}} on success
  {:error, info} on failure
  """
  @spec get_all_webhooks(Tesla.Env.client, keyword()) :: {:ok, MailSlurpAPI.Model.PageWebhookProjection.t} | {:error, Tesla.Env.t}
  def get_all_webhooks(connection, opts \\ []) do
    optional_params = %{
      :"page" => :query,
      :"size" => :query,
      :"sort" => :query,
      :"searchFilter" => :query,
      :"since" => :query,
      :"inboxId" => :query,
      :"phoneId" => :query,
      :"before" => :query
    }
    %{}
    |> method(:get)
    |> url("/webhooks/paginated")
    |> add_optional_params(optional_params, opts)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> evaluate_response([
      { 200, %MailSlurpAPI.Model.PageWebhookProjection{}}
    ])
  end

  @doc """
  Get paginated webhooks for an Inbox

  ## Parameters

  - connection (MailSlurpAPI.Connection): Connection to server
  - inbox_id (String.t): 
  - opts (KeywordList): [optional] Optional parameters
    - :page (integer()): Optional page index in list pagination
    - :size (integer()): Optional page size in list pagination
    - :sort (String.t): Optional createdAt sort direction ASC or DESC
    - :search_filter (String.t): Optional search filter
    - :since (DateTime.t): Filter by created at after the given timestamp
    - :before (DateTime.t): Filter by created at before the given timestamp
  ## Returns

  {:ok, %MailSlurpAPI.Model.PageWebhookProjection{}} on success
  {:error, info} on failure
  """
  @spec get_inbox_webhooks_paginated(Tesla.Env.client, String.t, keyword()) :: {:ok, MailSlurpAPI.Model.PageWebhookProjection.t} | {:error, Tesla.Env.t}
  def get_inbox_webhooks_paginated(connection, inbox_id, opts \\ []) do
    optional_params = %{
      :"page" => :query,
      :"size" => :query,
      :"sort" => :query,
      :"searchFilter" => :query,
      :"since" => :query,
      :"before" => :query
    }
    %{}
    |> method(:get)
    |> url("/inboxes/#{inbox_id}/webhooks/paginated")
    |> add_optional_params(optional_params, opts)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> evaluate_response([
      { 200, %MailSlurpAPI.Model.PageWebhookProjection{}}
    ])
  end

  @doc """
  Get JSON Schema definition for webhook payload by event

  ## Parameters

  - connection (MailSlurpAPI.Connection): Connection to server
  - event (String.t): 
  - opts (KeywordList): [optional] Optional parameters
  ## Returns

  {:ok, %MailSlurpAPI.Model.JsonSchemaDto{}} on success
  {:error, info} on failure
  """
  @spec get_json_schema_for_webhook_event(Tesla.Env.client, String.t, keyword()) :: {:ok, MailSlurpAPI.Model.JsonSchemaDto.t} | {:error, Tesla.Env.t}
  def get_json_schema_for_webhook_event(connection, event, _opts \\ []) do
    %{}
    |> method(:post)
    |> url("/webhooks/schema")
    |> add_param(:query, :"event", event)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> evaluate_response([
      { 200, %MailSlurpAPI.Model.JsonSchemaDto{}}
    ])
  end

  @doc """
  Get JSON Schema definition for webhook payload

  ## Parameters

  - connection (MailSlurpAPI.Connection): Connection to server
  - webhook_id (String.t): 
  - opts (KeywordList): [optional] Optional parameters
  ## Returns

  {:ok, %MailSlurpAPI.Model.JsonSchemaDto{}} on success
  {:error, info} on failure
  """
  @spec get_json_schema_for_webhook_payload(Tesla.Env.client, String.t, keyword()) :: {:ok, MailSlurpAPI.Model.JsonSchemaDto.t} | {:error, Tesla.Env.t}
  def get_json_schema_for_webhook_payload(connection, webhook_id, _opts \\ []) do
    %{}
    |> method(:post)
    |> url("/webhooks/#{webhook_id}/schema")
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> evaluate_response([
      { 200, %MailSlurpAPI.Model.JsonSchemaDto{}}
    ])
  end

  @doc """
  Get paginated webhooks for a phone number

  ## Parameters

  - connection (MailSlurpAPI.Connection): Connection to server
  - phone_id (String.t): 
  - opts (KeywordList): [optional] Optional parameters
    - :page (integer()): Optional page index in list pagination
    - :size (integer()): Optional page size in list pagination
    - :sort (String.t): Optional createdAt sort direction ASC or DESC
    - :since (DateTime.t): Filter by created at after the given timestamp
    - :before (DateTime.t): Filter by created at before the given timestamp
  ## Returns

  {:ok, %MailSlurpAPI.Model.PageWebhookProjection{}} on success
  {:error, info} on failure
  """
  @spec get_phone_number_webhooks_paginated(Tesla.Env.client, String.t, keyword()) :: {:ok, MailSlurpAPI.Model.PageWebhookProjection.t} | {:error, Tesla.Env.t}
  def get_phone_number_webhooks_paginated(connection, phone_id, opts \\ []) do
    optional_params = %{
      :"page" => :query,
      :"size" => :query,
      :"sort" => :query,
      :"since" => :query,
      :"before" => :query
    }
    %{}
    |> method(:get)
    |> url("/phone/numbers/#{phone_id}/webhooks/paginated")
    |> add_optional_params(optional_params, opts)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> evaluate_response([
      { 200, %MailSlurpAPI.Model.PageWebhookProjection{}}
    ])
  end

  @doc """
  Get test webhook payload example. Response content depends on eventName passed. Uses `EMAIL_RECEIVED` as default.

  ## Parameters

  - connection (MailSlurpAPI.Connection): Connection to server
  - opts (KeywordList): [optional] Optional parameters
    - :event_name (String.t): 
  ## Returns

  {:ok, %MailSlurpAPI.Model.AbstractWebhookPayload{}} on success
  {:error, info} on failure
  """
  @spec get_test_webhook_payload(Tesla.Env.client, keyword()) :: {:ok, MailSlurpAPI.Model.AbstractWebhookPayload.t} | {:error, Tesla.Env.t}
  def get_test_webhook_payload(connection, opts \\ []) do
    optional_params = %{
      :"eventName" => :query
    }
    %{}
    |> method(:get)
    |> url("/webhooks/test")
    |> add_optional_params(optional_params, opts)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> evaluate_response([
      { 200, %MailSlurpAPI.Model.AbstractWebhookPayload{}}
    ])
  end

  @doc """
  Get webhook test payload for bounce

  ## Parameters

  - connection (MailSlurpAPI.Connection): Connection to server
  - opts (KeywordList): [optional] Optional parameters
  ## Returns

  {:ok, %MailSlurpAPI.Model.WebhookBouncePayload{}} on success
  {:error, info} on failure
  """
  @spec get_test_webhook_payload_bounce(Tesla.Env.client, keyword()) :: {:ok, MailSlurpAPI.Model.WebhookBouncePayload.t} | {:error, Tesla.Env.t}
  def get_test_webhook_payload_bounce(connection, _opts \\ []) do
    %{}
    |> method(:get)
    |> url("/webhooks/test/email-bounce-payload")
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> evaluate_response([
      { 200, %MailSlurpAPI.Model.WebhookBouncePayload{}}
    ])
  end

  @doc """
  Get webhook test payload for bounce recipient

  ## Parameters

  - connection (MailSlurpAPI.Connection): Connection to server
  - opts (KeywordList): [optional] Optional parameters
  ## Returns

  {:ok, %MailSlurpAPI.Model.WebhookBounceRecipientPayload{}} on success
  {:error, info} on failure
  """
  @spec get_test_webhook_payload_bounce_recipient(Tesla.Env.client, keyword()) :: {:ok, MailSlurpAPI.Model.WebhookBounceRecipientPayload.t} | {:error, Tesla.Env.t}
  def get_test_webhook_payload_bounce_recipient(connection, _opts \\ []) do
    %{}
    |> method(:get)
    |> url("/webhooks/test/email-bounce-recipient-payload")
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> evaluate_response([
      { 200, %MailSlurpAPI.Model.WebhookBounceRecipientPayload{}}
    ])
  end

  @doc """
  Get webhook test payload for delivery status event

  ## Parameters

  - connection (MailSlurpAPI.Connection): Connection to server
  - opts (KeywordList): [optional] Optional parameters
  ## Returns

  {:ok, %MailSlurpAPI.Model.WebhookDeliveryStatusPayload{}} on success
  {:error, info} on failure
  """
  @spec get_test_webhook_payload_delivery_status(Tesla.Env.client, keyword()) :: {:ok, MailSlurpAPI.Model.WebhookDeliveryStatusPayload.t} | {:error, Tesla.Env.t}
  def get_test_webhook_payload_delivery_status(connection, _opts \\ []) do
    %{}
    |> method(:get)
    |> url("/webhooks/test/delivery-status-payload")
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> evaluate_response([
      { 200, %MailSlurpAPI.Model.WebhookDeliveryStatusPayload{}}
    ])
  end

  @doc """
  Get webhook test payload for email opened event

  ## Parameters

  - connection (MailSlurpAPI.Connection): Connection to server
  - opts (KeywordList): [optional] Optional parameters
  ## Returns

  {:ok, %MailSlurpAPI.Model.WebhookEmailOpenedPayload{}} on success
  {:error, info} on failure
  """
  @spec get_test_webhook_payload_email_opened(Tesla.Env.client, keyword()) :: {:ok, MailSlurpAPI.Model.WebhookEmailOpenedPayload.t} | {:error, Tesla.Env.t}
  def get_test_webhook_payload_email_opened(connection, _opts \\ []) do
    %{}
    |> method(:get)
    |> url("/webhooks/test/email-opened-payload")
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> evaluate_response([
      { 200, %MailSlurpAPI.Model.WebhookEmailOpenedPayload{}}
    ])
  end

  @doc """
  Get webhook test payload for email opened event

  ## Parameters

  - connection (MailSlurpAPI.Connection): Connection to server
  - opts (KeywordList): [optional] Optional parameters
  ## Returns

  {:ok, %MailSlurpAPI.Model.WebhookEmailReadPayload{}} on success
  {:error, info} on failure
  """
  @spec get_test_webhook_payload_email_read(Tesla.Env.client, keyword()) :: {:ok, MailSlurpAPI.Model.WebhookEmailReadPayload.t} | {:error, Tesla.Env.t}
  def get_test_webhook_payload_email_read(connection, _opts \\ []) do
    %{}
    |> method(:get)
    |> url("/webhooks/test/email-read-payload")
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> evaluate_response([
      { 200, %MailSlurpAPI.Model.WebhookEmailReadPayload{}}
    ])
  end

  @doc """
  Get example payload for webhook

  ## Parameters

  - connection (MailSlurpAPI.Connection): Connection to server
  - webhook_id (String.t): 
  - opts (KeywordList): [optional] Optional parameters
  ## Returns

  {:ok, %MailSlurpAPI.Model.AbstractWebhookPayload{}} on success
  {:error, info} on failure
  """
  @spec get_test_webhook_payload_for_webhook(Tesla.Env.client, String.t, keyword()) :: {:ok, MailSlurpAPI.Model.AbstractWebhookPayload.t} | {:error, Tesla.Env.t}
  def get_test_webhook_payload_for_webhook(connection, webhook_id, _opts \\ []) do
    %{}
    |> method(:post)
    |> url("/webhooks/#{webhook_id}/example")
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> evaluate_response([
      { 201, %MailSlurpAPI.Model.AbstractWebhookPayload{}}
    ])
  end

  @doc """
  Get webhook test payload for new attachment event

  ## Parameters

  - connection (MailSlurpAPI.Connection): Connection to server
  - opts (KeywordList): [optional] Optional parameters
  ## Returns

  {:ok, %MailSlurpAPI.Model.WebhookNewAttachmentPayload{}} on success
  {:error, info} on failure
  """
  @spec get_test_webhook_payload_new_attachment(Tesla.Env.client, keyword()) :: {:ok, MailSlurpAPI.Model.WebhookNewAttachmentPayload.t} | {:error, Tesla.Env.t}
  def get_test_webhook_payload_new_attachment(connection, _opts \\ []) do
    %{}
    |> method(:get)
    |> url("/webhooks/test/new-attachment-payload")
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> evaluate_response([
      { 200, %MailSlurpAPI.Model.WebhookNewAttachmentPayload{}}
    ])
  end

  @doc """
  Get webhook test payload for new contact event

  ## Parameters

  - connection (MailSlurpAPI.Connection): Connection to server
  - opts (KeywordList): [optional] Optional parameters
  ## Returns

  {:ok, %MailSlurpAPI.Model.WebhookNewContactPayload{}} on success
  {:error, info} on failure
  """
  @spec get_test_webhook_payload_new_contact(Tesla.Env.client, keyword()) :: {:ok, MailSlurpAPI.Model.WebhookNewContactPayload.t} | {:error, Tesla.Env.t}
  def get_test_webhook_payload_new_contact(connection, _opts \\ []) do
    %{}
    |> method(:get)
    |> url("/webhooks/test/new-contact-payload")
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> evaluate_response([
      { 200, %MailSlurpAPI.Model.WebhookNewContactPayload{}}
    ])
  end

  @doc """
  Get webhook test payload for new email event

  ## Parameters

  - connection (MailSlurpAPI.Connection): Connection to server
  - opts (KeywordList): [optional] Optional parameters
  ## Returns

  {:ok, %MailSlurpAPI.Model.WebhookNewEmailPayload{}} on success
  {:error, info} on failure
  """
  @spec get_test_webhook_payload_new_email(Tesla.Env.client, keyword()) :: {:ok, MailSlurpAPI.Model.WebhookNewEmailPayload.t} | {:error, Tesla.Env.t}
  def get_test_webhook_payload_new_email(connection, _opts \\ []) do
    %{}
    |> method(:get)
    |> url("/webhooks/test/new-email-payload")
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> evaluate_response([
      { 200, %MailSlurpAPI.Model.WebhookNewEmailPayload{}}
    ])
  end

  @doc """
  Get webhook test payload for new sms event

  ## Parameters

  - connection (MailSlurpAPI.Connection): Connection to server
  - opts (KeywordList): [optional] Optional parameters
  ## Returns

  {:ok, %MailSlurpAPI.Model.WebhookNewSmsPayload{}} on success
  {:error, info} on failure
  """
  @spec get_test_webhook_payload_new_sms(Tesla.Env.client, keyword()) :: {:ok, MailSlurpAPI.Model.WebhookNewSmsPayload.t} | {:error, Tesla.Env.t}
  def get_test_webhook_payload_new_sms(connection, _opts \\ []) do
    %{}
    |> method(:get)
    |> url("/webhooks/test/new-sms-payload")
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> evaluate_response([
      { 200, %MailSlurpAPI.Model.WebhookNewSmsPayload{}}
    ])
  end

  @doc """
  Get a webhook

  ## Parameters

  - connection (MailSlurpAPI.Connection): Connection to server
  - webhook_id (String.t): 
  - opts (KeywordList): [optional] Optional parameters
  ## Returns

  {:ok, %MailSlurpAPI.Model.WebhookDto{}} on success
  {:error, info} on failure
  """
  @spec get_webhook(Tesla.Env.client, String.t, keyword()) :: {:ok, MailSlurpAPI.Model.WebhookDto.t} | {:error, Tesla.Env.t}
  def get_webhook(connection, webhook_id, _opts \\ []) do
    %{}
    |> method(:get)
    |> url("/webhooks/#{webhook_id}")
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> evaluate_response([
      { 200, %MailSlurpAPI.Model.WebhookDto{}}
    ])
  end

  @doc """
  Get a webhook result for a webhook

  ## Parameters

  - connection (MailSlurpAPI.Connection): Connection to server
  - webhook_result_id (String.t): Webhook Result ID
  - opts (KeywordList): [optional] Optional parameters
  ## Returns

  {:ok, %MailSlurpAPI.Model.WebhookResultDto{}} on success
  {:error, info} on failure
  """
  @spec get_webhook_result(Tesla.Env.client, String.t, keyword()) :: {:ok, MailSlurpAPI.Model.WebhookResultDto.t} | {:error, Tesla.Env.t}
  def get_webhook_result(connection, webhook_result_id, _opts \\ []) do
    %{}
    |> method(:get)
    |> url("/webhooks/results/#{webhook_result_id}")
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> evaluate_response([
      { 200, %MailSlurpAPI.Model.WebhookResultDto{}}
    ])
  end

  @doc """
  Get a webhook results for a webhook

  ## Parameters

  - connection (MailSlurpAPI.Connection): Connection to server
  - webhook_id (String.t): ID of webhook to get results for
  - opts (KeywordList): [optional] Optional parameters
    - :page (integer()): Optional page index in list pagination
    - :size (integer()): Optional page size in list pagination
    - :sort (String.t): Optional createdAt sort direction ASC or DESC
    - :search_filter (String.t): Optional search filter
    - :since (DateTime.t): Filter by created at after the given timestamp
    - :before (DateTime.t): Filter by created at before the given timestamp
    - :unseen_only (boolean()): Filter for unseen exceptions only
  ## Returns

  {:ok, %MailSlurpAPI.Model.PageWebhookResult{}} on success
  {:error, info} on failure
  """
  @spec get_webhook_results(Tesla.Env.client, String.t, keyword()) :: {:ok, MailSlurpAPI.Model.PageWebhookResult.t} | {:error, Tesla.Env.t}
  def get_webhook_results(connection, webhook_id, opts \\ []) do
    optional_params = %{
      :"page" => :query,
      :"size" => :query,
      :"sort" => :query,
      :"searchFilter" => :query,
      :"since" => :query,
      :"before" => :query,
      :"unseenOnly" => :query
    }
    %{}
    |> method(:get)
    |> url("/webhooks/#{webhook_id}/results")
    |> add_optional_params(optional_params, opts)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> evaluate_response([
      { 200, %MailSlurpAPI.Model.PageWebhookResult{}}
    ])
  end

  @doc """
  Get count of unseen webhook results with error status

  ## Parameters

  - connection (MailSlurpAPI.Connection): Connection to server
  - opts (KeywordList): [optional] Optional parameters
  ## Returns

  {:ok, %MailSlurpAPI.Model.UnseenErrorCountDto{}} on success
  {:error, info} on failure
  """
  @spec get_webhook_results_unseen_error_count(Tesla.Env.client, keyword()) :: {:ok, MailSlurpAPI.Model.UnseenErrorCountDto.t} | {:error, Tesla.Env.t}
  def get_webhook_results_unseen_error_count(connection, _opts \\ []) do
    %{}
    |> method(:get)
    |> url("/webhooks/results/unseen-count")
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> evaluate_response([
      { 200, %MailSlurpAPI.Model.UnseenErrorCountDto{}}
    ])
  end

  @doc """
  Get all webhooks for an Inbox

  ## Parameters

  - connection (MailSlurpAPI.Connection): Connection to server
  - inbox_id (String.t): 
  - opts (KeywordList): [optional] Optional parameters
  ## Returns

  {:ok, [%WebhookDto{}, ...]} on success
  {:error, info} on failure
  """
  @spec get_webhooks(Tesla.Env.client, String.t, keyword()) :: {:ok, list(MailSlurpAPI.Model.WebhookDto.t)} | {:error, Tesla.Env.t}
  def get_webhooks(connection, inbox_id, _opts \\ []) do
    %{}
    |> method(:get)
    |> url("/inboxes/#{inbox_id}/webhooks")
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> evaluate_response([
      { 200, [%MailSlurpAPI.Model.WebhookDto{}]}
    ])
  end

  @doc """
  Get a webhook result and try to resend the original webhook payload
  Allows you to resend a webhook payload that was already sent. Webhooks that fail are retried automatically for 24 hours and then put in a dead letter queue. You can retry results manually using this method.

  ## Parameters

  - connection (MailSlurpAPI.Connection): Connection to server
  - webhook_result_id (String.t): Webhook Result ID
  - opts (KeywordList): [optional] Optional parameters
  ## Returns

  {:ok, %MailSlurpAPI.Model.WebhookRedriveResult{}} on success
  {:error, info} on failure
  """
  @spec redrive_webhook_result(Tesla.Env.client, String.t, keyword()) :: {:ok, MailSlurpAPI.Model.WebhookRedriveResult.t} | {:error, Tesla.Env.t}
  def redrive_webhook_result(connection, webhook_result_id, _opts \\ []) do
    %{}
    |> method(:post)
    |> url("/webhooks/results/#{webhook_result_id}/redrive")
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> evaluate_response([
      { 200, %MailSlurpAPI.Model.WebhookRedriveResult{}}
    ])
  end

  @doc """
  Send webhook test data

  ## Parameters

  - connection (MailSlurpAPI.Connection): Connection to server
  - webhook_id (String.t): 
  - opts (KeywordList): [optional] Optional parameters
  ## Returns

  {:ok, %MailSlurpAPI.Model.WebhookTestResult{}} on success
  {:error, info} on failure
  """
  @spec send_test_data(Tesla.Env.client, String.t, keyword()) :: {:ok, MailSlurpAPI.Model.WebhookTestResult.t} | {:error, Tesla.Env.t}
  def send_test_data(connection, webhook_id, _opts \\ []) do
    %{}
    |> method(:post)
    |> url("/webhooks/#{webhook_id}/test")
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> evaluate_response([
      { 201, %MailSlurpAPI.Model.WebhookTestResult{}}
    ])
  end

  @doc """
  Update a webhook request headers

  ## Parameters

  - connection (MailSlurpAPI.Connection): Connection to server
  - webhook_id (String.t): 
  - webhook_headers (WebhookHeaders): 
  - opts (KeywordList): [optional] Optional parameters
  ## Returns

  {:ok, %MailSlurpAPI.Model.WebhookDto{}} on success
  {:error, info} on failure
  """
  @spec update_webhook_headers(Tesla.Env.client, String.t, MailSlurpAPI.Model.WebhookHeaders.t, keyword()) :: {:ok, MailSlurpAPI.Model.WebhookDto.t} | {:error, Tesla.Env.t}
  def update_webhook_headers(connection, webhook_id, webhook_headers, _opts \\ []) do
    %{}
    |> method(:put)
    |> url("/webhooks/#{webhook_id}/headers")
    |> add_param(:body, :body, webhook_headers)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> evaluate_response([
      { 200, %MailSlurpAPI.Model.WebhookDto{}}
    ])
  end

  @doc """
  Verify a webhook payload signature
  Verify a webhook payload using the messageId and signature. This allows you to be sure that MailSlurp sent the payload and not another server.

  ## Parameters

  - connection (MailSlurpAPI.Connection): Connection to server
  - verify_webhook_signature_options (VerifyWebhookSignatureOptions): 
  - opts (KeywordList): [optional] Optional parameters
  ## Returns

  {:ok, %MailSlurpAPI.Model.VerifyWebhookSignatureResults{}} on success
  {:error, info} on failure
  """
  @spec verify_webhook_signature(Tesla.Env.client, MailSlurpAPI.Model.VerifyWebhookSignatureOptions.t, keyword()) :: {:ok, MailSlurpAPI.Model.VerifyWebhookSignatureResults.t} | {:error, Tesla.Env.t}
  def verify_webhook_signature(connection, verify_webhook_signature_options, _opts \\ []) do
    %{}
    |> method(:post)
    |> url("/webhooks/verify")
    |> add_param(:body, :body, verify_webhook_signature_options)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> evaluate_response([
      { 200, %MailSlurpAPI.Model.VerifyWebhookSignatureResults{}}
    ])
  end
end