import * as react_jsx_runtime from 'react/jsx-runtime';
import { ReactNode, PropsWithChildren } from 'react';
import { Schema } from 'effect';
import { PlaidLinkOnSuccessMetadata } from 'react-plaid-link';

interface BankTransactionsStringOverrides {
    bankTransactionCTAs?: BankTransactionCTAStringOverrides;
    transactionsTable?: BankTransactionsTableStringOverrides;
    bankTransactionsHeader?: BankTransactionsHeaderStringOverrides;
}
interface BankTransactionCTAStringOverrides {
    approveButtonText?: string;
    updateButtonText?: string;
}
interface BankTransactionsHeaderStringOverrides {
    header?: string;
    /** @deprecated Download moved into the header menu and no longer supports a custom label. This override is ignored and will be removed. */
    downloadButton?: string;
}
interface BankTransactionsTableStringOverrides {
    dateColumnHeaderText?: string;
    transactionColumnHeaderText?: string;
    accountColumnHeaderText?: string;
    amountColumnHeaderText?: string;
    categorizeColumnHeaderText?: string;
    categoryColumnHeaderText?: string;
}

declare enum BankTransactionDirection {
    Credit = "CREDIT",
    Debit = "DEBIT"
}
declare const BankTransactionDirectionSchema: Schema.transform<Schema.Literal<["CREDIT", "MONEY_IN", "DEBIT", "MONEY_OUT"]>, Schema.SchemaClass<BankTransactionDirection, BankTransactionDirection, never>>;
type RawBankTransactionDirection = typeof BankTransactionDirectionSchema.Encoded;

type MobileComponentType = 'regularList' | 'mobileList';

declare enum DisplayState {
    all = "all",
    review = "review",
    categorized = "categorized"
}

type TagFilterInput = {
    tagKey: string;
    tagValues: string[];
} | 'None';
type TagOption = {
    label: string;
    tagKey: string;
    tagValues: string[];
};

type DateRange<T = Date> = {
    startDate: T;
    endDate: T;
};

interface NumericRangeFilter {
    min?: number;
    max?: number;
}
type BankTransactionFilters = {
    amount?: NumericRangeFilter;
    sourceAccountIds?: string[];
    bankAccountIds?: string[];
    direction?: RawBankTransactionDirection[];
    categorizationStatus?: DisplayState;
    dateRange?: DateRange;
    query?: string;
    tagFilter?: TagFilterInput;
};

declare const ApiEnumErrorType: {
    readonly SpecifiedIdNotFound: 'SpecifiedIdNotFound';
    readonly SpecifiedBadRequest: 'SpecifiedBadRequest';
    readonly MileageDistanceIncalculable: 'MileageDistanceIncalculable';
};
type ApiEnumErrorType = typeof ApiEnumErrorType[keyof typeof ApiEnumErrorType];
type APIErrorMessage = {
    type?: string;
    description?: string;
    error_enum?: ApiEnumErrorType;
};
declare class APIError extends Error {
    code?: number;
    info?: string;
    messages?: APIErrorMessage[];
    constructor(message: string, code?: number, messages?: APIErrorMessage[]);
    getMessage(): string;
    getAllMessages(): (string | undefined)[] | undefined;
}

type LayerErrorType = 'unauthenticated' | 'api' | 'render';
type LayerErrorScope = 'BankTransaction' | 'ChartOfAccounts';
interface LayerError {
    type?: LayerErrorType;
    scope?: LayerErrorScope;
    payload: Error | APIError;
}

declare enum EntityName {
    Unknown = "Unknown",
    BankTransaction = "Bank Transaction",
    Invoice = "Invoice",
    InvoicePayment = "Invoice Payment",
    Bill = "Bill",
    BillPayment = "Bill Payment",
    CustomerRefund = "Customer Refund",
    CustomerRefundAllocation = "Customer Refund Allocation",
    CustomerRefundPayment = "Customer Refund Payment",
    VendorRefund = "Vendor Refund",
    VendorRefundAllocation = "Vendor Refund Allocation",
    VendorRefundPayment = "Vendor Refund Payment",
    CustomerPayout = "Customer Payout",
    VendorPayout = "Vendor Payout",
    QuickBooks = "QuickBooks",
    CustomJournalEntry = "Custom Journal Entry",
    Payroll = "Payroll",
    PayrollPayment = "Payroll Payment",
    LoanPayment = "Loan Payment",
    LoanProceed = "Loan Proceeds",
    OpeningBalance = "Opening Balance",
    InvoiceWriteOff = "Invoice Write-Off",
    VendorCredit = "Vendor Credit",
    CustomerCredit = "Customer Credit",
    ClosingAction = "Closing Action"
}
interface RelatedEntityLinkingMetadata {
    id: string;
    entityName: EntityName;
    externalId?: string;
    referenceNumber?: string;
    metadata?: unknown;
}
interface LinkingMetadata {
    id: string;
    entityName: EntityName;
    externalId?: string;
    referenceNumber?: string;
    metadata?: unknown;
    relatedEntityLinkingMetadata?: RelatedEntityLinkingMetadata[];
}

type BankTransactionsMode = 'bookkeeping-client' | 'self-serve';

interface BankTransactionsProps {
    asWidget?: boolean;
    pageSize?: number;
    /**
     * @deprecated `mode` can be inferred from the bookkeeping configuration of a business
     */
    mode?: BankTransactionsMode;
    showCategorizationRules?: boolean;
    showCustomerVendor?: boolean;
    /**
     * @deprecated This prop is no longer honored; transaction descriptions are always enabled.
     */
    showDescriptions?: boolean;
    /**
     * @deprecated This prop is no longer honored; receipt uploads are always enabled.
     */
    showReceiptUploads?: boolean;
    showStatusToggle?: boolean;
    showTags?: boolean;
    showTooltips?: boolean;
    showUploadOptions?: boolean;
    applyGlobalDateRange?: boolean;
    monthlyView?: boolean;
    /**
     * @deprecated `categorizeView` is no longer used. Categorization is enabled based on the bookkeeping configuration of a business.
     */
    categorizeView?: boolean;
    mobileComponent?: MobileComponentType;
    filters?: BankTransactionFilters;
    hideHeader?: boolean;
    collapseHeader?: boolean;
    stringOverrides?: BankTransactionsStringOverrides;
    renderInAppLink?: (details: LinkingMetadata) => ReactNode;
}
interface BankTransactionsWithErrorProps extends BankTransactionsProps {
    onError?: (error: LayerError) => void;
}
declare const BankTransactions: ({ onError, monthlyView, applyGlobalDateRange, mode, renderInAppLink, filters, categorizeView: _categorizeView, showDescriptions: _showDescriptions, showReceiptUploads: _showReceiptUploads, asWidget, pageSize, mobileComponent, hideHeader, collapseHeader, stringOverrides, ...featureVisibility }: BankTransactionsWithErrorProps) => react_jsx_runtime.JSX.Element;

type Awaitable<T> = T | Promise<T>;

/**
 * Public configuration for customer-managed Plaid items, accepted as a prop by exported
 * components that allow linking accounts.
 *
 * The customer platform owns the Plaid item and mints a processor token scoped to Layer, so
 * every operation needing the customer's Plaid credentials is delegated to these callbacks.
 * Layer still opens the Plaid Link modal and owns the surrounding UI.
 *
 * Mutually exclusive with `PlaidHostedLinkConfig`, which mints tokens through Layer's backend.
 */
