Billetera

import os
from compense_gateway import CompenseClient

client = CompenseClient(api_key=os.environ["COMPENSE_API_KEY"], environment="sandbox")
DOC = "1000000001"   # titular de prueba: perfil elegible, saldo 500.000

saldo = client.wallet.balance(DOC)
print(saldo.available.amount, saldo.total.amount, saldo.currency)
if saldo.pending is not None:
    print("En tránsito:", saldo.pending.amount)

import { CompenseClient } from "@compense/sdk";

const client = new CompenseClient({ apiKey: process.env.COMPENSE_API_KEY!, environment: "sandbox" });
const DOC = "1000000001"; // titular de prueba: perfil elegible, saldo 500.000

const saldo = await client.wallet.balance(DOC);
console.log(saldo.available.amount, saldo.total.amount, saldo.currency);
if (saldo.pending) console.log("En tránsito:", saldo.pending.amount);

<?php
require __DIR__ . '/vendor/autoload.php';

use Compense\Sdk\CompenseClient;

$client = new CompenseClient(apiKey: getenv('COMPENSE_API_KEY'), environment: 'sandbox');
$doc = '1000000001'; // titular de prueba: perfil elegible, saldo 500.000

$saldo = $client->wallet->balance($doc);
echo $saldo->available->amount, ' ', $saldo->total->amount, ' ', $saldo->currency, PHP_EOL;
if ($saldo->pending !== null) {
    echo 'En tránsito: ', $saldo->pending->amount, PHP_EOL;
}

using Compense.Sdk;
using Compense.Sdk.Models;

using var client = new CompenseClient(
    Environment.GetEnvironmentVariable("COMPENSE_API_KEY")!, CompenseEnvironment.Sandbox);
const string Doc = "1000000001"; // titular de prueba: perfil elegible, saldo 500.000

Balance saldo = await client.Wallet.BalanceAsync(Doc);
Console.WriteLine($"{saldo.Available.Amount} {saldo.Total.Amount} {saldo.Currency}");
if (saldo.Pending is not null) Console.WriteLine($"En tránsito: {saldo.Pending.Amount}");

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	compense "github.com/Appiasoft/compense-saas-sdk-go"
)

func main() {
	ctx := context.Background()
	client, err := compense.NewClient(os.Getenv("COMPENSE_API_KEY"),
		compense.WithEnvironment(compense.Sandbox))
	if err != nil {
		log.Fatal(err)
	}
	const doc = "1000000001" // titular de prueba: perfil elegible, saldo 500.000

	saldo, err := client.Wallet.Balance(ctx, doc)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(saldo.Available.Amount, saldo.Total.Amount, saldo.Currency)
	if saldo.Pending != nil {
		fmt.Println("En tránsito:", saldo.Pending.Amount)
	}
}

curl "https://sandbox.dev.compense.co/gw/v1/gateway/wallet/balance/?document=1000000001" \
  -H "X-API-Key: $COMPENSE_API_KEY"

pagina = client.wallet.transactions.list(DOC, start_date="2026-10-01",
                                         end_date="2026-10-31", limit=20)
while True:
    for mov in pagina:
        print(mov["date"], mov["transaction_type"], mov["amount"], mov["status"])
    if not pagina.has_more:
        break
    pagina = client.wallet.transactions.list(DOC, start_date="2026-10-01",
                                             end_date="2026-10-31", limit=20,
                                             offset=pagina.next_offset)

detalle = client.wallet.transactions.get(mov["id"], document=DOC)

const pagina = await client.wallet.transactions.list(DOC, {
  startDate: "2026-10-01",
  endDate: "2026-10-31",
  limit: 20,
});
// `for await` recorre todas las páginas siguiendo next_offset
for await (const mov of pagina) {
  console.log(mov.date, mov.transaction_type, mov.amount, mov.status);
}

const detalle = await client.wallet.transactions.get(String(pagina.results[0].id), { document: DOC });

$offset = 0;
do {
    $pagina = $client->wallet->transactions->list(
        $doc, startDate: '2026-10-01', endDate: '2026-10-31', limit: 20, offset: $offset,
    );
    foreach ($pagina as $mov) {
        echo $mov['date'], ' ', $mov['transaction_type'], ' ', $mov['amount'], ' ', $mov['status'], PHP_EOL;
    }
    $offset = $pagina->nextOffset;
} while ($pagina->hasMore && $offset !== null);

