import starkinfra

requests = starkinfra.pixrequest.create([
    starkinfra.PixRequest(
        amount=1000,
        external_id="my-external-id-1",
        end_to_end_id="E20018183202201011000r01",
        sender_account_number="00000-0",
        sender_branch_code="0001",
        sender_account_type="checking",
        sender_name="Arya Stark",
        sender_tax_id="012.345.678-90",
        receiver_account_number="10000-0",
        receiver_account_type="checking",
        receiver_bank_code="20018183",
        receiver_tax_id="98.765.432/0001-10",
        receiver_branch_code="0001",
        receiver_name="Jon Snow",
        tags=["transfer", "pix"]
    )
])

for request in requests:
    print(request)
  

const starkinfra = require('starkinfra')

const requests = await starkinfra.pixRequest.create([
    {
        amount: 1000,
        externalId: "my-external-id-1",
        receiverBankCode: "20018183",
        receiverBranchCode: "0001",
        receiverAccountNumber: "10000-0",
        receiverAccountType: "checking",
        receiverName: "Jon Snow",
        receiverTaxId: "012.345.678-90",
        tags: ["transfer", "pix"]
    }
])

for (const request of requests) {
    console.log(request)
}
  

 1000,
        "externalId" => "my-external-id-1",
        "receiverBankCode" => "20018183",
        "receiverBranchCode" => "0001",
        "receiverAccountNumber" => "10000-0",
        "receiverAccountType" => "checking",
        "receiverName" => "Jon Snow",
        "receiverTaxId" => "012.345.678-90",
        "tags" => ["transfer", "pix"]
    ])
]);

foreach ($requests as $request) {
    print_r($request);
}
  

import com.starkinfra.*;
import java.util.Arrays;

List requests = PixRequest.create(
    Arrays.asList(
        new PixRequest.Builder()
            .amount(1000L)
            .externalId("my-external-id-1")
            .receiverBankCode("20018183")
            .receiverBranchCode("0001")
            .receiverAccountNumber("10000-0")
            .receiverAccountType("checking")
            .receiverName("Jon Snow")
            .receiverTaxId("012.345.678-90")
            .tags(Arrays.asList("transfer", "pix"))
            .build()
    )
);

for (PixRequest request : requests) {
    System.out.println(request);
}
  

require('starkinfra')

requests = StarkInfra::PixRequest.create([
    StarkInfra::PixRequest.new(
        amount: 1000,
        external_id: "my-external-id-1",
        receiver_bank_code: "20018183",
        receiver_branch_code: "0001",
        receiver_account_number: "10000-0",
        receiver_account_type: "checking",
        receiver_name: "Jon Snow",
        receiver_tax_id: "012.345.678-90",
        tags: ["transfer", "pix"]
    )
])

requests.each do |request|
    puts request
end
  

requests = StarkInfra.PixRequest.create!([
    %StarkInfra.PixRequest{
        amount: 1000,
        external_id: "my-external-id-1",
        receiver_bank_code: "20018183",
        receiver_branch_code: "0001",
        receiver_account_number: "10000-0",
        receiver_account_type: "checking",
        receiver_name: "Jon Snow",
        receiver_tax_id: "012.345.678-90",
        tags: ["transfer", "pix"]
    }
])

for request <- requests do
    IO.inspect(request)
end
  

using StarkInfra;
using System.Collections.Generic;

List requests = PixRequest.Create(
    new List {
        new PixRequest(
            amount: 1000,
            externalId: "my-external-id-1",
            receiverBankCode: "20018183",
            receiverBranchCode: "0001",
            receiverAccountNumber: "10000-0",
            receiverAccountType: "checking",
            receiverName: "Jon Snow",
            receiverTaxId: "012.345.678-90",
            tags: new List { "transfer", "pix" }
        )
    }
);

foreach (PixRequest request in requests) {
    Console.WriteLine(request);
}
  

package main

import (
    "fmt"
    PixRequest "github.com/starkinfra/sdk-go/starkinfra/pixrequest"
)

requests, err := PixRequest.Create(
    []PixRequest.PixRequest{
        {
            Amount:                1000,
            ExternalId:            "my-external-id-1",
            ReceiverBankCode:      "20018183",
            ReceiverBranchCode:    "0001",
            ReceiverAccountNumber: "10000-0",
            ReceiverAccountType:   "checking",
            ReceiverName:          "Jon Snow",
            ReceiverTaxId:         "012.345.678-90",
            Tags:                  []string{"transfer", "pix"},
        },
    }, nil)

for _, request := range requests {
    fmt.Println(request)
}
  

(def requests
    (starkinfra.pix-request/create
        [{:amount 1000
          :external-id "my-external-id-1"
          :receiver-bank-code "20018183"
          :receiver-branch-code "0001"
          :receiver-account-number "10000-0"
          :receiver-account-type "checking"
          :receiver-name "Jon Snow"
          :receiver-tax-id "012.345.678-90"
          :tags ["transfer" "pix"]}]))

(doseq [request requests]
    (println request))
  

curl --location --request POST '{{baseUrl}}/v2/pix-request' \
--header 'Access-Id: {{accessId}}' \
--header 'Access-Time: {{accessTime}}' \
--header 'Access-Signature: {{accessSignature}}' \
--header 'Content-Type: application/json' \
--data-raw '{
    "requests": [
        {
            "amount": 1000,
            "externalId": "my-external-id-1",
            "receiverBankCode": "20018183",
            "receiverBranchCode": "0001",
            "receiverAccountNumber": "10000-0",
            "receiverAccountType": "checking",
            "receiverName": "Jon Snow",
            "receiverTaxId": "012.345.678-90",
            "tags": ["transfer", "pix"]
        }
    ]
}'
  

[
    PixRequest(
        id="5656565656565656",
        amount=1000,
        end_to_end_id="E20018183202201011000r01",
        fee=0,
        flow="out",
        method="manual",
        external_id="my-external-id-1",
        initiator_tax_id="",
        receiver_bank_code="20018183",
        receiver_branch_code="0001",
        receiver_account_number="10000-0",
        receiver_account_type="checking",
        receiver_name="Jon Snow",
        receiver_tax_id="98.765.432/0001-10",
        sender_bank_code="34052649",
        sender_branch_code="0001",
        sender_account_number="00000-0",
        sender_account_type="checking",
        sender_name="Arya Stark",
        sender_tax_id="012.345.678-90",
        status="created",
        tags=["transfer", "pix"],
        description="",
        reconciliation_id="",
        cash_amount=0,
        cashier_type="",
        cashier_bank_code="",
        priority="high",
        reason="customerRequest",
        created="2022-01-01T00:00:00+00:00",
        updated="2022-01-01T00:00:00+00:00"
    )
]
  

[
    {
        id: "5656565656565656",
        amount: 1000,
        externalId: "my-external-id-1",
        receiverBankCode: "20018183",
        receiverBranchCode: "0001",
        receiverAccountNumber: "10000-0",
        receiverAccountType: "checking",
        receiverName: "Jon Snow",
        receiverTaxId: "012.345.678-90",
        status: "created",
        flow: "out",
        tags: ["transfer", "pix"],
        created: "2022-01-01T00:00:00+00:00",
        updated: "2022-01-01T00:00:00+00:00"
    }
]
  

[
    PixRequest Object (
        [id] => 5656565656565656
        [amount] => 1000
        [externalId] => my-external-id-1
        [receiverBankCode] => 20018183
        [receiverBranchCode] => 0001
        [receiverAccountNumber] => 10000-0
        [receiverAccountType] => checking
        [receiverName] => Jon Snow
        [receiverTaxId] => 012.345.678-90
        [status] => created
        [flow] => out
        [tags] => Array ( [0] => transfer [1] => pix )
        [created] => 2022-01-01T00:00:00+00:00
        [updated] => 2022-01-01T00:00:00+00:00
    )
]
  

[
    PixRequest(
        id=5656565656565656,
        amount=1000,
        externalId=my-external-id-1,
        receiverBankCode=20018183,
        receiverBranchCode=0001,
        receiverAccountNumber=10000-0,
        receiverAccountType=checking,
        receiverName=Jon Snow,
        receiverTaxId=012.345.678-90,
        status=created,
        flow=out,
        tags=[transfer, pix],
        created=2022-01-01T00:00:00+00:00,
        updated=2022-01-01T00:00:00+00:00
    )
]
  

[
    starkinfra_pix_request: {
        id: "5656565656565656",
        amount: 1000,
        external_id: "my-external-id-1",
        receiver_bank_code: "20018183",
        receiver_branch_code: "0001",
        receiver_account_number: "10000-0",
        receiver_account_type: "checking",
        receiver_name: "Jon Snow",
        receiver_tax_id: "012.345.678-90",
        status: "created",
        flow: "out",
        tags: ["transfer", "pix"],
        created: "2022-01-01T00:00:00+00:00",
        updated: "2022-01-01T00:00:00+00:00"
    }
]
  

[
    %StarkInfra.PixRequest{
        id: "5656565656565656",
        amount: 1000,
        external_id: "my-external-id-1",
        receiver_bank_code: "20018183",
        receiver_branch_code: "0001",
        receiver_account_number: "10000-0",
        receiver_account_type: "checking",
        receiver_name: "Jon Snow",
        receiver_tax_id: "012.345.678-90",
        status: "created",
        flow: "out",
        tags: ["transfer", "pix"],
        created: "2022-01-01T00:00:00+00:00",
        updated: "2022-01-01T00:00:00+00:00"
    }
]
  

[
    PixRequest(
        id: "5656565656565656",
        amount: 1000,
        externalId: "my-external-id-1",
        receiverBankCode: "20018183",
        receiverBranchCode: "0001",
        receiverAccountNumber: "10000-0",
        receiverAccountType: "checking",
        receiverName: "Jon Snow",
        receiverTaxId: "012.345.678-90",
        status: "created",
        flow: "out",
        tags: [ "transfer", "pix" ],
        created: "2022-01-01T00:00:00+00:00",
        updated: "2022-01-01T00:00:00+00:00"
    )
]
  

[
    {
        Id: "5656565656565656",
        Amount: 1000,
        ExternalId: "my-external-id-1",
        ReceiverBankCode: "20018183",
        ReceiverBranchCode: "0001",
        ReceiverAccountNumber: "10000-0",
        ReceiverAccountType: "checking",
        ReceiverName: "Jon Snow",
        ReceiverTaxId: "012.345.678-90",
        Status: "created",
        Flow: "out",
        Tags: ["transfer", "pix"],
        Created: "2022-01-01T00:00:00+00:00",
        Updated: "2022-01-01T00:00:00+00:00"
    }
]
  

[
    {:id "5656565656565656"
     :amount 1000
     :external-id "my-external-id-1"
     :receiver-bank-code "20018183"
     :receiver-branch-code "0001"
     :receiver-account-number "10000-0"
     :receiver-account-type "checking"
     :receiver-name "Jon Snow"
     :receiver-tax-id "012.345.678-90"
     :status "created"
     :flow "out"
     :tags ["transfer" "pix"]
     :created "2022-01-01T00:00:00+00:00"
     :updated "2022-01-01T00:00:00+00:00"}
]
  

{
    "requests": [
        {
            "id": "5656565656565656",
            "amount": 1000,
            "externalId": "my-external-id-1",
            "receiverBankCode": "20018183",
            "receiverBranchCode": "0001",
            "receiverAccountNumber": "10000-0",
            "receiverAccountType": "checking",
            "receiverName": "Jon Snow",
            "receiverTaxId": "012.345.678-90",
            "status": "created",
            "flow": "out",
            "tags": ["transfer", "pix"],
            "created": "2022-01-01T00:00:00+00:00",
            "updated": "2022-01-01T00:00:00+00:00"
        }
    ]
}
  

import starkinfra


my_bank_code = "34052649"
end_to_end_id = starkinfra.endtoendid.create(my_bank_code)

key = starkinfra.pixkey.get(
    "+5511285025604",
    payer_id="594.739.480-42",
    end_to_end_id=end_to_end_id
)

requests = starkinfra.pixrequest.create([
    starkinfra.PixRequest(
        amount=10000,
        description="A Lannister always pays his debts",
        end_to_end_id=end_to_end_id,
        external_id="my_unique_id_170",
        receiver_account_number=key.account_number,
        receiver_account_type=key.account_type,
        receiver_bank_code=key.bank_code,
        receiver_branch_code=key.branch_code,
        receiver_key_id=key.id,
        receiver_name=key.name,
        receiver_tax_id=key.tax_id,
        sender_account_number="00000",
        sender_account_type="checking",
        sender_branch_code="0000",
        sender_name="jaime Lannister",
        sender_tax_id="594.739.480-42",
        tags=['lannister', 'war/123']
    )
])

for request in requests:
    print(request)
  

const starkinfra = require('starkinfra');


(async() => {
    let myBankCode = '34052649'
    let endToEndId = endToEndId.create(myBankCode)

    let key = await starkinfra.pixKey.get(
        '+5511285025604',
        payerId='594.739.480-42',
        endToEndId=endToEndId
    )

    let requests = await starkinfra.pixRequest.create([
        {
            amount: 10000,
            description: 'A Lannister always pays his debts',
            endToEndId: endToEndId,
            externalId: 'my_unique_id_165',
            receiverAccountNumber: key.accountNumber,
            receiverAccountType: key.accountType,
            receiverBankCode: key.bankCode,
            receiverBranchCode: key.branchCode,
            receiverKeyId: key.id,
            receiverName: key.name,
            receiverTaxId: key.taxId,
            senderAccountNumber: '00000',
            senderAccountType: 'checking',
            senderBranchCode: '0000',
            senderName: 'jaime Lannister',
            senderTaxId: '594.739.480-42',
            tags: ['lannister', 'war/123']
        }
    ])

    for await (let request of requests) {
        console.log(request)
    }
})()
  

 $endToEndId]
);

$requests = PixRequest::create([
    new PixRequest([
        "amount" => 10000,
        "description" => "A Lannister always pays his debts",
        "endToEndId" => $endToEndId,
        "externalId" => "my_unique_id_538",
        "receiverAccountNumber" => $key->accountNumber,
        "receiverAccountType" => $key->accountType,
        "receiverBankCode" => $key->bankCode,
        "receiverBranchCode" => $key->branchCode,
        "receiverKeyId" => $key->id,
        "receiverName" => $key->name,
        "receiverTaxId" => $key->taxId,
        "senderAccountNumber" => "00000",
        "senderAccountType" => "checking",
        "senderBranchCode" => "0000",
        "senderName" => "jaime Lannister",
        "senderTaxId" => "594.739.480-42",
        "tags" => ["lannister", "war/123"]
    ])
]);

foreach ($requests as $request){
    print_r($request);
}
  

import com.starkinfra.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;


String myBankCode = "34052649";
String endToEndId = EndToEndId.create(myBankCode);

HashMap params = new HashMap<>();
params.put("endToEndId", endToEndId);

PixKey key = PixKey.get(
    "+5511285025604",
    "594.739.480-42",
    params
);

List requests = new ArrayList<>();
HashMap data = new HashMap<>();
data.put("amount", 10000);
data.put("externalId", "my_unique_id_740");
data.put("senderAccountNumber", "00000");
data.put("senderBranchCode", "0000");
data.put("senderAccountType", "checking");
data.put("senderName", "jaime Lannister");
data.put("senderTaxId", "594.739.480-42");
data.put("receiverBankCode", key.bankCode);
data.put("receiverAccountNumber", key.accountNumber);
data.put("receiverBranchCode", key.branchCode);
data.put("receiverAccountType", key.accountType);
data.put("receiverKeyId", key.id);
data.put("receiverName", key.name);
data.put("receiverTaxId", key.taxId);
data.put("endToEndId", endToEndId);
data.put("description", "A Lannister always pays his debts");
data.put("tags", new String[] {"lannister", "war/123"});
requests.add(new PixRequest(data));

requests = PixRequest.create(requests);

for (PixRequest request : requests){
    System.out.println(request);
}
  

require('starkinfra')


my_bank_code = '34052649'
end_to_end_id = StarkInfra::EndToEndId.create(my_bank_code)

key = StarkInfra::PixKey.get(
    '+5511285025604',
    payer_id: '594.739.480-42',
    end_to_end_id: end_to_end_id
)

requests = StarkInfra::PixRequest.create(
    [
        StarkInfra::PixRequest.new(
            amount: 10000,
            description: 'A Lannister always pays his debts',
            end_to_end_id: end_to_end_id,
            external_id: 'my_unique_id_626',
            receiver_account_number: key.account_number,
            receiver_account_type: key.account_type,
            receiver_bank_code: key.bank_code,
            receiver_branch_code: key.branch_code,
            receiver_key_id: key.id,
            receiver_name: key.name,
            receiver_tax_id: key.tax_id,
            sender_account_number: '00000',
            sender_account_type: 'checking',
            sender_branch_code: '0000',
            sender_name: 'jaime Lannister',
            sender_tax_id: '594.739.480-42',
            tags: %w[lannister war/123]
        )
    ]
)

requests.each do |request|
    puts request
end
  

key = StarkInfra.PixKey.get!(
    "+5511285025604",
    "594.739.480-42",
    end_to_end_id: "E34052649202208201432u34sDGd19lz"
)

request = StarkInfra.PixRequest.create!([
    %StarkInfra.PixRequest{
        amount: 10000,
        description: "A Lannister always pays his debts",
        end_to_end_id: "E34052649202208201432u34sDGd19lz",
        external_id: "my_unique_id_081",
        receiver_account_number: key.account_number,
        receiver_account_type: key.account_type,
        receiver_bank_code: key.bank_code,
        receiver_branch_code: key.branch_code,
        receiver_key_id: key.id,
        receiver_name: key.name,
        receiver_tax_id: key.tax_id,
        sender_account_number: "00000",
        sender_account_type: "checking",
        sender_branch_code: "0000",
        sender_name: "jaime Lannister",
        sender_tax_id: "594.739.480-42",
        tags: ["lannister", "war/123"]
    }
]) |> IO.inspect
  

using System;
using System.Collections.Generic;

String myBankCode = "34052649";
String endToEndId = EndToEndId.Create(myBankCode);

StarkInfra.PixKey key = StarkInfra.PixKey.Get(
    "+5511285025604",
    payerId: "594.739.480-42",
    new Dictionary {
        { "endToEndId", endToEndId }
    }
);

List requests = StarkInfra.PixRequest.Create(
    new List {
        new StarkInfra.PixRequest(
            amount: 10000,
            description: "A Lannister always pays his debts",
            endToEndID: endToEndId,
            externalID: "my_unique_id_430",
            receiverAccountNumber: key.AccountNumber,
            receiverAccountType: key.AccountType,
            receiverBankCode: key.BankCode,
            receiverBranchCode: key.BranchCode,
            receiverKeyID: key.ID,
            receiverName: key.Name,
            receiverTaxID: key.TaxID,
            senderAccountNumber: "00000",
            senderAccountType: "checking",
            senderBranchCode: "0000",
            senderName: "jaime Lannister",
            senderTaxID: "594.739.480-42",
            tags: new List { "lannister", "war/123" }
        )
    }
);

foreach (StarkInfra.PixRequest request in requests)
{
    Console.WriteLine(request);
}
  

package main

import (
    "fmt"
    EndToEndId "github.com/starkinfra/sdk-go/starkinfra/utils/endtoendid"
    PixKey "github.com/starkinfra/sdk-go/starkinfra/pixkey"
    PixRequest "github.com/starkinfra/sdk-go/starkinfra/pixrequest"
)

myBankCode := "34052649"
endToEndId := EndToEndId.Create(myBankCode)

key, err := PixKey.Get(
    "+5511285025604",
    "594.739.480-42",
    map[string]interface{}{"endToEndId": endToEndId},
    nil)

requests, err := PixRequest.Create(
    []PixRequest.PixRequest{
        {
            Amount:                10000,
            Description:           "A Lannister always pays his debts",
            EndToEndId:            endToEndId,
            ExternalId:            "my_unique_id_170",
            ReceiverAccountNumber: key.AccountNumber,
            ReceiverAccountType:   key.AccountType,
            ReceiverBankCode:      key.BankCode,
            ReceiverBranchCode:    key.BranchCode,
            ReceiverKeyId:         key.Id,
            ReceiverName:          key.Name,
            ReceiverTaxId:         key.TaxId,
            SenderAccountNumber:   "00000",
            SenderAccountType:     "checking",
            SenderBranchCode:      "0000",
            SenderName:            "jaime Lannister",
            SenderTaxId:           "594.739.480-42",
            Tags:                  []string{"lannister", "war/123"},
        },
    }, nil)

for _, request := range requests {
    fmt.Println(request)
}
  

curl --location --request POST '{{baseUrl}}/v2/pix-request' \
--header 'Access-Id: {{accessId}}' \
--header 'Access-Time: {{accessTime}}' \
--header 'Access-Signature: {{accessSignature}}' \
--header 'Content-Type: application/json' \
--data-raw '{
    "requests": [
        {
            "amount": 10000,
            "description": "A Lannister always pays his debts",
            "endToEndId": "E34052649202208201432u34sDGd19lz",
            "externalId": "my_unique_id_170",
            "receiverAccountNumber": "0000",
            "receiverAccountType": "savings",
            "receiverBankCode": "35547753",
            "receiverBranchCode": "0000",
            "receiverKeyId": "+5511285025604",
            "receiverName": "Jaime Lannister",
            "receiverTaxId": "012.345.678-90",
            "senderAccountNumber": "00000",
            "senderAccountType": "checking",
            "senderBranchCode": "0000",
            "senderName": "jaime Lannister",
            "senderTaxId": "594.739.480-42",
            "tags": ["lannister", "war/123"]
        }
    ]
}'
  

PixRequest(
    amount=10000,
    cash_amount=0,
    cashier_bank_code=,
    cashier_type=,
    created=2022-08-05 19:19:47.256075,
    description=A Lannister always pays his debts,
    end_to_end_id=E34052649202245501450u34sDGd19lz,
    external_id=my_unique_id_170,
    fee=0,
    flow=out,
    id=6123232910376960,
    initiator_tax_id=,
    method=dict,
    receiver_account_number=0000,
    receiver_account_type=savings,
    receiver_bank_code=35547753,
    receiver_branch_code=0000,
    receiver_key_id=+5511285025604,
    receiver_name=Jaime Lannister,
    receiver_tax_id=012.345.678-90,
    reconciliation_id=,
    sender_account_number=00000,
    sender_account_type=checking,
    sender_bank_code=34052649,
    sender_branch_code=0000,
    sender_name=jaime Lannister,
    sender_tax_id=594.739.480-42,
    status=created,
    tags=['lannister', 'war/123'],
    updated=2022-08-05 19:19:47.256092
)
  

PixRequest {
    id: '4517879126949888',
    amount: 10000,
    externalId: 'my_unique_id_165',
    senderName: 'jaime Lannister',
    senderTaxId: '594.739.480-42',
    senderBranchCode: '0000',
    senderAccountNumber: '00000',
    senderAccountType: 'checking',
    receiverName: 'Jaime Lannister',
    receiverTaxId: '012.345.678-90',
    receiverBankCode: '35547753',
    receiverAccountNumber: '0000',
    receiverBranchCode: '0000',
    receiverAccountType: 'savings',
    endToEndId: 'E34052649202206201452u34sDGd19lz',
    receiverKeyId: '+5511285025604',
    description: 'A Lannister always pays his debts',
    reconciliationId: '',
    initiatorTaxId: '',
    cashAmount: 0,
    cashierBankCode: '',
    cashierType: '',
    tags: [ 'lannister', 'war/123' ],
    method: 'dict',
    fee: 0,
    status: 'created',
    flow: 'out',
    senderBankCode: '34052649',
    created: '2022-08-05T19:32:15.307261+00:00',
    updated: '2022-08-05T19:32:15.307275+00:00'
}
  

StarkInfra\PixRequest Object
(
    [id] => 4644400944644096
    [amount] => 10000
    [externalId] => my_unique_id_538
    [senderName] => jaime Lannister
    [senderTaxId] => 594.739.480-42
    [senderBranchCode] => 0000
    [senderAccountNumber] => 00000
    [senderAccountType] => checking
    [receiverName] => Jaime Lannister
    [receiverTaxId] => 012.345.678-90
    [receiverBankCode] => 35547753
    [receiverAccountNumber] => 0000
    [receiverBranchCode] => 0000
    [receiverAccountType] => savings
    [endToEndId] => E34052649202207201452u34sDGd19lz
    [receiverKeyId] => +5511285025604
    [description] => A Lannister always pays his debts
    [reconciliationId] =>
    [initiatorTaxId] =>
    [cashAmount] => 0
    [cashierBankCode] =>
    [cashierType] =>
    [tags] => Array
        (
            [0] => lannister
            [1] => war/123
        )

    [method] => dict
    [fee] => 0
    [status] => created
    [flow] => out
    [senderBankCode] => 34052649
    [created] => DateTime Object ( [date] => 2022-08-05 19:36:50.250648 )
    [updated] => DateTime Object ( [date] => 2022-08-05 19:36:50.250662 )
)
  

