International shipping

customs_item = {
    :description => "T-Shirt",
    :quantity => 20,
    :net_weight => "1",
    :mass_unit => "lb",
    :value_amount => "200",
    :value_currency => "USD",
    :origin_country => "US"
}

customs_declaration = Shippo::CustomsDeclaration.create(
    :contents_type => "MERCHANDISE",
    :contents_explanation => "T-Shirt purchase",
    :non_delivery_option => "RETURN",
    :certify => true,
    :certify_signer => "Simon Kreuz",
    :items => [customs_item]
)

customs_item = components.CustomsItemCreateRequest(
    description="T-Shirt",
    quantity=20,
    net_weight="1",
    mass_unit=components.WeightUnitEnum.LB,
    value_amount="200",
    value_currency="USD",
    origin_country="US",
)

customs_declaration = shippo_sdk.customs_declarations.create(
    components.CustomsDeclarationCreateRequest(
        contents_type=components.CustomsDeclarationContentsTypeEnum.MERCHANDISE,
        contents_explanation='T-Shirt purchase',
        non_delivery_option=components.CustomsDeclarationNonDeliveryOptionEnum.RETURN,
        certify=True,
        certify_signer='Simon Kreuz',
        items=[customs_item]
    )
)

$customs_item = array(
    'description'=> 'T-Shirt',
    'quantity'=> '20',
    'net_weight'=> '1',
    'mass_unit'=> 'lb',
    'value_amount'=> '200',
    'value_currency'=> 'USD',
    'origin_country'=> 'US');

$customs_declaration = Shippo_CustomsDeclaration::create(
array(
    'contents_type'=> 'MERCHANDISE',
    'contents_explanation'=> 'T-Shirt purchase',
    'non_delivery_option'=> 'RETURN',
    'certify'=> 'true',
    'certify_signer'=> 'Simon Kreuz',
    'items'=> array($customs_item)
));

const customsItem: CustomsItem = {
    description: "T-Shirt",
    quantity: 20,
    netWeight: "1",
    massUnit: WeightUnitEnum.Lb,
    valueAmount: "200",
    valueCurrency: "USD",
    originCountry: "US",
};

const customsDeclaration = await shippo.customsDeclarations.create({
    contentsType: CustomsDeclarationContentsTypeEnum.Merchandise,
    contentsExplanation: "T-Shirt purchase",
    nonDeliveryOption: CustomsDeclarationNonDeliveryOptionEnum.Return,
    certify: true,
    certifySigner: "Simon Kreuz",
    items: [customsItem],
});

HashMap<String, Object> customsItemMap = new HashMap<String, Object>();
customsItemMap.put("description", "T-Shirt");
customsItemMap.put("quantity", 20);
customsItemMap.put("net_weight", "1");
customsItemMap.put("mass_unit", "lb");
customsItemMap.put("value_amount", "200");
customsItemMap.put("value_currency", "USD");
customsItemMap.put("origin_country", "US");

HashMap<String, Object> customsDeclarationMap = new HashMap<String, Object>();
customsDeclarationMap.put("contents_type", "MERCHANDISE");
customsDeclarationMap.put("contents_explanation", "T-Shirt purchase");
customsDeclarationMap.put("non_delivery_option", "RETURN");
customsDeclarationMap.put("certify", true);
customsDeclarationMap.put("certify_signer", "Simon Kreuz");
customsDeclarationMap.put("items", customsItemMap);

CustomsDeclaration.create(customsDeclarationMap);

CustomsItemCreateRequest customsItemCreateRequest = new CustomsItemCreateRequest()
{
    Description = "T-Shirt",
    Quantity = 20,
    NetWeight = "1",
    MassUnit = WeightUnitEnum.Lb,
    ValueAmount = "200",
    ValueCurrency = "USD",
    OriginCountry = "US",
};
CustomsDeclaration customsDeclaration = await sdk.CustomsDeclarations.CreateAsync(
    new CustomsDeclarationCreateRequest()
    {
        ContentsType = CustomsDeclarationContentsTypeEnum.Merchandise,
        ContentsExplanation = "T-Shirt purchase",
        NonDeliveryOption = CustomsDeclarationNonDeliveryOptionEnum.Return,
        Certify = true,
        CertifySigner = "Simon Kreuz",
        Items = new List<CustomsItemCreateRequest>() { customsItemCreateRequest },
    }
);

# Create the shipment object
shipment = Shippo::Shipment.create(
    # you can also use the object_id directly for the following, but this is more convenient
    :address_from => address_from,
    :address_to => address_to,
    :parcels => parcel,
    :customs_declaration => customs_declaration,
    :async => false
)

# Create shipment object
shipment = shippo_sdk.shipments.create(
    components.ShipmentCreateRequest(
        address_from="d799c2679e644279b59fe661ac8fa488",
        address_to="42236bcf36214f62bcc6d7f12f02a849",
        parcels=["7df2ecf8b4224763ab7c71fae7ec8274"],
        customs_declaration="b741b99f95e841639b54272834bc478c",
        async_=False
    )
)

