Intalio.Signing.SDK 2.0.0

Intalio.Signing.SDK

Official .NET SDK for document signing. Self-contained library - pass document bytes in, get signed bytes out. No external storage configuration required.

Installation

# Package Manager
Install-Package Intalio.Signing.SDK

# .NET CLI
dotnet add package Intalio.Signing.SDK

Quick Start (Zero Configuration)

// 1. Register the SDK (Program.cs)
builder.Services.AddIntalioSigning(builder.Configuration);

// 2. Inject and use
public class MyService(ISigningService signingService)
{
    public async Task<byte[]> SignDocumentAsync(byte[] documentBytes)
    {
        // Create sign request - just pass the bytes!
        var session = await signingService.CreateSignRequestAsync(new CreateSignRequest
        {
            TenantId = "my-tenant",
            UserId = "user-123",
            DocumentBytes = documentBytes,     // Pass document bytes directly
            FileName = "contract.pdf",         // SDK detects PDF/DOCX from extension
            Placements =
            [
                new PlacementInput { PageNumber = 1, X = 100, Y = 700, Width = 200, Height = 50 }
            ]
        });

        // Finalize and get signed bytes back
        var result = await signingService.FinalizeSignRequestAsync(session.Id);

        return result.SignedDocumentBytes!;  // Your signed document!
    }
}

That's it! No storage URLs, no external dependencies. The SDK handles everything internally.

Configuration Options

Minimal (In-Memory, No Persistence)

{
  "Signer": {
    "StorageMode": "InMemory",
    "PersistToDatabase": false
  },
  "Database": {
    "Provider": "InMemory"
  }
}

With Database Persistence

{
  "Signer": {
    "StorageMode": "Database",
    "PersistToDatabase": true,
    "RetentionDays": 90,
    "Providers": "Aspose"
  },
  "Database": {
    "Provider": "SqlServer",
    "ConnectionString": "Server=...;Database=SigningDB;..."
  },
  "Aspose": {
    "LicensePath": "C:\\licenses\\Aspose.Total.lic"
  }
}

Storage Modes

SigningOptions

builder.Services.AddIntalioSigning(builder.Configuration, options =>
{
    options.StorageMode = StorageMode.InMemory;       // InMemory | Database | External
    options.PersistToDatabase = false;                // Save to DB?
    options.IncludeSignedBytesInResponse = true;      // Return bytes in response?
    options.MaxDocumentSizeBytes = 50 * 1024 * 1024;  // 50MB limit
    options.RetentionDays = 90;                       // For DB persistence
});

Features

• Self-Contained - Pass bytes in, get signed bytes out
• Zero Configuration - Works out of the box with InMemory mode
• PDF & DOCX Support - PAdES-LT signing standard
• Multiple Providers - Aspose (default), UAE Pass, DocuSign
• Multi-Party Signing - Sequential, Parallel, Quorum patterns
• Bulk Signing - Sign multiple documents in batch
• Flexible Storage - InMemory, Database, or External
• Full Audit Trail - When persistence is enabled

Multi-Party Signing

var session = await signingService.CreateSignRequestAsync(new CreateSignRequest
{
    TenantId = "my-tenant",
    UserId = "initiator",
    DocumentBytes = documentBytes,
    FileName = "contract.pdf",
    Pattern = "Sequential",  // Sequential | Parallel | Quorum
    Signers =
    [
        new SignerInput { UserId = "manager", Role = "Approver" },
        new SignerInput { UserId = "director", Role = "Signer" }
    ],
    Placements =
    [
        new PlacementInput { PageNumber = 1, X = 100, Y = 600, SignerUserId = "manager" },
        new PlacementInput { PageNumber = 1, X = 100, Y = 700, SignerUserId = "director" }
    ]
});

// Each signer completes their action
await signingService.CompleteSignerAsync(session.Id, signerId);

Bulk Signing

var job = await signingService.SubmitBulkSignAsync(new BulkSignRequest
{
    TenantId = "my-tenant",
    UserId = "user-123",
    Documents =
    [
        new BulkDocumentInput { DocumentBytes = doc1Bytes, FileName = "doc1.pdf" },
        new BulkDocumentInput { DocumentBytes = doc2Bytes, FileName = "doc2.pdf" }
    ],
    Placements = [new PlacementInput { PageNumber = 1, X = 100, Y = 700 }]
});

// Check progress
var status = await signingService.GetBulkSignJobAsync(job.Id);

API Reference

Advanced: Direct Database Access

For advanced scenarios, you can access Domain entities and Infrastructure services directly:

using Platform.Signer.Domain.Entities;
using Platform.Signer.Domain.Interfaces;
using Platform.Signer.Domain.Enums;
using Platform.Signer.Infrastructure.Persistence;

public class MyAdvancedService(
    ISigningSessionRepository sessionRepository,
    ICertificateRepository certificateRepository,
    IUnitOfWork unitOfWork,
    SigningDbContext dbContext)  // Direct DbContext access!
{
    public async Task CustomQueryAsync()
    {
        // Direct DbContext for custom queries
        var sessions = await dbContext.SigningSessions
            .Where(s => s.TenantId == "tenant-1" && s.Status == SigningStatus.Signed)
            .Include(s => s.Signers)
            .ToListAsync();
    }

    public async Task CustomInsertAsync()
    {
        // Direct entity creation
        var session = SigningSession.Create(
            tenantId: "tenant-1",
            documentRef: "doc.pdf",
            provider: SigningProvider.Aspose,
            placements: new[] { new Placement(1, 100, 700, 200, 50) },
            pattern: SigningPattern.Single);

        await sessionRepository.AddAsync(session);
        await unitOfWork.SaveChangesAsync();
    }
}

Available Types

Documentation

See full documentation for complete API reference.

License

MIT