PixRequest({
    "amount": 10000,
    "externalId": "my_unique_id_740",
    "senderName": "jaime Lannister",
    "senderTaxId": "594.739.480-42",
    "senderBranchCode": "0000",
    "senderAccountNumber": "00000",
    "senderAccountType": "checking",
    "receiverName": "Jaime Lannister",
    "receiverTaxId": "012.345.678-90",
    "receiverBankCode": "35547753",
    "receiverAccountNumber": "0000",
    "receiverBranchCode": "0000",
    "receiverAccountType": "savings",
    "endToEndId": "E34052649202207201420u34sDGd19lz",
    "receiverKeyId": "+5511285025604",
    "description": "A Lannister always pays his debts",
    "reconciliationId": "",
    "initiatorTaxId": "",
    "cashAmount": 0,
    "cashierBankCode": "",
    "cashierType": "",
    "tags": [ "lannister", "war/123" ],
    "method": "dict",
    "fee": 0,
    "status": "created",
    "flow": "out",
    "senderBankCode": "34052649",
    "created": "2022-08-05T19:43:46.436331+00:00",
    "updated": "2022-08-05T19:43:46.436343+00:00",
    "id": "4610304910557184"
})
  

pixrequest(
    id: 4874004393361408,
    amount: 10000,
    external_id: my_unique_id_626,
    sender_name: jaime Lannister,
    sender_tax_id: 594.739.480-42,
    sender_branch_code: 0000,
    sender_account_number: 00000,
    sender_account_type: checking,
    receiver_name: Jamie Lannister,
    receiver_tax_id: 012.345.678-90,
    receiver_bank_code: 35547753,
    receiver_account_number: 0000,
    receiver_branch_code: 0000,
    receiver_account_type: savings,
    end_to_end_id: E34052649202565201451u34sDGd19lz,
    receiver_key_id: +5511285025604,
    description: A Lannister always pays his debts,
    reconciliation_id: ,
    initiator_tax_id: ,
    cash_amount: 0,
    cashier_bank_code: ,
    cashier_type: ,
    tags: ["lannister", "war/123"],
    method: dict,
    fee: 0,
    status: created,
    flow: out,
    sender_bank_code: 34052649,
    created: 2022-08-05T19:50:40+00:00,
    updated: 2022-08-05T19:50:40+00:00
)
  

%StarkInfra.PixRequest{
    amount: 10000,
    cash_amount: 0,
    cashier_bank_code: "",
    cashier_type: "",
    created: ~U[2022-08-05 19:54:24.677757Z],
    description: "A Lannister always pays his debts",
    end_to_end_id: "E34052649202208201432u34sDGd19lz",
    external_id: "my_unique_id_081",
    fee: 0,
    flow: "out",
    id: "5859166811848704",
    initiator_tax_id: "",
    method: "dict",
    receiver_account_number: "0000",
    receiver_account_type: "savings",
    receiver_bank_code: "35547753",
    receiver_branch_code: "0000",
    receiver_key_id: "+5511285025604",
    receiver_name: "Jamie Lannister",
    receiver_tax_id: "012.345.678-90",
    reconciliation_id: "",
    sender_account_number: "00000",
    sender_account_type: "checking",
    sender_bank_code: "34052649",
    sender_branch_code: "0000",
    sender_name: "jaime Lannister",
    sender_tax_id: "594.739.480-42",
    status: "created",
    tags: ["lannister", "war/123"],
    updated: ~U[2022-08-05 19:54:24.677771Z]
}
  

PixRequest(
    Amount: 10000,
    ExternalID: my_unique_id_430,
    SenderName: jaime Lannister,
    SenderTaxID: 594.739.480-42,
    SenderBranchCode: 0000,
    SenderAccountNumber: 00000,
    SenderAccountType: checking,
    ReceiverName: Jamie Lannister,
    ReceiverTaxId: 012.345.678-90,
    ReceiverBankCode: 35547753,
    ReceiverAccountNumber: 0000,
    ReceiverBranchCode: 0000,
    ReceiverAccountType: savings,
    EndToEndID: E34052649202408201432u34sDGd19lz,
    ReceiverKeyID: +5511285025604,
    Description: A Lannister always pays his debts,
    ReconciliationID: ,
    InitiatorTaxId: ,
    CashAmount: 0,
    CashierBankCode: ,
    CashierType: ,
    Tags: { lannister, war/123 },
    Method: dict,
    Fee: 0,
    Status: created,
    Flow: out,
    SenderBankCode: 34052649,
    Created: 08/05/2022 16:59:05,
    Updated: 08/05/2022 16:59:05,
    ID: 6510413743128576
)
  

import starkinfra


my_bank_code = "35547753"

previews = starkinfra.brcodepreview.create([
    starkinfra.BrcodePreview(
        id="00020126360014br.gov.bcb.pix0114+5541999999999520400005303986540510.005802BR5910Tony Stark6014Rio de Janeiro62070503***630466B7"
    )
])
preview = previews[0]

requests = starkinfra.pixrequest.create([
    starkinfra.PixRequest(
        amount=preview.amount,
        description="A Lannister always pays his debts",
        end_to_end_id=starkinfra.endtoendid.create(my_bank_code),
        external_id="my_unique_id_170",
        receiver_account_number=preview.account_number,
        receiver_account_type=preview.account_type,
        receiver_bank_code=preview.bank_code,
        receiver_branch_code=preview.branch_code,
        receiver_name=preview.name,
        receiver_tax_id=preview.tax_id,
        receiver_key_id=preview.key_id,
        reconciliation_id=preview.reconciliation_id,
        sender_account_number="00000",
        sender_account_type="checking",
        sender_branch_code="0000",
        sender_name="jaime Lannister",
        sender_tax_id="594.739.480-42",
        tags=['lannister', 'war/123']
    )
])

for request in requests:
    print(request)
  

const starkinfra = require('starkinfra');


(async() => {
    let myBankCode = '35547753'

    let previews = await starkinfra.brcodePreview.create(
        '00020101021226930014br.gov.bcb.pix2571brcode-h.development.starkinfra.com/v2/c1c351eb237342a795fd4178f4af009a5204000053039865802BR5915Jaime Lannister6014Rio de Janeiro62070503***6304575D'
    )
    let preview = previews[0]

    let requests = await starkinfra.pixRequest.create([
        {
            amount: preview.amount,
            cashAmount: preview.cashAmount,
            cashierBankCode: preview.cashierBankCode,
            cashierType: preview.cashierType,
            description: 'A Lannister always pays his debts',
            endToEndId: endToEndId.create(myBankCode),
            externalId: 'my_unique_id_165',
            receiverAccountNumber: preview.accountNumber,
            receiverAccountType: preview.accountType,
            receiverBankCode: preview.bankCode,
            receiverBranchCode: preview.branchCode,
            receiverName: preview.name,
            receiverTaxId: preview.taxId,
            receiverKeyId: preview.keyId,
            reconciliationId: preview.reconciliationId,
            senderAccountNumber: '00000',
            senderAccountType: 'checking',
            senderBranchCode: '0000',
            senderName: 'jaime Lannister',
            senderTaxId: '594.739.480-42',
            tags: ['lannister', 'war/123']
        }
    ])

    for await (let request of requests) {
        console.log(request)
    }
})()
  

 "00020126360014br.gov.bcb.pix0114+5541999999999520400005303986540510.005802BR5910Tony Stark6014Rio de Janeiro62070503***630466B7"
    ])
]);
$preview = $previews[0];

$requests = PixRequest::create([
    new PixRequest([
        "amount" => $preview->amount,
        "cashAmount" => $preview->cashAmount,
        "cashierBankCode" => $preview->cashierBankCode,
        "cashierType" => $preview->cashierType,
        "description" => "A Lannister always pays his debts",
        "endToEndId" => EndToEndId::create($myBankCode),
        "externalId" => "my_unique_id_538",
        "receiverAccountNumber" => $preview->accountNumber,
        "receiverAccountType" => $preview->accountType,
        "receiverBankCode" => $preview->bankCode,
        "receiverBranchCode" => $preview->branchCode,
        "receiverName" => $preview->name,
        "receiverTaxId" => $preview->taxId,
        "receiverKeyId" => $preview->keyId,
        "reconciliationId" => $preview->reconciliationId,
        "senderAccountNumber" => "00000",
        "senderAccountType" => "checking",
        "senderBranchCode" => "0000",
        "senderName" => "jaime Lannister",
        "senderTaxId" => "594.739.480-42",
        "tags" => ["lannister", "war/123"]
    ])
]);

foreach ($requests as $request){
    print_r($request);
}
  

import com.starkinfra.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;


String myBankCode = "35547753";

List previews = new ArrayList<>();
HashMap previewData = new HashMap<>();
previewData.put("id", "00020126360014br.gov.bcb.pix0114+5541999999999520400005303986540510.005802BR5910Tony Stark6014Rio de Janeiro62070503***630466B7");
previews.add(new BrcodePreview(previewData));

previews = (List) BrcodePreview.create(previews);
BrcodePreview preview = previews.get(0);

List requests = new ArrayList<>();
HashMap data = new HashMap<>();
data.put("amount", preview.amount);
data.put("cashAmount", preview.cashAmount);
data.put("cashierBankCode", preview.cashierBankCode);
data.put("cashierType", preview.cashierType);
data.put("externalId", "my_unique_id_740");
data.put("senderAccountNumber", "00000");
data.put("senderBranchCode", "0000");
data.put("senderAccountType", "checking");
data.put("senderName", "jaime Lannister");
data.put("senderTaxId", "594.739.480-42");
data.put("receiverBankCode", preview.bankCode);
data.put("receiverAccountNumber", preview.accountNumber);
data.put("receiverBranchCode", preview.branchCode);
data.put("receiverAccountType", preview.accountType);
data.put("receiverName", preview.name);
data.put("receiverTaxId", preview.taxId);
data.put("receiverKeyId", preview.keyId);
data.put("reconciliationId", preview.reconciliationId);
data.put("endToEndId", EndToEndId.create(myBankCode));
data.put("description", "A Lannister always pays his debts");
data.put("tags", new String[] {"lannister", "war/123"});
requests.add(new PixRequest(data));

requests = PixRequest.create(requests);

for (PixRequest request : requests){
    System.out.println(request);
}
  

require('starkinfra')


my_bank_code = '35547753'

previews = StarkInfra::BrcodePreview.create([
    StarkInfra::BrcodePreview.new(
        '00020101021226930014br.gov.bcb.pix2571brcode-h.development.starkinfra.com/v2/c1c351eb237342a795fd4178f4af009a5204000053039865802BR5915Jaime Lannister6014Rio de Janeiro62070503***6304575D',
    )
])
preview = previews.first

requests = StarkInfra::PixRequest.create([
    StarkInfra::PixRequest.new(
        amount: preview.amount,
        cash_amount: preview.cash_amount,
        cashier_bank_code: preview.cashier_bank_code,
        cashier_type: preview.cashier_type,
        description: 'A Lannister always pays his debts',
        end_to_end_id: StarkInfra::EndToEndId.create(my_bank_code),
        external_id: 'my_unique_id_626',
        receiver_account_number: preview.account_number,
        receiver_account_type: preview.account_type,
        receiver_bank_code: preview.bank_code,
        receiver_branch_code: preview.branch_code,
        receiver_name: preview.name,
        receiver_tax_id: preview.tax_id,
        receiver_key_id: preview.key_id,
        reconciliation_id: preview.reconciliation_id,
        sender_account_number: '00000',
        sender_account_type: 'checking',
        sender_branch_code: '0000',
        sender_name: 'jaime Lannister',
        sender_tax_id: '594.739.480-42',
        tags: %w[lannister war/123]
    )
])

requests.each do |request|
    puts request
end
  

previews = StarkInfra.BrcodePreview.create!([
    %StarkInfra.BrcodePreview{
        "00020101021226930014br.gov.bcb.pix2571brcode-h.development.starkinfra.com/v2/c1c351eb237342a795fd4178f4af009a5204000053039865802BR5915Jaime Lannister6014Rio de Janeiro62070503***6304575D"
    }
])
preview = hd(previews)

request = StarkInfra.PixRequest.create!([
    %StarkInfra.PixRequest{
        amount: preview.amount,
        cash_amount: preview.cash_amount,
        cashier_bank_code: preview.cashier_bank_code,
        cashier_type: preview.cashier_type,
        description: "A Lannister always pays his debts",
        end_to_end_id: "E35547753202208201432u34sDGd19lz",
        external_id: "my_unique_id_081",
        receiver_account_number: preview.account_number,
        receiver_account_type: preview.account_type,
        receiver_bank_code: preview.bank_code,
        receiver_branch_code: preview.branch_code,
        receiver_name: preview.name,
        receiver_tax_id: preview.tax_id,
        receiver_key_id: preview.key_id,
        reconciliation_id: preview.reconciliation_id,
        sender_account_number: "00000",
        sender_account_type: "checking",
        sender_branch_code: "0000",
        sender_name: "jaime Lannister",
        sender_tax_id: "594.739.480-42",
        tags: ["lannister", "war/123"]
    }
]) |> IO.inspect
  

using System;
using System.Collections.Generic;

String myBankCode = "35547753";

List previews = StarkInfra.BrcodePreview.Create(
    new List {
        new StarkInfra.BrcodePreview(
            id: "00020101021226930014br.gov.bcb.pix2571brcode-h.development.starkinfra.com/v2/c1c351eb237342a795fd4178f4af009a5204000053039865802BR5915Jaime Lannister6014Rio de Janeiro62070503***6304575D"
        )
    }
);
StarkInfra.BrcodePreview preview = previews[0];

List requests = StarkInfra.PixRequest.Create(
    new List {
        new StarkInfra.PixRequest(
            amount: preview.Amount,
            cashAmount: preview.CashAmount,
            cashierBankCode: preview.CashierBankCode,
            cashierType: preview.CashierType,
            description: "A Lannister always pays his debts",
            endToEndID: EndToEndId.Create(myBankCode),
            externalID: "my_unique_id_430",
            receiverAccountNumber: preview.AccountNumber,
            receiverAccountType: preview.AccountType,
            receiverBankCode: preview.BankCode,
            receiverBranchCode: preview.BranchCode,
            receiverName: preview.Name,
            receiverTaxID: preview.TaxID,
            receiverKeyID: preview.KeyID,
            reconciliationID: preview.ReconciliationID,
            senderAccountNumber: "00000",
            senderAccountType: "checking",
            senderBranchCode: "0000",
            senderName: "jaime Lannister",
            senderTaxID: "594.739.480-42",
            tags: new List { "lannister", "war/123" }
        )
    }
);

foreach (StarkInfra.PixRequest request in requests)
{
    Console.WriteLine(request);
}
  

package main

import (
    "fmt"
    EndToEndId "github.com/starkinfra/sdk-go/starkinfra/utils/endtoendid"
    BrcodePreview "github.com/starkinfra/sdk-go/starkinfra/brcodepreview"
    PixRequest "github.com/starkinfra/sdk-go/starkinfra/pixrequest"
)

myBankCode := "35547753"

previews := BrcodePreview.Create(
    []BrcodePreview.BrcodePreview{
        {
            Id: "00020126360014br.gov.bcb.pix0114+5541999999999520400005303986540510.005802BR5910Tony Stark6014Rio de Janeiro62070503***630466B7",
        },
    }, nil)
preview := previews[0]

requests, err := PixRequest.Create(
    []PixRequest.PixRequest{
        {
            Amount:                preview.Amount,
            CashAmount:            preview.CashAmount,
            CashierBankCode:       preview.CashierBankCode,
            CashierType:           preview.CashierType,
            Description:           "A Lannister always pays his debts",
            EndToEndId:            EndToEndId.Create(myBankCode),
            ExternalId:            "my_unique_id_170",
            ReceiverAccountNumber: preview.AccountNumber,
            ReceiverAccountType:   preview.AccountType,
            ReceiverBankCode:      preview.BankCode,
            ReceiverBranchCode:    preview.BranchCode,
            ReceiverName:          preview.Name,
            ReceiverTaxId:         preview.TaxId,
            ReceiverKeyId:         preview.KeyId,
            ReconciliationId:      preview.ReconciliationId,
            SenderAccountNumber:   "00000",
            SenderAccountType:     "checking",
            SenderBranchCode:      "0000",
            SenderName:            "jaime Lannister",
            SenderTaxId:           "594.739.480-42",
            Tags:                  []string{"lannister", "war/123"},
        },
    }, nil)

for _, request := range requests {
    fmt.Println(request)
}
  

curl --location --request POST '{{baseUrl}}/v2/pix-request' \
--header 'Access-Id: {{accessId}}' \
--header 'Access-Time: {{accessTime}}' \
--header 'Access-Signature: {{accessSignature}}' \
--header 'Content-Type: application/json' \
--data-raw '{
    "requests": [
        {
            "amount": 1000,
            "description": "A Lannister always pays his debts",
            "endToEndId": "E35547753202208222101Ll2MpIBYy08",
            "externalId": "my_unique_id_170",
            "method": "staticQrcode",
            "receiverAccountNumber": "2446567693893903",
            "receiverAccountType": "checking",
            "receiverBankCode": "03412878",
            "receiverBranchCode": "5742",
            "receiverKeyId": "+5511285025604",
            "receiverName": "Jaime Lannister",
            "receiverTaxId": "012.345.678-90",
            "reconciliationId": "12345678910",
            "senderAccountNumber": "00000",
            "senderAccountType": "checking",
            "senderBranchCode": "0000",
            "senderName": "jaime Lannister",
            "senderTaxId": "594.739.480-42",
            "tags": ["lannister", "war/123"]
        }
    ]
}'
  

PixRequest(
    amount=1000,
    cash_amount=0,
    cashier_bank_code=,
    cashier_type=,
    created=2022-08-22 21:01:48.917564,
    description=A Lannister always pays his debts,
    end_to_end_id=E35547753202208222101Ll2MpIBYy08,
    external_id=my_unique_id_170,
    fee=0,
    flow=out,
    id=6298665144549376,
    initiator_tax_id=,
    method=staticQrcode,
    receiver_account_number=2446567693893903,
    receiver_account_type=checking,
    receiver_bank_code=03412878,
    receiver_branch_code=5742,
    receiver_key_id=+5511285025604,
    receiver_name=Jaime Lannister,
    receiver_tax_id=012.345.678-90,
    reconciliation_id=12345678910,
    sender_account_number=00000,
    sender_account_type=checking,
    sender_bank_code=35547753,
    sender_branch_code=0000,
    sender_name=jaime Lannister,
    sender_tax_id=594.739.480-42,
    status=created,
    tags=['lannister', 'war/123'],
    updated=2022-08-22 21:01:48.917580
)
  

PixRequest {
    id: '4517879126949888',
    amount: 10000,
    externalId: 'my_unique_id_165',
    senderName: 'jaime Lannister',
    senderTaxId: '594.739.480-42',
    senderBranchCode: '0000',
    senderAccountNumber: '00000',
    senderAccountType: 'checking',
    receiverName: 'Jaime Lannister',
    receiverTaxId: '012.345.678-90',
    receiverBankCode: '35547753',
    receiverAccountNumber: '0000',
    receiverBranchCode: '0000',
    receiverAccountType: 'savings',
    endToEndId: 'E35547753202206201452u34sDGd19lz',
    receiverKeyId: '+5511285025604',
    description: 'A Lannister always pays his debts',
    reconciliationId: '12345678910',
    initiatorTaxId: '',
    cashAmount: 0,
    cashierBankCode: '',
    cashierType: '',
    tags: [ 'lannister', 'war/123' ],
    method: 'staticQrcode',
    fee: 0,
    status: 'created',
    flow: 'out',
    senderBankCode: '35547753',
    created: '2022-08-05T19:32:15.307261+00:00',
    updated: '2022-08-05T19:32:15.307275+00:00'
}
  

StarkInfra\PixRequest Object
(
    [id] => 5959433360244736
    [amount] => 1000
    [externalId] => my_unique_id_538
    [senderName] => jaime Lannister
    [senderTaxId] => 594.739.480-42
    [senderBranchCode] => 0000
    [senderAccountNumber] => 00000
    [senderAccountType] => checking
    [receiverName] => Jaime Lannister
    [receiverTaxId] => 012.345.678-90
    [receiverBankCode] => 35547753
    [receiverAccountNumber] => 0000
    [receiverBranchCode] => 0000
    [receiverAccountType] => savings
    [endToEndId] => E35547753202207201452u34sDGd19lz
    [receiverKeyId] => +5511285025604
    [description] => A Lannister always pays his debts
    [reconciliationId] => 12345678910
    [initiatorTaxId] =>
    [cashAmount] => 0
    [cashierBankCode] =>
    [cashierType] =>
    [tags] => Array
        (
            [0] => lannister
            [1] => war/123
        )

    [method] => staticQrcode
    [fee] => 0
    [status] => created
    [flow] => out
    [senderBankCode] => 35547753
    [created] => DateTime Object ( [date] => 2022-08-22 21:14:48.244187 )
    [updated] => DateTime Object ( [date] => 2022-08-22 21:14:48.244202 )
)
  

PixRequest({
    "amount": 1000,
    "externalId": "my_unique_id_740",
    "senderName": "jaime Lannister",
    "senderTaxId": "594.739.480-42",
    "senderBranchCode": "0000",
    "senderAccountNumber": "00000",
    "senderAccountType": "checking",
    "receiverName": "Jaime Lannister",
    "receiverTaxId": "012.345.678-90",
    "receiverBankCode": "35547753",
    "receiverAccountNumber": "0000",
    "receiverBranchCode": "0000",
    "receiverAccountType": "savings",
    "endToEndId": "E35547753202207201420u34sDGd19lz",
    "receiverKeyId": "+5511285025604",
    "description": "A Lannister always pays his debts",
    "reconciliationId": "12345678910",
    "initiatorTaxId": "",
    "cashAmount": 0,
    "cashierBankCode": "",
    "cashierType": "",
    "tags": [ "lannister", "war/123" ],
    "method": "staticQrcode",
    "fee": 0,
    "status": "created",
    "flow": "out",
    "senderBankCode": "35547753",
    "created": "2022-08-22T21:33:12.873095+00:00",
    "updated": "2022-08-22T21:33:12.873115+00:00",
    "id": "6029802104422400"
})
  

pixrequest(
    id: 4874004393361408,
    amount: 10000,
    external_id: my_unique_id_626,
    sender_name: jaime Lannister,
    sender_tax_id: 594.739.480-42,
    sender_branch_code: 0000,
    sender_account_number: 00000,
    sender_account_type: checking,
    receiver_name: Jamie Lannister,
    receiver_tax_id: 012.345.678-90,
    receiver_bank_code: 35547753,
    receiver_account_number: 0000,
    receiver_branch_code: 0000,
    receiver_account_type: savings,
    end_to_end_id: E35547753202565201451u34sDGd19lz,
    receiver_key_id: +5511285025604,
    description: A Lannister always pays his debts,
    reconciliation_id: 12345678910,
    initiator_tax_id: ,
    cash_amount: 0,
    cashier_bank_code: ,
    cashier_type: ,
    tags: ["lannister", "war/123"],
    method: staticQrcode,
    fee: 0,
    status: created,
    flow: out,
    sender_bank_code: 35547753,
    created: 2022-08-05T19:50:40+00:00,
    updated: 2022-08-05T19:50:40+00:00
)
  

%StarkInfra.PixRequest{
    amount: 10000,
    cash_amount: 0,
    cashier_bank_code: "",
    cashier_type: "",
    created: ~U[2022-08-05 19:54:24.677757Z],
    description: "A Lannister always pays his debts",
    end_to_end_id: "E35547753202208201432u34sDGd19lz",
    external_id: "my_unique_id_081",
    fee: 0,
    flow: "out",
    id: "5859166811848704",
    initiator_tax_id: "",
    method: "staticQrcode",
    receiver_account_number: "0000",
    receiver_account_type: "savings",
    receiver_bank_code: "35547753",
    receiver_branch_code: "0000",
    receiver_key_id: "+5511285025604",
    receiver_name: "Jamie Lannister",
    receiver_tax_id: "012.345.678-90",
    reconciliation_id: "12345678910",
    sender_account_number: "00000",
    sender_account_type: "checking",
    sender_bank_code: "35547753",
    sender_branch_code: "0000",
    sender_name: "jaime Lannister",
    sender_tax_id: "594.739.480-42",
    status: "created",
    tags: ["lannister", "war/123"],
    updated: ~U[2022-08-05 19:54:24.677771Z]
}
  

