### Display Formatting Workflow

Source: https://github.com/ex-phone-number/ex_phone_number/blob/master/usage-rules.md

An example workflow for formatting phone numbers for display, choosing between national and international formats based on the user's region.

```APIDOC
### Display Formatting
```elixir
def format_for_display(e164_number, user_region) do
  case ExPhoneNumber.parse(e164_number, "") do
    {:ok, phone_number} ->
      # Show national format if same country, international otherwise
      if phone_number.country_code == get_country_code(user_region) do
        ExPhoneNumber.format(phone_number, :national)
      else
        ExPhoneNumber.format(phone_number, :international)
      end
    {:error, _} ->
      e164_number # fallback to original
  end
end
```
```

--------------------------------

### User Input Processing Workflow

Source: https://github.com/ex-phone-number/ex_phone_number/blob/master/usage-rules.md

An example workflow demonstrating how to process user input for phone numbers, including parsing, validation, and formatting to E.164.

```APIDOC
## Example Workflows

### User Input Processing
```elixir
def process_phone_input(phone_string, user_region) do
  case ExPhoneNumber.parse(phone_string, user_region) do
    {:ok, phone_number} ->
      if ExPhoneNumber.is_valid_number?(phone_number) do
        {:ok, ExPhoneNumber.format(phone_number, :e164)}
      else
        {:error, "Invalid phone number for region"}
      end
    {:error, reason} ->
      {:error, "Could not parse phone number: #{reason}"}
  end
end
```
```

--------------------------------

### Get Phone Number Type

Source: https://github.com/ex-phone-number/ex_phone_number/blob/master/README.md

Determine the type of a parsed phone number, such as :fixed_line, :mobile, etc.

```elixir
iex> ExPhoneNumber.get_number_type(phone_number)
:fixed_line
```

--------------------------------

### Get Phone Number Type

Source: https://github.com/ex-phone-number/ex_phone_number/blob/master/usage-rules.md

Use `ExPhoneNumber.get_number_type/1` to determine the type of a phone number, such as mobile, toll-free, or VoIP.

```elixir
# Get the type of phone number
ExPhoneNumber.get_number_type(phone_number) 
# Returns: :fixed_line, :mobile, :fixed_line_or_mobile, :toll_free, 
#          :premium_rate, :shared_cost, :voip, :personal_number, 
#          :pager, :uan, :voicemail, :unknown
```

--------------------------------

### Getting the Number Type

Source: https://github.com/ex-phone-number/ex_phone_number/blob/master/README.md

Determines the type of a phone number (e.g., fixed line, mobile, toll-free).

```APIDOC
## ExPhoneNumber.get_number_type/1

### Description
Determines the type of a phone number (e.g., fixed line, mobile, toll-free).

### Parameters
#### Path Parameters
- `phone_number` (%ExPhoneNumber.Model.PhoneNumber{}) - Required - The phone number struct to analyze.

### Response
#### Success Response (200)
- `atom` - The type of the phone number (e.g., `:fixed_line`, `:mobile`).

### Request Example
```elixir
ExPhoneNumber.get_number_type(phone_number)
```

### Response Example
```elixir
:fixed_line
```
```

--------------------------------

### Parse E.164 Phone Numbers

Source: https://github.com/ex-phone-number/ex_phone_number/blob/master/usage-rules.md

E.164 numbers (starting with '+') can be parsed with an empty string or nil as the region code.

```elixir
 {:ok, phone_number} = ExPhoneNumber.parse("+41446681800", "")
 {:ok, phone_number} = ExPhoneNumber.parse("+12024561111", nil)
```

--------------------------------

### Publish Package to Hex.pm

Source: https://github.com/ex-phone-number/ex_phone_number/blob/master/maintenance.md

Command to publish the ExPhoneNumber package to Hex.pm. Ensure you have followed the preceding steps for versioning and committing.

```bash
mix hex.publish
```

--------------------------------

### Set Version and Commit Release

Source: https://github.com/ex-phone-number/ex_phone_number/blob/master/maintenance.md

Commands to set the release version, commit the changes, tag the release, and push to origin. This is part of the release process.

```bash
export VERSION=x.x.x
git commit -am "Release v$VERSION"
git tag v$VERSION
git push origin master --tags
```

--------------------------------

### Configure Custom Metadata File

Source: https://github.com/ex-phone-number/ex_phone_number/blob/master/README.md

Configure ExPhoneNumber to use a custom metadata XML file at compile time. Ensure the path is absolute if the file is outside the dependency directory.

```elixir
config :ex_phone_number, :metadata_file, Path.join(File.cwd!(), "path/to/custom/PhoneNumberMetadata.xml")
```

--------------------------------

### Recompile Dependency After Configuration Change

Source: https://github.com/ex-phone-number/ex_phone_number/blob/master/README.md

After changing the metadata file configuration, recompile the ex_phone_number dependency to apply the changes.