$detalle = $client->wallet->transactions->get($pagina->results[0]['id'], $doc);

using System.Text.Json.Nodes;

// Recorre todas las páginas siguiendo next_offset
await foreach (JsonObject mov in client.Wallet.Transactions.ListAutoPagingAsync(
    Doc, startDate: "2026-10-01", endDate: "2026-10-31", limit: 20))
{
    Console.WriteLine($"{mov["date"]} {mov["transaction_type"]} {mov["amount"]} {mov["status"]}");
}

// O una sola página:
OffsetPage pagina = await client.Wallet.Transactions.ListAsync(Doc, startDate: "2026-10-01", limit: 20);
JsonObject detalle = await client.Wallet.Transactions.GetAsync(
    pagina.Results[0]["id"]!.GetValue<string>(), Doc);

it := compense.NewOffsetIterator(ctx, func(ctx context.Context, offset int) (*compense.OffsetPage, error) {
	return client.Wallet.Transactions.List(ctx, doc, &compense.WalletTransactionsParams{
		StartDate: "2026-10-01", EndDate: "2026-10-31", Limit: 20, Offset: offset,
	})
})
for it.Next() {
	mov := it.Item()
	fmt.Println(mov["date"], mov["transaction_type"], mov["amount"], mov["status"])
}
if err := it.Err(); err != nil {
	log.Fatal(err)
}

detalle, err := client.Wallet.Transactions.Get(ctx, "wtx-E-3f1c9a0b2d4e", doc)
if err != nil {
	log.Fatal(err)
}
fmt.Println(detalle["status"])

curl "https://sandbox.dev.compense.co/gw/v1/gateway/wallet/transactions/?document=1000000001&start_date=2026-10-01&end_date=2026-10-31&limit=20&offset=0" \
  -H "X-API-Key: $COMPENSE_API_KEY"

curl "https://sandbox.dev.compense.co/gw/v1/gateway/wallet/transactions/$MOV_ID/?document=1000000001" \
  -H "X-API-Key: $COMPENSE_API_KEY"

r = client.wallet.p2p.resolve(document=DOC, alias="3001234567", key_type="PHONE")
if not r.found:
    raise SystemExit("Nadie tiene ese alias en la entidad")
if r.is_local is False:
    raise SystemExit("La llave es de otra entidad: usa Bre-B")

# Muestra r.display_name al usuario y pide confirmación antes de r.expires_in segundos
tx = client.wallet.p2p.transfer(
    document=DOC,
    resolution_token=r.resolution_token,
    amount="30000",
    description="Arriendo",
    idempotency_key="nova-p2p-2026-11-02-000123",
)
print(tx.transaction_id, tx.data["transaction_id"], tx.data["status"], tx.idempotent_replay)

const r = await client.wallet.p2p.resolve({ document: DOC, alias: "3001234567", keyType: "PHONE" });
if (!r.found) throw new Error("Nadie tiene ese alias en la entidad");
if (r.isLocal === false) throw new Error("La llave es de otra entidad: usa Bre-B");

// Muestra r.displayName al usuario y pide confirmación antes de r.expiresIn segundos
const tx = await client.wallet.p2p.transfer({
  document: DOC,
  resolutionToken: r.resolutionToken,
  amount: "30000",
  description: "Arriendo",
  idempotencyKey: "nova-p2p-2026-11-02-000123",
});
console.log(tx.transactionId, tx.data.transaction_id, tx.data.status, tx.idempotentReplay);

$r = $client->wallet->p2p->resolve(document: $doc, alias: '3001234567', keyType: 'PHONE');
if (!$r->found) {
    exit("Nadie tiene ese alias en la entidad\n");
}
if ($r->isLocal === false) {
    exit("La llave es de otra entidad: usa Bre-B\n");
}

// Muestra $r->displayName al usuario y pide confirmación antes de $r->expiresIn segundos
$tx = $client->wallet->p2p->transfer(
    document: $doc,
    resolutionToken: $r->resolutionToken,
    amount: '30000',
    description: 'Arriendo',
    idempotencyKey: 'nova-p2p-2026-11-02-000123',
);
echo $tx->transactionId, ' ', $tx->data['transaction_id'], ' ', $tx->data['status'], PHP_EOL;

