Resources

accounts, err := client.Connect.Accounts.List(ctx, &connect.ListAccountsRequest{
    PageSize:   10,
    PageNumber: 1,
})
if err != nil {
    log.Fatal(err)
}

account, err := client.Connect.Accounts.Get(ctx, accounts.Data[0].AccountID)

cardholder, err := client.Issuing.Cardholders.Create(ctx, &issuing.CreateCardholderRequest{
    Email:       "user@example.com",
    PhoneNumber: "1234567890",
    FirstName:   "John",
    LastName:    "Doe",
    CountryCode: "US",
})
if err != nil {
    log.Fatal(err)
}
fmt.Printf("Cardholder ID: %s\n", cardholder.CardholderID)

products, err := client.Issuing.Products.List(ctx, &issuing.ListProductsRequest{
    PageSize:   10,
    PageNumber: 1,
})
if err != nil {
    log.Fatal(err)
}

for _, product := range products.Data {
    fmt.Printf("Product: %s (%s)\n", product.ProductID, product.CardScheme)
}

card, err := client.Issuing.Cards.Create(ctx, &issuing.CreateCardRequest{
    CardCurrency:  "USD",
    CardholderID:  cardholder.CardholderID,
    CardProductID: "product-id",
})
if err != nil {
    log.Fatal(err)
}
fmt.Printf("Card ID: %s (Status: %s)\n", card.CardID, card.CardStatus)

secureInfo, err := client.Issuing.Cards.GetSecure(ctx, card.CardID)
if err != nil {
    log.Fatal(err)
}
fmt.Printf("Card Number: %s\n", secureInfo.CardNumber)
fmt.Printf("CVV: %s\n", secureInfo.CVV)
fmt.Printf("Expiry: %s\n", secureInfo.ExpiryDate)

order, err := client.Issuing.Cards.Recharge(ctx, card.CardID, &issuing.CardOrderRequest{
    Amount: 100.50,
})
if err != nil {
    log.Fatal(err)
}
fmt.Printf("Recharge Order ID: %s\n", order.OrderID)

order, err := client.Issuing.Cards.Withdraw(ctx, card.CardID, &issuing.CardOrderRequest{
    Amount: 50.00,
})
if err != nil {
    log.Fatal(err)
}
fmt.Printf("Withdraw Order ID: %s (Status: %s)\n", order.OrderID, order.Status)

// Freeze a card
err = client.Issuing.Cards.UpdateStatus(ctx, card.CardID, &issuing.UpdateCardStatusRequest{
    CardStatus: "FROZEN",
})
if err != nil {
    log.Fatal(err)
}

// Unfreeze a card
err = client.Issuing.Cards.UpdateStatus(ctx, card.CardID, &issuing.UpdateCardStatusRequest{
    CardStatus: "ACTIVE",
})

transactions, err := client.Issuing.Transactions.List(ctx, &issuing.ListTransactionsRequest{
    PageSize:   10,
    PageNumber: 1,
    CardID:     card.CardID,
})
if err != nil {
    log.Fatal(err)
}

for _, txn := range transactions.Data {
    fmt.Printf("Transaction: %s - %s %s\n",
        txn.TransactionID,
        txn.TransactionAmount,
        txn.TransactionCurrency,
    )
}

balances, err := client.Banking.Balances.List(ctx, &banking.ListBalancesRequest{
    PageSize:   20,
    PageNumber: 1,
})

balance, err := client.Banking.Balances.Get(ctx, "SGD")

txns, err := client.Banking.Balances.ListTransactions(ctx, &banking.ListBalanceTransactionsRequest{
    PageSize: 20,
})

transfer, err := client.Banking.Transfers.Create(ctx, &banking.CreateTransferRequest{
    SourceAccountID:      "acc-123",
    DestinationAccountID: "acc-456",
    Currency:             "SGD",
    Amount:               "100.00",
})

transfers, err := client.Banking.Transfers.List(ctx, &banking.ListTransfersRequest{
    PageSize: 20,
})

transfer, err := client.Banking.Transfers.Get(ctx, "transfer-id")

deposits, err := client.Banking.Deposits.List(ctx, &banking.ListDepositsRequest{
    PageSize: 20,
})

deposit, err := client.Banking.Deposits.Get(ctx, "deposit-id")

beneficiary, err := client.Banking.Beneficiaries.Create(ctx, &banking.CreateBeneficiaryRequest{
    // ... set fields
})

list, err := client.Banking.Beneficiaries.List(ctx, &banking.ListBeneficiariesRequest{
    PageSize: 20,
})

beneficiary, err := client.Banking.Beneficiaries.Get(ctx, "ben-id")
beneficiary, err = client.Banking.Beneficiaries.Update(ctx, "ben-id", updateRequest)
err = client.Banking.Beneficiaries.Delete(ctx, "ben-id")
err = client.Banking.Beneficiaries.Check(ctx, checkRequest)

payout, err := client.Banking.Payouts.Create(ctx, &banking.CreatePayoutRequest{
    BeneficiaryID: "ben-123",
    Currency:      "SGD",
    Amount:        "50.00",
    PurposeCode:   "PERSONAL",
})

quote, err := client.Banking.Conversions.CreateQuote(ctx, &banking.CreateQuoteRequest{
    SellCurrency: "SGD",
    BuyCurrency:  "USD",
    Amount:       "100",
    FixedSide:    "SELL",
})

conversion, err := client.Banking.Conversions.Create(ctx, &banking.CreateConversionRequest{
    QuoteID: quote.QuoteID,
})

conversions, err := client.Banking.Conversions.List(ctx, &banking.ListConversionsRequest{
    PageSize: 20,
})

dates, err := client.Banking.Conversions.ListConversionDates(ctx, nil)

rates, err := client.Banking.ExchangeRates.List(ctx, &banking.ListExchangeRatesRequest{})

intent, err := client.Payment.PaymentIntents.Create(ctx, &payment.CreatePaymentIntentRequest{
    Amount:          "10.00",
    Currency:        "USD",
    MerchantOrderID: fmt.Sprintf("get-test-%d", time.Now().UnixNano()),
    Description:     "SDK test get intent",
    ReturnURL:       "https://example.com/return",
})
if err != nil {
    log.Fatal(err)
}

retrieved, err := client.Payment.PaymentIntents.Get(ctx, intent.PaymentIntentID)

links, err := client.Supporting.Files.GetDownloadLinks(ctx, &supporting.DownloadLinksRequest{
    FileIDs: []string{"file_nonexistent_123", "file_nonexistent_456"},
})

_, err := client.Simulator.Issuing.Authorize(ctx, &simulator.AuthorizationRequest{
    CardID: "card_123",
})

_, err = client.Simulator.Issuing.Reverse(ctx, &simulator.ReversalRequest{
    TransactionID: "txn_123",
})