can you generate the table of contents for the following markdown document pls? # common-kotlin
This module contains many simple and atomic utils that can be used in Kotlin backend projects.
Feel free to cherry-pick the one you need for your project.

## Errors lib

### Introduction
This library contains base classes and interfaces for representing application errors.
The idea is to use objects and return values to represent errors instead of exceptions.
This library is based on [arrow-kt](https://arrow-kt.io/): it uses extensively the `arrow.core.Either` datatype (and potentially other utils from arrow).

Functions should return an `Either` whose left side is an error object and whose right side is the result of the function.
Callers of those function can then decide to handle the error or not.

Errors with `Either` offer the same error handling capabilities as exceptions:
- Catching / recovering from errors can be done by using the `handleError` or `handleErrorWith` operators
- Rethrowing / raising a different error can be done with the `mapLeft` operator
- Propagating errors can be done by simply returning the `Either` value

The benefits are multiple:
- Error types are explicit, without the need for complicated verbose type signatures, like with checked exceptions
- Errors can be handled as values, without the need for `try` / `catch` blocks
- Error handling is more explicit: each function error case need to be handled or propagated.
 With exceptions, error propagation is implicit and can lead to unexpected behavior

Other modules in this repository depend on this base error abstraction to provide a consistent error handling mechanism.

### Usage
The core of this module is the `ApplicationError` interface. All user defined errors should inherit from this interface.
There are multiple subtypes of `ApplicationError`:
- `RetryableApplicationError` => errors that can be retried
- `NonRetryableApplicationError` => errors that cannot / shouldn't be retried.
 This subtype further specialises in more types.
 Other libraries may decide to present these errors types differently to the user.
 - `NotFoundError` => errors that indicate that a resource was not found
 - `ConflictError` => errors that indicate that a resource already exists / would result in a conflict
 - `InvalidInputError` => errors that indicate that the input is invalid

To define a new type of error, simply create a new class that inherits from one of the above subtypes.
```kotlin
data class FluxCapacitorOverloadedError(
 override val message: String = "Flux Capacitor overloaded",
 override val meta: Map = emptyMap(),
 override val cause: Throwable? = null,
) : RetryableApplicationError
```

For convenience, some helper classes are available to easily create new types of errors without having to redeclare all the fields:
```kotlin
// without dynamic fields
object FluxCapacitorOverloadedError : DefaultRetryableApplicationError(message = "Flux Capacitor overloaded")

// with dynamic fields
data class FluxCapacitorOverloadedError(
 val capacitorId: Long,
) : DefaultRetryableApplicationError(
 message = "Flux Capacitor $capacitorId overloaded",
 meta = mapOf("capacitorId" to capacitorId),
)
```

To signify that a method can return an error, simply return an `Either` whose left side is an `ApplicationError`
and whose right side is the result of the function.
You could use the convenient `ErrorOr`, which is a typealias for `Either`.
```kotlin
fun turnOnFluxCapacitor(capacitorId: Long): ErrorOr {
 if (isOverloaded(capacitorId)) {
 return FluxCapacitorOverloadedError(capacitorId).left()
 }
 // do stuff
 return FluxCapacitor(capacitorId).right()

}
```

To bridge the gap between functional and imperative world, it is sometimes mandatory to use exceptions to signal errors to the framework with use.
This is for example the case with Spring Transactional methods, or with jvm-kit event listeners.

For that reason, this lib exposes a very convenient util call `orThrow` that can be called on an instance of `ErrorOr`.
This util will (by default) throw an `ApplicationException` if the `ErrorOr` is a `Left` and return the value if it is a `Right`.
The `ApplicationException` extends `RuntimeException` and will contain the underlying error object.
If the error object had a cause, the `ApplicationException` will have its cause set to the original error cause.

```kotlin
val fluxCapacitor: FluxCapacitor = turnOnFluxCapacitor(capacitorId).orThrow()
```

## Well Known Tiny types
### Overview
This library provides a collection of Kotlin utilities for managing and validating various data types within the Glovo ecosystem.
It includes several value classes and error classes to handle different types of input, such as city codes, country codes, currency codes, and time zones.
Those classes are represented as inline value classes (aka Tiny Types),
which means that they are lightweight and do not incur any runtime overhead (aka Zero Cost Abstraction).

### Features
- Encapsulates various data validation and parsing within value classes
- Provides parse functions to handle invalid input
- Checks if given input strings are valid or not for each utility

### Utilities
#### CityCode

The `CityCode` value class represents a valid city code within the Glovo ecosystem.
City codes must be 3 characters long.

##### Usage
###### Creating a CityCode

```kotlin
val cityCode = CityCode("ABC")
```

###### Parsing City Codes

```kotlin
val parsedCityCode = CityCode.parse("XYZ")
```

###### Checking If a City Code is Valid

```kotlin
val isValid = CityCode.isValid("XYZ")
```

#### CountryCode

The `CountryCode` value class represents a valid country code as defined by ISO 3166-1 alpha-2 ([link](https://en.wikipedia.org/wiki/ISO\_3166-1\_alpha-2)).

##### Usage
###### Creating a CountryCode

```kotlin
val countryCode = CountryCode("US")
```
###### Parsing Country Codes

```kotlin
val parsedCountryCode = CountryCode.parse("FR")
```
###### Checking If a Country Code is Valid

```kotlin
val isValid = CountryCode.isValid("DE")
```
#### Currency

The `Currency` value class represents a valid currency code as defined by ISO 4217 ([link](https://en.wikipedia.org/wiki/ISO\_4217)).

##### Usage
###### Creating a Currency

```kotlin
val currency = Currency("USD")
```
###### Parsing Currency Codes

```kotlin
val parsedCurrency = Currency.parse("EUR")
```
###### Checking If a Currency Code is Valid

```kotlin
val isValid = Currency.isValid("JPY")
```
#### TimeZone

The `TimeZone` value class represents a valid time zone.

##### Usage
###### Creating a TimeZone

```kotlin
val timeZone = TimeZone("America/New\_York")
```

###### Parsing Time Zones

```kotlin
val parsedTimeZone = TimeZone.parse("Europe/London")
```
###### Checking If a Time Zone is Valid

```kotlin
val isValid = TimeZone.isValid("Asia/Tokyo")
```
### Error Classes

Each utility has its own error class to represent any errors that might occur during validation:
- `InvalidCityCodeError`
- `InvalidCountryCodeError`
- `InvalidCurrencyError`
- `InvalidTimeZoneError`

These error classes contain information about the input and the reason for the error. For example:

```kotlin
data class InvalidCityCodeError(val input: String, val reason: String)
```
다음 마크다운 문서 pls의 목차를 생성할 수 있나요? # common-kotlin이 모듈에는 Kotlin 백엔드 프로젝트에서 사용할 수 있는 많은 간단한 원자 유틸리티가 포함되어 있습니다.프로젝트에 필요한 것을 자유롭게 골라 사용하세요.## 오류 라이브러리### 소개이 라이브러리에는 애플리케이션 오류를 표현하기 위한 기본 클래스와 인터페이스가 포함되어 있습니다.예외 대신 객체와 반환값을 사용하여 오류를 표현하는 것이 아이디어입니다.이 라이브러리는 [arrow-kt](https://arrow-kt.io/)를 기반으로 하며, `arrow.core.Either` 데이터 유형(및 잠재적으로 arrow의 다른 유틸리티)을 광범위하게 사용합니다.함수는 왼쪽이 오류 객체이고 오른쪽이 함수의 결과인 `Either`를 반환해야 합니다.그러면 해당 함수의 호출자는 오류를 처리할지 여부를 결정할 수 있습니다.둘 중 하나`가 있는 오류는 예외와 동일한 오류 처리 기능을 제공합니다:- 오류를 포착/복구하는 것은 `handleError` 또는 `handleErrorWith` 연산자를 사용하여 수행할 수 있습니다.- 다른 에러를 다시 던지거나 발생시키는 것은 `mapLeft` 연산자로 할 수 있습니다.- 오류 전파는 단순히 `Either` 값을 반환하여 수행할 수 있습니다.이점은 여러 가지가 있습니다:- 오류 유형이 명시적이므로, 체크된 예외와 같이 복잡한 장황한 유형 서명이 필요하지 않습니다.- 시도`/`캐치` 블록 없이 오류를 값으로 처리할 수 있습니다.- 오류 처리가 더 명확해졌습니다. 각 함수 오류 사례를 처리하거나 전파해야 합니다. 예외를 제외하고, 오류 전파는 암시적이며 예기치 않은 동작으로 이어질 수 있습니다.이 저장소의 다른 모듈은 일관된 오류 처리 메커니즘을 제공하기 위해 이 기본 오류 추상화에 의존합니다.### 사용법이 모듈의 핵심은 `ApplicationError` 인터페이스입니다. 모든 사용자 정의 에러는 이 인터페이스에서 상속되어야 합니다.응용 프로그램 에러`에는 여러 가지 서브 타입이 있습니다:- 재시도 가능한 오류(`RetryableApplicationError` => 재시도 가능한 오류)- NonRetryableApplicationError` => 재시도할 수 없거나 재시도해서는 안 되는 에러. 이 하위 유형은 더 많은 유형에 특화되어 있습니다. 다른 라이브러리에서는 이러한 에러 유형을 사용자에게 다르게 표시할 수 있습니다. - NotFoundError` => 리소스를 찾을 수 없음을 나타내는 에러 - 충돌 에러` => 리소스가 이미 존재하거나 충돌을 일으킬 수 있음을 나타내는 에러 - InvalidInputError` => 입력이 유효하지 않음을 나타내는 오류새로운 유형의 오류를 정의하려면 위의 하위 유형 중 하나를 상속하는 새 클래스를 생성하기만 하면 됩니다.```kotlin데이터 클래스 FluxCapacitorOverloadedError( val 메시지를 재정의합니다: String = "플럭스 커패시터 과부하", override val meta: Map = emptyMap(), override val cause: Throwable? = null,) : RetryableApplicationError```편의를 위해 모든 필드를 다시 선언하지 않고도 새로운 유형의 오류를 쉽게 생성할 수 있는 일부 헬퍼 클래스를 사용할 수 있습니다:```kotlin// 동적 필드 없이객체 FluxCapacitorOverloadedError : DefaultRetryableApplicationError(message = "플럭스 커패시터 과부하")// 동적 필드 포함데이터 클래스 FluxCapacitorOverloadedError( val capacitorId: Long,) : DefaultRetryableApplicationError( 메시지 = "플럭스 커패시터 $capacitorId 과부하", meta = mapOf("capacitorId" to capacitorId),)```메서드가 오류를 반환할 수 있음을 나타내려면, 왼쪽이 `ApplicationError`인 `Either`를 반환하면 됩니다.를 반환하고 오른쪽은 함수의 결과입니다.또는 `Either`의 유형 별칭인 편리한 `ErrorOr`을 사용할 수도 있습니다.```kotlinfun turnOnFluxCapacitor(capacitorId: Long): ErrorOr { if (isOverloaded(capacitorId)) { return FluxCapacitorOverloadedError(capacitorId).left() } // 작업 수행 return FluxCapacitor(capacitorId).right()}```기능적 세계와 명령적 세계 사이의 간극을 메우기 위해 사용 시 프레임워크에 오류를 알리기 위해 예외를 사용해야 할 때가 있습니다.예를 들어 Spring 트랜잭션 메서드나 jvm-kit 이벤트 리스너를 사용하는 경우가 이에 해당합니다.이러한 이유로 이 라이브러리에는 `ErrorOr` 인스턴스에서 호출할 수 있는 매우 편리한 `orThrow`라는 유틸리티 호출이 노출되어 있습니다.이 유틸리티는 (기본적으로) `ErrorOr`가 `Left`인 경우 `ApplicationException`을 던지고, `Right`인 경우 값을 반환합니다.응용 프로그램 예외`는 `RuntimeException`을 확장하며 기본 오류 객체를 포함합니다.오류 객체에 원인이 있는 경우 `ApplicationException`의 원인은 원래 오류 원인으로 설정됩니다.```kotlinval fluxCapacitor: FluxCapacitor = turnOnFluxCapacitor(capacitorId).orThrow()```## 잘 알려진 작은 유형### 개요이 라이브러리는 Glovo 에코시스템 내에서 다양한 데이터 유형을 관리하고 유효성을 검사하기 위한 Kotlin 유틸리티 모음을 제공합니다.여기에는 도시 코드, 국가 코드, 통화 코드 및 시간대와 같은 다양한 유형의 입력을 처리하기 위한 여러 값 클래스와 오류 클래스가 포함되어 있습니다.이러한 클래스는 인라인 값 클래스(일명 작은 유형)로 표현됩니다,즉, 경량이며 런타임 오버헤드가 발생하지 않습니다(제로 비용 추상화라고도 함).### 기능- 캡슐화