braid-ui 1.0.99 → 1.0.100

package/dist/index.d.ts

@@ -0,0 +1,2027 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { z } from 'zod';
+import * as React$1 from 'react';
+import React__default, { ReactNode } from 'react';
+import { UseFormReturn, FieldValues, FieldPath, UseFormProps, Path } from 'react-hook-form';
+import * as class_variance_authority_dist_types from 'class-variance-authority/dist/types';
+import { VariantProps } from 'class-variance-authority';
+import { DayPicker } from 'react-day-picker';
+import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
+import * as LabelPrimitive from '@radix-ui/react-label';
+import * as PopoverPrimitive from '@radix-ui/react-popover';
+import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area';
+import * as SeparatorPrimitive from '@radix-ui/react-separator';
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+import { Toaster as Toaster$1 } from 'sonner';
+import * as TabsPrimitive from '@radix-ui/react-tabs';
+import * as ToastPrimitives from '@radix-ui/react-toast';
+
+interface TimelineEvent {
+    id: string;
+    timestamp: string;
+    user: string;
+    action: string;
+    details?: string;
+    status?: string;
+}
+interface AlertNote {
+    id: string;
+    timestamp: string;
+    user: string;
+    content: string;
+    type: "RFI Note" | "Internal Note";
+}
+interface AlertDocument {
+    id: string;
+    name: string;
+    type: string;
+    description?: string;
+    size: string;
+    uploadedBy: string;
+    uploadedAt: string;
+    url?: string;
+}
+interface Alert {
+    id: string;
+    createdAt: string;
+    type: string;
+    status: "Unassigned" | "Closed" | "In Progress";
+    contextType: string;
+    rfiStatus?: "Completed" | "Provided" | "Pending";
+    description: string;
+    contextId?: string;
+    assignee?: string;
+    timeline?: TimelineEvent[];
+    notes?: AlertNote[];
+    documents?: AlertDocument[];
+    contextData?: any;
+}
+
+interface AlertDetailRouterProps {
+    alert: Alert;
+}
+declare const AlertDetailRouter: ({ alert }: AlertDetailRouterProps) => react_jsx_runtime.JSX.Element;
+
+interface AlertDocumentsProps {
+    alertId: string;
+    documents: AlertDocument[];
+    renderDocumentViewer?: (document: AlertDocument) => React.ReactNode;
+}
+declare const AlertDocuments: ({ alertId, documents, renderDocumentViewer }: AlertDocumentsProps) => react_jsx_runtime.JSX.Element;
+
+interface AlertHeaderControlsProps {
+    status: string;
+    assignee: string;
+    rfiStatus: string;
+    onAssigneeChange: (value: string) => void;
+    onRfiStatusChange: (value: string) => void;
+}
+declare const AlertHeaderControls: ({ status, assignee, rfiStatus, onAssigneeChange, onRfiStatusChange }: AlertHeaderControlsProps) => react_jsx_runtime.JSX.Element;
+
+interface AlertNotesProps {
+    alertId: string;
+    notes: AlertNote[];
+}
+declare const AlertNotes: ({ alertId, notes }: AlertNotesProps) => react_jsx_runtime.JSX.Element;
+
+interface AlertTimelineProps {
+    events: TimelineEvent[];
+}
+declare const AlertTimeline: ({ events }: AlertTimelineProps) => react_jsx_runtime.JSX.Element;
+
+interface ContextSectionProps {
+    alert: Alert;
+}
+declare const ContextSection: ({ alert }: ContextSectionProps) => react_jsx_runtime.JSX.Element;
+
+interface OFACAlertViewProps {
+    alert: Alert;
+}
+declare const OFACAlertView: ({ alert }: OFACAlertViewProps) => react_jsx_runtime.JSX.Element;
+
+declare const resolveAlertSchema: z.ZodObject<{
+    action: z.ZodString;
+    changeToAccount: z.ZodOptional<z.ZodString>;
+    note: z.ZodString;
+    returnCode: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ResolveAlertFormData = z.infer<typeof resolveAlertSchema>;
+
+interface ResolveAlertDialogProps {
+    alertId: string;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onResolve: (data: ResolveAlertFormData) => Promise<void>;
+}
+declare const ResolveAlertDialog: ({ alertId, open, onOpenChange, onResolve }: ResolveAlertDialogProps) => react_jsx_runtime.JSX.Element;
+
+declare function AppSidebar(): react_jsx_runtime.JSX.Element;
+
+interface MainLayoutProps {
+    children: ReactNode;
+}
+declare const MainLayout: ({ children }: MainLayoutProps) => react_jsx_runtime.JSX.Element;
+
+interface UBO {
+    id: string;
+    name: string;
+    title: string;
+    ownershipPercentage: number;
+    customerId: string;
+}
+
+interface BusinessDocument {
+    id: string;
+    name: string;
+    type: string;
+    description?: string;
+    size: string;
+    uploadedBy: string;
+    uploadedAt: string;
+    url?: string;
+}
+
+interface OFACCheck {
+    id: string;
+    created: string;
+    entityId: string;
+    entityName: string;
+    entityType: "Individual" | "Business" | "Counterparty";
+    alertId: string | null;
+    status: "NO MATCH" | "REVIEW" | "CLEARED" | "CONFIRMED";
+    updatedBy: string;
+    note: string | null;
+}
+
+interface IdentityVerification {
+    customerId: string;
+    isDeveloperInitiated: boolean;
+    provider: string;
+    result: string;
+}
+
+declare const businessProfileSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    productId: z.ZodOptional<z.ZodNumber>;
+    businessIdType: z.ZodOptional<z.ZodString>;
+    idNumber: z.ZodOptional<z.ZodString>;
+    dba: z.ZodOptional<z.ZodString>;
+    businessEntityType: z.ZodOptional<z.ZodString>;
+    incorporationState: z.ZodOptional<z.ZodString>;
+    formationDate: z.ZodOptional<z.ZodString>;
+    website: z.ZodOptional<z.ZodString>;
+    achCompanyId: z.ZodOptional<z.ZodString>;
+    mcc: z.ZodOptional<z.ZodString>;
+    naics: z.ZodOptional<z.ZodString>;
+    mobilePhone: z.ZodOptional<z.ZodString>;
+    contactPersonFirstName: z.ZodOptional<z.ZodString>;
+    contactPersonLastName: z.ZodOptional<z.ZodString>;
+    contactPersonEmail: z.ZodOptional<z.ZodString>;
+    contactPersonPhone: z.ZodOptional<z.ZodString>;
+    address: z.ZodOptional<z.ZodObject<{
+        line1: z.ZodOptional<z.ZodString>;
+        line2: z.ZodOptional<z.ZodString>;
+        city: z.ZodOptional<z.ZodString>;
+        state: z.ZodOptional<z.ZodString>;
+        postalCode: z.ZodOptional<z.ZodString>;
+        countryCode: z.ZodString;
+        type: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    submittedBy: z.ZodOptional<z.ZodObject<{
+        contactPersonEmail: z.ZodOptional<z.ZodString>;
+        contactPersonFirstName: z.ZodOptional<z.ZodString>;
+        contactPersonLastName: z.ZodOptional<z.ZodString>;
+        contactPersonPhone: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type BusinessProfile = z.infer<typeof businessProfileSchema>;
+
+declare const uboSchema: z.ZodObject<{
+    legalFirstName: z.ZodOptional<z.ZodString>;
+    legalLastName: z.ZodOptional<z.ZodString>;
+    email: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    ownershipPercentage: z.ZodOptional<z.ZodNumber>;
+    idNumber: z.ZodOptional<z.ZodString>;
+    ssn: z.ZodOptional<z.ZodString>;
+    dateOfBirth: z.ZodOptional<z.ZodDate>;
+    street: z.ZodOptional<z.ZodString>;
+    apartment: z.ZodOptional<z.ZodString>;
+    city: z.ZodOptional<z.ZodString>;
+    state: z.ZodOptional<z.ZodString>;
+    country: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type UBOFormData = z.infer<typeof uboSchema>;
+
+declare const accountSchema: z.ZodObject<{
+    routingNumber: z.ZodOptional<z.ZodString>;
+    accountNumber: z.ZodOptional<z.ZodString>;
+    accountType: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type AccountFormData = z.infer<typeof accountSchema>;
+
+interface Business {
+    id: string;
+    businessName: string;
+    status: string;
+    cipStatus: "PASS" | "FAIL" | "IN_REVIEW" | "NOT_START" | "not_start" | "pending" | "rejected" | "verified";
+    type: "Business" | "Individual";
+    subType: "Customer" | "UBO";
+}
+interface BusinessAccount$1 {
+    id: string;
+    accountNumber: string;
+    routingNumber: string;
+    bankName: string;
+    bankAccountType: string;
+}
+interface SelectOption$4 {
+    value: string;
+    label: string;
+}
+interface BusinessDetailViewProps {
+    business: Business;
+    businessProfile?: BusinessProfile;
+    identityVerification?: IdentityVerification;
+    latestOFAC?: OFACCheck;
+    onNavigateToOFAC?: (ofacCheckId?: string) => void;
+    showTimeline?: boolean;
+    businessUBOs: UBO[];
+    businessDocuments: BusinessDocument[];
+    businessAccounts: BusinessAccount$1[];
+    currentStatus: string;
+    isEditingProfile: boolean;
+    statusOptions: SelectOption$4[];
+    businessEntityTypeOptions: SelectOption$4[];
+    onStatusChange: (newStatus: string) => void;
+    onProfileDataChange: (profile: BusinessProfile) => void;
+    onToggleProfileEdit: () => void;
+    onNavigateToAccounts: () => void;
+    onNavigateToCounterparty: () => void;
+    onCreateCounterparty?: () => void;
+    onNavigateToTransactions?: () => void;
+    onAddAccount?: (data: AccountFormData) => Promise<void | boolean> | void | boolean;
+    onDeleteAccount?: (accountId: string) => Promise<void | boolean> | void | boolean;
+    onUBOClick: (customerId: string) => void;
+    onAddUBO?: (data: UBOFormData) => Promise<void | boolean> | void | boolean;
+    onRemoveUBO?: (uboId: string) => void;
+    onDocumentUpload: (file: File, metadata: {
+        name: string;
+        description: string;
+        type: string;
+    }) => Promise<void>;
+    onDocumentDelete?: (documentId: string) => Promise<void | boolean> | void | boolean;
+    renderDocumentViewer?: (document: BusinessDocument) => ReactNode;
+    onRevealIdNumber?: () => Promise<string>;
+    isIdNumberRevealed?: boolean;
+    onToggleIdNumberVisibility?: () => void;
+    isLoadingIdNumber?: boolean;
+    revealedIdNumber?: string | null;
+    onProductIdClick?: (productId: number) => void;
+}
+declare const BusinessDetailView: ({ business, businessProfile, identityVerification, latestOFAC, onNavigateToOFAC, showTimeline, businessUBOs, businessDocuments, businessAccounts, currentStatus, isEditingProfile, statusOptions, businessEntityTypeOptions, onStatusChange, onProfileDataChange, onToggleProfileEdit, onNavigateToAccounts, onNavigateToCounterparty, onCreateCounterparty, onNavigateToTransactions, onAddAccount, onDeleteAccount, onUBOClick, onAddUBO, onRemoveUBO, onDocumentUpload, onDocumentDelete, renderDocumentViewer, onRevealIdNumber, isIdNumberRevealed, onToggleIdNumberVisibility, isLoadingIdNumber, revealedIdNumber, onProductIdClick, }: BusinessDetailViewProps) => react_jsx_runtime.JSX.Element;
+
+interface BusinessFilters {
+    businessId: string;
+    name: string;
+    productName: string;
+    status: string;
+    createdDateStart?: Date;
+    createdDateEnd?: Date;
+}
+interface BusinessFiltersSheetProps {
+    filters: BusinessFilters;
+    onFilterChange: (field: keyof BusinessFilters, value: string | Date | undefined) => void;
+    onResetFilters: () => void;
+}
+declare const BusinessFiltersSheet: ({ filters, onFilterChange, onResetFilters }: BusinessFiltersSheetProps) => react_jsx_runtime.JSX.Element;
+
+interface CreateBusinessViewProps {
+    form: UseFormReturn<BusinessProfile>;
+    businessType: string;
+    onBusinessTypeChange: (value: string) => void;
+    onSubmit: (data: BusinessProfile) => void;
+    onCancel: () => void;
+}
+declare const CreateBusinessView: ({ form, businessType, onBusinessTypeChange, onSubmit, onCancel }: CreateBusinessViewProps) => react_jsx_runtime.JSX.Element;
+
+interface CounterpartiesViewProps {
+    table: React.ReactNode;
+    filters: {
+        name: string;
+        status: string;
+        productId: string;
+        businessId: string;
+        individualId: string;
+        accountId: string;
+    };
+    onFilterChange: (field: string, value: string) => void;
+    onResetFilters: () => void;
+    onCreateCounterparty: () => void;
+}
+declare const CounterpartiesView: ({ table, filters, onFilterChange, onResetFilters, onCreateCounterparty }: CounterpartiesViewProps) => react_jsx_runtime.JSX.Element;
+
+interface PaymentMethodCardProps {
+    type: "ACH" | "Wire";
+    fiId: string;
+    accountNumber: string;
+    bankName?: string;
+    accountType?: string;
+    beneficiaryBankName?: string;
+    beneficiaryFiIdType?: string;
+    correspondentBankId?: string;
+    intermediaryBankId?: string;
+    wireType?: "DOMESTIC" | "INTERNATIONAL";
+    direction?: "INBOUND" | "OUTBOUND";
+    className?: string;
+    onDelete?: () => void;
+}
+
+declare const addressSchema: z.ZodObject<{
+    line1: z.ZodOptional<z.ZodString>;
+    line2: z.ZodOptional<z.ZodString>;
+    city: z.ZodOptional<z.ZodString>;
+    state: z.ZodOptional<z.ZodString>;
+    postalCode: z.ZodOptional<z.ZodString>;
+    countryCode: z.ZodString;
+    type: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const counterpartyDetailSchema: z.ZodObject<{
+    email: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+    phone: z.ZodOptional<z.ZodString>;
+    dateOfBirth: z.ZodOptional<z.ZodString>;
+    idNumber: z.ZodOptional<z.ZodString>;
+    idDocType: z.ZodOptional<z.ZodString>;
+    idType: z.ZodOptional<z.ZodString>;
+    idValue: z.ZodOptional<z.ZodString>;
+    address: z.ZodOptional<z.ZodObject<{
+        line1: z.ZodOptional<z.ZodString>;
+        line2: z.ZodOptional<z.ZodString>;
+        city: z.ZodOptional<z.ZodString>;
+        state: z.ZodOptional<z.ZodString>;
+        postalCode: z.ZodOptional<z.ZodString>;
+        countryCode: z.ZodString;
+        type: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type CounterpartyDetail$1 = z.infer<typeof counterpartyDetailSchema>;
+type Address = z.infer<typeof addressSchema>;
+
+declare const achTransferSchema: z.ZodObject<{
+    basicInfo: z.ZodObject<{
+        counterpartyName: z.ZodString;
+        shortName: z.ZodString;
+        type: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    bankDetails: z.ZodObject<{
+        gatewayRoutingNumber: z.ZodString;
+        rdfiNumberQualifier: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+type ACHTransfer = z.infer<typeof achTransferSchema>;
+
+declare const intermediaryFISchema: z.ZodObject<{
+    accountNumber: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    idType: z.ZodOptional<z.ZodString>;
+    idNumber: z.ZodOptional<z.ZodString>;
+    address: z.ZodOptional<z.ZodObject<{
+        line1: z.ZodOptional<z.ZodString>;
+        line2: z.ZodOptional<z.ZodString>;
+        city: z.ZodOptional<z.ZodString>;
+        state: z.ZodOptional<z.ZodString>;
+        postalCode: z.ZodOptional<z.ZodString>;
+        countryCode: z.ZodString;
+        type: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type IntermediaryFI$1 = z.infer<typeof intermediaryFISchema>;
+
+interface CounterpartyDetailViewProps {
+    counterpartyName: string;
+    counterpartyType: string;
+    currentStatus: string;
+    isEditingProfile: boolean;
+    counterpartyProfileData: CounterpartyDetail$1;
+    achPaymentMethod?: PaymentMethodCardProps | null;
+    wirePaymentMethod?: PaymentMethodCardProps | null;
+    onStatusChange: (newStatus: string) => void;
+    onToggleProfileEdit: () => void;
+    onProfileDataChange: (data: CounterpartyDetail$1) => void;
+    onAddACH: () => void;
+    onDeleteACH: () => void;
+    onAddWire: () => void;
+    onDeleteWire: () => void;
+    onEntityClick?: (entityType: string, entityId: string) => void;
+    onNavigateToTransactions?: () => void;
+    latestOFAC?: OFACCheck;
+    onNavigateToOFAC?: (ofacCheckId?: string) => void;
+}
+declare const CounterpartyDetailView: ({ counterpartyName, counterpartyType, currentStatus, isEditingProfile, counterpartyProfileData, achPaymentMethod, wirePaymentMethod, onStatusChange, onToggleProfileEdit, onProfileDataChange, onAddACH, onDeleteACH, onAddWire, onDeleteWire, onEntityClick, onNavigateToTransactions, latestOFAC, onNavigateToOFAC, }: CounterpartyDetailViewProps) => react_jsx_runtime.JSX.Element;
+
+interface CreateCounterpartyViewProps {
+    counterpartyData: any;
+    onBasicInfoChange: (data: any) => void;
+    onCancel: () => void;
+    onSubmit: () => void;
+    achPaymentMethod: PaymentMethodCardProps | null;
+    wirePaymentMethod: PaymentMethodCardProps | null;
+    hasWire: boolean;
+    onAddACH: () => void;
+    onDeleteACH: () => void;
+    onAddWire: () => void;
+    onDeleteWire: () => void;
+    validationErrors?: Record<string, boolean>;
+    onCountryCodeChange?: (value: string) => void;
+}
+declare const CreateCounterpartyView: ({ counterpartyData, onBasicInfoChange, onCancel, onSubmit, achPaymentMethod, wirePaymentMethod, hasWire, onAddACH, onDeleteACH, onAddWire, onDeleteWire, validationErrors, onCountryCodeChange, }: CreateCounterpartyViewProps) => react_jsx_runtime.JSX.Element;
+
+interface BusinessAccount {
+    id: string;
+    name: string;
+    number: string;
+    type: "checking" | "savings" | "zero-balance" | "funding";
+    status: "active" | "inactive";
+    settledBalance: number;
+    pendingCredits: number;
+    pendingDebits: number;
+    fundsOnHold: number;
+    accountBalance: number;
+    availableBalance: number;
+    currency: string;
+    institution: string;
+    routingNumber: string;
+    country: string;
+    customerName: string;
+    customerId: string;
+    customerType: "business" | "individual";
+    created: string;
+    modified: string;
+}
+
+interface AccountFormValues {
+    accountName: string;
+    canAcceptSweep: "Yes" | "No";
+    fundingAccountNumber?: string;
+    sweepAccountNumber?: string;
+}
+interface SelectOption$3 {
+    value: string;
+    label: string;
+}
+interface AccountDetailViewProps {
+    account: BusinessAccount;
+    currentStatus: string;
+    onStatusChange: (status: string) => void;
+    statusOptions: SelectOption$3[];
+    canAcceptSweepOptions: SelectOption$3[];
+    form: UseFormReturn<AccountFormValues> & {
+        isEditing: boolean;
+        handleToggleEdit: () => void;
+        handleSave: () => void;
+        handleCancel: () => void;
+    };
+    onNavigateCustomer: () => void;
+    onNavigateCounterparty: () => void;
+    onNavigateLimits: () => void;
+    onNavigateTransactions: () => void;
+    onNavigateProduct?: () => void;
+    hideTransactionAction?: boolean;
+    isLoading?: boolean;
+    error?: string | null;
+    onRetry?: () => void;
+    onNavigateFees?: () => void;
+    onCreateTransaction?: () => void;
+    onCreateCounterparty?: () => void;
+    onCreateLimit?: () => void;
+}
+declare const AccountDetailView: ({ account, currentStatus, onStatusChange, statusOptions, canAcceptSweepOptions, form, onNavigateCustomer, onNavigateCounterparty, onNavigateLimits, onNavigateTransactions, onNavigateProduct, hideTransactionAction, isLoading, error, onRetry, onNavigateFees, onCreateTransaction, onCreateCounterparty, onCreateLimit, }: AccountDetailViewProps) => react_jsx_runtime.JSX.Element;
+
+interface AccountFilters {
+    accountNumber: string;
+}
+
+interface AccountsViewProps {
+    table: React.ReactNode;
+    filters: AccountFilters;
+    onFilterChange: (field: keyof AccountFilters, value: string) => void;
+    onResetFilters: () => void;
+    onApplyFilters: () => void;
+    isLoading?: boolean;
+    error?: string | null;
+    onRetry?: () => void;
+    isEmpty?: boolean;
+    hasActiveFilters?: boolean;
+    hideBalanceColumns?: boolean;
+}
+declare const AccountsView: ({ table, filters, onFilterChange, onResetFilters, onApplyFilters, isLoading, error, onRetry, isEmpty, hasActiveFilters, hideBalanceColumns }: AccountsViewProps) => react_jsx_runtime.JSX.Element;
+
+interface IndividualsFilters {
+    individualId: string;
+    name: string;
+    productName: string;
+    status: string;
+    createdDateStart?: Date;
+    createdDateEnd?: Date;
+}
+
+interface IndividualsViewProps {
+    title?: string;
+    filters: IndividualsFilters;
+    statusOptions: {
+        value: string;
+        label: string;
+    }[];
+    onFilterChange: (field: keyof IndividualsFilters, value: string | Date | undefined) => void;
+    onResetFilters: () => void;
+    onApplyFilters: () => void;
+    onCreateIndividual: () => void;
+    table: React.ReactNode;
+}
+declare const IndividualsView: ({ title, filters, statusOptions, onFilterChange, onResetFilters, onApplyFilters, onCreateIndividual, table, }: IndividualsViewProps) => react_jsx_runtime.JSX.Element;
+
+declare const individualProfileEditSchema: z.ZodObject<{
+    firstName: z.ZodOptional<z.ZodString>;
+    lastName: z.ZodOptional<z.ZodString>;
+    dateOfBirth: z.ZodOptional<z.ZodString>;
+    idType: z.ZodOptional<z.ZodString>;
+    idNumber: z.ZodOptional<z.ZodString>;
+    ssn: z.ZodOptional<z.ZodString>;
+    email: z.ZodOptional<z.ZodString>;
+    mobilePhone: z.ZodOptional<z.ZodString>;
+    streetAddress: z.ZodOptional<z.ZodString>;
+    apartment: z.ZodOptional<z.ZodString>;
+    city: z.ZodOptional<z.ZodString>;
+    state: z.ZodOptional<z.ZodString>;
+    postalCode: z.ZodOptional<z.ZodString>;
+    country: z.ZodOptional<z.ZodString>;
+    externalId: z.ZodOptional<z.ZodCoercedString<unknown>>;
+    productId: z.ZodOptional<z.ZodCoercedString<unknown>>;
+}, z.core.$strip>;
+type IndividualProfileEdit = z.infer<typeof individualProfileEditSchema>;
+
+declare const externalAccountSchema: z.ZodObject<{
+    routingNumber: z.ZodOptional<z.ZodString>;
+    accountNumber: z.ZodOptional<z.ZodString>;
+    bankName: z.ZodOptional<z.ZodString>;
+    bankAccountType: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ExternalAccountFormData = z.infer<typeof externalAccountSchema>;
+
+interface SelectOption$2 {
+    value: string;
+    label: string;
+}
+interface IndividualDetailViewProps {
+    individual: {
+        id: string;
+        firstName: string;
+        lastName: string;
+        cipStatus: any;
+        subType?: "UBO" | "Customer";
+    };
+    profile: IndividualProfileEdit;
+    onProfileSave?: (data: IndividualProfileEdit) => Promise<void> | void;
+    status: string;
+    statusOptions: SelectOption$2[];
+    onStatusChange: (newStatus: string) => void;
+    latestOFAC?: OFACCheck;
+    onNavigateToOFAC?: (ofacCheckId?: string) => void;
+    onNavigateToAccounts: () => void;
+    onNavigateToCounterparty: () => void;
+    onCreateCounterparty: () => void;
+    onNavigateToTransactions: () => void;
+    showTimeline?: boolean;
+    profileIsEditing: boolean;
+    onToggleProfileEdit: () => void;
+    onProductIdClick?: (productId: string) => void;
+    externalAccounts: Array<{
+        id: string;
+        routingNumber: string;
+        accountNumber: string;
+        bankName: string;
+        bankAccountType: string;
+    }>;
+    onAddExternalAccount: (data: ExternalAccountFormData) => Promise<void | boolean> | void | boolean;
+    onDeleteExternalAccount: (accountId: string) => Promise<void | boolean> | void | boolean;
+    documents: BusinessDocument[];
+    onDocumentUpload: (file: File, metadata: {
+        name: string;
+        description: string;
+        type: string;
+    }) => Promise<void>;
+    onDocumentDelete?: (documentId: string) => Promise<void | boolean> | void | boolean;
+    renderDocumentViewer?: (document: BusinessDocument) => React.ReactNode;
+}
+declare const IndividualDetailView: ({ individual, profile, onProfileSave, status, statusOptions, onStatusChange, latestOFAC, onNavigateToOFAC, onNavigateToAccounts, onNavigateToCounterparty, onCreateCounterparty, onNavigateToTransactions, showTimeline, profileIsEditing, onToggleProfileEdit, onProductIdClick, externalAccounts, onAddExternalAccount, onDeleteExternalAccount, documents, onDocumentUpload, onDocumentDelete, renderDocumentViewer, }: IndividualDetailViewProps) => react_jsx_runtime.JSX.Element;
+
+type CreateIndividualViewForm = {
+    handleSubmit: (onValid: any) => (e?: any) => void;
+    handleSave: (data?: any) => Promise<void> | void;
+    isFormValid: boolean;
+    isLoading: boolean;
+};
+interface CreateIndividualViewProps {
+    form: CreateIndividualViewForm;
+    onCancel: () => void;
+    onSubmit: () => void;
+}
+declare const CreateIndividualView: ({ form, onCancel, onSubmit }: CreateIndividualViewProps) => react_jsx_runtime.JSX.Element;
+
+interface ACHBankCardProps {
+    data?: Partial<ACHTransfer>;
+    onDataChange?: (data: ACHTransfer) => void;
+    isEditing?: boolean;
+    onToggleEdit?: () => void;
+    className?: string;
+    hideActions?: boolean;
+}
+declare const ACHBankCard: ({ data, onDataChange, isEditing, onToggleEdit, className, hideActions }: ACHBankCardProps) => react_jsx_runtime.JSX.Element;
+
+interface ACHBasicInfoCardProps {
+    data?: Partial<ACHTransfer>;
+    onDataChange?: (data: ACHTransfer) => void;
+    isEditing?: boolean;
+    onToggleEdit?: () => void;
+    className?: string;
+    hideActions?: boolean;
+}
+declare const ACHBasicInfoCard: ({ data, onDataChange, isEditing, onToggleEdit, className, hideActions }: ACHBasicInfoCardProps) => react_jsx_runtime.JSX.Element;
+
+interface ACHTransferSectionProps {
+    isEditing?: boolean;
+    onToggleEdit?: () => void;
+    className?: string;
+    hideActions?: boolean;
+}
+declare const ACHTransferSection: ({ isEditing, onToggleEdit, className, hideActions }: ACHTransferSectionProps) => react_jsx_runtime.JSX.Element;
+
+declare const inputVariants: (props?: {
+    variant?: "default" | "success" | "disabled" | "error" | "readonly";
+    size?: "default" | "sm" | "lg";
+} & class_variance_authority_dist_types.ClassProp) => string;
+interface InputProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, 'size'>, VariantProps<typeof inputVariants> {
+    label?: string;
+    hint?: string;
+    error?: string;
+    success?: string;
+    isLoading?: boolean;
+}
+declare const EnhancedInput: React$1.ForwardRefExoticComponent<InputProps & React$1.RefAttributes<HTMLInputElement>>;
+
+interface AddressFormProps {
+    title: string;
+    description: string;
+    fieldPrefix?: string;
+    showAddressType?: boolean;
+    addressTypeOptions?: Array<{
+        value: string;
+        label: string;
+    }>;
+    fieldOverrides?: {
+        state?: Partial<React.ComponentProps<typeof EnhancedInput>>;
+        city?: Partial<React.ComponentProps<typeof EnhancedInput>>;
+        streetAddress?: Partial<React.ComponentProps<typeof EnhancedInput>>;
+        postalCode?: Partial<React.ComponentProps<typeof EnhancedInput>>;
+        apartment?: Partial<React.ComponentProps<typeof EnhancedInput>>;
+    };
+    showApartment?: boolean;
+    countryCode?: string;
+    onCountryCodeChange?: (value: string) => void;
+    countryCodeError?: boolean;
+}
+declare const AddressForm: ({ title, description, fieldPrefix, showAddressType, addressTypeOptions, fieldOverrides, showApartment, countryCode, onCountryCodeChange, countryCodeError, }: AddressFormProps) => react_jsx_runtime.JSX.Element;
+
+interface BankAddressCardProps {
+    data?: Partial<Address>;
+    onDataChange?: (data: Address) => void;
+    isEditing?: boolean;
+    onToggleEdit?: () => void;
+    className?: string;
+    hideActions?: boolean;
+}
+declare const BankAddressCard: ({ data, onDataChange, isEditing, onToggleEdit, className, hideActions }: BankAddressCardProps) => react_jsx_runtime.JSX.Element;
+
+interface BankingDetailsCardProps {
+    isEditing?: boolean;
+    onToggleEdit?: () => void;
+    className?: string;
+}
+declare const BankingDetailsCard: ({ isEditing, onToggleEdit, className }: BankingDetailsCardProps) => react_jsx_runtime.JSX.Element;
+
+interface BasicInfoCardProps {
+    isEditing?: boolean;
+    onToggleEdit?: () => void;
+    className?: string;
+    hideActions?: boolean;
+}
+declare const BasicInfoCard: ({ isEditing, onToggleEdit, className, hideActions }: BasicInfoCardProps) => react_jsx_runtime.JSX.Element;
+
+interface BasicInfoSectionProps {
+    isEditing?: boolean;
+    onToggleEdit?: () => void;
+    className?: string;
+    hideActions?: boolean;
+}
+declare const BasicInfoSection: ({ isEditing, onToggleEdit, className, hideActions }: BasicInfoSectionProps) => react_jsx_runtime.JSX.Element;
+
+declare const BeneficiaryAddress: () => react_jsx_runtime.JSX.Element;
+
+interface BeneficiaryCardProps {
+    isEditing?: boolean;
+    onToggleEdit?: () => void;
+    className?: string;
+    hideActions?: boolean;
+}
+declare const BeneficiaryCard: ({ isEditing, onToggleEdit, className, hideActions }: BeneficiaryCardProps) => react_jsx_runtime.JSX.Element;
+
+declare const BeneficiaryDomesticWire: () => react_jsx_runtime.JSX.Element;
+
+interface SelectOption$1 {
+    value: string;
+    label: string;
+}
+interface BusinessProfileCardProps {
+    data?: Partial<BusinessProfile>;
+    businessId?: string;
+    identityVerification?: IdentityVerification;
+    onDataChange?: (data: BusinessProfile) => void;
+    isEditing?: boolean;
+    onToggleEdit?: () => void;
+    className?: string;
+    hideActions?: boolean;
+    onProductIdClick?: (productId: number) => void;
+    onRevealIdNumber?: () => Promise<string>;
+    isIdNumberRevealed?: boolean;
+    onToggleIdNumberVisibility?: () => void;
+    isLoadingIdNumber?: boolean;
+    revealedIdNumber?: string | null;
+    businessEntityTypeOptions?: SelectOption$1[];
+}
+declare const BusinessProfileCard: ({ data, businessId, identityVerification, onDataChange, isEditing, onToggleEdit, className, hideActions, onProductIdClick, onRevealIdNumber, isIdNumberRevealed, onToggleIdNumberVisibility, isLoadingIdNumber, revealedIdNumber, businessEntityTypeOptions }: BusinessProfileCardProps) => react_jsx_runtime.JSX.Element;
+
+interface BusinessStatusCardProps {
+    isEditing?: boolean;
+    onToggleEdit?: () => void;
+    className?: string;
+}
+declare const BusinessStatusCard: ({ isEditing, onToggleEdit, className }: BusinessStatusCardProps) => react_jsx_runtime.JSX.Element;
+
+interface ContactInfoCardProps {
+    isEditing?: boolean;
+    onToggleEdit?: () => void;
+    className?: string;
+}
+declare const ContactInfoCard: ({ isEditing, onToggleEdit, className }: ContactInfoCardProps) => react_jsx_runtime.JSX.Element;
+
+interface CounterpartyBasicInfoProps {
+    value?: any;
+    onDataChange?: (data: any) => void;
+    validationErrors?: Record<string, boolean>;
+}
+declare const CounterpartyBasicInfo: ({ value, onDataChange, validationErrors }: CounterpartyBasicInfoProps) => react_jsx_runtime.JSX.Element;
+
+interface CounterpartyProfileCardProps {
+    data?: Partial<CounterpartyDetail$1>;
+    onDataChange?: (data: CounterpartyDetail$1) => void;
+    isEditing?: boolean;
+    onToggleEdit?: () => void;
+    hideActions?: boolean;
+    className?: string;
+    onEntityClick?: (entityType: string, entityId: string) => void;
+}
+declare const CounterpartyProfileCard: ({ data, onDataChange, isEditing, onToggleEdit, hideActions, className, onEntityClick }: CounterpartyProfileCardProps) => react_jsx_runtime.JSX.Element;
+
+interface CounterpartyRecordsCardProps {
+    isEditing?: boolean;
+    hideActions?: boolean;
+    className?: string;
+}
+declare const CounterpartyRecordsCard: ({ isEditing, hideActions, className }: CounterpartyRecordsCardProps) => react_jsx_runtime.JSX.Element;
+
+interface IntermediaryCardProps {
+    data?: Partial<IntermediaryFI$1>;
+    onDataChange?: (data: IntermediaryFI$1) => void;
+    isEditing?: boolean;
+    onToggleEdit?: () => void;
+    className?: string;
+    hideActions?: boolean;
+}
+declare const IntermediaryCard: ({ data, onDataChange, isEditing, onToggleEdit, className, hideActions }: IntermediaryCardProps) => react_jsx_runtime.JSX.Element;
+
+declare const IntermediaryFI: () => react_jsx_runtime.JSX.Element;
+
+declare const IntermediaryFIAddress: () => react_jsx_runtime.JSX.Element;
+
+interface OriginatorCardProps {
+    isEditing?: boolean;
+    onToggleEdit?: () => void;
+    className?: string;
+    hideActions?: boolean;
+}
+declare const OriginatorCard: ({ isEditing, onToggleEdit, className, hideActions }: OriginatorCardProps) => react_jsx_runtime.JSX.Element;
+
+declare const OriginatorFI: () => react_jsx_runtime.JSX.Element;
+
+declare const OriginatorFIAddress: () => react_jsx_runtime.JSX.Element;
+
+interface PaymentInformationSectionProps {
+    achEnabled?: boolean;
+    wireEnabled?: boolean;
+    onACHToggle?: (enabled: boolean) => void;
+    onWireToggle?: (enabled: boolean) => void;
+}
+declare const PaymentInformationSection: ({ achEnabled: achEnabledProp, wireEnabled: wireEnabledProp, onACHToggle, onWireToggle, }: PaymentInformationSectionProps) => react_jsx_runtime.JSX.Element;
+
+declare const receiverSchema: z.ZodObject<{
+    routingNumber: z.ZodString;
+    bankShortName: z.ZodString;
+}, z.core.$strip>;
+type ReceiverInfo = z.infer<typeof receiverSchema>;
+interface ReceiverCardProps {
+    data?: Partial<ReceiverInfo>;
+    onDataChange?: (data: ReceiverInfo) => void;
+    isEditing?: boolean;
+    onToggleEdit?: () => void;
+    className?: string;
+    hideActions?: boolean;
+}
+declare const ReceiverCard: ({ data, onDataChange, isEditing, onToggleEdit, className, hideActions }: ReceiverCardProps) => react_jsx_runtime.JSX.Element;
+
+interface WireTransferSectionProps {
+    isEditing?: boolean;
+    onToggleEdit?: () => void;
+    className?: string;
+    hideActions?: boolean;
+}
+declare const WireTransferSection: ({ isEditing, onToggleEdit, className, hideActions }: WireTransferSectionProps) => react_jsx_runtime.JSX.Element;
+
+interface BreadcrumbItem {
+    label: string;
+    href?: string;
+    icon?: React$1.ReactNode;
+}
+interface BreadcrumbProps {
+    items: BreadcrumbItem[];
+    showHome?: boolean;
+    separator?: React$1.ReactNode;
+    className?: string;
+}
+declare const Breadcrumb: React$1.ForwardRefExoticComponent<BreadcrumbProps & React$1.RefAttributes<HTMLElement>>;
+
+interface PageAction$1 {
+    label: string;
+    onClick: () => void;
+    variant?: "default" | "outline" | "secondary";
+    icon?: React$1.ReactNode;
+}
+interface ListPageProps {
+    title: string;
+    description?: string;
+    breadcrumbs?: BreadcrumbItem[];
+    actions?: PageAction$1[];
+    children: React$1.ReactNode;
+    maxWidth?: "sm" | "md" | "lg" | "xl" | "full";
+    loading?: boolean;
+    emptyState?: React$1.ReactNode;
+    className?: string;
+}
+declare const ListPage: React$1.ForwardRefExoticComponent<ListPageProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface StatementHeader {
+    account?: string;
+    productId?: string;
+    programId?: string;
+    startDate?: string;
+    endDate?: string;
+    startingBalance?: string;
+    endingBalance?: string;
+}
+interface StatementTransaction {
+    transactionType: string;
+    direction: "CREDIT" | "DEBIT";
+    amount: number;
+    count: number;
+}
+
+interface StatementViewProps {
+    statementType: string;
+    selectedProgram: string;
+    selectedProduct: string;
+    accountNumber: string;
+    startDate: Date | undefined;
+    endDate: Date | undefined;
+    statementGenerated: boolean;
+    programs: Array<{
+        value: string;
+        label: string;
+    }>;
+    products: Array<{
+        value: string;
+        label: string;
+    }>;
+    statementHeader: StatementHeader | null;
+    statementTransactions: StatementTransaction[];
+    programsLoading: boolean;
+    productsLoading: boolean;
+    programsError: string | null;
+    productsError: string | null;
+    onStatementTypeChange: (value: string) => void;
+    onProgramChange: (value: string) => void;
+    onProductChange: (value: string) => void;
+    onAccountNumberChange: (value: string) => void;
+    onStartDateChange: (date: Date | undefined) => void;
+    onEndDateChange: (date: Date | undefined) => void;
+    onGenerateStatement: () => void;
+    onEdit: () => void;
+    onDownloadCSV: () => void;
+    onPrintPDF: () => void;
+    onRetryFetch: () => void;
+    shouldShowRetry: boolean;
+    isGenerateDisabled: boolean;
+    isLoading: boolean;
+}
+declare const StatementView: ({ statementType, selectedProgram, selectedProduct, accountNumber, startDate, endDate, statementGenerated, programs, products, statementHeader, statementTransactions, programsLoading, productsLoading, programsError, productsError, onStatementTypeChange, onProgramChange, onProductChange, onAccountNumberChange, onStartDateChange, onEndDateChange, onGenerateStatement, onEdit, onDownloadCSV, onPrintPDF, onRetryFetch, shouldShowRetry, isGenerateDisabled, isLoading }: StatementViewProps) => react_jsx_runtime.JSX.Element;
+
+interface ACHDetails {
+    originatorName: string;
+    originatorRtn: string;
+    originatorId: string;
+    receiverName: string;
+    receiverRtn: string;
+    receiverAccount: string;
+    secCode: string;
+    accountType?: string;
+    effectiveDate?: string;
+    service?: string;
+    traceNumber: string;
+    correctedData?: string;
+    returnCode?: string;
+    changeCode?: string;
+    returnReason?: string;
+    changeReason?: string;
+    returnedAt?: string;
+    nocAt?: string;
+    addenda?: string;
+    iatAddenda?: any;
+    raw?: any;
+}
+interface ACHDetailsSectionProps {
+    data: ACHDetails;
+}
+declare const ACHDetailsSection: ({ data }: ACHDetailsSectionProps) => react_jsx_runtime.JSX.Element;
+
+interface WireDetails {
+    type: "DOMESTIC" | "INTERNATIONAL";
+    imad?: string;
+    omad?: string;
+    originatorName: string;
+    originatorAccountNumber: string;
+    originatorFIName: string;
+    originatorFIId: string;
+    beneficiaryName: string;
+    beneficiaryAccountNumber: string;
+    beneficiaryFIName: string;
+    beneficiaryFIId: string;
+    returnCode?: string;
+    returnReason?: string;
+    originatorToBeneficiaryInfo?: string;
+    raw?: any;
+}
+interface WireDetailsSectionProps {
+    data: WireDetails;
+    onIMADChange?: (newImad: string) => void;
+}
+declare const WireDetailsSection: ({ data, onIMADChange }: WireDetailsSectionProps) => react_jsx_runtime.JSX.Element;
+
+interface AccountData {
+    accountNumber: string;
+    accountName: string;
+    accountType: string;
+    balance: string;
+    customerName: string;
+    customerId: string;
+    customerType: string;
+}
+interface CounterpartyData {
+    counterpartyName: string;
+    counterpartyId: string;
+    counterpartyType: string;
+    status: string;
+    taxId: string;
+    primaryContact: string;
+    contactEmail: string;
+    contactPhone: string;
+    address: string;
+    paymentInstrumentType: string;
+}
+interface CounterpartySearchResult {
+    id: string;
+    name: string;
+    type: string;
+    paymentInstrumentType: string;
+}
+interface NewTransactionFormValues {
+    transactionType: string;
+    accountNumber: string;
+    counterpartyName?: string;
+    amount: string;
+    description: string;
+    certifyInformation: boolean;
+    adjustmentDirection?: string;
+    adjustmentType?: string;
+    receiverAccountNumber?: string;
+}
+interface TransactionTypeOption {
+    value: string;
+    label: string;
+    icon: React__default.ComponentType<{
+        className?: string;
+    }>;
+    disabled?: boolean;
+}
+declare const ADJUSTMENT_DIRECTION_OPTIONS: {
+    value: string;
+    label: string;
+}[];
+interface AdjustmentTypeOption {
+    value: string;
+    label: string;
+}
+interface NewTransactionViewProps {
+    form: UseFormReturn<NewTransactionFormValues>;
+    accountLookedUp: boolean;
+    accountData: AccountData | null;
+    counterpartyLookedUp: boolean;
+    counterpartyData: CounterpartyData | null;
+    confirmationOpen: boolean;
+    submissionStatus: "success" | "error" | null;
+    errorMessage: string;
+    transactionId: string;
+    isAccountLoading: boolean;
+    isCounterpartyLoading: boolean;
+    isSubmitting: boolean;
+    counterpartySearchResults: CounterpartySearchResult[];
+    isCounterpartySearching: boolean;
+    showCounterpartyDropdown: boolean;
+    onAccountLookup: () => void;
+    onEditAccount: () => void;
+    onEditCounterparty: () => void;
+    onTransactionTypeChange: (type: string) => void;
+    onSubmit: () => void;
+    onConfirmationClose: () => void;
+    onConfirmationOpenChange: (open: boolean) => void;
+    onNewTransaction: () => void;
+    onCounterpartySearchChange: (value: string) => void;
+    onCounterpartySelect: (result: CounterpartySearchResult) => void;
+    onCounterpartyDropdownClose: () => void;
+    counterpartyHasMore: boolean;
+    counterpartyTotalResults: number;
+    isLoadingMoreCounterparties: boolean;
+    onLoadMoreCounterparties: () => void;
+    receiverAccountLookedUp: boolean;
+    receiverAccountData: AccountData | null;
+    isReceiverAccountLoading: boolean;
+    onReceiverAccountLookup: () => void;
+    onEditReceiverAccount: () => void;
+    isReviewReady: boolean;
+    adjustmentTypeOptions: AdjustmentTypeOption[];
+    transactionTypeOptions: TransactionTypeOption[];
+    showSuccessInfoBox?: boolean;
+    successInfoMessage?: string;
+}
+declare const NewTransactionView: ({ form, accountLookedUp, accountData, counterpartyLookedUp, counterpartyData, confirmationOpen, submissionStatus, errorMessage, transactionId, isAccountLoading, isCounterpartyLoading, isSubmitting, counterpartySearchResults, isCounterpartySearching, showCounterpartyDropdown, onAccountLookup, onEditAccount, onEditCounterparty, onTransactionTypeChange, onSubmit, onConfirmationClose, onConfirmationOpenChange, onNewTransaction, onCounterpartySearchChange, onCounterpartySelect, onCounterpartyDropdownClose, counterpartyHasMore, counterpartyTotalResults, isLoadingMoreCounterparties, onLoadMoreCounterparties, receiverAccountLookedUp, receiverAccountData, isReceiverAccountLoading, onReceiverAccountLookup, onEditReceiverAccount, isReviewReady, adjustmentTypeOptions, transactionTypeOptions, showSuccessInfoBox, successInfoMessage, }: NewTransactionViewProps) => react_jsx_runtime.JSX.Element;
+
+interface TransactionHistoryFilters {
+    originalFileName?: string;
+    requesterIpAddress?: string;
+    requesterUsername?: string;
+    showAchNoc?: boolean;
+    excludeWire?: boolean;
+    excludeAch?: boolean;
+    wireFileHandle?: string;
+    direction?: string;
+    counterpartyId?: string;
+    customerId?: string;
+    settlementFileName?: string;
+    isInbound?: boolean;
+    accountNumber?: string;
+    processingStatus?: string[];
+    beginDate?: string;
+    endDate?: string;
+    postDateStart?: string;
+    postDateEnd?: string;
+    maxAmount?: string;
+    minAmount?: string;
+    productId?: string;
+    paymentId?: string;
+    transactionStatus?: string[];
+    transactionType?: string[];
+}
+type FilterValue$1 = string | string[] | boolean | undefined;
+interface SelectOption {
+    value: string;
+    label: string;
+}
+interface FilterOptions {
+    transactionTypes?: SelectOption[];
+    transactionStatuses?: SelectOption[];
+    processingStatuses?: SelectOption[];
+    directions?: SelectOption[];
+    products?: SelectOption[];
+}
+interface TransactionHistoryFiltersSheetProps {
+    filters: TransactionHistoryFilters;
+    filterOptions?: FilterOptions;
+    onFilterChange: (field: keyof TransactionHistoryFilters, value: FilterValue$1) => void;
+    onResetFilters: () => void;
+    onApplyFilters: () => void;
+}
+declare const TransactionHistoryFiltersSheet: ({ filters, filterOptions, onFilterChange, onResetFilters, onApplyFilters }: TransactionHistoryFiltersSheetProps) => react_jsx_runtime.JSX.Element;
+
+type FilterValue = string | string[] | boolean | undefined;
+interface TransactionHistoryViewProps {
+    table: React.ReactNode;
+    filters: TransactionHistoryFilters;
+    filterOptions?: FilterOptions;
+    onFilterChange: (field: keyof TransactionHistoryFilters, value: FilterValue) => void;
+    onResetFilters: () => void;
+    onApplyFilters: () => void;
+    isLoading?: boolean;
+    error?: string | null;
+    onRetry?: () => void;
+}
+declare const TransactionHistoryView: ({ table, filters, filterOptions, onFilterChange, onResetFilters, onApplyFilters, isLoading, error, onRetry }: TransactionHistoryViewProps) => react_jsx_runtime.JSX.Element;
+
+interface TransactionData {
+    id: string;
+    amount: number;
+    transactionType: string;
+    isInbound: boolean;
+    status: string;
+    processingStatus: string;
+    accountNumber: string;
+    customer: string;
+    description: string;
+    counterparty: string;
+    created: string;
+    ofacId?: string;
+    productId?: string;
+    achDetails?: any;
+    wireDetails?: any;
+    originalFilename?: string;
+    loadedFromFile?: string;
+    linkedPaymentId?: string;
+    pendingUntilDate?: string;
+    furtherCreditTo?: string;
+    balanceAvailableDate?: string;
+    requesterUsername?: string;
+    requesterIpAddress?: string;
+    settlementFilename?: string;
+    alerts?: string[];
+}
+interface TransactionDetailViewProps {
+    transaction?: TransactionData | null;
+    timelineEvents: TimelineEvent[];
+    isWireTransfer: boolean;
+    isACHTransfer: boolean;
+    showCancelButton: boolean;
+    showReturnButton: boolean;
+    onReturnClick: () => void;
+    onCancelClick: () => void;
+    onAccountClick: (accountNumber: string) => void;
+    onCustomerClick: (customer: string) => void;
+    onCounterpartyClick: (counterparty: string) => void;
+    onOFACClick: (ofacId: string) => void;
+    onProductClick: (productId: string) => void;
+    onAlertClick?: (alertId: string) => void;
+    onLinkedPaymentClick?: (paymentId: string) => void;
+    onIMADChange?: (newImad: string) => void;
+    isLoading?: boolean;
+    error?: string | null;
+    onRetry?: () => void;
+}
+declare const TransactionDetailView: ({ transaction, timelineEvents, isWireTransfer, isACHTransfer, showCancelButton, showReturnButton, onReturnClick, onCancelClick, onAccountClick, onCustomerClick, onCounterpartyClick, onOFACClick, onProductClick, onAlertClick, onLinkedPaymentClick, onIMADChange, isLoading, error, onRetry, }: TransactionDetailViewProps) => react_jsx_runtime.JSX.Element;
+
+declare const cancelTransactionSchema: z.ZodObject<{
+    reason: z.ZodString;
+}, z.core.$strip>;
+type CancelTransactionFormData = z.infer<typeof cancelTransactionSchema>;
+declare const returnTransactionSchema: z.ZodObject<{
+    reasonCode: z.ZodString;
+}, z.core.$strip>;
+type ReturnTransactionFormData = z.infer<typeof returnTransactionSchema>;
+interface ReturnReasonCode {
+    value: string;
+    label: string;
+}
+
+interface CancelTransactionDialogProps {
+    transactionId: string;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onCancel: (data: CancelTransactionFormData) => Promise<void>;
+}
+declare const CancelTransactionDialog: ({ transactionId, open, onOpenChange, onCancel, }: CancelTransactionDialogProps) => react_jsx_runtime.JSX.Element;
+
+interface ReturnTransactionDialogProps {
+    transactionId: string;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onReturn: (data: ReturnTransactionFormData) => Promise<void>;
+    reasonCodes: ReturnReasonCode[];
+}
+declare function ReturnTransactionDialog({ transactionId, open, onOpenChange, onReturn, reasonCodes, }: ReturnTransactionDialogProps): react_jsx_runtime.JSX.Element;
+
+interface AccountCardProps {
+    account: {
+        id: string;
+        name: string;
+        number: string;
+        type: "checking" | "savings" | "credit" | "investment";
+        status: "active" | "inactive" | "pending" | "suspended";
+        balance?: string;
+        currency?: string;
+        institution?: string;
+        routingNumber?: string;
+        country?: string;
+    };
+    showBalance?: boolean;
+    className?: string;
+}
+declare const AccountCard: React$1.ForwardRefExoticComponent<AccountCardProps & React$1.RefAttributes<HTMLDivElement>>;
+
+type AccountType = "checking" | "savings" | "zero-balance" | "funding";
+interface AccountTypeBadgeProps {
+    type: AccountType;
+    className?: string;
+}
+declare const AccountTypeBadge: ({ type, className }: AccountTypeBadgeProps) => react_jsx_runtime.JSX.Element;
+
+declare const badgeVariants: (props?: {
+    variant?: "default" | "secondary" | "destructive" | "outline" | "success" | "warning" | "blocked" | "inbound" | "outbound" | "business" | "individual" | "government" | "nonprofit" | "corporation" | "llc" | "partnership" | "sole_proprietorship" | "active" | "inactive" | "pending" | "suspended" | "cip-active" | "cip-inactive" | "cip-pending" | "cip-secondary" | "alert-ofac" | "alert-dual" | "alert-monitoring" | "alert-error" | "ofac_no_match" | "ofac_review" | "ofac_cleared" | "ofac_confirmed" | "ofac_blocked" | "checking" | "savings" | "zero-balance" | "funding";
+} & class_variance_authority_dist_types.ClassProp) => string;
+interface BadgeProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
+}
+declare function Badge({ className, variant, ...props }: BadgeProps): react_jsx_runtime.JSX.Element;
+
+interface BusinessTypeBadgeProps {
+    type: "corporation" | "llc" | "partnership" | "sole_proprietorship";
+    className?: string;
+}
+declare const BusinessTypeBadge: ({ type, className }: BusinessTypeBadgeProps) => react_jsx_runtime.JSX.Element;
+
+declare const buttonVariants: (props?: {
+    variant?: "default" | "ghost" | "link" | "secondary" | "destructive" | "outline";
+    size?: "default" | "sm" | "lg" | "icon";
+} & class_variance_authority_dist_types.ClassProp) => string;
+interface ButtonProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+}
+declare const Button: React$1.ForwardRefExoticComponent<ButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
+
+type CalendarProps = React$1.ComponentProps<typeof DayPicker>;
+declare function Calendar({ className, classNames, showOutsideDays, ...props }: CalendarProps): react_jsx_runtime.JSX.Element;
+declare namespace Calendar {
+    var displayName: string;
+}
+
+declare const cardVariants: (props?: {
+    variant?: "default" | "elevated" | "outlined" | "ghost" | "subtle";
+    size?: "sm" | "md" | "lg" | "none";
+    fullHeight?: boolean;
+    interactive?: boolean;
+} & class_variance_authority_dist_types.ClassProp) => string;
+interface CardProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof cardVariants> {
+}
+declare const Card: React$1.ForwardRefExoticComponent<CardProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const cardHeaderVariants: (props?: {
+    size?: "sm" | "md" | "lg";
+    align?: "start" | "center" | "end";
+    direction?: "row" | "column";
+} & class_variance_authority_dist_types.ClassProp) => string;
+interface CardHeaderProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof cardHeaderVariants> {
+}
+declare const CardHeader: React$1.ForwardRefExoticComponent<CardHeaderProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const cardTitleVariants: (props?: {
+    size?: "sm" | "md" | "lg";
+} & class_variance_authority_dist_types.ClassProp) => string;
+interface CardTitleProps extends React$1.HTMLAttributes<HTMLHeadingElement>, VariantProps<typeof cardTitleVariants> {
+}
+declare const CardTitle: React$1.ForwardRefExoticComponent<CardTitleProps & React$1.RefAttributes<HTMLParagraphElement>>;
+declare const CardDescription: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLParagraphElement> & React$1.RefAttributes<HTMLParagraphElement>>;
+declare const cardContentVariants: (props?: {
+    size?: "sm" | "md" | "lg";
+    fullHeight?: boolean;
+} & class_variance_authority_dist_types.ClassProp) => string;
+interface CardContentProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof cardContentVariants> {
+}
+declare const CardContent: React$1.ForwardRefExoticComponent<CardContentProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const cardFooterVariants: (props?: {
+    size?: "sm" | "md" | "lg";
+    justify?: "start" | "center" | "end" | "between";
+} & class_variance_authority_dist_types.ClassProp) => string;
+interface CardFooterProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof cardFooterVariants> {
+}
+declare const CardFooter: React$1.ForwardRefExoticComponent<CardFooterProps & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const Checkbox: React$1.ForwardRefExoticComponent<Omit<CheckboxPrimitive.CheckboxProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+
+interface ContainerProps {
+    children: React$1.ReactNode;
+    size?: "sm" | "md" | "lg" | "xl" | "full";
+    padding?: "none" | "sm" | "md" | "lg";
+    center?: boolean;
+    className?: string;
+}
+declare const Container: React$1.ForwardRefExoticComponent<ContainerProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface CounterpartyTypeBadgeProps {
+    type: "BUSINESS" | "INDIVIDUAL";
+    className?: string;
+}
+declare const CounterpartyTypeBadge: ({ type, className }: CounterpartyTypeBadgeProps) => react_jsx_runtime.JSX.Element;
+
+interface DataGridItem {
+    label?: string;
+    value: string;
+    layout?: "vertical" | "horizontal";
+}
+interface DataGridSection {
+    title?: string;
+    items: DataGridItem[];
+    className?: string;
+}
+interface DataGridProps {
+    data: DataGridItem[] | DataGridSection[];
+    columns?: 1 | 2 | 3 | 4;
+    gap?: "sm" | "md" | "lg";
+    className?: string;
+}
+declare const DataGrid: React$1.ForwardRefExoticComponent<DataGridProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface DataTableColumn<T = any> {
+    key: string;
+    title: string;
+    sortable?: boolean;
+    render?: (value: any, row: T) => React$1.ReactNode;
+    width?: string;
+    align?: "left" | "center" | "right";
+}
+interface DataTableProps<T = any> {
+    columns: DataTableColumn<T>[];
+    data: T[];
+    sortBy?: string;
+    sortDirection?: "asc" | "desc";
+    onSort?: (key: string) => void;
+    onRowClick?: (row: T) => void;
+    loading?: boolean;
+    emptyMessage?: string;
+    className?: string;
+    pagination?: {
+        currentPage: number;
+        pageSize: number;
+        totalItems: number;
+        onPageChange: (page: number) => void;
+    };
+}
+declare function DataTable<T extends Record<string, any>>({ columns, data, sortBy, sortDirection, onSort, onRowClick, loading, emptyMessage, className, pagination }: DataTableProps<T>): react_jsx_runtime.JSX.Element;
+
+interface DetailPageCard {
+    key: string;
+    component: (props: {
+        isEditing: boolean;
+        onToggleEdit: () => void;
+        className?: string;
+    }) => ReactNode;
+    expandOnEdit?: boolean;
+}
+interface DetailPageAction {
+    label: string;
+    variant?: "default" | "outline" | "destructive" | "secondary" | "ghost";
+    onClick?: () => void;
+    className?: string;
+}
+interface DetailPageLayoutProps {
+    title: string | ReactNode;
+    description?: string;
+    cards: DetailPageCard[];
+    actions?: DetailPageAction[];
+    initialEditingState?: Record<string, boolean>;
+    headerContent?: ReactNode;
+}
+declare const DetailPageLayout: ({ title, description, cards, actions, initialEditingState, headerContent }: DetailPageLayoutProps) => react_jsx_runtime.JSX.Element;
+
+declare const Dialog: React$1.FC<DialogPrimitive.DialogProps>;
+declare const DialogTrigger: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const DialogPortal: React$1.FC<DialogPrimitive.DialogPortalProps>;
+declare const DialogClose: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const DialogOverlay: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+interface DialogContentProps extends React$1.ComponentPropsWithoutRef<typeof DialogPrimitive.Content> {
+    hideCloseButton?: boolean;
+}
+declare const DialogContent: React$1.ForwardRefExoticComponent<DialogContentProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const DialogHeader: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const DialogFooter: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const DialogTitle: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;
+declare const DialogDescription: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>;
+
+declare const DropdownMenu: React$1.FC<DropdownMenuPrimitive.DropdownMenuProps>;
+declare const DropdownMenuTrigger: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenuContent: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuItem: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuLabel: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+interface FormCardProps extends Omit<CardProps, 'children'> {
+    title: string;
+    titleBadge?: React$1.ReactNode;
+    description?: string;
+    children: React$1.ReactNode;
+    headerActions?: React$1.ReactNode;
+}
+declare const FormCard: React$1.ForwardRefExoticComponent<FormCardProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface EditableFormCardProps extends Omit<FormCardProps, 'headerActions' | 'children'> {
+    title: string;
+    description?: string;
+    children?: React$1.ReactNode;
+    editContent: React$1.ReactNode;
+    viewContent: React$1.ReactNode;
+    isEditing?: boolean;
+    onToggleEdit?: () => void;
+    hideActions?: boolean;
+    onSave?: () => void | Promise<void>;
+    onCancel?: () => void;
+    className?: string;
+    isFormValid?: boolean;
+    isDirty?: boolean;
+    isSubmitting?: boolean;
+}
+declare const EditableFormCard: React$1.ForwardRefExoticComponent<EditableFormCardProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface EditableInfoFieldProps {
+    label: string;
+    value: string | null | undefined;
+    options: {
+        value: string;
+        label: string;
+    }[];
+    onChange: (value: string) => void;
+    placeholder?: string;
+    renderValue?: (value: string) => React.ReactNode;
+    className?: string;
+}
+declare const EditableInfoField: ({ label, value, options, onChange, placeholder, renderValue, className }: EditableInfoFieldProps) => react_jsx_runtime.JSX.Element;
+
+declare const selectVariants: (props?: {
+    variant?: "default" | "success" | "disabled" | "error";
+} & class_variance_authority_dist_types.ClassProp) => string;
+interface EnhancedSelectProps extends VariantProps<typeof selectVariants> {
+    label?: string;
+    hint?: string;
+    error?: string;
+    success?: string;
+    placeholder?: string;
+    options: {
+        value: string;
+        label: string;
+        disabled?: boolean;
+    }[];
+    value?: string;
+    onValueChange?: (value: string) => void;
+    disabled?: boolean;
+    className?: string;
+    required?: boolean;
+}
+declare const EnhancedSelect: React$1.ForwardRefExoticComponent<EnhancedSelectProps & React$1.RefAttributes<HTMLButtonElement>>;
+
+declare const textareaVariants: (props?: {
+    variant?: "default" | "success" | "disabled" | "error" | "readonly";
+} & class_variance_authority_dist_types.ClassProp) => string;
+interface TextareaProps extends React$1.TextareaHTMLAttributes<HTMLTextAreaElement>, VariantProps<typeof textareaVariants> {
+    label?: string;
+    hint?: string;
+    error?: string;
+    success?: string;
+}
+declare const EnhancedTextarea: React$1.ForwardRefExoticComponent<TextareaProps & React$1.RefAttributes<HTMLTextAreaElement>>;
+
+interface EntityAction {
+    label: string;
+    icon: React$1.ReactNode;
+    onClick: () => void;
+    variant?: "default" | "destructive";
+}
+interface EntityCardProps {
+    entity: {
+        id: string;
+        name: string;
+        type: string;
+        status: string;
+        description?: string;
+        metadata?: Record<string, any>;
+    };
+    actions?: EntityAction[];
+    showDefaultActions?: boolean;
+    onView?: (id: string) => void;
+    onEdit?: (id: string) => void;
+    onDelete?: (id: string) => void;
+    className?: string;
+    children?: React$1.ReactNode;
+}
+declare const EntityCard: React$1.ForwardRefExoticComponent<EntityCardProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface FormFieldProps {
+    label?: string;
+    description?: string;
+    error?: string;
+    required?: boolean;
+    children: React$1.ReactNode;
+    className?: string;
+    layout?: "vertical" | "horizontal";
+}
+declare const FormField: React$1.ForwardRefExoticComponent<FormFieldProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface FormInputProps<T extends FieldValues = FieldValues> extends Omit<InputProps, 'error' | 'name'> {
+    name: FieldPath<T>;
+}
+declare const FormInput: <T extends FieldValues = FieldValues>({ name, type, ...props }: FormInputProps<T>) => react_jsx_runtime.JSX.Element;
+
+interface FormProviderProps<T extends FieldValues> {
+    form: UseFormReturn<T>;
+    children: React$1.ReactNode;
+}
+declare const FormProvider: <T extends FieldValues>({ form, children }: FormProviderProps<T>) => react_jsx_runtime.JSX.Element;
+
+interface FormSectionProps {
+    title?: string;
+    description?: string;
+    children: React$1.ReactNode;
+    className?: string;
+    spacing?: "sm" | "md" | "lg";
+    layout?: "vertical" | "grid";
+    columns?: 1 | 2 | 3 | 4;
+}
+declare const FormSection: React$1.ForwardRefExoticComponent<FormSectionProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface FormSelectProps<T extends FieldValues = FieldValues> {
+    name: FieldPath<T>;
+    label?: string;
+    hint?: string;
+    placeholder?: string;
+    options: {
+        value: string;
+        label: string;
+        disabled?: boolean;
+    }[];
+    disabled?: boolean;
+    className?: string;
+    required?: boolean;
+}
+declare const FormSelect: <T extends FieldValues = FieldValues>({ name, ...props }: FormSelectProps<T>) => react_jsx_runtime.JSX.Element;
+
+interface InfoFieldProps {
+    label?: string;
+    value: string | React__default.ReactNode;
+    layout?: 'vertical' | 'horizontal' | 'compact';
+    className?: string;
+}
+
+declare const InfoField: ({ label, value, layout, className }: InfoFieldProps) => react_jsx_runtime.JSX.Element;
+
+interface JsonViewerProps {
+    data: any;
+    className?: string;
+    compact?: boolean;
+    maxHeight?: string;
+    expandFully?: boolean;
+    defaultExpandDepth?: number;
+}
+declare const JsonViewer: ({ data, className, compact, maxHeight, expandFully, defaultExpandDepth }: JsonViewerProps) => react_jsx_runtime.JSX.Element;
+
+declare const Label: React$1.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React$1.RefAttributes<HTMLLabelElement>, "ref"> & VariantProps<(props?: class_variance_authority_dist_types.ClassProp) => string> & React$1.RefAttributes<HTMLLabelElement>>;
+
+interface MetricCardProps {
+    title: string;
+    value: string | number;
+    description?: string;
+    trend?: {
+        value: number;
+        label: string;
+        direction: "up" | "down" | "neutral";
+    };
+    icon?: React$1.ReactNode;
+    variant?: "default" | "success" | "warning" | "destructive";
+    className?: string;
+}
+declare const MetricCard: React$1.ForwardRefExoticComponent<MetricCardProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface PageAction {
+    label: string;
+    variant?: "default" | "secondary" | "destructive" | "outline" | "ghost";
+    onClick: () => void;
+    icon?: React$1.ComponentType<{
+        className?: string;
+    }>;
+}
+interface PageCard {
+    component: React$1.ComponentType<any>;
+    key: string;
+    expandOnEdit?: boolean;
+    props?: Record<string, any>;
+}
+interface PageLayoutProps {
+    title: string | React$1.ReactNode;
+    description?: string;
+    children?: React$1.ReactNode;
+    actions?: PageAction[];
+    cards?: PageCard[];
+    mode?: "simple" | "detail" | "cards";
+    maxWidth?: "sm" | "md" | "lg" | "xl" | "2xl" | "full";
+    gridCols?: 1 | 2 | 3 | 4;
+    responsive?: boolean;
+    className?: string;
+    headerContent?: React$1.ReactNode;
+}
+declare const PageLayout: React$1.ForwardRefExoticComponent<PageLayoutProps & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const Popover: React$1.FC<PopoverPrimitive.PopoverProps>;
+declare const PopoverTrigger: React$1.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+interface PopoverContentProps extends React$1.ComponentPropsWithoutRef<typeof PopoverPrimitive.Content> {
+    container?: HTMLElement | null;
+}
+declare const PopoverContent: React$1.ForwardRefExoticComponent<PopoverContentProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface ResponsiveGridProps {
+    children: React$1.ReactNode;
+    type?: "cards" | "forms" | "data" | "custom";
+    gap?: "sm" | "md" | "lg" | "xl";
+    editMode?: boolean;
+    className?: string;
+}
+declare const ResponsiveGrid: React$1.ForwardRefExoticComponent<ResponsiveGridProps & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const ScrollArea: React$1.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const ScrollBar: React$1.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaScrollbarProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const Separator: React$1.ForwardRefExoticComponent<Omit<SeparatorPrimitive.SeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const Sheet: React$1.FC<DialogPrimitive.DialogProps>;
+declare const SheetTrigger: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const SheetClose: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const SheetPortal: React$1.FC<DialogPrimitive.DialogPortalProps>;
+declare const SheetOverlay: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const sheetVariants: (props?: {
+    side?: "left" | "right" | "top" | "bottom";
+} & class_variance_authority_dist_types.ClassProp) => string;
+interface SheetContentProps extends React$1.ComponentPropsWithoutRef<typeof DialogPrimitive.Content>, VariantProps<typeof sheetVariants> {
+}
+declare const SheetContent: React$1.ForwardRefExoticComponent<SheetContentProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const SheetHeader: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const SheetFooter: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const SheetTitle: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;
+declare const SheetDescription: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>;
+
+declare const TooltipProvider: React$1.FC<TooltipPrimitive.TooltipProviderProps>;
+declare const Tooltip: React$1.FC<TooltipPrimitive.TooltipProps>;
+declare const TooltipTrigger: React$1.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const TooltipContent: React$1.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+type SidebarContext = {
+    state: "expanded" | "collapsed";
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    openMobile: boolean;
+    setOpenMobile: (open: boolean) => void;
+    isMobile: boolean;
+    toggleSidebar: () => void;
+};
+declare const SidebarContext: React$1.Context<SidebarContext>;
+declare function useSidebar(): SidebarContext;
+declare const SidebarProvider: React$1.ForwardRefExoticComponent<Omit<React$1.ClassAttributes<HTMLDivElement> & React$1.HTMLAttributes<HTMLDivElement> & {
+    defaultOpen?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const Sidebar: React$1.ForwardRefExoticComponent<Omit<React$1.ClassAttributes<HTMLDivElement> & React$1.HTMLAttributes<HTMLDivElement> & {
+    side?: "left" | "right";
+    variant?: "sidebar" | "floating" | "inset";
+    collapsible?: "offcanvas" | "icon" | "none";
+}, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SidebarTrigger: React$1.ForwardRefExoticComponent<Omit<ButtonProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+declare const SidebarRail: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+declare const SidebarInset: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SidebarInput: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> & React$1.RefAttributes<HTMLInputElement>>;
+declare const SidebarHeader: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SidebarFooter: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SidebarSeparator: React$1.ForwardRefExoticComponent<Omit<Omit<SeparatorPrimitive.SeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SidebarContent: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SidebarGroup: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SidebarGroupLabel: React$1.ForwardRefExoticComponent<Omit<React$1.ClassAttributes<HTMLDivElement> & React$1.HTMLAttributes<HTMLDivElement> & {
+    asChild?: boolean;
+}, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SidebarGroupAction: React$1.ForwardRefExoticComponent<Omit<React$1.ClassAttributes<HTMLButtonElement> & React$1.ButtonHTMLAttributes<HTMLButtonElement> & {
+    asChild?: boolean;
+}, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+declare const SidebarGroupContent: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SidebarMenu: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React$1.RefAttributes<HTMLUListElement>>;
+declare const SidebarMenuItem: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React$1.RefAttributes<HTMLLIElement>>;
+declare const SidebarMenuButton: React$1.ForwardRefExoticComponent<Omit<React$1.ClassAttributes<HTMLButtonElement> & React$1.ButtonHTMLAttributes<HTMLButtonElement> & {
+    asChild?: boolean;
+    isActive?: boolean;
+    tooltip?: string | React$1.ComponentProps<typeof TooltipContent>;
+} & VariantProps<(props?: {
+    variant?: "default" | "outline";
+    size?: "default" | "sm" | "lg";
+} & class_variance_authority_dist_types.ClassProp) => string>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+declare const SidebarMenuAction: React$1.ForwardRefExoticComponent<Omit<React$1.ClassAttributes<HTMLButtonElement> & React$1.ButtonHTMLAttributes<HTMLButtonElement> & {
+    asChild?: boolean;
+    showOnHover?: boolean;
+}, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+declare const SidebarMenuBadge: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SidebarMenuSkeleton: React$1.ForwardRefExoticComponent<Omit<React$1.ClassAttributes<HTMLDivElement> & React$1.HTMLAttributes<HTMLDivElement> & {
+    showIcon?: boolean;
+}, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SidebarMenuSub: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React$1.RefAttributes<HTMLUListElement>>;
+declare const SidebarMenuSubItem: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React$1.RefAttributes<HTMLLIElement>>;
+declare const SidebarMenuSubButton: React$1.ForwardRefExoticComponent<Omit<React$1.ClassAttributes<HTMLAnchorElement> & React$1.AnchorHTMLAttributes<HTMLAnchorElement> & {
+    asChild?: boolean;
+    size?: "sm" | "md";
+    isActive?: boolean;
+}, "ref"> & React$1.RefAttributes<HTMLAnchorElement>>;
+
+type ToasterProps = React.ComponentProps<typeof Toaster$1>;
+declare const Toaster: ({ ...props }: ToasterProps) => react_jsx_runtime.JSX.Element;
+
+interface StackProps {
+    children: React$1.ReactNode;
+    direction?: "vertical" | "horizontal";
+    spacing?: "none" | "xs" | "sm" | "md" | "lg" | "xl";
+    align?: "start" | "center" | "end" | "stretch";
+    justify?: "start" | "center" | "end" | "between" | "around";
+    className?: string;
+}
+declare const Stack: React$1.ForwardRefExoticComponent<StackProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface StatusBadgeProps {
+    status: "ACTIVE" | "INACTIVE" | "PENDING" | "SUSPENDED" | "BLOCKED" | "PENDING_APPROVAL" | "POSTED" | "FAILED" | "CANCELLED" | "DELETED" | "NEEDS_OFAC" | "PENDING_UNBLOCK";
+    className?: string;
+    /** Shows a subtle chevron to indicate the status is a clickable dropdown/select. */
+    showDropdownIndicator?: boolean;
+    /** Shows only the icon without the label text. */
+    iconOnly?: boolean;
+}
+declare const StatusBadge: ({ status, className, showDropdownIndicator, iconOnly }: StatusBadgeProps) => react_jsx_runtime.JSX.Element;
+
+interface CIPStatusBadgeProps {
+    status: "NOT_START" | "PASS" | "FAIL" | "IN_REVIEW" | "verified" | "not_start" | "pending" | "rejected";
+    className?: string;
+}
+declare const CIPStatusBadge: ({ status, className }: CIPStatusBadgeProps) => react_jsx_runtime.JSX.Element;
+
+declare const Table: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableElement> & React$1.RefAttributes<HTMLTableElement>>;
+declare const TableHeader: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
+declare const TableBody: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
+declare const TableFooter: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
+declare const TableRow: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableRowElement> & React$1.RefAttributes<HTMLTableRowElement>>;
+declare const TableHead: React$1.ForwardRefExoticComponent<React$1.ThHTMLAttributes<HTMLTableCellElement> & React$1.RefAttributes<HTMLTableCellElement>>;
+declare const TableCell: React$1.ForwardRefExoticComponent<React$1.TdHTMLAttributes<HTMLTableCellElement> & React$1.RefAttributes<HTMLTableCellElement>>;
+declare const TableCaption: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableCaptionElement> & React$1.RefAttributes<HTMLTableCaptionElement>>;
+
+declare const Tabs: React$1.ForwardRefExoticComponent<TabsPrimitive.TabsProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const TabsList: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const TabsTrigger: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+declare const TabsContent: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const ToastProvider: React$1.FC<ToastPrimitives.ToastProviderProps>;
+declare const ToastViewport: React$1.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastViewportProps & React$1.RefAttributes<HTMLOListElement>, "ref"> & React$1.RefAttributes<HTMLOListElement>>;
+declare const Toast$1: React$1.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastProps & React$1.RefAttributes<HTMLLIElement>, "ref"> & VariantProps<(props?: {
+    variant?: "default" | "destructive";
+} & class_variance_authority_dist_types.ClassProp) => string> & React$1.RefAttributes<HTMLLIElement>>;
+declare const ToastAction: React$1.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastActionProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+declare const ToastClose: React$1.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastCloseProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+declare const ToastTitle: React$1.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastTitleProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const ToastDescription: React$1.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastDescriptionProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+type ToastProps = React$1.ComponentPropsWithoutRef<typeof Toast$1>;
+type ToastActionElement = React$1.ReactElement<typeof ToastAction>;
+
+interface TransactionTypeBadgeProps {
+    transactionType: string;
+    isInbound: boolean;
+    className?: string;
+}
+declare const TransactionTypeBadge: ({ transactionType, isInbound, className }: TransactionTypeBadgeProps) => react_jsx_runtime.JSX.Element;
+
+declare function DashboardDemo(): react_jsx_runtime.JSX.Element;
+
+declare function PatternLibrary(): react_jsx_runtime.JSX.Element;
+
+declare function UIKitShowcase(): react_jsx_runtime.JSX.Element;
+
+declare function useIsMobile(): boolean;
+
+type ToasterToast = ToastProps & {
+    id: string;
+    title?: React$1.ReactNode;
+    description?: React$1.ReactNode;
+    action?: ToastActionElement;
+};
+declare const actionTypes: {
+    readonly ADD_TOAST: "ADD_TOAST";
+    readonly UPDATE_TOAST: "UPDATE_TOAST";
+    readonly DISMISS_TOAST: "DISMISS_TOAST";
+    readonly REMOVE_TOAST: "REMOVE_TOAST";
+};
+type ActionType = typeof actionTypes;
+type Action = {
+    type: ActionType["ADD_TOAST"];
+    toast: ToasterToast;
+} | {
+    type: ActionType["UPDATE_TOAST"];
+    toast: Partial<ToasterToast>;
+} | {
+    type: ActionType["DISMISS_TOAST"];
+    toastId?: ToasterToast["id"];
+} | {
+    type: ActionType["REMOVE_TOAST"];
+    toastId?: ToasterToast["id"];
+};
+interface State {
+    toasts: ToasterToast[];
+}
+declare const reducer: (state: State, action: Action) => State;
+type Toast = Omit<ToasterToast, "id">;
+declare function toast({ ...props }: Toast): {
+    id: string;
+    dismiss: () => void;
+    update: (props: ToasterToast) => void;
+};
+declare function useToast(): {
+    toast: typeof toast;
+    dismiss: (toastId?: string) => void;
+    toasts: ToasterToast[];
+};
+
+interface UseAlertDetailReturn {
+    alert: Alert | undefined;
+    isLoading: boolean;
+    rfiStatus: string;
+    assignee: string;
+    handleRfiStatusChange: (status: string) => void;
+    handleAssigneeChange: (assignee: string) => void;
+    handleResolveAlert: (data: ResolveAlertFormData) => Promise<void>;
+}
+declare const useAlertDetail: (id: string | undefined) => UseAlertDetailReturn;
+
+interface UseEditStateProps {
+    initialEditing?: boolean;
+    onToggleEdit?: () => void;
+    onSave?: () => void | Promise<void>;
+    onCancel?: () => void;
+}
+declare const useEditState: ({ initialEditing, onToggleEdit, onSave, onCancel }: UseEditStateProps) => {
+    isEditing: boolean;
+    isLoading: boolean;
+    handleToggleEdit: () => void;
+    handleSave: () => Promise<void>;
+    handleCancel: () => void;
+};
+
+interface UseFormWithEditStateProps<T extends FieldValues> extends UseFormProps<T> {
+    schema?: z.ZodSchema<T>;
+    initialEditing?: boolean;
+    onToggleEdit?: () => void;
+    onSave?: (data: T) => void | Promise<void>;
+    onCancel?: () => void;
+}
+interface UseFormWithEditStateReturn<T extends FieldValues> extends UseFormReturn<T> {
+    isEditing: boolean;
+    isLoading: boolean;
+    handleToggleEdit: () => void;
+    handleSave: () => Promise<void>;
+    handleCancel: () => void;
+    isFormValid: boolean;
+    isDirty: boolean;
+    setFieldError: (field: Path<T>, error: string) => void;
+}
+declare const useFormWithEditState: <T extends FieldValues>({ schema, initialEditing, onToggleEdit, onSave, onCancel, ...formProps }: UseFormWithEditStateProps<T>) => UseFormWithEditStateReturn<T>;
+
+interface CounterpartyListItem {
+    id: string;
+    name: string;
+    type: "BUSINESS" | "INDIVIDUAL";
+    status: "ACTIVE" | "INACTIVE" | "PENDING" | "SUSPENDED";
+    productId?: string;
+    businessId?: string;
+    individualId?: string;
+    accountNumber?: string;
+    customerId?: string;
+    customerType?: "business" | "individual";
+    created: string;
+    modified: string;
+}
+
+interface CounterpartyWithEntity extends CounterpartyListItem {
+    associatedEntity: string;
+    entityType: "product" | "business" | "individual" | "account" | null;
+}
+declare const useCounterpartyEntity: (counterparties: CounterpartyListItem[]) => {
+    counterparties: CounterpartyWithEntity[];
+    loading: boolean;
+};
+
+declare const Accounts: () => react_jsx_runtime.JSX.Element;
+
+declare const AccountDetail: () => react_jsx_runtime.JSX.Element;
+
+declare const AlertDetail: () => react_jsx_runtime.JSX.Element;
+
+declare const Alerts: () => react_jsx_runtime.JSX.Element;
+
+declare const Businesses: () => react_jsx_runtime.JSX.Element;
+
+declare const BusinessDetail: () => react_jsx_runtime.JSX.Element;
+
+declare const CreateBusiness: () => react_jsx_runtime.JSX.Element;
+
+declare const Cases: () => react_jsx_runtime.JSX.Element;
+
+declare const Counterparties: () => react_jsx_runtime.JSX.Element;
+
+declare const CounterpartyDetail: () => react_jsx_runtime.JSX.Element;
+
+declare const CreateCounterparty: () => react_jsx_runtime.JSX.Element;
+
+declare const Dashboard: () => react_jsx_runtime.JSX.Element;
+
+declare const Individuals: () => react_jsx_runtime.JSX.Element;
+
+declare const IndividualDetail: () => react_jsx_runtime.JSX.Element;
+
+declare const CreateIndividual: () => react_jsx_runtime.JSX.Element;
+
+declare const NotFound: () => react_jsx_runtime.JSX.Element;
+
+declare function Statement(): react_jsx_runtime.JSX.Element;
+
+declare const TransactionHistory: () => react_jsx_runtime.JSX.Element;
+
+declare const newTransactionSchema: z.ZodObject<{
+    transactionType: z.ZodString;
+    accountNumber: z.ZodString;
+    counterpartyName: z.ZodOptional<z.ZodString>;
+    amount: z.ZodString;
+    description: z.ZodString;
+    certifyInformation: z.ZodBoolean;
+    adjustmentDirection: z.ZodOptional<z.ZodString>;
+    adjustmentType: z.ZodOptional<z.ZodString>;
+    receiverAccountNumber: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare function NewTransaction(): react_jsx_runtime.JSX.Element;
+
+declare const TransactionDetail: () => react_jsx_runtime.JSX.Element;
+
+declare function UIKit(): react_jsx_runtime.JSX.Element;
+
+declare function VelocityLimits(): react_jsx_runtime.JSX.Element;
+
+declare function CreateVelocityLimit(): react_jsx_runtime.JSX.Element;
+
+declare function VelocityLimitDetail(): react_jsx_runtime.JSX.Element;
+
+declare function ReconUpload(): react_jsx_runtime.JSX.Element;
+
+declare function ReconExceptions(): react_jsx_runtime.JSX.Element;
+
+declare const Fees: () => react_jsx_runtime.JSX.Element;
+
+/**
+ * Generates a CSV string from statement header and transaction data
+ */
+declare function generateStatementCSV(header: StatementHeader, transactions: StatementTransaction[]): string;
+/**
+ * Triggers a browser download for CSV content
+ */
+declare function downloadCSV(content: string, filename: string): void;
+
+export { ACHBankCard, ACHBasicInfoCard, ACHDetailsSection, ACHTransferSection, ADJUSTMENT_DIRECTION_OPTIONS, AccountCard, type AccountData, AccountDetail, AccountDetailView, type AccountFormValues, AccountTypeBadge, Accounts, AccountsView, AddressForm, type AdjustmentTypeOption, AlertDetail, AlertDetailRouter, type AlertDetailRouterProps, AlertDocuments, AlertHeaderControls, AlertNotes, AlertTimeline, Alerts, AppSidebar, Badge, type BadgeProps, BankAddressCard, BankingDetailsCard, BasicInfoCard, BasicInfoSection, BeneficiaryAddress, BeneficiaryCard, BeneficiaryDomesticWire, Breadcrumb, type BreadcrumbItem, BusinessDetail, BusinessDetailView, BusinessFiltersSheet, BusinessProfileCard, BusinessStatusCard, BusinessTypeBadge, Businesses, Button, type ButtonProps, CIPStatusBadge, Calendar, type CalendarProps, CancelTransactionDialog, Card, CardContent, type CardContentProps, CardDescription, CardFooter, type CardFooterProps, CardHeader, type CardHeaderProps, type CardProps, CardTitle, type CardTitleProps, Cases, Checkbox, ContactInfoCard, Container, ContextSection, Counterparties, CounterpartiesView, CounterpartyBasicInfo, type CounterpartyData, CounterpartyDetail, CounterpartyDetailView, CounterpartyProfileCard, CounterpartyRecordsCard, type CounterpartySearchResult, CounterpartyTypeBadge, type CounterpartyWithEntity, CreateBusiness, CreateBusinessView, CreateCounterparty, CreateCounterpartyView, CreateIndividual, CreateIndividualView, CreateVelocityLimit, Dashboard, DashboardDemo, DataGrid, type DataGridItem, type DataGridSection, DataTable, type DataTableColumn, type DataTableProps, DetailPageLayout, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuTrigger, EditableFormCard, EditableInfoField, EnhancedInput, EnhancedSelect, EnhancedTextarea, EntityCard, Fees, type FilterOptions, FormCard, type FormCardProps, FormField, FormInput, FormProvider, FormSection, FormSelect, IndividualDetail, IndividualDetailView, Individuals, IndividualsView, InfoField, type InputProps, IntermediaryCard, IntermediaryFI, IntermediaryFIAddress, JsonViewer, Label, ListPage, MainLayout, MetricCard, NewTransaction, type NewTransactionFormValues, NewTransactionView, NotFound, OFACAlertView, type OFACAlertViewProps, OriginatorCard, OriginatorFI, OriginatorFIAddress, type PageAction, type PageCard, PageLayout, PatternLibrary, PaymentInformationSection, Popover, PopoverContent, PopoverTrigger, ReceiverCard, ReconExceptions, ReconUpload, ResolveAlertDialog, ResponsiveGrid, ReturnTransactionDialog, ScrollArea, ScrollBar, type SelectOption, Separator, Sheet, SheetClose, SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetOverlay, SheetPortal, SheetTitle, SheetTrigger, Sidebar, SidebarContent, SidebarFooter, SidebarGroup, SidebarGroupAction, SidebarGroupContent, SidebarGroupLabel, SidebarHeader, SidebarInput, SidebarInset, SidebarMenu, SidebarMenuAction, SidebarMenuBadge, SidebarMenuButton, SidebarMenuItem, SidebarMenuSkeleton, SidebarMenuSub, SidebarMenuSubButton, SidebarMenuSubItem, SidebarProvider, SidebarRail, SidebarSeparator, SidebarTrigger, Stack, Statement, type StatementHeader, type StatementTransaction, StatementView, StatusBadge, Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, TableRow, Tabs, TabsContent, TabsList, TabsTrigger, type TextareaProps, Toast$1 as Toast, ToastAction, type ToastActionElement, ToastClose, ToastDescription, type ToastProps, ToastProvider, ToastTitle, ToastViewport, Toaster, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, TransactionDetail, TransactionDetailView, type TransactionDetailViewProps, TransactionHistory, type TransactionHistoryFilters, TransactionHistoryFiltersSheet, TransactionHistoryView, TransactionTypeBadge, type TransactionTypeOption, UIKit, UIKitShowcase, type UseAlertDetailReturn, VelocityLimitDetail, VelocityLimits, WireDetailsSection, WireTransferSection, badgeVariants, buttonVariants, cardVariants, downloadCSV, generateStatementCSV, inputVariants, newTransactionSchema, reducer, textareaVariants, toast, useAlertDetail, useCounterpartyEntity, useEditState, useFormWithEditState, useIsMobile, useSidebar, useToast };