Create a spending card

mc, _ := moov.NewClient()

var accountID string

mc.CreateIssuedCard(ctx, accountID, moov.CreateIssuedCard{
  Controls: &moov.IssuingControls{
    SingleUse: moov.PtrOf(true),
    VelocityLimits: []moov.IssuingVelocityLimit{
      {
        Amount:   moov.PtrOf(int32(10000)),
        Count:    moov.PtrOf(int32(5)),
        Interval: moov.PtrOf(moov.IssuingIntervalLimit_Daily),
      },
    },
    MerchantCategoryRestrictions: &moov.MerchantCategoryRestrictions{
      Mode:            moov.IssuingControlsRestrictionMode_Block,
      Categories:      []moov.IssuingMerchantCategory{moov.IssuingMerchantCategory_Gambling},
      CustomMCCs:      []string{"5811"},
      ExemptMerchants: []moov.MerchantEntry{{Name: moov.PtrOf("Moov Financial")}},
    },
    MerchantRestrictions: &moov.MerchantRestrictions{
      Mode:      moov.IssuingControlsRestrictionMode_Allow,
      Merchants: []moov.MerchantEntry{{DescriptorPattern: moov.PtrOf("(?i)amazon")}},
    },
    AllowedSchedule: &moov.AllowedSchedule{
      Timezone: "America/Denver",
      Windows: []moov.ScheduleWindow{
        {
          Days:      []moov.IssuingScheduleDay{moov.IssuingScheduleDay_Monday},
          StartTime: "09:00",
          EndTime:   "17:00",
        },
      },
    },
    ExpiresOn: moov.PtrOf(time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC)),
  },
})

import { Moov } from "@moovio/sdk";

const moov = new Moov({
  security: {
    username: "",
    password: "",
  },
});

async function run() {
  const result = await moov.cardIssuing.request({
    accountID: "d9ac71ae-fccb-4dfc-9fed-710ca654e3ed",
    requestCard: {
      metadata: {
        "optional": "metadata",
      },
      billingAddress: {
        addressLine1: "123 Main Street",
        addressLine2: "Apt 302",
        city: "Boulder",
        stateOrProvince: "CO",
        postalCode: "80301",
        country: "US",
      },
      expiration: {
        month: "01",
        year: "21",
      },
      controls: {
        velocityLimits: [
          {
            amount: 10000,
            interval: "per-transaction",
          },
        ],
      },
    },
  });

  console.log(result);
}

run();

declare(strict_types=1);

require 'vendor/autoload.php';

use Moov\MoovPhp;
use Moov\MoovPhp\Models\Components;

$sdk = MoovPhp\Moov::builder()
    ->setSecurity(
        new Components\Security(
            username: '',
            password: '',
        )
    )
    ->build();

$requestCard = new Components\RequestCard(
    metadata: [
        'optional' => 'metadata',
    ],
    billingAddress: new Components\Address(
        addressLine1: '123 Main Street',
        addressLine2: 'Apt 302',
        city: 'Boulder',
        stateOrProvince: 'CO',
        postalCode: '80301',
        country: 'US',
    ),
    expiration: new Components\CardExpiration(
        month: '01',
        year: '21',
    ),
    controls: new Components\IssuingControls(
        velocityLimits: [
            new Components\IssuingVelocityLimit(
                amount: 10000,
                interval: Components\IssuingIntervalLimit::PerTransaction,
            ),
        ],
    ),
);

$response = $sdk->cardIssuing->request(
    accountID: 'd9ac71ae-fccb-4dfc-9fed-710ca654e3ed',
    requestCard: $requestCard

);

if ($response->issuedCard !== null) {
    // handle response
}

package hello.world;

import io.moov.sdk.Moov;
import io.moov.sdk.models.components.*;
import io.moov.sdk.models.errors.GenericError;
import io.moov.sdk.models.errors.RequestCardError;
import io.moov.sdk.models.operations.RequestCardResponse;
import java.lang.Exception;
import java.util.List;
import java.util.Map;

public class Application {