PixRequest(
    Amount: 10000,
    ExternalID: my_unique_id_430,
    SenderName: jaime Lannister,
    SenderTaxID: 594.739.480-42,
    SenderBranchCode: 0000,
    SenderAccountNumber: 00000,
    SenderAccountType: checking,
    ReceiverName: Jamie Lannister,
    ReceiverTaxId: 012.345.678-90,
    ReceiverBankCode: 35547753,
    ReceiverAccountNumber: 0000,
    ReceiverBranchCode: 0000,
    ReceiverAccountType: savings,
    EndToEndID: E35547753202408201432u34sDGd19lz,
    ReceiverKeyID: +5511285025604,
    Description: A Lannister always pays his debts,
    ReconciliationID: 12345678910,
    InitiatorTaxId: ,
    CashAmount: 0,
    CashierBankCode: ,
    CashierType: ,
    Tags: { lannister, war/123 },
    Method: staticQrcode,
    Fee: 0,
    Status: created,
    Flow: out,
    SenderBankCode: 35547753,
    Created: 08/05/2022 16:59:05,
    Updated: 08/05/2022 16:59:05,
    ID: 6510413743128576
)
  

import starkinfra

requests = starkinfra.pixrequest.create([
    starkinfra.PixRequest(
        amount=1000,
        external_id="my-external-id-1",
        end_to_end_id="E20018183202201011000r01",
        method="subscription",
        reconciliation_id="my-pull-request-reconciliation-id",
        sender_account_number="00000-0",
        sender_branch_code="0001",
        sender_account_type="checking",
        sender_name="Arya Stark",
        sender_tax_id="012.345.678-90",
        receiver_account_number="10000-0",
        receiver_account_type="checking",
        receiver_bank_code="20018183",
        receiver_tax_id="98.765.432/0001-10",
        receiver_branch_code="0001",
        receiver_name="Jon Snow",
        tags=["transfer", "pix"]
    )
])

for request in requests:
    print(request)
  

const starkinfra = require('starkinfra')

const requests = await starkinfra.pixRequest.create([
    {
        amount: 1000,
        externalId: "my-external-id-1",
        endToEndId: "E20018183202201011000r01",
        method: "subscription",
        reconciliationId: "my-pull-request-reconciliation-id",
        receiverBankCode: "20018183",
        receiverBranchCode: "0001",
        receiverAccountNumber: "10000-0",
        receiverAccountType: "checking",
        receiverName: "Jon Snow",
        receiverTaxId: "012.345.678-90",
        tags: ["transfer", "pix"]
    }
])

for (const request of requests) {
    console.log(request)
}
  

 1000,
        "externalId" => "my-external-id-1",
        "endToEndId" => "E20018183202201011000r01",
        "method" => "subscription",
        "reconciliationId" => "my-pull-request-reconciliation-id",
        "receiverBankCode" => "20018183",
        "receiverBranchCode" => "0001",
        "receiverAccountNumber" => "10000-0",
        "receiverAccountType" => "checking",
        "receiverName" => "Jon Snow",
        "receiverTaxId" => "012.345.678-90",
        "tags" => ["transfer", "pix"]
    ])
]);

foreach ($requests as $request) {
    print_r($request);
}
  

import com.starkinfra.*;
import java.util.Arrays;

List requests = PixRequest.create(
    Arrays.asList(
        new PixRequest.Builder()
            .amount(1000L)
            .externalId("my-external-id-1")
            .endToEndId("E20018183202201011000r01")
            .method("subscription")
            .reconciliationId("my-pull-request-reconciliation-id")
            .receiverBankCode("20018183")
            .receiverBranchCode("0001")
            .receiverAccountNumber("10000-0")
            .receiverAccountType("checking")
            .receiverName("Jon Snow")
            .receiverTaxId("012.345.678-90")
            .tags(Arrays.asList("transfer", "pix"))
            .build()
    )
);

for (PixRequest request : requests) {
    System.out.println(request);
}
  

require('starkinfra')

requests = StarkInfra::PixRequest.create([
    StarkInfra::PixRequest.new(
        amount: 1000,
        external_id: "my-external-id-1",
        end_to_end_id: "E20018183202201011000r01",
        method: "subscription",
        reconciliation_id: "my-pull-request-reconciliation-id",
        receiver_bank_code: "20018183",
        receiver_branch_code: "0001",
        receiver_account_number: "10000-0",
        receiver_account_type: "checking",
        receiver_name: "Jon Snow",
        receiver_tax_id: "012.345.678-90",
        tags: ["transfer", "pix"]
    )
])

requests.each do |request|
    puts request
end
  

requests = StarkInfra.PixRequest.create!([
    %StarkInfra.PixRequest{
        amount: 1000,
        external_id: "my-external-id-1",
        end_to_end_id: "E20018183202201011000r01",
        method: "subscription",
        reconciliation_id: "my-pull-request-reconciliation-id",
        receiver_bank_code: "20018183",
        receiver_branch_code: "0001",
        receiver_account_number: "10000-0",
        receiver_account_type: "checking",
        receiver_name: "Jon Snow",
        receiver_tax_id: "012.345.678-90",
        tags: ["transfer", "pix"]
    }
])

for request <- requests do
    IO.inspect(request)
end
  

using StarkInfra;
using System.Collections.Generic;

List requests = PixRequest.Create(
    new List {
        new PixRequest(
            amount: 1000,
            externalId: "my-external-id-1",
            endToEndId: "E20018183202201011000r01",
            method: "subscription",
            reconciliationId: "my-pull-request-reconciliation-id",
            receiverBankCode: "20018183",
            receiverBranchCode: "0001",
            receiverAccountNumber: "10000-0",
            receiverAccountType: "checking",
            receiverName: "Jon Snow",
            receiverTaxId: "012.345.678-90",
            tags: new List { "transfer", "pix" }
        )
    }
);

foreach (PixRequest request in requests) {
    Console.WriteLine(request);
}
  

package main

import (
    "fmt"
    PixRequest "github.com/starkinfra/sdk-go/starkinfra/pixrequest"
)

requests, err := PixRequest.Create(
    []PixRequest.PixRequest{
        {
            Amount:                1000,
            ExternalId:            "my-external-id-1",
            EndToEndId:            "E20018183202201011000r01",
            Method:                "subscription",
            ReconciliationId:      "my-pull-request-reconciliation-id",
            ReceiverBankCode:      "20018183",
            ReceiverBranchCode:    "0001",
            ReceiverAccountNumber: "10000-0",
            ReceiverAccountType:   "checking",
            ReceiverName:          "Jon Snow",
            ReceiverTaxId:         "012.345.678-90",
            Tags:                  []string{"transfer", "pix"},
        },
    }, nil)

for _, request := range requests {
    fmt.Println(request)
}
  

(def requests
    (starkinfra.pix-request/create
        [{:amount 1000
          :external-id "my-external-id-1"
          :end-to-end-id "E20018183202201011000r01"
          :method "subscription"
          :reconciliation-id "my-pull-request-reconciliation-id"
          :receiver-bank-code "20018183"
          :receiver-branch-code "0001"
          :receiver-account-number "10000-0"
          :receiver-account-type "checking"
          :receiver-name "Jon Snow"
          :receiver-tax-id "012.345.678-90"
          :tags ["transfer" "pix"]}]))

(doseq [request requests]
    (println request))
  

curl --location --request POST '{{baseUrl}}/v2/pix-request' \
--header 'Access-Id: {{accessId}}' \
--header 'Access-Time: {{accessTime}}' \
--header 'Access-Signature: {{accessSignature}}' \
--header 'Content-Type: application/json' \
--data-raw '{
    "requests": [
        {
            "amount": 1000,
            "externalId": "my-external-id-1",
            "endToEndId": "E20018183202201011000r01",
            "method": "subscription",
            "reconciliationId": "my-pull-request-reconciliation-id",
            "receiverBankCode": "20018183",
            "receiverBranchCode": "0001",
            "receiverAccountNumber": "10000-0",
            "receiverAccountType": "checking",
            "receiverName": "Jon Snow",
            "receiverTaxId": "012.345.678-90",
            "tags": ["transfer", "pix"]
        }
    ]
}'
  

import starkinfra

# map the received chargeback's reversal_* fields onto the receiver_* fields
requests = starkinfra.pixrequest.create([
    starkinfra.PixRequest(
        amount=1000,
        external_id="my-external-id-1",
        end_to_end_id="E20018183202201011000r01",
        sender_account_number="00000-0",
        sender_branch_code="0001",
        sender_account_type="checking",
        sender_name="Arya Stark",
        sender_tax_id="20.018.183/0001-80",
        receiver_bank_code=chargeback.reversal_bank_code,
        receiver_branch_code=chargeback.reversal_branch_code,
        receiver_account_number=chargeback.reversal_account_number,
        receiver_account_type=chargeback.reversal_account_type,
        receiver_tax_id=chargeback.reversal_tax_id,
        reason="fraud",
        tags=["chargeback", "pix"]
    )
])

for request in requests:
    print(request)
  

const starkinfra = require('starkinfra')

// map the received chargeback's reversal* fields onto the receiver* fields
const requests = await starkinfra.pixRequest.create([
    {
        amount: 1000,
        externalId: "my-external-id-1",
        endToEndId: "E20018183202201011000r01",
        senderAccountNumber: "00000-0",
        senderBranchCode: "0001",
        senderAccountType: "checking",
        senderName: "Arya Stark",
        senderTaxId: "20.018.183/0001-80",
        receiverBankCode: chargeback.reversalBankCode,
        receiverBranchCode: chargeback.reversalBranchCode,
        receiverAccountNumber: chargeback.reversalAccountNumber,
        receiverAccountType: chargeback.reversalAccountType,
        receiverTaxId: chargeback.reversalTaxId,
        reason: "fraud",
        tags: ["chargeback", "pix"]
    }
])

for (const request of requests) {
    console.log(request)
}
  

 1000,
        "externalId" => "my-external-id-1",
        "endToEndId" => "E20018183202201011000r01",
        "senderAccountNumber" => "00000-0",
        "senderBranchCode" => "0001",
        "senderAccountType" => "checking",
        "senderName" => "Arya Stark",
        "senderTaxId" => "20.018.183/0001-80",
        "receiverBankCode" => $chargeback->reversalBankCode,
        "receiverBranchCode" => $chargeback->reversalBranchCode,
        "receiverAccountNumber" => $chargeback->reversalAccountNumber,
        "receiverAccountType" => $chargeback->reversalAccountType,
        "receiverTaxId" => $chargeback->reversalTaxId,
        "reason" => "fraud",
        "tags" => ["chargeback", "pix"]
    ])
]);

foreach ($requests as $request) {
    print_r($request);
}
  

import com.starkinfra.*;
import java.util.Arrays;

// map the received chargeback's reversal* fields onto the receiver* fields
List requests = PixRequest.create(
    Arrays.asList(
        new PixRequest.Builder()
            .amount(1000L)
            .externalId("my-external-id-1")
            .endToEndId("E20018183202201011000r01")
            .senderAccountNumber("00000-0")
            .senderBranchCode("0001")
            .senderAccountType("checking")
            .senderName("Arya Stark")
            .senderTaxId("20.018.183/0001-80")
            .receiverBankCode(chargeback.reversalBankCode)
            .receiverBranchCode(chargeback.reversalBranchCode)
            .receiverAccountNumber(chargeback.reversalAccountNumber)
            .receiverAccountType(chargeback.reversalAccountType)
            .receiverTaxId(chargeback.reversalTaxId)
            .reason("fraud")
            .tags(Arrays.asList("chargeback", "pix"))
            .build()
    )
);

for (PixRequest request : requests) {
    System.out.println(request);
}
  

require('starkinfra')

# map the received chargeback's reversal_* fields onto the receiver_* fields
requests = StarkInfra::PixRequest.create([
    StarkInfra::PixRequest.new(
        amount: 1000,
        external_id: "my-external-id-1",
        end_to_end_id: "E20018183202201011000r01",
        sender_account_number: "00000-0",
        sender_branch_code: "0001",
        sender_account_type: "checking",
        sender_name: "Arya Stark",
        sender_tax_id: "20.018.183/0001-80",
        receiver_bank_code: chargeback.reversal_bank_code,
        receiver_branch_code: chargeback.reversal_branch_code,
        receiver_account_number: chargeback.reversal_account_number,
        receiver_account_type: chargeback.reversal_account_type,
        receiver_tax_id: chargeback.reversal_tax_id,
        reason: "fraud",
        tags: ["chargeback", "pix"]
    )
])

requests.each do |request|
    puts request
end
  

# map the received chargeback's reversal_* fields onto the receiver_* fields
requests = StarkInfra.PixRequest.create!([
    %StarkInfra.PixRequest{
        amount: 1000,
        external_id: "my-external-id-1",
        end_to_end_id: "E20018183202201011000r01",
        sender_account_number: "00000-0",
        sender_branch_code: "0001",
        sender_account_type: "checking",
        sender_name: "Arya Stark",
        sender_tax_id: "20.018.183/0001-80",
        receiver_bank_code: chargeback.reversal_bank_code,
        receiver_branch_code: chargeback.reversal_branch_code,
        receiver_account_number: chargeback.reversal_account_number,
        receiver_account_type: chargeback.reversal_account_type,
        receiver_tax_id: chargeback.reversal_tax_id,
        reason: "fraud",
        tags: ["chargeback", "pix"]
    }
])

for request <- requests do
    IO.inspect(request)
end
  

using StarkInfra;
using System.Collections.Generic;

// map the received chargeback's reversal* fields onto the receiver* fields
List requests = PixRequest.Create(
    new List {
        new PixRequest(
            amount: 1000,
            externalId: "my-external-id-1",
            endToEndId: "E20018183202201011000r01",
            senderAccountNumber: "00000-0",
            senderBranchCode: "0001",
            senderAccountType: "checking",
            senderName: "Arya Stark",
            senderTaxId: "20.018.183/0001-80",
            receiverBankCode: chargeback.ReversalBankCode,
            receiverBranchCode: chargeback.ReversalBranchCode,
            receiverAccountNumber: chargeback.ReversalAccountNumber,
            receiverAccountType: chargeback.ReversalAccountType,
            receiverTaxId: chargeback.ReversalTaxId,
            reason: "fraud",
            tags: new List { "chargeback", "pix" }
        )
    }
);

foreach (PixRequest request in requests) {
    Console.WriteLine(request);
}
  

package main

import (
    "fmt"
    PixRequest "github.com/starkinfra/sdk-go/starkinfra/pixrequest"
)

// map the received chargeback's Reversal* fields onto the Receiver* fields
requests, err := PixRequest.Create(
    []PixRequest.PixRequest{
        {
            Amount:                1000,
            ExternalId:            "my-external-id-1",
            EndToEndId:            "E20018183202201011000r01",
            SenderAccountNumber:   "00000-0",
            SenderBranchCode:      "0001",
            SenderAccountType:     "checking",
            SenderName:            "Arya Stark",
            SenderTaxId:           "20.018.183/0001-80",
            ReceiverBankCode:      chargeback.ReversalBankCode,
            ReceiverBranchCode:    chargeback.ReversalBranchCode,
            ReceiverAccountNumber: chargeback.ReversalAccountNumber,
            ReceiverAccountType:   chargeback.ReversalAccountType,
            ReceiverTaxId:         chargeback.ReversalTaxId,
            Reason:                "fraud",
            Tags:                  []string{"chargeback", "pix"},
        },
    }, nil)

for _, request := range requests {
    fmt.Println(request)
}
  

;; map the received chargeback's reversal-* fields onto the receiver-* fields
(def requests
    (starkinfra.pix-request/create
        [{:amount 1000
          :external-id "my-external-id-1"
          :end-to-end-id "E20018183202201011000r01"
          :sender-account-number "00000-0"
          :sender-branch-code "0001"
          :sender-account-type "checking"
          :sender-name "Arya Stark"
          :sender-tax-id "20.018.183/0001-80"
          :receiver-bank-code (:reversal-bank-code chargeback)
          :receiver-branch-code (:reversal-branch-code chargeback)
          :receiver-account-number (:reversal-account-number chargeback)
          :receiver-account-type (:reversal-account-type chargeback)
          :receiver-tax-id (:reversal-tax-id chargeback)
          :reason "fraud"
          :tags ["chargeback" "pix"]}]))

(doseq [request requests]
    (println request))
  

curl --location --request POST '{{baseUrl}}/v2/pix-request' \
--header 'Access-Id: {{accessId}}' \
--header 'Access-Time: {{accessTime}}' \
--header 'Access-Signature: {{accessSignature}}' \
--header 'Content-Type: application/json' \
--data-raw '{
    "requests": [
        {
            "amount": 1000,
            "externalId": "my-external-id-1",
            "endToEndId": "E20018183202201011000r01",
            "senderAccountNumber": "00000-0",
            "senderBranchCode": "0001",
            "senderAccountType": "checking",
            "senderName": "Arya Stark",
            "senderTaxId": "20.018.183/0001-80",
            "receiverBankCode": "20018183",
            "receiverBranchCode": "0001",
            "receiverAccountNumber": "10000-0",
            "receiverAccountType": "checking",
            "receiverTaxId": "98.765.432/0001-10",
            "reason": "fraud",
            "tags": ["chargeback", "pix"]
        }
    ]
}'
  

import starkinfra

requests = starkinfra.pixrequest.create([
    starkinfra.PixRequest(
        amount=10000,
        external_id="my-external-id-1",
        end_to_end_id="E20018183202201011000r01",
        cash_amount=1000,
        cashier_type="merchant",
        cashier_bank_code="20018183",
        sender_account_number="00000-0",
        sender_branch_code="0001",
        sender_account_type="checking",
        sender_name="Arya Stark",
        sender_tax_id="012.345.678-90",
        receiver_account_number="10000-0",
        receiver_account_type="checking",
        receiver_bank_code="20018183",
        receiver_tax_id="98.765.432/0001-10",
        receiver_branch_code="0001",
        receiver_name="Jon Snow",
        tags=["transfer", "pix"]
    )
])

for request in requests:
    print(request)
  

const starkinfra = require('starkinfra')

const requests = await starkinfra.pixRequest.create([
    {
        amount: 10000,
        externalId: "my-external-id-1",
        endToEndId: "E20018183202201011000r01",
        cashAmount: 1000,
        cashierType: "merchant",
        cashierBankCode: "20018183",
        receiverBankCode: "20018183",
        receiverBranchCode: "0001",
        receiverAccountNumber: "10000-0",
        receiverAccountType: "checking",
        receiverName: "Jon Snow",
        receiverTaxId: "012.345.678-90",
        tags: ["transfer", "pix"]
    }
])

for (const request of requests) {
    console.log(request)
}
  

 10000,
        "externalId" => "my-external-id-1",
        "endToEndId" => "E20018183202201011000r01",
        "cashAmount" => 1000,
        "cashierType" => "merchant",
        "cashierBankCode" => "20018183",
        "receiverBankCode" => "20018183",
        "receiverBranchCode" => "0001",
        "receiverAccountNumber" => "10000-0",
        "receiverAccountType" => "checking",
        "receiverName" => "Jon Snow",
        "receiverTaxId" => "012.345.678-90",
        "tags" => ["transfer", "pix"]
    ])
]);

foreach ($requests as $request) {
    print_r($request);
}
  

import com.starkinfra.*;
import java.util.Arrays;

List requests = PixRequest.create(
    Arrays.asList(
        new PixRequest.Builder()
            .amount(10000L)
            .externalId("my-external-id-1")
            .endToEndId("E20018183202201011000r01")
            .cashAmount(1000L)
            .cashierType("merchant")
            .cashierBankCode("20018183")
            .receiverBankCode("20018183")
            .receiverBranchCode("0001")
            .receiverAccountNumber("10000-0")
            .receiverAccountType("checking")
            .receiverName("Jon Snow")
            .receiverTaxId("012.345.678-90")
            .tags(Arrays.asList("transfer", "pix"))
            .build()
    )
);

for (PixRequest request : requests) {
    System.out.println(request);
}
  

require('starkinfra')

requests = StarkInfra::PixRequest.create([
    StarkInfra::PixRequest.new(
        amount: 10000,
        external_id: "my-external-id-1",
        end_to_end_id: "E20018183202201011000r01",
        cash_amount: 1000,
        cashier_type: "merchant",
        cashier_bank_code: "20018183",
        receiver_bank_code: "20018183",
        receiver_branch_code: "0001",
        receiver_account_number: "10000-0",
        receiver_account_type: "checking",
        receiver_name: "Jon Snow",
        receiver_tax_id: "012.345.678-90",
        tags: ["transfer", "pix"]
    )
])

requests.each do |request|
    puts request
end
  

requests = StarkInfra.PixRequest.create!([
    %StarkInfra.PixRequest{
        amount: 10000,
        external_id: "my-external-id-1",
        end_to_end_id: "E20018183202201011000r01",
        cash_amount: 1000,
        cashier_type: "merchant",
        cashier_bank_code: "20018183",
        receiver_bank_code: "20018183",
        receiver_branch_code: "0001",
        receiver_account_number: "10000-0",
        receiver_account_type: "checking",
        receiver_name: "Jon Snow",
        receiver_tax_id: "012.345.678-90",
        tags: ["transfer", "pix"]
    }
])

for request <- requests do
    IO.inspect(request)
end
  

using StarkInfra;
using System.Collections.Generic;

List requests = PixRequest.Create(
    new List {
        new PixRequest(
            amount: 10000,
            externalId: "my-external-id-1",
            endToEndId: "E20018183202201011000r01",
            cashAmount: 1000,
            cashierType: "merchant",
            cashierBankCode: "20018183",
            receiverBankCode: "20018183",
            receiverBranchCode: "0001",
            receiverAccountNumber: "10000-0",
            receiverAccountType: "checking",
            receiverName: "Jon Snow",
            receiverTaxId: "012.345.678-90",
            tags: new List { "transfer", "pix" }
        )
    }
);

foreach (PixRequest request in requests) {
    Console.WriteLine(request);
}
  

package main

import (
    "fmt"
    PixRequest "github.com/starkinfra/sdk-go/starkinfra/pixrequest"
)

requests, err := PixRequest.Create(
    []PixRequest.PixRequest{
        {
            Amount:                10000,
            ExternalId:            "my-external-id-1",
            EndToEndId:            "E20018183202201011000r01",
            CashAmount:            1000,
            CashierType:           "merchant",
            CashierBankCode:       "20018183",
            ReceiverBankCode:      "20018183",
            ReceiverBranchCode:    "0001",
            ReceiverAccountNumber: "10000-0",
            ReceiverAccountType:   "checking",
            ReceiverName:          "Jon Snow",
            ReceiverTaxId:         "012.345.678-90",
            Tags:                  []string{"transfer", "pix"},
        },
    }, nil)

for _, request := range requests {
    fmt.Println(request)
}
  

(def requests
    (starkinfra.pix-request/create
        [{:amount 10000
          :external-id "my-external-id-1"
          :end-to-end-id "E20018183202201011000r01"
          :cash-amount 1000
          :cashier-type "merchant"
          :cashier-bank-code "20018183"
          :receiver-bank-code "20018183"
          :receiver-branch-code "0001"
          :receiver-account-number "10000-0"
          :receiver-account-type "checking"
          :receiver-name "Jon Snow"
          :receiver-tax-id "012.345.678-90"
          :tags ["transfer" "pix"]}]))

(doseq [request requests]
    (println request))
  

curl --location --request POST '{{baseUrl}}/v2/pix-request' \
--header 'Access-Id: {{accessId}}' \
--header 'Access-Time: {{accessTime}}' \
--header 'Access-Signature: {{accessSignature}}' \
--header 'Content-Type: application/json' \
--data-raw '{
    "requests": [
        {
            "amount": 10000,
            "externalId": "my-external-id-1",
            "endToEndId": "E20018183202201011000r01",
            "cashAmount": 1000,
            "cashierType": "merchant",
            "cashierBankCode": "20018183",
            "receiverBankCode": "20018183",
            "receiverBranchCode": "0001",
            "receiverAccountNumber": "10000-0",
            "receiverAccountType": "checking",
            "receiverName": "Jon Snow",
            "receiverTaxId": "012.345.678-90",
            "tags": ["transfer", "pix"]
        }
    ]
}'
  

import starkinfra