type CustomerManagedPlaidConfig = {
    /** Mints an add-flow link token with the customer's own Plaid client. */
    createLinkToken: () => Awaitable<{
        linkToken: string;
    }>;
    /**
     * Mints an update-mode link token for the given connection. The id is the
     * `connectionExternalId` Layer holds on file: the Plaid item id for a Layer-managed item, or
     * the processor token for a customer-managed one.
     */
    createUpdateModeLinkToken: (connectionExternalId: string) => Awaitable<{
        linkToken: string;
    }>;
    /**
     * Hands off a successful Link result. The customer exchanges the public token, mints a
     * processor token for Layer, and registers it via `plaid_processor_tokens` on
     * `POST`/`PUT /v1/businesses`.
     *
     * Must not resolve until Layer has persisted the connection: resolution triggers the refetch,
     * and nothing times this out.
     */
    onPublicTokenReceived: (handoff: {
        publicToken: string;
        metadata: PlaidLinkOnSuccessMetadata;
    }) => Awaitable<void>;
};

/**
 * Public configuration for the Plaid Hosted Link flow, accepted as a prop by
 * exported components that allow linking accounts.
 *
 * When `isMobileApp` is `true`, both `redirectUri` and `completionRedirectUri`
 * are required so the hosted flow can return the user to the app. Otherwise all
 * fields are optional. Modelled as a union so the type system enforces the
 * mobile-app requirements.
 */
declare const PlaidHostedLinkConfigSchema: Schema.Union<[Schema.Struct<{
    isMobileApp: Schema.Literal<[true]>;
    redirectUri: typeof Schema.String;
    completionRedirectUri: typeof Schema.String;
}>, Schema.Struct<{
    isMobileApp: Schema.optional<Schema.Literal<[false]>>;
    redirectUri: Schema.optional<typeof Schema.String>;
    completionRedirectUri: Schema.optional<typeof Schema.String>;
}>]>;
type PlaidHostedLinkParams = typeof PlaidHostedLinkConfigSchema.Type;
type PlaidHostedLinkConfig = PlaidHostedLinkParams & {
    /**
     * Navigates the customer platform to the Plaid Hosted Link URL, returning via
     * `completionRedirectUri`. The return must reload the page: status is polled
     * only while mounted, so the remount is what signals the user came back and
     * restarts polling. Without it, a completed or failed link may go undetected.
     */
    navigateToHostedLink: (hostedLinkUrl: string) => Awaitable<void>;
};

interface LinkedAccountsProps {
    asWidget?: boolean;
    elevated?: boolean;
    showLedgerBalance?: boolean;
    showUnlinkItem?: boolean;
    showBreakConnection?: boolean;
    plaidHostedLinkConfig?: PlaidHostedLinkConfig;
    customerManagedPlaidConfig?: CustomerManagedPlaidConfig;
    onPlaidConnectionSuccess?: () => Awaitable<void>;
    stringOverrides?: {
        title?: string;
    };
}
declare const LinkedAccounts: ({ plaidHostedLinkConfig, customerManagedPlaidConfig, onPlaidConnectionSuccess, ...props }: LinkedAccountsProps) => react_jsx_runtime.JSX.Element;

type UnknownEnumValue = string & Record<never, never>;
type EnumWithUnknownValues<T extends string> = T | UnknownEnumValue;

type StrictReportingBasis = 'CASH' | 'CASH_COLLECTED' | 'ACCRUAL';
type ReportingBasis = EnumWithUnknownValues<StrictReportingBasis>;

type ProfitAndLossChartColors = {
    /** Ordered palette; cycles with reduced opacity once exhausted. */
    revenue?: string[];
    expenses?: string[];
    /** Omit to keep the dot-pattern donut fill and the neutral default swatch. */
    uncategorized?: string;
};
type ProfitAndLossChartConfig = {
    /** Shared by the donuts, the summary mini charts, and the summary tile swatches. */
    colors?: ProfitAndLossChartColors;
    barChart?: {
        barWidth?: number;
        /** Bar width below 620px wide. Defaults to half `barWidth`. */
        compactBarWidth?: number;
    };
    /** The scope donuts in the detailed charts and the expenses card, not the summary mini donuts. */
    donutChart?: {
        innerRadius?: string | number;
        outerRadius?: string | number;
    };
};

interface ProfitAndLossChartProps {
    tagFilter?: {
        key: string;
        values: string[];
    };
    hideLegend?: boolean;
    chartConfig?: ProfitAndLossChartConfig;
}
declare const ProfitAndLossChart: ({ tagFilter, hideLegend, chartConfig, }: ProfitAndLossChartProps) => react_jsx_runtime.JSX.Element;

type Scope = 'expenses' | 'revenue';
type SidebarScope = Scope | undefined;
interface DetailedChartStringOverrides {
    expenseChartHeader?: string;
    revenueChartHeader?: string;
    revenueToggleLabel?: string;
    expenseToggleLabel?: string;
}

type DateSelectionMode = 'full' | 'month' | 'year';

interface DetailedTableStringOverrides {
    categoryColumnHeader?: string;
    typeColumnHeader?: string;
    valueColumnHeader?: string;
}

interface ProfitAndLossDetailReportStringOverrides {
    title?: string;
    dateColumnHeader?: string;
    typeColumnHeader?: string;
    accountColumnHeader?: string;
    descriptionColumnHeader?: string;
    amountColumnHeader?: string;
    balanceColumnHeader?: string;
    sourceDetailsTitle?: string;
}

interface ProfitAndLossDetailedChartsSlotProps {
    detailedTable?: {
        showTypeColumn?: boolean;
    };
}
interface ProfitAndLossDetailedChartsStringOverrides {
    detailedChartStringOverrides?: DetailedChartStringOverrides;
    detailedTableStringOverrides?: DetailedTableStringOverrides;
    detailReportStringOverrides?: ProfitAndLossDetailReportStringOverrides;
}
declare const ProfitAndLossDetailedCharts: ({ scope, hideClose, hideHeader, showDatePicker, chartConfig, chartColorsList, stringOverrides, slotProps, }: {
    scope?: SidebarScope;
    hideClose?: boolean;
    hideHeader?: boolean;
    showDatePicker?: boolean;
    chartConfig?: ProfitAndLossChartConfig;
    /** Legacy flat palette. `chartConfig.colors` takes precedence when both are supplied. */
    chartColorsList?: string[];
    stringOverrides?: ProfitAndLossDetailedChartsStringOverrides;
    slotProps?: ProfitAndLossDetailedChartsSlotProps;
}) => react_jsx_runtime.JSX.Element;

type MoneyFormat = 'CENTS' | 'DOLLAR_STRING';
declare enum Direction {
    CREDIT = "CREDIT",
    DEBIT = "DEBIT"
}

type TimeRangePickerConfig = {
    /**
     * @deprecated This property is no longer used. Use `dateSelectionMode` instead.
     */
    datePickerMode?: unknown;
    /**
     * @deprecated This property is no longer used. Use `dateSelectionMode` instead.
     */
    defaultDatePickerMode?: unknown;
    /**
     * @deprecated This property is no longer used. Use `dateSelectionMode` instead.
     */
    allowedDatePickerModes?: unknown;
    /**
     * @deprecated This property is no longer used. Use `dateSelectionMode` instead.
     */
    customDateRanges?: unknown;
    dateSelectionMode?: DateSelectionMode;
    csvMoneyFormat?: MoneyFormat;
};

