Envelopes para Assinatura Expressa

import { readFileSync } from 'fs';

const pdfBase64 = readFileSync('contrato.pdf').toString('base64');

const envelope = await client.envelopes.create({
  signingMode: 'SEQUENTIAL',
  totalSigners: 2,
  document: {
    content: pdfBase64,
    filename: 'contrato-prestacao-servicos.pdf',
  },
  returnUrl: 'https://app.empresa.com.br/assinatura/sucesso',
  cancelUrl: 'https://app.empresa.com.br/assinatura/cancelado',
  expiresInMinutes: 4320, // 3 dias
  metadata: { contractId: 'CTR-2026-001' },
});

console.log(envelope.envelopeId); // "env_01J..."
console.log(envelope.status);     // "CREATED"

import base64
from pathlib import Path
from signdocs_brasil.models.envelope import CreateEnvelopeRequest

pdf_base64 = base64.b64encode(Path('contrato.pdf').read_bytes()).decode()

envelope = client.envelopes.create(CreateEnvelopeRequest(
    signing_mode='SEQUENTIAL',
    total_signers=2,
    document_content=pdf_base64,
    document_filename='contrato-prestacao-servicos.pdf',
    return_url='https://app.empresa.com.br/assinatura/sucesso',
    cancel_url='https://app.empresa.com.br/assinatura/cancelado',
    expires_in_minutes=4320,  # 3 dias
    metadata={'contractId': 'CTR-2026-001'},
))

print(envelope.envelope_id)  # "env_01J..."
print(envelope.status)       # "CREATED"

pdfBytes, _ := os.ReadFile("contrato.pdf")
pdfBase64 := base64.StdEncoding.EncodeToString(pdfBytes)

envelope, err := client.Envelopes.Create(ctx, &signdocs.CreateEnvelopeRequest{
    SigningMode:  "SEQUENTIAL",
    TotalSigners: 2,
    Document: signdocs.EnvelopeDocument{
        Content:  pdfBase64,
        Filename: "contrato-prestacao-servicos.pdf",
    },
    ReturnURL:        "https://app.empresa.com.br/assinatura/sucesso",
    CancelURL:        "https://app.empresa.com.br/assinatura/cancelado",
    ExpiresInMinutes: 4320,
    Metadata:         map[string]string{"contractId": "CTR-2026-001"},
})
if err != nil { log.Fatal(err) }

fmt.Println(envelope.EnvelopeID) // "env_01J..."
fmt.Println(envelope.Status)     // "CREATED"

byte[] pdfBytes = Files.readAllBytes(Path.of("contrato.pdf"));
String pdfBase64 = Base64.getEncoder().encodeToString(pdfBytes);

Envelope envelope = client.envelopes().create(CreateEnvelopeRequest.builder()
    .signingMode("SEQUENTIAL")
    .totalSigners(2)
    .documentContent(pdfBase64)
    .documentFilename("contrato-prestacao-servicos.pdf")
    .returnUrl("https://app.empresa.com.br/assinatura/sucesso")
    .cancelUrl("https://app.empresa.com.br/assinatura/cancelado")
    .expiresInMinutes(4320)
    .metadata(Map.of("contractId", "CTR-2026-001"))
    .build());

System.out.println(envelope.getEnvelopeId()); // "env_01J..."
System.out.println(envelope.getStatus());     // "CREATED"

$pdfBase64 = base64_encode(file_get_contents('contrato.pdf'));

$envelope = $client->envelopes()->create([
    'signingMode' => 'SEQUENTIAL',
    'totalSigners' => 2,
    'document' => [
        'content' => $pdfBase64,
        'filename' => 'contrato-prestacao-servicos.pdf',
    ],
    'returnUrl' => 'https://app.empresa.com.br/assinatura/sucesso',
    'cancelUrl' => 'https://app.empresa.com.br/assinatura/cancelado',
    'expiresInMinutes' => 4320,
    'metadata' => ['contractId' => 'CTR-2026-001'],
]);

echo $envelope->envelopeId; // "env_01J..."
echo $envelope->status;     // "CREATED"

var pdfBase64 = Convert.ToBase64String(File.ReadAllBytes("contrato.pdf"));

