> ## 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.

# Inscripción en iOS

> Inscribe métodos de pago en iOS con full-checkout usando el delegate de inscripción y el manejo de resultados

> [!NOTE]
>
> **Esta página documenta un SDK heredado.** ¿Vas a iniciar una nueva integración? Usa el [Yuno SDK](https://docs.y.uno/docs/yuno-sdk/get-started.md). ¿Ya usas un SDK heredado? Sigue la [guía de migración](https://docs.y.uno/docs/yuno-sdk/migration/overview.md).
>
> El nuevo **Yuno SDK** (Web v2.x, iOS v3.x, Android v3.x, React Native v2.x) reemplaza los SDK Full, Lite, Seamless, Render, Headless y Secure Fields con una sola API en todas las plataformas. Los SDK heredados siguen siendo compatibles en paralelo durante la transición y está previsto dejarlos de usar en **2027**. Contacta a tu Account Manager para planificar la migración.

El SDK de iOS facilita la implementación de flujos de inscripción para guardar métodos de pago en la cuenta de un cliente.

Incluye la biblioteca en tu proyecto siguiendo los mismos pasos que en [full-checkout](https://docs.y.uno/docs/sdks/full-checkout/ios-payments#include-the-library-in-your-project).

## Recursos adicionales

* Consulta [Elige la integración adecuada para ti](https://docs.y.uno/es/docs/sdks/overview/choose-integration.md) si no estás seguro de qué flujo seguir.

* Accede a las [notas de la versión](https://docs.y.uno/changelog/ios.md) o al [repositorio del Yuno iOS SDK](https://github.com/yuno-payments/yuno-sdk-ios) para verificar la última versión disponible del SDK.

* [Inscripción con full-checkout (iOS)](#full-checkout-enrollment-ios): inscripción automática con componentes de interfaz prediseñados

## Requisitos

* CocoaPods o [Swift Package Manager](https://www.swift.org/package-manager/)
* iOS 14.0 o posterior
* Cuenta activa de Yuno; credenciales de API (obtenlas en el [Dashboard de Yuno](https://dashboard.y.uno/) → **Developers** > **Credentials**)
* Crea un cliente con el [endpoint Crear cliente](https://docs.y.uno/reference/customers/create-customer.md) antes de realizar la inscripción

## Parámetros

Para ver la lista completa de parámetros, consulta la [Referencia común del SDK de iOS](https://docs.y.uno/es/docs/sdks/resources/references/ios.md).

| Parámetro | Descripción |
| - | - |
| `customerSession` | ID de la sesión de cliente de la API Crear sesión de cliente. Obligatorio. |
| `countryCode` | Código de país ISO (por ejemplo, `BR`). Obligatorio. |
| `language` | Código de idioma de la interfaz. Opcional. |
| `viewController` | UIViewController que presenta el flujo de inscripción. Obligatorio para el delegate. |
| `yunoEnrollmentResult(_:)` | Delegate: la inscripción finalizó con un resultado. |
| `YunoConfig` (initialize) | Opcional: `appearance`, `saveCardEnabled`. Consulta la Referencia común. |

## Inscripción con full-checkout (iOS)

El Yuno full-checkout SDK para iOS ofrece inscripción con interfaz prediseñada, inscripción de tarjetas, manejo de estados y manejo básico de errores. Consulta la sección anterior de [Requisitos](#requirements).

### Paso 1: crea un cliente y una sesión de cliente

Crea un cliente en el sistema de Yuno con el [endpoint Crear cliente](https://docs.y.uno/reference/customers/create-customer.md) antes de inscribir métodos de pago. Este endpoint devolverá un `customer_id` que usarás para asociar los métodos de pago inscritos con el cliente específico.

Luego crea una sesión de cliente con el endpoint [Crear sesión de cliente](https://docs.y.uno/reference/customer-sessions-enrollment/create-customer-session.md). La información de la sesión se usará al llamar a los métodos de inscripción.

```json theme={"theme":{"light":"github-dark","dark":"github-dark-dimmed"}}
POST /v1/customer-session

{
  "country": "BR",
  "customer_id": "6c85a4e3-0a6c-423d-a12a-10045320ab4a"
}
```

La respuesta incluye un ID de `customer_session` que usarás en el siguiente paso.

En tu servidor, crea también un [objeto de método de pago para inscripción](https://docs.y.uno/reference/payment-methods-checkout/enroll-payment-method-checkout.md) para esa sesión de cliente, a fin de definir qué método de pago puede inscribir el cliente. Mantén tus claves de API privadas en el servidor.

### Paso 2: incluye la biblioteca en tu proyecto

Incluir la biblioteca en tu proyecto se hace de la misma manera que en los flujos de pago. Sigue allí los pasos de [Incluye la biblioteca en tu proyecto](https://docs.y.uno/docs/sdks/full-checkout/ios-payments#include-the-library-in-your-project).

#### CocoaPods

```ruby theme={"theme":{"light":"github-dark","dark":"github-dark-dimmed"}}
pod 'YunoSDK', '~> 2.29.0'
```

Ejecuta:

```ruby theme={"theme":{"light":"github-dark","dark":"github-dark-dimmed"}}
pod install
```

#### Swift Package Manager

```swift theme={"theme":{"light":"github-dark","dark":"github-dark-dimmed"}}
dependencies: [
    .package(url: "https://github.com/yuno-payments/yuno-sdk-ios.git", .upToNextMajor(from: "2.29.0"))
]
```

Consulta las [notas de la versión](https://docs.y.uno/changelog/ios.md) o el [repositorio del Yuno iOS SDK](https://github.com/yuno-payments/yuno-sdk-ios) para ver la versión actual del SDK.

### Paso 3: inicializa el SDK con la clave pública

Inicializa el SDK:

1. Obtén tu clave de API pública en el [Dashboard de Yuno](https://dashboard.y.uno/)
2. Inicializa el SDK llamando a `Yuno.initialize()` con tu clave de API:

```swift theme={"theme":{"light":"github-dark","dark":"github-dark-dimmed"}}
import YunoSDK

Yuno.initialize(
    apiKey: "PUBLIC_API_KEY",
    config: YunoConfig(),
    callback: { print("Yuno SDK initialized") }
)
```

Usa la data class `YunoConfig` para personalizar el comportamiento del SDK. Incluye esta configuración al llamar a `Yuno.initialize()`. Por ejemplo:

```swift theme={"theme":{"light":"github-dark","dark":"github-dark-dimmed"}}
struct YunoConfig {
    var appearance: Appearance? = nil
    var saveCardEnabled: Bool = false
}
```

### Paso 4: implementa el delegate de inscripción

Crea una clase que adopte el protocolo `YunoEnrollmentDelegate`:

> [!NOTE]
>
> **Requisitos de concurrencia de Swift 6**
>
> Si usas Swift 6, deberás implementar el protocolo `YunoEnrollmentDelegate` con consideraciones específicas de concurrencia. Consulta la guía de [concurrencia de Swift 6](https://docs.y.uno/es/docs/sdks/resources/swift-6-concurrency.md) para ver opciones de implementación detalladas y mejores prácticas.

```swift theme={"theme":{"light":"github-dark","dark":"github-dark-dimmed"}}
protocol YunoEnrollmentDelegate: AnyObject {
    var customerSession: String { get }
    var countryCode: String { get }
    var language: String? { get }
    var viewController: UIViewController? { get }

    func yunoEnrollmentResult(_ result: Yuno.Result)
}

class ViewController: UIViewController, @preconcurrency YunoEnrollmentDelegate {
    var customerSession: String { "cus_ses_123456" }
    var countryCode: String { "BR" }
    var language: String? { "en" }
    var viewController: UIViewController? { self }

    func yunoEnrollmentResult(_ result: Yuno.Result) {
        switch result.status {
        case .succeeded:
            print("Enrollment successful")
        case .fail:
            print("Enrollment failed")
        case .processing:
            print("Enrollment processing")
        case .reject:
            print("Enrollment rejected")
        case .userCancelled:
            print("User canceled")
        case .internalError:
            print("Internal error")
        @unknown default:
            break
        }
    }
}
```

#### Opciones

| Parámetro | Descripción |
| - | - |
| `customerSession` | El identificador único de la sesión de cliente. |
| `countryCode` | Código del país donde se realiza la inscripción. Consulta [Cobertura por país](https://docs.y.uno/es/docs/sdks/resources/country-coverage.md) para ver los países compatibles. |
| `language` | Código de idioma de los formularios de inscripción (por ejemplo, `"en"`, `"es"`, `"pt"`). Consulta [Idiomas compatibles](https://docs.y.uno/es/docs/sdks/resources/languages-supported.md). |
| `viewController` | El `UIViewController` usado para presentar el flujo de inscripción. Obligatorio para una presentación correcta de la interfaz. |
| `yunoEnrollmentResult(_:)` | Se llama cuando el proceso de inscripción finaliza con el resultado final. |

### Paso 5: inicia el proceso de inscripción

Llama al método `enrollPayment()` para mostrar el flujo de inscripción:

```swift theme={"theme":{"light":"github-dark","dark":"github-dark-dimmed"}}
func startEnrollment() {
    Yuno.enrollPayment(with: self, showPaymentStatus: true)
}
```

El SDK presenta de forma modal un `UIViewController` a pantalla completa usando el `viewController` proporcionado en tu delegate. En SwiftUI, envuelve un `UIViewController` y devuélvelo mediante la propiedad `viewController`.

#### Opciones

| Parámetro | Tipo | Descripción |
| - | - | - |
| `delegate` | `YunoEnrollmentDelegate` | El objeto delegate que maneja los callbacks de inscripción. |
| `showPaymentStatus` | `Bool` | Indica si se muestran vistas de estado durante el proceso de inscripción. Cuando es `true`, el SDK muestra las pantallas de estado predeterminadas. Cuando es `false`, tú manejas la visualización del estado mediante callbacks. |

En SwiftUI, envuelve un `UIViewController` y devuélvelo desde la propiedad `viewController` para que el SDK pueda presentar la interfaz.

### Paso 6: maneja el regreso del deep link (opcional)

Solo es necesario cuando el flujo de inscripción usa deep links. Si tu método de pago no usa deep links, omite este paso. De lo contrario, maneja el regreso en tu `AppDelegate`:

```swift theme={"theme":{"light":"github-dark","dark":"github-dark-dimmed"}}
func application(_ app: UIApplication,
                 open url: URL,
                 options: [UIApplication.OpenURLOptionsKey: Any] = [:]) -> Bool {

    guard url.scheme == "yunoexample" else { return false }

    return Yuno.receiveDeeplink(url)
}
```

Asegúrate de que `url.scheme` coincida con el `callback_url` usado al crear el `customer_session`.

### Paso 7: maneja el resultado de la inscripción

El SDK llama a tu método delegate `yunoEnrollmentResult(_:)` con el estado final:

```swift theme={"theme":{"light":"github-dark","dark":"github-dark-dimmed"}}
func yunoEnrollmentResult(_ result: Yuno.Result) {
    switch result.status {
    case .succeeded:
        print("Enrollment successful")
        // Navigate to success screen or update UI
    case .fail:
        print("Enrollment failed")
        // Show error message
    case .processing:
        print("Enrollment still processing")
        // Show processing message
    case .reject:
        print("Enrollment rejected")
        // Show rejection message
    case .userCancelled:
        print("User canceled")
        // Handle cancellation
    case .internalError:
        print("Internal error occurred")
        // Show error message
    @unknown default:
        break
    }
}
```

#### Estados del resultado de la inscripción

| Estado | Descripción | Acción requerida |
| - | - | - |
| `succeeded` | La inscripción se completó correctamente | No |
| `fail` | La inscripción falló por problemas de validación o técnicos | Sí - Investiga y reintenta |
| `processing` | Inscripción en curso, en espera de aprobación | No |
| `reject` | Inscripción rechazada (datos no válidos, detección de fraude, etc.) | Sí - Informa al usuario y sugiere acciones |
| `internalError` | Ocurrió un error interno inesperado | Sí - Se requiere intervención técnica |
| `userCancelled` | El usuario canceló la inscripción | No |

`Yuno.Result` no incluye tokens. Además del `status` de alto nivel, expone `substatus` y `message` (SDK 2.27.0 y posteriores).

### Funciones complementarias

Para estilos, temas, opciones de formulario y configuraciones adicionales, consulta [Personalizaciones del SDK](https://docs.y.uno/es/docs/sdks/customization/ios.md).

## Referencia común

Para ver los detalles completos de parámetros y personalización, consulta la [Referencia común del SDK de iOS](https://docs.y.uno/es/docs/sdks/resources/references/ios.md).


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