Resolution r = await client.Wallet.P2P.ResolveAsync(Doc, "3001234567", keyType: "PHONE");
if (!r.Found) throw new InvalidOperationException("Nadie tiene ese alias en la entidad");
if (r.IsLocal == false) throw new InvalidOperationException("La llave es de otra entidad: usa Bre-B");

// Muestra r.DisplayName al usuario y pide confirmación antes de r.ExpiresIn segundos
Transaction tx = await client.Wallet.P2P.TransferAsync(
    Doc, r.ResolutionToken, "30000", description: "Arriendo",
    idempotencyKey: "nova-p2p-2026-11-02-000123");
Console.WriteLine($"{tx.TransactionId} {tx.Data["transaction_id"]} {tx.Data["status"]} {tx.IdempotentReplay}");

r, err := client.Wallet.P2P.Resolve(ctx, &compense.P2PResolveParams{
	Document: doc, Alias: "3001234567", KeyType: "PHONE",
})
if err != nil {
	log.Fatal(err)
}
if !r.Found {
	log.Fatal("nadie tiene ese alias en la entidad")
}
if r.IsLocal != nil && !*r.IsLocal {
	log.Fatal("la llave es de otra entidad: usa Bre-B")
}

// Muestra r.DisplayName al usuario y pide confirmación antes de r.ExpiresIn segundos
tx, err := client.Wallet.P2P.Transfer(ctx, &compense.WalletTransferParams{
	Document:        doc,
	ResolutionToken: r.ResolutionToken,
	Amount:          "30000",
	Description:     "Arriendo",
}, compense.WithIdempotencyKey("nova-p2p-2026-11-02-000123"))
if err != nil {
	log.Fatal(err)
}
fmt.Println(tx.TransactionID, tx.Data["transaction_id"], tx.Data["status"], tx.IdempotentReplay)

curl -X POST https://sandbox.dev.compense.co/gw/v1/gateway/wallet/p2p/resolve/ \
  -H "X-API-Key: $COMPENSE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"document": "1000000001", "alias": "3001234567", "key_type": "PHONE"}'

curl -X POST https://sandbox.dev.compense.co/gw/v1/gateway/wallet/p2p/transfers/ \
  -H "X-API-Key: $COMPENSE_API_KEY" \
  -H "Idempotency-Key: nova-p2p-2026-11-02-000123" \
  -H "Content-Type: application/json" \
  -d '{"document": "1000000001", "resolution_token": "'"$TOKEN"'", "amount": "30000", "description": "Arriendo"}'

limites = client.wallet.breb.limits(DOC)
print(limites["max_per_transaction"], limites["available_today"])

r = client.wallet.breb.resolve(document=DOC, key_type="PHONE", value="3109876543")
if r.found:
    # Muestra al usuario r.display_name, r.institution_name y r.key_display
    tx = client.wallet.breb.transfer(
        document=DOC, resolution_token=r.resolution_token, amount="25000",
        description="Pago", idempotency_key="nova-breb-2026-11-02-000045",
    )
    if tx.data["status"] == "PENDING":
        print("El banco destino aún no confirma: espera wallets.transfer.settled")

const limites = await client.wallet.breb.limits(DOC);
console.log(limites.max_per_transaction, limites.available_today);

const r = await client.wallet.breb.resolve({ document: DOC, keyType: "PHONE", value: "3109876543" });
if (r.found) {
  // Muestra al usuario r.displayName, r.institutionName y r.keyDisplay
  const tx = await client.wallet.breb.transfer({
    document: DOC,
    resolutionToken: r.resolutionToken,
    amount: "25000",
    description: "Pago",
    idempotencyKey: "nova-breb-2026-11-02-000045",
  });
  if (tx.data.status === "PENDING") console.log("El banco destino aún no confirma");
}

$limites = $client->wallet->breb->limits($doc);
echo $limites['max_per_transaction'], ' ', $limites['available_today'], PHP_EOL;

