- name: Checkout code

uses: actions/checkout@v4

- name: Setup .NET

uses: actions/setup-dotnet@v4

with:

dotnet-version: "10.0.x" # Adjust the .NET version as needed

- name: Restore dependencies

run: dotnet restore

- name: Build

run: dotnet build --configuration Release --no-restore

- name: Pack

run: dotnet pack --configuration Release --no-build --output ./nupkg

- name: Install xmllint

run: sudo apt-get update && sudo apt-get install -y libxml2-utils

- name: Check if version exists on NuGet

id: version-check

run: |

- name: Publish to NuGet

if: steps.version-check.outputs.exists == 'false'

run: dotnet nuget push ./nupkg/*.nupkg --api-key ${{ secrets.NUGET_API_KEY }} --source https://api.nuget.org/v3/index.json

- Wrappers can no longer be constructed directly; their constructors are internal and they are intended to be used only through `FacturapiClient`.

- Renamed existing methods to match documented C# surface: `Organization.List/Create/Update/DeleteSeriesAsync` (were `*SeriesGroupAsync`), `Invoice.UpdateStatusAsync` (was `UpdateStatus`), and `Tool.ValidateTaxIdAsync` (was `ValidateTaxId`).

- Carta Porte catalog methods moved to a dedicated `CartaporteCatalogWrapper`; `CartaporteCatalog` is now of that type, and `CatalogWrapper` retains only product/unit catalogs.

- Expose webhook methods through `FacturapiClient`/`IFacturapiClient`.

- New organization endpoints: `MeAsync` (`/organizations/me`), `CheckDomainIsAvailableAsync`, `UpdateReceiptSettingsAsync`, and `UpdateDomainAsync`.

- New `CartaporteCatalogWrapper` for Carta Porte catalog searches.

- Added `DomainAvailability` model for domain check responses.

- Added `Tool.HealthCheckAsync` for `/check`.

- Introduced `IFacturapiClient` so consumers can mock the client surface in tests.

- Optional `CancellationToken` parameters on client methods to allow request cancellation from callers.

- `FacturapiClient` now implements `IDisposable`; call `Dispose()` when finished (or wrap in `using`) to release HTTP resources. If not disposed, garbage collection will eventually clean up, but explicit disposal avoids lingering HTTP connections.

- `Invoices.PreviewPdfAsync` now calls the documented POST endpoint with a JSON body (breaking change to the method signature).

- `Receipts.CreateGlobalInvoiceAsync` posts directly to `/receipts/global-invoice` and no longer requires an id (breaking change to the signature).

- Receipt routes now hit `/receipts/{id}` for cancel, invoice, email, and PDF download instead of invoice endpoints.

- `Organizations.CreateSeriesAsync` uses POST (not PUT) to `/organizations/{id}/series-group`, matching the API.

using Facturapi.Wrappers;

using System;

using System.Net.Http;

using System.Net.Http.Headers;

using System.Text;

namespace Facturapi

public sealed class FacturapiClient : IFacturapiClient

public CustomerWrapper Customer { get; private set; }

public ProductWrapper Product { get; private set; }

public InvoiceWrapper Invoice { get; private set; }

public OrganizationWrapper Organization { get; private set; }

public ReceiptWrapper Receipt { get; private set; }

public RetentionWrapper Retention { get; private set; }

public CatalogWrapper Catalog { get; private set; }

public CartaporteCatalogWrapper CartaporteCatalog { get; private set; }

public ToolWrapper Tool { get; private set; }

public WebhookWrapper Webhook { get; private set; }

private readonly HttpClient httpClient;

private bool disposed;

var apiKeyBase64 = Convert.ToBase64String(Encoding.UTF8.GetBytes(apiKey + ":"));

this.httpClient = new HttpClient

{

BaseAddress = new Uri($"https://www.facturapi.io/{apiVersion}/")

};

this.httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", apiKeyBase64);

this.Customer = new CustomerWrapper(apiKey, apiVersion, this.httpClient);

this.Product = new ProductWrapper(apiKey, apiVersion, this.httpClient);

this.Invoice = new InvoiceWrapper(apiKey, apiVersion, this.httpClient);

this.Organization = new OrganizationWrapper(apiKey, apiVersion, this.httpClient);

this.Receipt = new ReceiptWrapper(apiKey, apiVersion, this.httpClient);

this.Retention = new RetentionWrapper(apiKey, apiVersion, this.httpClient);

this.Catalog = new CatalogWrapper(apiKey, apiVersion, this.httpClient);

this.CartaporteCatalog = new CartaporteCatalogWrapper(apiKey, apiVersion, this.httpClient);

this.Tool = new ToolWrapper(apiKey, apiVersion, this.httpClient);

this.Webhook = new WebhookWrapper(apiKey, apiVersion, this.httpClient);

}

public void Dispose()

{

if (this.disposed)

{

return;

}

this.httpClient?.Dispose();

this.disposed = true;

GC.SuppressFinalize(this);

using Facturapi.Wrappers;

using System;

namespace Facturapi

public interface IFacturapiClient : IDisposable

{

CustomerWrapper Customer { get; }

ProductWrapper Product { get; }

InvoiceWrapper Invoice { get; }

OrganizationWrapper Organization { get; }

ReceiptWrapper Receipt { get; }

RetentionWrapper Retention { get; }

CatalogWrapper Catalog { get; }

CartaporteCatalogWrapper CartaporteCatalog { get; }

ToolWrapper Tool { get; }

WebhookWrapper Webhook { get; }

}

namespace Facturapi

public class DomainAvailability

{

public bool Available { get; set; }

}

namespace Facturapi

internal static partial class Router

{

public static string HealthCheck()

{

return "check";

}

}

public static string PreviewPdf()

return "invoices/preview/pdf";

public static string OrganizationMe()

{

return "organizations/me";

}

public static string CheckDomainAvailability(Dictionary<string, object> query = null)

{

return UriWithQuery("organizations/domain-check", query);

}

public static string UpdateReceipts(string id)

{

return $"{RetrieveOrganization(id)}/receipts";

}

public static string UpdateDomain(string organizationId)

{

return $"{RetrieveOrganization(organizationId)}/domain";

}

return $"receipts/{id}/invoice";

public static string CreateGlobalInvoice()

return $"receipts/{id}/pdf";

return $"receipts/{id}/email";

using System.Threading;

public BaseWrapper(string apiKey, string apiVersion, HttpClient httpClient)

this.apiKey = apiKey;

this.apiVersion = apiVersion;

this.client = httpClient ?? throw new ArgumentNullException(nameof(httpClient));

protected async Task ThrowIfErrorAsync(HttpResponseMessage response, CancellationToken cancellationToken = default)

cancellationToken.ThrowIfCancellationRequested();