requests = starkinfra.pixrequest.create([
    starkinfra.PixRequest(
        amount=1000,
        external_id="my-external-id-1",
        end_to_end_id="E20018183202201011000r01",
        initiator_tax_id="20.018.183/0001-80",
        sender_account_number="00000-0",
        sender_branch_code="0001",
        sender_account_type="checking",
        sender_name="Arya Stark",
        sender_tax_id="012.345.678-90",
        receiver_account_number="10000-0",
        receiver_account_type="checking",
        receiver_bank_code="20018183",
        receiver_tax_id="98.765.432/0001-10",
        receiver_branch_code="0001",
        receiver_name="Jon Snow",
        tags=["transfer", "pix"]
    )
])

for request in requests:
    print(request)
  

const starkinfra = require('starkinfra')

const requests = await starkinfra.pixRequest.create([
    {
        amount: 1000,
        externalId: "my-external-id-1",
        endToEndId: "E20018183202201011000r01",
        initiatorTaxId: "20.018.183/0001-80",
        receiverBankCode: "20018183",
        receiverBranchCode: "0001",
        receiverAccountNumber: "10000-0",
        receiverAccountType: "checking",
        receiverName: "Jon Snow",
        receiverTaxId: "012.345.678-90",
        tags: ["transfer", "pix"]
    }
])

for (const request of requests) {
    console.log(request)
}
  

 1000,
        "externalId" => "my-external-id-1",
        "endToEndId" => "E20018183202201011000r01",
        "initiatorTaxId" => "20.018.183/0001-80",
        "receiverBankCode" => "20018183",
        "receiverBranchCode" => "0001",
        "receiverAccountNumber" => "10000-0",
        "receiverAccountType" => "checking",
        "receiverName" => "Jon Snow",
        "receiverTaxId" => "012.345.678-90",
        "tags" => ["transfer", "pix"]
    ])
]);

foreach ($requests as $request) {
    print_r($request);
}
  

import com.starkinfra.*;
import java.util.Arrays;

List requests = PixRequest.create(
    Arrays.asList(
        new PixRequest.Builder()
            .amount(1000L)
            .externalId("my-external-id-1")
            .endToEndId("E20018183202201011000r01")
            .initiatorTaxId("20.018.183/0001-80")
            .receiverBankCode("20018183")
            .receiverBranchCode("0001")
            .receiverAccountNumber("10000-0")
            .receiverAccountType("checking")
            .receiverName("Jon Snow")
            .receiverTaxId("012.345.678-90")
            .tags(Arrays.asList("transfer", "pix"))
            .build()
    )
);

for (PixRequest request : requests) {
    System.out.println(request);
}
  

require('starkinfra')

requests = StarkInfra::PixRequest.create([
    StarkInfra::PixRequest.new(
        amount: 1000,
        external_id: "my-external-id-1",
        end_to_end_id: "E20018183202201011000r01",
        initiator_tax_id: "20.018.183/0001-80",
        receiver_bank_code: "20018183",
        receiver_branch_code: "0001",
        receiver_account_number: "10000-0",
        receiver_account_type: "checking",
        receiver_name: "Jon Snow",
        receiver_tax_id: "012.345.678-90",
        tags: ["transfer", "pix"]
    )
])

requests.each do |request|
    puts request
end
  

requests = StarkInfra.PixRequest.create!([
    %StarkInfra.PixRequest{
        amount: 1000,
        external_id: "my-external-id-1",
        end_to_end_id: "E20018183202201011000r01",
        initiator_tax_id: "20.018.183/0001-80",
        receiver_bank_code: "20018183",
        receiver_branch_code: "0001",
        receiver_account_number: "10000-0",
        receiver_account_type: "checking",
        receiver_name: "Jon Snow",
        receiver_tax_id: "012.345.678-90",
        tags: ["transfer", "pix"]
    }
])

for request <- requests do
    IO.inspect(request)
end
  

using StarkInfra;
using System.Collections.Generic;

List requests = PixRequest.Create(
    new List {
        new PixRequest(
            amount: 1000,
            externalId: "my-external-id-1",
            endToEndId: "E20018183202201011000r01",
            initiatorTaxId: "20.018.183/0001-80",
            receiverBankCode: "20018183",
            receiverBranchCode: "0001",
            receiverAccountNumber: "10000-0",
            receiverAccountType: "checking",
            receiverName: "Jon Snow",
            receiverTaxId: "012.345.678-90",
            tags: new List { "transfer", "pix" }
        )
    }
);

foreach (PixRequest request in requests) {
    Console.WriteLine(request);
}
  

package main

import (
    "fmt"
    PixRequest "github.com/starkinfra/sdk-go/starkinfra/pixrequest"
)

requests, err := PixRequest.Create(
    []PixRequest.PixRequest{
        {
            Amount:                1000,
            ExternalId:            "my-external-id-1",
            EndToEndId:            "E20018183202201011000r01",
            InitiatorTaxId:        "20.018.183/0001-80",
            ReceiverBankCode:      "20018183",
            ReceiverBranchCode:    "0001",
            ReceiverAccountNumber: "10000-0",
            ReceiverAccountType:   "checking",
            ReceiverName:          "Jon Snow",
            ReceiverTaxId:         "012.345.678-90",
            Tags:                  []string{"transfer", "pix"},
        },
    }, nil)

for _, request := range requests {
    fmt.Println(request)
}
  

(def requests
    (starkinfra.pix-request/create
        [{:amount 1000
          :external-id "my-external-id-1"
          :end-to-end-id "E20018183202201011000r01"
          :initiator-tax-id "20.018.183/0001-80"
          :receiver-bank-code "20018183"
          :receiver-branch-code "0001"
          :receiver-account-number "10000-0"
          :receiver-account-type "checking"
          :receiver-name "Jon Snow"
          :receiver-tax-id "012.345.678-90"
          :tags ["transfer" "pix"]}]))

(doseq [request requests]
    (println request))
  

curl --location --request POST '{{baseUrl}}/v2/pix-request' \
--header 'Access-Id: {{accessId}}' \
--header 'Access-Time: {{accessTime}}' \
--header 'Access-Signature: {{accessSignature}}' \
--header 'Content-Type: application/json' \
--data-raw '{
    "requests": [
        {
            "amount": 1000,
            "externalId": "my-external-id-1",
            "endToEndId": "E20018183202201011000r01",
            "initiatorTaxId": "20.018.183/0001-80",
            "receiverBankCode": "20018183",
            "receiverBranchCode": "0001",
            "receiverAccountNumber": "10000-0",
            "receiverAccountType": "checking",
            "receiverName": "Jon Snow",
            "receiverTaxId": "012.345.678-90",
            "tags": ["transfer", "pix"]
        }
    ]
}'
  

import starkinfra

requests = starkinfra.pixrequest.query(
    limit=10,
    after="2022-01-01",
    before="2022-12-31",
    status=["success"],
    tags=["pix"]
)

for request in requests:
    print(request)
  

const starkinfra = require('starkinfra')

const requests = await starkinfra.pixRequest.query({
    limit: 10,
    after: "2022-01-01",
    before: "2022-12-31",
    status: "success",
    flow: "out",
    tags: ["pix"]
})

for await (const request of requests) {
    console.log(request)
}
  

 10,
    "after" => "2022-01-01",
    "before" => "2022-12-31",
    "status" => "success",
    "flow" => "out",
    "tags" => ["pix"]
]);

foreach ($requests as $request) {
    print_r($request);
}
  

import com.starkinfra.*;
import java.util.HashMap;

HashMap params = new HashMap<>();
params.put("limit", 10);
params.put("after", "2022-01-01");
params.put("before", "2022-12-31");
params.put("status", "success");
params.put("flow", "out");

Generator requests = PixRequest.query(params);

for (PixRequest request : requests) {
    System.out.println(request);
}
  

require('starkinfra')

requests = StarkInfra::PixRequest.query(
    limit: 10,
    after: "2022-01-01",
    before: "2022-12-31",
    status: "success",
    flow: "out",
    tags: ["pix"]
)

requests.each do |request|
    puts request
end
  

requests = StarkInfra.PixRequest.query!(
    limit: 10,
    after: "2022-01-01",
    before: "2022-12-31",
    status: "success",
    flow: "out",
    tags: ["pix"]
)

for request <- requests do
    IO.inspect(request)
end
  

using StarkInfra;

IEnumerable requests = PixRequest.Query(
    limit: 10,
    after: new DateTime(2022, 1, 1),
    before: new DateTime(2022, 12, 31),
    status: "success",
    flow: "out",
    tags: new List { "pix" }
);

foreach (PixRequest request in requests) {
    Console.WriteLine(request);
}
  

package main

import (
    "fmt"
    PixRequest "github.com/starkinfra/sdk-go/starkinfra/pixrequest"
)

var params = map[string]interface{}{
    "limit":  10,
    "after":  "2022-01-01",
    "before": "2022-12-31",
    "status": "success",
    "flow":   "out",
}

requests := PixRequest.Query(params, nil)

for request := range requests {
    fmt.Println(request)
}
  

(def requests
    (starkinfra.pix-request/query {
        :limit 10
        :after "2022-01-01"
        :before "2022-12-31"
        :status "success"
        :flow "out"
        :tags ["pix"]
    }))

(doseq [request requests]
    (println request))
  

curl --location --request GET '{{baseUrl}}/v2/pix-request?limit=10&after=2022-01-01&before=2022-12-31&status=success&flow=out' \
--header 'Access-Id: {{accessId}}' \
--header 'Access-Time: {{accessTime}}' \
--header 'Access-Signature: {{accessSignature}}'
  

PixRequest(
    id="5656565656565656",
    amount=1000,
    end_to_end_id="E20018183202201011000r01",
    fee=0,
    flow="out",
    method="manual",
    status="success",
    tags=["pix"],
    priority="high",
    reason="customerRequest",
    created="2022-01-01T00:00:00+00:00",
    updated="2022-01-01T00:00:00+00:00"
)
  

{
    id: "5656565656565656",
    amount: 1000,
    status: "success",
    flow: "out",
    tags: ["pix"],
    created: "2022-01-01T00:00:00+00:00",
    updated: "2022-01-01T00:00:00+00:00"
}
  

PixRequest Object (
    [id] => 5656565656565656
    [amount] => 1000
    [status] => success
    [flow] => out
    [tags] => Array ( [0] => pix )
    [created] => 2022-01-01T00:00:00+00:00
    [updated] => 2022-01-01T00:00:00+00:00
)
  

PixRequest(
    id=5656565656565656,
    amount=1000,
    status=success,
    flow=out,
    tags=[pix],
    created=2022-01-01T00:00:00+00:00,
    updated=2022-01-01T00:00:00+00:00
)
  

{
    id: "5656565656565656",
    amount: 1000,
    status: "success",
    flow: "out",
    tags: ["pix"],
    created: "2022-01-01T00:00:00+00:00",
    updated: "2022-01-01T00:00:00+00:00"
}
  

%StarkInfra.PixRequest{
    id: "5656565656565656",
    amount: 1000,
    status: "success",
    flow: "out",
    tags: ["pix"],
    created: "2022-01-01T00:00:00+00:00",
    updated: "2022-01-01T00:00:00+00:00"
}
  

PixRequest(
    id: "5656565656565656",
    amount: 1000,
    status: "success",
    flow: "out",
    tags: [ "pix" ],
    created: "2022-01-01T00:00:00+00:00",
    updated: "2022-01-01T00:00:00+00:00"
)
  

{
    Id: "5656565656565656",
    Amount: 1000,
    Status: "success",
    Flow: "out",
    Tags: ["pix"],
    Created: "2022-01-01T00:00:00+00:00",
    Updated: "2022-01-01T00:00:00+00:00"
}
  

{:id "5656565656565656"
 :amount 1000
 :status "success"
 :flow "out"
 :tags ["pix"]
 :created "2022-01-01T00:00:00+00:00"
 :updated "2022-01-01T00:00:00+00:00"}
  

{
    "cursor": null,
    "requests": [
        {
            "id": "5656565656565656",
            "amount": 1000,
            "status": "success",
            "flow": "out",
            "tags": ["pix"],
            "created": "2022-01-01T00:00:00+00:00",
            "updated": "2022-01-01T00:00:00+00:00"
        }
    ]
}
  

import starkinfra

request = starkinfra.pixrequest.get("5656565656565656")

print(request)
  

const starkinfra = require('starkinfra')

const request = await starkinfra.pixRequest.get("5656565656565656")

console.log(request)
  

import com.starkinfra.*;

PixRequest request = PixRequest.get("5656565656565656");

System.out.println(request);
  

require('starkinfra')

request = StarkInfra::PixRequest.get("5656565656565656")

puts request
  

request = StarkInfra.PixRequest.get!("5656565656565656")

IO.inspect(request)
  

using StarkInfra;

PixRequest request = PixRequest.Get("5656565656565656");

Console.WriteLine(request);
  

package main

import (
    "fmt"
    PixRequest "github.com/starkinfra/sdk-go/starkinfra/pixrequest"
)

request, err := PixRequest.Get("5656565656565656", nil)

fmt.Println(request)
  

(def request
    (starkinfra.pix-request/get "5656565656565656"))

(println request)
  

curl --location --request GET '{{baseUrl}}/v2/pix-request/5656565656565656' \
--header 'Access-Id: {{accessId}}' \
--header 'Access-Time: {{accessTime}}' \
--header 'Access-Signature: {{accessSignature}}'
  

PixRequest(
    id="5656565656565656",
    amount=1000,
    end_to_end_id="E20018183202201011000r01",
    fee=0,
    flow="out",
    method="manual",
    external_id="my-external-id-1",
    initiator_tax_id="",
    receiver_bank_code="20018183",
    receiver_branch_code="0001",
    receiver_account_number="10000-0",
    receiver_account_type="checking",
    receiver_name="Jon Snow",
    receiver_tax_id="98.765.432/0001-10",
    sender_bank_code="34052649",
    sender_branch_code="0001",
    sender_account_number="00000-0",
    sender_account_type="checking",
    sender_name="Arya Stark",
    sender_tax_id="012.345.678-90",
    status="success",
    tags=["pix"],
    description="",
    reconciliation_id="",
    cash_amount=0,
    cashier_type="",
    cashier_bank_code="",
    priority="high",
    reason="customerRequest",
    created="2022-01-01T00:00:00+00:00",
    updated="2022-01-01T00:00:00+00:00"
)
  

{
    id: "5656565656565656",
    amount: 1000,
    externalId: "my-external-id-1",
    receiverBankCode: "20018183",
    receiverBranchCode: "0001",
    receiverAccountNumber: "10000-0",
    receiverAccountType: "checking",
    receiverName: "Jon Snow",
    receiverTaxId: "012.345.678-90",
    status: "success",
    flow: "out",
    tags: ["pix"],
    created: "2022-01-01T00:00:00+00:00",
    updated: "2022-01-01T00:00:00+00:00"
}
  

PixRequest Object (
    [id] => 5656565656565656
    [amount] => 1000
    [externalId] => my-external-id-1
    [receiverBankCode] => 20018183
    [receiverBranchCode] => 0001
    [receiverAccountNumber] => 10000-0
    [receiverAccountType] => checking
    [receiverName] => Jon Snow
    [receiverTaxId] => 012.345.678-90
    [status] => success
    [flow] => out
    [tags] => Array ( [0] => pix )
    [created] => 2022-01-01T00:00:00+00:00
    [updated] => 2022-01-01T00:00:00+00:00
)
  

PixRequest(
    id=5656565656565656,
    amount=1000,
    externalId=my-external-id-1,
    receiverBankCode=20018183,
    receiverBranchCode=0001,
    receiverAccountNumber=10000-0,
    receiverAccountType=checking,
    receiverName=Jon Snow,
    receiverTaxId=012.345.678-90,
    status=success,
    flow=out,
    tags=[pix],
    created=2022-01-01T00:00:00+00:00,
    updated=2022-01-01T00:00:00+00:00
)
  

{
    id: "5656565656565656",
    amount: 1000,
    external_id: "my-external-id-1",
    receiver_bank_code: "20018183",
    receiver_branch_code: "0001",
    receiver_account_number: "10000-0",
    receiver_account_type: "checking",
    receiver_name: "Jon Snow",
    receiver_tax_id: "012.345.678-90",
    status: "success",
    flow: "out",
    tags: ["pix"],
    created: "2022-01-01T00:00:00+00:00",
    updated: "2022-01-01T00:00:00+00:00"
}
  

%StarkInfra.PixRequest{
    id: "5656565656565656",
    amount: 1000,
    external_id: "my-external-id-1",
    receiver_bank_code: "20018183",
    receiver_branch_code: "0001",
    receiver_account_number: "10000-0",
    receiver_account_type: "checking",
    receiver_name: "Jon Snow",
    receiver_tax_id: "012.345.678-90",
    status: "success",
    flow: "out",
    tags: ["pix"],
    created: "2022-01-01T00:00:00+00:00",
    updated: "2022-01-01T00:00:00+00:00"
}
  

PixRequest(
    id: "5656565656565656",
    amount: 1000,
    externalId: "my-external-id-1",
    receiverBankCode: "20018183",
    receiverBranchCode: "0001",
    receiverAccountNumber: "10000-0",
    receiverAccountType: "checking",
    receiverName: "Jon Snow",
    receiverTaxId: "012.345.678-90",
    status: "success",
    flow: "out",
    tags: [ "pix" ],
    created: "2022-01-01T00:00:00+00:00",
    updated: "2022-01-01T00:00:00+00:00"
)
  

{
    Id: "5656565656565656",
    Amount: 1000,
    ExternalId: "my-external-id-1",
    ReceiverBankCode: "20018183",
    ReceiverBranchCode: "0001",
    ReceiverAccountNumber: "10000-0",
    ReceiverAccountType: "checking",
    ReceiverName: "Jon Snow",
    ReceiverTaxId: "012.345.678-90",
    Status: "success",
    Flow: "out",
    Tags: ["pix"],
    Created: "2022-01-01T00:00:00+00:00",
    Updated: "2022-01-01T00:00:00+00:00"
}
  

{:id "5656565656565656"
 :amount 1000
 :external-id "my-external-id-1"
 :receiver-bank-code "20018183"
 :receiver-branch-code "0001"
 :receiver-account-number "10000-0"
 :receiver-account-type "checking"
 :receiver-name "Jon Snow"
 :receiver-tax-id "012.345.678-90"
 :status "success"
 :flow "out"
 :tags ["pix"]
 :created "2022-01-01T00:00:00+00:00"
 :updated "2022-01-01T00:00:00+00:00"}
  

{
    "request": {
        "id": "5656565656565656",
        "amount": 1000,
        "externalId": "my-external-id-1",
        "receiverBankCode": "20018183",
        "receiverBranchCode": "0001",
        "receiverAccountNumber": "10000-0",
        "receiverAccountType": "checking",
        "receiverName": "Jon Snow",
        "receiverTaxId": "012.345.678-90",
        "status": "success",
        "flow": "out",
        "tags": ["pix"],
        "created": "2022-01-01T00:00:00+00:00",
        "updated": "2022-01-01T00:00:00+00:00"
    }
}
  

import starkinfra

reversals = starkinfra.pixreversal.create([
    starkinfra.PixReversal(
        amount=1000,
        external_id="my-reversal-id-1",
        end_to_end_id="E20018183202201060100rq1feOMJqtZ",
        reason="fraud",
        description="reversing a fraudulent transfer",
        tags=["reversal", "pix"]
    )
])

for reversal in reversals:
    print(reversal)
  

const starkinfra = require('starkinfra')

const reversals = await starkinfra.pixReversal.create([
    {
        amount: 1000,
        externalId: "my-reversal-id-1",
        endToEndId: "E20018183202201060100rq1feOMJqtZ",
        reason: "fraud",
        tags: ["reversal", "pix"]
    }
])

for (const reversal of reversals) {
    console.log(reversal)
}
  

 1000,
        "externalId" => "my-reversal-id-1",
        "endToEndId" => "E20018183202201060100rq1feOMJqtZ",
        "reason" => "fraud",
        "tags" => ["reversal", "pix"]
    ])
]);

foreach ($reversals as $reversal) {
    print_r($reversal);
}
  

import com.starkinfra.*;
import java.util.Arrays;

List reversals = PixReversal.create(
    Arrays.asList(
        new PixReversal.Builder()
            .amount(1000L)
            .externalId("my-reversal-id-1")
            .endToEndId("E20018183202201060100rq1feOMJqtZ")
            .reason("fraud")
            .tags(Arrays.asList("reversal", "pix"))
            .build()
    )
);

for (PixReversal reversal : reversals) {
    System.out.println(reversal);
}
  

require('starkinfra')

reversals = StarkInfra::PixReversal.create([
    StarkInfra::PixReversal.new(
        amount: 1000,
        external_id: "my-reversal-id-1",
        end_to_end_id: "E20018183202201060100rq1feOMJqtZ",
        reason: "fraud",
        tags: ["reversal", "pix"]
    )
])

reversals.each do |reversal|
    puts reversal
end
  

reversals = StarkInfra.PixReversal.create!([
    %StarkInfra.PixReversal{
        amount: 1000,
        external_id: "my-reversal-id-1",
        end_to_end_id: "E20018183202201060100rq1feOMJqtZ",
        reason: "fraud",
        tags: ["reversal", "pix"]
    }
])

for reversal <- reversals do
    IO.inspect(reversal)
end
  

using StarkInfra;
using System.Collections.Generic;

List reversals = PixReversal.Create(
    new List {
        new PixReversal(
            amount: 1000,
            externalId: "my-reversal-id-1",
            endToEndId: "E20018183202201060100rq1feOMJqtZ",
            reason: "fraud",
            tags: new List { "reversal", "pix" }
        )
    }
);

foreach (PixReversal reversal in reversals) {
    Console.WriteLine(reversal);
}
  

package main

import (
    "fmt"
    PixReversal "github.com/starkinfra/sdk-go/starkinfra/pixreversal"
)

reversals, err := PixReversal.Create(
    []PixReversal.PixReversal{
        {
            Amount:      1000,
            ExternalId:  "my-reversal-id-1",
            EndToEndId:  "E20018183202201060100rq1feOMJqtZ",
            Reason:      "fraud",
            Tags:        []string{"reversal", "pix"},
        },
    }, nil)

for _, reversal := range reversals {
    fmt.Println(reversal)
}
  

(def reversals
    (starkinfra.pix-reversal/create
        [{:amount 1000
          :external-id "my-reversal-id-1"
          :end-to-end-id "E20018183202201060100rq1feOMJqtZ"
          :reason "fraud"
          :tags ["reversal" "pix"]}]))

(doseq [reversal reversals]
    (println reversal))
  

curl --location --request POST '{{baseUrl}}/v2/pix-reversal' \
--header 'Access-Id: {{accessId}}' \
--header 'Access-Time: {{accessTime}}' \
--header 'Access-Signature: {{accessSignature}}' \
--header 'Content-Type: application/json' \
--data-raw '{
    "reversals": [
        {
            "amount": 1000,
            "externalId": "my-reversal-id-1",
            "endToEndId": "E20018183202201060100rq1feOMJqtZ",
            "reason": "fraud",
            "tags": ["reversal", "pix"]
        }
    ]
}'
  

[
    PixReversal(
        id="5656565656565656",
        amount=1000,
        external_id="my-reversal-id-1",
        end_to_end_id="E20018183202201060100rq1feOMJqtZ",
        return_id="D20018183202202030109X3OoBHG74wo",
        reason="fraud",
        status="created",
        flow="out",
        fee=0,
        description="reversing a fraudulent transfer",
        tags=["reversal", "pix"],
        created="2022-01-01T00:00:00+00:00",
        updated="2022-01-01T00:00:00+00:00"
    )
]
  

[
    {
        id: "5656565656565656",
        amount: 1000,
        externalId: "my-reversal-id-1",
        endToEndId: "E20018183202201060100rq1feOMJqtZ",
        reason: "fraud",
        status: "created",
        flow: "out",
        tags: ["reversal", "pix"],
        created: "2022-01-01T00:00:00+00:00",
        updated: "2022-01-01T00:00:00+00:00"
    }
]
  

[
    PixReversal Object (
        [id] => 5656565656565656
        [amount] => 1000
        [externalId] => my-reversal-id-1
        [endToEndId] => E20018183202201060100rq1feOMJqtZ
        [reason] => fraud
        [status] => created
        [flow] => out
        [tags] => Array ( [0] => reversal [1] => pix )
        [created] => 2022-01-01T00:00:00+00:00
        [updated] => 2022-01-01T00:00:00+00:00
    )
]
  

[
    PixReversal(
        id=5656565656565656,
        amount=1000,
        externalId=my-reversal-id-1,
        endToEndId=E20018183202201060100rq1feOMJqtZ,
        reason=fraud,
        status=created,
        flow=out,
        tags=[reversal, pix],
        created=2022-01-01T00:00:00+00:00,
        updated=2022-01-01T00:00:00+00:00
    )
]
  