```shell
mix deps.compile ex_phone_number --force
```

--------------------------------

### Update Metadata with mix

Source: https://github.com/ex-phone-number/ex_phone_number/blob/master/maintenance.md

Use this command to update the library's metadata. Remember to also update the CHANGELOG.md and commit the changes.

```elixir
mix update_metadata
```

--------------------------------

### Configure Custom Phone Metadata

Source: https://context7.com/ex-phone-number/ex_phone_number/llms.txt

Substitute the default Google libphonenumber metadata with a custom XML file at compile time via application configuration. Ensure an absolute path is used for correct resolution.

```elixir
import Config

config :ex_phone_number,
  :metadata_file,
  Path.join(File.cwd!(), "priv/custom_phone_metadata.xml")
```

--------------------------------

### Add Maintainer to Hex Package

Source: https://github.com/ex-phone-number/ex_phone_number/blob/master/maintenance.md

Use this command to add a new maintainer to the ExPhoneNumber package on Hex.pm. Replace <email or hex.pm username> with the appropriate identifier.

```bash
mix hex.owner add ex_phone_number <email or hex.pm username> --level maintainer
```

--------------------------------

### Quick Phone Number Feasibility Check

Source: https://context7.com/ex-phone-number/ex_phone_number/llms.txt

Uses `is_possible_number?/1` or `is_possible_number?/2` for a fast check of phone number plausibility based on length. The two-argument form parses the number internally.

```elixir
{:ok, phone} = ExPhoneNumber.parse("044 668 18 00", "CH")

ExPhoneNumber.is_possible_number?(phone)
# => true

# Two-argument form skips explicit parse step
ExPhoneNumber.is_possible_number?("044 668 18 00", "CH")
# => true

ExPhoneNumber.is_possible_number?("12345", "US")
# => false  (too short for a US number)

# Difference between possible and valid:
{:ok, short} = ExPhoneNumber.parse("+12024561111", "")
ExPhoneNumber.is_possible_number?(short)  # => true  (correct length)
ExPhoneNumber.is_valid_number?(short)     # => true  (also matches valid pattern)

# A number can be possible but not valid for a specific region
ExPhoneNumber.is_possible_number?("6502530000", "US")  # => true
```

--------------------------------

### Add ExPhoneNumber to Mix Dependencies

Source: https://github.com/ex-phone-number/ex_phone_number/blob/master/README.md

Add the :ex_phone_number library to your project's dependencies in the mix.exs file.

```elixir
def deps do
  [
    {:ex_phone_number, "~> 0.4.11"}
  ]
end
```

--------------------------------

### Error Handling for Parsing

Source: https://github.com/ex-phone-number/ex_phone_number/blob/master/usage-rules.md

The `parse/2` function returns `{:ok, phone_number}` on success or `{:error, reason}` on failure. Handle these tuples appropriately in your code.

```APIDOC
## Error Handling

The `parse/2` function returns `{:ok, phone_number}` or `{:error, reason}`:

```elixir
case ExPhoneNumber.parse(input, region) do
  {:ok, phone_number} -> 
    # Use phone_number
  {:error, reason} -> 
    # Handle parsing error
end
```
```

--------------------------------

### Handle Parsing Errors

Source: https://github.com/ex-phone-number/ex_phone_number/blob/master/usage-rules.md

The `parse/2` function returns `{:ok, phone_number}` on success or `{:error, reason}` on failure. Use a case statement to handle both outcomes.

```elixir
case ExPhoneNumber.parse(input, region) do
  {:ok, phone_number} -> 
    # Use phone_number
  {:error, reason} -> 
    # Handle parsing error
end
```

--------------------------------

### Formatting Phone Numbers

Source: https://github.com/ex-phone-number/ex_phone_number/blob/master/usage-rules.md

Use `ExPhoneNumber.format/2` with specific format atoms to format phone numbers. Available formats include :e164, :international, :national, and :rfc3966.

```APIDOC
## Formatting Phone Numbers

Use `ExPhoneNumber.format/2` with these format atoms:

- `:e164` - International format without spaces (e.g., "+41446681800")
- `:international` - International format with spaces (e.g., "+41 44 668 18 00")
- `:national` - National format (e.g., "044 668 18 00")
- `:rfc3966` - RFC3966 URI format (e.g., "tel:+41-44-668-18-00")

```elixir
ExPhoneNumber.format(phone_number, :e164)
ExPhoneNumber.format(phone_number, :international)
ExPhoneNumber.format(phone_number, :national)
ExPhoneNumber.format(phone_number, :rfc3966)
```
```

--------------------------------

### ExPhoneNumber.is_possible_number?/1 and ExPhoneNumber.is_possible_number?/2

Source: https://context7.com/ex-phone-number/ex_phone_number/llms.txt