// Create shipment object
$shipment = Shippo_Shipment::create(
    array(
        "address_from" => $fromAddress,
        "address_to" => $toAddress,
        "parcels" => array($parcel),
        "customs_declaration" => $customs_declaration -> object_id,
        "async" => False
    )
);

// Create shipment object
const shipment = await shippo.shipments.create({
    addressFrom: "d799c2679e644279b59fe661ac8fa488",
    addressTo: "42236bcf36214f62bcc6d7f12f02a849",
    parcels: ["7df2ecf8b4224763ab7c71fae7ec8274"],
    customsDeclaration: "b741b99f95e841639b54272834bc478c",
    async: false
});

HashMap<String, Object> createShipmentMap = new HashMap<String, Object>();
createShipmentMap.put("address_to", addressToMap);
createShipmentMap.put("address_from", addressFromMap);
createShipmentMap.put("parcels", parcelMap);
createShipmentMap.put("customs_declaration", customsDeclarationMap);
createShipmentMap.put("async", false);

Shipment.create(createShipmentMap);

Shipment shipment = await sdk.Shipments.CreateAsync(
    new ShipmentCreateRequest()
    {
        AddressFrom = AddressFrom.CreateStr("d799c2679e644279b59fe661ac8fa488"),
        AddressTo = AddressTo.CreateStr("42236bcf36214f62bcc6d7f12f02a849"),
        Parcels = new List<Shippo.Models.Components.Parcels>()
        {
            Shippo.Models.Components.Parcels.CreateStr("7df2ecf8b4224763ab7c71fae7ec8274")
        },
        CustomsDeclaration = ShipmentCreateRequestCustomsDeclaration.CreateStr("b741b99f95e841639b54272834bc478c"),
        Async = false,
    }
);

# Get the first rate in the rates results.
# Customize this based on your business logic.
rate = shipment.rates.first

# Purchase the desired rate.
transaction = Shippo::Transaction.create( 
  :rate => rate["object_id"], 
  :label_file_type => "PDF", 
  :async => false )

# label_url and tracking_number
if transaction["status"] == "SUCCESS"
  puts "Label sucessfully generated:"
  puts "label_url: #{transaction.label_url}" 
  puts "tracking_number: #{transaction.tracking_number}" 
else
  puts "Error generating label:"
  puts transaction.messages
end

# Get the first rate in the rates results.
# Customize this based on your business logic.
rate = shipment.rates[0]

# Purchase the desired rate.
transaction = api.transactions.create(
    components.TransactionCreateRequest(
        rate=rate.object_id,
        label_file_type=components.LabelFileTypeEnum.PDF,
        async_=False
    )
)

# Retrieve label url and tracking number or error message
if transaction.status == components.TransactionStatusEnum.SUCCESS:
    print(transaction.label_url)
    print(transaction.tracking_number)
else:
    print(transaction.messages)

// Get the first rate in the rates results.
// Customize this based on your business logic.
$rate = $shipment["rates"][0];

// Purchase the desired rate.
$transaction = Shippo_Transaction::create( array( 
    'rate' => $rate["object_id"], 
    'label_file_type' => "PDF", 
    'async' => false ) );

// Retrieve label url and tracking number or error message
if ($transaction["status"] == "SUCCESS"){
    echo( $transaction["label_url"] );
    echo("\n");
    echo( $transaction["tracking_number"] );
}else {
    echo( $transaction["messages"] );
}

// Get the first rate in the rates results.
// Customize this based on your business logic.
const rate = shipment.rates[0];

// Purchase the desired rate.
const transaction = await shippo.transactions.create({
    rate: rate.objectId,
    labelFileType: LabelFileTypeEnum.Pdf,
    async: false
});

// Get the first rate in the rates results.
// Customize this based on your own business logic
Rate rate = rates.get(0);

Map<String, Object> transactionParameters = new HashMap<String, Object>();
transactionParameters.put("rate", rate.getObjectId());
transactionParameters.put("async", false);
Transaction transaction = Transaction.create(transactionParameters);

if (transaction.getStatus().equals("SUCCESS")) {
    System.out.println(String.format("Label url : %s", transaction.getLabelUrl()));
    System.out.println(String.format("Tracking number : %s", transaction.getTrackingNumber()));
} else {
    System.out.println(String.format("An Error has occured while generating you label. Messages : %s", transaction.getMessages()));
}

// Get the first rate in the rates results.
// Customize this based on your own business logic.
Rate rate = shipment.Rates[0];
Transaction transaction = await sdk.Transactions.CreateAsync(
    CreateTransactionRequestBody.CreateTransactionCreateRequest(
        new TransactionCreateRequest()
        {
            Rate = rate.ObjectId,
            LabelFileType = LabelFileTypeEnum.Pdf,
            Async = false,
        }
    )
);
if (transaction.Status == TransactionStatusEnum.Success)
{
    Console.WriteLine($"{transaction.LabelUrl}");
    Console.WriteLine($"{transaction.TrackingNumber}");
}
else
{
    Console.WriteLine($"{transaction.Messages}");
}