var envelope = await client.Envelopes.CreateAsync(new CreateEnvelopeRequest
{
    SigningMode = "SEQUENTIAL",
    TotalSigners = 2,
    Document = new EnvelopeDocument
    {
        Content = pdfBase64,
        Filename = "contrato-prestacao-servicos.pdf",
    },
    ReturnUrl = "https://app.empresa.com.br/assinatura/sucesso",
    CancelUrl = "https://app.empresa.com.br/assinatura/cancelado",
    ExpiresInMinutes = 4320,
    Metadata = new Dictionary<string, string> { ["contractId"] = "CTR-2026-001" },
});

Console.WriteLine(envelope.EnvelopeId); // "env_01J..."
Console.WriteLine(envelope.Status);     // "CREATED"

// Signatário 1 — Diretor Financeiro (biometria + OTP)
const session1 = await client.envelopes.addSession(envelope.envelopeId, {
  signer: {
    userExternalId: 'usr_maria_001',
    name: 'Maria Souza',
    cpf: '123.456.789-00',
    email: 'maria.souza@empresa.com.br',
    phone: '+5511999990001',
    otpChannel: 'SMS',
  },
  policy: { profile: 'BIOMETRIC_PLUS_OTP' },
  signerIndex: 1,
  metadata: { role: 'CFO' },
});

console.log(session1.url);          // URL da página de assinatura
console.log(session1.clientSecret); // Para integração via SDK frontend

// Signatário 2 — Diretor Jurídico (aceite simples)
const session2 = await client.envelopes.addSession(envelope.envelopeId, {
  signer: {
    userExternalId: 'usr_carlos_002',
    name: 'Carlos Lima',
    cpf: '987.654.321-00',
  },
  policy: { profile: 'CLICK_ONLY' },
  signerIndex: 2,
});

from signdocs_brasil.models.envelope import AddEnvelopeSessionRequest

# Signatário 1 — Diretor Financeiro (biometria + OTP)
session1 = client.envelopes.add_session(envelope.envelope_id, AddEnvelopeSessionRequest(
    signer_name='Maria Souza',
    signer_cpf='123.456.789-00',
    signer_email='maria.souza@empresa.com.br',
    signer_phone='+5511999990001',
    signer_otp_channel='SMS',
    signer_user_external_id='usr_maria_001',
    policy_profile='BIOMETRIC_PLUS_OTP',
    signer_index=1,
    metadata={'role': 'CFO'},
))

print(session1.url)            # URL da página de assinatura
print(session1.client_secret)  # Para integração via SDK frontend

# Signatário 2 — Diretor Jurídico (aceite simples)
session2 = client.envelopes.add_session(envelope.envelope_id, AddEnvelopeSessionRequest(
    signer_name='Carlos Lima',
    signer_cpf='987.654.321-00',
    signer_user_external_id='usr_carlos_002',
    policy_profile='CLICK_ONLY',
    signer_index=2,
))

// Signatário 1 — Diretor Financeiro (biometria + OTP)
session1, err := client.Envelopes.AddSession(ctx, envelope.EnvelopeID, &signdocs.AddEnvelopeSessionRequest{
    Signer: signdocs.Signer{
        UserExternalID: "usr_maria_001",
        Name:           "Maria Souza",
        CPF:            "123.456.789-00",
        Email:          "maria.souza@empresa.com.br",
        Phone:          "+5511999990001",
        OTPChannel:     "SMS",
    },
    Policy:      signdocs.Policy{Profile: "BIOMETRIC_PLUS_OTP"},
    SignerIndex:  1,
    Metadata:    map[string]string{"role": "CFO"},
})
if err != nil { log.Fatal(err) }

fmt.Println(session1.URL)          // URL da página de assinatura
fmt.Println(session1.ClientSecret) // Para integração via SDK frontend

// Signatário 2 — Diretor Jurídico (aceite simples)
session2, err := client.Envelopes.AddSession(ctx, envelope.EnvelopeID, &signdocs.AddEnvelopeSessionRequest{
    Signer: signdocs.Signer{
        UserExternalID: "usr_carlos_002",
        Name:           "Carlos Lima",
        CPF:            "987.654.321-00",
    },
    Policy:     signdocs.Policy{Profile: "CLICK_ONLY"},
    SignerIndex: 2,
})
if err != nil { log.Fatal(err) }