Quickly checks if a phone number's length is plausible for its region. It can accept a parsed PhoneNumber struct or a raw string and region code.

```APIDOC
## `ExPhoneNumber.is_possible_number?/1` and `ExPhoneNumber.is_possible_number?/2`

### Description
Quickly checks if a phone number's length is plausible for its region. It can accept a parsed PhoneNumber struct or a raw string and region code.

### Method
`is_possible_number?/1` accepts a parsed `%PhoneNumber{}` struct.
`is_possible_number?/2` accepts a raw string and a region code, parsing internally before the check.

### Parameters
#### `is_possible_number?/1`
- **phone** (%PhoneNumber{}) - Required - A parsed phone number struct.

#### `is_possible_number?/2`
- **input** (string) - Required - The raw phone number string.
- **region** (string) - Required - The ISO 3166-1 alpha-2 region code.

### Request Example
```elixir
{:ok, phone} = ExPhoneNumber.parse("044 668 18 00", "CH")

ExPhoneNumber.is_possible_number?(phone)
# => true

# Two-argument form skips explicit parse step
ExPhoneNumber.is_possible_number?("044 668 18 00", "CH")
# => true

ExPhoneNumber.is_possible_number?("12345", "US")
# => false  (too short for a US number)
```

### Response
- **boolean** - Returns `true` if the number is possible, `false` otherwise.
```

--------------------------------

### Formatting a Phone Number

Source: https://github.com/ex-phone-number/ex_phone_number/blob/master/README.md

Formats a phone number struct into various string representations.

```APIDOC
## ExPhoneNumber.format/2

### Description
Formats a phone number struct into various string representations.

### Parameters
#### Path Parameters
- `phone_number` (%ExPhoneNumber.Model.PhoneNumber{}) - Required - The phone number struct to format.
- `format` (atom) - Required - The desired format (`:national`, `:international`, `:e164`, `:rfc3966`).

### Response
#### Success Response (200)
- `string` - The formatted phone number string.

### Request Example
```elixir
ExPhoneNumber.format(phone_number, :international)
```

### Response Example
```elixir
"+41 44 668 18 00"
```
```

--------------------------------

### Pattern Match on Phone Number Fields

Source: https://context7.com/ex-phone-number/ex_phone_number/llms.txt

Use pattern matching to extract and format phone numbers based on country code. Handles North American and international numbers, as well as errors.

```elixir
case ExPhoneNumber.parse(input, region) do
  {:ok, %{country_code: 1} = phone} ->
    IO.puts("North American number: #{ExPhoneNumber.format(phone, :national)}")
  {:ok, phone} ->
    IO.puts("International: #{ExPhoneNumber.format(phone, :international)}")
  {:error, _reason} ->
    IO.puts("Invalid input")
end
```

--------------------------------

### ExPhoneNumber.Model.PhoneNumber Struct Fields

Source: https://context7.com/ex-phone-number/ex_phone_number/llms.txt

Details the key fields of the `%ExPhoneNumber.Model.PhoneNumber{}` struct, which is returned by `parse/2`. Fields include `country_code`, `national_number`, `extension`, and `raw_input`. Manual construction of this struct is not recommended.

```elixir
{:ok, phone} = ExPhoneNumber.parse("+41446681800", "")

phone.country_code    # => 41
phone.national_number # => 446681800
phone.extension       # => nil
phone.raw_input       # => nil  (not preserved by default parse/2)

# Extension handling
{:ok, with_ext} = ExPhoneNumber.parse("+1-800-555-1234;ext=9999", "")
with_ext.extension    # => "9999"

# Italian leading zeros
{:ok, it_phone} = ExPhoneNumber.parse("+390612345678", "")
it_phone.italian_leading_zero  # => nil (only set when a leading zero is present)
```

--------------------------------

### Format Phone Number Struct with ExPhoneNumber.format/2

Source: https://context7.com/ex-phone-number/ex_phone_number/llms.txt

Converts a parsed `%PhoneNumber{}` struct into a formatted string using one of four format atoms: `:e164`, `:international`, `:national`, or `:rfc3966`. Always use these atoms for formatting.

```elixir
ExPhoneNumber.format(phone, :e164)
# => "+41446681800"
```

```elixir
ExPhoneNumber.format(phone, :international)
# => "+41 44 668 18 00"
```

```elixir
ExPhoneNumber.format(phone, :national)
# => "044 668 18 00"
```

```elixir
ExPhoneNumber.format(phone, :rfc3966)
# => "tel:+41-44-668-18-00"
```

```elixir
# US example
{:ok, us_phone} = ExPhoneNumber.parse("202-456-1111", "US")

ExPhoneNumber.format(us_phone, :e164)          # => "+12024561111"
ExPhoneNumber.format(us_phone, :international) # => "+1 202-456-1111"
ExPhoneNumber.format(us_phone, :national)      # => "(202) 456-1111"
ExPhoneNumber.format(us_phone, :rfc3966)       # => "tel:+1-202-456-1111"
```