$r = $client->wallet->breb->resolve(document: $doc, keyType: 'PHONE', value: '3109876543');
if ($r->found) {
    // Muestra al usuario $r->displayName, $r->institutionName y $r->keyDisplay
    $tx = $client->wallet->breb->transfer(
        document: $doc,
        resolutionToken: $r->resolutionToken,
        amount: '25000',
        description: 'Pago',
        idempotencyKey: 'nova-breb-2026-11-02-000045',
    );
    if ($tx->data['status'] === 'PENDING') {
        echo "El banco destino aún no confirma\n";
    }
}

JsonObject limites = await client.Wallet.BreB.LimitsAsync(Doc);
Console.WriteLine($"{limites["max_per_transaction"]} {limites["available_today"]}");

Resolution r = await client.Wallet.BreB.ResolveAsync(Doc, "PHONE", "3109876543");
if (r.Found)
{
    // Muestra al usuario r.DisplayName, r.InstitutionName y r.KeyDisplay
    Transaction tx = await client.Wallet.BreB.TransferAsync(
        Doc, r.ResolutionToken, "25000", description: "Pago",
        idempotencyKey: "nova-breb-2026-11-02-000045");
    if (tx.Data["status"]?.GetValue<string>() == "PENDING")
        Console.WriteLine("El banco destino aún no confirma");
}

limites, err := client.Wallet.BreB.Limits(ctx, doc)
if err != nil {
	log.Fatal(err)
}
fmt.Println(limites["max_per_transaction"], limites["available_today"])

r, err := client.Wallet.BreB.Resolve(ctx, &compense.BreBResolveParams{
	Document: doc, KeyType: "PHONE", Value: "3109876543",
})
if err != nil {
	log.Fatal(err)
}
if r.Found {
	// Muestra al usuario r.DisplayName, r.InstitutionName y r.KeyDisplay
	tx, err := client.Wallet.BreB.Transfer(ctx, &compense.WalletTransferParams{
		Document: doc, ResolutionToken: r.ResolutionToken, Amount: "25000", Description: "Pago",
	}, compense.WithIdempotencyKey("nova-breb-2026-11-02-000045"))
	if err != nil {
		log.Fatal(err)
	}
	if tx.Data["status"] == "PENDING" {
		fmt.Println("El banco destino aún no confirma")
	}
}

curl "https://sandbox.dev.compense.co/gw/v1/gateway/wallet/breb/limits/?document=1000000001" \
  -H "X-API-Key: $COMPENSE_API_KEY"

curl -X POST https://sandbox.dev.compense.co/gw/v1/gateway/wallet/breb/resolve/ \
  -H "X-API-Key: $COMPENSE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"document": "1000000001", "key_type": "PHONE", "value": "3109876543"}'

curl -X POST https://sandbox.dev.compense.co/gw/v1/gateway/wallet/breb/transfers/ \
  -H "X-API-Key: $COMPENSE_API_KEY" \
  -H "Idempotency-Key: nova-breb-2026-11-02-000045" \
  -H "Content-Type: application/json" \
  -d '{"document": "1000000001", "resolution_token": "'"$TOKEN"'", "amount": "25000", "description": "Pago"}'

convenios = client.wallet.bills.billers(category="POWER", q="epm")   # no necesita document

factura = client.wallet.bills.inquire(document=DOC, biller_code="EPM", reference="123456789")
print(factura["holder_name"], factura["amount"], factura["due_date"], factura["status"])

tx = client.wallet.bills.pay(
    document=DOC, biller_code="EPM", reference="123456789",
    amount=factura["amount"],                       # el valor de la consulta
    idempotency_key="nova-bill-EPM-123456789-2026-10",
)
print(tx.data["status"], tx.data.get("approval_number"))

historial = client.wallet.bills.list_payments(DOC, kind="BILL", limit=20)
pago = client.wallet.bills.get_payment(historial.results[0]["id"], document=DOC)

const convenios = await client.wallet.bills.billers({ category: "POWER", q: "epm" });

const factura = await client.wallet.bills.inquire({ document: DOC, billerCode: "EPM", reference: "123456789" });
console.log(factura.holder_name, factura.amount, factura.due_date, factura.status);

const tx = await client.wallet.bills.pay({
  document: DOC,
  billerCode: "EPM",
  reference: "123456789",
  amount: String(factura.amount), // el valor de la consulta
  idempotencyKey: "nova-bill-EPM-123456789-2026-10",
});
console.log(tx.data.status, tx.data.approval_number);