// Signatário 1 — Diretor Financeiro (biometria + OTP)
EnvelopeSession session1 = client.envelopes().addSession(
    envelope.getEnvelopeId(),
    AddEnvelopeSessionRequest.builder()
        .signerName("Maria Souza")
        .signerCpf("123.456.789-00")
        .signerEmail("maria.souza@empresa.com.br")
        .signerPhone("+5511999990001")
        .signerOtpChannel("SMS")
        .signerUserExternalId("usr_maria_001")
        .policyProfile("BIOMETRIC_PLUS_OTP")
        .signerIndex(1)
        .metadata(Map.of("role", "CFO"))
        .build());

System.out.println(session1.getUrl());          // URL da página de assinatura
System.out.println(session1.getClientSecret()); // Para integração via SDK frontend

// Signatário 2 — Diretor Jurídico (aceite simples)
EnvelopeSession session2 = client.envelopes().addSession(
    envelope.getEnvelopeId(),
    AddEnvelopeSessionRequest.builder()
        .signerName("Carlos Lima")
        .signerCpf("987.654.321-00")
        .signerUserExternalId("usr_carlos_002")
        .policyProfile("CLICK_ONLY")
        .signerIndex(2)
        .build());

// Signatário 1 — Diretor Financeiro (biometria + OTP)
$session1 = $client->envelopes()->addSession($envelope->envelopeId, [
    'signer' => [
        'userExternalId' => 'usr_maria_001',
        'name' => 'Maria Souza',
        'cpf' => '123.456.789-00',
        'email' => 'maria.souza@empresa.com.br',
        'phone' => '+5511999990001',
        'otpChannel' => 'SMS',
    ],
    'policy' => ['profile' => 'BIOMETRIC_PLUS_OTP'],
    'signerIndex' => 1,
    'metadata' => ['role' => 'CFO'],
]);

echo $session1->url;          // URL da página de assinatura
echo $session1->clientSecret; // Para integração via SDK frontend

// Signatário 2 — Diretor Jurídico (aceite simples)
$session2 = $client->envelopes()->addSession($envelope->envelopeId, [
    'signer' => [
        'userExternalId' => 'usr_carlos_002',
        'name' => 'Carlos Lima',
        'cpf' => '987.654.321-00',
    ],
    'policy' => ['profile' => 'CLICK_ONLY'],
    'signerIndex' => 2,
]);

// Signatário 1 — Diretor Financeiro (biometria + OTP)
var session1 = await client.Envelopes.AddSessionAsync(envelope.EnvelopeId, new AddEnvelopeSessionRequest
{
    Signer = new Signer
    {
        UserExternalId = "usr_maria_001",
        Name = "Maria Souza",
        Cpf = "123.456.789-00",
        Email = "maria.souza@empresa.com.br",
        Phone = "+5511999990001",
        OtpChannel = "SMS",
    },
    Policy = new Policy { Profile = "BIOMETRIC_PLUS_OTP" },
    SignerIndex = 1,
    Metadata = new Dictionary<string, string> { ["role"] = "CFO" },
});

Console.WriteLine(session1.Url);          // URL da página de assinatura
Console.WriteLine(session1.ClientSecret); // Para integração via SDK frontend

// Signatário 2 — Diretor Jurídico (aceite simples)
var session2 = await client.Envelopes.AddSessionAsync(envelope.EnvelopeId, new AddEnvelopeSessionRequest
{
    Signer = new Signer
    {
        UserExternalId = "usr_carlos_002",
        Name = "Carlos Lima",
        Cpf = "987.654.321-00",
    },
    Policy = new Policy { Profile = "CLICK_ONLY" },
    SignerIndex = 2,
});

const detail = await client.envelopes.get(envelope.envelopeId);

console.log(detail.status);            // "ACTIVE"
console.log(detail.completedSessions); // 1
console.log(detail.totalSigners);      // 2

for (const s of detail.sessions) {
  console.log(`${s.signerName} (${s.signerIndex}): ${s.status}`);
}

detail = client.envelopes.get(envelope.envelope_id)

