@pfm-platform/shared 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,2758 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { z } from 'zod';
+import { Theme } from '@mui/material/styles';
+import { Variants, Transition } from 'framer-motion';
+
+/**
+ * Application mode type
+ *
+ * - `admin`: Test data creation mode with relaxed validation
+ * - `user`: Production mode with full business rules
+ */
+type AppMode = 'admin' | 'user';
+/**
+ * App Mode Context value interface
+ */
+interface AppModeContextValue {
+    /** Current application mode */
+    mode: AppMode;
+    /** Function to change application mode */
+    setMode: (mode: AppMode) => void;
+}
+/**
+ * App Mode Context
+ *
+ * Default context with 'user' mode
+ */
+declare const AppModeContext: react.Context<AppModeContextValue>;
+/**
+ * Props for AppModeProvider
+ */
+interface AppModeProviderProps {
+    /** Child components */
+    children: ReactNode;
+    /** Initial mode (default: 'user') */
+    initialMode?: AppMode;
+}
+/**
+ * App Mode Provider Component
+ *
+ * Provides application mode context to all child components.
+ * Wrap your application root with this provider.
+ *
+ * @example
+ * ```tsx
+ * // Admin/Test application
+ * <AppModeProvider initialMode="admin">
+ *   <ComponentDemo />
+ * </AppModeProvider>
+ *
+ * // Production application
+ * <AppModeProvider initialMode="user">
+ *   <ProductionApp />
+ * </AppModeProvider>
+ * ```
+ */
+declare function AppModeProvider({ children, initialMode, }: AppModeProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook to access App Mode context
+ *
+ * Must be used within AppModeProvider
+ *
+ * @returns Current app mode and setter function
+ * @throws Error if used outside AppModeProvider
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { mode, setMode } = useAppMode();
+ *
+ *   return (
+ *     <div>
+ *       <p>Current mode: {mode}</p>
+ *       {mode === 'admin' && <AdminPanel />}
+ *       <button onClick={() => setMode('admin')}>
+ *         Switch to Admin
+ *       </button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useAppMode(): AppModeContextValue;
+
+/**
+ * Account types from legacy API
+ * Source: ~/code/pfm-platform/apps/legacy/src/api/data/accounts.json
+ * Note: 15 values, not the 7 we assumed in Session 1
+ */
+declare const AccountTypeSchema: z.ZodEnum<{
+    checking: "checking";
+    savings: "savings";
+    cards: "cards";
+    student_loans: "student_loans";
+    bill: "bill";
+    autos: "autos";
+    home: "home";
+    investment: "investment";
+    loan: "loan";
+    asset: "asset";
+    cd: "cd";
+    money_market: "money_market";
+    certificates: "certificates";
+    commercial: "commercial";
+    creditline: "creditline";
+}>;
+/**
+ * Account state from legacy API
+ * Source: ~/code/pfm-platform/services/validator/specs/openapi-spec/components/schemas/Account.yaml
+ */
+declare const AccountStateSchema: z.ZodEnum<{
+    active: "active";
+    closed: "closed";
+    archived: "archived";
+    pending_deletion: "pending_deletion";
+}>;
+/**
+ * Aggregation type from legacy API
+ */
+declare const AggregationTypeSchema: z.ZodEnum<{
+    finicity: "finicity";
+    cashedge: "cashedge";
+    partner: "partner";
+}>;
+/**
+ * Preferred balance type from legacy API
+ */
+declare const PreferredBalanceTypeSchema: z.ZodEnum<{
+    Available: "Available";
+    Current: "Current";
+    Outstanding: "Outstanding";
+}>;
+/**
+ * Financial institution reference
+ * Note: Exists in API response but not in Prisma (JOINed in route handler)
+ */
+declare const FinancialInstitutionSchema: z.ZodNullable<z.ZodObject<{
+    id: z.ZodNumber;
+    name: z.ZodString;
+}, z.core.$strip>>;
+/**
+ * CashEdge account type mapping
+ * Note: Exists in API response but not in Prisma
+ */
+declare const CashEdgeAccountTypeSchema: z.ZodNullable<z.ZodObject<{
+    name: z.ZodString;
+    acct_type: z.ZodString;
+    ext_type: z.ZodString;
+    group: z.ZodString;
+}, z.core.$strip>>;
+/**
+ * Account error information
+ * Note: Exists in API response but not in Prisma
+ */
+declare const AccountErrorSchema: z.ZodNullable<z.ZodObject<{
+    message: z.ZodString;
+    code: z.ZodString;
+    actionable: z.ZodBoolean;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+/**
+ * Other balance information
+ */
+declare const OtherBalanceSchema: z.ZodObject<{
+    balance_type: z.ZodString;
+    balance: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Account schema matching legacy API response structure
+ * Source: ~/code/pfm-platform/apps/legacy/src/api/data/accounts.json
+ *
+ * CRITICAL: This matches the ACTUAL API response, not assumptions
+ * - IDs are integers (e.g., 41), NOT UUIDs
+ * - Balance is string "13172.66", NOT number
+ * - Field names are account_type and state, NOT type and status
+ * - Nested objects (fi, cashedge_account_type, error) included
+ */
+declare const AccountSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    name: z.ZodString;
+    balance: z.ZodString;
+    locked_balance: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    preferred_balance_type: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        Available: "Available";
+        Current: "Current";
+        Outstanding: "Outstanding";
+    }>>>;
+    account_type: z.ZodEnum<{
+        checking: "checking";
+        savings: "savings";
+        cards: "cards";
+        student_loans: "student_loans";
+        bill: "bill";
+        autos: "autos";
+        home: "home";
+        investment: "investment";
+        loan: "loan";
+        asset: "asset";
+        cd: "cd";
+        money_market: "money_market";
+        certificates: "certificates";
+        commercial: "commercial";
+        creditline: "creditline";
+    }>;
+    display_account_type: z.ZodOptional<z.ZodString>;
+    state: z.ZodEnum<{
+        active: "active";
+        closed: "closed";
+        archived: "archived";
+        pending_deletion: "pending_deletion";
+    }>;
+    aggregation_type: z.ZodEnum<{
+        finicity: "finicity";
+        cashedge: "cashedge";
+        partner: "partner";
+    }>;
+    reference_id: z.ZodOptional<z.ZodString>;
+    harvest_updated_at: z.ZodNullable<z.ZodString>;
+    include_in_expenses: z.ZodBoolean;
+    include_in_budget: z.ZodBoolean;
+    include_in_cashflow: z.ZodBoolean;
+    include_in_dashboard: z.ZodBoolean;
+    include_in_goals: z.ZodBoolean;
+    include_in_networth: z.ZodBoolean;
+    fi: z.ZodNullable<z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+    }, z.core.$strip>>;
+    cashedge_account_type: z.ZodNullable<z.ZodObject<{
+        name: z.ZodString;
+        acct_type: z.ZodString;
+        ext_type: z.ZodString;
+        group: z.ZodString;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        message: z.ZodString;
+        code: z.ZodString;
+        actionable: z.ZodBoolean;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    other_balances: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        balance_type: z.ZodString;
+        balance: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+/**
+ * Accounts list response schema
+ * Used for GET /users/{userId}/accounts/all endpoint
+ */
+declare const AccountsResponseSchema: z.ZodObject<{
+    accounts: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+        balance: z.ZodString;
+        locked_balance: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        preferred_balance_type: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            Available: "Available";
+            Current: "Current";
+            Outstanding: "Outstanding";
+        }>>>;
+        account_type: z.ZodEnum<{
+            checking: "checking";
+            savings: "savings";
+            cards: "cards";
+            student_loans: "student_loans";
+            bill: "bill";
+            autos: "autos";
+            home: "home";
+            investment: "investment";
+            loan: "loan";
+            asset: "asset";
+            cd: "cd";
+            money_market: "money_market";
+            certificates: "certificates";
+            commercial: "commercial";
+            creditline: "creditline";
+        }>;
+        display_account_type: z.ZodOptional<z.ZodString>;
+        state: z.ZodEnum<{
+            active: "active";
+            closed: "closed";
+            archived: "archived";
+            pending_deletion: "pending_deletion";
+        }>;
+        aggregation_type: z.ZodEnum<{
+            finicity: "finicity";
+            cashedge: "cashedge";
+            partner: "partner";
+        }>;
+        reference_id: z.ZodOptional<z.ZodString>;
+        harvest_updated_at: z.ZodNullable<z.ZodString>;
+        include_in_expenses: z.ZodBoolean;
+        include_in_budget: z.ZodBoolean;
+        include_in_cashflow: z.ZodBoolean;
+        include_in_dashboard: z.ZodBoolean;
+        include_in_goals: z.ZodBoolean;
+        include_in_networth: z.ZodBoolean;
+        fi: z.ZodNullable<z.ZodObject<{
+            id: z.ZodNumber;
+            name: z.ZodString;
+        }, z.core.$strip>>;
+        cashedge_account_type: z.ZodNullable<z.ZodObject<{
+            name: z.ZodString;
+            acct_type: z.ZodString;
+            ext_type: z.ZodString;
+            group: z.ZodString;
+        }, z.core.$strip>>;
+        error: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            message: z.ZodString;
+            code: z.ZodString;
+            actionable: z.ZodBoolean;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        other_balances: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            balance_type: z.ZodString;
+            balance: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Account creation schema - Admin mode
+ * Minimal validation for test data creation
+ * Allows creating accounts with basic required fields only
+ */
+declare const AccountCreateSchemaAdmin: z.ZodObject<{
+    name: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    balance: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    account_type: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        checking: "checking";
+        savings: "savings";
+        cards: "cards";
+        student_loans: "student_loans";
+        bill: "bill";
+        autos: "autos";
+        home: "home";
+        investment: "investment";
+        loan: "loan";
+        asset: "asset";
+        cd: "cd";
+        money_market: "money_market";
+        certificates: "certificates";
+        commercial: "commercial";
+        creditline: "creditline";
+    }>>>;
+    state: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        closed: "closed";
+        archived: "archived";
+        pending_deletion: "pending_deletion";
+    }>>>;
+    aggregation_type: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        finicity: "finicity";
+        cashedge: "cashedge";
+        partner: "partner";
+    }>>>;
+    include_in_expenses: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    include_in_budget: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    include_in_cashflow: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    include_in_dashboard: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    include_in_goals: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    include_in_networth: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    locked_balance: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    preferred_balance_type: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        Available: "Available";
+        Current: "Current";
+        Outstanding: "Outstanding";
+    }>>>;
+    display_account_type: z.ZodOptional<z.ZodString>;
+    reference_id: z.ZodOptional<z.ZodString>;
+    harvest_updated_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    other_balances: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        balance_type: z.ZodString;
+        balance: z.ZodString;
+    }, z.core.$strip>>>>;
+    fi: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+    }, z.core.$strip>>>;
+    cashedge_account_type: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        name: z.ZodString;
+        acct_type: z.ZodString;
+        ext_type: z.ZodString;
+        group: z.ZodString;
+    }, z.core.$strip>>>;
+    error: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        message: z.ZodString;
+        code: z.ZodString;
+        actionable: z.ZodBoolean;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strict>;
+/**
+ * Account creation schema - User mode
+ * Full validation with business rules for production use
+ * Note: Legacy API doesn't expose id in request body (server-generated)
+ * Using .strict() to prevent unknown fields (discovered in Session 1)
+ */
+declare const AccountCreateSchemaUser: z.ZodObject<{
+    error: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        message: z.ZodString;
+        code: z.ZodString;
+        actionable: z.ZodBoolean;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    name: z.ZodString;
+    balance: z.ZodString;
+    account_type: z.ZodEnum<{
+        checking: "checking";
+        savings: "savings";
+        cards: "cards";
+        student_loans: "student_loans";
+        bill: "bill";
+        autos: "autos";
+        home: "home";
+        investment: "investment";
+        loan: "loan";
+        asset: "asset";
+        cd: "cd";
+        money_market: "money_market";
+        certificates: "certificates";
+        commercial: "commercial";
+        creditline: "creditline";
+    }>;
+    state: z.ZodEnum<{
+        active: "active";
+        closed: "closed";
+        archived: "archived";
+        pending_deletion: "pending_deletion";
+    }>;
+    aggregation_type: z.ZodEnum<{
+        finicity: "finicity";
+        cashedge: "cashedge";
+        partner: "partner";
+    }>;
+    fi: z.ZodNullable<z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+    }, z.core.$strip>>;
+    cashedge_account_type: z.ZodNullable<z.ZodObject<{
+        name: z.ZodString;
+        acct_type: z.ZodString;
+        ext_type: z.ZodString;
+        group: z.ZodString;
+    }, z.core.$strip>>;
+    locked_balance: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    preferred_balance_type: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        Available: "Available";
+        Current: "Current";
+        Outstanding: "Outstanding";
+    }>>>;
+    display_account_type: z.ZodOptional<z.ZodString>;
+    reference_id: z.ZodOptional<z.ZodString>;
+    harvest_updated_at: z.ZodNullable<z.ZodString>;
+    include_in_expenses: z.ZodBoolean;
+    include_in_budget: z.ZodBoolean;
+    include_in_cashflow: z.ZodBoolean;
+    include_in_dashboard: z.ZodBoolean;
+    include_in_goals: z.ZodBoolean;
+    include_in_networth: z.ZodBoolean;
+    other_balances: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        balance_type: z.ZodString;
+        balance: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strict>;
+declare const AccountCreateSchema: z.ZodObject<{
+    error: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        message: z.ZodString;
+        code: z.ZodString;
+        actionable: z.ZodBoolean;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    name: z.ZodString;
+    balance: z.ZodString;
+    account_type: z.ZodEnum<{
+        checking: "checking";
+        savings: "savings";
+        cards: "cards";
+        student_loans: "student_loans";
+        bill: "bill";
+        autos: "autos";
+        home: "home";
+        investment: "investment";
+        loan: "loan";
+        asset: "asset";
+        cd: "cd";
+        money_market: "money_market";
+        certificates: "certificates";
+        commercial: "commercial";
+        creditline: "creditline";
+    }>;
+    state: z.ZodEnum<{
+        active: "active";
+        closed: "closed";
+        archived: "archived";
+        pending_deletion: "pending_deletion";
+    }>;
+    aggregation_type: z.ZodEnum<{
+        finicity: "finicity";
+        cashedge: "cashedge";
+        partner: "partner";
+    }>;
+    fi: z.ZodNullable<z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+    }, z.core.$strip>>;
+    cashedge_account_type: z.ZodNullable<z.ZodObject<{
+        name: z.ZodString;
+        acct_type: z.ZodString;
+        ext_type: z.ZodString;
+        group: z.ZodString;
+    }, z.core.$strip>>;
+    locked_balance: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    preferred_balance_type: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        Available: "Available";
+        Current: "Current";
+        Outstanding: "Outstanding";
+    }>>>;
+    display_account_type: z.ZodOptional<z.ZodString>;
+    reference_id: z.ZodOptional<z.ZodString>;
+    harvest_updated_at: z.ZodNullable<z.ZodString>;
+    include_in_expenses: z.ZodBoolean;
+    include_in_budget: z.ZodBoolean;
+    include_in_cashflow: z.ZodBoolean;
+    include_in_dashboard: z.ZodBoolean;
+    include_in_goals: z.ZodBoolean;
+    include_in_networth: z.ZodBoolean;
+    other_balances: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        balance_type: z.ZodString;
+        balance: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strict>;
+/**
+ * Account update schema
+ * Note: Legacy API requires id, all other fields optional
+ */
+declare const AccountUpdateSchema: z.ZodObject<{
+    id: z.ZodNonOptional<z.ZodOptional<z.ZodNumber>>;
+    name: z.ZodOptional<z.ZodString>;
+    balance: z.ZodOptional<z.ZodString>;
+    locked_balance: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+    preferred_balance_type: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        Available: "Available";
+        Current: "Current";
+        Outstanding: "Outstanding";
+    }>>>>;
+    account_type: z.ZodOptional<z.ZodEnum<{
+        checking: "checking";
+        savings: "savings";
+        cards: "cards";
+        student_loans: "student_loans";
+        bill: "bill";
+        autos: "autos";
+        home: "home";
+        investment: "investment";
+        loan: "loan";
+        asset: "asset";
+        cd: "cd";
+        money_market: "money_market";
+        certificates: "certificates";
+        commercial: "commercial";
+        creditline: "creditline";
+    }>>;
+    display_account_type: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    state: z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        closed: "closed";
+        archived: "archived";
+        pending_deletion: "pending_deletion";
+    }>>;
+    aggregation_type: z.ZodOptional<z.ZodEnum<{
+        finicity: "finicity";
+        cashedge: "cashedge";
+        partner: "partner";
+    }>>;
+    reference_id: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    harvest_updated_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    include_in_expenses: z.ZodOptional<z.ZodBoolean>;
+    include_in_budget: z.ZodOptional<z.ZodBoolean>;
+    include_in_cashflow: z.ZodOptional<z.ZodBoolean>;
+    include_in_dashboard: z.ZodOptional<z.ZodBoolean>;
+    include_in_goals: z.ZodOptional<z.ZodBoolean>;
+    include_in_networth: z.ZodOptional<z.ZodBoolean>;
+    fi: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+    }, z.core.$strip>>>;
+    cashedge_account_type: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        name: z.ZodString;
+        acct_type: z.ZodString;
+        ext_type: z.ZodString;
+        group: z.ZodString;
+    }, z.core.$strip>>>;
+    error: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        message: z.ZodString;
+        code: z.ZodString;
+        actionable: z.ZodBoolean;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>>;
+    other_balances: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        balance_type: z.ZodString;
+        balance: z.ZodString;
+    }, z.core.$strip>>>>;
+}, z.core.$strip>;
+/**
+ * Account delete schema
+ * Endpoint: DELETE /users/{userId}/accounts/{id}
+ * Simple id-only schema (id comes from URL path)
+ */
+declare const AccountDeleteSchema: z.ZodObject<{
+    id: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Account archive schema
+ * Endpoint: PUT /users/{userId}/accounts/{id}/archive
+ * Simple id-only schema (id comes from URL path)
+ */
+declare const AccountArchiveSchema: z.ZodObject<{
+    id: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Pending account schema
+ * Returned after aggregation when accounts need classification
+ */
+declare const PendingAccountSchema: z.ZodObject<{
+    account_ids: z.ZodArray<z.ZodNumber>;
+    institution_id: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Pending accounts response
+ * Endpoint: GET /users/{userId}/pending_accounts
+ */
+declare const PendingAccountsResponseSchema: z.ZodObject<{
+    pending_accounts: z.ZodArray<z.ZodObject<{
+        account_ids: z.ZodArray<z.ZodNumber>;
+        institution_id: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Delete pending account schema
+ * Endpoint: DELETE /users/{userId}/pending_accounts/{accountId}
+ * Simple id-only schema (id comes from URL path)
+ */
+declare const PendingAccountDeleteSchema: z.ZodObject<{
+    accountId: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Investment holding schema
+ * Individual security/position in investment account
+ * Note: Structure based on typical investment account responses
+ */
+declare const InvestmentHoldingSchema: z.ZodObject<{
+    symbol: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    quantity: z.ZodNumber;
+    price: z.ZodNumber;
+    value: z.ZodString;
+    cost_basis: z.ZodOptional<z.ZodString>;
+    unrealized_gain_loss: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Investment schema
+ * Container for investment holdings
+ */
+declare const InvestmentSchema: z.ZodObject<{
+    account_id: z.ZodNumber;
+    holdings: z.ZodArray<z.ZodObject<{
+        symbol: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        quantity: z.ZodNumber;
+        price: z.ZodNumber;
+        value: z.ZodString;
+        cost_basis: z.ZodOptional<z.ZodString>;
+        unrealized_gain_loss: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    total_value: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Investments response schema
+ * Endpoint: GET /users/{userId}/accounts/{id}/investments
+ */
+declare const InvestmentsResponseSchema: z.ZodObject<{
+    investments: z.ZodArray<z.ZodObject<{
+        account_id: z.ZodNumber;
+        holdings: z.ZodArray<z.ZodObject<{
+            symbol: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            quantity: z.ZodNumber;
+            price: z.ZodNumber;
+            value: z.ZodString;
+            cost_basis: z.ZodOptional<z.ZodString>;
+            unrealized_gain_loss: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        total_value: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+
+/**
+ * Type exports for Account domain
+ * Source: Inferred from Zod schemas matching legacy API
+ */
+type Account = z.infer<typeof AccountSchema>;
+type AccountsResponse = z.infer<typeof AccountsResponseSchema>;
+type AccountCreate = z.infer<typeof AccountCreateSchema>;
+type AccountUpdate = z.infer<typeof AccountUpdateSchema>;
+type AccountDelete = z.infer<typeof AccountDeleteSchema>;
+type AccountArchive = z.infer<typeof AccountArchiveSchema>;
+type AccountType = z.infer<typeof AccountTypeSchema>;
+type AccountState = z.infer<typeof AccountStateSchema>;
+type AggregationType = z.infer<typeof AggregationTypeSchema>;
+type PreferredBalanceType = z.infer<typeof PreferredBalanceTypeSchema>;
+type FinancialInstitution = z.infer<typeof FinancialInstitutionSchema>;
+type CashEdgeAccountType = z.infer<typeof CashEdgeAccountTypeSchema>;
+type AccountError = z.infer<typeof AccountErrorSchema>;
+type OtherBalance = z.infer<typeof OtherBalanceSchema>;
+type PendingAccount = z.infer<typeof PendingAccountSchema>;
+type PendingAccountsResponse = z.infer<typeof PendingAccountsResponseSchema>;
+type PendingAccountDelete = z.infer<typeof PendingAccountDeleteSchema>;
+type Investment = z.infer<typeof InvestmentSchema>;
+type InvestmentHolding = z.infer<typeof InvestmentHoldingSchema>;
+type InvestmentsResponse = z.infer<typeof InvestmentsResponseSchema>;
+
+/**
+ * Transaction type from legacy API
+ * Source: ~/code/pfm-platform/apps/legacy/src/api/data/accountTransactions.json
+ */
+declare const TransactionTypeSchema: z.ZodEnum<{
+    Debit: "Debit";
+    Credit: "Credit";
+}>;
+/**
+ * Transaction tag (category) with split amount
+ * Tags allow transactions to be categorized, with support for split transactions
+ */
+declare const TransactionTagSchema: z.ZodObject<{
+    name: z.ZodString;
+    balance: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Links to related resources
+ */
+declare const TransactionLinksSchema: z.ZodObject<{
+    account: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Transaction schema matching legacy API response structure
+ * Source: ~/code/pfm-platform/apps/legacy/src/api/data/accountTransactions.json
+ *
+ * CRITICAL DIFFERENCES FROM ACCOUNT SCHEMA:
+ * - ID is string format "YYYY_MM_DD_referenceId_accountId" (NOT integer)
+ * - balance is NUMBER (NOT string) - unlike Account schema
+ * - OpenAPI spec shows string but legacy data uses number - following legacy (PRIMARY source)
+ */
+declare const TransactionSchema: z.ZodObject<{
+    id: z.ZodString;
+    reference_id: z.ZodString;
+    transaction_type: z.ZodEnum<{
+        Debit: "Debit";
+        Credit: "Credit";
+    }>;
+    memo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    balance: z.ZodNumber;
+    posted_at: z.ZodString;
+    created_at: z.ZodString;
+    deleted_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    nickname: z.ZodString;
+    original_name: z.ZodString;
+    check_number: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    tags: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        balance: z.ZodNumber;
+    }, z.core.$strip>>;
+    links: z.ZodObject<{
+        account: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * Transactions response schema - array of transactions
+ * Used by search endpoint: GET /users/:userId/transactions/search
+ */
+declare const TransactionsResponseSchema: z.ZodObject<{
+    transactions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        reference_id: z.ZodString;
+        transaction_type: z.ZodEnum<{
+            Debit: "Debit";
+            Credit: "Credit";
+        }>;
+        memo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        balance: z.ZodNumber;
+        posted_at: z.ZodString;
+        created_at: z.ZodString;
+        deleted_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        nickname: z.ZodString;
+        original_name: z.ZodString;
+        check_number: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        tags: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            balance: z.ZodNumber;
+        }, z.core.$strip>>;
+        links: z.ZodObject<{
+            account: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Transaction creation schema - Admin mode
+ * Minimal validation for test data creation
+ * Allows creating transactions with basic required fields
+ */
+declare const TransactionCreateSchemaAdmin: z.ZodObject<{
+    reference_id: z.ZodString;
+    transaction_type: z.ZodEnum<{
+        Debit: "Debit";
+        Credit: "Credit";
+    }>;
+    balance: z.ZodNumber;
+    posted_at: z.ZodString;
+    nickname: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    original_name: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    memo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    check_number: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    deleted_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    tags: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        balance: z.ZodNumber;
+    }, z.core.$strip>>>>;
+    links: z.ZodObject<{
+        account: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strict>;
+/**
+ * Transaction creation schema - User mode
+ * Full validation with business rules for production use
+ * Note: id is server-generated, created_at is server-generated
+ * Using .strict() to prevent unknown fields (Session 1 pattern)
+ */
+declare const TransactionCreateSchemaUser: z.ZodObject<{
+    balance: z.ZodNumber;
+    reference_id: z.ZodString;
+    transaction_type: z.ZodEnum<{
+        Debit: "Debit";
+        Credit: "Credit";
+    }>;
+    links: z.ZodObject<{
+        account: z.ZodNumber;
+    }, z.core.$strip>;
+    memo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    posted_at: z.ZodString;
+    deleted_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    nickname: z.ZodString;
+    original_name: z.ZodString;
+    check_number: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    tags: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        balance: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strict>;
+declare const TransactionCreateSchema: z.ZodObject<{
+    balance: z.ZodNumber;
+    reference_id: z.ZodString;
+    transaction_type: z.ZodEnum<{
+        Debit: "Debit";
+        Credit: "Credit";
+    }>;
+    links: z.ZodObject<{
+        account: z.ZodNumber;
+    }, z.core.$strip>;
+    memo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    posted_at: z.ZodString;
+    deleted_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    nickname: z.ZodString;
+    original_name: z.ZodString;
+    check_number: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    tags: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        balance: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strict>;
+/**
+ * Transaction update schema
+ * Note: Partial update with required id
+ * Based on legacy API updateTransaction function - only nickname and tags can be updated
+ * Using .strict() to prevent unknown fields (Session 1 pattern)
+ */
+declare const TransactionUpdateSchema: z.ZodObject<{
+    id: z.ZodString;
+    nickname: z.ZodString;
+    tags: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        balance: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strict>;
+/**
+ * Transaction tagging - Regular (non-split)
+ * Applies single or multiple tags to entire transaction
+ */
+declare const TransactionTaggingRegularSchema: z.ZodObject<{
+    type: z.ZodLiteral<"regular">;
+    repeat: z.ZodBoolean;
+    regular: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Transaction tagging - Split
+ * Splits transaction amount across multiple tags
+ */
+declare const TransactionTaggingSplitItemSchema: z.ZodObject<{
+    name: z.ZodString;
+    value: z.ZodNumber;
+}, z.core.$strip>;
+declare const TransactionTaggingSplitSchema: z.ZodObject<{
+    type: z.ZodLiteral<"split">;
+    split: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Transaction tagging discriminated union
+ * Endpoint: PUT /users/{userId}/transactions/{id}
+ */
+declare const TransactionTaggingSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"regular">;
+    repeat: z.ZodBoolean;
+    regular: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"split">;
+    split: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>], "type">;
+/**
+ * Transaction search parameters
+ * Endpoint: GET /users/{userId}/transactions/search
+ */
+declare const TransactionSearchParamsSchema: z.ZodObject<{
+    begin_on: z.ZodString;
+    end_on: z.ZodString;
+    q: z.ZodOptional<z.ZodString>;
+    untagged: z.ZodOptional<z.ZodEnum<{
+        0: "0";
+        1: "1";
+    }>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * Transaction delete schema
+ * Endpoint: DELETE /users/{userId}/transactions/{id}
+ * Simple id-only schema (id comes from URL path)
+ */
+declare const TransactionDeleteSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+
+/**
+ * Type exports for Transaction domain
+ * Source: Inferred from Zod schemas matching legacy API
+ */
+type Transaction = z.infer<typeof TransactionSchema>;
+type TransactionCreate = z.infer<typeof TransactionCreateSchema>;
+type TransactionUpdate = z.infer<typeof TransactionUpdateSchema>;
+type TransactionDelete = z.infer<typeof TransactionDeleteSchema>;
+type TransactionsResponse = z.infer<typeof TransactionsResponseSchema>;
+type TransactionType = z.infer<typeof TransactionTypeSchema>;
+type TransactionTag = z.infer<typeof TransactionTagSchema>;
+type TransactionLinks = z.infer<typeof TransactionLinksSchema>;
+type TransactionTagging = z.infer<typeof TransactionTaggingSchema>;
+type TransactionTaggingRegular = z.infer<typeof TransactionTaggingRegularSchema>;
+type TransactionTaggingSplit = z.infer<typeof TransactionTaggingSplitSchema>;
+type TransactionTaggingSplitItem = z.infer<typeof TransactionTaggingSplitItemSchema>;
+type TransactionSearchParams = z.infer<typeof TransactionSearchParamsSchema>;
+
+/**
+ * Cashflow event type - Bill (outflow) or Income (inflow)
+ */
+declare const CashflowEventTypeSchema: z.ZodEnum<{
+    bill: "bill";
+    income: "income";
+}>;
+/**
+ * Recurrence frequency
+ */
+declare const RecurrenceFrequencySchema: z.ZodEnum<{
+    once: "once";
+    weekly: "weekly";
+    biweekly: "biweekly";
+    monthly: "monthly";
+    quarterly: "quarterly";
+    yearly: "yearly";
+}>;
+/**
+ * Cashflow Event schema for upcoming bills and recurring income
+ *
+ * Represents scheduled transactions that haven't occurred yet:
+ * - Bills to be paid
+ * - Income to be received
+ * - Recurring/one-time events
+ *
+ * Design Notes:
+ * - Lightweight schema for MVP cashflow tracking
+ * - Extends transaction concept with scheduling
+ * - Supports recurring patterns
+ */
+declare const CashflowEventSchema: z.ZodObject<{
+    id: z.ZodString;
+    event_id: z.ZodString;
+    name: z.ZodString;
+    amount: z.ZodNumber;
+    memo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    scheduled_date: z.ZodString;
+    event_type: z.ZodEnum<{
+        bill: "bill";
+        income: "income";
+    }>;
+    is_paid: z.ZodDefault<z.ZodBoolean>;
+    is_recurring: z.ZodDefault<z.ZodBoolean>;
+    recurrence_frequency: z.ZodOptional<z.ZodEnum<{
+        once: "once";
+        weekly: "weekly";
+        biweekly: "biweekly";
+        monthly: "monthly";
+        quarterly: "quarterly";
+        yearly: "yearly";
+    }>>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+    account_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    transaction_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * Create cashflow event schema
+ * Server generates: id, created_at, updated_at
+ */
+declare const CashflowEventCreateSchema: z.ZodObject<{
+    name: z.ZodString;
+    account_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    memo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    event_type: z.ZodEnum<{
+        bill: "bill";
+        income: "income";
+    }>;
+    event_id: z.ZodString;
+    amount: z.ZodNumber;
+    scheduled_date: z.ZodString;
+    is_paid: z.ZodDefault<z.ZodBoolean>;
+    is_recurring: z.ZodDefault<z.ZodBoolean>;
+    recurrence_frequency: z.ZodOptional<z.ZodEnum<{
+        once: "once";
+        weekly: "weekly";
+        biweekly: "biweekly";
+        monthly: "monthly";
+        quarterly: "quarterly";
+        yearly: "yearly";
+    }>>;
+}, z.core.$strict>;
+/**
+ * Update cashflow event schema
+ * Allows updating event details and payment status
+ */
+declare const CashflowEventUpdateSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    memo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    amount: z.ZodNumber;
+    scheduled_date: z.ZodString;
+    is_paid: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+/**
+ * Filter cashflow events by date range and type
+ */
+declare const CashflowEventFilterSchema: z.ZodObject<{
+    start_date: z.ZodString;
+    end_date: z.ZodString;
+    event_type: z.ZodDefault<z.ZodEnum<{
+        bill: "bill";
+        income: "income";
+        all: "all";
+    }>>;
+    include_paid: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * Cashflow events response - array of events
+ */
+declare const CashflowEventsResponseSchema: z.ZodObject<{
+    events: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        event_id: z.ZodString;
+        name: z.ZodString;
+        amount: z.ZodNumber;
+        memo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        scheduled_date: z.ZodString;
+        event_type: z.ZodEnum<{
+            bill: "bill";
+            income: "income";
+        }>;
+        is_paid: z.ZodDefault<z.ZodBoolean>;
+        is_recurring: z.ZodDefault<z.ZodBoolean>;
+        recurrence_frequency: z.ZodOptional<z.ZodEnum<{
+            once: "once";
+            weekly: "weekly";
+            biweekly: "biweekly";
+            monthly: "monthly";
+            quarterly: "quarterly";
+            yearly: "yearly";
+        }>>;
+        created_at: z.ZodString;
+        updated_at: z.ZodString;
+        account_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        transaction_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+
+type CashflowEvent = z.infer<typeof CashflowEventSchema>;
+type CashflowEventCreate = z.infer<typeof CashflowEventCreateSchema>;
+type CashflowEventUpdate = z.infer<typeof CashflowEventUpdateSchema>;
+type CashflowEventFilter = z.infer<typeof CashflowEventFilterSchema>;
+type CashflowEventsResponse = z.infer<typeof CashflowEventsResponseSchema>;
+type CashflowEventType = z.infer<typeof CashflowEventTypeSchema>;
+type RecurrenceFrequency = z.infer<typeof RecurrenceFrequencySchema>;
+
+/**
+ * Budget state based on spending progress
+ * Source: ~/code/pfm-platform/apps/legacy/src/api/data/budgets.js
+ */
+declare const BudgetStateSchema: z.ZodEnum<{
+    under: "under";
+    risk: "risk";
+    over: "over";
+}>;
+/**
+ * Links to related resources
+ */
+declare const BudgetLinksSchema: z.ZodObject<{
+    accounts: z.ZodArray<z.ZodNumber>;
+    budget_histories: z.ZodArray<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Budget schema matching legacy API response structure
+ * Source: ~/code/pfm-platform/apps/legacy/src/api/data/budgets.js
+ *
+ * CRITICAL DIFFERENCES FROM OPENAPI:
+ * - spent is NUMBER (NOT string) - legacy data shows integers
+ * - budget_amount is NUMBER (NOT string) - legacy data shows integers
+ * - OpenAPI shows oneOf (integer OR string) but legacy only uses integers
+ */
+declare const BudgetSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    month: z.ZodNumber;
+    year: z.ZodNumber;
+    name: z.ZodString;
+    state: z.ZodEnum<{
+        under: "under";
+        risk: "risk";
+        over: "over";
+    }>;
+    spent: z.ZodNumber;
+    budget_amount: z.ZodNumber;
+    tag_names: z.ZodArray<z.ZodString>;
+    links: z.ZodObject<{
+        accounts: z.ZodArray<z.ZodNumber>;
+        budget_histories: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * Budgets response schema - array of budgets
+ * Used by list endpoint: GET /users/:userId/budgets
+ */
+declare const BudgetsResponseSchema: z.ZodObject<{
+    budgets: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        month: z.ZodNumber;
+        year: z.ZodNumber;
+        name: z.ZodString;
+        state: z.ZodEnum<{
+            under: "under";
+            risk: "risk";
+            over: "over";
+        }>;
+        spent: z.ZodNumber;
+        budget_amount: z.ZodNumber;
+        tag_names: z.ZodArray<z.ZodString>;
+        links: z.ZodObject<{
+            accounts: z.ZodArray<z.ZodNumber>;
+            budget_histories: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Budget creation schema
+ * Note: id is server-generated, month/year/spent/state calculated by server
+ * Based on legacy API asBudgetJson function - only these fields sent to server
+ * Using .strict() to prevent unknown fields (Session 1 pattern)
+ */
+declare const BudgetCreateSchema: z.ZodObject<{
+    name: z.ZodString;
+    budget_amount: z.ZodNumber;
+    tag_names: z.ZodArray<z.ZodString>;
+    account_list: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    show_on_dashboard: z.ZodOptional<z.ZodBoolean>;
+    other: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+/**
+ * Budget update schema
+ * Note: Same fields as create per asBudgetJson function
+ * Using .strict() to prevent unknown fields (Session 1 pattern)
+ */
+declare const BudgetUpdateSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    name: z.ZodString;
+    budget_amount: z.ZodNumber;
+    tag_names: z.ZodArray<z.ZodString>;
+    account_list: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    show_on_dashboard: z.ZodOptional<z.ZodBoolean>;
+    other: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+
+/**
+ * Type exports for Budget domain
+ * Source: Inferred from Zod schemas matching legacy API
+ */
+type Budget = z.infer<typeof BudgetSchema>;
+type BudgetCreate = z.infer<typeof BudgetCreateSchema>;
+type BudgetUpdate = z.infer<typeof BudgetUpdateSchema>;
+type BudgetsResponse = z.infer<typeof BudgetsResponseSchema>;
+type BudgetState = z.infer<typeof BudgetStateSchema>;
+type BudgetLinks = z.infer<typeof BudgetLinksSchema>;
+
+/**
+ * Goal state
+ * Source: ~/code/pfm-platform/apps/legacy/src/api/data/goals.js
+ */
+declare const GoalStateSchema: z.ZodEnum<{
+    active: "active";
+    archived: "archived";
+    completed: "completed";
+}>;
+/**
+ * Goal status based on progress
+ * Source: ~/code/pfm-platform/apps/legacy/src/api/data/goals.js
+ */
+declare const GoalStatusSchema: z.ZodEnum<{
+    under: "under";
+    risk: "risk";
+    over: "over";
+    complete: "complete";
+}>;
+/**
+ * Links to related resources
+ */
+declare const GoalLinksSchema: z.ZodObject<{
+    accounts: z.ZodArray<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Savings goal schema matching legacy API response structure
+ * Source: ~/code/pfm-platform/apps/legacy/src/api/data/goals.js
+ *
+ * Savings goals save TO a target amount (building up savings)
+ */
+declare const SavingsGoalSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    name: z.ZodString;
+    state: z.ZodEnum<{
+        active: "active";
+        archived: "archived";
+        completed: "completed";
+    }>;
+    status: z.ZodEnum<{
+        under: "under";
+        risk: "risk";
+        over: "over";
+        complete: "complete";
+    }>;
+    image_name: z.ZodString;
+    image_url: z.ZodString;
+    percent_complete: z.ZodNumber;
+    complete: z.ZodBoolean;
+    initial_value: z.ZodString;
+    current_value: z.ZodString;
+    target_value: z.ZodString;
+    monthly_contribution: z.ZodString;
+    remaining_monthly_contribution: z.ZodString;
+    current_progress: z.ZodOptional<z.ZodString>;
+    target_contribution: z.ZodOptional<z.ZodString>;
+    target_completion_on: z.ZodString;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+    links: z.ZodObject<{
+        accounts: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strip>;
+    weight: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Payoff goal schema matching legacy API response structure
+ * Source: ~/code/pfm-platform/apps/legacy/src/api/data/goals.js
+ *
+ * Payoff goals pay DOWN from an initial balance (paying off debt)
+ */
+declare const PayoffGoalSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    name: z.ZodString;
+    state: z.ZodEnum<{
+        active: "active";
+        archived: "archived";
+        completed: "completed";
+    }>;
+    status: z.ZodEnum<{
+        under: "under";
+        risk: "risk";
+        over: "over";
+        complete: "complete";
+    }>;
+    image_name: z.ZodString;
+    image_url: z.ZodString;
+    percent_complete: z.ZodNumber;
+    complete: z.ZodBoolean;
+    initial_value: z.ZodString;
+    current_value: z.ZodString;
+    target_value: z.ZodString;
+    monthly_contribution: z.ZodString;
+    remaining_monthly_contribution: z.ZodString;
+    current_progress: z.ZodOptional<z.ZodString>;
+    target_contribution: z.ZodOptional<z.ZodString>;
+    target_completion_on: z.ZodString;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+    links: z.ZodObject<{
+        accounts: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * Goal creation schema (shared for both types)
+ * Note: id, timestamps, progress fields are server-generated
+ * Based on legacy API createGoal function - removes id from payload
+ * Using .strict() to prevent unknown fields (Session 1 pattern)
+ */
+declare const GoalCreateSchema: z.ZodObject<{
+    name: z.ZodString;
+    state: z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        archived: "archived";
+        completed: "completed";
+    }>>;
+    image_name: z.ZodString;
+    target_value: z.ZodString;
+    target_completion_on: z.ZodOptional<z.ZodString>;
+    target_contribution: z.ZodOptional<z.ZodString>;
+    account_ids: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+}, z.core.$strict>;
+/**
+ * Goal update schema
+ * Note: Same fields as create per updateGoal function (removes id from payload)
+ * Using .strict() to prevent unknown fields (Session 1 pattern)
+ */
+declare const GoalUpdateSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    name: z.ZodString;
+    state: z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        archived: "archived";
+        completed: "completed";
+    }>>;
+    image_name: z.ZodString;
+    target_value: z.ZodString;
+    target_completion_on: z.ZodOptional<z.ZodString>;
+    target_contribution: z.ZodOptional<z.ZodString>;
+    account_ids: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+}, z.core.$strict>;
+/**
+ * Savings goals response schema - array of savings goals
+ * Used by list endpoint: GET /users/:userId/savings_goals
+ */
+declare const SavingsGoalsResponseSchema: z.ZodObject<{
+    savings_goals: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+        state: z.ZodEnum<{
+            active: "active";
+            archived: "archived";
+            completed: "completed";
+        }>;
+        status: z.ZodEnum<{
+            under: "under";
+            risk: "risk";
+            over: "over";
+            complete: "complete";
+        }>;
+        image_name: z.ZodString;
+        image_url: z.ZodString;
+        percent_complete: z.ZodNumber;
+        complete: z.ZodBoolean;
+        initial_value: z.ZodString;
+        current_value: z.ZodString;
+        target_value: z.ZodString;
+        monthly_contribution: z.ZodString;
+        remaining_monthly_contribution: z.ZodString;
+        current_progress: z.ZodOptional<z.ZodString>;
+        target_contribution: z.ZodOptional<z.ZodString>;
+        target_completion_on: z.ZodString;
+        created_at: z.ZodString;
+        updated_at: z.ZodString;
+        links: z.ZodObject<{
+            accounts: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strip>;
+        weight: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Payoff goals response schema - array of payoff goals
+ * Used by list endpoint: GET /users/:userId/payoff_goals
+ */
+declare const PayoffGoalsResponseSchema: z.ZodObject<{
+    payoff_goals: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+        state: z.ZodEnum<{
+            active: "active";
+            archived: "archived";
+            completed: "completed";
+        }>;
+        status: z.ZodEnum<{
+            under: "under";
+            risk: "risk";
+            over: "over";
+            complete: "complete";
+        }>;
+        image_name: z.ZodString;
+        image_url: z.ZodString;
+        percent_complete: z.ZodNumber;
+        complete: z.ZodBoolean;
+        initial_value: z.ZodString;
+        current_value: z.ZodString;
+        target_value: z.ZodString;
+        monthly_contribution: z.ZodString;
+        remaining_monthly_contribution: z.ZodString;
+        current_progress: z.ZodOptional<z.ZodString>;
+        target_contribution: z.ZodOptional<z.ZodString>;
+        target_completion_on: z.ZodString;
+        created_at: z.ZodString;
+        updated_at: z.ZodString;
+        links: z.ZodObject<{
+            accounts: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Goal images response schema - array of image metadata
+ * Used by catalog endpoints: GET /savings_goals, GET /payoff_goals
+ */
+declare const GoalImagesResponseSchema: z.ZodObject<{
+    images: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+        url: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+
+/**
+ * Type exports for Goal domain
+ * Source: Inferred from Zod schemas matching legacy API
+ */
+type SavingsGoal = z.infer<typeof SavingsGoalSchema>;
+type PayoffGoal = z.infer<typeof PayoffGoalSchema>;
+type GoalCreate = z.infer<typeof GoalCreateSchema>;
+type GoalUpdate = z.infer<typeof GoalUpdateSchema>;
+type SavingsGoalsResponse = z.infer<typeof SavingsGoalsResponseSchema>;
+type PayoffGoalsResponse = z.infer<typeof PayoffGoalsResponseSchema>;
+type GoalImagesResponse = z.infer<typeof GoalImagesResponseSchema>;
+type GoalState = z.infer<typeof GoalStateSchema>;
+type GoalStatus = z.infer<typeof GoalStatusSchema>;
+type GoalLinks = z.infer<typeof GoalLinksSchema>;
+
+/**
+ * User sex/gender
+ * Source: ~/code/pfm-platform/services/validator/specs/openapi-spec/components/schemas/User.yaml
+ */
+declare const UserSexSchema: z.ZodEnum<{
+    Male: "Male";
+    Female: "Female";
+}>;
+/**
+ * User schema matching legacy API response structure
+ * Source: ~/code/pfm-platform/apps/legacy/src/api/data/users.json
+ *
+ * CRITICAL DATA TYPE NOTES:
+ * - id: STRING (partner customer ID, not integer like Account/Budget)
+ * - login_count: INTEGER (number type)
+ * - birth_year: INTEGER (number type)
+ * - custom_settings: OBJECT with arbitrary key-value pairs
+ * - custom_tags: ARRAY of strings
+ * - last_login_at: STRING (RFC 3339 datetime format)
+ */
+declare const UserSchema: z.ZodObject<{
+    id: z.ZodString;
+    login: z.ZodString;
+    email: z.ZodString;
+    login_count: z.ZodNumber;
+    last_login_at: z.ZodString;
+    custom_tags: z.ZodArray<z.ZodString>;
+    custom_settings: z.ZodObject<{}, z.core.$loose>;
+    first_name: z.ZodString;
+    last_name: z.ZodString;
+    postal_code: z.ZodString;
+    birth_year: z.ZodNumber;
+    sex: z.ZodEnum<{
+        Male: "Male";
+        Female: "Female";
+    }>;
+    city: z.ZodOptional<z.ZodString>;
+    state: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * User creation schema - Admin mode
+ * Minimal validation for test data creation
+ * Allows creating users with basic required fields only
+ */
+declare const UserCreateSchemaAdmin: z.ZodObject<{
+    login: z.ZodString;
+    email: z.ZodString;
+    first_name: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    last_name: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    postal_code: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    birth_year: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    sex: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        Male: "Male";
+        Female: "Female";
+    }>>>;
+    custom_tags: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    custom_settings: z.ZodDefault<z.ZodOptional<z.ZodObject<{}, z.core.$loose>>>;
+    city: z.ZodOptional<z.ZodString>;
+    state: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * User creation schema - User mode
+ * Full validation with business rules for production use
+ * Based on legacy API createUser function - sends user object
+ * Using .strict() to prevent unknown fields (Session 1 pattern)
+ * Note: id, login_count, last_login_at are server-generated
+ */
+declare const UserCreateSchemaUser: z.ZodObject<{
+    login: z.ZodString;
+    email: z.ZodString;
+    first_name: z.ZodString;
+    last_name: z.ZodString;
+    postal_code: z.ZodString;
+    birth_year: z.ZodNumber;
+    sex: z.ZodEnum<{
+        Male: "Male";
+        Female: "Female";
+    }>;
+    custom_tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    custom_settings: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+    city: z.ZodOptional<z.ZodString>;
+    state: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+declare const UserCreateSchema: z.ZodObject<{
+    login: z.ZodString;
+    email: z.ZodString;
+    first_name: z.ZodString;
+    last_name: z.ZodString;
+    postal_code: z.ZodString;
+    birth_year: z.ZodNumber;
+    sex: z.ZodEnum<{
+        Male: "Male";
+        Female: "Female";
+    }>;
+    custom_tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    custom_settings: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+    city: z.ZodOptional<z.ZodString>;
+    state: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * User update schema - Admin mode
+ * Minimal validation for test data updates
+ */
+declare const UserUpdateSchemaAdmin: z.ZodObject<{
+    email: z.ZodOptional<z.ZodString>;
+    first_name: z.ZodOptional<z.ZodString>;
+    last_name: z.ZodOptional<z.ZodString>;
+    postal_code: z.ZodOptional<z.ZodString>;
+    birth_year: z.ZodOptional<z.ZodNumber>;
+    sex: z.ZodOptional<z.ZodEnum<{
+        Male: "Male";
+        Female: "Female";
+    }>>;
+    custom_tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    custom_settings: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+    city: z.ZodOptional<z.ZodString>;
+    state: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * User update schema - User mode
+ * Full validation with business rules for production use
+ * Based on legacy API putCurrentUser function - sends user object
+ * Using .strict() to prevent unknown fields (Session 1 pattern)
+ * Note: id, login, login_count, last_login_at cannot be updated
+ */
+declare const UserUpdateSchemaUser: z.ZodObject<{
+    email: z.ZodString;
+    first_name: z.ZodString;
+    last_name: z.ZodString;
+    postal_code: z.ZodString;
+    birth_year: z.ZodNumber;
+    sex: z.ZodEnum<{
+        Male: "Male";
+        Female: "Female";
+    }>;
+    custom_tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    custom_settings: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+    city: z.ZodOptional<z.ZodString>;
+    state: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+declare const UserUpdateSchema: z.ZodObject<{
+    email: z.ZodString;
+    first_name: z.ZodString;
+    last_name: z.ZodString;
+    postal_code: z.ZodString;
+    birth_year: z.ZodNumber;
+    sex: z.ZodEnum<{
+        Male: "Male";
+        Female: "Female";
+    }>;
+    custom_tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    custom_settings: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+    city: z.ZodOptional<z.ZodString>;
+    state: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+
+/**
+ * Type exports for User domain
+ * Source: Inferred from Zod schemas matching legacy API
+ */
+type User = z.infer<typeof UserSchema>;
+type UserCreate = z.infer<typeof UserCreateSchema>;
+type UserUpdate = z.infer<typeof UserUpdateSchema>;
+type UserSex = z.infer<typeof UserSexSchema>;
+
+/**
+ * Tag schemas matching legacy API response structure
+ * Source: ~/code/pfm-platform/apps/legacy/src/api/data/tags.json
+ *
+ * CRITICAL NOTES:
+ * - Tags are simple arrays of strings
+ * - Two types: defaultTags (system-provided) and userTags (includes custom tags)
+ * - API endpoints: GET /tags (default), GET /users/:userId/tags (user tags)
+ * - Update: PUT /users/:userId/tags with array of tag names
+ */
+/**
+ * User tags response schema
+ * Includes both default tags and user-created custom tags
+ */
+declare const UserTagsSchema: z.ZodObject<{
+    userTags: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Default tags response schema
+ * System-provided standard tags for transaction categorization
+ */
+declare const DefaultTagsSchema: z.ZodObject<{
+    defaultTags: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Combined tags response (for complete legacy data structure)
+ */
+declare const TagsResponseSchema: z.ZodObject<{
+    userTags: z.ZodArray<z.ZodString>;
+    defaultTags: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Tag update schema
+ * Based on legacy API updateTags function - sends array of tag names
+ * Using .strict() to prevent unknown fields (Session 1 pattern)
+ */
+declare const TagsUpdateSchema: z.ZodArray<z.ZodString>;
+/**
+ * Tag create schema - Admin mode
+ * Minimal validation for test data creation
+ */
+declare const TagCreateSchemaAdmin: z.ZodObject<{
+    name: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Tag create schema - User mode
+ * Full business rules and validation
+ */
+declare const TagCreateSchemaUser: z.ZodObject<{
+    name: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Tag delete schema
+ * Just requires the tag name to delete
+ */
+declare const TagDeleteSchema: z.ZodObject<{
+    name: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Tag usage statistics item schema
+ * Represents usage count for a single tag
+ */
+declare const TagUsageStatSchema: z.ZodObject<{
+    tag: z.ZodString;
+    count: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Tag usage statistics response schema
+ * Array of tag usage statistics
+ */
+declare const TagUsageStatsSchema: z.ZodObject<{
+    stats: z.ZodArray<z.ZodObject<{
+        tag: z.ZodString;
+        count: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Tag color schema
+ * Hex color code for tag visual customization
+ */
+declare const TagColorSchema: z.ZodObject<{
+    color: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Tag usage data point for time series
+ * Represents tag usage count at a specific date
+ */
+declare const TagUsageDataPointSchema: z.ZodObject<{
+    date: z.ZodString;
+    count: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Tag usage report for a single tag
+ * Contains time series data for usage trends
+ */
+declare const TagReportItemSchema: z.ZodObject<{
+    tag: z.ZodString;
+    totalCount: z.ZodNumber;
+    dataPoints: z.ZodArray<z.ZodObject<{
+        date: z.ZodString;
+        count: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Tag usage report response schema
+ * Contains usage data for all tags over time
+ */
+declare const TagUsageReportSchema: z.ZodObject<{
+    report: z.ZodArray<z.ZodObject<{
+        tag: z.ZodString;
+        totalCount: z.ZodNumber;
+        dataPoints: z.ZodArray<z.ZodObject<{
+            date: z.ZodString;
+            count: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    startDate: z.ZodOptional<z.ZodString>;
+    endDate: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+
+/**
+ * Type exports for Tag domain
+ * Source: Inferred from Zod schemas matching legacy API
+ */
+type UserTags = z.infer<typeof UserTagsSchema>;
+type DefaultTags = z.infer<typeof DefaultTagsSchema>;
+type TagsResponse = z.infer<typeof TagsResponseSchema>;
+type TagsUpdate = z.infer<typeof TagsUpdateSchema>;
+type TagUsageStat = z.infer<typeof TagUsageStatSchema>;
+type TagUsageStats = z.infer<typeof TagUsageStatsSchema>;
+type TagColor = z.infer<typeof TagColorSchema>;
+type TagUsageDataPoint = z.infer<typeof TagUsageDataPointSchema>;
+type TagReportItem = z.infer<typeof TagReportItemSchema>;
+type TagUsageReport = z.infer<typeof TagUsageReportSchema>;
+
+/**
+ * Alert type enum
+ * Source: ~/code/pfm-platform/apps/legacy/src/api/alerts.js (routeMapping)
+ */
+declare const AlertTypeSchema: z.ZodEnum<{
+    AccountThresholdAlert: "AccountThresholdAlert";
+    GoalAlert: "GoalAlert";
+    MerchantNameAlert: "MerchantNameAlert";
+    SpendingTargetAlert: "SpendingTargetAlert";
+    TransactionLimitAlert: "TransactionLimitAlert";
+    UpcomingBillAlert: "UpcomingBillAlert";
+}>;
+/**
+ * Alert source type enum
+ * Source: ~/code/pfm-platform/services/validator/specs/openapi-spec/components/schemas/Alert.yaml
+ */
+declare const AlertSourceTypeSchema: z.ZodNullable<z.ZodEnum<{
+    Account: "Account";
+    Budget: "Budget";
+    CashflowTransaction: "CashflowTransaction";
+    PayoffGoal: "PayoffGoal";
+    SavingsGoal: "SavingsGoal";
+}>>;
+/**
+ * Alert destinations schema
+ * Source: ~/code/pfm-platform/services/validator/specs/openapi-spec/components/schemas/AlertDestinations.yaml
+ */
+declare const AlertDestinationsSchema: z.ZodObject<{
+    email_address: z.ZodNullable<z.ZodString>;
+    sms_number: z.ZodNullable<z.ZodString>;
+    partner_sms_enabled: z.ZodBoolean;
+}, z.core.$strip>;
+/**
+ * Alert schema matching legacy API response structure
+ * Source: ~/code/pfm-platform/apps/legacy/src/api/data/alerts.json
+ *
+ * CRITICAL NOTES:
+ * - id: INTEGER (internal DB ID)
+ * - source_id: STRING in legacy data (e.g., "41"), not integer like OpenAPI suggests
+ * - options: Dynamic object with alert-specific config (use .passthrough())
+ * - source: Full nested object (Account, Goal, Budget, etc.) - keeping as unknown for flexibility
+ * - Legacy data shows source can be deeply nested with full object structure
+ */
+declare const AlertSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    type: z.ZodEnum<{
+        AccountThresholdAlert: "AccountThresholdAlert";
+        GoalAlert: "GoalAlert";
+        MerchantNameAlert: "MerchantNameAlert";
+        SpendingTargetAlert: "SpendingTargetAlert";
+        TransactionLimitAlert: "TransactionLimitAlert";
+        UpcomingBillAlert: "UpcomingBillAlert";
+    }>;
+    options: z.ZodObject<{}, z.core.$loose>;
+    email_delivery: z.ZodBoolean;
+    sms_delivery: z.ZodBoolean;
+    source_type: z.ZodNullable<z.ZodEnum<{
+        Account: "Account";
+        Budget: "Budget";
+        CashflowTransaction: "CashflowTransaction";
+        PayoffGoal: "PayoffGoal";
+        SavingsGoal: "SavingsGoal";
+    }>>;
+    source_id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    source: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+/**
+ * Alert creation schema
+ * Based on legacy API createAlert function - uses toJson() which removes id and type
+ * Type is determined by route, id is server-generated
+ * Using .strict() to prevent unknown fields (Session 1 pattern)
+ */
+declare const AlertCreateSchema: z.ZodObject<{
+    options: z.ZodObject<{}, z.core.$loose>;
+    email_delivery: z.ZodBoolean;
+    sms_delivery: z.ZodBoolean;
+    source_type: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        Account: "Account";
+        Budget: "Budget";
+        CashflowTransaction: "CashflowTransaction";
+        PayoffGoal: "PayoffGoal";
+        SavingsGoal: "SavingsGoal";
+    }>>>;
+    source_id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+}, z.core.$strict>;
+/**
+ * Alert update schema
+ * Based on legacy API updateAlert function - uses toJson() which removes id and type
+ * Using .strict() to prevent unknown fields (Session 1 pattern)
+ */
+declare const AlertUpdateSchema: z.ZodObject<{
+    options: z.ZodObject<{}, z.core.$loose>;
+    email_delivery: z.ZodBoolean;
+    sms_delivery: z.ZodBoolean;
+    source_type: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        Account: "Account";
+        Budget: "Budget";
+        CashflowTransaction: "CashflowTransaction";
+        PayoffGoal: "PayoffGoal";
+        SavingsGoal: "SavingsGoal";
+    }>>>;
+    source_id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+}, z.core.$strict>;
+/**
+ * Alert destinations update schema
+ * Based on legacy API updateDestinations function
+ */
+declare const AlertDestinationsUpdateSchema: z.ZodObject<{
+    email_address: z.ZodNullable<z.ZodString>;
+    sms_number: z.ZodNullable<z.ZodString>;
+    partner_sms_enabled: z.ZodBoolean;
+}, z.core.$strip>;
+/**
+ * Alerts response schema - array of alerts
+ * Used by list endpoint: GET /users/:userId/alerts
+ */
+declare const AlertsResponseSchema: z.ZodObject<{
+    alerts: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        type: z.ZodEnum<{
+            AccountThresholdAlert: "AccountThresholdAlert";
+            GoalAlert: "GoalAlert";
+            MerchantNameAlert: "MerchantNameAlert";
+            SpendingTargetAlert: "SpendingTargetAlert";
+            TransactionLimitAlert: "TransactionLimitAlert";
+            UpcomingBillAlert: "UpcomingBillAlert";
+        }>;
+        options: z.ZodObject<{}, z.core.$loose>;
+        email_delivery: z.ZodBoolean;
+        sms_delivery: z.ZodBoolean;
+        source_type: z.ZodNullable<z.ZodEnum<{
+            Account: "Account";
+            Budget: "Budget";
+            CashflowTransaction: "CashflowTransaction";
+            PayoffGoal: "PayoffGoal";
+            SavingsGoal: "SavingsGoal";
+        }>>;
+        source_id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+        source: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+
+/**
+ * Type exports for Alert domain
+ * Source: Inferred from Zod schemas matching legacy API
+ */
+type AlertType = z.infer<typeof AlertTypeSchema>;
+type AlertSourceType = z.infer<typeof AlertSourceTypeSchema>;
+type Alert = z.infer<typeof AlertSchema>;
+type AlertCreate = z.infer<typeof AlertCreateSchema>;
+type AlertUpdate = z.infer<typeof AlertUpdateSchema>;
+type AlertDestinations = z.infer<typeof AlertDestinationsSchema>;
+type AlertDestinationsUpdate = z.infer<typeof AlertDestinationsUpdateSchema>;
+type AlertsResponse = z.infer<typeof AlertsResponseSchema>;
+
+/**
+ * Notification schema matching legacy API response structure
+ * Source: ~/code/pfm-platform/apps/legacy/src/api/data/notifications.json
+ *
+ * CRITICAL NOTES:
+ * - Notifications are read-only (GET + DELETE endpoints only)
+ * - System-generated based on alert configurations
+ * - alert_type references AlertType enum from alerts domain
+ * - No create/update schemas (notifications generated by system)
+ * - created_at: RFC 3339 datetime string
+ */
+declare const NotificationSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    user_id: z.ZodString;
+    alert_id: z.ZodNumber;
+    message: z.ZodString;
+    alert_type: z.ZodEnum<{
+        AccountThresholdAlert: "AccountThresholdAlert";
+        GoalAlert: "GoalAlert";
+        MerchantNameAlert: "MerchantNameAlert";
+        SpendingTargetAlert: "SpendingTargetAlert";
+        TransactionLimitAlert: "TransactionLimitAlert";
+        UpcomingBillAlert: "UpcomingBillAlert";
+    }>;
+    is_read: z.ZodDefault<z.ZodBoolean>;
+    created_at: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Notifications list response schema
+ * API returns notifications array wrapper
+ */
+declare const NotificationsResponseSchema: z.ZodObject<{
+    notifications: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        user_id: z.ZodString;
+        alert_id: z.ZodNumber;
+        message: z.ZodString;
+        alert_type: z.ZodEnum<{
+            AccountThresholdAlert: "AccountThresholdAlert";
+            GoalAlert: "GoalAlert";
+            MerchantNameAlert: "MerchantNameAlert";
+            SpendingTargetAlert: "SpendingTargetAlert";
+            TransactionLimitAlert: "TransactionLimitAlert";
+            UpcomingBillAlert: "UpcomingBillAlert";
+        }>;
+        is_read: z.ZodDefault<z.ZodBoolean>;
+        created_at: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Notification create schema - Admin mode
+ * Minimal validation for test data creation
+ * Allows creating notifications manually for testing purposes
+ */
+declare const NotificationCreateSchemaAdmin: z.ZodObject<{
+    message: z.ZodString;
+    alert_type: z.ZodEnum<{
+        AccountThresholdAlert: "AccountThresholdAlert";
+        GoalAlert: "GoalAlert";
+        MerchantNameAlert: "MerchantNameAlert";
+        SpendingTargetAlert: "SpendingTargetAlert";
+        TransactionLimitAlert: "TransactionLimitAlert";
+        UpcomingBillAlert: "UpcomingBillAlert";
+    }>;
+    created_at: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Notification create schema - User mode
+ * Notifications are system-generated, users cannot create them
+ */
+declare const NotificationCreateSchemaUser: z.ZodNever;
+/**
+ * Notification update schema - Admin mode
+ * Allows updating notification message for testing
+ */
+declare const NotificationUpdateSchemaAdmin: z.ZodObject<{
+    message: z.ZodOptional<z.ZodString>;
+    alert_type: z.ZodOptional<z.ZodEnum<{
+        AccountThresholdAlert: "AccountThresholdAlert";
+        GoalAlert: "GoalAlert";
+        MerchantNameAlert: "MerchantNameAlert";
+        SpendingTargetAlert: "SpendingTargetAlert";
+        TransactionLimitAlert: "TransactionLimitAlert";
+        UpcomingBillAlert: "UpcomingBillAlert";
+    }>>;
+}, z.core.$strip>;
+/**
+ * Notification update schema - User mode
+ * Users can mark notifications as read/unread
+ */
+declare const NotificationUpdateSchemaUser: z.ZodObject<{
+    is_read: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * Notification frequency options
+ */
+declare const NotificationFrequencySchema: z.ZodEnum<{
+    weekly: "weekly";
+    realtime: "realtime";
+    daily: "daily";
+}>;
+type NotificationFrequency = z.infer<typeof NotificationFrequencySchema>;
+/**
+ * User notification preferences schema
+ */
+declare const NotificationPreferencesSchema: z.ZodObject<{
+    emailNotifications: z.ZodBoolean;
+    pushNotifications: z.ZodBoolean;
+    frequency: z.ZodEnum<{
+        weekly: "weekly";
+        realtime: "realtime";
+        daily: "daily";
+    }>;
+}, z.core.$strip>;
+type NotificationPreferences = z.infer<typeof NotificationPreferencesSchema>;
+/**
+ * Notification preferences update schema
+ */
+declare const NotificationPreferencesUpdateSchema: z.ZodObject<{
+    emailNotifications: z.ZodOptional<z.ZodBoolean>;
+    pushNotifications: z.ZodOptional<z.ZodBoolean>;
+    frequency: z.ZodOptional<z.ZodEnum<{
+        weekly: "weekly";
+        realtime: "realtime";
+        daily: "daily";
+    }>>;
+}, z.core.$strip>;
+
+/**
+ * Type exports for Notification domain
+ * Source: Inferred from Zod schemas matching legacy API
+ */
+type Notification = z.infer<typeof NotificationSchema>;
+type NotificationsResponse = z.infer<typeof NotificationsResponseSchema>;
+
+/**
+ * Partner schema matching legacy API response structure
+ * Source: ~/code/pfm-platform/apps/legacy/src/api/data/partners.json
+ *
+ * CRITICAL NOTES:
+ * - Partners are read-only configuration (GET endpoint only)
+ * - OpenAPI schema has DIFFERENT fields than legacy data (name, logo_url vs product_name, browser_title)
+ * - Legacy is SOURCE OF TRUTH - using actual fields from mock data
+ * - modules: Dynamic nested object with partner-specific configuration
+ * - featured_searches: Array of search configurations (empty in mock)
+ */
+declare const PartnerSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    domain: z.ZodString;
+    product_name: z.ZodString;
+    browser_title: z.ZodString;
+    partner_alerts_enabled: z.ZodBoolean;
+    demo: z.ZodBoolean;
+    modules: z.ZodObject<{}, z.core.$loose>;
+    featured_searches: z.ZodArray<z.ZodUnknown>;
+}, z.core.$strip>;
+/**
+ * Partners list response schema
+ * API returns partners array wrapper
+ * Note: Typically contains single partner (current partner)
+ */
+declare const PartnersResponseSchema: z.ZodObject<{
+    partners: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        domain: z.ZodString;
+        product_name: z.ZodString;
+        browser_title: z.ZodString;
+        partner_alerts_enabled: z.ZodBoolean;
+        demo: z.ZodBoolean;
+        modules: z.ZodObject<{}, z.core.$loose>;
+        featured_searches: z.ZodArray<z.ZodUnknown>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Partner create schema - Admin mode
+ * Minimal validation for test data creation
+ * Allows creating partner configuration manually for testing purposes
+ */
+declare const PartnerCreateSchemaAdmin: z.ZodObject<{
+    domain: z.ZodString;
+    product_name: z.ZodString;
+    browser_title: z.ZodString;
+    partner_alerts_enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    demo: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    modules: z.ZodDefault<z.ZodOptional<z.ZodObject<{}, z.core.$loose>>>;
+    featured_searches: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodUnknown>>>;
+}, z.core.$strip>;
+/**
+ * Partner create schema - User mode
+ * Partners are configuration data, users cannot create them
+ */
+declare const PartnerCreateSchemaUser: z.ZodNever;
+/**
+ * Partner update schema - Admin mode
+ * Allows updating partner configuration for testing
+ */
+declare const PartnerUpdateSchemaAdmin: z.ZodObject<{
+    domain: z.ZodOptional<z.ZodString>;
+    product_name: z.ZodOptional<z.ZodString>;
+    browser_title: z.ZodOptional<z.ZodString>;
+    partner_alerts_enabled: z.ZodOptional<z.ZodBoolean>;
+    demo: z.ZodOptional<z.ZodBoolean>;
+    modules: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+    featured_searches: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+}, z.core.$strip>;
+/**
+ * Partner update schema - User mode
+ * Partners are configuration data, users cannot update them
+ */
+declare const PartnerUpdateSchemaUser: z.ZodNever;
+/**
+ * Partner delete schema
+ * Requires partner ID for deletion
+ */
+declare const PartnerDeleteSchema: z.ZodObject<{
+    id: z.ZodNumber;
+}, z.core.$strip>;
+
+/**
+ * Type exports for Partner domain
+ * Source: Inferred from Zod schemas matching legacy API
+ */
+type Partner = z.infer<typeof PartnerSchema>;
+type PartnersResponse = z.infer<typeof PartnersResponseSchema>;
+
+/**
+ * Expense schema matching legacy API response structure
+ * Source: ~/code/pfm-platform/apps/legacy/src/api/data/expenses.json
+ *
+ * CRITICAL NOTES:
+ * - Expenses are read-only aggregated data (GET endpoint only with date range filters)
+ * - Computed from transaction data grouped by tag
+ * - OpenAPI has additional fields (percentage, transaction_count) NOT in legacy data
+ * - Legacy is SOURCE OF TRUTH - only tag and amount present
+ * - amount: STRING with decimal format (like Account, Goal amounts)
+ * - tag: References tag names from tags domain (but not enforced as enum)
+ */
+declare const ExpenseSchema: z.ZodObject<{
+    tag: z.ZodString;
+    amount: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Expenses list response schema
+ * API returns expenses array wrapper
+ * Aggregated by tag for the specified date range
+ */
+declare const ExpensesResponseSchema: z.ZodObject<{
+    expenses: z.ZodArray<z.ZodObject<{
+        tag: z.ZodString;
+        amount: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Expense create schema - Admin mode
+ * Minimal validation for test data creation
+ * Allows creating expense records manually for testing purposes
+ */
+declare const ExpenseCreateSchemaAdmin: z.ZodObject<{
+    tag: z.ZodString;
+    amount: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Expense create schema - User mode
+ * Expenses are computed from transactions, users cannot create them directly
+ */
+declare const ExpenseCreateSchemaUser: z.ZodNever;
+/**
+ * Expense update schema - Admin mode
+ * Allows updating expense fields for testing
+ */
+declare const ExpenseUpdateSchemaAdmin: z.ZodObject<{
+    amount: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Expense update schema - User mode
+ * Expenses are computed from transactions, users cannot update them
+ */
+declare const ExpenseUpdateSchemaUser: z.ZodNever;
+/**
+ * Expense delete schema
+ * Requires expense tag for deletion
+ */
+declare const ExpenseDeleteSchema: z.ZodObject<{
+    tag: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Expense search parameters
+ * Endpoint: GET /users/{userId}/expenses
+ * Note: All expenses endpoints are read-only (computed from transactions)
+ */
+declare const ExpenseSearchParamsSchema: z.ZodObject<{
+    begin_on: z.ZodOptional<z.ZodString>;
+    end_on: z.ZodOptional<z.ZodString>;
+    threshold: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+
+/**
+ * Type exports for Expense domain
+ * Source: Inferred from Zod schemas matching legacy API
+ */
+type Expense = z.infer<typeof ExpenseSchema>;
+type ExpensesResponse = z.infer<typeof ExpensesResponseSchema>;
+type ExpenseSearchParams = z.infer<typeof ExpenseSearchParamsSchema>;
+
+/**
+ * Net Worth schema matching legacy API response structure
+ * Source: ~/code/pfm-platform/apps/legacy/src/stores/netWorthStore.js
+ * Endpoint: GET /users/{userId}/networth
+ *
+ * CRITICAL NOTES:
+ * - Amounts are STRINGS with decimal format (like Account, Expense schemas)
+ * - Meta provides summary totals
+ * - Assets and debts are aggregated from accounts + manual net worth accounts
+ * - History provides monthly snapshots for trending
+ */
+/**
+ * Net worth meta (summary totals)
+ * All amounts are strings with decimal format
+ */
+declare const NetWorthMetaSchema: z.ZodObject<{
+    net_worth: z.ZodString;
+    net_worth_change: z.ZodString;
+    total_assets: z.ZodString;
+    total_debts: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Net worth asset item
+ * Can be from aggregated account OR manual net worth account
+ */
+declare const NetWorthAssetSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    name: z.ZodString;
+    balance: z.ZodString;
+    additional_networth_account: z.ZodBoolean;
+}, z.core.$strip>;
+/**
+ * Net worth debt item
+ * Can be from aggregated account OR manual net worth account
+ */
+declare const NetWorthDebtSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    name: z.ZodString;
+    balance: z.ZodString;
+    additional_networth_account: z.ZodBoolean;
+}, z.core.$strip>;
+/**
+ * Net worth history (monthly snapshot)
+ * Provides historical trending data
+ */
+declare const NetWorthHistorySchema: z.ZodObject<{
+    total: z.ZodString;
+    total_asset: z.ZodString;
+    total_debt: z.ZodString;
+    month: z.ZodString;
+    year: z.ZodString;
+    since_last_month: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Complete net worth response
+ */
+declare const NetWorthSchema: z.ZodObject<{
+    meta: z.ZodObject<{
+        net_worth: z.ZodString;
+        net_worth_change: z.ZodString;
+        total_assets: z.ZodString;
+        total_debts: z.ZodString;
+    }, z.core.$strip>;
+    assets: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+        balance: z.ZodString;
+        additional_networth_account: z.ZodBoolean;
+    }, z.core.$strip>>;
+    debts: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+        balance: z.ZodString;
+        additional_networth_account: z.ZodBoolean;
+    }, z.core.$strip>>;
+    networth_histories: z.ZodArray<z.ZodObject<{
+        total: z.ZodString;
+        total_asset: z.ZodString;
+        total_debt: z.ZodString;
+        month: z.ZodString;
+        year: z.ZodString;
+        since_last_month: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Net worth response wrapper
+ * Note: API returns object directly, not wrapped in array
+ */
+declare const NetWorthResponseSchema: z.ZodObject<{
+    meta: z.ZodObject<{
+        net_worth: z.ZodString;
+        net_worth_change: z.ZodString;
+        total_assets: z.ZodString;
+        total_debts: z.ZodString;
+    }, z.core.$strip>;
+    assets: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+        balance: z.ZodString;
+        additional_networth_account: z.ZodBoolean;
+    }, z.core.$strip>>;
+    debts: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+        balance: z.ZodString;
+        additional_networth_account: z.ZodBoolean;
+    }, z.core.$strip>>;
+    networth_histories: z.ZodArray<z.ZodObject<{
+        total: z.ZodString;
+        total_asset: z.ZodString;
+        total_debt: z.ZodString;
+        month: z.ZodString;
+        year: z.ZodString;
+        since_last_month: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Manual net worth account type
+ * For assets/debts not tracked via aggregation
+ */
+declare const NetWorthAccountTypeSchema: z.ZodEnum<{
+    asset: "asset";
+    debt: "debt";
+}>;
+/**
+ * Create manual net worth account
+ * Endpoint: POST /users/{userId}/networth/accounts
+ */
+declare const NetWorthAccountCreateSchema: z.ZodObject<{
+    networth_account: z.ZodObject<{
+        account_type: z.ZodEnum<{
+            asset: "asset";
+            debt: "debt";
+        }>;
+        balance: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * Update manual net worth account
+ * Endpoint: PUT /users/{userId}/networth/accounts/{id}
+ */
+declare const NetWorthAccountUpdateSchema: z.ZodObject<{
+    networth_account: z.ZodObject<{
+        account_type: z.ZodOptional<z.ZodEnum<{
+            asset: "asset";
+            debt: "debt";
+        }>>;
+        balance: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * Delete manual net worth account
+ * Endpoint: DELETE /users/{userId}/networth/accounts/{id}
+ * Simple id-only schema (id comes from URL path)
+ */
+declare const NetWorthAccountDeleteSchema: z.ZodObject<{
+    id: z.ZodNumber;
+}, z.core.$strip>;
+
+type NetWorth = z.infer<typeof NetWorthSchema>;
+type NetWorthResponse = z.infer<typeof NetWorthResponseSchema>;
+type NetWorthMeta = z.infer<typeof NetWorthMetaSchema>;
+type NetWorthAsset = z.infer<typeof NetWorthAssetSchema>;
+type NetWorthDebt = z.infer<typeof NetWorthDebtSchema>;
+type NetWorthHistory = z.infer<typeof NetWorthHistorySchema>;
+type NetWorthAccountType = z.infer<typeof NetWorthAccountTypeSchema>;
+type NetWorthAccountCreate = z.infer<typeof NetWorthAccountCreateSchema>;
+type NetWorthAccountUpdate = z.infer<typeof NetWorthAccountUpdateSchema>;
+type NetWorthAccountDelete = z.infer<typeof NetWorthAccountDeleteSchema>;
+
+/**
+ * CashEdge and Finicity aggregation schemas
+ * Source: ~/code/pfm-platform/apps/legacy/src/stores/cashedgeStore.js
+ *
+ * CRITICAL NOTES:
+ * - Most requests use application/x-www-form-urlencoded, NOT JSON
+ * - Some endpoints are partner-level (no userId)
+ * - MFA flows require session state management
+ */
+/**
+ * Institution login parameter
+ * Defines credential inputs required for institution authentication
+ */
+declare const InstitutionLoginParameterSchema: z.ZodObject<{
+    parameter_id: z.ZodString;
+    label: z.ZodString;
+    type: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Institution search metadata
+ * Pagination info for institution search results
+ */
+declare const InstitutionSearchMetaSchema: z.ZodObject<{
+    page: z.ZodNumber;
+    total_pages: z.ZodNumber;
+    total_results: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Financial institution schema
+ * Institution available for account aggregation
+ */
+declare const InstitutionSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    name: z.ZodString;
+    home_url: z.ZodString;
+    ce_login_parameters: z.ZodArray<z.ZodObject<{
+        parameter_id: z.ZodString;
+        label: z.ZodString;
+        type: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Institutions response schema
+ * Endpoint: GET /ce_fis/search?q={query}&scope={scope}&page={page}
+ * Endpoint: GET /ce_fis?page={page}
+ * Endpoint: GET /ce_fis/{id}
+ */
+declare const InstitutionsResponseSchema: z.ZodObject<{
+    ce_fis: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+        home_url: z.ZodString;
+        ce_login_parameters: z.ZodArray<z.ZodObject<{
+            parameter_id: z.ZodString;
+            label: z.ZodString;
+            type: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    meta: z.ZodObject<{
+        page: z.ZodNumber;
+        total_pages: z.ZodNumber;
+        total_results: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * Authenticate institution request
+ * Endpoint: POST /users/{userId}/ce_fis
+ * Content-Type: application/x-www-form-urlencoded
+ *
+ * Note: Legacy uses form encoding, not JSON
+ * Example: id=101939&credentials[login_params][username]=user&credentials[login_params][password]=pass
+ */
+declare const AuthenticateRequestSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    credentials: z.ZodObject<{
+        login_params: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * Authenticate institution response
+ * Returns session IDs for tracking aggregation progress
+ */
+declare const AuthenticateResponseSchema: z.ZodObject<{
+    harvest_id: z.ZodString;
+    login_id: z.ZodString;
+    status: z.ZodString;
+}, z.core.$strip>;
+/**
+ * MFA (Multi-Factor Authentication) request
+ * Endpoint: PUT /users/{userId}/ce_fis/{institutionId}
+ * Content-Type: application/x-www-form-urlencoded
+ *
+ * Example: harvest_id=H123&login_id=L789&session_key=SK123&mfa_responses[code]=123456
+ */
+declare const MFARequestSchema: z.ZodObject<{
+    harvest_id: z.ZodString;
+    login_id: z.ZodString;
+    session_key: z.ZodString;
+    mfa_responses: z.ZodRecord<z.ZodString, z.ZodString>;
+}, z.core.$strip>;
+/**
+ * MFA response
+ */
+declare const MFAResponseSchema: z.ZodObject<{
+    status: z.ZodString;
+    message: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Update credentials request
+ * Endpoint: PUT /users/{userId}/accounts/{accountId}/update_credentials
+ * Content-Type: application/x-www-form-urlencoded
+ *
+ * Example: id=101939&credentials[login_params][username]=newuser&credentials[login_params][password]=newpass
+ */
+declare const UpdateCredentialsRequestSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    credentials: z.ZodObject<{
+        login_params: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * Update credentials response
+ */
+declare const UpdateCredentialsResponseSchema: z.ZodObject<{
+    status: z.ZodString;
+    message: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Classify accounts request
+ * Endpoint: PUT /users/{userId}/accounts/classify
+ * Content-Type: application/x-www-form-urlencoded
+ *
+ * Example: accounts[123][type_code]=DDA,DDA&accounts[456][type_code]=SAV,SAV&accounts[789][type_code]=ignore
+ *
+ * Note: Classifies pending accounts after aggregation
+ * type_code format: "ACCT_TYPE,EXT_TYPE" or "ignore" to skip
+ */
+declare const ClassifyAccountsRequestSchema: z.ZodObject<{
+    accounts: z.ZodRecord<z.ZodString, z.ZodObject<{
+        type_code: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * CashEdge login session request
+ * Endpoint: POST /users/{userId}/cashedge/login
+ *
+ * Note: Structure unclear from legacy code, needs investigation
+ * Placeholder schema based on typical session patterns
+ */
+declare const CashEdgeLoginRequestSchema: z.ZodObject<{
+    session_token: z.ZodOptional<z.ZodString>;
+    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+/**
+ * CashEdge login session response
+ * Endpoint: GET /users/{userId}/cashedge/login
+ * Endpoint: POST /users/{userId}/cashedge/login
+ *
+ * Note: Structure unclear from legacy code, needs investigation
+ * Placeholder schema based on typical session patterns
+ */
+declare const CashEdgeLoginResponseSchema: z.ZodObject<{
+    session_id: z.ZodString;
+    session_token: z.ZodOptional<z.ZodString>;
+    expires_at: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+
+type Institution = z.infer<typeof InstitutionSchema>;
+type InstitutionsResponse = z.infer<typeof InstitutionsResponseSchema>;
+type InstitutionLoginParameter = z.infer<typeof InstitutionLoginParameterSchema>;
+type InstitutionSearchMeta = z.infer<typeof InstitutionSearchMetaSchema>;
+type AuthenticateRequest = z.infer<typeof AuthenticateRequestSchema>;
+type AuthenticateResponse = z.infer<typeof AuthenticateResponseSchema>;
+type MFARequest = z.infer<typeof MFARequestSchema>;
+type MFAResponse = z.infer<typeof MFAResponseSchema>;
+type UpdateCredentialsRequest = z.infer<typeof UpdateCredentialsRequestSchema>;
+type UpdateCredentialsResponse = z.infer<typeof UpdateCredentialsResponseSchema>;
+type ClassifyAccountsRequest = z.infer<typeof ClassifyAccountsRequestSchema>;
+type CashEdgeLoginRequest = z.infer<typeof CashEdgeLoginRequestSchema>;
+type CashEdgeLoginResponse = z.infer<typeof CashEdgeLoginResponseSchema>;
+
+/**
+ * Chart Utilities
+ * Shared utilities for MUI X Charts across all domains
+ */
+
+/**
+ * Currency formatter for chart axes and tooltips
+ */
+declare function formatCurrency(value: number): string;
+/**
+ * Abbreviated currency formatter for compact displays
+ * E.g., $1,234 → $1.2K, $1,234,567 → $1.2M
+ */
+declare function formatCurrencyAbbreviated(value: number): string;
+/**
+ * Percentage formatter for chart labels
+ */
+declare function formatPercentage(value: number): string;
+/**
+ * Get chart color palette from MUI theme
+ * Returns an array of colors suitable for pie/donut charts
+ */
+declare function getChartColors(theme: Theme): string[];
+/**
+ * Get color by index with wrapping
+ * Ensures we always have a color even for large datasets
+ */
+declare function getColorByIndex(colors: string[], index: number): string;
+/**
+ * Chart dimension constants
+ * Based on legacy D3 component sizes
+ */
+declare const CHART_DIMENSIONS: {
+    readonly donut: {
+        readonly width: 200;
+        readonly height: 200;
+        readonly innerRadius: 60;
+        readonly outerRadius: 95;
+    };
+    readonly lineChart: {
+        readonly width: 300;
+        readonly height: 150;
+        readonly margin: {
+            readonly top: 10;
+            readonly right: 20;
+            readonly bottom: 20;
+            readonly left: 50;
+        };
+    };
+    readonly barChart: {
+        readonly width: 300;
+        readonly height: 160;
+        readonly margin: {
+            readonly top: 20;
+            readonly left: 50;
+            readonly bottom: 40;
+            readonly right: 20;
+        };
+    };
+};
+/**
+ * Common chart props for consistency
+ */
+interface BaseChartData {
+    name: string;
+    value: number;
+}
+/**
+ * Chart theming configuration
+ * Provides consistent styling across all charts
+ */
+declare function getChartThemeConfig(theme: Theme): {
+    backgroundColor: string;
+    textColor: string;
+    gridColor: string;
+    tooltipBackgroundColor: string;
+    tooltipBorderColor: string;
+};
+
+/**
+ * Animation Utilities
+ *
+ * D3-equivalent animation configurations for Framer Motion.
+ * Matches legacy D3 transition timing and easing functions.
+ */
+
+/**
+ * D3 Transition Durations (matching legacy)
+ */
+declare const ANIMATION_DURATIONS: {
+    /** Arc/pie slice transitions (D3: 1000ms) */
+    readonly arc: 1000;
+    /** Text transitions (D3: 200ms) */
+    readonly text: 200;
+    /** Meter/progress bar (D3: 600ms) */
+    readonly meter: 600;
+    /** Settings panel slide */
+    readonly panel: 300;
+    /** Tooltip/hover states */
+    readonly hover: 150;
+};
+/**
+ * Easing functions matching D3 defaults
+ * D3 uses easeInOut by default for most transitions
+ */
+declare const ANIMATION_EASING: {
+    /** D3 easeInOut equivalent */
+    readonly default: readonly [0.4, 0, 0.2, 1];
+    /** D3 easeOut equivalent */
+    readonly easeOut: readonly [0, 0, 0.2, 1];
+    /** D3 easeIn equivalent */
+    readonly easeIn: readonly [0.4, 0, 1, 1];
+    /** D3 easeLinear equivalent */
+    readonly linear: readonly [0, 0, 1, 1];
+};
+/**
+ * Arc/Pie Slice Animation Variants
+ * Matches D3 arc enter/update/exit pattern with 1000ms duration
+ */
+declare const arcVariants: Variants;
+/**
+ * Text Animation Variants
+ * Matches D3 text transition with 200ms duration
+ */
+declare const textVariants: Variants;
+/**
+ * Panel Slide Animation Variants
+ * For settings panel and card flipper animations
+ */
+declare const panelVariants: Variants;
+/**
+ * Fade Animation Variants
+ * For loading states and empty states
+ */
+declare const fadeVariants: Variants;
+/**
+ * Progress Bar Animation Variants
+ * Matches D3 meter transitions (600ms)
+ */
+declare const progressVariants: Variants;
+/**
+ * List Item Stagger Animation
+ * For breakdown table rows and tag lists
+ */
+declare const listContainerVariants: Variants;
+declare const listItemVariants: Variants;
+/**
+ * Create custom transition config
+ */
+declare function createTransition(duration: number, ease?: readonly number[]): Transition;
+/**
+ * Spring animation config (alternative to easing)
+ * Useful for interactive elements
+ */
+declare const SPRING_CONFIG: {
+    default: {
+        type: "spring";
+        stiffness: number;
+        damping: number;
+    };
+    bouncy: {
+        type: "spring";
+        stiffness: number;
+        damping: number;
+    };
+    slow: {
+        type: "spring";
+        stiffness: number;
+        damping: number;
+    };
+};
+
+export { ANIMATION_DURATIONS, ANIMATION_EASING, type Account, type AccountArchive, AccountArchiveSchema, type AccountCreate, AccountCreateSchema, AccountCreateSchemaAdmin, AccountCreateSchemaUser, type AccountDelete, AccountDeleteSchema, type AccountError, AccountErrorSchema, AccountSchema, type AccountState, AccountStateSchema, type AccountType, AccountTypeSchema, type AccountUpdate, AccountUpdateSchema, type AccountsResponse, AccountsResponseSchema, type AggregationType, AggregationTypeSchema, type Alert, type AlertCreate, AlertCreateSchema, type AlertDestinations, AlertDestinationsSchema, type AlertDestinationsUpdate, AlertDestinationsUpdateSchema, AlertSchema, type AlertSourceType, AlertSourceTypeSchema, type AlertType, AlertTypeSchema, type AlertUpdate, AlertUpdateSchema, type AlertsResponse, AlertsResponseSchema, type AppMode, AppModeContext, type AppModeContextValue, AppModeProvider, type AppModeProviderProps, type AuthenticateRequest, AuthenticateRequestSchema, type AuthenticateResponse, AuthenticateResponseSchema, type BaseChartData, type Budget, type BudgetCreate, BudgetCreateSchema, type BudgetLinks, BudgetLinksSchema, BudgetSchema, type BudgetState, BudgetStateSchema, type BudgetUpdate, BudgetUpdateSchema, type BudgetsResponse, BudgetsResponseSchema, CHART_DIMENSIONS, type CashEdgeAccountType, CashEdgeAccountTypeSchema, type CashEdgeLoginRequest, CashEdgeLoginRequestSchema, type CashEdgeLoginResponse, CashEdgeLoginResponseSchema, type CashflowEvent, type CashflowEventCreate, CashflowEventCreateSchema, type CashflowEventFilter, CashflowEventFilterSchema, CashflowEventSchema, type CashflowEventType, CashflowEventTypeSchema, type CashflowEventUpdate, CashflowEventUpdateSchema, type CashflowEventsResponse, CashflowEventsResponseSchema, type ClassifyAccountsRequest, ClassifyAccountsRequestSchema, type DefaultTags, DefaultTagsSchema, type Expense, ExpenseCreateSchemaAdmin, ExpenseCreateSchemaUser, ExpenseDeleteSchema, ExpenseSchema, type ExpenseSearchParams, ExpenseSearchParamsSchema, ExpenseUpdateSchemaAdmin, ExpenseUpdateSchemaUser, type ExpensesResponse, ExpensesResponseSchema, type FinancialInstitution, FinancialInstitutionSchema, type GoalCreate, GoalCreateSchema, type GoalImagesResponse, GoalImagesResponseSchema, type GoalLinks, GoalLinksSchema, type GoalState, GoalStateSchema, type GoalStatus, GoalStatusSchema, type GoalUpdate, GoalUpdateSchema, type Institution, type InstitutionLoginParameter, InstitutionLoginParameterSchema, InstitutionSchema, type InstitutionSearchMeta, InstitutionSearchMetaSchema, type InstitutionsResponse, InstitutionsResponseSchema, type Investment, type InvestmentHolding, InvestmentHoldingSchema, InvestmentSchema, type InvestmentsResponse, InvestmentsResponseSchema, type MFARequest, MFARequestSchema, type MFAResponse, MFAResponseSchema, type NetWorth, type NetWorthAccountCreate, NetWorthAccountCreateSchema, type NetWorthAccountDelete, NetWorthAccountDeleteSchema, type NetWorthAccountType, NetWorthAccountTypeSchema, type NetWorthAccountUpdate, NetWorthAccountUpdateSchema, type NetWorthAsset, NetWorthAssetSchema, type NetWorthDebt, NetWorthDebtSchema, type NetWorthHistory, NetWorthHistorySchema, type NetWorthMeta, NetWorthMetaSchema, type NetWorthResponse, NetWorthResponseSchema, NetWorthSchema, type Notification, NotificationCreateSchemaAdmin, NotificationCreateSchemaUser, type NotificationFrequency, NotificationFrequencySchema, type NotificationPreferences, NotificationPreferencesSchema, NotificationPreferencesUpdateSchema, NotificationSchema, NotificationUpdateSchemaAdmin, NotificationUpdateSchemaUser, type NotificationsResponse, NotificationsResponseSchema, type OtherBalance, OtherBalanceSchema, type Partner, PartnerCreateSchemaAdmin, PartnerCreateSchemaUser, PartnerDeleteSchema, PartnerSchema, PartnerUpdateSchemaAdmin, PartnerUpdateSchemaUser, type PartnersResponse, PartnersResponseSchema, type PayoffGoal, PayoffGoalSchema, type PayoffGoalsResponse, PayoffGoalsResponseSchema, type PendingAccount, type PendingAccountDelete, PendingAccountDeleteSchema, PendingAccountSchema, type PendingAccountsResponse, PendingAccountsResponseSchema, type PreferredBalanceType, PreferredBalanceTypeSchema, type RecurrenceFrequency, RecurrenceFrequencySchema, SPRING_CONFIG, type SavingsGoal, SavingsGoalSchema, type SavingsGoalsResponse, SavingsGoalsResponseSchema, type TagColor, TagColorSchema, TagCreateSchemaAdmin, TagCreateSchemaUser, TagDeleteSchema, type TagReportItem, TagReportItemSchema, type TagUsageDataPoint, TagUsageDataPointSchema, type TagUsageReport, TagUsageReportSchema, type TagUsageStat, TagUsageStatSchema, type TagUsageStats, TagUsageStatsSchema, type TagsResponse, TagsResponseSchema, type TagsUpdate, TagsUpdateSchema, type Transaction, type TransactionCreate, TransactionCreateSchema, TransactionCreateSchemaAdmin, TransactionCreateSchemaUser, type TransactionDelete, TransactionDeleteSchema, type TransactionLinks, TransactionLinksSchema, TransactionSchema, type TransactionSearchParams, TransactionSearchParamsSchema, type TransactionTag, TransactionTagSchema, type TransactionTagging, type TransactionTaggingRegular, TransactionTaggingRegularSchema, TransactionTaggingSchema, type TransactionTaggingSplit, type TransactionTaggingSplitItem, TransactionTaggingSplitItemSchema, TransactionTaggingSplitSchema, type TransactionType, TransactionTypeSchema, type TransactionUpdate, TransactionUpdateSchema, type TransactionsResponse, TransactionsResponseSchema, type UpdateCredentialsRequest, UpdateCredentialsRequestSchema, type UpdateCredentialsResponse, UpdateCredentialsResponseSchema, type User, type UserCreate, UserCreateSchema, UserCreateSchemaAdmin, UserCreateSchemaUser, UserSchema, type UserSex, UserSexSchema, type UserTags, UserTagsSchema, type UserUpdate, UserUpdateSchema, UserUpdateSchemaAdmin, UserUpdateSchemaUser, arcVariants, createTransition, fadeVariants, formatCurrency, formatCurrencyAbbreviated, formatPercentage, getChartColors, getChartThemeConfig, getColorByIndex, listContainerVariants, listItemVariants, panelVariants, progressVariants, textVariants, useAppMode };