const historial = await client.wallet.bills.listPayments(DOC, { kind: "BILL", limit: 20 });
const pago = await client.wallet.bills.getPayment(String(historial.results[0].id), { document: DOC });

$convenios = $client->wallet->bills->billers(category: 'POWER', q: 'epm');

$factura = $client->wallet->bills->inquire(document: $doc, billerCode: 'EPM', reference: '123456789');
echo $factura['holder_name'], ' ', $factura['amount'], ' ', $factura['due_date'], PHP_EOL;

$tx = $client->wallet->bills->pay(
    document: $doc,
    billerCode: 'EPM',
    reference: '123456789',
    amount: $factura['amount'], // el valor de la consulta
    idempotencyKey: 'nova-bill-EPM-123456789-2026-10',
);
echo $tx->data['status'], ' ', $tx->data['approval_number'] ?? '-', PHP_EOL;

$historial = $client->wallet->bills->listPayments($doc, kind: 'BILL', limit: 20);
$pago = $client->wallet->bills->getPayment($historial->results[0]['id'], $doc);

IReadOnlyList<JsonObject> convenios = await client.Wallet.Bills.BillersAsync("POWER", "epm");

JsonObject factura = await client.Wallet.Bills.InquireAsync(Doc, billerCode: "EPM", reference: "123456789");
string valor = factura["amount"]!.GetValue<string>();
Console.WriteLine($"{factura["holder_name"]} {valor} {factura["due_date"]}");

Transaction tx = await client.Wallet.Bills.PayAsync(
    Doc, "EPM", "123456789", valor, // el valor de la consulta
    idempotencyKey: "nova-bill-EPM-123456789-2026-10");
Console.WriteLine($"{tx.Data["status"]} {tx.Data["approval_number"]}");

OffsetPage historial = await client.Wallet.Bills.ListPaymentsAsync(Doc, kind: "BILL", limit: 20);
JsonObject pago = await client.Wallet.Bills.GetPaymentAsync(historial.Results[0]["id"]!.GetValue<string>(), Doc);

convenios, err := client.Wallet.Bills.Billers(ctx, &compense.BillersParams{Category: "POWER", Q: "epm"})
if err != nil {
	log.Fatal(err)
}
fmt.Println(len(convenios), "convenios")

factura, err := client.Wallet.Bills.Inquire(ctx, &compense.BillInquiryParams{
	Document: doc, BillerCode: "EPM", Reference: "123456789",
})
if err != nil {
	log.Fatal(err)
}
valor, _ := factura["amount"].(string)

tx, err := client.Wallet.Bills.Pay(ctx, &compense.BillPayParams{
	Document: doc, BillerCode: "EPM", Reference: "123456789",
	Amount: compense.Amount(valor), // el valor de la consulta
}, compense.WithIdempotencyKey("nova-bill-EPM-123456789-2026-10"))
if err != nil {
	log.Fatal(err)
}
fmt.Println(tx.Data["status"], tx.Data["approval_number"])

historial, err := client.Wallet.Bills.ListPayments(ctx, doc, &compense.BillPaymentsParams{Kind: "BILL", Limit: 20})
if err != nil {
	log.Fatal(err)
}
pagoID, _ := historial.Results[0]["id"].(string)
pago, err := client.Wallet.Bills.GetPayment(ctx, pagoID, doc)
if err != nil {
	log.Fatal(err)
}
fmt.Println(pago["status"], pago["approval_number"])

curl "https://sandbox.dev.compense.co/gw/v1/gateway/wallet/billers/?category=POWER&q=epm" \
  -H "X-API-Key: $COMPENSE_API_KEY"

curl -X POST https://sandbox.dev.compense.co/gw/v1/gateway/wallet/bills/inquiry/ \
  -H "X-API-Key: $COMPENSE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"document": "1000000001", "biller_code": "EPM", "reference": "123456789"}'

curl -X POST https://sandbox.dev.compense.co/gw/v1/gateway/wallet/bills/pay/ \
  -H "X-API-Key: $COMPENSE_API_KEY" \
  -H "Idempotency-Key: nova-bill-EPM-123456789-2026-10" \
  -H "Content-Type: application/json" \
  -d '{"document": "1000000001", "biller_code": "EPM", "reference": "123456789", "amount": "90000.00"}'

