PHPackages azaharizaman/nexus-account-consolidation - 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. [Utility & Helpers](/categories/utility) 4. / 5. azaharizaman/nexus-account-consolidation ActiveLibrary[Utility & Helpers](/categories/utility) azaharizaman/nexus-account-consolidation ======================================== Multi-entity financial consolidation, intercompany elimination, and NCI calculations v0.1.0-alpha1(2mo ago)00MITPHPPHP ^8.3 Since May 5Pushed 2mo agoCompare [ Source](https://github.com/azaharizaman/nexus-account-consolidation)[ Packagist](https://packagist.org/packages/azaharizaman/nexus-account-consolidation)[ RSS](/packages/azaharizaman-nexus-account-consolidation/feed)WikiDiscussions main Synced 3w ago READMEChangelogDependencies (2)Versions (2)Used By (0) Nexus\\AccountConsolidation =========================== [](#nexusaccountconsolidation) **Framework-Agnostic Financial Consolidation Engine** [![PHP Version](https://camo.githubusercontent.com/ef0054230522e542bc1f908ac005c6c75888dea255bac910f9015e12095e31d7/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f7068702d253545382e332d626c7565)](https://www.php.net/)[![License](https://camo.githubusercontent.com/f8df3091bbe1149f398a5369b2c39e896766f9f6efba3477c63e9b4aa940ef14/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f6c6963656e73652d4d49542d677265656e)](LICENSE) Overview -------- [](#overview) `Nexus\AccountConsolidation` is a pure PHP package that provides the core engine for consolidating financial statements from multiple entities (parent company and subsidiaries). It handles intercompany eliminations, currency translation, non-controlling interest (NCI) calculations, and ownership hierarchy resolution. This package is **framework-agnostic** and contains no database access, no HTTP controllers, and no framework-specific code. Consuming applications provide entity data through injected interfaces. Installation ------------ [](#installation) ``` composer require azaharizaman/nexus-account-consolidation ``` Package Responsibilities ------------------------ [](#package-responsibilities) ResponsibilityDescription**Multi-Entity Consolidation**Combine financial data from parent and subsidiaries**Intercompany Eliminations**Remove intercompany transactions and balances**Currency Translation**Translate foreign subsidiary financials**NCI Calculations**Calculate non-controlling interest allocations**Ownership Resolution**Determine consolidation method based on ownership %**Goodwill Calculation**Calculate goodwill from acquisitionsKey Concepts ------------ [](#key-concepts) ### Consolidation Methods [](#consolidation-methods) MethodOwnershipTreatment**Full Consolidation**> 50%100% of assets/liabilities, NCI for minority**Proportionate**20-50% (Joint Venture)Pro-rata share of assets/liabilities**Equity Method**20-50% (Associate)Single-line investment + share of profit**Cost Method**< 20%Investment at cost, dividends as income### Elimination Types [](#elimination-types) - **Intercompany Revenue/Expense** - Sales between group entities - **Intercompany Receivables/Payables** - Balances between entities - **Intercompany Dividends** - Dividend payments within group - **Investment Elimination** - Parent's investment in subsidiary - **Unrealized Profit** - Profit on intercompany inventory/assets --- Architecture ------------ [](#architecture) ``` src/ ├── Contracts/ # Interfaces defining the public API ├── ValueObjects/ # Immutable consolidation data structures ├── Enums/ # Consolidation types and methods ├── Services/ # Core consolidation logic ├── Rules/ # Elimination rule implementations └── Exceptions/ # Domain-specific errors ``` --- Contracts (Interfaces) ---------------------- [](#contracts-interfaces) ### Core Interfaces [](#core-interfaces) #### `ConsolidationEngineInterface` [](#consolidationengineinterface) The main entry point for consolidation operations. ``` interface ConsolidationEngineInterface { /** * Consolidate financial statements from multiple entities * * @param string $parentEntityId The parent company ID * @param array $subsidiaryIds List of subsidiary IDs to consolidate * @param string $periodId The reporting period * @param ConsolidationMethod $method The consolidation method * @return ConsolidationResult */ public function consolidate( string $parentEntityId, array $subsidiaryIds, string $periodId, ConsolidationMethod $method = ConsolidationMethod::FULL ): ConsolidationResult; /** * Preview consolidation adjustments without applying */ public function preview( string $parentEntityId, array $subsidiaryIds, string $periodId ): ConsolidationPreview; } ``` #### `EliminationRuleInterface` [](#eliminationruleinterface) Contract for intercompany elimination rules. ``` interface EliminationRuleInterface { /** * Get the elimination type this rule handles */ public function getType(): EliminationType; /** * Check if this rule applies to the given transaction */ public function applies(IntercompanyBalance $balance): bool; /** * Generate elimination entries for the balance * * @return array */ public function eliminate(IntercompanyBalance $balance): array; /** * Get rule priority (lower = higher priority) */ public function getPriority(): int; } ``` #### `CurrencyTranslatorInterface` [](#currencytranslatorinterface) Handles foreign currency translation. ``` interface CurrencyTranslatorInterface { /** * Translate entity financials to reporting currency * * @param ConsolidationEntity $entity The foreign entity * @param string $reportingCurrency Target currency code * @param TranslationMethod $method Translation method * @return TranslationAdjustment */ public function translate( ConsolidationEntity $entity, string $reportingCurrency, TranslationMethod $method = TranslationMethod::CURRENT_RATE ): TranslationAdjustment; /** * Get cumulative translation adjustment for entity */ public function getCumulativeTranslationAdjustment( string $entityId, string $reportingCurrency ): Money; } ``` #### `NciCalculatorInterface` [](#ncicalculatorinterface) Calculates non-controlling interest. ``` interface NciCalculatorInterface { /** * Calculate NCI allocation for a subsidiary * * @param ConsolidationEntity $subsidiary * @param OwnershipStructure $ownership * @return NciAllocation */ public function calculate( ConsolidationEntity $subsidiary, OwnershipStructure $ownership ): NciAllocation; /** * Calculate NCI share of subsidiary profit/loss */ public function calculateProfitShare( Money $subsidiaryNetIncome, float $nciPercentage ): Money; } ``` #### `OwnershipResolverInterface` [](#ownershipresolverinterface) Determines ownership percentages and consolidation requirements. ``` interface OwnershipResolverInterface { /** * Resolve ownership structure for an entity */ public function resolve( string $parentEntityId, string $subsidiaryId ): OwnershipStructure; /** * Determine the appropriate consolidation method */ public function determineConsolidationMethod( OwnershipStructure $ownership ): ConsolidationMethod; /** * Get effective ownership percentage (direct + indirect) */ public function getEffectiveOwnership( string $parentEntityId, string $targetEntityId ): float; /** * Detect circular ownership */ public function detectCircularOwnership( string $entityId, array $visitedEntities = [] ): bool; } ``` #### `ConsolidationDataProviderInterface` [](#consolidationdataproviderinterface) Contract for consuming applications to provide entity data. ``` interface ConsolidationDataProviderInterface { /** * Get consolidation entity data */ public function getEntity(string $entityId): ConsolidationEntity; /** * Get all intercompany balances for a period * * @return array */ public function getIntercompanyBalances( string $periodId, array $entityIds ): array; /** * Get investment balances */ public function getInvestmentBalances( string $parentEntityId, string $periodId ): array; } ``` --- Value Objects ------------- [](#value-objects) ### `ConsolidationEntity` [](#consolidationentity) ``` final readonly class ConsolidationEntity { public function __construct( public string $entityId, public string $entityName, public string $functionalCurrency, public string $parentEntityId, public float $ownershipPercentage, public ControlType $controlType, public \DateTimeImmutable $acquisitionDate, public array $financialData = [] ) {} } ``` ### `OwnershipStructure` [](#ownershipstructure) ``` final readonly class OwnershipStructure { public function __construct( public string $parentEntityId, public string $subsidiaryEntityId, public float $directOwnership, public float $indirectOwnership, public float $effectiveOwnership, public ConsolidationMethod $recommendedMethod, public array $ownershipChain = [] ) {} public function getNciPercentage(): float { return 100.0 - $this->effectiveOwnership; } } ``` ### `EliminationEntry` [](#eliminationentry) ``` final readonly class EliminationEntry { public function __construct( public string $id, public EliminationType $type, public string $debitAccountId, public string $creditAccountId, public Money $amount, public string $description, public string $relatedEntityId, public string $counterpartyEntityId ) {} } ``` ### `TranslationAdjustment` [](#translationadjustment) ``` final readonly class TranslationAdjustment { public function __construct( public string $entityId, public string $fromCurrency, public string $toCurrency, public Money $translationGainLoss, public float $averageRate, public float $closingRate, public float $historicalRate, public array $adjustedBalances = [] ) {} } ``` ### `ConsolidationResult` [](#consolidationresult) ``` final readonly class ConsolidationResult { public function __construct( public string $consolidationId, public string $parentEntityId, public string $periodId, public array $consolidatedBalances, public array $eliminationEntries, public array $translationAdjustments, public Money $totalNci, public Money $goodwill, public int $eliminationsCount, public int $translationAdjustmentsCount, public \DateTimeImmutable $generatedAt ) {} } ``` ### `IntercompanyBalance` [](#intercompanybalance) ``` final readonly class IntercompanyBalance { public function __construct( public string $fromEntityId, public string $toEntityId, public string $accountId, public EliminationType $type, public Money $amount, public string $transactionReference ) {} } ``` --- Enums ----- [](#enums) ### `ConsolidationMethod` [](#consolidationmethod) ``` enum ConsolidationMethod: string { case FULL = 'full'; // > 50% ownership case PROPORTIONATE = 'proportionate'; // Joint ventures case EQUITY = 'equity'; // Associates (20-50%) case COST = 'cost'; // < 20% ownership } ``` ### `EliminationType` [](#eliminationtype) ``` enum EliminationType: string { case INTERCOMPANY_REVENUE = 'intercompany_revenue'; case INTERCOMPANY_RECEIVABLE = 'intercompany_receivable'; case INTERCOMPANY_DIVIDEND = 'intercompany_dividend'; case INVESTMENT_ELIMINATION = 'investment_elimination'; case UNREALIZED_PROFIT = 'unrealized_profit'; } ``` ### `TranslationMethod` [](#translationmethod) ``` enum TranslationMethod: string { case CURRENT_RATE = 'current_rate'; // All at closing rate case TEMPORAL = 'temporal'; // Historical rates for non-monetary case MONETARY_NONMONETARY = 'monetary'; // Split by account type } ``` ### `ControlType` [](#controltype) ``` enum ControlType: string { case SUBSIDIARY = 'subsidiary'; // Controlled entity case ASSOCIATE = 'associate'; // Significant influence case JOINT_VENTURE = 'joint_venture'; // Joint control case INVESTMENT = 'investment'; // No significant influence } ``` --- Services -------- [](#services) ### `ConsolidationCalculator` [](#consolidationcalculator) Orchestrates the consolidation process: 1. Collect entity financial data 2. Determine consolidation method per entity 3. Apply currency translation 4. Execute elimination rules 5. Calculate NCI allocations 6. Produce consolidated result ### `IntercompanyEliminator` [](#intercompanyeliminator) Identifies and eliminates intercompany transactions: - Matches receivables with payables - Eliminates revenue/expense - Handles partial matching - Tracks elimination mismatches ### `CurrencyTranslator` [](#currencytranslator) Translates foreign currency financials: - Current rate method (IFRS default) - Temporal method - Calculates translation gain/loss - Maintains cumulative translation adjustment (CTA) ### `NciCalculator` [](#ncicalculator) Calculates non-controlling interest: - NCI at acquisition - NCI share of profits - NCI in net assets - Changes in NCI without loss of control ### `OwnershipResolver` [](#ownershipresolver) Resolves complex ownership structures: - Direct ownership - Indirect ownership (chains) - Cross-holdings - Circular ownership detection ### `GoodwillCalculator` [](#goodwillcalculator) Calculates acquisition goodwill: - Consideration paid - Less: Fair value of net assets acquired - Plus: NCI at fair value - Equals: Goodwill ### `MinorityInterestAdjuster` [](#minorityinterestadjuster) Adjusts for minority interests in multi-tier structures. --- Rules ----- [](#rules) ### Elimination Rule Implementations [](#elimination-rule-implementations) RuleDescription`IntercompanyRevenueRule`Eliminates sales between group entities`IntercompanyReceivableRule`Eliminates A/R and A/P between entities`IntercompanyDividendRule`Eliminates intra-group dividends`InvestmentEliminationRule`Eliminates parent investment vs subsidiary equity`UnrealizedProfitRule`Eliminates unrealized profit in inventory--- Exceptions ---------- [](#exceptions) ExceptionWhen Thrown`ConsolidationException`General consolidation failure`CircularOwnershipException`Circular ownership detected in structure`InvalidOwnershipException`Ownership percentage invalid (< 0 or > 100)`CurrencyTranslationException`Currency translation fails`EliminationException`Elimination entry cannot be created--- Usage Example ------------- [](#usage-example) ``` use Nexus\AccountConsolidation\Contracts\ConsolidationEngineInterface; use Nexus\AccountConsolidation\Contracts\OwnershipResolverInterface; use Nexus\AccountConsolidation\Enums\ConsolidationMethod; final readonly class GroupConsolidationService { public function __construct( private ConsolidationEngineInterface $engine, private OwnershipResolverInterface $ownershipResolver ) {} public function consolidateGroup( string $parentEntityId, array $subsidiaryIds, string $periodId ): ConsolidationResult { // Verify no circular ownership foreach ($subsidiaryIds as $subId) { if ($this->ownershipResolver->detectCircularOwnership($subId)) { throw new CircularOwnershipException($subId); } } // Perform consolidation return $this->engine->consolidate( parentEntityId: $parentEntityId, subsidiaryIds: $subsidiaryIds, periodId: $periodId, method: ConsolidationMethod::FULL ); } } ``` --- Integration with Other Packages ------------------------------- [](#integration-with-other-packages) PackageIntegration`Nexus\Finance`Provides GL balances for each entity`Nexus\Currency`Provides exchange rates for translation`Nexus\FinancialStatements`Generates consolidated statements`Nexus\Backoffice`Provides entity/company structure`Nexus\AuditLogger`Logs consolidation events--- Consolidation Process Flow -------------------------- [](#consolidation-process-flow) ``` ┌─────────────────────────────────────────────────────────────┐ │ CONSOLIDATION PROCESS │ ├─────────────────────────────────────────────────────────────┤ │ │ │ 1. OWNERSHIP RESOLUTION │ │ ├── Determine ownership % │ │ ├── Check for circular ownership │ │ └── Select consolidation method │ │ │ │ 2. CURRENCY TRANSLATION (if needed) │ │ ├── Translate foreign subsidiary financials │ │ └── Calculate translation adjustments │ │ │ │ 3. INTERCOMPANY ELIMINATIONS │ │ ├── Identify intercompany balances │ │ ├── Apply elimination rules │ │ └── Generate elimination entries │ │ │ │ 4. NCI CALCULATIONS │ │ ├── Calculate NCI in net assets │ │ └── Allocate NCI share of profit/loss │ │ │ │ 5. GOODWILL & INVESTMENT ELIMINATION │ │ ├── Eliminate parent investment │ │ ├── Eliminate subsidiary equity │ │ └── Calculate goodwill/bargain purchase │ │ │ │ 6. PRODUCE CONSOLIDATED RESULT │ │ └── Aggregated balances + adjustments │ │ │ └─────────────────────────────────────────────────────────────┘ ``` --- Related Documentation --------------------- [](#related-documentation) - [ARCHITECTURE.md](../../ARCHITECTURE.md) - Overall system architecture - [CODING\_GUIDELINES.md](../../CODING_GUIDELINES.md) - Coding standards - [Nexus Packages Reference](../../docs/NEXUS_PACKAGES_REFERENCE.md) - All available packages --- License ------- [](#license) MIT License - See [LICENSE](LICENSE) for details. ### Health Score 32 — LowBetter than 69% of packages Maintenance84 Actively maintained with recent releases Popularity0 Limited adoption so far Community6 Small or concentrated contributor base Maturity35 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 81d ago ### Community Maintainers ![](https://avatars.githubusercontent.com/u/117408?v=4)[Azahari Zaman](/maintainers/azaharizaman)[@azaharizaman](https://github.com/azaharizaman) --- Top Contributors [![azaharizaman](https://avatars.githubusercontent.com/u/117408?v=4)](https://github.com/azaharizaman "azaharizaman (5 commits)") ### Code Quality TestsPHPUnit ### Embed Badge ![Health badge](/badges/azaharizaman-nexus-account-consolidation/health.svg) ``` [![Health](https://phpackages.com/badges/azaharizaman-nexus-account-consolidation/health.svg)](https://phpackages.com/packages/azaharizaman-nexus-account-consolidation) ``` PHPackages © 2026 [Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)