--------------------------------

### Parse Phone Numbers with Region Code

Source: https://github.com/ex-phone-number/ex_phone_number/blob/master/usage-rules.md

Use `ExPhoneNumber.parse/2` to convert strings to phone number structs. Always provide a region code for non-E.164 numbers.

```elixir
 {:ok, phone_number} = ExPhoneNumber.parse("044 668 18 00", "CH")
 {:ok, phone_number} = ExPhoneNumber.parse("(650) 253-0000", "US")
```

--------------------------------

### Validate Phone Numbers

Source: https://github.com/ex-phone-number/ex_phone_number/blob/master/usage-rules.md

Use `is_valid_number?/1` to check if a phone number is valid according to regional rules, and `is_possible_number?/1` for a less strict check.

```elixir
# Check if number is valid according to regional rules
ExPhoneNumber.is_valid_number?(phone_number) # returns boolean

# Check if number is possible (correct length, etc.)
ExPhoneNumber.is_possible_number?(phone_number) # returns boolean

# Can also check possibility without parsing first
ExPhoneNumber.is_possible_number?("650 253 0000", "US") # returns boolean
```

--------------------------------

### User Input Processing Workflow

Source: https://github.com/ex-phone-number/ex_phone_number/blob/master/usage-rules.md

This function parses user input, validates the phone number, and formats it to E.164 if valid. It handles both parsing errors and invalid numbers.

```elixir
def process_phone_input(phone_string, user_region) do
  case ExPhoneNumber.parse(phone_string, user_region) do
    {:ok, phone_number} ->
      if ExPhoneNumber.is_valid_number?(phone_number) do
        {:ok, ExPhoneNumber.format(phone_number, :e164)}
      else
        {:error, "Invalid phone number for region"}
      end
    {:error, reason} ->
      {:error, "Could not parse phone number: #{reason}"}
  end
end
```

--------------------------------

### ExPhoneNumber.format/2

Source: https://context7.com/ex-phone-number/ex_phone_number/llms.txt

Converts a parsed %PhoneNumber{} struct into a formatted string using one of four format atoms: :e164, :international, :national, or :rfc3966.

```APIDOC
## ExPhoneNumber.format/2

### Description
Converts a parsed `%PhoneNumber{}` struct into a formatted string. The second argument is a format atom: `:e164`, `:international`, `:national`, or `:rfc3966`. Always use these atoms — do not pass format strings.

### Method
`ExPhoneNumber.format/2`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```elixir
{:ok, phone} = ExPhoneNumber.parse("044 668 18 00", "CH")

ExPhoneNumber.format(phone, :e164)
# => "+41446681800"

ExPhoneNumber.format(phone, :international)
# => "+41 44 668 18 00"

ExPhoneNumber.format(phone, :national)
# => "044 668 18 00"

ExPhoneNumber.format(phone, :rfc3966)
# => "tel:+41-44-668-18-00"

# US example
{:ok, us_phone} = ExPhoneNumber.parse("202-456-1111", "US")

ExPhoneNumber.format(us_phone, :e164)          # => "+12024561111"
ExPhoneNumber.format(us_phone, :international) # => "+1 202-456-1111"
ExPhoneNumber.format(us_phone, :national)      # => "(202) 456-1111"
ExPhoneNumber.format(us_phone, :rfc3966)       # => "tel:+1-202-456-1111"
```

### Response
#### Success Response
`String.t()` representing the formatted phone number.

#### Response Example
`"+41446681800"`
```

--------------------------------

### Format Phone Numbers

Source: https://github.com/ex-phone-number/ex_phone_number/blob/master/usage-rules.md

Use `ExPhoneNumber.format/2` with format atoms like `:e164`, `:international`, `:national`, or `:rfc3966` to format parsed phone numbers.

```elixir
ExPhoneNumber.format(phone_number, :e164)
ExPhoneNumber.format(phone_number, :international)
ExPhoneNumber.format(phone_number, :national)
ExPhoneNumber.format(phone_number, :rfc3966)
```

--------------------------------

### Parse and Validate a Phone Number

Source: https://github.com/ex-phone-number/ex_phone_number/blob/master/README.md

Parse a phone number string with a given country code and check its validity. The parsed number is returned as a %ExPhoneNumber.Model.PhoneNumber struct.

```elixir
iex> {:ok, phone_number} = ExPhoneNumber.parse("044 668 18 00", "CH")
{:ok,
%ExPhoneNumber.Model.PhoneNumber{
  country_code: 41,
  country_code_source: nil,
  extension: nil,
  italian_leading_zero: nil,
  national_number: 446681800,
  number_of_leading_zeros: nil,
  preferred_domestic_carrier_code: nil,
  raw_input: nil
}}

iex> ExPhoneNumber.is_possible_number?(phone_number)
true

iex> ExPhoneNumber.is_valid_number?(phone_number)
true
```

