Biometria com Documento — Fallback (BIOMETRIC_DOCUMENT_FALLBACK)

const tx = await client.transactions.create({
  purpose: 'DOCUMENT_SIGNATURE',
  policy: { profile: 'BIOMETRIC_DOCUMENT_FALLBACK' },
  signer: {
    name: 'João Silva',
    userExternalId: 'user-001',
  },
  document: { content: pdfBase64, filename: 'contrato.pdf' },
});

tx = client.transactions.create(CreateTransactionRequest(
    purpose='DOCUMENT_SIGNATURE',
    policy=Policy(profile='BIOMETRIC_DOCUMENT_FALLBACK'),
    signer=Signer(name='João Silva', user_external_id='user-001'),
    document=InlineDocument(content=pdf_base64, filename='contrato.pdf'),
))

tx, _ := client.Transactions.Create(ctx, &signdocs.CreateTransactionRequest{
    Purpose:  signdocs.TransactionPurposeDocumentSignature,
    Policy:   signdocs.Policy{Profile: "BIOMETRIC_DOCUMENT_FALLBACK"},
    Signer:   signdocs.Signer{Name: "João Silva", UserExternalID: "user-001"},
    Document: &signdocs.DocumentInline{Content: pdfBase64, Filename: "contrato.pdf"},
})

CreateTransactionRequest request = new CreateTransactionRequest();
request.purpose = "DOCUMENT_SIGNATURE";
request.policy = new Policy("BIOMETRIC_DOCUMENT_FALLBACK");
request.signer = new Signer("João Silva", null, "user-001");
request.document = new CreateTransactionRequest.InlineDocument(pdfBase64, "contrato.pdf");

Transaction tx = client.transactions().create(request);

$tx = $client->transactions->create(new CreateTransactionRequest(
    purpose: 'DOCUMENT_SIGNATURE',
    policy: new Policy(profile: 'BIOMETRIC_DOCUMENT_FALLBACK'),
    signer: new Signer(name: 'João Silva', userExternalId: 'user-001'),
    document: ['content' => $pdfBase64, 'filename' => 'contrato.pdf'],
));

const steps = await client.steps.list(tx.transactionId);
const docStep = steps.find(s => s.type === 'DOCUMENT_PHOTO_MATCH');

const startResp = await client.steps.start(tx.transactionId, docStep.stepId);

steps = client.steps.list(tx.transaction_id)
doc_step = next(s for s in steps if s.type == 'DOCUMENT_PHOTO_MATCH')

start_resp = client.steps.start(tx.transaction_id, doc_step.step_id)

steps, _ := client.Steps.List(ctx, tx.TransactionID)
var docStep signdocs.Step
for _, s := range steps {
    if s.Type == "DOCUMENT_PHOTO_MATCH" {
        docStep = s
        break
    }
}

startResp, _ := client.Steps.Start(ctx, tx.TransactionID, docStep.StepID, nil)

List<Step> steps = client.steps().list(tx.transactionId);
Step docStep = steps.stream()
    .filter(s -> "DOCUMENT_PHOTO_MATCH".equals(s.type))
    .findFirst().orElseThrow();

StartStepResponse startResp = client.steps().start(tx.transactionId, docStep.stepId);

$steps = $client->steps->list($tx->transactionId);
$docStep = current(array_filter($steps, fn($s) => $s->type === 'DOCUMENT_PHOTO_MATCH'));

$startResp = $client->steps->start($tx->transactionId, $docStep->stepId);

const result = await client.steps.complete(tx.transactionId, docStep.stepId, {
  referenceImage: {
    source: 'BASE64_IMAGE',
    data: documentPhotoBase64,
  },
});

result = client.steps.complete(tx.transaction_id, doc_step.step_id,
    CompleteBiometricMatchRequest(
        reference_image=ReferenceImage(data=document_photo_base64),
    ))

result, _ := client.Steps.Complete(ctx, tx.TransactionID, docStep.StepID,
    &signdocs.CompleteBiometricMatchRequest{
        ReferenceImage: &signdocs.ReferenceImage{Source: "BASE64_IMAGE", Data: documentPhotoBase64},
    })

Step result = client.steps().complete(tx.transactionId, docStep.stepId,
    Map.of("referenceImage", Map.of("source", "BASE64_IMAGE", "data", documentPhotoBase64)));

$result = $client->steps->complete($tx->transactionId, $docStep->stepId, [
    'referenceImage' => ['source' => 'BASE64_IMAGE', 'data' => $documentPhotoBase64],
]);

await client.transactions.finalize(tx.transactionId);

client.transactions.finalize(tx.transaction_id)

client.Transactions.Finalize(ctx, tx.TransactionID)

client.transactions().finalize(tx.transactionId);

$client->transactions->finalize($tx->transactionId);