> ## Documentation Index
> Fetch the complete documentation index at: https://docs.y.uno/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> Test in the sandbox first: base URL https://api-sandbox.y.uno (Test Mode in the Dashboard). Production is https://api.y.uno (Live Mode).
> Every API request needs the public-api-key and private-secret-key headers. Get them in the Dashboard at https://dashboard.y.uno/developers (Developers > Credentials); sandbox and production keys are different.
> Send an X-Idempotency-Key (a UUID) when creating payments, refunds and cancels, so retries do not create duplicates.
> Start with the Quickstart (https://docs.y.uno/docs/quickstart.md) and the agent guide (https://docs.y.uno/agents.md). To search these docs from a coding agent, connect the docs MCP server at https://docs.y.uno/mcp.

# Modo Lite

> Migra las integraciones Android Lite (Activity.startCheckout + Activity.startPaymentLite) a la API unificada Transaction.

El modo Lite preseleccionaba el método de pago del lado del comercio y luego cedía el control al SDK para mostrar el formulario, tokenizar, crear el pago, gestionar 3DS e informar el resultado. En la API unificada este es el **comportamiento predeterminado** de `Transaction.start(paymentSelected:)`. No se necesitan sobrescrituras del controlador aparte de `onStatus`.

## Antes de empezar

* Reemplaza las importaciones `com.yuno.sdk.*` y `com.yuno.presentation.*` por sus equivalentes `com.yuno.payments.sdk.api.*` (la comparación lado a lado las lista). Tu clave de API pública y las sesiones de checkout que crea tu backend no cambian ([Antes de comenzar](https://docs.y.uno/es/docs/yuno-sdk/get-started.md#before-you-begin)).
* Decide quién crea el pago. El `workflow` de la sesión de checkout debe coincidir con esa decisión:

| Quién crea el pago | En Lite tenías | En la API unificada | `workflow` de la sesión |
| - | - | - | - |
| Tu backend | `callbackOTT` implementado (la variante headless) | Sobrescribe `createPayment` | Predeterminado (`SDK_CHECKOUT`) |
| El SDK | Sin `callbackOTT` | Sin sobrescritura | `SDK_SEAMLESS` |

> [!WARNING]
>
> Una sesión con el workflow predeterminado y sin la sobrescritura de `createPayment` termina en `INTERNAL_ERROR`: el backend rechaza la creación del pago del SDK. Consulta [`createPayment`](https://docs.y.uno/es/docs/yuno-sdk/controllers/create-payment).

## Comparación lado a lado

```kotlin Before. Lite mode theme={"theme":{"light":"github-dark","dark":"github-dark-dimmed"}}
import com.yuno.sdk.Yuno
import com.yuno.sdk.YunoConfig
import com.yuno.sdk.payments.startCheckout
import com.yuno.sdk.payments.startPaymentLite
import com.yuno.presentation.core.components.PaymentSelected

class CheckoutActivity : ComponentActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // 1. Initialize once at app startup (usually in Application.onCreate)
        Yuno.initialize(
            applicationContext,
            apiKey = "your-public-api-key",
            config = YunoConfig(
                saveCardEnabled = true,
                keepLoader = false,
                styles = customStyles,
            ),
        )

        // 2. Set up the checkout launcher and the result callbacks
        startCheckout(
            checkoutSession = "session-from-backend",
            countryCode = "CO",
            callbackPaymentState = { state, subState ->
                when (state) {
                    "SUCCEEDED"         -> println("Success")
                    "REJECT"            -> println("Rejected")
                    "FAIL"              -> println("Failed")
                    "PROCESSING"        -> println("Processing")
                    "INTERNAL_ERROR"    -> println("Internal error")
                    "CANCELED_BY_USER"  -> println("User cancelled")
                }
            },
        )
    }

    // 3. Trigger the payment with a pre-selected method
    fun pay(paymentSelected: PaymentSelected) {
        startPaymentLite(
            paymentSelected = paymentSelected,
            showPaymentStatus = true,
        )
    }
}
```

```kotlin After. Unified Transaction theme={"theme":{"light":"github-dark","dark":"github-dark-dimmed"}}
import com.yuno.payments.sdk.api.SdkPayments
import com.yuno.payments.sdk.api.Transaction
import com.yuno.payments.sdk.api.TransactionConfig
import com.yuno.payments.sdk.api.TransactionController
import com.yuno.payments.sdk.api.models.PaymentMethodSelected
import com.yuno.payments.sdk.api.models.TransactionStatus

class CheckoutActivity : ComponentActivity(), TransactionController {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // 1. Initialize once at app startup (usually in Application.onCreate)
        SdkPayments.initialize(applicationContext, apiKey = "your-public-api-key")
    }

    // 2. Implement the controller
    override fun onStatus(status: TransactionStatus) {
        when (status.status) {
            "SUCCEEDED"      -> println("Success")
            "DECLINED"       -> println("Declined")
            "REJECTED"       -> println("Rejected")
            "ERROR"          -> println("Error")
            "PENDING"        -> println("Pending")
            "INTERNAL_ERROR" -> println("Internal error")
            "USER_CANCEL"    -> println("User cancelled")
        }
    }

    // 3. Trigger the payment with a pre-selected method
    fun pay(paymentSelected: PaymentMethodSelected) {
        val config = TransactionConfig(
            checkoutSession = "session-from-backend",
            countryCode = "CO",
            language = "en",
            appearance = customAppearance,      // optional
            controller = this,
            showStatusScreen = true,
        )

        Transaction(config = config)
            .start(activity = this, paymentSelected = paymentSelected)
    }
}
```

## Qué cambia

Agrupado en el orden en que editas el código. **Renombrado**: mismo rol, nuevo nombre. **Movido**: mismo valor, nuevo responsable. **Eliminado**: no hay nada que llamar. **Nuevo**: sin equivalente anterior. La última columna es lo único que debes hacer además del cambio de nombre.

### Inicialización y configuración

| Lite | Unificado | Cambio | Qué hacer |
| - | - | - | - |
| `import com.yuno.sdk.*` | `import com.yuno.payments.sdk.api.*` | Renombrado | |
| `Yuno.initialize(context, apiKey, YunoConfig)` | `SdkPayments.initialize(context, apiKey)` | Renombrado | `YunoConfig` desaparece: sus campos pasan a `TransactionConfig` o se eliminan (filas siguientes). |
| `YunoConfig.styles` | `TransactionConfig.appearance` | Movido | Pásalo por transacción en lugar de una sola vez al inicio. |
| `YunoConfig.language` | `TransactionConfig.language` | Movido | Pásalo por transacción en lugar de una sola vez al inicio. |
| `YunoConfig.saveCardEnabled` | *(eliminado)* | Eliminado | Elimínalo: el indicador ahora se controla del lado del servidor mediante el servicio de configuración y el cliente ya no lo pasa. |
| `YunoConfig.keepLoader` | *(eliminado)* | Eliminado | El SDK conserva su indicador de carga. Sobrescribe `showLoading` solo si quieres uno propio (consulta Controlador). |
| `YunoConfig.isDynamicViewEnabled` | *(eliminado)* | Eliminado | Elimínalo: el flujo de vista dinámica es el único flujo en la API unificada. |
| Argumentos `checkoutSession`, `countryCode` de `startCheckout` | Los mismos campos en `TransactionConfig` | Movido | Los argumentos de la llamada de configuración pasan a ser campos de la configuración. |
| Argumento `merchantSessionId` | *(eliminado)* | Eliminado | Reservado: el ID de sesión antifraude ahora se configura del lado del servidor y ya no se pasa desde el cliente. |
| Argumento `showPaymentStatus` de `startPaymentLite` | `TransactionConfig.showStatusScreen` | Movido | Consulta la nota siguiente. |

> [!NOTE]
>
> **La pantalla de resultado del SDK ahora está desactivada de forma predeterminada.** Define `showStatusScreen = true` para conservarla.

### Controlador

| Lite | Unificado | Cambio | Qué hacer |
| - | - | - | - |
| Lambdas pasadas a `startCheckout` (`callbackPaymentState`, `callbackOTT`) | `TransactionController` | Renombrado | Las lambdas pasan a ser una interfaz: implementa `TransactionController` en la clase que mantengas durante la transacción (tu `Activity`, `ViewModel` o un contenedor de estado dedicado) y pásala como `TransactionConfig.controller`. El SDK no la retiene: mantenla activa durante toda la transacción. |
| `callbackPaymentState: (state, subState) -> Unit` | `onStatus(status: TransactionStatus)` | Renombrado | Sigue siendo el único callback de resultado, una vez por transacción con el estado terminal, también cuando el SDK muestra su pantalla de resultado, para que puedas manejar tu propia interfaz encima. El par de cadenas sin procesar `(state, subState)` pasa a ser un objeto `TransactionStatus`: `status` y `substatus` provienen del backend, tal como los devuelve. Las cadenas anteriores `REJECT`, `FAIL` y `PROCESSING` ya no se emiten: gestiona `DECLINED`, `REJECTED`, `ERROR` y `PENDING`. `CANCELED_BY_USER` ahora es `USER_CANCEL`; `subState` se corresponde 1 a 1 con `substatus`. El SDK solo emite `INTERNAL_ERROR` y `USER_CANCEL`. Consulta [`Status`](https://docs.y.uno/es/docs/yuno-sdk/reference/objects-you-receive#status). |
| `callbackOTT: (String?) -> Unit` | `createPayment(token: Map<String, Any>)` | Renombrado | Opcional. En Lite esta lambda solo se activaba en la variante headless; para el flujo Lite gestionado por el SDK no la necesitas. Si tu backend crea el pago, sobrescríbela: `token` es el token de un solo uso completo como mapa, no solo la cadena del token. Crea el pago y retorna; el SDK luego consulta el estado, ejecuta 3DS si hace falta y llama a `onStatus`. Si el manejador lanza una excepción, el flujo se detiene y no se llama a `onStatus`, así que muestra el error tú mismo. Consulta [`createPayment`](https://docs.y.uno/es/docs/yuno-sdk/controllers/create-payment) y [Migración Headless](https://docs.y.uno/es/docs/yuno-sdk/migration/android/payment/headless.md). |
| *(ninguno)* | `showLoading(isLoading: Boolean)` | Nuevo | Opcional. Lite no tenía un callback de carga: el SDK siempre mostraba su propio indicador. Lo sigue haciendo a menos que sobrescribas `showLoading`; una vez sobrescrito, el SDK oculta su indicador y te informa el estado. Consulta [`showLoading`](https://docs.y.uno/es/docs/yuno-sdk/controllers/show-loading). |

### Puntos de entrada

| Lite | Unificado | Cambio | Qué hacer |
| - | - | - | - |
| `startCheckout(…)` + `startPaymentLite(paymentSelected, …, showPaymentStatus)` | `Transaction(config).start(activity, paymentSelected)` | Renombrado | Crea la configuración y luego llama a `start`. Sigues eligiendo el método y pasándolo. Las dos funciones de extensión de `Activity` pasan a ser una sola llamada en una instancia normal de `Transaction`: no necesitas una `Activity` para construirla (solo necesitas una `Activity`/`Context` si quieres lanzar la interfaz del SDK). `showPaymentStatus` pasó a la configuración (consulta Inicialización y configuración). |
| `PaymentSelected` | `PaymentMethodSelected` | Renombrado | Mismo rol: el valor que pasas a `start`. |

## Relacionado

* [Primeros pasos](https://docs.y.uno/es/docs/yuno-sdk/get-started.md). Guía completa de la API unificada.
* [`TransactionConfig`](https://docs.y.uno/es/docs/yuno-sdk/reference/objects-you-pass#transaction-config). Referencia completa de campos.
* [`Status`](https://docs.y.uno/es/docs/yuno-sdk/reference/objects-you-receive#status). Valores y substatus.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.