[
    starkinfra_pix_reversal: {
        id: "5656565656565656",
        amount: 1000,
        external_id: "my-reversal-id-1",
        end_to_end_id: "E20018183202201060100rq1feOMJqtZ",
        reason: "fraud",
        status: "created",
        flow: "out",
        tags: ["reversal", "pix"],
        created: "2022-01-01T00:00:00+00:00",
        updated: "2022-01-01T00:00:00+00:00"
    }
]
  

[
    %StarkInfra.PixReversal{
        id: "5656565656565656",
        amount: 1000,
        external_id: "my-reversal-id-1",
        end_to_end_id: "E20018183202201060100rq1feOMJqtZ",
        reason: "fraud",
        status: "created",
        flow: "out",
        tags: ["reversal", "pix"],
        created: "2022-01-01T00:00:00+00:00",
        updated: "2022-01-01T00:00:00+00:00"
    }
]
  

[
    PixReversal(
        id: "5656565656565656",
        amount: 1000,
        externalId: "my-reversal-id-1",
        endToEndId: "E20018183202201060100rq1feOMJqtZ",
        reason: "fraud",
        status: "created",
        flow: "out",
        tags: [ "reversal", "pix" ],
        created: "2022-01-01T00:00:00+00:00",
        updated: "2022-01-01T00:00:00+00:00"
    )
]
  

[
    {
        Id: "5656565656565656",
        Amount: 1000,
        ExternalId: "my-reversal-id-1",
        EndToEndId: "E20018183202201060100rq1feOMJqtZ",
        Reason: "fraud",
        Status: "created",
        Flow: "out",
        Tags: ["reversal", "pix"],
        Created: "2022-01-01T00:00:00+00:00",
        Updated: "2022-01-01T00:00:00+00:00"
    }
]
  

[
    {:id "5656565656565656"
     :amount 1000
     :external-id "my-reversal-id-1"
     :end-to-end-id "E20018183202201060100rq1feOMJqtZ"
     :reason "fraud"
     :status "created"
     :flow "out"
     :tags ["reversal" "pix"]
     :created "2022-01-01T00:00:00+00:00"
     :updated "2022-01-01T00:00:00+00:00"}
]
  

{
    "reversals": [
        {
            "id": "5656565656565656",
            "amount": 1000,
            "externalId": "my-reversal-id-1",
            "endToEndId": "E20018183202201060100rq1feOMJqtZ",
            "reason": "fraud",
            "status": "created",
            "flow": "out",
            "tags": ["reversal", "pix"],
            "created": "2022-01-01T00:00:00+00:00",
            "updated": "2022-01-01T00:00:00+00:00"
        }
    ]
}
  

import starkinfra

reversals = starkinfra.pixreversal.query(
    limit=10,
    after="2022-01-01",
    before="2022-12-31",
    status=["success"],
    external_ids=["my-reversal-id-1"],
    tags=["pix"]
)

for reversal in reversals:
    print(reversal)
  

const starkinfra = require('starkinfra')

const reversals = await starkinfra.pixReversal.query({
    limit: 10,
    after: "2022-01-01",
    before: "2022-12-31",
    status: "success",
    flow: "out",
    tags: ["pix"]
})

for await (const reversal of reversals) {
    console.log(reversal)
}
  

 10,
    "after" => "2022-01-01",
    "before" => "2022-12-31",
    "status" => "success",
    "flow" => "out",
    "tags" => ["pix"]
]);

foreach ($reversals as $reversal) {
    print_r($reversal);
}
  

import com.starkinfra.*;
import java.util.HashMap;

HashMap params = new HashMap<>();
params.put("limit", 10);
params.put("after", "2022-01-01");
params.put("before", "2022-12-31");
params.put("status", "success");
params.put("flow", "out");

Generator reversals = PixReversal.query(params);

for (PixReversal reversal : reversals) {
    System.out.println(reversal);
}
  

require('starkinfra')

reversals = StarkInfra::PixReversal.query(
    limit: 10,
    after: "2022-01-01",
    before: "2022-12-31",
    status: "success",
    flow: "out",
    tags: ["pix"]
)

reversals.each do |reversal|
    puts reversal
end
  

reversals = StarkInfra.PixReversal.query!(
    limit: 10,
    after: "2022-01-01",
    before: "2022-12-31",
    status: "success",
    flow: "out",
    tags: ["pix"]
)

for reversal <- reversals do
    IO.inspect(reversal)
end
  

using StarkInfra;

IEnumerable reversals = PixReversal.Query(
    limit: 10,
    after: new DateTime(2022, 1, 1),
    before: new DateTime(2022, 12, 31),
    status: "success",
    flow: "out",
    tags: new List { "pix" }
);

foreach (PixReversal reversal in reversals) {
    Console.WriteLine(reversal);
}
  

package main

import (
    "fmt"
    PixReversal "github.com/starkinfra/sdk-go/starkinfra/pixreversal"
)

var params = map[string]interface{}{
    "limit":  10,
    "after":  "2022-01-01",
    "before": "2022-12-31",
    "status": "success",
    "flow":   "out",
}

reversals := PixReversal.Query(params, nil)

for reversal := range reversals {
    fmt.Println(reversal)
}
  

(def reversals
    (starkinfra.pix-reversal/query {
        :limit 10
        :after "2022-01-01"
        :before "2022-12-31"
        :status "success"
        :flow "out"
        :tags ["pix"]
    }))

(doseq [reversal reversals]
    (println reversal))
  

curl --location --request GET '{{baseUrl}}/v2/pix-reversal?limit=10&after=2022-01-01&before=2022-12-31&status=success&flow=out' \
--header 'Access-Id: {{accessId}}' \
--header 'Access-Time: {{accessTime}}' \
--header 'Access-Signature: {{accessSignature}}'
  

PixReversal(
    id="5656565656565656",
    amount=1000,
    external_id="my-reversal-id-1",
    end_to_end_id="E20018183202201060100rq1feOMJqtZ",
    return_id="D20018183202202030109X3OoBHG74wo",
    reason="fraud",
    status="success",
    flow="out",
    fee=0,
    description="reversing a fraudulent transfer",
    tags=["pix"],
    created="2022-01-01T00:00:00+00:00",
    updated="2022-01-01T00:00:00+00:00"
)
  

{
    id: "5656565656565656",
    amount: 1000,
    status: "success",
    flow: "out",
    tags: ["pix"],
    created: "2022-01-01T00:00:00+00:00",
    updated: "2022-01-01T00:00:00+00:00"
}
  

PixReversal Object (
    [id] => 5656565656565656
    [amount] => 1000
    [status] => success
    [flow] => out
    [tags] => Array ( [0] => pix )
    [created] => 2022-01-01T00:00:00+00:00
    [updated] => 2022-01-01T00:00:00+00:00
)
  

PixReversal(
    id=5656565656565656,
    amount=1000,
    status=success,
    flow=out,
    tags=[pix],
    created=2022-01-01T00:00:00+00:00,
    updated=2022-01-01T00:00:00+00:00
)
  

{
    id: "5656565656565656",
    amount: 1000,
    status: "success",
    flow: "out",
    tags: ["pix"],
    created: "2022-01-01T00:00:00+00:00",
    updated: "2022-01-01T00:00:00+00:00"
}
  

%StarkInfra.PixReversal{
    id: "5656565656565656",
    amount: 1000,
    status: "success",
    flow: "out",
    tags: ["pix"],
    created: "2022-01-01T00:00:00+00:00",
    updated: "2022-01-01T00:00:00+00:00"
}
  

PixReversal(
    id: "5656565656565656",
    amount: 1000,
    status: "success",
    flow: "out",
    tags: [ "pix" ],
    created: "2022-01-01T00:00:00+00:00",
    updated: "2022-01-01T00:00:00+00:00"
)
  

{
    Id: "5656565656565656",
    Amount: 1000,
    Status: "success",
    Flow: "out",
    Tags: ["pix"],
    Created: "2022-01-01T00:00:00+00:00",
    Updated: "2022-01-01T00:00:00+00:00"
}
  

{:id "5656565656565656"
 :amount 1000
 :status "success"
 :flow "out"
 :tags ["pix"]
 :created "2022-01-01T00:00:00+00:00"
 :updated "2022-01-01T00:00:00+00:00"}
  

{
    "cursor": null,
    "reversals": [
        {
            "id": "5656565656565656",
            "amount": 1000,
            "status": "success",
            "flow": "out",
            "tags": ["pix"],
            "created": "2022-01-01T00:00:00+00:00",
            "updated": "2022-01-01T00:00:00+00:00"
        }
    ]
}
  

import starkinfra

reversal = starkinfra.pixreversal.get("5656565656565656")

print(reversal)
  

const starkinfra = require('starkinfra')

const reversal = await starkinfra.pixReversal.get("5656565656565656")

console.log(reversal)
  

import com.starkinfra.*;

PixReversal reversal = PixReversal.get("5656565656565656");

System.out.println(reversal);
  

require('starkinfra')

reversal = StarkInfra::PixReversal.get("5656565656565656")

puts reversal
  

reversal = StarkInfra.PixReversal.get!("5656565656565656")

IO.inspect(reversal)
  

using StarkInfra;

PixReversal reversal = PixReversal.Get("5656565656565656");

Console.WriteLine(reversal);
  

package main

import (
    "fmt"
    PixReversal "github.com/starkinfra/sdk-go/starkinfra/pixreversal"
)

reversal, err := PixReversal.Get("5656565656565656", nil)

fmt.Println(reversal)
  

(def reversal
    (starkinfra.pix-reversal/get "5656565656565656"))

(println reversal)
  

curl --location --request GET '{{baseUrl}}/v2/pix-reversal/5656565656565656' \
--header 'Access-Id: {{accessId}}' \
--header 'Access-Time: {{accessTime}}' \
--header 'Access-Signature: {{accessSignature}}'
  

PixReversal(
    id="5656565656565656",
    amount=1000,
    external_id="my-reversal-id-1",
    end_to_end_id="E20018183202201060100rq1feOMJqtZ",
    return_id="D20018183202202030109X3OoBHG74wo",
    reason="fraud",
    status="success",
    flow="out",
    fee=0,
    description="reversing a fraudulent transfer",
    tags=["pix"],
    created="2022-01-01T00:00:00+00:00",
    updated="2022-01-01T00:00:00+00:00"
)
  

{
    id: "5656565656565656",
    amount: 1000,
    externalId: "my-reversal-id-1",
    endToEndId: "E20018183202201060100rq1feOMJqtZ",
    reason: "fraud",
    status: "success",
    flow: "out",
    tags: ["pix"],
    created: "2022-01-01T00:00:00+00:00",
    updated: "2022-01-01T00:00:00+00:00"
}
  

PixReversal Object (
    [id] => 5656565656565656
    [amount] => 1000
    [externalId] => my-reversal-id-1
    [endToEndId] => E20018183202201060100rq1feOMJqtZ
    [reason] => fraud
    [status] => success
    [flow] => out
    [tags] => Array ( [0] => pix )
    [created] => 2022-01-01T00:00:00+00:00
    [updated] => 2022-01-01T00:00:00+00:00
)
  

PixReversal(
    id=5656565656565656,
    amount=1000,
    externalId=my-reversal-id-1,
    endToEndId=E20018183202201060100rq1feOMJqtZ,
    reason=fraud,
    status=success,
    flow=out,
    tags=[pix],
    created=2022-01-01T00:00:00+00:00,
    updated=2022-01-01T00:00:00+00:00
)
  

{
    id: "5656565656565656",
    amount: 1000,
    external_id: "my-reversal-id-1",
    end_to_end_id: "E20018183202201060100rq1feOMJqtZ",
    reason: "fraud",
    status: "success",
    flow: "out",
    tags: ["pix"],
    created: "2022-01-01T00:00:00+00:00",
    updated: "2022-01-01T00:00:00+00:00"
}
  

%StarkInfra.PixReversal{
    id: "5656565656565656",
    amount: 1000,
    external_id: "my-reversal-id-1",
    end_to_end_id: "E20018183202201060100rq1feOMJqtZ",
    reason: "fraud",
    status: "success",
    flow: "out",
    tags: ["pix"],
    created: "2022-01-01T00:00:00+00:00",
    updated: "2022-01-01T00:00:00+00:00"
}
  

PixReversal(
    id: "5656565656565656",
    amount: 1000,
    externalId: "my-reversal-id-1",
    endToEndId: "E20018183202201060100rq1feOMJqtZ",
    reason: "fraud",
    status: "success",
    flow: "out",
    tags: [ "pix" ],
    created: "2022-01-01T00:00:00+00:00",
    updated: "2022-01-01T00:00:00+00:00"
)
  

{
    Id: "5656565656565656",
    Amount: 1000,
    ExternalId: "my-reversal-id-1",
    EndToEndId: "E20018183202201060100rq1feOMJqtZ",
    Reason: "fraud",
    Status: "success",
    Flow: "out",
    Tags: ["pix"],
    Created: "2022-01-01T00:00:00+00:00",
    Updated: "2022-01-01T00:00:00+00:00"
}
  

{:id "5656565656565656"
 :amount 1000
 :external-id "my-reversal-id-1"
 :end-to-end-id "E20018183202201060100rq1feOMJqtZ"
 :reason "fraud"
 :status "success"
 :flow "out"
 :tags ["pix"]
 :created "2022-01-01T00:00:00+00:00"
 :updated "2022-01-01T00:00:00+00:00"}
  

{
    "reversal": {
        "id": "5656565656565656",
        "amount": 1000,
        "externalId": "my-reversal-id-1",
        "endToEndId": "E20018183202201060100rq1feOMJqtZ",
        "reason": "fraud",
        "status": "success",
        "flow": "out",
        "tags": ["pix"],
        "created": "2022-01-01T00:00:00+00:00",
        "updated": "2022-01-01T00:00:00+00:00"
    }
}
  

import starkinfra

reports = starkinfra.pixinternaltransactionreport.create([
    starkinfra.PixInternalTransactionReport(
        reference_type="request",
        amount=1000,
        end_to_end_id="E20018183202201011000r01",
        method="manual",
        created="2022-01-01T00:00:00+00:00",
        sender_bank_code="34052649",
        sender_branch_code="0001",
        sender_account_number="00000-0",
        sender_account_type="checking",
        sender_tax_id="012.345.678-90",
        receiver_bank_code="20018183",
        receiver_branch_code="0001",
        receiver_account_number="10000-0",
        receiver_account_type="checking",
        receiver_tax_id="20.018.183/0001-80",
        receiver_key_id="20.018.183/0001-80"
    )
])

for report in reports:
    print(report)
  

const starkinfra = require('starkinfra')

const reports = await starkinfra.pixInternalTransactionReport.create([
    {
        referenceType: "request",
        amount: 1000,
        endToEndId: "E20018183202201011000r01",
        method: "manual",
        created: "2022-01-01T00:00:00+00:00",
        senderBankCode: "34052649",
        senderBranchCode: "0001",
        senderAccountNumber: "00000-0",
        senderAccountType: "checking",
        senderTaxId: "012.345.678-90",
        receiverBankCode: "20018183",
        receiverBranchCode: "0001",
        receiverAccountNumber: "10000-0",
        receiverAccountType: "checking",
        receiverTaxId: "20.018.183/0001-80",
        receiverKeyId: "20.018.183/0001-80"
    }
])

for (const report of reports) {
    console.log(report)
}
  

 "request",
        "amount" => 1000,
        "endToEndId" => "E20018183202201011000r01",
        "method" => "manual",
        "created" => "2022-01-01T00:00:00+00:00",
        "senderBankCode" => "34052649",
        "senderBranchCode" => "0001",
        "senderAccountNumber" => "00000-0",
        "senderAccountType" => "checking",
        "senderTaxId" => "012.345.678-90",
        "receiverBankCode" => "20018183",
        "receiverBranchCode" => "0001",
        "receiverAccountNumber" => "10000-0",
        "receiverAccountType" => "checking",
        "receiverTaxId" => "20.018.183/0001-80",
        "receiverKeyId" => "20.018.183/0001-80"
    ])
]);

foreach ($reports as $report) {
    print_r($report);
}
  

import com.starkinfra.*;
import java.util.Arrays;

List reports = PixInternalTransactionReport.create(
    Arrays.asList(
        new PixInternalTransactionReport.Builder()
            .referenceType("request")
            .amount(1000L)
            .endToEndId("E20018183202201011000r01")
            .method("manual")
            .created("2022-01-01T00:00:00+00:00")
            .senderBankCode("34052649")
            .senderBranchCode("0001")
            .senderAccountNumber("00000-0")
            .senderAccountType("checking")
            .senderTaxId("012.345.678-90")
            .receiverBankCode("20018183")
            .receiverBranchCode("0001")
            .receiverAccountNumber("10000-0")
            .receiverAccountType("checking")
            .receiverTaxId("20.018.183/0001-80")
            .receiverKeyId("20.018.183/0001-80")
            .build()
    )
);

for (PixInternalTransactionReport report : reports) {
    System.out.println(report);
}
  

require('starkinfra')

reports = StarkInfra::PixInternalTransactionReport.create([
    StarkInfra::PixInternalTransactionReport.new(
        reference_type: "request",
        amount: 1000,
        end_to_end_id: "E20018183202201011000r01",
        method: "manual",
        created: "2022-01-01T00:00:00+00:00",
        sender_bank_code: "34052649",
        sender_branch_code: "0001",
        sender_account_number: "00000-0",
        sender_account_type: "checking",
        sender_tax_id: "012.345.678-90",
        receiver_bank_code: "20018183",
        receiver_branch_code: "0001",
        receiver_account_number: "10000-0",
        receiver_account_type: "checking",
        receiver_tax_id: "20.018.183/0001-80",
        receiver_key_id: "20.018.183/0001-80"
    )
])

reports.each do |report|
    puts report
end
  

reports = StarkInfra.PixInternalTransactionReport.create!([
    %StarkInfra.PixInternalTransactionReport{
        reference_type: "request",
        amount: 1000,
        end_to_end_id: "E20018183202201011000r01",
        method: "manual",
        created: "2022-01-01T00:00:00+00:00",
        sender_bank_code: "34052649",
        sender_branch_code: "0001",
        sender_account_number: "00000-0",
        sender_account_type: "checking",
        sender_tax_id: "012.345.678-90",
        receiver_bank_code: "20018183",
        receiver_branch_code: "0001",
        receiver_account_number: "10000-0",
        receiver_account_type: "checking",
        receiver_tax_id: "20.018.183/0001-80",
        receiver_key_id: "20.018.183/0001-80"
    }
])

for report <- reports do
    IO.inspect(report)
end
  

using StarkInfra;
using System.Collections.Generic;

List reports = PixInternalTransactionReport.Create(
    new List {
        new PixInternalTransactionReport(
            referenceType: "request",
            amount: 1000,
            endToEndId: "E20018183202201011000r01",
            method: "manual",
            created: "2022-01-01T00:00:00+00:00",
            senderBankCode: "34052649",
            senderBranchCode: "0001",
            senderAccountNumber: "00000-0",
            senderAccountType: "checking",
            senderTaxId: "012.345.678-90",
            receiverBankCode: "20018183",
            receiverBranchCode: "0001",
            receiverAccountNumber: "10000-0",
            receiverAccountType: "checking",
            receiverTaxId: "20.018.183/0001-80",
            receiverKeyId: "20.018.183/0001-80"
        )
    }
);

foreach (PixInternalTransactionReport report in reports) {
    Console.WriteLine(report);
}
  

package main

import (
    "fmt"
    PixInternalTransactionReport "github.com/starkinfra/sdk-go/starkinfra/pixinternaltransactionreport"
)

reports, err := PixInternalTransactionReport.Create(
    []PixInternalTransactionReport.PixInternalTransactionReport{
        {
            ReferenceType:         "request",
            Amount:                1000,
            EndToEndId:            "E20018183202201011000r01",
            Method:                "manual",
            Created:               "2022-01-01T00:00:00+00:00",
            SenderBankCode:        "34052649",
            SenderBranchCode:      "0001",
            SenderAccountNumber:   "00000-0",
            SenderAccountType:     "checking",
            SenderTaxId:           "012.345.678-90",
            ReceiverBankCode:      "20018183",
            ReceiverBranchCode:    "0001",
            ReceiverAccountNumber: "10000-0",
            ReceiverAccountType:   "checking",
            ReceiverTaxId:         "20.018.183/0001-80",
            ReceiverKeyId:         "20.018.183/0001-80",
        },
    }, nil)

for _, report := range reports {
    fmt.Println(report)
}
  

(def reports
    (starkinfra.pix-internal-transaction-report/create
        [{:reference-type "request"
          :amount 1000
          :end-to-end-id "E20018183202201011000r01"
          :method "manual"
          :created "2022-01-01T00:00:00+00:00"
          :sender-bank-code "34052649"
          :sender-branch-code "0001"
          :sender-account-number "00000-0"
          :sender-account-type "checking"
          :sender-tax-id "012.345.678-90"
          :receiver-bank-code "20018183"
          :receiver-branch-code "0001"
          :receiver-account-number "10000-0"
          :receiver-account-type "checking"
          :receiver-tax-id "20.018.183/0001-80"
          :receiver-key-id "20.018.183/0001-80"}]))

(doseq [report reports]
    (println report))
  

curl --location --request POST '{{baseUrl}}/v2/pix-internal-transaction-report' \
--header 'Access-Id: {{accessId}}' \
--header 'Access-Time: {{accessTime}}' \
--header 'Access-Signature: {{accessSignature}}' \
--header 'Content-Type: application/json' \
--data-raw '{
    "reports": [
        {
            "referenceType": "request",
            "amount": 1000,
            "endToEndId": "E20018183202201011000r01",
            "method": "manual",
            "created": "2022-01-01T00:00:00+00:00",
            "senderBankCode": "34052649",
            "senderBranchCode": "0001",
            "senderAccountNumber": "00000-0",
            "senderAccountType": "checking",
            "senderTaxId": "012.345.678-90",
            "receiverBankCode": "20018183",
            "receiverBranchCode": "0001",
            "receiverAccountNumber": "10000-0",
            "receiverAccountType": "checking",
            "receiverTaxId": "20.018.183/0001-80",
            "receiverKeyId": "20.018.183/0001-80"
        }
    ]
}'
  

[
    PixInternalTransactionReport(
        id="5656565656565656",
        reference_type="request",
        amount=1000,
        end_to_end_id="E20018183202201011000r01",
        return_id="",
        method="manual",
        sender_bank_code="34052649",
        sender_branch_code="0001",
        sender_account_number="00000-0",
        sender_account_type="checking",
        sender_tax_id="012.345.678-90",
        receiver_bank_code="20018183",
        receiver_branch_code="0001",
        receiver_account_number="10000-0",
        receiver_account_type="checking",
        receiver_tax_id="20.018.183/0001-80",
        receiver_key_id="20.018.183/0001-80",
        status="created",
        created="2022-01-01T00:00:00+00:00",
        updated="2022-01-01T00:00:00+00:00"
    )
]
  

[
    {
        id: "5656565656565656",
        referenceType: "request",
        amount: 1000,
        endToEndId: "E20018183202201011000r01",
        method: "manual",
        senderBankCode: "34052649",
        senderBranchCode: "0001",
        senderAccountNumber: "00000-0",
        senderAccountType: "checking",
        senderTaxId: "012.345.678-90",
        receiverBankCode: "20018183",
        receiverBranchCode: "0001",
        receiverAccountNumber: "10000-0",
        receiverAccountType: "checking",
        receiverTaxId: "20.018.183/0001-80",
        receiverKeyId: "20.018.183/0001-80",
        status: "created",
        created: "2022-01-01T00:00:00+00:00",
        updated: "2022-01-01T00:00:00+00:00"
    }
]
  

[
    PixInternalTransactionReport Object (
        [id] => 5656565656565656
        [referenceType] => request
        [amount] => 1000
        [endToEndId] => E20018183202201011000r01
        [method] => manual
        [senderBankCode] => 34052649
        [senderBranchCode] => 0001
        [senderAccountNumber] => 00000-0
        [senderAccountType] => checking
        [senderTaxId] => 012.345.678-90
        [receiverBankCode] => 20018183
        [receiverBranchCode] => 0001
        [receiverAccountNumber] => 10000-0
        [receiverAccountType] => checking
        [receiverTaxId] => 20.018.183/0001-80
        [receiverKeyId] => 20.018.183/0001-80
        [status] => created
        [created] => 2022-01-01T00:00:00+00:00
        [updated] => 2022-01-01T00:00:00+00:00
    )
]
  