--------------------------------

### Parsing a Phone Number

Source: https://github.com/ex-phone-number/ex_phone_number/blob/master/README.md

Parses a phone number string with an optional default region. Returns an {:ok, %ExPhoneNumber.Model.PhoneNumber{}} struct on success or an error tuple.

```APIDOC
## ExPhoneNumber.parse/2

### Description
Parses a phone number string with an optional default region. Returns an `{:ok, %ExPhoneNumber.Model.PhoneNumber{}}` struct on success or an error tuple.

### Parameters
#### Path Parameters
- `phone_number_string` (string) - Required - The phone number to parse.
- `default_region` (string) - Optional - The default region to use if the number is not in international format.

### Response
#### Success Response (200)
- `{:ok, %ExPhoneNumber.Model.PhoneNumber{}}` - A struct containing the parsed phone number details.

### Request Example
```elixir
ExPhoneNumber.parse("044 668 18 00", "CH")
```

### Response Example
```elixir
{:ok,
 %ExPhoneNumber.Model.PhoneNumber{
   country_code: 41,
   national_number: 446681800,
   raw_input: nil
}}
```
```

--------------------------------

### Parsing Phone Numbers

Source: https://github.com/ex-phone-number/ex_phone_number/blob/master/usage-rules.md

Use `ExPhoneNumber.parse/2` to convert strings into phone number structs. Always provide a region code for non-E164 numbers. E164 numbers can be parsed with an empty or nil region code.

```APIDOC
## Parsing Phone Numbers

Always use `ExPhoneNumber.parse/2` to convert strings to phone number structs:

```elixir
# Parse with region code (required for non-E164 numbers)
{:ok, phone_number} = ExPhoneNumber.parse("044 668 18 00", "CH")
{:ok, phone_number} = ExPhoneNumber.parse("(650) 253-0000", "US")

# Parse E164 numbers (region code can be empty string or nil)
{:ok, phone_number} = ExPhoneNumber.parse("+41446681800", "")
{:ok, phone_number} = ExPhoneNumber.parse("+12024561111", nil)
```

**Never** try to create `%ExPhoneNumber.Model.PhoneNumber{}` structs manually - always use the parser.
```

--------------------------------

### Display Formatting Workflow

Source: https://github.com/ex-phone-number/ex_phone_number/blob/master/usage-rules.md

This function formats an E.164 number for display, using the national format if the user's region matches the number's country code, and international format otherwise.

```elixir
def format_for_display(e164_number, user_region) do
  case ExPhoneNumber.parse(e164_number, "") do
    {:ok, phone_number} ->
      # Show national format if same country, international otherwise
      if phone_number.country_code == get_country_code(user_region) do
        ExPhoneNumber.format(phone_number, :national)
      else
        ExPhoneNumber.format(phone_number, :international)
      end
    {:error, _} ->
      e164_number # fallback to original
  end
end
```

--------------------------------

### ExPhoneNumber.parse/2

Source: https://context7.com/ex-phone-number/ex_phone_number/llms.txt

Converts a raw phone number string into a structured %ExPhoneNumber.Model.PhoneNumber{} struct. A region code is required for non-E164 numbers. Returns {:ok, %PhoneNumber{}} on success or {:error, reason} on failure.

```APIDOC
## ExPhoneNumber.parse/2

### Description
Converts a raw phone number string into a `%ExPhoneNumber.Model.PhoneNumber{}` struct. The second argument is an ISO 3166-1 alpha-2 region code (e.g., `"US"`, `"GB"`, `"CH"`) required for numbers that are not in E164 format. E164 numbers (beginning with `+`) can be parsed with `""` or `nil` as the region code. Returns `{:ok, %PhoneNumber{}}` on success or `{:error, reason}` on failure.

### Method
`ExPhoneNumber.parse/2`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```elixir
# Parse a Swiss national number with region code
{:ok, phone} = ExPhoneNumber.parse("044 668 18 00", "CH")
# => {:ok, %ExPhoneNumber.Model.PhoneNumber{country_code: 41, national_number: 446681800, ...}}

# Parse a US number
{:ok, phone} = ExPhoneNumber.parse("(202) 456-1111", "US")
# => {:ok, %ExPhoneNumber.Model.PhoneNumber{country_code: 1, national_number: 2024561111, ...}}

# Parse an E164 number — region code is not needed
{:ok, phone} = ExPhoneNumber.parse("+41446681800", "")
{:ok, phone} = ExPhoneNumber.parse("+12024561111", nil)

# Parse a number with an extension
{:ok, phone} = ExPhoneNumber.parse("+1-800-555-1234 ext. 9999", "")
# phone.extension => "9999"