type View = 'mobile' | 'tablet' | 'desktop';

interface ProfitAndLossDownloadButtonStringOverrides {
    downloadButtonText?: string;
    retryButtonText?: string;
}

interface ProfitAndLossTableStringOverrides {
    grossProfitLabel?: string;
    profitBeforeTaxesLabel?: string;
    netProfitLabel?: string;
}

type ViewBreakpoint = View | undefined;
interface ProfitAndLossReportStringOverrides {
    downloadButton?: ProfitAndLossDownloadButtonStringOverrides;
    profitAndLoss?: {
        table?: ProfitAndLossTableStringOverrides;
    };
}
type ProfitAndLossReportProps = {
    stringOverrides?: ProfitAndLossReportStringOverrides;
    view?: ViewBreakpoint;
    renderInAppLink?: (source: LinkingMetadata) => ReactNode;
    hideHeader?: boolean;
} & TimeRangePickerConfig;
declare const ProfitAndLossReport: ({ stringOverrides, dateSelectionMode, csvMoneyFormat, view, renderInAppLink, hideHeader, }: ProfitAndLossReportProps) => react_jsx_runtime.JSX.Element;

declare const _SIZE_VARIANTS: readonly ['sm', 'lg'];
type SizeVariant = (typeof _SIZE_VARIANTS)[number];
type Variants = Partial<{
    size: SizeVariant;
}>;

interface ProfitAndLossSummariesStringOverrides {
    revenueLabel?: string;
    expensesLabel?: string;
    netProfitLabel?: string;
    moneyInLabel?: string;
    moneyOutLabel?: string;
    netCashFlowLabel?: string;
}
type ProfitAndLossSummariesReportingVariant = {
    type?: 'profitAndLoss';
} | {
    type: 'cashflow';
    showProfitAndLossBreakdown?: boolean;
};
type ProfitAndLossSummariesSlotProps = {
    chartConfig?: ProfitAndLossChartConfig;
    reportingVariant?: ProfitAndLossSummariesReportingVariant;
    /**
     * @deprecated This prop no longer has any effect; the summaries tiles size themselves
     * responsively to their container. Override the `--text-*` font size variables to adjust sizing.
     */
    variants?: Variants;
};
type ProfitAndLossSummariesProps = {
    actionable?: boolean;
    stringOverrides?: ProfitAndLossSummariesStringOverrides;
    chartConfig?: ProfitAndLossChartConfig;
    /** Legacy flat palette. `chartConfig.colors` takes precedence when both are supplied. */
    chartColorsList?: string[];
    reportingVariant?: ProfitAndLossSummariesReportingVariant;
    /**
     * @deprecated This prop no longer has any effect; the summaries tiles size themselves
     * responsively to their container. Override the `--text-*` font size variables to adjust sizing.
     */
    variants?: Variants;
    onTransactionsToReviewClick?: () => void;
    /**
     * @deprecated Use `stringOverrides.revenueLabel` instead
     */
    revenueLabel?: string;
    /**
     * @deprecated Orientation is determined by the container size
     */
    vertical?: boolean;
};
declare function ProfitAndLossSummaries({ actionable, revenueLabel, stringOverrides, chartConfig, chartColorsList, reportingVariant, onTransactionsToReviewClick, }: ProfitAndLossSummariesProps): react_jsx_runtime.JSX.Element;

type Props = PropsWithChildren<{
    tagFilter?: {
        key: string;
        values: string[];
    };
    /**
     * @deprecated The Profit & Loss comparison feature has been removed and this prop is ignored.
     * Use the `UnifiedReports` component for period/tag comparisons instead.
     */
    comparisonConfig?: unknown;
    reportingBasis?: ReportingBasis;
    asContainer?: boolean;
}>;
declare function ProfitAndLoss({ children, tagFilter, reportingBasis, asContainer, }: Props): react_jsx_runtime.JSX.Element;
declare namespace ProfitAndLoss {
    export { ProfitAndLossChart as Chart };
    export { ProfitAndLossSummaries as Summaries };
    export { ProfitAndLossDetailedCharts as DetailedCharts };
    export { ProfitAndLossReport as Report };
}

interface BalanceSheetTableStringOverrides {
    typeColumnHeader?: string;
    totalColumnHeader?: string;
}

interface BalanceSheetStringOverrides {
    balanceSheetTable?: BalanceSheetTableStringOverrides;
}
type BalanceSheetProps = PropsWithChildren<{
    effectiveDate?: Date;
    /** @deprecated No longer used. Expand all does not exist in Balance Sheet. */
    withExpandAllButton?: boolean;
    view?: View;
    stringOverrides?: BalanceSheetStringOverrides;
    dateSelectionMode?: DateSelectionMode;
}>;
declare const BalanceSheet: (props: BalanceSheetProps) => react_jsx_runtime.JSX.Element;

interface StatementOfCashFlowTableStringOverrides {
    typeColumnHeader?: string;
    totalColumnHeader?: string;
}

interface StatementOfCashFlowStringOverrides {
    statementOfCashFlowTable?: StatementOfCashFlowTableStringOverrides;
}
type StatementOfCashFlowProps = TimeRangePickerConfig & {
    view?: View;
    stringOverrides?: StatementOfCashFlowStringOverrides;
};
declare const StatementOfCashFlow: (props: StatementOfCashFlowProps) => react_jsx_runtime.JSX.Element;

interface ChartOfAccountsFormStringOverrides {
    editModeHeader?: string;
    createModeHeader?: string;
    cancelButton?: string;
    saveButton?: string;
    retryButton?: string;
    parentLabel?: string;
    nameLabel?: string;
    accountNumberLabel?: string;
    typeLabel?: string;
    subTypeLabel?: string;
    normalityLabel?: string;
}

interface ChartOfAccountsTableStringOverrides {
    headerText?: string;
    addAccountButtonText?: string;
    csvDownloadButtonText?: string;
    nameColumnHeader?: string;
    numberColumnHeader?: string;
    typeColumnHeader?: string;
    balanceColumnHeader?: string;
    subtypeColumnHeader?: string;
    chartOfAccountsForm?: ChartOfAccountsFormStringOverrides;
}

interface LedgerEntrySourceDetailStringOverrides {
    sourceLabel?: string;
    accountNameLabel?: string;
    dateLabel?: string;
    amountLabel?: string;
    directionLabel?: string;
    counterpartyLabel?: string;
    invoiceNumberLabel?: string;
    recipientNameLabel?: string;
    memoLabel?: string;
    createdByLabel?: string;
    processorLabel?: string;
}

interface JournalEntryDetailStringOverrides {
    entryTypeLabel?: string;
    dateLabel?: string;
    creationDateLabel?: string;
    reversalLabel?: string;
}
interface LedgerEntryDetailsLineItemsTableStringOverrides {
    lineItemsColumnHeader?: string;
    debitColumnHeader?: string;
    creditColumnHeader?: string;
    totalRowHeader?: string;
}
interface LedgerEntryDetailStringOverrides {
    title?: string;
    transactionSource?: {
        header?: string;
        details?: LedgerEntrySourceDetailStringOverrides;
    };
    journalEntry?: {
        header?: (entryId?: string) => string;
        details?: JournalEntryDetailStringOverrides;
    };
    lineItemsTable?: LedgerEntryDetailsLineItemsTableStringOverrides;
}

type LedgerAccountEntryDetailsStringOverrides = LedgerEntryDetailStringOverrides;