[
    PixInternalTransactionReport(
        id=5656565656565656,
        referenceType=request,
        amount=1000,
        endToEndId=E20018183202201011000r01,
        method=manual,
        senderBankCode=34052649,
        senderBranchCode=0001,
        senderAccountNumber=00000-0,
        senderAccountType=checking,
        senderTaxId=012.345.678-90,
        receiverBankCode=20018183,
        receiverBranchCode=0001,
        receiverAccountNumber=10000-0,
        receiverAccountType=checking,
        receiverTaxId=20.018.183/0001-80,
        receiverKeyId=20.018.183/0001-80,
        status=created,
        created=2022-01-01T00:00:00+00:00,
        updated=2022-01-01T00:00:00+00:00
    )
]
  

[
    starkinfra_pix_internal_transaction_report: {
        id: "5656565656565656",
        reference_type: "request",
        amount: 1000,
        end_to_end_id: "E20018183202201011000r01",
        method: "manual",
        sender_bank_code: "34052649",
        sender_branch_code: "0001",
        sender_account_number: "00000-0",
        sender_account_type: "checking",
        sender_tax_id: "012.345.678-90",
        receiver_bank_code: "20018183",
        receiver_branch_code: "0001",
        receiver_account_number: "10000-0",
        receiver_account_type: "checking",
        receiver_tax_id: "20.018.183/0001-80",
        receiver_key_id: "20.018.183/0001-80",
        status: "created",
        created: "2022-01-01T00:00:00+00:00",
        updated: "2022-01-01T00:00:00+00:00"
    }
]
  

[
    %StarkInfra.PixInternalTransactionReport{
        id: "5656565656565656",
        reference_type: "request",
        amount: 1000,
        end_to_end_id: "E20018183202201011000r01",
        method: "manual",
        sender_bank_code: "34052649",
        sender_branch_code: "0001",
        sender_account_number: "00000-0",
        sender_account_type: "checking",
        sender_tax_id: "012.345.678-90",
        receiver_bank_code: "20018183",
        receiver_branch_code: "0001",
        receiver_account_number: "10000-0",
        receiver_account_type: "checking",
        receiver_tax_id: "20.018.183/0001-80",
        receiver_key_id: "20.018.183/0001-80",
        status: "created",
        created: "2022-01-01T00:00:00+00:00",
        updated: "2022-01-01T00:00:00+00:00"
    }
]
  

[
    PixInternalTransactionReport(
        id: "5656565656565656",
        referenceType: "request",
        amount: 1000,
        endToEndId: "E20018183202201011000r01",
        method: "manual",
        senderBankCode: "34052649",
        senderBranchCode: "0001",
        senderAccountNumber: "00000-0",
        senderAccountType: "checking",
        senderTaxId: "012.345.678-90",
        receiverBankCode: "20018183",
        receiverBranchCode: "0001",
        receiverAccountNumber: "10000-0",
        receiverAccountType: "checking",
        receiverTaxId: "20.018.183/0001-80",
        receiverKeyId: "20.018.183/0001-80",
        status: "created",
        created: "2022-01-01T00:00:00+00:00",
        updated: "2022-01-01T00:00:00+00:00"
    )
]
  

[
    {
        Id: "5656565656565656",
        ReferenceType: "request",
        Amount: 1000,
        EndToEndId: "E20018183202201011000r01",
        Method: "manual",
        SenderBankCode: "34052649",
        SenderBranchCode: "0001",
        SenderAccountNumber: "00000-0",
        SenderAccountType: "checking",
        SenderTaxId: "012.345.678-90",
        ReceiverBankCode: "20018183",
        ReceiverBranchCode: "0001",
        ReceiverAccountNumber: "10000-0",
        ReceiverAccountType: "checking",
        ReceiverTaxId: "20.018.183/0001-80",
        ReceiverKeyId: "20.018.183/0001-80",
        Status: "created",
        Created: "2022-01-01T00:00:00+00:00",
        Updated: "2022-01-01T00:00:00+00:00"
    }
]
  

[
    {:id "5656565656565656"
     :reference-type "request"
     :amount 1000
     :end-to-end-id "E20018183202201011000r01"
     :method "manual"
     :sender-bank-code "34052649"
     :sender-branch-code "0001"
     :sender-account-number "00000-0"
     :sender-account-type "checking"
     :sender-tax-id "012.345.678-90"
     :receiver-bank-code "20018183"
     :receiver-branch-code "0001"
     :receiver-account-number "10000-0"
     :receiver-account-type "checking"
     :receiver-tax-id "20.018.183/0001-80"
     :receiver-key-id "20.018.183/0001-80"
     :status "created"
     :created "2022-01-01T00:00:00+00:00"
     :updated "2022-01-01T00:00:00+00:00"}
]
  

{
    "reports": [
        {
            "id": "5656565656565656",
            "referenceType": "request",
            "amount": 1000,
            "endToEndId": "E20018183202201011000r01",
            "method": "manual",
            "senderBankCode": "34052649",
            "senderBranchCode": "0001",
            "senderAccountNumber": "00000-0",
            "senderAccountType": "checking",
            "senderTaxId": "012.345.678-90",
            "receiverBankCode": "20018183",
            "receiverBranchCode": "0001",
            "receiverAccountNumber": "10000-0",
            "receiverAccountType": "checking",
            "receiverTaxId": "20.018.183/0001-80",
            "receiverKeyId": "20.018.183/0001-80",
            "status": "created",
            "created": "2022-01-01T00:00:00+00:00",
            "updated": "2022-01-01T00:00:00+00:00"
        }
    ]
}
  

import starkinfra

reports = starkinfra.pixinternaltransactionreport.query(
    limit=10,
    after="2022-01-01",
    before="2022-12-31",
    status=["success"],
    ids=["5656565656565656"]
)

for report in reports:
    print(report)
  

const starkinfra = require('starkinfra')

const reports = await starkinfra.pixInternalTransactionReport.query({
    limit: 10,
    after: "2022-01-01",
    before: "2022-12-31",
    status: "success",
    ids: ["5656565656565656"]
})

for await (const report of reports) {
    console.log(report)
}
  

 10,
    "after" => "2022-01-01",
    "before" => "2022-12-31",
    "status" => "success",
    "ids" => ["5656565656565656"]
]);

foreach ($reports as $report) {
    print_r($report);
}
  

import com.starkinfra.*;
import java.util.HashMap;

HashMap params = new HashMap<>();
params.put("limit", 10);
params.put("after", "2022-01-01");
params.put("before", "2022-12-31");
params.put("status", "success");

Generator reports = PixInternalTransactionReport.query(params);

for (PixInternalTransactionReport report : reports) {
    System.out.println(report);
}
  

require('starkinfra')

reports = StarkInfra::PixInternalTransactionReport.query(
    limit: 10,
    after: "2022-01-01",
    before: "2022-12-31",
    status: "success",
    ids: ["5656565656565656"]
)

reports.each do |report|
    puts report
end
  

reports = StarkInfra.PixInternalTransactionReport.query!(
    limit: 10,
    after: "2022-01-01",
    before: "2022-12-31",
    status: "success",
    ids: ["5656565656565656"]
)

for report <- reports do
    IO.inspect(report)
end
  

using StarkInfra;

IEnumerable reports = PixInternalTransactionReport.Query(
    limit: 10,
    after: new DateTime(2022, 1, 1),
    before: new DateTime(2022, 12, 31),
    status: "success",
    ids: new List { "5656565656565656" }
);

foreach (PixInternalTransactionReport report in reports) {
    Console.WriteLine(report);
}
  

package main

import (
    "fmt"
    PixInternalTransactionReport "github.com/starkinfra/sdk-go/starkinfra/pixinternaltransactionreport"
)

var params = map[string]interface{}{
    "limit":  10,
    "after":  "2022-01-01",
    "before": "2022-12-31",
    "status": "success",
}

reports := PixInternalTransactionReport.Query(params, nil)

for report := range reports {
    fmt.Println(report)
}
  

(def reports
    (starkinfra.pix-internal-transaction-report/query {
        :limit 10
        :after "2022-01-01"
        :before "2022-12-31"
        :status "success"
        :ids ["5656565656565656"]
    }))

(doseq [report reports]
    (println report))
  

curl --location --request GET '{{baseUrl}}/v2/pix-internal-transaction-report?limit=10&after=2022-01-01&before=2022-12-31&status=success' \
--header 'Access-Id: {{accessId}}' \
--header 'Access-Time: {{accessTime}}' \
--header 'Access-Signature: {{accessSignature}}'
  

PixInternalTransactionReport(
    id="5656565656565656",
    reference_type="request",
    amount=1000,
    end_to_end_id="E20018183202201011000r01",
    method="manual",
    status="success",
    created="2022-01-01T00:00:00+00:00",
    updated="2022-01-01T00:00:00+00:00"
)
  

{
    id: "5656565656565656",
    referenceType: "request",
    amount: 1000,
    endToEndId: "E20018183202201011000r01",
    method: "manual",
    status: "success",
    created: "2022-01-01T00:00:00+00:00",
    updated: "2022-01-01T00:00:00+00:00"
}
  

PixInternalTransactionReport Object (
    [id] => 5656565656565656
    [referenceType] => request
    [amount] => 1000
    [endToEndId] => E20018183202201011000r01
    [method] => manual
    [status] => success
    [created] => 2022-01-01T00:00:00+00:00
    [updated] => 2022-01-01T00:00:00+00:00
)
  

PixInternalTransactionReport(
    id=5656565656565656,
    referenceType=request,
    amount=1000,
    endToEndId=E20018183202201011000r01,
    method=manual,
    status=success,
    created=2022-01-01T00:00:00+00:00,
    updated=2022-01-01T00:00:00+00:00
)
  

{
    id: "5656565656565656",
    reference_type: "request",
    amount: 1000,
    end_to_end_id: "E20018183202201011000r01",
    method: "manual",
    status: "success",
    created: "2022-01-01T00:00:00+00:00",
    updated: "2022-01-01T00:00:00+00:00"
}
  

%StarkInfra.PixInternalTransactionReport{
    id: "5656565656565656",
    reference_type: "request",
    amount: 1000,
    end_to_end_id: "E20018183202201011000r01",
    method: "manual",
    status: "success",
    created: "2022-01-01T00:00:00+00:00",
    updated: "2022-01-01T00:00:00+00:00"
}
  

PixInternalTransactionReport(
    id: "5656565656565656",
    referenceType: "request",
    amount: 1000,
    endToEndId: "E20018183202201011000r01",
    method: "manual",
    status: "success",
    created: "2022-01-01T00:00:00+00:00",
    updated: "2022-01-01T00:00:00+00:00"
)
  

{
    Id: "5656565656565656",
    ReferenceType: "request",
    Amount: 1000,
    EndToEndId: "E20018183202201011000r01",
    Method: "manual",
    Status: "success",
    Created: "2022-01-01T00:00:00+00:00",
    Updated: "2022-01-01T00:00:00+00:00"
}
  

{:id "5656565656565656"
 :reference-type "request"
 :amount 1000
 :end-to-end-id "E20018183202201011000r01"
 :method "manual"
 :status "success"
 :created "2022-01-01T00:00:00+00:00"
 :updated "2022-01-01T00:00:00+00:00"}
  

{
    "cursor": null,
    "reports": [
        {
            "id": "5656565656565656",
            "referenceType": "request",
            "amount": 1000,
            "endToEndId": "E20018183202201011000r01",
            "method": "manual",
            "status": "success",
            "created": "2022-01-01T00:00:00+00:00",
            "updated": "2022-01-01T00:00:00+00:00"
        }
    ]
}
  

import starkinfra

report = starkinfra.pixinternaltransactionreport.get("5656565656565656")

print(report)
  

const starkinfra = require('starkinfra')

const report = await starkinfra.pixInternalTransactionReport.get("5656565656565656")

console.log(report)
  

import com.starkinfra.*;

PixInternalTransactionReport report = PixInternalTransactionReport.get("5656565656565656");

System.out.println(report);
  

require('starkinfra')

report = StarkInfra::PixInternalTransactionReport.get("5656565656565656")

puts report
  

report = StarkInfra.PixInternalTransactionReport.get!("5656565656565656")

IO.inspect(report)
  

using StarkInfra;

PixInternalTransactionReport report = PixInternalTransactionReport.Get("5656565656565656");

Console.WriteLine(report);
  

package main

import (
    "fmt"
    PixInternalTransactionReport "github.com/starkinfra/sdk-go/starkinfra/pixinternaltransactionreport"
)

report, err := PixInternalTransactionReport.Get("5656565656565656", nil)

fmt.Println(report)
  

(def report
    (starkinfra.pix-internal-transaction-report/get "5656565656565656"))

(println report)
  

curl --location --request GET '{{baseUrl}}/v2/pix-internal-transaction-report/5656565656565656' \
--header 'Access-Id: {{accessId}}' \
--header 'Access-Time: {{accessTime}}' \
--header 'Access-Signature: {{accessSignature}}'
  

PixInternalTransactionReport(
    id="5656565656565656",
    reference_type="request",
    amount=1000,
    end_to_end_id="E20018183202201011000r01",
    return_id="",
    method="manual",
    sender_bank_code="34052649",
    sender_branch_code="0001",
    sender_account_number="00000-0",
    sender_account_type="checking",
    sender_tax_id="012.345.678-90",
    receiver_bank_code="20018183",
    receiver_branch_code="0001",
    receiver_account_number="10000-0",
    receiver_account_type="checking",
    receiver_tax_id="20.018.183/0001-80",
    receiver_key_id="20.018.183/0001-80",
    status="success",
    created="2022-01-01T00:00:00+00:00",
    updated="2022-01-01T00:00:00+00:00"
)
  

{
    id: "5656565656565656",
    referenceType: "request",
    amount: 1000,
    endToEndId: "E20018183202201011000r01",
    method: "manual",
    senderBankCode: "34052649",
    senderBranchCode: "0001",
    senderAccountNumber: "00000-0",
    senderAccountType: "checking",
    senderTaxId: "012.345.678-90",
    receiverBankCode: "20018183",
    receiverBranchCode: "0001",
    receiverAccountNumber: "10000-0",
    receiverAccountType: "checking",
    receiverTaxId: "20.018.183/0001-80",
    receiverKeyId: "20.018.183/0001-80",
    status: "success",
    created: "2022-01-01T00:00:00+00:00",
    updated: "2022-01-01T00:00:00+00:00"
}
  

PixInternalTransactionReport Object (
    [id] => 5656565656565656
    [referenceType] => request
    [amount] => 1000
    [endToEndId] => E20018183202201011000r01
    [method] => manual
    [senderBankCode] => 34052649
    [senderBranchCode] => 0001
    [senderAccountNumber] => 00000-0
    [senderAccountType] => checking
    [senderTaxId] => 012.345.678-90
    [receiverBankCode] => 20018183
    [receiverBranchCode] => 0001
    [receiverAccountNumber] => 10000-0
    [receiverAccountType] => checking
    [receiverTaxId] => 20.018.183/0001-80
    [receiverKeyId] => 20.018.183/0001-80
    [status] => success
    [created] => 2022-01-01T00:00:00+00:00
    [updated] => 2022-01-01T00:00:00+00:00
)
  

PixInternalTransactionReport(
    id=5656565656565656,
    referenceType=request,
    amount=1000,
    endToEndId=E20018183202201011000r01,
    method=manual,
    senderBankCode=34052649,
    senderBranchCode=0001,
    senderAccountNumber=00000-0,
    senderAccountType=checking,
    senderTaxId=012.345.678-90,
    receiverBankCode=20018183,
    receiverBranchCode=0001,
    receiverAccountNumber=10000-0,
    receiverAccountType=checking,
    receiverTaxId=20.018.183/0001-80,
    receiverKeyId=20.018.183/0001-80,
    status=success,
    created=2022-01-01T00:00:00+00:00,
    updated=2022-01-01T00:00:00+00:00
)
  

{
    id: "5656565656565656",
    reference_type: "request",
    amount: 1000,
    end_to_end_id: "E20018183202201011000r01",
    method: "manual",
    sender_bank_code: "34052649",
    sender_branch_code: "0001",
    sender_account_number: "00000-0",
    sender_account_type: "checking",
    sender_tax_id: "012.345.678-90",
    receiver_bank_code: "20018183",
    receiver_branch_code: "0001",
    receiver_account_number: "10000-0",
    receiver_account_type: "checking",
    receiver_tax_id: "20.018.183/0001-80",
    receiver_key_id: "20.018.183/0001-80",
    status: "success",
    created: "2022-01-01T00:00:00+00:00",
    updated: "2022-01-01T00:00:00+00:00"
}
  

%StarkInfra.PixInternalTransactionReport{
    id: "5656565656565656",
    reference_type: "request",
    amount: 1000,
    end_to_end_id: "E20018183202201011000r01",
    method: "manual",
    sender_bank_code: "34052649",
    sender_branch_code: "0001",
    sender_account_number: "00000-0",
    sender_account_type: "checking",
    sender_tax_id: "012.345.678-90",
    receiver_bank_code: "20018183",
    receiver_branch_code: "0001",
    receiver_account_number: "10000-0",
    receiver_account_type: "checking",
    receiver_tax_id: "20.018.183/0001-80",
    receiver_key_id: "20.018.183/0001-80",
    status: "success",
    created: "2022-01-01T00:00:00+00:00",
    updated: "2022-01-01T00:00:00+00:00"
}
  

PixInternalTransactionReport(
    id: "5656565656565656",
    referenceType: "request",
    amount: 1000,
    endToEndId: "E20018183202201011000r01",
    method: "manual",
    senderBankCode: "34052649",
    senderBranchCode: "0001",
    senderAccountNumber: "00000-0",
    senderAccountType: "checking",
    senderTaxId: "012.345.678-90",
    receiverBankCode: "20018183",
    receiverBranchCode: "0001",
    receiverAccountNumber: "10000-0",
    receiverAccountType: "checking",
    receiverTaxId: "20.018.183/0001-80",
    receiverKeyId: "20.018.183/0001-80",
    status: "success",
    created: "2022-01-01T00:00:00+00:00",
    updated: "2022-01-01T00:00:00+00:00"
)
  

{
    Id: "5656565656565656",
    ReferenceType: "request",
    Amount: 1000,
    EndToEndId: "E20018183202201011000r01",
    Method: "manual",
    SenderBankCode: "34052649",
    SenderBranchCode: "0001",
    SenderAccountNumber: "00000-0",
    SenderAccountType: "checking",
    SenderTaxId: "012.345.678-90",
    ReceiverBankCode: "20018183",
    ReceiverBranchCode: "0001",
    ReceiverAccountNumber: "10000-0",
    ReceiverAccountType: "checking",
    ReceiverTaxId: "20.018.183/0001-80",
    ReceiverKeyId: "20.018.183/0001-80",
    Status: "success",
    Created: "2022-01-01T00:00:00+00:00",
    Updated: "2022-01-01T00:00:00+00:00"
}
  

{:id "5656565656565656"
 :reference-type "request"
 :amount 1000
 :end-to-end-id "E20018183202201011000r01"
 :method "manual"
 :sender-bank-code "34052649"
 :sender-branch-code "0001"
 :sender-account-number "00000-0"
 :sender-account-type "checking"
 :sender-tax-id "012.345.678-90"
 :receiver-bank-code "20018183"
 :receiver-branch-code "0001"
 :receiver-account-number "10000-0"
 :receiver-account-type "checking"
 :receiver-tax-id "20.018.183/0001-80"
 :receiver-key-id "20.018.183/0001-80"
 :status "success"
 :created "2022-01-01T00:00:00+00:00"
 :updated "2022-01-01T00:00:00+00:00"}
  

{
    "report": {
        "id": "5656565656565656",
        "referenceType": "request",
        "amount": 1000,
        "endToEndId": "E20018183202201011000r01",
        "method": "manual",
        "senderBankCode": "34052649",
        "senderBranchCode": "0001",
        "senderAccountNumber": "00000-0",
        "senderAccountType": "checking",
        "senderTaxId": "012.345.678-90",
        "receiverBankCode": "20018183",
        "receiverBranchCode": "0001",
        "receiverAccountNumber": "10000-0",
        "receiverAccountType": "checking",
        "receiverTaxId": "20.018.183/0001-80",
        "receiverKeyId": "20.018.183/0001-80",
        "status": "success",
        "created": "2022-01-01T00:00:00+00:00",
        "updated": "2022-01-01T00:00:00+00:00"
    }
}
  

import starkinfra

brcodes = starkinfra.staticbrcode.create([
    starkinfra.StaticBrcode(
        name="Jon Snow",
        key_id="+5511989898989",
        city="São Paulo",
        amount=1000,
        cashier_bank_code="20018183",
        type="instant",
        reconciliation_id="my-reconciliation-id",
        description="Payment for services",
        tags=["invoice", "payment"]
    )
])

for brcode in brcodes:
    print(brcode)
  

const starkinfra = require('starkinfra')

const brcodes = await starkinfra.staticBrcode.create([
    {
        name: "Jon Snow",
        keyId: "+5511989898989",
        city: "São Paulo",
        amount: 1000,
        reconciliationId: "my-reconciliation-id",
        description: "Payment for services",
        tags: ["invoice", "payment"]
    }
])

for (const brcode of brcodes) {
    console.log(brcode)
}
  

 "Jon Snow",
        "keyId" => "+5511989898989",
        "city" => "São Paulo",
        "amount" => 1000,
        "reconciliationId" => "my-reconciliation-id",
        "description" => "Payment for services",
        "tags" => ["invoice", "payment"]
    ])
]);

foreach ($brcodes as $brcode) {
    print_r($brcode);
}
  

import com.starkinfra.*;
import java.util.Arrays;

List brcodes = StaticBrcode.create(
    Arrays.asList(
        new StaticBrcode.Builder()
            .name("Jon Snow")
            .keyId("+5511989898989")
            .city("São Paulo")
            .amount(1000L)
            .reconciliationId("my-reconciliation-id")
            .description("Payment for services")
            .tags(Arrays.asList("invoice", "payment"))
            .build()
    )
);

for (StaticBrcode brcode : brcodes) {
    System.out.println(brcode);
}
  

require('starkinfra')

brcodes = StarkInfra::StaticBrcode.create([
    StarkInfra::StaticBrcode.new(
        name: "Jon Snow",
        key_id: "+5511989898989",
        city: "São Paulo",
        amount: 1000,
        reconciliation_id: "my-reconciliation-id",
        description: "Payment for services",
        tags: ["invoice", "payment"]
    )
])

brcodes.each do |brcode|
    puts brcode
end
  

brcodes = StarkInfra.StaticBrcode.create!([
    %StarkInfra.StaticBrcode{
        name: "Jon Snow",
        key_id: "+5511989898989",
        city: "São Paulo",
        amount: 1000,
        reconciliation_id: "my-reconciliation-id",
        description: "Payment for services",
        tags: ["invoice", "payment"]
    }
])

for brcode <- brcodes do
    IO.inspect(brcode)
end
  

using StarkInfra;
using System.Collections.Generic;

List brcodes = StaticBrcode.Create(
    new List {
        new StaticBrcode(
            name: "Jon Snow",
            keyId: "+5511989898989",
            city: "São Paulo",
            amount: 1000,
            reconciliationId: "my-reconciliation-id",
            description: "Payment for services",
            tags: new List { "invoice", "payment" }
        )
    }
);

foreach (StaticBrcode brcode in brcodes) {
    Console.WriteLine(brcode);
}
  

package main

import (
    "fmt"
    StaticBrcode "github.com/starkinfra/sdk-go/starkinfra/staticbrcode"
)

brcodes, err := StaticBrcode.Create(
    []StaticBrcode.StaticBrcode{
        {
            Name:             "Jon Snow",
            KeyId:            "+5511989898989",
            City:             "São Paulo",
            Amount:           1000,
            ReconciliationId: "my-reconciliation-id",
            Description:      "Payment for services",
            Tags:             []string{"invoice", "payment"},
        },
    }, nil)

for _, brcode := range brcodes {
    fmt.Println(brcode)
}
  

(def brcodes
    (starkinfra.static-brcode/create
        [{:name "Jon Snow"
          :key-id "+5511989898989"
          :city "São Paulo"
          :amount 1000
          :reconciliation-id "my-reconciliation-id"
          :description "Payment for services"
          :tags ["invoice" "payment"]}]))

(doseq [brcode brcodes]
    (println brcode))
  

curl --location --request POST '{{baseUrl}}/v2/static-brcode' \
--header 'Access-Id: {{accessId}}' \
--header 'Access-Time: {{accessTime}}' \
--header 'Access-Signature: {{accessSignature}}' \
--header 'Content-Type: application/json' \
--data-raw '{
    "brcodes": [
        {
            "name": "Jon Snow",
            "keyId": "+5511989898989",
            "city": "São Paulo",
            "amount": 1000,
            "reconciliationId": "my-reconciliation-id",
            "description": "Payment for services",
            "tags": ["invoice", "payment"]
        }
    ]
}'
  