# Handle parse errors
case ExPhoneNumber.parse("not-a-number", "US") do
  {:ok, phone_number} ->
    IO.inspect(phone_number)
  {:error, reason} ->
    IO.puts("Failed: #{reason}")
    # => "Failed: The string supplied did not seem to be a phone number"
end
```

### Response
#### Success Response
`{:ok, %ExPhoneNumber.Model.PhoneNumber{}}`

#### Error Response
`{:error, reason}` where reason is a string describing the error (e.g., `"Invalid country calling code"`, `"The string supplied did not seem to be a phone number"`).
```

--------------------------------

### Normalize and Validate Phone Numbers

Source: https://context7.com/ex-phone-number/ex_phone_number/llms.txt

Parses an input string with a given region, validates it, and formats it to E.164 if valid. Returns an error tuple if parsing fails or the number is invalid for the region.

```elixir
def normalize_phone(input, region) do
  case ExPhoneNumber.parse(input, region) do
    {:ok, phone} ->
      if ExPhoneNumber.is_valid_number?(phone) do
        {:ok, ExPhoneNumber.format(phone, :e164)}
      else
        {:error, "Phone number is not valid for the given region"}
      end
    {:error, reason} ->
      {:error, "Could not parse: #{reason}"}
  end
end

normalize_phone("044 668 18 00", "CH")  # => {:ok, "+41446681800"}
normalize_phone("000 000 00 00", "CH")  # => {:error, "Phone number is not valid for the given region"}
```

--------------------------------

### Parse Phone Number String with ExPhoneNumber.parse/2

Source: https://context7.com/ex-phone-number/ex_phone_number/llms.txt

Converts a raw phone number string into a `%ExPhoneNumber.Model.PhoneNumber{}` struct. A region code is required for non-E164 numbers. Handles extensions and returns `{:ok, %PhoneNumber{}}` or `{:error, reason}`.

```elixir
# Parse a Swiss national number with region code
{:ok, phone} = ExPhoneNumber.parse("044 668 18 00", "CH")
# => {:ok, %ExPhoneNumber.Model.PhoneNumber{country_code: 41, national_number: 446681800, ...}}
```

```elixir
# Parse a US number
{:ok, phone} = ExPhoneNumber.parse("(202) 456-1111", "US")
# => {:ok, %ExPhoneNumber.Model.PhoneNumber{country_code: 1, national_number: 2024561111, ...}}
```

```elixir
# Parse an E164 number — region code is not needed
{:ok, phone} = ExPhoneNumber.parse("+41446681800", "")
{:ok, phone} = ExPhoneNumber.parse("+12024561111", nil)
```

```elixir
# Parse a number with an extension
{:ok, phone} = ExPhoneNumber.parse("+1-800-555-1234 ext. 9999", "")
# phone.extension => "9999"
```

```elixir
# Handle parse errors
case ExPhoneNumber.parse("not-a-number", "US") do
  {:ok, phone_number} ->
    IO.inspect(phone_number)
  {:error, reason} ->
    IO.puts("Failed: #{reason}")
    # => "Failed: The string supplied did not seem to be a phone number"
end
```

```elixir
# Error cases and their messages:
# "Invalid country calling code"
# "The string supplied did not seem to be a phone number"
# "The string supplied is too short to be a phone number"
# "The string supplied is too long to be a phone number"
```

--------------------------------

### Checking if a Number is Possible

Source: https://github.com/ex-phone-number/ex_phone_number/blob/master/README.md

Checks if a given phone number struct represents a possible number based on its length and prefix.

```APIDOC
## ExPhoneNumber.is_possible_number?/1

### Description
Checks if a given phone number struct represents a possible number based on its length and prefix.

### Parameters
#### Path Parameters
- `phone_number` (%ExPhoneNumber.Model.PhoneNumber{}) - Required - The phone number struct to check.

### Response
#### Success Response (200)
- `boolean` - `true` if the number is possible, `false` otherwise.

### Request Example
```elixir
ExPhoneNumber.is_possible_number?(phone_number)
```

### Response Example
```elixir
true
```
```

--------------------------------

### Validation

Source: https://github.com/ex-phone-number/ex_phone_number/blob/master/usage-rules.md

Validate phone numbers using `is_valid_number?/1` and `is_possible_number?/1`. You can also check possibility without parsing first. `get_number_type/1` returns the type of the phone number.

```APIDOC
## Validation

Use these functions to validate phone numbers:

```elixir
# Check if number is valid according to regional rules
ExPhoneNumber.is_valid_number?(phone_number) # returns boolean

# Check if number is possible (correct length, etc.)
ExPhoneNumber.is_possible_number?(phone_number) # returns boolean

# Can also check possibility without parsing first
ExPhoneNumber.is_possible_number?("650 253 0000", "US") # returns boolean

# Get the type of phone number
ExPhoneNumber.get_number_type(phone_number) 
# Returns: :fixed_line, :mobile, :fixed_line_or_mobile, :toll_free, 
#          :premium_rate, :shared_cost, :voip, :personal_number, 
#          :pager, :uan, :voicemail, :unknown
```
```