interface LedgerAccountLineItemsTableStringOverrides {
    dateColumnHeader?: string;
    journalIdColumnHeader?: string;
    sourceColumnHeader?: string;
    accountColumnHeader?: string;
    debitColumnHeader?: string;
    creditColumnHeader?: string;
    runningBalanceColumnHeader?: string;
}

interface LedgerAccountStringOverrides {
    ledgerEntryDetail?: LedgerAccountEntryDetailsStringOverrides;
    ledgerEntriesTable?: LedgerAccountLineItemsTableStringOverrides;
}

interface ChartOfAccountsStringOverrides {
    chartOfAccountsTable?: ChartOfAccountsTableStringOverrides;
    ledgerAccount?: LedgerAccountStringOverrides;
}
interface ChartOfAccountsProps {
    asWidget?: boolean;
    withDateControl?: boolean;
    withExpandAllButton?: boolean;
    stringOverrides?: ChartOfAccountsStringOverrides;
    showAddAccountButton?: boolean;
    templateAccountsEditable?: boolean;
    renderInAppLink?: (source: LinkingMetadata) => ReactNode;
}
/**
 * Views already inside a `LedgerDateStoreProvider` (e.g. `GeneralLedger`) should
 * render {@link InternalChartOfAccounts} instead to avoid a nested store.
 */
declare const ChartOfAccounts: (props: ChartOfAccountsProps) => react_jsx_runtime.JSX.Element;

interface JournalTableStringOverrides {
    componentTitle?: string;
    /** @deprecated The sub-header row was removed; this override no longer renders. */
    componentSubtitle?: string;
    addEntryButton?: string;
    idColumnHeader?: string;
    dateColumnHeader?: string;
    transactionColumnHeader?: string;
    accountNumberColumnHeader?: string;
    accountColumnHeader?: string;
    debitColumnHeader?: string;
    creditColumnHeader?: string;
}

interface JournalStringOverrides {
    journalTable?: JournalTableStringOverrides;
}
interface JournalProps {
    asWidget?: boolean;
    stringOverrides?: JournalStringOverrides;
    renderInAppLink?: (source: LinkingMetadata) => ReactNode;
    showTags?: boolean;
    showCustomerVendor?: boolean;
}
/**
 * Views already inside a `LedgerDateStoreProvider` (e.g. `GeneralLedger`) should
 * render {@link InternalJournal} instead to avoid a nested store.
 */
declare const Journal: (props: JournalProps) => react_jsx_runtime.JSX.Element;

interface TasksStringOverrides {
    header?: string;
}
type TasksProps = {
    /**
     * @deprecated Use `stringOverrides.header` instead
     */
    tasksHeader?: string;
    mobile?: boolean;
    stringOverrides?: TasksStringOverrides;
    onClickReconnectAccounts?: () => void;
};
declare function Tasks({ mobile, tasksHeader, onClickReconnectAccounts, stringOverrides, }: TasksProps): react_jsx_runtime.JSX.Element;

interface LinkAccountsStringOverrides {
    removeUnusedAccountsNextStep?: string;
}

type LinkAccountsProps = {
    onComplete?: () => Awaitable<void>;
    onPlaidConnectionSuccess?: () => Awaitable<void>;
    plaidHostedLinkConfig?: PlaidHostedLinkConfig;
    customerManagedPlaidConfig?: CustomerManagedPlaidConfig;
    isReconnectFlow?: boolean;
    stringOverrides?: LinkAccountsStringOverrides;
};
declare function LinkAccounts({ plaidHostedLinkConfig, customerManagedPlaidConfig, onPlaidConnectionSuccess, ...props }: LinkAccountsProps): react_jsx_runtime.JSX.Element;

/**
 * A Link acts as a call-to-action for users interacting with the LandingPage component.
 * @see LandingPage
 */
type LandingPageLink = {
    /** Text label displayed for the link. */
    label: string;
    /** Destination for the link. If calendly URL, opens a Calendly modal. Otherwise, opens a new tab. */
    url: string;
};
/**
 * The PlatformConfig holds on to the name of the platform integrating with Layer, the primary
 * top-of-fold image shown on the LandingPage component, and the name of the platform's
 * niche or industry.
 @see LandingPage
 */
interface LandingPagePlatformConfig {
    /**
       * The platform/brand name displayed throughout the component (e.g., "Shopify", "WooCommerce").
       * Used in titles, descriptions, and feature text to customize the content.
       */
    platformName: string;
    /**
       * The target industry for customization (e.g., "e-commerce", "SaaS", "retail").
       * Used to tailor feature descriptions and messaging to the specific industry.
       *
       * In cases where the industry name substitution does not work well for the value
       * propositions or features, we recommended you overwrite the value propositions directly.
       *
      @see LandingPageValueProposition
       */
    industry: string;
}
/**
 * Utility type for creating deep partial types - makes all properties optional recursively
 */
type DeepPartial<T> = {
    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
};
/**
 * Configuration for the hero/main content section of the Landing Page page
 */
type HeroContentConfig = {
    stringOverrides: {
        title: string;
        subtitle: string;
        heading1: string;
        heading1Desc: string;
        heading2: string;
        heading2Desc: string;
    };
    mediaUrls: {
        topOfFoldImage: string;
    };
    cta: {
        primary: LandingPageLink;
        secondary: LandingPageLink;
    };
};
/**
 * Configuration for individual Landing Page cards (accounting or bookkeeping)
 */
type LandingPageCardConfig = {
    offerType: 'accounting' | 'bookkeeping';
    stringOverrides: {
        badge: string;
        title: string;
        subtitle: string;
        priceAmount: string;
        priceUnit: string;
    };
    mediaUrls: {
        offerImage: string;
    };
    cta: {
        primary: LandingPageLink;
    };
    showStartingAtLabel: boolean;
};

interface LandingPageProps {
    platform: LandingPagePlatformConfig;
    availableOffers: ('accounting' | 'bookkeeping')[];
    heroOverrides: DeepPartial<HeroContentConfig>;
    offeringOverrides: {
        stringOverrides?: {
            sectionTitle: string;
        };
        accounting: DeepPartial<LandingPageCardConfig>;
        bookkeeping: DeepPartial<LandingPageCardConfig>;
    };
}
declare const LandingPage: ({ platform, availableOffers, heroOverrides, offeringOverrides, }: LandingPageProps) => react_jsx_runtime.JSX.Element;

type GlobalDateRangeSelectionProps = {
    showLabels?: boolean;
    isCompact?: boolean;
};
declare const GlobalDateRangeSelection: ({ showLabels, isCompact }: GlobalDateRangeSelectionProps) => react_jsx_runtime.JSX.Element;

type GlobalMonthPickerProps = {
    truncateMonth?: boolean;
    showLabel?: boolean;
};
declare const GlobalMonthPicker: ({ truncateMonth, showLabel }: GlobalMonthPickerProps) => react_jsx_runtime.JSX.Element;

declare const MileageSummaryCard: () => react_jsx_runtime.JSX.Element;

interface ToastData {
    id?: string;
    content: string;
    duration?: number;
    isExiting?: boolean;
    type?: 'success' | 'error' | 'default';
}

