polarex

defmodule Polarex.Checkout do
  @moduledoc """
  Provides struct and type for a Checkout
  """

  @type t :: %__MODULE__{
          active_trial_interval: String.t() | nil,
          active_trial_interval_count: integer | nil,
          allow_discount_codes: boolean,
          allow_trial: boolean | nil,
          amount: integer,
          attached_custom_fields: [Polarex.AttachedCustomField.t()] | nil,
          billing_address_fields: Polarex.CheckoutBillingAddressFields.t(),
          client_secret: String.t(),
          created_at: DateTime.t(),
          currency: String.t(),
          custom_field_data: map | nil,
          customer_billing_address: Polarex.Address.t() | nil,
          customer_billing_name: String.t() | nil,
          customer_email: String.t() | nil,
          customer_id: String.t() | nil,
          customer_ip_address: String.t() | nil,
          customer_metadata: map,
          customer_name: String.t() | nil,
          customer_tax_id: String.t() | nil,
          discount: map | nil,
          discount_amount: integer,
          discount_id: String.t() | nil,
          embed_origin: String.t() | nil,
          expires_at: DateTime.t(),
          external_customer_id: String.t() | nil,
          id: String.t(),
          is_business_customer: boolean,
          is_discount_applicable: boolean,
          is_free_product_price: boolean,
          is_payment_form_required: boolean,
          is_payment_required: boolean,
          is_payment_setup_required: boolean,
          locale: String.t() | nil,
          max_seats: integer | nil,
          metadata: map,
          min_seats: integer | nil,
          modified_at: DateTime.t() | nil,
          net_amount: integer,
          organization_id: String.t(),
          payment_processor: String.t(),
          payment_processor_metadata: map,
          prices: map | nil,
          product: Polarex.CheckoutProduct.t() | nil,
          product_id: String.t() | nil,
          product_price: map | nil,
          product_price_id: String.t() | nil,
          products: [Polarex.CheckoutProduct.t()],
          require_billing_address: boolean,
          return_url: String.t() | nil,
          seats: integer | nil,
          status: String.t(),
          subscription_id: String.t() | nil,
          success_url: String.t(),
          tax_amount: integer | nil,
          tax_behavior: String.t() | nil,
          total_amount: integer,
          trial_end: DateTime.t() | nil,
          trial_interval: String.t() | nil,
          trial_interval_count: integer | nil,
          url: String.t()
        }

  defstruct [
    :active_trial_interval,
    :active_trial_interval_count,
    :allow_discount_codes,
    :allow_trial,
    :amount,
    :attached_custom_fields,
    :billing_address_fields,
    :client_secret,
    :created_at,
    :currency,
    :custom_field_data,
    :customer_billing_address,
    :customer_billing_name,
    :customer_email,
    :customer_id,
    :customer_ip_address,
    :customer_metadata,
    :customer_name,
    :customer_tax_id,
    :discount,
    :discount_amount,
    :discount_id,
    :embed_origin,
    :expires_at,
    :external_customer_id,
    :id,
    :is_business_customer,
    :is_discount_applicable,
    :is_free_product_price,
    :is_payment_form_required,
    :is_payment_required,
    :is_payment_setup_required,
    :locale,
    :max_seats,
    :metadata,
    :min_seats,
    :modified_at,
    :net_amount,
    :organization_id,
    :payment_processor,
    :payment_processor_metadata,
    :prices,
    :product,
    :product_id,
    :product_price,
    :product_price_id,
    :products,
    :require_billing_address,
    :return_url,
    :seats,
    :status,
    :subscription_id,
    :success_url,
    :tax_amount,
    :tax_behavior,
    :total_amount,
    :trial_end,
    :trial_interval,
    :trial_interval_count,
    :url
  ]

  @doc false
  @spec __fields__(atom) :: keyword
  def __fields__(type \\ :t)

  def __fields__(:t) do
    [
      active_trial_interval: {:union, [{:enum, ["day", "week", "month", "year"]}, :null]},
      active_trial_interval_count: {:union, [:integer, :null]},
      allow_discount_codes: :boolean,
      allow_trial: {:union, [:boolean, :null]},
      amount: :integer,
      attached_custom_fields: {:union, [[{Polarex.AttachedCustomField, :t}], :null]},
      billing_address_fields: {Polarex.CheckoutBillingAddressFields, :t},
      client_secret: :string,
      created_at: {:string, "date-time"},
      currency: :string,
      custom_field_data: :map,
      customer_billing_address: {:union, [{Polarex.Address, :t}, :null]},
      customer_billing_name: {:union, [:string, :null]},
      customer_email: {:union, [:string, :null]},
      customer_id: {:union, [{:string, "uuid4"}, :null]},
      customer_ip_address: {:union, [{:string, "ipvanyaddress"}, :null]},
      customer_metadata: :map,
      customer_name: {:union, [:string, :null]},
      customer_tax_id: {:union, [:string, :null]},
      discount: {:union, [:map, :null]},
      discount_amount: :integer,
      discount_id: {:union, [{:string, "uuid4"}, :null]},
      embed_origin: {:union, [:string, :null]},
      expires_at: {:string, "date-time"},
      external_customer_id: {:union, [:string, :null]},
      id: {:string, "uuid4"},
      is_business_customer: :boolean,
      is_discount_applicable: :boolean,
      is_free_product_price: :boolean,
      is_payment_form_required: :boolean,
      is_payment_required: :boolean,
      is_payment_setup_required: :boolean,
      locale: {:union, [:string, :null]},
      max_seats: {:union, [:integer, :null]},
      metadata: :map,
      min_seats: {:union, [:integer, :null]},
      modified_at: {:union, [{:string, "date-time"}, :null]},
      net_amount: :integer,
      organization_id: {:string, "uuid4"},
      payment_processor: {:const, "stripe"},
      payment_processor_metadata: :map,
      prices: {:union, [:map, :null]},
      product: {:union, [{Polarex.CheckoutProduct, :t}, :null]},
      product_id: {:union, [{:string, "uuid4"}, :null]},
      product_price: {:union, [:map, :null]},
      product_price_id: {:union, [{:string, "uuid4"}, :null]},
      products: [{Polarex.CheckoutProduct, :t}],
      require_billing_address: :boolean,
      return_url: {:union, [:string, :null]},
      seats: {:union, [:integer, :null]},
      status: {:enum, ["open", "expired", "confirmed", "succeeded", "failed"]},
      subscription_id: {:union, [{:string, "uuid4"}, :null]},
      success_url: :string,
      tax_amount: {:union, [:integer, :null]},
      tax_behavior: {:union, [{:enum, ["inclusive", "exclusive"]}, :null]},
      total_amount: :integer,
      trial_end: {:union, [{:string, "date-time"}, :null]},
      trial_interval: {:union, [{:enum, ["day", "week", "month", "year"]}, :null]},
      trial_interval_count: {:union, [:integer, :null]},
      url: :string
    ]
  end
end