    public static void main(String[] args) throws GenericError, RequestCardError, Exception {

        Moov sdk = Moov.builder()
                .security(Security.builder()
                    .username("")
                    .password("")
                    .build())
            .build();

        RequestCardResponse res = sdk.cardIssuing().request()
                .accountID("d9ac71ae-fccb-4dfc-9fed-710ca654e3ed")
                .requestCard(RequestCard.builder()
                    .metadata(Map.ofEntries(
                        Map.entry("optional", "metadata")))
                    .billingAddress(Address.builder()
                        .addressLine1("123 Main Street")
                        .city("Boulder")
                        .stateOrProvince("CO")
                        .postalCode("80301")
                        .country("US")
                        .addressLine2("Apt 302")
                        .build())
                    .expiration(CardExpiration.builder()
                        .month("01")
                        .year("21")
                        .build())
                    .controls(IssuingControls.builder()
                        .velocityLimits(List.of(
                            IssuingVelocityLimit.builder()
                                .interval(IssuingIntervalLimit.PER_TRANSACTION)
                                .amount(10000L)
                                .build()))
                        .build())
                    .build())
                .call();

        if (res.issuedCard().isPresent()) {
            System.out.println(res.issuedCard().get());
        }
    }
}

from moovio_sdk import Moov
from moovio_sdk.models import components


with Moov(
    security=components.Security(
        username="",
        password="",
    ),
) as moov:

    res = moov.card_issuing.request(account_id="d9ac71ae-fccb-4dfc-9fed-710ca654e3ed", metadata={
        "optional": "metadata",
    }, billing_address={
        "address_line1": "123 Main Street",
        "address_line2": "Apt 302",
        "city": "Boulder",
        "state_or_province": "CO",
        "postal_code": "80301",
        "country": "US",
    }, expiration={
        "month": "01",
        "year": "21",
    }, controls=components.IssuingControls(
        velocity_limits=[
            components.IssuingVelocityLimit(
                amount=10000,
                interval=components.IssuingIntervalLimit.PER_TRANSACTION,
            ),
        ],
    ))

    # Handle response
    print(res)

require 'moov_ruby'

Models = ::Moov::Models
s = ::Moov::Client.new(
  security: Models::Components::Security.new(
    username: '',
    password: ''
  )
)
res = s.card_issuing.request(account_id: '4d9ac71a-efcc-4bdf-bcfe-d710ca654e3e', request_card: Models::Components::RequestCard.new(
  metadata: {
    'optional' => 'metadata',
  },
  billing_address: Models::Components::Address.new(
    address_line1: '123 Main Street',
    address_line2: 'Apt 302',
    city: 'Boulder',
    state_or_province: 'CO',
    postal_code: '80301',
    country: 'US'
  ),
  expiration: Models::Components::CardExpiration.new(
    month: '01',
    year: '21'
  ),
  controls: Models::Components::IssuingControls.new(
    velocity_limits: [
      Models::Components::IssuingVelocityLimit.new(
        amount: 10_000,
        interval: Models::Components::IssuingIntervalLimit::PER_TRANSACTION
      ),
    ]
  )
))

unless res.issued_card.nil?
  # handle response
end

using Moov.Sdk;
using Moov.Sdk.Models.Components;
using System.Collections.Generic;

var sdk = new MoovClient(security: new Security() {
    Username = "",
    Password = "",
});

var res = await sdk.CardIssuing.RequestAsync(
    accountID: "4d9ac71a-efcc-4bdf-bcfe-d710ca654e3e",
    body: new RequestCard() {
        Metadata = new Dictionary<string, string>() {
            { "optional", "metadata" },
        },
        BillingAddress = new Address() {
            AddressLine1 = "123 Main Street",
            AddressLine2 = "Apt 302",
            City = "Boulder",
            StateOrProvince = "CO",
            PostalCode = "80301",
            Country = "US",
        },
        Expiration = new CardExpiration() {
            Month = "01",
            Year = "21",
        },
        Controls = new IssuingControls() {
            VelocityLimits = new List<IssuingVelocityLimit>() {
                new IssuingVelocityLimit() {
                    Amount = 10000,
                    Interval = IssuingIntervalLimit.PerTransaction,
                },
            },
        },
    }
);

// handle response