/** Versioned public contract for events emitted via `eventCallbacks.onEvent`. */
declare const LayerEventType: {
    readonly TaskMonthSelected: 'tasks.month_selected';
    readonly TaskYearSelected: 'tasks.year_selected';
    readonly TaskClicked: 'tasks.task_clicked';
    readonly BookkeepingScheduleCallClicked: 'bookkeeping.schedule_call_clicked';
    readonly ProfitAndLossMonthSelected: 'profit_and_loss.month_selected';
    readonly TransactionsSearchSubmitted: 'transactions.search_submitted';
    readonly TransactionsDownloadClicked: 'transactions.download_clicked';
    readonly TransactionDescriptionEntered: 'transactions.description_entered';
    readonly TransactionReceiptUploadClicked: 'transactions.receipt_upload_clicked';
    readonly TransactionsPageChanged: 'transactions.page_changed';
    readonly ReportsNavigated: 'reports.navigated';
    readonly ReportsPeriodSelected: 'reports.period_selected';
    readonly ReportsDownloadClicked: 'reports.download_clicked';
    readonly ReportsSectionExpanded: 'reports.section_expanded';
    readonly LinkedAccountsAddAccountClicked: 'linked_accounts.add_account_clicked';
    readonly LinkedAccountsUnlinkAccountClicked: 'linked_accounts.unlink_account_clicked';
};
type LayerEventType = (typeof LayerEventType)[keyof typeof LayerEventType];
declare const LayerEventComponent: {
    readonly BankTransactions: 'BankTransactions';
    readonly Tasks: 'Tasks';
    readonly ProfitAndLossChart: 'ProfitAndLossChart';
    readonly BookkeepingOverview: 'BookkeepingOverview';
    readonly UnifiedReports: 'UnifiedReports';
    readonly LinkedAccounts: 'LinkedAccounts';
};
type LayerEventComponent = (typeof LayerEventComponent)[keyof typeof LayerEventComponent];
declare const LayerEventSchema: Schema.Union<[Schema.Struct<{
    source: Schema.Literal<["layer"]>;
    type: Schema.Literal<["tasks.month_selected"]>;
    version: Schema.Literal<[1]>;
    payload: Schema.Struct<{
        year: typeof Schema.Number;
        month: typeof Schema.Number;
    }>;
    metadata: Schema.Struct<{
        component: Schema.Literal<["BankTransactions", "Tasks", "ProfitAndLossChart", "BookkeepingOverview", "UnifiedReports", "LinkedAccounts"]>;
        timestamp: typeof Schema.String;
        packageVersion: Schema.optional<typeof Schema.String>;
    }>;
}>, Schema.Struct<{
    source: Schema.Literal<["layer"]>;
    type: Schema.Literal<["tasks.year_selected"]>;
    version: Schema.Literal<[1]>;
    payload: Schema.Struct<{
        year: typeof Schema.Number;
    }>;
    metadata: Schema.Struct<{
        component: Schema.Literal<["BankTransactions", "Tasks", "ProfitAndLossChart", "BookkeepingOverview", "UnifiedReports", "LinkedAccounts"]>;
        timestamp: typeof Schema.String;
        packageVersion: Schema.optional<typeof Schema.String>;
    }>;
}>, Schema.Struct<{
    source: Schema.Literal<["layer"]>;
    type: Schema.Literal<["tasks.task_clicked"]>;
    version: Schema.Literal<[1]>;
    payload: Schema.Struct<{
        taskId: typeof Schema.String;
    }>;
    metadata: Schema.Struct<{
        component: Schema.Literal<["BankTransactions", "Tasks", "ProfitAndLossChart", "BookkeepingOverview", "UnifiedReports", "LinkedAccounts"]>;
        timestamp: typeof Schema.String;
        packageVersion: Schema.optional<typeof Schema.String>;
    }>;
}>, Schema.Struct<{
    source: Schema.Literal<["layer"]>;
    type: Schema.Literal<["bookkeeping.schedule_call_clicked"]>;
    version: Schema.Literal<[1]>;
    payload: Schema.Struct<{}>;
    metadata: Schema.Struct<{
        component: Schema.Literal<["BankTransactions", "Tasks", "ProfitAndLossChart", "BookkeepingOverview", "UnifiedReports", "LinkedAccounts"]>;
        timestamp: typeof Schema.String;
        packageVersion: Schema.optional<typeof Schema.String>;
    }>;
}>, Schema.Struct<{
    source: Schema.Literal<["layer"]>;
    type: Schema.Literal<["profit_and_loss.month_selected"]>;
    version: Schema.Literal<[1]>;
    payload: Schema.Struct<{
        year: typeof Schema.Number;
        month: typeof Schema.Number;
    }>;
    metadata: Schema.Struct<{
        component: Schema.Literal<["BankTransactions", "Tasks", "ProfitAndLossChart", "BookkeepingOverview", "UnifiedReports", "LinkedAccounts"]>;
        timestamp: typeof Schema.String;
        packageVersion: Schema.optional<typeof Schema.String>;
    }>;
}>, Schema.Struct<{
    source: Schema.Literal<["layer"]>;
    type: Schema.Literal<["transactions.search_submitted"]>;
    version: Schema.Literal<[1]>;
    payload: Schema.Struct<{
        query: typeof Schema.String;
    }>;
    metadata: Schema.Struct<{
        component: Schema.Literal<["BankTransactions", "Tasks", "ProfitAndLossChart", "BookkeepingOverview", "UnifiedReports", "LinkedAccounts"]>;
        timestamp: typeof Schema.String;
        packageVersion: Schema.optional<typeof Schema.String>;
    }>;
}>, Schema.Struct<{
    source: Schema.Literal<["layer"]>;
    type: Schema.Literal<["transactions.download_clicked"]>;
    version: Schema.Literal<[1]>;
    payload: Schema.Struct<{}>;
    metadata: Schema.Struct<{
        component: Schema.Literal<["BankTransactions", "Tasks", "ProfitAndLossChart", "BookkeepingOverview", "UnifiedReports", "LinkedAccounts"]>;
        timestamp: typeof Schema.String;
        packageVersion: Schema.optional<typeof Schema.String>;
    }>;
}>, Schema.Struct<{
    source: Schema.Literal<["layer"]>;
    type: Schema.Literal<["transactions.description_entered"]>;
    version: Schema.Literal<[1]>;
    payload: Schema.Struct<{
        transactionId: typeof Schema.String;
    }>;
    metadata: Schema.Struct<{
        component: Schema.Literal<["BankTransactions", "Tasks", "ProfitAndLossChart", "BookkeepingOverview", "UnifiedReports", "LinkedAccounts"]>;
        timestamp: typeof Schema.String;
        packageVersion: Schema.optional<typeof Schema.String>;
    }>;
}>, Schema.Struct<{
    source: Schema.Literal<["layer"]>;
    type: Schema.Literal<["transactions.receipt_upload_clicked"]>;
    version: Schema.Literal<[1]>;
    payload: Schema.Struct<{
        transactionId: typeof Schema.String;
    }>;
    metadata: Schema.Struct<{
        component: Schema.Literal<["BankTransactions", "Tasks", "ProfitAndLossChart", "BookkeepingOverview", "UnifiedReports", "LinkedAccounts"]>;
        timestamp: typeof Schema.String;
        packageVersion: Schema.optional<typeof Schema.String>;
    }>;
}>, Schema.Struct<{
    source: Schema.Literal<["layer"]>;
    type: Schema.Literal<["transactions.page_changed"]>;
    version: Schema.Literal<[1]>;
    payload: Schema.Struct<{
        page: typeof Schema.Number;
    }>;
    metadata: Schema.Struct<{
        component: Schema.Literal<["BankTransactions", "Tasks", "ProfitAndLossChart", "BookkeepingOverview", "UnifiedReports", "LinkedAccounts"]>;
        timestamp: typeof Schema.String;
        packageVersion: Schema.optional<typeof Schema.String>;
    }>;
}>, Schema.Struct<{
    source: Schema.Literal<["layer"]>;
    type: Schema.Literal<["reports.navigated"]>;
    version: Schema.Literal<[1]>;
    payload: Schema.Struct<{
        reportKey: typeof Schema.String;
    }>;
    metadata: Schema.Struct<{
        component: Schema.Literal<["BankTransactions", "Tasks", "ProfitAndLossChart", "BookkeepingOverview", "UnifiedReports", "LinkedAccounts"]>;
        timestamp: typeof Schema.String;
        packageVersion: Schema.optional<typeof Schema.String>;
    }>;
}>, Schema.Struct<{
    source: Schema.Literal<["layer"]>;
    type: Schema.Literal<["reports.period_selected"]>;
    version: Schema.Literal<[1]>;
    payload: Schema.Struct<{
        startDate: typeof Schema.String;
        endDate: typeof Schema.String;
    }>;
    metadata: Schema.Struct<{
        component: Schema.Literal<["BankTransactions", "Tasks", "ProfitAndLossChart", "BookkeepingOverview", "UnifiedReports", "LinkedAccounts"]>;
        timestamp: typeof Schema.String;
        packageVersion: Schema.optional<typeof Schema.String>;
    }>;
}>, Schema.Struct<{
    source: Schema.Literal<["layer"]>;
    type: Schema.Literal<["reports.download_clicked"]>;
    version: Schema.Literal<[1]>;
    payload: Schema.Struct<{
        reportKey: typeof Schema.String;
    }>;
    metadata: Schema.Struct<{
        component: Schema.Literal<["BankTransactions", "Tasks", "ProfitAndLossChart", "BookkeepingOverview", "UnifiedReports", "LinkedAccounts"]>;
        timestamp: typeof Schema.String;
        packageVersion: Schema.optional<typeof Schema.String>;
    }>;
}>, Schema.Struct<{
    source: Schema.Literal<["layer"]>;
    type: Schema.Literal<["reports.section_expanded"]>;
    version: Schema.Literal<[1]>;
    payload: Schema.Struct<{
        sectionKey: typeof Schema.String;
        expanded: typeof Schema.Boolean;
    }>;
    metadata: Schema.Struct<{
        component: Schema.Literal<["BankTransactions", "Tasks", "ProfitAndLossChart", "BookkeepingOverview", "UnifiedReports", "LinkedAccounts"]>;
        timestamp: typeof Schema.String;
        packageVersion: Schema.optional<typeof Schema.String>;
    }>;
}>, Schema.Struct<{
    source: Schema.Literal<["layer"]>;
    type: Schema.Literal<["linked_accounts.add_account_clicked"]>;
    version: Schema.Literal<[1]>;
    payload: Schema.Struct<{}>;
    metadata: Schema.Struct<{
        component: Schema.Literal<["BankTransactions", "Tasks", "ProfitAndLossChart", "BookkeepingOverview", "UnifiedReports", "LinkedAccounts"]>;
        timestamp: typeof Schema.String;
        packageVersion: Schema.optional<typeof Schema.String>;
    }>;
}>, Schema.Struct<{
    source: Schema.Literal<["layer"]>;
    type: Schema.Literal<["linked_accounts.unlink_account_clicked"]>;
    version: Schema.Literal<[1]>;
    payload: Schema.Struct<{
        accountId: typeof Schema.String;
    }>;
    metadata: Schema.Struct<{
        component: Schema.Literal<["BankTransactions", "Tasks", "ProfitAndLossChart", "BookkeepingOverview", "UnifiedReports", "LinkedAccounts"]>;
        timestamp: typeof Schema.String;
        packageVersion: Schema.optional<typeof Schema.String>;
    }>;
}>]>;
type LayerEvent = typeof LayerEventSchema.Type;