--------------------------------

### ExPhoneNumber.country_code_to_region_code_map/0

Source: https://context7.com/ex-phone-number/ex_phone_number/llms.txt

Provides access to the complete mapping of country calling codes to their corresponding ISO 3166-1 alpha-2 region codes.

```APIDOC
## `ExPhoneNumber.country_code_to_region_code_map/0`

### Description
Provides access to the complete mapping of country calling codes to their corresponding ISO 3166-1 alpha-2 region codes. This map is compiled metadata useful for lookup and introspection.

### Method
`country_code_to_region_code_map/0` takes no arguments.

### Request Example
```elixir
map = ExPhoneNumber.country_code_to_region_code_map()

# Look up regions for a calling code
map[1]   # => ["US", "AG", "AI", "AS", "BB", "BM", ...]  (NANPA countries)
map[41]  # => ["CH"]
map[44]  # => ["GB", "GG", "IM", "JE"]

# Check how many regions use a given country code
map[1] |> length()  # => 25 (NANPA countries)

# Get all supported calling codes
Map.keys(map) |> Enum.sort()
# => [1, 7, 20, 27, 30, 31, ...]
```

### Response
- **map** - A map where keys are integer country calling codes and values are lists of ISO 3166-1 alpha-2 region code strings.
```

--------------------------------

### Parse E.164 Formatted Number

Source: https://github.com/ex-phone-number/ex_phone_number/blob/master/README.md

Parse an E.164 formatted phone number where the country code can be automatically detected. Pass an empty string or nil for the country code argument.

```elixir
iex> ExPhoneNumber.parse("+977123456789", "")
{:ok,
%ExPhoneNumber.Model.PhoneNumber{
  country_code: 977,
  country_code_source: nil,
  extension: nil,
  italian_leading_zero: nil,
  national_number: 123456789,
  number_of_leading_zeros: nil,
  preferred_domestic_carrier_code: nil,
  raw_input: nil
 }}
```

--------------------------------

### Validate Phone Number with ExPhoneNumber.is_valid_number?/1

Source: https://context7.com/ex-phone-number/ex_phone_number/llms.txt

Strictly validates if a phone number struct matches regional rules, ensuring it conforms to known valid patterns for its country code. Returns `true` if valid, `false` otherwise.

```elixir
ExPhoneNumber.is_valid_number?(valid_ch)    # => true
ExPhoneNumber.is_valid_number?(invalid_ch)  # => false
```

--------------------------------

### Format Phone Number

Source: https://github.com/ex-phone-number/ex_phone_number/blob/master/README.md

Format a parsed phone number into different standard formats: national, international, E.164, and RFC3966.

```elixir
iex> ExPhoneNumber.format(phone_number, :national)
"044 668 18 00"

iex> ExPhoneNumber.format(phone_number, :international)
"+41 44 668 18 00"

iex> ExPhoneNumber.format(phone_number, :e164)
"+41446681800"

iex> ExPhoneNumber.format(phone_number, :rfc3966)
"tel:+41-44-668-18-00"
```

--------------------------------

### ExPhoneNumber.get_number_type/1

Source: https://context7.com/ex-phone-number/ex_phone_number/llms.txt

Determines and returns the category of a given phone number as an atom.

```APIDOC
## `ExPhoneNumber.get_number_type/1`

### Description
Determines and returns the category of a given phone number as an atom. Possible return values include `:fixed_line`, `:mobile`, `:toll_free`, `:premium_rate`, `:voip`, and `:unknown`.

### Method
`get_number_type/1` accepts a parsed `%PhoneNumber{}` struct.

### Parameters
- **phone** (%PhoneNumber{}) - Required - A parsed phone number struct.

### Request Example
```elixir
{:ok, swiss_fixed}  = ExPhoneNumber.parse("044 668 18 00", "CH")
{:ok, us_number}    = ExPhoneNumber.parse("202-456-1111", "US")
{:ok, toll_free}    = ExPhoneNumber.parse("1-800-555-1234", "US")

ExPhoneNumber.get_number_type(swiss_fixed) # => :fixed_line
ExPhoneNumber.get_number_type(us_number)   # => :fixed_line_or_mobile
ExPhoneNumber.get_number_type(toll_free)   # => :toll_free
```

### Response
- **atom** - An atom representing the type of the phone number (e.g., `:fixed_line`, `:mobile`, `:toll_free`, `:unknown`).
```

--------------------------------

### Country Code to Region Code Mapping

Source: https://context7.com/ex-phone-number/ex_phone_number/llms.txt

Accesses the `country_code_to_region_code_map/0` function to retrieve a map of country calling codes to their corresponding ISO 3166-1 alpha-2 region codes. This map is useful for lookups and introspection.