[
    StaticBrcode(
        id="5656565656565656",
        name="Jon Snow",
        key_id="+5511989898989",
        city="São Paulo",
        amount=1000,
        reconciliation_id="my-reconciliation-id",
        cashier_bank_code="20018183",
        type="instant",
        description="Payment for services",
        tags=["invoice", "payment"],
        uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
        url="https://brcode.starkinfra.com/static-qrcode/a1b2c3d4-e5f6-7890-abcd-ef1234567890.png",
        created="2022-01-01T00:00:00+00:00",
        updated="2022-01-01T00:00:00+00:00"
    )
]
  

[
    {
        id: "5656565656565656",
        name: "Jon Snow",
        keyId: "+5511989898989",
        city: "São Paulo",
        amount: 1000,
        reconciliationId: "my-reconciliation-id",
        description: "Payment for services",
        tags: ["invoice", "payment"],
        uuid: "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
        url: "https://brcode.starkinfra.com/static-qrcode/a1b2c3d4-e5f6-7890-abcd-ef1234567890.png",
        created: "2022-01-01T00:00:00+00:00",
        updated: "2022-01-01T00:00:00+00:00"
    }
]
  

[
    StaticBrcode Object (
        [id] => 5656565656565656
        [name] => Jon Snow
        [keyId] => +5511989898989
        [city] => São Paulo
        [amount] => 1000
        [reconciliationId] => my-reconciliation-id
        [description] => Payment for services
        [tags] => Array ( [0] => invoice [1] => payment )
        [uuid] => a1b2c3d4-e5f6-7890-abcd-ef1234567890
        [url] => https://brcode.starkinfra.com/static-qrcode/a1b2c3d4-e5f6-7890-abcd-ef1234567890.png
        [created] => 2022-01-01T00:00:00+00:00
        [updated] => 2022-01-01T00:00:00+00:00
    )
]
  

[
    StaticBrcode(
        id=5656565656565656,
        name=Jon Snow,
        keyId=+5511989898989,
        city=São Paulo,
        amount=1000,
        reconciliationId=my-reconciliation-id,
        description=Payment for services,
        tags=[invoice, payment],
        uuid=a1b2c3d4-e5f6-7890-abcd-ef1234567890,
        url=https://brcode.starkinfra.com/static-qrcode/a1b2c3d4-e5f6-7890-abcd-ef1234567890.png,
        created=2022-01-01T00:00:00+00:00,
        updated=2022-01-01T00:00:00+00:00
    )
]
  

[
    {
        id: "5656565656565656",
        name: "Jon Snow",
        key_id: "+5511989898989",
        city: "São Paulo",
        amount: 1000,
        reconciliation_id: "my-reconciliation-id",
        description: "Payment for services",
        tags: ["invoice", "payment"],
        uuid: "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
        url: "https://brcode.starkinfra.com/static-qrcode/a1b2c3d4-e5f6-7890-abcd-ef1234567890.png",
        created: "2022-01-01T00:00:00+00:00",
        updated: "2022-01-01T00:00:00+00:00"
    }
]
  

[
    %StarkInfra.StaticBrcode{
        id: "5656565656565656",
        name: "Jon Snow",
        key_id: "+5511989898989",
        city: "São Paulo",
        amount: 1000,
        reconciliation_id: "my-reconciliation-id",
        description: "Payment for services",
        tags: ["invoice", "payment"],
        uuid: "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
        url: "https://brcode.starkinfra.com/static-qrcode/a1b2c3d4-e5f6-7890-abcd-ef1234567890.png",
        created: "2022-01-01T00:00:00+00:00",
        updated: "2022-01-01T00:00:00+00:00"
    }
]
  

[
    StaticBrcode(
        id: "5656565656565656",
        name: "Jon Snow",
        keyId: "+5511989898989",
        city: "São Paulo",
        amount: 1000,
        reconciliationId: "my-reconciliation-id",
        description: "Payment for services",
        tags: [ "invoice", "payment" ],
        uuid: "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
        url: "https://brcode.starkinfra.com/static-qrcode/a1b2c3d4-e5f6-7890-abcd-ef1234567890.png",
        created: "2022-01-01T00:00:00+00:00",
        updated: "2022-01-01T00:00:00+00:00"
    )
]
  

[
    {
        Id: "5656565656565656",
        Name: "Jon Snow",
        KeyId: "+5511989898989",
        City: "São Paulo",
        Amount: 1000,
        ReconciliationId: "my-reconciliation-id",
        Description: "Payment for services",
        Tags: ["invoice", "payment"],
        Uuid: "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
        Url: "https://brcode.starkinfra.com/static-qrcode/a1b2c3d4-e5f6-7890-abcd-ef1234567890.png",
        Created: "2022-01-01T00:00:00+00:00",
        Updated: "2022-01-01T00:00:00+00:00"
    }
]
  

[
    {:id "5656565656565656"
     :name "Jon Snow"
     :key-id "+5511989898989"
     :city "São Paulo"
     :amount 1000
     :reconciliation-id "my-reconciliation-id"
     :description "Payment for services"
     :tags ["invoice" "payment"]
     :uuid "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
     :url "https://brcode.starkinfra.com/static-qrcode/a1b2c3d4-e5f6-7890-abcd-ef1234567890.png"
     :created "2022-01-01T00:00:00+00:00"
     :updated "2022-01-01T00:00:00+00:00"}
]
  

{
    "brcodes": [
        {
            "id": "5656565656565656",
            "name": "Jon Snow",
            "keyId": "+5511989898989",
            "city": "São Paulo",
            "amount": 1000,
            "reconciliationId": "my-reconciliation-id",
            "description": "Payment for services",
            "tags": ["invoice", "payment"],
            "uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
            "url": "https://brcode.starkinfra.com/static-qrcode/a1b2c3d4-e5f6-7890-abcd-ef1234567890.png",
            "created": "2022-01-01T00:00:00+00:00",
            "updated": "2022-01-01T00:00:00+00:00"
        }
    ]
}
  

import starkinfra

brcodes = starkinfra.staticbrcode.query(
    limit=10,
    after="2022-01-01",
    before="2022-12-31",
    uuids=["a1b2c3d4-e5f6-7890-abcd-ef1234567890"],
    tags=["invoice"]
)

for brcode in brcodes:
    print(brcode)
  

const starkinfra = require('starkinfra')

const brcodes = await starkinfra.staticBrcode.query({
    limit: 10,
    after: "2022-01-01",
    before: "2022-12-31",
    tags: ["invoice"]
})

for await (const brcode of brcodes) {
    console.log(brcode)
}
  

 10,
    "after" => "2022-01-01",
    "before" => "2022-12-31",
    "tags" => ["invoice"]
]);

foreach ($brcodes as $brcode) {
    print_r($brcode);
}
  

import com.starkinfra.*;
import java.util.HashMap;

HashMap params = new HashMap<>();
params.put("limit", 10);
params.put("after", "2022-01-01");
params.put("before", "2022-12-31");

Generator brcodes = StaticBrcode.query(params);

for (StaticBrcode brcode : brcodes) {
    System.out.println(brcode);
}
  

require('starkinfra')

brcodes = StarkInfra::StaticBrcode.query(
    limit: 10,
    after: "2022-01-01",
    before: "2022-12-31",
    tags: ["invoice"]
)

brcodes.each do |brcode|
    puts brcode
end
  

brcodes = StarkInfra.StaticBrcode.query!(
    limit: 10,
    after: "2022-01-01",
    before: "2022-12-31",
    tags: ["invoice"]
)

for brcode <- brcodes do
    IO.inspect(brcode)
end
  

using StarkInfra;

IEnumerable brcodes = StaticBrcode.Query(
    limit: 10,
    after: new DateTime(2022, 1, 1),
    before: new DateTime(2022, 12, 31),
    tags: new List { "invoice" }
);

foreach (StaticBrcode brcode in brcodes) {
    Console.WriteLine(brcode);
}
  

package main

import (
    "fmt"
    StaticBrcode "github.com/starkinfra/sdk-go/starkinfra/staticbrcode"
)

var params = map[string]interface{}{
    "limit":  10,
    "after":  "2022-01-01",
    "before": "2022-12-31",
}

brcodes := StaticBrcode.Query(params, nil)

for brcode := range brcodes {
    fmt.Println(brcode)
}
  

(def brcodes
    (starkinfra.static-brcode/query {
        :limit 10
        :after "2022-01-01"
        :before "2022-12-31"
        :tags ["invoice"]
    }))

(doseq [brcode brcodes]
    (println brcode))
  

curl --location --request GET '{{baseUrl}}/v2/static-brcode?limit=10&after=2022-01-01&before=2022-12-31' \
--header 'Access-Id: {{accessId}}' \
--header 'Access-Time: {{accessTime}}' \
--header 'Access-Signature: {{accessSignature}}'
  

StaticBrcode(
    id="5656565656565656",
    name="Jon Snow",
    key_id="+5511989898989",
    city="São Paulo",
    amount=1000,
    reconciliation_id="my-reconciliation-id",
    cashier_bank_code="20018183",
    type="instant",
    description="Payment for services",
    tags=["invoice"],
    uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    url="https://brcode.starkinfra.com/static-qrcode/a1b2c3d4-e5f6-7890-abcd-ef1234567890.png",
    created="2022-01-01T00:00:00+00:00",
    updated="2022-01-01T00:00:00+00:00"
)
  

{
    id: "5656565656565656",
    name: "Jon Snow",
    keyId: "+5511989898989",
    city: "São Paulo",
    amount: 1000,
    uuid: "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    url: "https://brcode.starkinfra.com/static-qrcode/a1b2c3d4-e5f6-7890-abcd-ef1234567890.png",
    tags: ["invoice"],
    created: "2022-01-01T00:00:00+00:00",
    updated: "2022-01-01T00:00:00+00:00"
}
  

StaticBrcode Object (
    [id] => 5656565656565656
    [name] => Jon Snow
    [keyId] => +5511989898989
    [city] => São Paulo
    [amount] => 1000
    [uuid] => a1b2c3d4-e5f6-7890-abcd-ef1234567890
    [url] => https://brcode.starkinfra.com/static-qrcode/a1b2c3d4-e5f6-7890-abcd-ef1234567890.png
    [tags] => Array ( [0] => invoice )
    [created] => 2022-01-01T00:00:00+00:00
    [updated] => 2022-01-01T00:00:00+00:00
)
  

StaticBrcode(
    id=5656565656565656,
    name=Jon Snow,
    keyId=+5511989898989,
    city=São Paulo,
    amount=1000,
    uuid=a1b2c3d4-e5f6-7890-abcd-ef1234567890,
    url=https://brcode.starkinfra.com/static-qrcode/a1b2c3d4-e5f6-7890-abcd-ef1234567890.png,
    tags=[invoice],
    created=2022-01-01T00:00:00+00:00,
    updated=2022-01-01T00:00:00+00:00
)
  

{
    id: "5656565656565656",
    name: "Jon Snow",
    key_id: "+5511989898989",
    city: "São Paulo",
    amount: 1000,
    uuid: "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    url: "https://brcode.starkinfra.com/static-qrcode/a1b2c3d4-e5f6-7890-abcd-ef1234567890.png",
    tags: ["invoice"],
    created: "2022-01-01T00:00:00+00:00",
    updated: "2022-01-01T00:00:00+00:00"
}
  

%StarkInfra.StaticBrcode{
    id: "5656565656565656",
    name: "Jon Snow",
    key_id: "+5511989898989",
    city: "São Paulo",
    amount: 1000,
    uuid: "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    url: "https://brcode.starkinfra.com/static-qrcode/a1b2c3d4-e5f6-7890-abcd-ef1234567890.png",
    tags: ["invoice"],
    created: "2022-01-01T00:00:00+00:00",
    updated: "2022-01-01T00:00:00+00:00"
}
  

StaticBrcode(
    id: "5656565656565656",
    name: "Jon Snow",
    keyId: "+5511989898989",
    city: "São Paulo",
    amount: 1000,
    uuid: "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    url: "https://brcode.starkinfra.com/static-qrcode/a1b2c3d4-e5f6-7890-abcd-ef1234567890.png",
    tags: [ "invoice" ],
    created: "2022-01-01T00:00:00+00:00",
    updated: "2022-01-01T00:00:00+00:00"
)
  

{
    Id: "5656565656565656",
    Name: "Jon Snow",
    KeyId: "+5511989898989",
    City: "São Paulo",
    Amount: 1000,
    Uuid: "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    Url: "https://brcode.starkinfra.com/static-qrcode/a1b2c3d4-e5f6-7890-abcd-ef1234567890.png",
    Tags: ["invoice"],
    Created: "2022-01-01T00:00:00+00:00",
    Updated: "2022-01-01T00:00:00+00:00"
}
  

{:id "5656565656565656"
 :name "Jon Snow"
 :key-id "+5511989898989"
 :city "São Paulo"
 :amount 1000
 :uuid "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
 :url "https://brcode.starkinfra.com/static-qrcode/a1b2c3d4-e5f6-7890-abcd-ef1234567890.png"
 :tags ["invoice"]
 :created "2022-01-01T00:00:00+00:00"
 :updated "2022-01-01T00:00:00+00:00"}
  

{
    "cursor": null,
    "brcodes": [
        {
            "id": "5656565656565656",
            "name": "Jon Snow",
            "keyId": "+5511989898989",
            "city": "São Paulo",
            "amount": 1000,
            "uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
            "url": "https://brcode.starkinfra.com/static-qrcode/a1b2c3d4-e5f6-7890-abcd-ef1234567890.png",
            "tags": ["invoice"],
            "created": "2022-01-01T00:00:00+00:00",
            "updated": "2022-01-01T00:00:00+00:00"
        }
    ]
}
  

import starkinfra

brcode = starkinfra.staticbrcode.get("a1b2c3d4-e5f6-7890-abcd-ef1234567890")

print(brcode)
  

const starkinfra = require('starkinfra')

const brcode = await starkinfra.staticBrcode.get("a1b2c3d4-e5f6-7890-abcd-ef1234567890")

console.log(brcode)
  

import com.starkinfra.*;

StaticBrcode brcode = StaticBrcode.get("a1b2c3d4-e5f6-7890-abcd-ef1234567890");

System.out.println(brcode);
  

require('starkinfra')

brcode = StarkInfra::StaticBrcode.get("a1b2c3d4-e5f6-7890-abcd-ef1234567890")

puts brcode
  

brcode = StarkInfra.StaticBrcode.get!("a1b2c3d4-e5f6-7890-abcd-ef1234567890")

IO.inspect(brcode)
  

using StarkInfra;

StaticBrcode brcode = StaticBrcode.Get("a1b2c3d4-e5f6-7890-abcd-ef1234567890");

Console.WriteLine(brcode);
  

package main

import (
    "fmt"
    StaticBrcode "github.com/starkinfra/sdk-go/starkinfra/staticbrcode"
)

brcode, err := StaticBrcode.Get("a1b2c3d4-e5f6-7890-abcd-ef1234567890", nil)

fmt.Println(brcode)
  

(def brcode
    (starkinfra.static-brcode/get "a1b2c3d4-e5f6-7890-abcd-ef1234567890"))

(println brcode)
  

curl --location --request GET '{{baseUrl}}/v2/static-brcode/a1b2c3d4-e5f6-7890-abcd-ef1234567890' \
--header 'Access-Id: {{accessId}}' \
--header 'Access-Time: {{accessTime}}' \
--header 'Access-Signature: {{accessSignature}}'
  

StaticBrcode(
    id="5656565656565656",
    name="Jon Snow",
    key_id="+5511989898989",
    city="São Paulo",
    amount=1000,
    reconciliation_id="my-reconciliation-id",
    cashier_bank_code="20018183",
    type="instant",
    description="Payment for services",
    tags=["invoice", "payment"],
    uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    url="https://brcode.starkinfra.com/static-qrcode/a1b2c3d4-e5f6-7890-abcd-ef1234567890.png",
    created="2022-01-01T00:00:00+00:00",
    updated="2022-01-01T00:00:00+00:00"
)
  

{
    id: "5656565656565656",
    name: "Jon Snow",
    keyId: "+5511989898989",
    city: "São Paulo",
    amount: 1000,
    reconciliationId: "my-reconciliation-id",
    description: "Payment for services",
    tags: ["invoice", "payment"],
    uuid: "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    url: "https://brcode.starkinfra.com/static-qrcode/a1b2c3d4-e5f6-7890-abcd-ef1234567890.png",
    created: "2022-01-01T00:00:00+00:00",
    updated: "2022-01-01T00:00:00+00:00"
}
  

StaticBrcode Object (
    [id] => 5656565656565656
    [name] => Jon Snow
    [keyId] => +5511989898989
    [city] => São Paulo
    [amount] => 1000
    [reconciliationId] => my-reconciliation-id
    [description] => Payment for services
    [tags] => Array ( [0] => invoice [1] => payment )
    [uuid] => a1b2c3d4-e5f6-7890-abcd-ef1234567890
    [url] => https://brcode.starkinfra.com/static-qrcode/a1b2c3d4-e5f6-7890-abcd-ef1234567890.png
    [created] => 2022-01-01T00:00:00+00:00
    [updated] => 2022-01-01T00:00:00+00:00
)
  

StaticBrcode(
    id=5656565656565656,
    name=Jon Snow,
    keyId=+5511989898989,
    city=São Paulo,
    amount=1000,
    reconciliationId=my-reconciliation-id,
    description=Payment for services,
    tags=[invoice, payment],
    uuid=a1b2c3d4-e5f6-7890-abcd-ef1234567890,
    url=https://brcode.starkinfra.com/static-qrcode/a1b2c3d4-e5f6-7890-abcd-ef1234567890.png,
    created=2022-01-01T00:00:00+00:00,
    updated=2022-01-01T00:00:00+00:00
)
  

{
    id: "5656565656565656",
    name: "Jon Snow",
    key_id: "+5511989898989",
    city: "São Paulo",
    amount: 1000,
    reconciliation_id: "my-reconciliation-id",
    description: "Payment for services",
    tags: ["invoice", "payment"],
    uuid: "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    url: "https://brcode.starkinfra.com/static-qrcode/a1b2c3d4-e5f6-7890-abcd-ef1234567890.png",
    created: "2022-01-01T00:00:00+00:00",
    updated: "2022-01-01T00:00:00+00:00"
}
  

%StarkInfra.StaticBrcode{
    id: "5656565656565656",
    name: "Jon Snow",
    key_id: "+5511989898989",
    city: "São Paulo",
    amount: 1000,
    reconciliation_id: "my-reconciliation-id",
    description: "Payment for services",
    tags: ["invoice", "payment"],
    uuid: "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    url: "https://brcode.starkinfra.com/static-qrcode/a1b2c3d4-e5f6-7890-abcd-ef1234567890.png",
    created: "2022-01-01T00:00:00+00:00",
    updated: "2022-01-01T00:00:00+00:00"
}
  

StaticBrcode(
    id: "5656565656565656",
    name: "Jon Snow",
    keyId: "+5511989898989",
    city: "São Paulo",
    amount: 1000,
    reconciliationId: "my-reconciliation-id",
    description: "Payment for services",
    tags: [ "invoice", "payment" ],
    uuid: "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    url: "https://brcode.starkinfra.com/static-qrcode/a1b2c3d4-e5f6-7890-abcd-ef1234567890.png",
    created: "2022-01-01T00:00:00+00:00",
    updated: "2022-01-01T00:00:00+00:00"
)
  

{
    Id: "5656565656565656",
    Name: "Jon Snow",
    KeyId: "+5511989898989",
    City: "São Paulo",
    Amount: 1000,
    ReconciliationId: "my-reconciliation-id",
    Description: "Payment for services",
    Tags: ["invoice", "payment"],
    Uuid: "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    Url: "https://brcode.starkinfra.com/static-qrcode/a1b2c3d4-e5f6-7890-abcd-ef1234567890.png",
    Created: "2022-01-01T00:00:00+00:00",
    Updated: "2022-01-01T00:00:00+00:00"
}
  

{:id "5656565656565656"
 :name "Jon Snow"
 :key-id "+5511989898989"
 :city "São Paulo"
 :amount 1000
 :reconciliation-id "my-reconciliation-id"
 :description "Payment for services"
 :tags ["invoice" "payment"]
 :uuid "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
 :url "https://brcode.starkinfra.com/static-qrcode/a1b2c3d4-e5f6-7890-abcd-ef1234567890.png"
 :created "2022-01-01T00:00:00+00:00"
 :updated "2022-01-01T00:00:00+00:00"}
  

{
    "brcode": {
        "id": "5656565656565656",
        "name": "Jon Snow",
        "keyId": "+5511989898989",
        "city": "São Paulo",
        "amount": 1000,
        "reconciliationId": "my-reconciliation-id",
        "description": "Payment for services",
        "tags": ["invoice", "payment"],
        "uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
        "url": "https://brcode.starkinfra.com/static-qrcode/a1b2c3d4-e5f6-7890-abcd-ef1234567890.png",
        "created": "2022-01-01T00:00:00+00:00",
        "updated": "2022-01-01T00:00:00+00:00"
    }
}
  

import starkinfra

brcodes = starkinfra.dynamicbrcode.create([
    starkinfra.DynamicBrcode(
        name="Jon Snow",
        city="São Paulo",
        external_id="my-dynamic-brcode-id-1",
        type="subscription",
        tags=["dynamic", "subscription"]
    )
])

for brcode in brcodes:
    print(brcode)
  

const starkinfra = require('starkinfra')

const brcodes = await starkinfra.dynamicBrcode.create([
    {
        name: "Jon Snow",
        city: "São Paulo",
        externalId: "my-dynamic-brcode-id-1",
        type: "instant",
        tags: ["dynamic", "instant"]
    }
])

for (const brcode of brcodes) {
    console.log(brcode)
}
  

 "Jon Snow",
        "city" => "São Paulo",
        "externalId" => "my-dynamic-brcode-id-1",
        "type" => "instant",
        "tags" => ["dynamic", "instant"]
    ])
]);

foreach ($brcodes as $brcode) {
    print_r($brcode);
}
  

import com.starkinfra.*;
import java.util.Arrays;

List brcodes = DynamicBrcode.create(
    Arrays.asList(
        new DynamicBrcode.Builder()
            .name("Jon Snow")
            .city("São Paulo")
            .externalId("my-dynamic-brcode-id-1")
            .type("instant")
            .tags(Arrays.asList("dynamic", "instant"))
            .build()
    )
);

for (DynamicBrcode brcode : brcodes) {
    System.out.println(brcode);
}
  

require('starkinfra')

brcodes = StarkInfra::DynamicBrcode.create([
    StarkInfra::DynamicBrcode.new(
        name: "Jon Snow",
        city: "São Paulo",
        external_id: "my-dynamic-brcode-id-1",
        type: "instant",
        tags: ["dynamic", "instant"]
    )
])

brcodes.each do |brcode|
    puts brcode
end
  

brcodes = StarkInfra.DynamicBrcode.create!([
    %StarkInfra.DynamicBrcode{
        name: "Jon Snow",
        city: "São Paulo",
        external_id: "my-dynamic-brcode-id-1",
        type: "instant",
        tags: ["dynamic", "instant"]
    }
])

for brcode <- brcodes do
    IO.inspect(brcode)
end
  

using StarkInfra;
using System.Collections.Generic;

List brcodes = DynamicBrcode.Create(
    new List {
        new DynamicBrcode(
            name: "Jon Snow",
            city: "São Paulo",
            externalId: "my-dynamic-brcode-id-1",
            type: "instant",
            tags: new List { "dynamic", "instant" }
        )
    }
);

foreach (DynamicBrcode brcode in brcodes) {
    Console.WriteLine(brcode);
}
  

package main

import (
    "fmt"
    DynamicBrcode "github.com/starkinfra/sdk-go/starkinfra/dynamicbrcode"
)

brcodes, err := DynamicBrcode.Create(
    []DynamicBrcode.DynamicBrcode{
        {
            Name:       "Jon Snow",
            City:       "São Paulo",
            ExternalId: "my-dynamic-brcode-id-1",
            Type:       "instant",
            Tags:       []string{"dynamic", "instant"},
        },
    }, nil)

for _, brcode := range brcodes {
    fmt.Println(brcode)
}
  

(def brcodes
    (starkinfra.dynamic-brcode/create
        [{:name "Jon Snow"
          :city "São Paulo"
          :external-id "my-dynamic-brcode-id-1"
          :type "instant"
          :tags ["dynamic" "instant"]}]))