curl "https://sandbox.dev.compense.co/gw/v1/gateway/wallet/bills/payments/?document=1000000001&kind=BILL&limit=20" \
  -H "X-API-Key: $COMPENSE_API_KEY"

catalogo = client.wallet.topups.operators()
claro = next(o for o in catalogo["operators"] if o["code"] == "CLARO")
print(claro["min_amount"], claro["max_amount"], claro["suggested_amounts"])

tx = client.wallet.topups.create(
    document=DOC, phone_number="3001234567", carrier="CLARO", amount="20000",
    idempotency_key="nova-topup-2026-11-02-000123",
)
print(tx.data["status"], tx.data["phone_number_masked"])

const catalogo = await client.wallet.topups.operators();
console.log(catalogo.source, catalogo.operators);

const tx = await client.wallet.topups.create({
  document: DOC,
  phoneNumber: "3001234567",
  carrier: "CLARO",
  amount: "20000",
  idempotencyKey: "nova-topup-2026-11-02-000123",
});
console.log(tx.data.status, tx.data.phone_number_masked);

$catalogo = $client->wallet->topups->operators();
echo $catalogo['source'], ' ', count($catalogo['operators']), PHP_EOL;

$tx = $client->wallet->topups->create(
    document: $doc,
    phoneNumber: '3001234567',
    carrier: 'CLARO',
    amount: '20000',
    idempotencyKey: 'nova-topup-2026-11-02-000123',
);
echo $tx->data['status'], ' ', $tx->data['phone_number_masked'], PHP_EOL;

JsonObject catalogo = await client.Wallet.Topups.OperatorsAsync();
Console.WriteLine($"{catalogo["source"]} {catalogo["operators"]!.AsArray().Count}");

Transaction tx = await client.Wallet.Topups.CreateAsync(
    Doc, "3001234567", "CLARO", "20000", idempotencyKey: "nova-topup-2026-11-02-000123");
Console.WriteLine($"{tx.Data["status"]} {tx.Data["phone_number_masked"]}");

catalogo, err := client.Wallet.Topups.Operators(ctx)
if err != nil {
	log.Fatal(err)
}
fmt.Println(catalogo["source"], catalogo["operators"])

tx, err := client.Wallet.Topups.Create(ctx, &compense.TopupParams{
	Document: doc, PhoneNumber: "3001234567", Carrier: "CLARO", Amount: "20000",
}, compense.WithIdempotencyKey("nova-topup-2026-11-02-000123"))
if err != nil {
	log.Fatal(err)
}
fmt.Println(tx.Data["status"], tx.Data["phone_number_masked"])

curl https://sandbox.dev.compense.co/gw/v1/gateway/wallet/topups/operators/ \
  -H "X-API-Key: $COMPENSE_API_KEY"

curl -X POST https://sandbox.dev.compense.co/gw/v1/gateway/wallet/topups/ \
  -H "X-API-Key: $COMPENSE_API_KEY" \
  -H "Idempotency-Key: nova-topup-2026-11-02-000123" \
  -H "Content-Type: application/json" \
  -d '{"document": "1000000001", "phone_number": "3001234567", "carrier": "CLARO", "amount": "20000"}'

cuentas = client.wallet.accounts.list(DOC)          # == client.accounts.list(DOC)
principal = next(c for c in cuentas if c.is_primary or c.kind.lower() == "wallet")

ahorro = client.wallet.accounts.create_pocket(
    document=DOC, name="Vacaciones", kind="savings",
    target_amount="500000", target_date="2026-12-31",
    idempotency_key="nova-pocket-1000000001-vacaciones",
)

envelope = client.wallet.accounts.transfer(
    document=DOC, from_account=principal.id, to_account=ahorro.id, amount="20000",
    idempotency_key="nova-acc-tx-2026-11-02-0001",
)
print(envelope["transaction_id"], envelope["data"])

const cuentas = await client.wallet.accounts.list(DOC); // === client.accounts
const principal = cuentas.find((c) => c.isPrimary || c.kind.toLowerCase() === "wallet")!;