declare const AccountingConfigurationSchema: Schema.Struct<{
    id: typeof Schema.UUID;
    enableAccountNumbers: Schema.PropertySignature<":", boolean, "enable_account_numbers", ":", boolean, false, never>;
    enableCustomerManagement: Schema.PropertySignature<":", boolean, "enable_customer_management", ":", boolean, false, never>;
    taxEstimatesUserAgreementAt: Schema.PropertySignature<":", Date | null | undefined, "tax_estimates_user_agreement_at", ":", string | null | undefined, false, never>;
    enableTaxEstimates: Schema.PropertySignature<":", boolean, "enable_tax_estimates", ":", boolean, false, never>;
    enableMileageTracking: Schema.PropertySignature<":", boolean, "enable_mileage_tracking", ":", boolean, false, never>;
    enableStripeOnboarding: Schema.PropertySignature<":", boolean, "enable_stripe_onboarding", ":", boolean, false, never>;
    platformDisplayTags: Schema.PropertySignature<":", readonly {
        readonly id: string;
        readonly key: string;
        readonly displayName: string | null | undefined;
        readonly strictness: "BALANCING" | "NON_BALANCING";
        readonly definedValues: readonly {
            readonly id: string;
            readonly key: string;
            readonly value: string;
            readonly displayName: string | null | undefined;
            readonly archivedAt: Date | null | undefined;
        }[];
        readonly createdAt: Date;
        readonly updatedAt: Date;
        readonly userVisible: boolean;
    }[], "platform_display_tags", ":", readonly {
        readonly created_at: string;
        readonly defined_values: readonly {
            readonly archived_at: string | null | undefined;
            readonly display_name: string | null | undefined;
            readonly id: string;
            readonly key: string;
            readonly value: string;
        }[];
        readonly display_name: string | null | undefined;
        readonly id: string;
        readonly key: string;
        readonly strictness: string;
        readonly updated_at: string;
        readonly user_visible: boolean;
    }[], false, never>;
}>;
type AccountingConfigurationSchemaType = typeof AccountingConfigurationSchema.Type;

declare const BusinessSchema: Schema.Struct<{
    id: typeof Schema.UUID;
    legalName: Schema.PropertySignature<":", string | null | undefined, "legal_name", ":", string | null | undefined, false, never>;
    activationAt: Schema.PropertySignature<":", Date, "activation_at", ":", string, false, never>;
    isDemo: Schema.PropertySignature<":", boolean, "is_demo", ":", boolean, false, never>;
}>;
type Business = typeof BusinessSchema.Type;