(doseq [brcode brcodes]
    (println brcode))
  

curl --location --request POST '{{baseUrl}}/v2/dynamic-brcode' \
--header 'Access-Id: {{accessId}}' \
--header 'Access-Time: {{accessTime}}' \
--header 'Access-Signature: {{accessSignature}}' \
--header 'Content-Type: application/json' \
--data-raw '{
    "brcodes": [
        {
            "name": "Jon Snow",
            "city": "São Paulo",
            "externalId": "my-dynamic-brcode-id-1",
            "type": "instant",
            "tags": ["dynamic", "instant"]
        }
    ]
}'
  

[
    DynamicBrcode(
        id="5656565656565656",
        name="Jon Snow",
        city="São Paulo",
        external_id="my-dynamic-brcode-id-1",
        type="subscription",
        tags=["dynamic", "subscription"],
        uuid="b2c3d4e5-f6a7-8901-bcde-f12345678901",
        url="https://brcode.starkinfra.com/dynamic-qrcode/b2c3d4e5-f6a7-8901-bcde-f12345678901.png",
        created="2022-01-01T00:00:00+00:00",
        updated="2022-01-01T00:00:00+00:00"
    )
]
  

[
    {
        id: "5656565656565656",
        name: "Jon Snow",
        city: "São Paulo",
        externalId: "my-dynamic-brcode-id-1",
        type: "instant",
        tags: ["dynamic", "instant"],
        uuid: "b2c3d4e5-f6a7-8901-bcde-f12345678901",
        url: "https://brcode.starkinfra.com/dynamic-qrcode/b2c3d4e5-f6a7-8901-bcde-f12345678901.png",
        created: "2022-01-01T00:00:00+00:00",
        updated: "2022-01-01T00:00:00+00:00"
    }
]
  

[
    DynamicBrcode Object (
        [id] => 5656565656565656
        [name] => Jon Snow
        [city] => São Paulo
        [externalId] => my-dynamic-brcode-id-1
        [type] => instant
        [tags] => Array ( [0] => dynamic [1] => instant )
        [uuid] => b2c3d4e5-f6a7-8901-bcde-f12345678901
        [url] => https://brcode.starkinfra.com/dynamic-qrcode/b2c3d4e5-f6a7-8901-bcde-f12345678901.png
        [created] => 2022-01-01T00:00:00+00:00
        [updated] => 2022-01-01T00:00:00+00:00
    )
]
  

[
    DynamicBrcode(
        id=5656565656565656,
        name=Jon Snow,
        city=São Paulo,
        externalId=my-dynamic-brcode-id-1,
        type=instant,
        tags=[dynamic, instant],
        uuid=b2c3d4e5-f6a7-8901-bcde-f12345678901,
        url=https://brcode.starkinfra.com/dynamic-qrcode/b2c3d4e5-f6a7-8901-bcde-f12345678901.png,
        created=2022-01-01T00:00:00+00:00,
        updated=2022-01-01T00:00:00+00:00
    )
]
  

[
    {
        id: "5656565656565656",
        name: "Jon Snow",
        city: "São Paulo",
        external_id: "my-dynamic-brcode-id-1",
        type: "instant",
        tags: ["dynamic", "instant"],
        uuid: "b2c3d4e5-f6a7-8901-bcde-f12345678901",
        url: "https://brcode.starkinfra.com/dynamic-qrcode/b2c3d4e5-f6a7-8901-bcde-f12345678901.png",
        created: "2022-01-01T00:00:00+00:00",
        updated: "2022-01-01T00:00:00+00:00"
    }
]
  

[
    %StarkInfra.DynamicBrcode{
        id: "5656565656565656",
        name: "Jon Snow",
        city: "São Paulo",
        external_id: "my-dynamic-brcode-id-1",
        type: "instant",
        tags: ["dynamic", "instant"],
        uuid: "b2c3d4e5-f6a7-8901-bcde-f12345678901",
        url: "https://brcode.starkinfra.com/dynamic-qrcode/b2c3d4e5-f6a7-8901-bcde-f12345678901.png",
        created: "2022-01-01T00:00:00+00:00",
        updated: "2022-01-01T00:00:00+00:00"
    }
]
  

[
    DynamicBrcode(
        id: "5656565656565656",
        name: "Jon Snow",
        city: "São Paulo",
        externalId: "my-dynamic-brcode-id-1",
        type: "instant",
        tags: [ "dynamic", "instant" ],
        uuid: "b2c3d4e5-f6a7-8901-bcde-f12345678901",
        url: "https://brcode.starkinfra.com/dynamic-qrcode/b2c3d4e5-f6a7-8901-bcde-f12345678901.png",
        created: "2022-01-01T00:00:00+00:00",
        updated: "2022-01-01T00:00:00+00:00"
    )
]
  

[
    {
        Id: "5656565656565656",
        Name: "Jon Snow",
        City: "São Paulo",
        ExternalId: "my-dynamic-brcode-id-1",
        Type: "instant",
        Tags: ["dynamic", "instant"],
        Uuid: "b2c3d4e5-f6a7-8901-bcde-f12345678901",
        Url: "https://brcode.starkinfra.com/dynamic-qrcode/b2c3d4e5-f6a7-8901-bcde-f12345678901.png",
        Created: "2022-01-01T00:00:00+00:00",
        Updated: "2022-01-01T00:00:00+00:00"
    }
]
  

[
    {:id "5656565656565656"
     :name "Jon Snow"
     :city "São Paulo"
     :external-id "my-dynamic-brcode-id-1"
     :type "instant"
     :tags ["dynamic" "instant"]
     :uuid "b2c3d4e5-f6a7-8901-bcde-f12345678901"
     :url "https://brcode.starkinfra.com/dynamic-qrcode/b2c3d4e5-f6a7-8901-bcde-f12345678901.png"
     :created "2022-01-01T00:00:00+00:00"
     :updated "2022-01-01T00:00:00+00:00"}
]
  

{
    "brcodes": [
        {
            "id": "5656565656565656",
            "name": "Jon Snow",
            "city": "São Paulo",
            "externalId": "my-dynamic-brcode-id-1",
            "type": "instant",
            "tags": ["dynamic", "instant"],
            "uuid": "b2c3d4e5-f6a7-8901-bcde-f12345678901",
            "url": "https://brcode.starkinfra.com/dynamic-qrcode/b2c3d4e5-f6a7-8901-bcde-f12345678901.png",
            "created": "2022-01-01T00:00:00+00:00",
            "updated": "2022-01-01T00:00:00+00:00"
        }
    ]
}
  

import starkinfra

brcodes = starkinfra.dynamicbrcode.query(
    limit=10,
    after="2022-01-01",
    before="2022-12-31",
    tags=["dynamic"]
)

for brcode in brcodes:
    print(brcode)
  

const starkinfra = require('starkinfra')

const brcodes = await starkinfra.dynamicBrcode.query({
    limit: 10,
    after: "2022-01-01",
    before: "2022-12-31",
    tags: ["dynamic"]
})

for await (const brcode of brcodes) {
    console.log(brcode)
}
  

 10,
    "after" => "2022-01-01",
    "before" => "2022-12-31",
    "tags" => ["dynamic"]
]);

foreach ($brcodes as $brcode) {
    print_r($brcode);
}
  

import com.starkinfra.*;
import java.util.HashMap;

HashMap params = new HashMap<>();
params.put("limit", 10);
params.put("after", "2022-01-01");
params.put("before", "2022-12-31");

Generator brcodes = DynamicBrcode.query(params);

for (DynamicBrcode brcode : brcodes) {
    System.out.println(brcode);
}
  

require('starkinfra')

brcodes = StarkInfra::DynamicBrcode.query(
    limit: 10,
    after: "2022-01-01",
    before: "2022-12-31",
    tags: ["dynamic"]
)

brcodes.each do |brcode|
    puts brcode
end
  

brcodes = StarkInfra.DynamicBrcode.query!(
    limit: 10,
    after: "2022-01-01",
    before: "2022-12-31",
    tags: ["dynamic"]
)

for brcode <- brcodes do
    IO.inspect(brcode)
end
  

using StarkInfra;

IEnumerable brcodes = DynamicBrcode.Query(
    limit: 10,
    after: new DateTime(2022, 1, 1),
    before: new DateTime(2022, 12, 31),
    tags: new List { "dynamic" }
);

foreach (DynamicBrcode brcode in brcodes) {
    Console.WriteLine(brcode);
}
  

package main

import (
    "fmt"
    DynamicBrcode "github.com/starkinfra/sdk-go/starkinfra/dynamicbrcode"
)

var params = map[string]interface{}{
    "limit":  10,
    "after":  "2022-01-01",
    "before": "2022-12-31",
}

brcodes := DynamicBrcode.Query(params, nil)

for brcode := range brcodes {
    fmt.Println(brcode)
}
  

(def brcodes
    (starkinfra.dynamic-brcode/query {
        :limit 10
        :after "2022-01-01"
        :before "2022-12-31"
        :tags ["dynamic"]
    }))

(doseq [brcode brcodes]
    (println brcode))
  

curl --location --request GET '{{baseUrl}}/v2/dynamic-brcode?limit=10&after=2022-01-01&before=2022-12-31' \
--header 'Access-Id: {{accessId}}' \
--header 'Access-Time: {{accessTime}}' \
--header 'Access-Signature: {{accessSignature}}'
  

DynamicBrcode(
    id="5656565656565656",
    name="Jon Snow",
    city="São Paulo",
    external_id="my-dynamic-brcode-id-1",
    type="instant",
    tags=["dynamic"],
    uuid="b2c3d4e5-f6a7-8901-bcde-f12345678901",
    url="https://brcode.starkinfra.com/dynamic-qrcode/b2c3d4e5-f6a7-8901-bcde-f12345678901.png",
    created="2022-01-01T00:00:00+00:00",
    updated="2022-01-01T00:00:00+00:00"
)
  

{
    id: "5656565656565656",
    name: "Jon Snow",
    city: "São Paulo",
    externalId: "my-dynamic-brcode-id-1",
    type: "instant",
    tags: ["dynamic"],
    uuid: "b2c3d4e5-f6a7-8901-bcde-f12345678901",
    url: "https://brcode.starkinfra.com/dynamic-qrcode/b2c3d4e5-f6a7-8901-bcde-f12345678901.png",
    created: "2022-01-01T00:00:00+00:00",
    updated: "2022-01-01T00:00:00+00:00"
}
  

DynamicBrcode Object (
    [id] => 5656565656565656
    [name] => Jon Snow
    [city] => São Paulo
    [externalId] => my-dynamic-brcode-id-1
    [type] => instant
    [tags] => Array ( [0] => dynamic )
    [uuid] => b2c3d4e5-f6a7-8901-bcde-f12345678901
    [url] => https://brcode.starkinfra.com/dynamic-qrcode/b2c3d4e5-f6a7-8901-bcde-f12345678901.png
    [created] => 2022-01-01T00:00:00+00:00
    [updated] => 2022-01-01T00:00:00+00:00
)
  

DynamicBrcode(
    id=5656565656565656,
    name=Jon Snow,
    city=São Paulo,
    externalId=my-dynamic-brcode-id-1,
    type=instant,
    tags=[dynamic],
    uuid=b2c3d4e5-f6a7-8901-bcde-f12345678901,
    url=https://brcode.starkinfra.com/dynamic-qrcode/b2c3d4e5-f6a7-8901-bcde-f12345678901.png,
    created=2022-01-01T00:00:00+00:00,
    updated=2022-01-01T00:00:00+00:00
)
  

{
    id: "5656565656565656",
    name: "Jon Snow",
    city: "São Paulo",
    external_id: "my-dynamic-brcode-id-1",
    type: "instant",
    tags: ["dynamic"],
    uuid: "b2c3d4e5-f6a7-8901-bcde-f12345678901",
    url: "https://brcode.starkinfra.com/dynamic-qrcode/b2c3d4e5-f6a7-8901-bcde-f12345678901.png",
    created: "2022-01-01T00:00:00+00:00",
    updated: "2022-01-01T00:00:00+00:00"
}
  

%StarkInfra.DynamicBrcode{
    id: "5656565656565656",
    name: "Jon Snow",
    city: "São Paulo",
    external_id: "my-dynamic-brcode-id-1",
    type: "instant",
    tags: ["dynamic"],
    uuid: "b2c3d4e5-f6a7-8901-bcde-f12345678901",
    url: "https://brcode.starkinfra.com/dynamic-qrcode/b2c3d4e5-f6a7-8901-bcde-f12345678901.png",
    created: "2022-01-01T00:00:00+00:00",
    updated: "2022-01-01T00:00:00+00:00"
}
  

DynamicBrcode(
    id: "5656565656565656",
    name: "Jon Snow",
    city: "São Paulo",
    externalId: "my-dynamic-brcode-id-1",
    type: "instant",
    tags: [ "dynamic" ],
    uuid: "b2c3d4e5-f6a7-8901-bcde-f12345678901",
    url: "https://brcode.starkinfra.com/dynamic-qrcode/b2c3d4e5-f6a7-8901-bcde-f12345678901.png",
    created: "2022-01-01T00:00:00+00:00",
    updated: "2022-01-01T00:00:00+00:00"
)
  

{
    Id: "5656565656565656",
    Name: "Jon Snow",
    City: "São Paulo",
    ExternalId: "my-dynamic-brcode-id-1",
    Type: "instant",
    Tags: ["dynamic"],
    Uuid: "b2c3d4e5-f6a7-8901-bcde-f12345678901",
    Url: "https://brcode.starkinfra.com/dynamic-qrcode/b2c3d4e5-f6a7-8901-bcde-f12345678901.png",
    Created: "2022-01-01T00:00:00+00:00",
    Updated: "2022-01-01T00:00:00+00:00"
}
  

{:id "5656565656565656"
 :name "Jon Snow"
 :city "São Paulo"
 :external-id "my-dynamic-brcode-id-1"
 :type "instant"
 :tags ["dynamic"]
 :uuid "b2c3d4e5-f6a7-8901-bcde-f12345678901"
 :url "https://brcode.starkinfra.com/dynamic-qrcode/b2c3d4e5-f6a7-8901-bcde-f12345678901.png"
 :created "2022-01-01T00:00:00+00:00"
 :updated "2022-01-01T00:00:00+00:00"}
  

{
    "cursor": null,
    "brcodes": [
        {
            "id": "5656565656565656",
            "name": "Jon Snow",
            "city": "São Paulo",
            "externalId": "my-dynamic-brcode-id-1",
            "type": "instant",
            "tags": ["dynamic"],
            "uuid": "b2c3d4e5-f6a7-8901-bcde-f12345678901",
            "url": "https://brcode.starkinfra.com/dynamic-qrcode/b2c3d4e5-f6a7-8901-bcde-f12345678901.png",
            "created": "2022-01-01T00:00:00+00:00",
            "updated": "2022-01-01T00:00:00+00:00"
        }
    ]
}
  

import starkinfra

brcode = starkinfra.dynamicbrcode.get("b2c3d4e5-f6a7-8901-bcde-f12345678901")

print(brcode)
  

const starkinfra = require('starkinfra')

const brcode = await starkinfra.dynamicBrcode.get("b2c3d4e5-f6a7-8901-bcde-f12345678901")

console.log(brcode)
  

import com.starkinfra.*;

DynamicBrcode brcode = DynamicBrcode.get("b2c3d4e5-f6a7-8901-bcde-f12345678901");

System.out.println(brcode);
  

require('starkinfra')

brcode = StarkInfra::DynamicBrcode.get("b2c3d4e5-f6a7-8901-bcde-f12345678901")

puts brcode
  

brcode = StarkInfra.DynamicBrcode.get!("b2c3d4e5-f6a7-8901-bcde-f12345678901")

IO.inspect(brcode)
  

using StarkInfra;

DynamicBrcode brcode = DynamicBrcode.Get("b2c3d4e5-f6a7-8901-bcde-f12345678901");

Console.WriteLine(brcode);
  

package main

import (
    "fmt"
    DynamicBrcode "github.com/starkinfra/sdk-go/starkinfra/dynamicbrcode"
)

brcode, err := DynamicBrcode.Get("b2c3d4e5-f6a7-8901-bcde-f12345678901", nil)

fmt.Println(brcode)
  

(def brcode
    (starkinfra.dynamic-brcode/get "b2c3d4e5-f6a7-8901-bcde-f12345678901"))

(println brcode)
  

curl --location --request GET '{{baseUrl}}/v2/dynamic-brcode/b2c3d4e5-f6a7-8901-bcde-f12345678901' \
--header 'Access-Id: {{accessId}}' \
--header 'Access-Time: {{accessTime}}' \
--header 'Access-Signature: {{accessSignature}}'
  

DynamicBrcode(
    id="5656565656565656",
    name="Jon Snow",
    city="São Paulo",
    external_id="my-dynamic-brcode-id-1",
    type="instant",
    tags=["dynamic", "instant"],
    uuid="b2c3d4e5-f6a7-8901-bcde-f12345678901",
    url="https://brcode.starkinfra.com/dynamic-qrcode/b2c3d4e5-f6a7-8901-bcde-f12345678901.png",
    created="2022-01-01T00:00:00+00:00",
    updated="2022-01-01T00:00:00+00:00"
)
  

{
    id: "5656565656565656",
    name: "Jon Snow",
    city: "São Paulo",
    externalId: "my-dynamic-brcode-id-1",
    type: "instant",
    tags: ["dynamic", "instant"],
    uuid: "b2c3d4e5-f6a7-8901-bcde-f12345678901",
    url: "https://brcode.starkinfra.com/dynamic-qrcode/b2c3d4e5-f6a7-8901-bcde-f12345678901.png",
    created: "2022-01-01T00:00:00+00:00",
    updated: "2022-01-01T00:00:00+00:00"
}
  

DynamicBrcode Object (
    [id] => 5656565656565656
    [name] => Jon Snow
    [city] => São Paulo
    [externalId] => my-dynamic-brcode-id-1
    [type] => instant
    [tags] => Array ( [0] => dynamic [1] => instant )
    [uuid] => b2c3d4e5-f6a7-8901-bcde-f12345678901
    [url] => https://brcode.starkinfra.com/dynamic-qrcode/b2c3d4e5-f6a7-8901-bcde-f12345678901.png
    [created] => 2022-01-01T00:00:00+00:00
    [updated] => 2022-01-01T00:00:00+00:00
)
  

DynamicBrcode(
    id=5656565656565656,
    name=Jon Snow,
    city=São Paulo,
    externalId=my-dynamic-brcode-id-1,
    type=instant,
    tags=[dynamic, instant],
    uuid=b2c3d4e5-f6a7-8901-bcde-f12345678901,
    url=https://brcode.starkinfra.com/dynamic-qrcode/b2c3d4e5-f6a7-8901-bcde-f12345678901.png,
    created=2022-01-01T00:00:00+00:00,
    updated=2022-01-01T00:00:00+00:00
)
  

{
    id: "5656565656565656",
    name: "Jon Snow",
    city: "São Paulo",
    external_id: "my-dynamic-brcode-id-1",
    type: "instant",
    tags: ["dynamic", "instant"],
    uuid: "b2c3d4e5-f6a7-8901-bcde-f12345678901",
    url: "https://brcode.starkinfra.com/dynamic-qrcode/b2c3d4e5-f6a7-8901-bcde-f12345678901.png",
    created: "2022-01-01T00:00:00+00:00",
    updated: "2022-01-01T00:00:00+00:00"
}
  

%StarkInfra.DynamicBrcode{
    id: "5656565656565656",
    name: "Jon Snow",
    city: "São Paulo",
    external_id: "my-dynamic-brcode-id-1",
    type: "instant",
    tags: ["dynamic", "instant"],
    uuid: "b2c3d4e5-f6a7-8901-bcde-f12345678901",
    url: "https://brcode.starkinfra.com/dynamic-qrcode/b2c3d4e5-f6a7-8901-bcde-f12345678901.png",
    created: "2022-01-01T00:00:00+00:00",
    updated: "2022-01-01T00:00:00+00:00"
}
  

DynamicBrcode(
    id: "5656565656565656",
    name: "Jon Snow",
    city: "São Paulo",
    externalId: "my-dynamic-brcode-id-1",
    type: "instant",
    tags: [ "dynamic", "instant" ],
    uuid: "b2c3d4e5-f6a7-8901-bcde-f12345678901",
    url: "https://brcode.starkinfra.com/dynamic-qrcode/b2c3d4e5-f6a7-8901-bcde-f12345678901.png",
    created: "2022-01-01T00:00:00+00:00",
    updated: "2022-01-01T00:00:00+00:00"
)
  

{
    Id: "5656565656565656",
    Name: "Jon Snow",
    City: "São Paulo",
    ExternalId: "my-dynamic-brcode-id-1",
    Type: "instant",
    Tags: ["dynamic", "instant"],
    Uuid: "b2c3d4e5-f6a7-8901-bcde-f12345678901",
    Url: "https://brcode.starkinfra.com/dynamic-qrcode/b2c3d4e5-f6a7-8901-bcde-f12345678901.png",
    Created: "2022-01-01T00:00:00+00:00",
    Updated: "2022-01-01T00:00:00+00:00"
}
  

{:id "5656565656565656"
 :name "Jon Snow"
 :city "São Paulo"
 :external-id "my-dynamic-brcode-id-1"
 :type "instant"
 :tags ["dynamic" "instant"]
 :uuid "b2c3d4e5-f6a7-8901-bcde-f12345678901"
 :url "https://brcode.starkinfra.com/dynamic-qrcode/b2c3d4e5-f6a7-8901-bcde-f12345678901.png"
 :created "2022-01-01T00:00:00+00:00"
 :updated "2022-01-01T00:00:00+00:00"}
  

{
    "brcode": {
        "id": "5656565656565656",
        "name": "Jon Snow",
        "city": "São Paulo",
        "externalId": "my-dynamic-brcode-id-1",
        "type": "instant",
        "tags": ["dynamic", "instant"],
        "uuid": "b2c3d4e5-f6a7-8901-bcde-f12345678901",
        "url": "https://brcode.starkinfra.com/dynamic-qrcode/b2c3d4e5-f6a7-8901-bcde-f12345678901.png",
        "created": "2022-01-01T00:00:00+00:00",
        "updated": "2022-01-01T00:00:00+00:00"
    }
}
  

import starkinfra


invoice = get_invoice(uuid)  # you should implement this method to get the information of the brcode from its uuid

response = starkinfra.dynamicbrcode.response_instant(
    version=invoice.version,
    created=invoice.created,
    key_id=invoice.key_id,
    status=invoice.status,
    reconciliation_id=invoice.reconciliation_id,
    amount=invoice.amount,
    cashier_type=invoice.cashier_type,
    cashier_bank_code=invoice.cashier_bank_code,
    cash_amount=invoice.cash_amount
)

send_response(response)  # you should also implement this method to answer to the read request
  

 $invoice->version,
    "created" => $invoice->created,
    "keyId" => $invoice->keyId,
    "status" => $invoice->status,
    "reconciliationId" => $invoice->reconciliationId,
    "amount" => $invoice->amount,
    "cashierType" => $invoice->cashierType,
    "cashierBankCode" => $invoice->cashierBankCode,
    "cashAmount" => $invoice->cashAmount
]);

sendResponse($response); # you should also implement this method to answer to the read request
  

{
    "version": 1,
    "created": "2022-07-29T18:00:21.264833+00:00",
    "keyId": "+5511989898989",
    "status": "created",
    "reconciliationId": "12345678901234567890123456",
    "amount": 100000
}
  

{
    "version": 1,
    "created": "2022-07-29T18:00:21.264833+00:00",
    "keyId": "+5511989898989",
    "status": "created",
    "reconciliationId": "12345678901234567890123456",
    "amount": 100000
}
  

{
    "version": 1,
    "created": "2022-07-29T18:00:21.264833+00:00",
    "keyId": "+5511989898989",
    "status": "created",
    "reconciliationId": "12345678901234567890123456",
    "amount": 100000
}
  

{
    "version": 1,
    "created": "2022-07-29T18:00:21.264833+00:00",
    "keyId": "+5511989898989",
    "status": "created",
    "reconciliationId": "12345678901234567890123456",
    "amount": 100000
}
  

{
    "version": 1,
    "created": "2022-07-29T18:00:21.264833+00:00",
    "keyId": "+5511989898989",
    "status": "created",
    "reconciliationId": "12345678901234567890123456",
    "amount": 100000
}
  

{
    "version": 1,
    "created": "2022-07-29T18:00:21.264833+00:00",
    "keyId": "+5511989898989",
    "status": "created",
    "reconciliationId": "12345678901234567890123456",
    "amount": 100000
}