print(detail.status)              # "ACTIVE"
print(detail.completed_sessions)  # 1
print(detail.total_signers)       # 2

for s in detail.sessions:
    print(f"{s.signer_name} ({s.signer_index}): {s.status}")

detail, err := client.Envelopes.Get(ctx, envelope.EnvelopeID)
if err != nil { log.Fatal(err) }

fmt.Println(detail.Status)            // "ACTIVE"
fmt.Println(detail.CompletedSessions) // 1
fmt.Println(detail.TotalSigners)      // 2

for _, s := range detail.Sessions {
    fmt.Printf("%s (%d): %s\n", s.SignerName, s.SignerIndex, s.Status)
}

EnvelopeDetail detail = client.envelopes().get(envelope.getEnvelopeId());

System.out.println(detail.getStatus());            // "ACTIVE"
System.out.println(detail.getCompletedSessions()); // 1
System.out.println(detail.getTotalSigners());       // 2

for (EnvelopeSessionSummary s : detail.getSessions()) {
    System.out.printf("%s (%d): %s%n", s.getSignerName(), s.getSignerIndex(), s.getStatus());
}

$detail = $client->envelopes()->get($envelope->envelopeId);

echo $detail->status;            // "ACTIVE"
echo $detail->completedSessions; // 1
echo $detail->totalSigners;      // 2

foreach ($detail->sessions as $s) {
    echo "{$s->signerName} ({$s->signerIndex}): {$s->status}\n";
}

var detail = await client.Envelopes.GetAsync(envelope.EnvelopeId);

Console.WriteLine(detail.Status);            // "ACTIVE"
Console.WriteLine(detail.CompletedSessions); // 1
Console.WriteLine(detail.TotalSigners);      // 2

foreach (var s in detail.Sessions)
{
    Console.WriteLine($"{s.SignerName} ({s.SignerIndex}): {s.Status}");
}

const combined = await client.envelopes.combinedStamp(envelope.envelopeId);

console.log(combined.downloadUrl); // URL temporária para download
console.log(combined.signerCount); // 2

// Baixar o PDF combinado
const res = await fetch(combined.downloadUrl);
const pdf = Buffer.from(await res.arrayBuffer());
writeFileSync('contrato-assinado-completo.pdf', pdf);

import httpx

combined = client.envelopes.combined_stamp(envelope.envelope_id)

print(combined.download_url)  # URL temporária para download
print(combined.signer_count)  # 2

# Baixar o PDF combinado
pdf = httpx.get(combined.download_url).content
Path('contrato-assinado-completo.pdf').write_bytes(pdf)

combined, err := client.Envelopes.CombinedStamp(ctx, envelope.EnvelopeID)
if err != nil { log.Fatal(err) }

fmt.Println(combined.DownloadURL) // URL temporária para download
fmt.Println(combined.SignerCount) // 2

// Baixar o PDF combinado
resp, _ := http.Get(combined.DownloadURL)
defer resp.Body.Close()
pdf, _ := io.ReadAll(resp.Body)
os.WriteFile("contrato-assinado-completo.pdf", pdf, 0644)

CombinedStampResponse combined = client.envelopes().combinedStamp(envelope.getEnvelopeId());

System.out.println(combined.getDownloadUrl()); // URL temporária para download
System.out.println(combined.getSignerCount()); // 2

// Baixar o PDF combinado
byte[] pdf = new URL(combined.getDownloadUrl()).openStream().readAllBytes();
Files.write(Path.of("contrato-assinado-completo.pdf"), pdf);

$combined = $client->envelopes()->combinedStamp($envelope->envelopeId);

echo $combined->downloadUrl; // URL temporária para download
echo $combined->signerCount; // 2

// Baixar o PDF combinado
$pdf = file_get_contents($combined->downloadUrl);
file_put_contents('contrato-assinado-completo.pdf', $pdf);

var combined = await client.Envelopes.CombinedStampAsync(envelope.EnvelopeId);

Console.WriteLine(combined.DownloadUrl); // URL temporária para download
Console.WriteLine(combined.SignerCount); // 2

// Baixar o PDF combinado
var pdf = await new HttpClient().GetByteArrayAsync(combined.DownloadUrl);
File.WriteAllBytes("contrato-assinado-completo.pdf", pdf);