type EventCallbacks$1 = {
    onEvent?: (event: LayerEvent) => void;
    onTransactionCategorized?: () => void;
    onTransactionsFetched?: () => void;
};
type LayerContextValues = {
    businessId: string;
    business?: Business;
    theme?: LayerThemeConfig;
    colors: ColorsPalette;
    /** @deprecated No longer used; the Onboarding component that consumed this has been removed. */
    onboardingStep?: OnboardingStep;
    toasts: (ToastData & {
        isExiting: boolean;
    })[];
    eventCallbacks?: EventCallbacks$1;
    accountingConfiguration?: AccountingConfigurationSchemaType;
};
type LayerContextDateRange = {
    dateRange: {
        range: DateRange;
        setRange: (dateRange: DateRange) => DateRange;
    };
};
type LayerContextHelpers = {
    getColor: (shade: number) => ColorsPaletteOption | undefined;
    setLightColor: (color?: ColorConfig) => void;
    setDarkColor: (color?: ColorConfig) => void;
    setTextColor: (color?: ColorConfig) => void;
    setColors: (colors?: LayerThemeConfigColors) => void;
    /** @deprecated No longer used; the Onboarding component that consumed this has been removed. */
    setOnboardingStep: (value: OnboardingStep) => void;
    addToast: (toast: ToastData) => void;
    removeToast: (toast: ToastData) => void;
    onError?: (error: LayerError) => void;
    setTheme: (theme: LayerThemeConfig) => void;
};
interface ColorHSLConfig {
    h: string;
    s: string;
    l: string;
}
interface ColorHSLNumberConfig {
    h: number;
    s: number;
    l: number;
}
interface ColorRGBConfig {
    r: string;
    g: string;
    b: string;
}
interface ColorRGBNumberConfig {
    r: number;
    g: number;
    b: number;
}
interface ColorHexConfig {
    hex: string;
}
type ColorConfig = ColorHSLConfig | ColorRGBConfig | ColorHexConfig;
interface ColorsPaletteOption {
    hsl: ColorHSLNumberConfig;
    rgb: ColorRGBNumberConfig;
    hex: string;
}
type ColorsPalette = Record<number, ColorsPaletteOption>;
interface LayerThemeConfigColors {
    dark?: ColorConfig;
    light?: ColorConfig;
    text?: ColorConfig;
}
interface LayerThemeConfig {
    colors?: LayerThemeConfigColors;
}
/** @deprecated No longer used; the Onboarding component that consumed this has been removed. */
type OnboardingStep = undefined | 'connectAccount' | 'complete';

interface AccountingOverviewStringOverrides {
    title?: string;
    header?: string;
    profitAndLoss?: {
        detailedCharts?: ProfitAndLossDetailedChartsStringOverrides;
        summaries?: ProfitAndLossSummariesStringOverrides;
    };
}
interface AccountingOverviewProps {
    /** @deprecated Use `stringOverrides.title` instead */
    title?: string;
    showTitle?: boolean;
    /** @deprecated The Onboarding component has been removed; this prop no longer does anything. */
    enableOnboarding?: boolean;
    /** @deprecated The Onboarding component has been removed; this prop no longer does anything. */
    onboardingStepOverride?: OnboardingStep;
    onTransactionsToReviewClick?: () => void;
    middleBanner?: ReactNode;
    chartColorsList?: string[];
    stringOverrides?: AccountingOverviewStringOverrides;
    tagFilter?: TagOption;
    slotProps?: {
        profitAndLoss?: {
            summaries?: ProfitAndLossSummariesSlotProps;
            chart?: {
                chartConfig?: ProfitAndLossChartConfig;
            };
            detailedCharts?: {
                revenue?: {
                    chartConfig?: ProfitAndLossChartConfig;
                };
                expenses?: {
                    chartConfig?: ProfitAndLossChartConfig;
                };
            };
        };
    };
}
declare const AccountingOverview: ({ title, showTitle, onTransactionsToReviewClick, middleBanner, chartColorsList, stringOverrides, tagFilter, slotProps, }: AccountingOverviewProps) => react_jsx_runtime.JSX.Element;

interface BankTransactionsWithLinkedAccountsStringOverrides {
    title?: string;
    linkedAccounts?: BankTransactionsWithLinkedAccountsStringOverrides;
    bankTransactions?: BankTransactionsStringOverrides;
}
interface BankTransactionsWithLinkedAccountsProps {
    title?: string;
    showTitle?: boolean;
    elevatedLinkedAccounts?: boolean;
    showBreakConnection?: boolean;
    showCustomerVendor?: boolean;
    /**
     * @deprecated This prop is no longer honored; transaction descriptions are always enabled.
     */
    showDescriptions?: boolean;
    showLedgerBalance?: boolean;
    /**
     * @deprecated This prop is no longer honored; receipt uploads are always enabled.
     */
    showReceiptUploads?: boolean;
    showTags?: boolean;
    showTooltips?: boolean;
    showUnlinkItem?: boolean;
    showUploadOptions?: boolean;
    /**
     * @deprecated `mode` can be inferred from the bookkeeping configuration of a business
     */
    mode?: BankTransactionsMode;
    mobileComponent?: MobileComponentType;
    stringOverrides?: BankTransactionsWithLinkedAccountsStringOverrides;
    renderInAppLink?: (details: LinkingMetadata) => ReactNode;
    showCategorizationRules?: boolean;
    plaidHostedLinkConfig?: PlaidHostedLinkConfig;
    customerManagedPlaidConfig?: CustomerManagedPlaidConfig;
}
declare const BankTransactionsWithLinkedAccounts: (props: BankTransactionsWithLinkedAccountsProps) => react_jsx_runtime.JSX.Element;

interface BookkeepingOverviewProps {
    showTitle?: boolean;
    stringOverrides?: {
        title?: string;
        tasks?: TasksStringOverrides;
        profitAndLoss?: {
            header?: string;
            detailedCharts?: ProfitAndLossDetailedChartsStringOverrides;
            summaries?: ProfitAndLossSummariesStringOverrides;
        };
    };
    slotProps?: {
        profitAndLoss?: {
            summaries?: ProfitAndLossSummariesSlotProps;
            chart?: {
                chartConfig?: ProfitAndLossChartConfig;
            };
            detailedCharts?: {
                revenue?: {
                    chartConfig?: ProfitAndLossChartConfig;
                };
                expenses?: {
                    chartConfig?: ProfitAndLossChartConfig;
                };
            };
        };
    };
    chartColorsList?: string[];
    onClickReconnectAccounts?: () => void;
    tagFilter?: TagOption;
    /**
     * @deprecated Use `stringOverrides.title` instead
     */
    title?: string;
}
declare const BookkeepingOverview: ({ title, showTitle, onClickReconnectAccounts, chartColorsList, stringOverrides, slotProps, tagFilter, }: BookkeepingOverviewProps) => react_jsx_runtime.JSX.Element;

interface GeneralLedgerStringOverrides {
    title?: string;
    chartOfAccountsToggleOption?: string;
    journalToggleOption?: string;
    chartOfAccounts: ChartOfAccountsStringOverrides;
    journal: JournalStringOverrides;
}
interface ChartOfAccountsOptions {
    templateAccountsEditable?: boolean;
    showAddAccountButton?: boolean;
}
interface GeneralLedgerProps {
    title?: string;
    showTitle?: boolean;
    showTags?: boolean;
    showCustomerVendor?: boolean;
    stringOverrides?: GeneralLedgerStringOverrides;
    chartOfAccountsOptions?: ChartOfAccountsOptions;
    renderInAppLink?: (source: LinkingMetadata) => ReactNode;
}
declare const GeneralLedgerView: ({ title, showTitle, showTags, showCustomerVendor, stringOverrides, chartOfAccountsOptions, renderInAppLink, }: GeneralLedgerProps) => react_jsx_runtime.JSX.Element;

interface InvoicesStringOverrides {
    title?: string;
}
interface InvoicesProps {
    stringOverrides?: InvoicesStringOverrides;
}
declare const Invoices: ({ stringOverrides }: InvoicesProps) => react_jsx_runtime.JSX.Element;

declare const MileageTracking: ({ showTitle }: {
    showTitle?: boolean;
}) => react_jsx_runtime.JSX.Element;