const ahorro = await client.wallet.accounts.createPocket({
  document: DOC,
  name: "Vacaciones",
  kind: "savings",
  targetAmount: "500000",
  targetDate: "2026-12-31",
  idempotencyKey: "nova-pocket-1000000001-vacaciones",
});

const envelope = await client.wallet.accounts.transfer({
  document: DOC,
  fromAccount: principal.id,
  toAccount: ahorro.id,
  amount: "20000",
  idempotencyKey: "nova-acc-tx-2026-11-02-0001",
});
console.log(envelope.transaction_id, envelope.data);

$cuentas = $client->wallet->accounts->list($doc); // === $client->accounts
$principal = $cuentas[0];

$ahorro = $client->wallet->accounts->createPocket(
    document: $doc,
    name: 'Vacaciones',
    kind: 'savings',
    targetAmount: '500000',
    targetDate: '2026-12-31',
    idempotencyKey: 'nova-pocket-1000000001-vacaciones',
);

$envelope = $client->wallet->accounts->transfer(
    document: $doc,
    fromAccount: $principal->id,
    toAccount: $ahorro->id,
    amount: '20000',
    idempotencyKey: 'nova-acc-tx-2026-11-02-0001',
);
echo $envelope['transaction_id'], PHP_EOL;

IReadOnlyList<Account> cuentas = await client.Wallet.Accounts.ListAsync(Doc); // == client.Accounts
Account principal = cuentas.First(c => c.IsPrimary || c.Kind.Equals("wallet", StringComparison.OrdinalIgnoreCase));

Account ahorro = await client.Wallet.Accounts.CreatePocketAsync(
    Doc, name: "Vacaciones", kind: "savings", targetAmount: "500000", targetDate: "2026-12-31",
    idempotencyKey: "nova-pocket-1000000001-vacaciones");

JsonObject envelope = await client.Wallet.Accounts.TransferAsync(
    Doc, principal.Id, ahorro.Id, "20000", idempotencyKey: "nova-acc-tx-2026-11-02-0001");
Console.WriteLine(envelope["transaction_id"]);

cuentas, err := client.Wallet.Accounts.List(ctx, doc) // == client.Accounts
if err != nil {
	log.Fatal(err)
}
principal := cuentas[0]

ahorro, err := client.Wallet.Accounts.CreatePocket(ctx, &compense.CreatePocketParams{
	Document: doc, Name: "Vacaciones", Kind: "savings",
	TargetAmount: "500000", TargetDate: "2026-12-31",
}, compense.WithIdempotencyKey("nova-pocket-1000000001-vacaciones"))
if err != nil {
	log.Fatal(err)
}

envelope, err := client.Wallet.Accounts.Transfer(ctx, &compense.AccountTransferParams{
	Document: doc, FromAccount: principal.ID, ToAccount: ahorro.ID, Amount: "20000",
}, compense.WithIdempotencyKey("nova-acc-tx-2026-11-02-0001"))
if err != nil {
	log.Fatal(err)
}
fmt.Println(envelope["transaction_id"])

curl "https://sandbox.dev.compense.co/gw/v1/gateway/wallet/accounts/?document=1000000001" \
  -H "X-API-Key: $COMPENSE_API_KEY"

curl -X POST https://sandbox.dev.compense.co/gw/v1/gateway/wallet/accounts/ \
  -H "X-API-Key: $COMPENSE_API_KEY" \
  -H "Idempotency-Key: nova-pocket-1000000001-vacaciones" \
  -H "Content-Type: application/json" \
  -d '{"document": "1000000001", "kind": "savings", "name": "Vacaciones"}'

curl -X POST https://sandbox.dev.compense.co/gw/v1/gateway/wallet/accounts/transfer/ \
  -H "X-API-Key: $COMPENSE_API_KEY" \
  -H "Idempotency-Key: nova-acc-tx-2026-11-02-0001" \
  -H "Content-Type: application/json" \
  -d '{"document": "1000000001", "from_account": "'"$CUENTA_PRINCIPAL"'", "to_account": "'"$BOLSILLO"'", "amount": "20000"}'

tarjeta = client.wallet.cards.issue(document=DOC, form_factor="virtual",
                                    idempotency_key="nova-card-1000000001-v1")
print(tarjeta.id, tarjeta.last_four, tarjeta.status)

