@iota-big3/layer-1-finance/dist/expense-conventions.d.ts

Layer 1 Finance conventions for School OS - Budget patterns, billing automation, and financial workflows

import { ConventionSet } from './types';
/**
 * Layer 1 Finance: Expense Management Conventions
 *
 * Philosophy: Streamline expense tracking to maximize resources for education
 * while maintaining transparency and accountability.
 *
 * Impact: 5 hours/week saved in expense processing and reporting
 */
export declare const EXPENSE_CATEGORIES: {
    INSTRUCTIONAL: {
        name: string;
        subcategories: {
            classroom_supplies: {
                budget_percentage: number;
                approval_level: string;
                fast_track: boolean;
            };
            textbooks_materials: {
                budget_percentage: number;
                approval_level: string;
                bulk_discount: boolean;
            };
            technology_software: {
                budget_percentage: number;
                approval_level: string;
                license_optimization: boolean;
            };
            professional_development: {
                budget_percentage: number;
                approval_level: string;
                impact_tracking: boolean;
            };
            lab_equipment: {
                budget_percentage: number;
                approval_level: string;
                shared_resource: boolean;
            };
        };
        philosophyMetrics: {
            direct_classroom_impact: number;
            'teacher_autonomy.enabled': boolean;
            'procurement_time.reduced': number;
        };
    };
    OPERATIONAL: {
        name: string;
        subcategories: {
            utilities: {
                optimization: string;
                monitoring: string;
                target_reduction: number;
            };
            maintenance: {
                strategy: string;
                priority: string;
                emergency_fund: number;
            };
            transportation: {
                optimization: string;
                sharing: string;
                alternative_options: boolean;
            };
            insurance: {
                review_frequency: string;
                bundling: boolean;
                risk_management: string;
            };
        };
        philosophyMetrics: {
            operational_efficiency: number;
            'cost_per_student.optimized': boolean;
            'resource_waste.minimized': number;
        };
    };
};
export declare class ExpenseApprovalEngine {
    static routeExpenseApproval(expense: ExpenseRequest): ApprovalRouting;
    private static getStandardRouting;
}
export declare class CostOptimizer {
    static analyzeSpendingPatterns(expenses: Expense[], period: string): SpendingAnalysis;
    private static identifySeasonalPatterns;
    private static identifyRecurringExpenses;
    private static identifySavingsOpportunities;
    private static generateSavingsRecommendations;
    private static assessPhilosophyAlignment;
    private static groupByCategory;
    private static groupByVendor;
    private static getTopVendors;
    private static identifyOutliers;
    private static calculateOptimizationPotential;
    private static findSimilarPurchases;
}
export declare class VendorManager {
    static evaluateVendor(vendor: string, transactions: Expense[]): VendorEvaluation;
    private static calculateAvgDeliveryTime;
    private static assessPricing;
    private static assessQuality;
    private static generateVendorRecommendations;
}
export declare const expenseConventions: ConventionSet;
interface ExpenseRequest {
    amount: number;
    category: string;
    urgency: 'normal' | 'high' | 'emergency';
    requester: {
        role: string;
        department: string;
    };
    educationalImpact: {
        studentsAffected: number;
        learningOutcome: string;
    };
    description: string;
}
interface ApprovalRouting {
    approver: string;
    timeframe: string;
    requirements: string[];
    notification: string;
    escalation?: boolean;
}
interface Expense {
    id: string;
    amount: number;
    category: string;
    vendor: string;
    date: string;
    description: string;
    approver?: string;
    deliveryDate?: string;
}
interface SpendingAnalysis {
    totalSpending: number;
    categoryBreakdown: Record<string, number>;
    topVendors: Array<{
        vendor: string;
        amount: number;
    }>;
    patterns: {
        seasonal: SeasonalPattern[];
        recurring: RecurringExpense[];
        outliers: Expense[];
        opportunities: SavingsOpportunity[];
    };
    savingsOpportunities: string[];
    optimizationPotential: number;
    philosophyAlignment: PhilosophyAlignment;
}
interface SeasonalPattern {
    month: number;
    type: 'peak' | 'valley';
    amount: number;
    recommendation: string;
}
interface RecurringExpense {
    vendor: string;
    amount: number;
    frequency: number;
    annualCost: number;
    optimizationOptions: string[];
}
interface SavingsOpportunity {
    type: string;
    items?: string[];
    vendor?: string;
    currentCost?: number;
    potentialSavings: number;
    implementation: string;
}
interface PhilosophyAlignment {
    educationFocusScore: number;
    recommendedShift: string;
    efficiencyScore: number;
}
interface VendorEvaluation {
    vendor: string;
    score: number;
    volume: number;
    reliability: number;
    avgDeliveryDays?: number;
    priceCompetitiveness?: number;
    recommendations: string[];
}
export default expenseConventions;
//# sourceMappingURL=expense-conventions.d.ts.map