```elixir
map = ExPhoneNumber.country_code_to_region_code_map()

# Look up regions for a calling code
map[1]   # => ["US", "AG", "AI", "AS", "BB", "BM", ...]  (NANPA countries)
map[41]  # => ["CH"]
map[44]  # => ["GB", "GG", "IM", "JE"]

# Check how many regions use a given country code
map[1] |> length()  # => 25 (NANPA countries)

# Get all supported calling codes
Map.keys(map) |> Enum.sort()
# => [1, 7, 20, 27, 30, 31, ...]
```

--------------------------------

### ExPhoneNumber.is_valid_number?/1

Source: https://context7.com/ex-phone-number/ex_phone_number/llms.txt

Validates a phone number struct against the regional rules of its country code, returning true if it matches a known valid pattern.

```APIDOC
## ExPhoneNumber.is_valid_number?/1

### Description
Returns `true` if the phone number is valid according to the regional rules of its country code. This is a strict check: the number must match a known valid pattern for the region (e.g., correct prefix, correct length for that number type). A number can be "possible" (correct length) without being "valid" (matching a known assignment).

### Method
`ExPhoneNumber.is_valid_number?/1`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```elixir
{:ok, valid_ch}   = ExPhoneNumber.parse("044 668 18 00", "CH")
{:ok, invalid_ch} = ExPhoneNumber.parse("012 345 67 89", "CH")

ExPhoneNumber.is_valid_number?(valid_ch)    # => true
ExPhoneNumber.is_valid_number?(invalid_ch)  # => false
```

### Response
#### Success Response
`boolean()` - `true` if the number is valid, `false` otherwise.

#### Response Example
`true`
```

--------------------------------

### Validating a Phone Number

Source: https://github.com/ex-phone-number/ex_phone_number/blob/master/README.md

Validates if a given phone number struct is a valid phone number for its region.

```APIDOC
## ExPhoneNumber.is_valid_number?/1

### Description
Validates if a given phone number struct is a valid phone number for its region.

### Parameters
#### Path Parameters
- `phone_number` (%ExPhoneNumber.Model.PhoneNumber{}) - Required - The phone number struct to validate.

### Response
#### Success Response (200)
- `boolean` - `true` if the number is valid, `false` otherwise.

### Request Example
```elixir
ExPhoneNumber.is_valid_number?(phone_number)
```

### Response Example
```elixir
true
```
```

--------------------------------

### Parsing E164 Numbers

Source: https://github.com/ex-phone-number/ex_phone_number/blob/master/README.md

Parses an E164 formatted phone number. The country code can be detected from the number itself, so the default region can be an empty string or nil.

```APIDOC
## ExPhoneNumber.parse/2 with E164 input

### Description
Parses an E164 formatted phone number. The country code can be detected from the number itself, so the default region can be an empty string or nil.

### Parameters
#### Path Parameters
- `phone_number_string` (string) - Required - The E164 formatted phone number string (e.g., "+977123456789").
- `default_region` (string) - Optional - Can be `""` or `nil` as the country code is detected from the number.

### Response
#### Success Response (200)
- `{:ok, %ExPhoneNumber.Model.PhoneNumber{}}` - A struct containing the parsed phone number details.

### Request Example
```elixir
ExPhoneNumber.parse("+977123456789", "")
```

### Response Example
```elixir
{:ok,
 %ExPhoneNumber.Model.PhoneNumber{
   country_code: 977,
   national_number: 123456789,
   raw_input: nil
 }}
```
```

--------------------------------

### Determine Phone Number Type

Source: https://context7.com/ex-phone-number/ex_phone_number/llms.txt

Identifies the category of a parsed phone number using `get_number_type/1`. This function returns an atom representing the number type, such as :fixed_line, :mobile, or :toll_free.

```elixir
{:ok, swiss_fixed}  = ExPhoneNumber.parse("044 668 18 00", "CH")
{:ok, us_number}    = ExPhoneNumber.parse("202-456-1111", "US")
{:ok, toll_free}    = ExPhoneNumber.parse("1-800-555-1234", "US")

ExPhoneNumber.get_number_type(swiss_fixed) # => :fixed_line
ExPhoneNumber.get_number_type(us_number)   # => :fixed_line_or_mobile
ExPhoneNumber.get_number_type(toll_free)   # => :toll_free

# Use type to branch logic
defp route_call(phone) do
  case ExPhoneNumber.get_number_type(phone) do
    :toll_free          -> {:ok, :free_routing}
    :premium_rate       -> {:ok, :premium_routing}
    :mobile             -> {:ok, :sms_capable}
    :fixed_line         -> {:ok, :landline_routing}
    :fixed_line_or_mobile -> {:ok, :unknown_routing}
    :voip               -> {:ok, :voip_routing}
    :unknown            -> {:error, "Cannot determine number type"}
    _other              -> {:ok, :default_routing}
  end
end
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.