client.wallet.cards.set_status(tarjeta.id, document=DOC, status="freeze")
client.wallet.cards.set_status(tarjeta.id, document=DOC, status="unfreeze")

tarjetas = client.wallet.cards.list(DOC)
movs = client.wallet.cards.transactions(tarjeta.id, document=DOC)

const tarjeta = await client.wallet.cards.issue({
  document: DOC,
  formFactor: "virtual",
  idempotencyKey: "nova-card-1000000001-v1",
});
console.log(tarjeta.id, tarjeta.lastFour, tarjeta.status);

await client.wallet.cards.setStatus(tarjeta.id, { document: DOC, status: "freeze" });
await client.wallet.cards.setStatus(tarjeta.id, { document: DOC, status: "unfreeze" });

const tarjetas = await client.wallet.cards.list(DOC);
const movs = await client.wallet.cards.transactions(tarjeta.id, { document: DOC });

$tarjeta = $client->wallet->cards->issue(
    document: $doc, formFactor: 'virtual', idempotencyKey: 'nova-card-1000000001-v1',
);
echo $tarjeta->id, ' ', $tarjeta->lastFour, ' ', $tarjeta->status, PHP_EOL;

$client->wallet->cards->setStatus($tarjeta->id, document: $doc, status: 'freeze');
$client->wallet->cards->setStatus($tarjeta->id, document: $doc, status: 'unfreeze');

$tarjetas = $client->wallet->cards->list($doc);
$movs = $client->wallet->cards->transactions($tarjeta->id, $doc);

Card tarjeta = await client.Wallet.Cards.IssueAsync(Doc, "virtual", idempotencyKey: "nova-card-1000000001-v1");
Console.WriteLine($"{tarjeta.Id} {tarjeta.LastFour} {tarjeta.Status}");

await client.Wallet.Cards.SetStatusAsync(tarjeta.Id, Doc, "freeze");
await client.Wallet.Cards.SetStatusAsync(tarjeta.Id, Doc, "unfreeze");

IReadOnlyList<Card> tarjetas = await client.Wallet.Cards.ListAsync(Doc);
JsonObject movs = await client.Wallet.Cards.TransactionsAsync(tarjeta.Id, Doc);

tarjeta, err := client.Wallet.Cards.Issue(ctx, &compense.IssueCardParams{
	Document: doc, FormFactor: "virtual",
}, compense.WithIdempotencyKey("nova-card-1000000001-v1"))
if err != nil {
	log.Fatal(err)
}
fmt.Println(tarjeta.ID, tarjeta.LastFour, tarjeta.Status)

if _, err := client.Wallet.Cards.SetStatus(ctx, tarjeta.ID, &compense.CardStatusParams{
	Document: doc, Status: "freeze",
}); err != nil {
	log.Fatal(err)
}

movs, err := client.Wallet.Cards.Transactions(ctx, tarjeta.ID, doc)
if err != nil {
	log.Fatal(err)
}
fmt.Println(movs["results"])

curl -X POST https://sandbox.dev.compense.co/gw/v1/gateway/wallet/cards/ \
  -H "X-API-Key: $COMPENSE_API_KEY" \
  -H "Idempotency-Key: nova-card-1000000001-v1" \
  -H "Content-Type: application/json" \
  -d '{"document": "1000000001", "form_factor": "virtual"}'

curl -X POST https://sandbox.dev.compense.co/gw/v1/gateway/wallet/cards/$CARD_ID/status/ \
  -H "X-API-Key: $COMPENSE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"document": "1000000001", "status": "freeze"}'

curl "https://sandbox.dev.compense.co/gw/v1/gateway/wallet/cards/$CARD_ID/transactions/?document=1000000001" \
  -H "X-API-Key: $COMPENSE_API_KEY"

cotizacion = client.wallet.fx.quote(document=DOC, sell_currency="COP",
                                    buy_currency="USD", amount="1000000")
print(cotizacion["rate"], cotizacion["converted_amount"])

envelope = client.wallet.fx.convert(
    document=DOC, sell_currency="COP", buy_currency="USD", amount="1000000",
    quote_id=cotizacion.get("quote_id"),
    idempotency_key="nova-fx-2026-11-02-0007",
)