type ReportType = 'profitAndLoss' | 'balanceSheet' | 'statementOfCashFlow';

interface ReportsStringOverrides {
    title?: string;
    downloadButton?: ProfitAndLossDownloadButtonStringOverrides;
    profitAndLoss?: {
        detailedCharts?: ProfitAndLossDetailedChartsStringOverrides;
        table?: ProfitAndLossTableStringOverrides;
    };
    balanceSheet?: BalanceSheetStringOverrides;
    statementOfCashflow?: StatementOfCashFlowStringOverrides;
}
interface ReportsProps {
    title?: string;
    showTitle?: boolean;
    stringOverrides?: ReportsStringOverrides;
    enabledReports?: ReportType[];
    /**
     * @deprecated The Profit & Loss comparison feature has been removed and this prop is ignored.
     * Use the `UnifiedReports` component for period/tag comparisons instead.
     */
    comparisonConfig?: unknown;
    profitAndLossConfig?: TimeRangePickerConfig;
    statementOfCashFlowConfig?: TimeRangePickerConfig;
    renderInAppLink?: (source: LinkingMetadata) => ReactNode;
}
declare const Reports: ({ title, showTitle, stringOverrides, enabledReports, profitAndLossConfig, statementOfCashFlowConfig, renderInAppLink, }: ReportsProps) => react_jsx_runtime.JSX.Element;

type SummaryCardInteractionProps = {
    onClickExpand?: () => void;
};
type SummaryCardStringOverrides = {
    title?: string;
};

interface SolopreneurOverviewStringOverrides {
    title?: string;
    profitAndLossSummaries?: ProfitAndLossSummariesStringOverrides;
    summaryCards?: {
        profitAndLoss?: SummaryCardStringOverrides;
        expenses?: SummaryCardStringOverrides;
        taxEstimates?: SummaryCardStringOverrides;
        mileageTracking?: SummaryCardStringOverrides;
    };
}
interface SolopreneurOverviewInteractionProps {
    banner?: {
        onSetupTaxProfile?: () => void;
    };
    cashflowSummaries?: {
        onTransactionsToReviewClick?: () => void;
    };
    summaryCards?: {
        profitAndLoss?: SummaryCardInteractionProps;
        expenses?: SummaryCardInteractionProps;
        taxEstimates?: SummaryCardInteractionProps;
        mileageTracking?: SummaryCardInteractionProps;
    };
}
interface SolopreneurOverviewProps {
    chartColorsList?: string[];
    stringOverrides?: SolopreneurOverviewStringOverrides;
    interactionProps?: SolopreneurOverviewInteractionProps;
    slotProps?: {
        profitAndLoss?: {
            summaries?: ProfitAndLossSummariesSlotProps;
        };
        summaryCards?: {
            profitAndLoss?: {
                chartConfig?: ProfitAndLossChartConfig;
            };
            expenses?: {
                chartConfig?: ProfitAndLossChartConfig;
            };
        };
    };
    plaidHostedLinkConfig?: PlaidHostedLinkConfig;
    customerManagedPlaidConfig?: CustomerManagedPlaidConfig;
}
declare const SolopreneurOverview: ({ interactionProps, chartColorsList, stringOverrides, slotProps, plaidHostedLinkConfig, customerManagedPlaidConfig, }: SolopreneurOverviewProps) => react_jsx_runtime.JSX.Element;

type TaxEstimatesReviewTransactionsPayload = {
    uncategorizedMoneyIn: number;
    uncategorizedMoneyOut: number;
    uncategorizedTransactionCount: number;
};
type TaxEstimatesContextProviderProps = PropsWithChildren<{
    onClickReviewTransactions?: (payload: TaxEstimatesReviewTransactionsPayload) => void;
}>;

type TaxEstimatesProps = TaxEstimatesContextProviderProps;
declare const TaxEstimates: ({ onClickReviewTransactions: onReviewClicked }: TaxEstimatesProps) => react_jsx_runtime.JSX.Element;

interface TimeTrackingStringOverrides {
    title?: string;
}
interface TimeTrackingProps {
    showTitle?: boolean;
    onReportsClick?: () => void;
    stringOverrides?: TimeTrackingStringOverrides;
}
declare const TimeTracking: ({ showTitle, onReportsClick, stringOverrides }: TimeTrackingProps) => react_jsx_runtime.JSX.Element;

type UnifiedReportsInitialState = {
    reportKey?: string;
};

type UnifiedReportNavigationVariant = 'sidebar' | 'menu';

type UnifiedReportProps = {
    dateSelectionMode?: DateSelectionMode;
    navigationVariant?: UnifiedReportNavigationVariant;
    showTitle?: boolean;
    /** Report to land on instead of the server default; applied once, when the report configuration loads. */
    initialState?: UnifiedReportsInitialState;
};
declare const UnifiedReports: ({ dateSelectionMode, navigationVariant, showTitle, initialState }: UnifiedReportProps) => react_jsx_runtime.JSX.Element;

type LayerContextShape = LayerContextValues & LayerContextHelpers & LayerContextDateRange;
declare const useLayerContext: () => LayerContextShape;

declare enum SupportedLocale {
    enUS = "en-US",
    frCA = "fr-CA"
}

type Environment = 'production' | 'production-ca' | 'sandbox' | 'staging' | 'internalStaging';
type EnvironmentConfig = {
    environment: Environment;
    apiUrl: string;
    authUrl: string;
    scope: string;
    usePlaidSandbox: boolean;
};
type EnvironmentConfigOverride = Omit<EnvironmentConfig, 'usePlaidSandbox'>;

type EventCallbacks = {
    onEvent?: (event: LayerEvent) => void;
    onTransactionCategorized?: () => void;
    onTransactionsFetched?: () => void;
};
type BaseLayerProviderProps = {
    businessId: string;
    appId?: string;
    appSecret?: string;
    businessAccessToken?: string;
    locale?: SupportedLocale;
    theme?: LayerThemeConfig;
    usePlaidSandbox?: boolean;
    onError?: (error: LayerError) => void;
    eventCallbacks?: EventCallbacks;
};
type LayerProviderPropsWithLayerEnv = BaseLayerProviderProps & {
    environment?: Environment;
};
type LayerProviderPropsWithEnvironmentConfigOverride = BaseLayerProviderProps & {
    environmentConfigOverride?: EnvironmentConfigOverride;
};
type LayerProviderProps = LayerProviderPropsWithLayerEnv | LayerProviderPropsWithEnvironmentConfigOverride;
declare const LayerProvider: ({ appId, appSecret, businessAccessToken, locale, usePlaidSandbox, ...restProps }: PropsWithChildren<LayerProviderProps>) => react_jsx_runtime.JSX.Element;

export { AccountingOverview, BalanceSheet, BankTransactions, BankTransactionsWithLinkedAccounts, BookkeepingOverview, ChartOfAccounts, Direction, DisplayState, EntityName, GeneralLedgerView, GlobalDateRangeSelection, GlobalMonthPicker, Invoices, Journal, LandingPage, LayerEventComponent, LayerEventType, LayerProvider, LinkAccounts, LinkedAccounts, MileageSummaryCard, MileageTracking, ProfitAndLoss, Reports, SolopreneurOverview, StatementOfCashFlow, SupportedLocale, Tasks, TaxEstimates, TimeTracking, UnifiedReports, useLayerContext };
export type { EventCallbacks, LayerEvent, LinkingMetadata };