PHPackages                             arturas88/finvalda-sdk - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [API Development](/categories/api)
4. /
5. arturas88/finvalda-sdk

ActiveLibrary[API Development](/categories/api)

arturas88/finvalda-sdk
======================

PHP SDK for Finvalda (FVS) accounting software web service API

v0.1.0(1mo ago)00MITPHPPHP ^8.3CI passing

Since Mar 22Pushed 1mo agoCompare

[ Source](https://github.com/arturas88/finvalda-sdk)[ Packagist](https://packagist.org/packages/arturas88/finvalda-sdk)[ Docs](https://github.com/arturas88/finvalda-sdk)[ RSS](/packages/arturas88-finvalda-sdk/feed)WikiDiscussions main Synced 1mo ago

READMEChangelogDependencies (3)Versions (2)Used By (0)

Finvalda PHP SDK
================

[](#finvalda-php-sdk)

PHP SDK for the [Finvalda (FVS)](https://www.finvalda.lt/) accounting software web service API.

Built from the official [Finvalda API documentation](https://documenter.getpostman.com/view/7208231/2s8YmRMLvd).

Requirements
------------

[](#requirements)

- PHP >= 8.3
- Guzzle HTTP client

Installation
------------

[](#installation)

```
composer require arturas88/finvalda-sdk
```

Configuration
-------------

[](#configuration)

```
use Finvalda\Finvalda;
use Finvalda\FinvaldaConfig;
use Finvalda\Enums\Language;

$config = new FinvaldaConfig(
    baseUrl: 'https://your-server.com/FvsServicePure.svc',
    username: 'your-username',
    password: 'your-password',
    // Optional:
    connString: null,           // Database connection string
    companyId: null,            // Company ID for multi-database setups
    language: Language::Lithuanian, // or Language::English
    removeEmptyStringTags: false,
    removeZeroNumberTags: false,
    removeNewLines: false,
    timeout: 30,
);

$finvalda = new Finvalda($config);
```

### Laravel Integration

[](#laravel-integration)

The package auto-registers via Laravel package discovery. Add your credentials to `.env`:

```
FINVALDA_BASE_URL=https://your-server.com/FvsServicePure.svc
FINVALDA_USERNAME=your-username
FINVALDA_PASSWORD=your-password
FINVALDA_COMPANY_ID=your-company-id
```

Publish the config file (optional):

```
php artisan vendor:publish --tag=finvalda-config
```

Then inject or use the facade:

```
// Dependency injection
public function index(Finvalda\Finvalda $finvalda)
{
    $clients = $finvalda->clients()->list();
}

// Facade
use Finvalda\Laravel\Facades\Finvalda;

$clients = Finvalda::clients()->list();
```

### Custom HTTP Client (Testing)

[](#custom-http-client-testing)

You can inject a custom Guzzle client for testing or custom configuration:

```
use GuzzleHttp\Client;
use GuzzleHttp\Handler\MockHandler;
use GuzzleHttp\HandlerStack;
use GuzzleHttp\Psr7\Response;

$mock = new MockHandler([
    new Response(200, [], json_encode(['AccessResult' => 'Success', 'items' => []])),
]);

$httpClient = new \Finvalda\HttpClient($config, new Client(['handler' => HandlerStack::create($mock)]));
```

Usage
-----

[](#usage)

All methods return a `Response` object with:

- `$response->successful()` - whether the request succeeded
- `$response->data` - the response data array
- `$response->error` - error message if failed
- `$response->raw` - full raw response array

### Stock / Inventory

[](#stock--inventory)

```
// Current stock balances
$response = $finvalda->stock()->balances();
$response = $finvalda->stock()->balances(productCode: 'PROD001', warehouseCode: 'WH01');

// Extended balances (includes product type, tags)
$response = $finvalda->stock()->balancesExtended();

// Balances with selling prices
$response = $finvalda->stock()->balancesWithPrices(includeZeroQuantity: true);

// Balances by warehouse group
$response = $finvalda->stock()->balancesByGroup(warehouseGroupCode: 'GROUP1');

// Ordered products
$response = $finvalda->stock()->orderedProducts();
```

### Clients

[](#clients)

```
// List clients
$response = $finvalda->clients()->list();
$response = $finvalda->clients()->list(modifiedSince: '2024-01-01');

// Get single client
$response = $finvalda->clients()->get('CLIENT001');

// All clients (with optional date filters)
$response = $finvalda->clients()->all();
$response = $finvalda->clients()->all(modifiedSince: '2024-01-01');

// Client email
$response = $finvalda->clients()->email('CLIENT001');

// Client types and tags
$response = $finvalda->clients()->typesAndTags();

// Clients by type
$response = $finvalda->clients()->byType('VIP');

// Accounts (with full filter support)
$response = $finvalda->clients()->accounts(clientCode: 'CLIENT001');
$response = $finvalda->clients()->accounts(
    clientCode: 'CLIENT001',
    journalGroup: 'PARD',
    debtType: 1,
    documentDateFrom: '2024-01-01',
    documentDateTo: '2024-12-31',
);

// Unpaid documents (sales and purchases)
$response = $finvalda->clients()->unpaidDocuments('CLIENT001');
$response = $finvalda->clients()->unpaidPurchaseDocuments('CLIENT001');

// Client debt condition
$response = $finvalda->clients()->debtCondition('CLIENT001', journalGroup: 'PARD');

// Settlements (with journal/number support)
$response = $finvalda->clients()->settlements(series: 'SER', document: 'DOC001');
$response = $finvalda->clients()->settlements(journal: 'PARD', number: 123);

// Detailed settlements
$response = $finvalda->clients()->settlementsDetailed(
    series: 'SER',
    document: 'DOC001',
    operationId: 1,
    operationClass: 2,
);

// Settlements from date
$response = $finvalda->clients()->settlementsFromDate(
    series: 'SER',
    document: 'DOC001',
    modifiedSince: '2024-01-01',
);

// Settlements with XML parameter
$response = $finvalda->clients()->settlementsFromDateParam('...');

// Create / update client
$result = $finvalda->clients()->create([
    'sKodas' => 'NEW001',
    'sPavadinimas' => 'New Client Ltd',
    'sDebtSask' => '2410',
    'sKredSask' => '5001',
    'sPvmMokKod' => 'LT',
]);

$result = $finvalda->clients()->update([
    'sKodas' => 'NEW001',
    'sPavadinimas' => 'Updated Client Name',
]);

// Delete a client
$result = $finvalda->clients()->delete('CLIENT001');

// Invoices related to a customer
$response = $finvalda->clients()->invoicesRelatedToCustomer('CLIENT001', debtType: 0);
```

### Products

[](#products)

```
// List products
$response = $finvalda->products()->list();

// Extended list with filters
$response = $finvalda->products()->listExtended(
    type: 'ELECTRONICS',
    supplier1: 'SUPP01',
    modifiedSince: '2024-01-01',
);

// Single product
$response = $finvalda->products()->get('PROD001');

// All products (with optional date filters)
$response = $finvalda->products()->all(modifiedSince: '2024-01-01');

// Product image
$response = $finvalda->products()->image('PROD001');

// Products in warehouse (with date filters)
$response = $finvalda->products()->inWarehouse('WH01', modifiedSince: '2024-01-01');
$response = $finvalda->products()->inWarehouseOrdered('WH01', order: 1);

// Types, tags, and type groups
$response = $finvalda->products()->typesAndTags();
$response = $finvalda->products()->typeGroups();
$response = $finvalda->products()->typeGroupComposition('GRP01');

// Product history
$response = $finvalda->products()->history('PROD001', dateFrom: '2024-01-01');

// Sold products per period
$response = $finvalda->products()->soldPerPeriod(
    productCode: 'PROD001',
    warehouseCode: 'WH01',
    dateFrom: '2024-01-01',
    dateTo: '2024-12-31',
    salesJournalCode: 'PARD',
);

// Create / update
$result = $finvalda->products()->create([
    'sKodas' => 'NEWPROD',
    'sPavadinimas' => 'New Product',
    'sRysysSuSask' => '2414',
    'sMatavimoVnt' => 'vnt',
    'sMokestis' => 'PVM1',
]);

// Update a product
$result = $finvalda->products()->update([
    'sKodas' => 'PROD001',
    'sPavadinimas' => 'Updated Product Name',
]);

// Batch edit properties
$result = $finvalda->products()->editProperties('PROD001', [
    'dKaina1' => 19.99,
    'sRusis' => 'ELECTRONICS',
]);

// Delete a product
$result = $finvalda->products()->delete('PROD001');
```

### Services

[](#services)

```
$response = $finvalda->services()->list();
$response = $finvalda->services()->get('SVC001');
$response = $finvalda->services()->all(modifiedSince: '2024-01-01');
$response = $finvalda->services()->typesAndTags();
$response = $finvalda->services()->byType('CONSULTING');

$result = $finvalda->services()->create([
    'sKodas' => 'NEWSVC',
    'sPavadinimas' => 'New Service',
    'sRysysSuSask' => '5001',
    'sMokestis' => 'PVM1',
]);

$result = $finvalda->services()->update(['sKodas' => 'SVC001', 'sPavadinimas' => 'Updated']);
$result = $finvalda->services()->delete('SVC001');
```

### Objects (6 Levels)

[](#objects-6-levels)

```
// List objects at level 1-6
$response = $finvalda->objects()->list(level: 1);
$response = $finvalda->objects()->list(level: 2, objectCode: 'OBJ001');

// Get single object
$response = $finvalda->objects()->get(level: 1, objectCode: 'OBJ001');

// Create / update
$result = $finvalda->objects()->create(level: 1, data: [
    'sKodas' => 'DEPT01',
    'sPavadinimas' => 'Sales Department',
]);

$result = $finvalda->objects()->update(level: 1, data: [
    'sKodas' => 'DEPT01',
    'sPavadinimas' => 'Updated Department',
]);
```

### Transactions (Financial Detail Data)

[](#transactions-financial-detail-data)

Read transaction details using typed filter DTOs:

```
use Finvalda\Filters\TransactionFilter;
use Finvalda\Filters\PaymentFilter;

// Create a reusable filter
$filter = new TransactionFilter(
    dateFrom: '2024-01-01',
    dateTo: '2024-12-31',
    journalGroup: 'PARD_GRP',
);

// Sales (headers, detail lines, detail with prime cost)
$response = $finvalda->transactions()->sales($filter);
$response = $finvalda->transactions()->salesDetail(new TransactionFilter(journal: 'PARD', opNumber: 123));
$response = $finvalda->transactions()->salesDetailWithPrimeCost($filter);

// Sale Reservations
$response = $finvalda->transactions()->saleReservations($filter);
$response = $finvalda->transactions()->saleReservationsDetail($filter);

// Sales Returns
$response = $finvalda->transactions()->salesReturns($filter);
$response = $finvalda->transactions()->salesReturnsDetail($filter);

// DateTimeInterface is also accepted
$filter = new TransactionFilter(
    dateFrom: new \DateTime('2024-01-01'),
    dateTo: new \DateTimeImmutable('2024-12-31'),
);

// Purchases (headers, detail, extended detail)
$response = $finvalda->transactions()->purchases($filter);
$response = $finvalda->transactions()->purchasesDetail($filter);
$response = $finvalda->transactions()->purchasesExtendedDetail($filter);

// Purchase Orders & Returns (headers + detail)
$response = $finvalda->transactions()->purchaseOrders($filter);
$response = $finvalda->transactions()->purchaseOrdersDetail($filter);
$response = $finvalda->transactions()->purchaseReturns($filter);
$response = $finvalda->transactions()->purchaseReturnsDetail($filter);

// Inflows with payment reference filter
$response = $finvalda->transactions()->inflowsDetail(
    filter: $filter,
    paymentFilter: new PaymentFilter(
        payedForDocSeries: 'AA',
        payedForDocOrderNumber: 'SF-001',
    ),
);

// Advance Payments (standard + extended)
$response = $finvalda->transactions()->advancedPaymentsDetail(
    filter: $filter,
    client: 'CLIENT001',
    offsetStatus: 0,
);
$response = $finvalda->transactions()->advancedPaymentsDetailExtended(filter: $filter);

// Disbursements, Clearing Offsets
$response = $finvalda->transactions()->disbursementsDetail($filter);
$response = $finvalda->transactions()->clearingOffsDetail($filter);

// OMM (Order Management Module) — sales + purchases, headers + detail
$response = $finvalda->transactions()->ommSales($filter);
$response = $finvalda->transactions()->ommSalesDetail($filter);
$response = $finvalda->transactions()->ommSalesXmlCondition('...');
$response = $finvalda->transactions()->ommSalesXmlConditionWithTitle('...');
$response = $finvalda->transactions()->ommPurchases($filter);
$response = $finvalda->transactions()->ommPurchasesDetail($filter);

// Fixed Assets & Currency
$response = $finvalda->transactions()->depreciationOfFixedAssets(year: 2024, month: 6);
$response = $finvalda->transactions()->depreciationOfFixedAssetsObjects(assetCode: 'ASSET01');
$response = $finvalda->transactions()->currencyDebtRecount($filter);

// Low Value Inventory
$response = $finvalda->transactions()->lowValueInventory();
```

### Operations (Create, Update, Delete)

[](#operations-create-update-delete)

```
use Finvalda\Enums\OperationClass;
use Finvalda\Enums\DeleteOperationClass;
use Finvalda\Enums\UpdateOperationClass;
use Finvalda\Enums\OpClass;

// Create a sale
$result = $finvalda->operations()->create(OperationClass::Sale, [
    'sKlientas' => 'CLIENT001',
    'tData' => '2024-06-15',
    'sDokumentas' => 'SF-001',
    'sValiuta' => 'EUR',
    'sSerija' => 'AA',
    'PardDokPrekeDetEil' => [
        [
            'sKodas' => 'PROD001',
            'sSandelis' => 'WH01',
            'nKiekis' => 10,
            'dSumaV' => 199.90,
            'dSumaL' => 199.90,
        ],
    ],
]);

if ($result->success) {
    echo "Created: {$result->journal} #{$result->number}";
}

// Create a purchase
$result = $finvalda->operations()->create(OperationClass::Purchase, [
    'sKlientas' => 'SUPPLIER001',
    'tData' => '2024-06-15',
    'sDokumentas' => 'PO-001',
    'sValiuta' => 'EUR',
    'PirkDokPrekeDetEil' => [
        [
            'sKodas' => 'PROD001',
            'sSandelis' => 'WH01',
            'nKiekis' => 100,
            'dSumaV' => 500.00,
            'dSumaL' => 500.00,
        ],
    ],
]);

// Create an internal transfer
$result = $finvalda->operations()->create(OperationClass::InternalTransfer, [
    'tData' => '2024-06-15',
    'VidPerkDokDetEil' => [
        [
            'sKodas' => 'PROD001',
            'sSandelisIs' => 'WH01',
            'sSandelisI' => 'WH02',
            'nKiekis' => 50,
        ],
    ],
]);

// Delete an operation
$result = $finvalda->operations()->delete(
    DeleteOperationClass::Sale,
    journal: 'PARD',
    number: 123,
);

// Update an operation
$result = $finvalda->operations()->update(UpdateOperationClass::Sale, [
    'sZurnalas' => 'PARD',
    'nNumeris' => 123,
    'PardDokHeadEil' => [
        'sPastaba' => 'Updated comment',
    ],
]);

// Read operations with filters (via GetOperations)
$response = $finvalda->operations()->get(OpClass::Sales, [
    'OpDateFrom' => '2024-01-01',
    'OpDateTill' => '2024-12-31',
    'Client' => 'CLIENT001',
]);

// Read with JSON body (supports complex filters, column selection, fullOp)
$response = $finvalda->operations()->query(OpClass::Sales, [
    'OpDateFrom' => '2024-01-01',
    'OpDateTill' => '2024-12-31',
    'fullOp' => true,
    'columns' => ['sKlientas', 'tData', 'sDokumentas'],
]);

// Lock / unlock operations
$finvalda->operations()->lock('PARD', 123);
$finvalda->operations()->unlock('PARD', 123);
$response = $finvalda->operations()->isLocked('PARD', 123);

// Change journal of an operation
$result = $finvalda->operations()->changeJournal([
    'sZurnalas' => 'PARD',
    'nNumeris' => 123,
    'sNaujasZurnalas' => 'PARD2',
]);

// Copy an operation
$result = $finvalda->operations()->copy([
    'sZurnalas' => 'PARD',
    'nNumeris' => 123,
]);

// Activity report by objects
$response = $finvalda->operations()->activityByObjects([
    'DateFrom' => '2024-01-01',
    'DateTo' => '2024-12-31',
]);
```

### Order Management (UVM)

[](#order-management-uvm)

```
// Sales reservation status by journal + number
$response = $finvalda->orderManagement()->salesReservationStatus('PARD', 123);

// List reservations with date range filters
$response = $finvalda->orderManagement()->completedReservations(
    journalGroup: 'PARD_GRP',
    dateFrom: '2024-01-01',
    dateTo: '2024-12-31',
);
$response = $finvalda->orderManagement()->pendingReservations();
$response = $finvalda->orderManagement()->cancelledReservations();

// Ordered products from reservations
$response = $finvalda->orderManagement()->orderedProducts(dateFrom: '2024-01-01');
```

### Pricing & Discounts

[](#pricing--discounts)

All pricing methods support `modifiedSince` and `createdSince` date filters.

```
// Combined client + item prices (discounts and additional prices)
$response = $finvalda->pricing()->clientItemPrices(clientCode: 'CLI001', itemCode: 'PROD001');
$response = $finvalda->pricing()->clientTypeItemPrices(clientTypeCode: 'VIP', itemCode: 'PROD001');
$response = $finvalda->pricing()->clientItemTypePrices(clientCode: 'CLI001', itemTypeCode: 'ELECTRONICS');
$response = $finvalda->pricing()->clientTypeItemTypePrices(
    clientTypeCode: 'VIP',
    itemTypeCode: 'ELECTRONICS',
);

// Product-specific (client + product, client + product type)
$response = $finvalda->pricing()->clientProductDiscounts('CLI001', modifiedSince: '2024-01-01');
$response = $finvalda->pricing()->clientProductAdditionalPrices('CLI001');
$response = $finvalda->pricing()->clientProductTypeDiscounts('CLI001');
$response = $finvalda->pricing()->clientProductTypeAdditionalPrices('CLI001');

// Service-specific (client + service, client + service type)
$response = $finvalda->pricing()->clientServiceDiscounts('CLI001');
$response = $finvalda->pricing()->clientServiceAdditionalPrices('CLI001');
$response = $finvalda->pricing()->clientServiceTypeDiscounts('CLI001');
$response = $finvalda->pricing()->clientServiceTypeAdditionalPrices('CLI001');

// Client TYPE + product/service
$response = $finvalda->pricing()->clientTypeProductDiscounts('VIP');
$response = $finvalda->pricing()->clientTypeProductAdditionalPrices('VIP');
$response = $finvalda->pricing()->clientTypeProductTypeDiscounts('VIP');
$response = $finvalda->pricing()->clientTypeProductTypeAdditionalPrices('VIP');

// Client TYPE + service
$response = $finvalda->pricing()->clientTypeServiceDiscounts('VIP');
$response = $finvalda->pricing()->clientTypeServiceAdditionalPrices('VIP');
$response = $finvalda->pricing()->clientTypeServiceTypeDiscounts('VIP');
$response = $finvalda->pricing()->clientTypeServiceTypeAdditionalPrices('VIP');

// Recommended price calculation
$response = $finvalda->pricing()->recommendedPrice([
    'invoiceType' => 0, // 0=sales, 1=purchases
    'invoiceDate' => ['year' => 2024, 'month' => 6, 'day' => 15],
    'itemType' => 1,    // 1=product, 2=service
    'itemCode' => 'PROD001',
    'itemAmount' => 10,
    'warehouseCode' => 'WH01',
    'clientCode' => 'CLI001',
]);
```

### Documents

[](#documents)

```
use Finvalda\Enums\DocumentEntityType;

// Upload from file path
$result = $finvalda->documents()->uploadFile('invoice.pdf', '/path/to/invoice.pdf');

// Upload hex-encoded content directly
$result = $finvalda->documents()->upload('doc.pdf', $hexContent);

// Attach to entity
$result = $finvalda->documents()->attach(
    DocumentEntityType::Sale,
    entityCode: 'CLI001',
    filename: 'invoice.pdf',
    journal: 'PARD',
    number: 123,
);

// Get attached documents
$response = $finvalda->documents()->attached(DocumentEntityType::Client, 'CLI001');

// Delete
$result = $finvalda->documents()->delete('invoice.pdf');
```

### Reports & Invoices

[](#reports--invoices)

```
// Generate invoice PDF (sParam contains serialized operation selection)
$response = $finvalda->reports()->makeInvoice('param_string');

// Generate report PDF
$response = $finvalda->reports()->makeReport('param_string');

// List auto-reports
$response = $finvalda->reports()->autoReports();
$response = $finvalda->reports()->autoReport('report_filename.pdf');
```

### Descriptions (Universal Query)

[](#descriptions-universal-query)

```
use Finvalda\Enums\DescriptionType;

// Generic query with pagination and column selection
$response = $finvalda->descriptions()->get(DescriptionType::Products, [
    'Codes' => ['PROD001', 'PROD002'],
], page: 1, limit: 50);

// Convenience methods
$response = $finvalda->descriptions()->stockOnDate('2024-06-15', ['Warehouse' => 'WH01']);
$response = $finvalda->descriptions()->products(['Type' => 'ELECTRONICS'], page: 1, limit: 100);
$response = $finvalda->descriptions()->clients(['Email' => 'client@example.com']);
$response = $finvalda->descriptions()->services();
$response = $finvalda->descriptions()->currentStock(['Warehouse' => 'WH01']);
$response = $finvalda->descriptions()->fixedAssets();
$response = $finvalda->descriptions()->barCodes(['Codes' => ['PROD001']]);
$response = $finvalda->descriptions()->prices(['Client' => 'CLI001']);
$response = $finvalda->descriptions()->currencyRates('2024-01-01', '2024-12-31', ['USD', 'GBP']);
$response = $finvalda->descriptions()->clientGroups();
$response = $finvalda->descriptions()->warehouseGroups();
$response = $finvalda->descriptions()->logbookGroups();
$response = $finvalda->descriptions()->opTypeGroups();
$response = $finvalda->descriptions()->vehicles();
$response = $finvalda->descriptions()->calendarEvents('admin');
$response = $finvalda->descriptions()->documentSeries(type: 0);
$response = $finvalda->descriptions()->invoiceList();
$response = $finvalda->descriptions()->reportList('Pardavimai');
$response = $finvalda->descriptions()->tagsAndTypes('product', 0);
```

### Reference Data

[](#reference-data)

```
$response = $finvalda->references()->measurementUnits();
$response = $finvalda->references()->warehouses();
$response = $finvalda->references()->taxes();
$response = $finvalda->references()->paymentTerms();
$response = $finvalda->references()->user();
$response = $finvalda->references()->materiallyResponsiblePersons(code: 'EMP01');

// Create reference entities
$result = $finvalda->references()->createBank(['sKodas' => 'BNK01', 'sPavadinimas' => 'My Bank']);
$result = $finvalda->references()->createWarehouse(['sKodas' => 'WH03', 'sPavadinimas' => 'Warehouse 3']);
$result = $finvalda->references()->createPaymentTerm(['sKodas' => 'NET30', 'sPavadinimas' => 'Net 30']);
$result = $finvalda->references()->createClientType(['sKodas' => 'VIP', 'sPavadinimas' => 'VIP Clients']);
$result = $finvalda->references()->createProductType(['sKodas' => 'ELEC', 'sPavadinimas' => 'Electronics']);

// Update reference entities
$result = $finvalda->references()->updateWarehouse(['sKodas' => 'WH03', 'sPavadinimas' => 'Updated']);
$result = $finvalda->references()->updatePaymentTerm(['sKodas' => 'NET30', 'sPavadinimas' => 'Updated']);

// Add item to group
$result = $finvalda->references()->addToGroup('Fvs.PrekesRusis', 'GRP01', 'PROD001');
```

### User Permissions

[](#user-permissions)

```
$response = $finvalda->permissions()->warehouses();
$response = $finvalda->permissions()->clients();
$response = $finvalda->permissions()->operationTypes();
$response = $finvalda->permissions()->operationJournals();

// Or by class ID directly
$response = $finvalda->permissions()->get(65); // warehouses
```

Error Handling
--------------

[](#error-handling)

```
use Finvalda\Exceptions\FinvaldaException;
use Finvalda\Exceptions\AccessDeniedException;

try {
    $response = $finvalda->clients()->list();

    if ($response->failed()) {
        echo "Error: {$response->error}";
    }
} catch (AccessDeniedException $e) {
    echo "Access denied: {$e->getMessage()}";
} catch (FinvaldaException $e) {
    echo "API error: {$e->getMessage()}";
}
```

For write operations (`create`, `update`, `delete`), the `OperationResult` object provides:

```
$result = $finvalda->operations()->create(OperationClass::Sale, $data);

if ($result->success) {
    echo "Series: {$result->series}";
    echo "Document: {$result->document}";
    echo "Journal: {$result->journal}";
    echo "Number: {$result->number}";
} else {
    echo "Error #{$result->errorCode}: {$result->error}";
}
```

API Versions
------------

[](#api-versions)

This SDK targets **V2 (FvsServicePure)** - the recommended REST interface that returns clean JSON/XML. Configure `baseUrl` accordingly:

VersionURL PatternDescriptionV2 (recommended)`.../FvsServicePure.svc`Clean REST JSON/XMLV1`.../FvsServiceR.svc/rest`REST with string-wrapped responsesV0`.../FvsService.asmx`SOAP + REST XMLKeeping Up to Date
------------------

[](#keeping-up-to-date)

The SDK is built from the [official Postman collection](https://documenter.getpostman.com/view/7208231/2s8YmRMLvd). To check for new endpoints:

```
bin/sync-postman-collection
```

This compares the latest online collection with the local copy and reports new/removed endpoints.

License
-------

[](#license)

MIT

###  Health Score

35

—

LowBetter than 79% of packages

Maintenance90

Actively maintained with recent releases

Popularity0

Limited adoption so far

Community6

Small or concentrated contributor base

Maturity38

Early-stage or recently created project

 Bus Factor1

Top contributor holds 100% of commits — single point of failure

How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window.

**Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores.

**Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement.

**Maturity (30%)** — Project age, version count, PHP version support, and release stability.

###  Release Activity

Cadence

Unknown

Total

1

Last Release

51d ago

### Community

Maintainers

![](https://www.gravatar.com/avatar/1b61dd7676c2221489564ec57033c4678b80bd05d0990ff5648b902f796a15ef?d=identicon)[arturas88](/maintainers/arturas88)

---

Top Contributors

[![arturas88](https://avatars.githubusercontent.com/u/4507937?v=4)](https://github.com/arturas88 "arturas88 (2 commits)")

---

Tags

phpapilaravelsdkAccountingERPfinvaldafvs

###  Code Quality

TestsPHPUnit

Static AnalysisPHPStan

Type Coverage Yes

### Embed Badge

![Health badge](/badges/arturas88-finvalda-sdk/health.svg)

```
[![Health](https://phpackages.com/badges/arturas88-finvalda-sdk/health.svg)](https://phpackages.com/packages/arturas88-finvalda-sdk)
```

###  Alternatives

[openai-php/laravel

OpenAI PHP for Laravel is a supercharged PHP API client that allows you to interact with the Open AI API

3.7k7.6M74](/packages/openai-php-laravel)[mozex/anthropic-laravel

Anthropic PHP for Laravel is a supercharged PHP API client that allows you to interact with the Anthropic API

71226.4k1](/packages/mozex-anthropic-laravel)[exlo89/laravel-sevdesk-api

A helpful Sevdesk API client for Laravel.

1116.5k](/packages/exlo89-laravel-sevdesk-api)

PHPackages © 2026

[Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)