@tesouro/embedded-components-react 0.2.1

package/dist/index.d.ts

@@ -0,0 +1,3119 @@
+import * as React from 'react';
+import { ComponentType, AnchorHTMLAttributes, ReactNode, PropsWithChildren, ErrorInfo, ReactElement } from 'react';
+import { FallbackProps } from 'react-error-boundary';
+import { SortingState, OnChangeFn } from '@tanstack/react-table';
+
+interface Labels$6 {
+    backButton: string;
+    editButton: string;
+    editTitle: string;
+    editDescription: string;
+    nicknameLabel: string;
+    referenceLabel: string;
+    cancelButton: string;
+    saveButton: string;
+    loadingLabel: string;
+    errorTitle: string;
+    editErrorTitle: string;
+    summaryTab: string;
+    transactionsTab: string;
+    transfersTab: string;
+    emptyTransactions: string;
+    emptyTransfers: string;
+    descriptionColumn: string;
+    dateColumn: string;
+    amountColumn: string;
+    balanceColumn: string;
+    routeColumn: string;
+    statusColumn: string;
+}
+
+interface FeatureLabels$6 {
+    accountFallback: string;
+    accountNumberLabel: string;
+    routingNumberLabel: string;
+    referenceLabel: string;
+    createdLabel: string;
+    balanceLabel: string;
+    unavailableLabel: string;
+    routeSeparator: string;
+}
+
+interface AccountDetailsWidgetProps {
+    accountId: string;
+    onBack: () => void;
+    labels?: Partial<Labels$6>;
+    featureLabels?: Partial<FeatureLabels$6>;
+}
+declare function AccountDetailsWidget({ accountId, onBack, labels, featureLabels: featureLabelOverrides, }: AccountDetailsWidgetProps): React.JSX.Element;
+
+interface Labels$5 {
+    title: string;
+    description: string;
+    totalBalanceLabel: string;
+    createButton: string;
+    createTitle: string;
+    createDescription: string;
+    nicknameLabel: string;
+    referenceLabel: string;
+    cancelButton: string;
+    submitButton: string;
+    loadingLabel: string;
+    errorTitle: string;
+    createErrorTitle: string;
+    emptyTitle: string;
+    emptyDescription: string;
+    accountColumn: string;
+    balanceColumn: string;
+    statusColumn: string;
+    detailsButton: string;
+}
+
+type AuthToken = string | undefined;
+interface Auth {
+    /**
+     * Which part of the request do we use to send the auth?
+     *
+     * @default 'header'
+     */
+    in?: 'header' | 'query' | 'cookie';
+    /**
+     * A unique identifier for the security scheme.
+     *
+     * Defined only when there are multiple security schemes whose `Auth`
+     * shape would otherwise be identical.
+     */
+    key?: string;
+    /**
+     * Header or query parameter name.
+     *
+     * @default 'Authorization'
+     */
+    name?: string;
+    scheme?: 'basic' | 'bearer';
+    type: 'apiKey' | 'http';
+}
+
+interface SerializerOptions<T> {
+    /**
+     * @default true
+     */
+    explode: boolean;
+    style: T;
+}
+type ArrayStyle = 'form' | 'spaceDelimited' | 'pipeDelimited';
+type ObjectStyle = 'form' | 'deepObject';
+
+type QuerySerializer = (query: Record<string, unknown>) => string;
+type BodySerializer = (body: unknown) => unknown;
+type QuerySerializerOptionsObject = {
+    allowReserved?: boolean;
+    array?: Partial<SerializerOptions<ArrayStyle>>;
+    object?: Partial<SerializerOptions<ObjectStyle>>;
+};
+type QuerySerializerOptions = QuerySerializerOptionsObject & {
+    /**
+     * Per-parameter serialization overrides. When provided, these settings
+     * override the global array/object settings for specific parameter names.
+     */
+    parameters?: Record<string, QuerySerializerOptionsObject>;
+};
+
+type HttpMethod = 'connect' | 'delete' | 'get' | 'head' | 'options' | 'patch' | 'post' | 'put' | 'trace';
+type Client$1<RequestFn = never, Config = unknown, MethodFn = never, BuildUrlFn = never, SseFn = never> = {
+    /**
+     * Returns the final request URL.
+     */
+    buildUrl: BuildUrlFn;
+    getConfig: () => Config;
+    request: RequestFn;
+    setConfig: (config: Config) => Config;
+} & {
+    [K in HttpMethod]: MethodFn;
+} & ([SseFn] extends [never] ? {
+    sse?: never;
+} : {
+    sse: {
+        [K in HttpMethod]: SseFn;
+    };
+});
+interface Config$1 {
+    /**
+     * Auth token or a function returning auth token. The resolved value will be
+     * added to the request payload as defined by its `security` array.
+     */
+    auth?: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken;
+    /**
+     * A function for serializing request body parameter. By default,
+     * {@link JSON.stringify()} will be used.
+     */
+    bodySerializer?: BodySerializer | null;
+    /**
+     * An object containing any HTTP headers that you want to pre-populate your
+     * `Headers` object with.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/Headers/Headers#init See more}
+     */
+    headers?: RequestInit['headers'] | Record<string, string | number | boolean | (string | number | boolean)[] | null | undefined | unknown>;
+    /**
+     * The request method.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/fetch#method See more}
+     */
+    method?: Uppercase<HttpMethod>;
+    /**
+     * A function for serializing request query parameters. By default, arrays
+     * will be exploded in form style, objects will be exploded in deepObject
+     * style, and reserved characters are percent-encoded.
+     *
+     * This method will have no effect if the native `paramsSerializer()` Axios
+     * API function is used.
+     *
+     * {@link https://swagger.io/docs/specification/serialization/#query View examples}
+     */
+    querySerializer?: QuerySerializer | QuerySerializerOptions;
+    /**
+     * A function validating request data. This is useful if you want to ensure
+     * the request conforms to the desired shape, so it can be safely sent to
+     * the server.
+     */
+    requestValidator?: (data: unknown) => Promise<unknown>;
+    /**
+     * A function transforming response data before it's returned. This is useful
+     * for post-processing data, e.g., converting ISO strings into Date objects.
+     */
+    responseTransformer?: (data: unknown) => Promise<unknown>;
+    /**
+     * A function validating response data. This is useful if you want to ensure
+     * the response conforms to the desired shape, so it can be safely passed to
+     * the transformers and returned to the user.
+     */
+    responseValidator?: (data: unknown) => Promise<unknown>;
+}
+
+type ServerSentEventsOptions<TData = unknown> = Omit<RequestInit, 'method'> & Pick<Config$1, 'method' | 'responseTransformer' | 'responseValidator'> & {
+    /**
+     * Fetch API implementation. You can use this option to provide a custom
+     * fetch instance.
+     *
+     * @default globalThis.fetch
+     */
+    fetch?: typeof fetch;
+    /**
+     * Implementing clients can call request interceptors inside this hook.
+     */
+    onRequest?: (url: string, init: RequestInit) => Promise<Request>;
+    /**
+     * Callback invoked when a network or parsing error occurs during streaming.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @param error The error that occurred.
+     */
+    onSseError?: (error: unknown) => void;
+    /**
+     * Callback invoked when an event is streamed from the server.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @param event Event streamed from the server.
+     * @returns Nothing (void).
+     */
+    onSseEvent?: (event: StreamEvent<TData>) => void;
+    serializedBody?: RequestInit['body'];
+    /**
+     * Default retry delay in milliseconds.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @default 3000
+     */
+    sseDefaultRetryDelay?: number;
+    /**
+     * Maximum number of retry attempts before giving up.
+     */
+    sseMaxRetryAttempts?: number;
+    /**
+     * Maximum retry delay in milliseconds.
+     *
+     * Applies only when exponential backoff is used.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @default 30000
+     */
+    sseMaxRetryDelay?: number;
+    /**
+     * Optional sleep function for retry backoff.
+     *
+     * Defaults to using `setTimeout`.
+     */
+    sseSleepFn?: (ms: number) => Promise<void>;
+    url: string;
+};
+interface StreamEvent<TData = unknown> {
+    data: TData;
+    event?: string;
+    id?: string;
+    retry?: number;
+}
+type ServerSentEventsResult<TData = unknown, TReturn = void, TNext = unknown> = {
+    stream: AsyncGenerator<TData extends Record<string, unknown> ? TData[keyof TData] : TData, TReturn, TNext>;
+};
+
+type ErrInterceptor<Err, Res, Req, Options> = (error: Err, 
+/** response may be undefined due to a network error where no response object is produced */
+response: Res | undefined, 
+/** request may be undefined, because error may be from building the request object itself */
+request: Req | undefined, options: Options) => Err | Promise<Err>;
+type ReqInterceptor<Req, Options> = (request: Req, options: Options) => Req | Promise<Req>;
+type ResInterceptor<Res, Req, Options> = (response: Res, request: Req, options: Options) => Res | Promise<Res>;
+declare class Interceptors<Interceptor> {
+    fns: Array<Interceptor | null>;
+    clear(): void;
+    eject(id: number | Interceptor): void;
+    exists(id: number | Interceptor): boolean;
+    getInterceptorIndex(id: number | Interceptor): number;
+    update(id: number | Interceptor, fn: Interceptor): number | Interceptor | false;
+    use(fn: Interceptor): number;
+}
+interface Middleware<Req, Res, Err, Options> {
+    error: Interceptors<ErrInterceptor<Err, Res, Req, Options>>;
+    request: Interceptors<ReqInterceptor<Req, Options>>;
+    response: Interceptors<ResInterceptor<Res, Req, Options>>;
+}
+
+type ResponseStyle = 'data' | 'fields';
+interface Config<T extends ClientOptions$1 = ClientOptions$1> extends Omit<RequestInit, 'body' | 'headers' | 'method'>, Config$1 {
+    /**
+     * Base URL for all requests made by this client.
+     */
+    baseUrl?: T['baseUrl'];
+    /**
+     * Fetch API implementation. You can use this option to provide a custom
+     * fetch instance.
+     *
+     * @default globalThis.fetch
+     */
+    fetch?: typeof fetch;
+    /**
+     * Please don't use the Fetch client for Next.js applications. The `next`
+     * options won't have any effect.
+     *
+     * Install {@link https://www.npmjs.com/package/@hey-api/client-next `@hey-api/client-next`} instead.
+     */
+    next?: never;
+    /**
+     * Return the response data parsed in a specified format. By default, `auto`
+     * will infer the appropriate method from the `Content-Type` response header.
+     * You can override this behavior with any of the {@link Body} methods.
+     * Select `stream` if you don't want to parse response data at all.
+     *
+     * @default 'auto'
+     */
+    parseAs?: 'arrayBuffer' | 'auto' | 'blob' | 'formData' | 'json' | 'stream' | 'text';
+    /**
+     * Should we return only data or multiple fields (data, error, response, etc.)?
+     *
+     * @default 'fields'
+     */
+    responseStyle?: ResponseStyle;
+    /**
+     * Throw an error instead of returning it in the response?
+     *
+     * @default false
+     */
+    throwOnError?: T['throwOnError'];
+}
+interface RequestOptions<TData = unknown, TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends Config<{
+    responseStyle: TResponseStyle;
+    throwOnError: ThrowOnError;
+}>, Pick<ServerSentEventsOptions<TData>, 'onRequest' | 'onSseError' | 'onSseEvent' | 'sseDefaultRetryDelay' | 'sseMaxRetryAttempts' | 'sseMaxRetryDelay'> {
+    /**
+     * Any body that you want to add to your request.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/fetch#body}
+     */
+    body?: unknown;
+    path?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    /**
+     * Security mechanism(s) to use for the request.
+     */
+    security?: ReadonlyArray<Auth>;
+    url: Url;
+}
+interface ResolvedRequestOptions<TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends RequestOptions<unknown, TResponseStyle, ThrowOnError, Url> {
+    headers: Headers;
+    serializedBody?: string;
+}
+type RequestResult<TData = unknown, TError = unknown, ThrowOnError extends boolean = boolean, TResponseStyle extends ResponseStyle = 'fields'> = ThrowOnError extends true ? Promise<TResponseStyle extends 'data' ? TData extends Record<string, unknown> ? TData[keyof TData] : TData : {
+    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
+    request: Request;
+    response: Response;
+}> : Promise<TResponseStyle extends 'data' ? (TData extends Record<string, unknown> ? TData[keyof TData] : TData) | undefined : ({
+    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
+    error: undefined;
+} | {
+    data: undefined;
+    error: TError extends Record<string, unknown> ? TError[keyof TError] : TError;
+}) & {
+    /** request may be undefined, because error may be from building the request object itself */
+    request?: Request;
+    /** response may be undefined, because error may be from building the request object itself or from a network error */
+    response?: Response;
+}>;
+interface ClientOptions$1 {
+    baseUrl?: string;
+    responseStyle?: ResponseStyle;
+    throwOnError?: boolean;
+}
+type MethodFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+type SseFn = <TData = unknown, _TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<never, TResponseStyle, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData>>;
+type RequestFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'> & Pick<Required<RequestOptions<TData, TResponseStyle, ThrowOnError>>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+type BuildUrlFn = <TData extends {
+    body?: unknown;
+    path?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    url: string;
+}>(options: TData & Options<TData>) => string;
+type Client = Client$1<RequestFn, Config, MethodFn, BuildUrlFn, SseFn> & {
+    interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>;
+};
+interface TDataShape {
+    body?: unknown;
+    headers?: unknown;
+    path?: unknown;
+    query?: unknown;
+    url: string;
+}
+type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>;
+type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown, TResponseStyle extends ResponseStyle = 'fields'> = OmitKeys<RequestOptions<TResponse, TResponseStyle, ThrowOnError>, 'body' | 'path' | 'query' | 'url'> & ([TData] extends [never] ? unknown : Omit<TData, 'url'>);
+
+type ClientOptions = {
+    baseUrl: 'https://api.stage.tesouro.com' | 'https://api.sandbox.stage.tesouro.com' | 'https://api.stage.business-banking.app' | 'https://api.tesouro.com' | 'https://api.sandbox.tesouro.com' | 'https://api.business-banking.app' | (string & {});
+};
+type OrganizationType = 'BANK' | 'EMBEDDED' | 'PLATFORM' | 'TRANSACTOR' | 'VERTICAL_SOFTWARE_PROVIDER';
+type WidgetInitResponse = {
+    bankName?: null | string;
+    organizationId?: null | string;
+    organizationTypes?: null | Array<OrganizationType>;
+    scopes: Array<string>;
+    status?: WidgetUserStatus;
+    userId?: null | string;
+    vspName?: null | string;
+};
+type WidgetUserStatus = 'ACTIVE' | 'INACTIVE' | 'INVITED' | 'NOT_FOUND';
+
+type EmbeddedClient = Client;
+type ExtractLiterals<T> = T extends string ? string extends T ? never : T : never;
+type BaseUrl = ExtractLiterals<ClientOptions['baseUrl']>;
+/**
+ * Returns a new {@link EmbeddedClient} that is a shallow clone of `source`:
+ * same config, and all existing interceptors copied in their original order.
+ *
+ * Use this inside a `configClient` callback when you want to add interceptors
+ * without mutating the client instance that was passed in.
+ *
+ * @example
+ * ```ts
+ * const addLogging = useCallback((client: EmbeddedClient) => {
+ *   const cloned = cloneEmbeddedClient(client);
+ *   cloned.interceptors.request.use((req) => {
+ *     console.log('[widget]', req.method, req.url);
+ *     return req;
+ *   });
+ *   return cloned;
+ * }, []);
+ * ```
+ */
+declare function cloneEmbeddedClient(source: EmbeddedClient): EmbeddedClient;
+
+type LinkComponentProps = AnchorHTMLAttributes<HTMLAnchorElement> & {
+    children?: ReactNode;
+};
+type LinkComponent = ComponentType<LinkComponentProps>;
+/**
+ * The UI frameworks a widget's UI layer can render with.
+ *
+ * - `shadcn` — the shadcn/Tailwind implementation. This is the default and the
+ *   implicit fallback, so existing consumers that select nothing keep rendering
+ *   shadcn.
+ * - `tecton` — the Tecton implementation.
+ *
+ * Declared as an `as const` object (not a TypeScript `enum`) per repo
+ * convention.
+ */
+declare const UIFramework: {
+    readonly Shadcn: "shadcn";
+    readonly Tecton: "tecton";
+};
+type UIFramework = (typeof UIFramework)[keyof typeof UIFramework];
+
+/**
+ * A renderer is just a component that accepts the widget's public props. The
+ * registry is keyed by a stable widget id (e.g. `'help-widget'`), so a single
+ * extension can register implementations for many widgets at once.
+ */
+type AnyRenderer = ComponentType<any>;
+type RendererMap = Record<string, AnyRenderer>;
+/** A framework's design-system bootstrap (idempotent, SSR-safe). */
+type DesignSystemEnsurer = () => Promise<void>;
+/**
+ * Registers UI renderers for a framework. Called by an extension package (never
+ * by core) to make its implementations resolvable by the widget switches.
+ *
+ * Idempotent and additive: later calls merge into any existing map for the
+ * framework, so multiple extensions (or repeated calls) compose rather than
+ * clobber. Notifies mounted switches via `useSyncExternalStore`.
+ *
+ * @param framework - The framework these renderers implement (e.g. `'tecton'`).
+ * @param map - Widget-id → component for that framework's surface.
+ */
+declare function registerUIRenderers(framework: UIFramework, map: RendererMap): void;
+/**
+ * Registers a framework's design-system bootstrap (e.g. Tecton's
+ * `ensureTectonDesignSystem`). Called by an extension; core invokes the
+ * registered ensurer from its provider cascade when the resolved framework
+ * matches. No-op resolution (undefined) means the extension is absent — core
+ * simply does not bootstrap any non-shadcn design system.
+ *
+ * @param framework - The framework this ensurer bootstraps.
+ * @param ensurer - Idempotent, SSR-safe bootstrap returning a `Promise`.
+ */
+declare function registerDesignSystemEnsurer(framework: UIFramework, ensurer: DesignSystemEnsurer): void;
+
+/**
+ * The implementation a widget renders with.
+ *
+ * - `native` — the Tesouro-native implementation. This is the default and the
+ *   implicit fallback, so consumers that select nothing keep rendering native.
+ * - `monite` — the Monite SDK implementation.
+ *
+ * Declared as an `as const` object (not a TypeScript `enum`) per repo
+ * convention.
+ */
+declare const Implementation: {
+    readonly Native: "native";
+    readonly Monite: "monite";
+};
+type Implementation = (typeof Implementation)[keyof typeof Implementation];
+/**
+ * The settable fields of the widget config cascade.
+ *
+ * This is the type accepted by {@link setGlobalWidgetConfig} and all provider props.
+ * It intentionally excludes `initResponse`, which is populated automatically by the
+ * provider after a successful fetch and must never be set manually.
+ *
+ * The `null` vs `undefined` distinction on `widgetToken` and `organizationId` is intentional:
+ * - `undefined` — not set at this level; inherit from the nearest ancestor or global store.
+ * - `null` — explicitly cleared; downstream sees "no value" even if an ancestor had one
+ *   (e.g. after logout or deliberate de-scoping).
+ *
+ * @see {@link WidgetConfig} for the resolved output type (includes `initResponse`)
+ * @see {@link RootWidgetProvider}
+ * @see {@link WidgetProvider}
+ * @see {@link setGlobalWidgetConfig}
+ */
+interface WidgetConfigInput {
+    /**
+     * Base URL of the Tesouro embedded API (e.g. `"https://api.tesouro.com"`).
+     *
+     * When omitted the nearest ancestor's `baseUrl` or the global store value is used.
+     * Changing this recreates the underlying HTTP client so all subsequent requests
+     * go to the new host.
+     */
+    baseUrl?: BaseUrl;
+    /**
+     * Bearer token used to authenticate widget requests.
+     *
+     * Injected as `Authorization: Bearer <token>` on every outgoing request via an
+     * interceptor on the scoped HTTP client. Token updates are picked up immediately
+     * without recreating the client.
+     *
+     * - `string` — send this token on all requests from this level downward.
+     * - `null` — explicitly cleared; no auth header is sent and fetching is suppressed.
+     * - `undefined` — not set at this level; inherit from the nearest ancestor or global store.
+     */
+    widgetToken?: string | null;
+    /**
+     * Organization ID forwarded as the `x-organization-id` request header.
+     *
+     * Passed through {@link EmbedApiProvider} context rather than the auth interceptor,
+     * so individual data-access hooks can opt in per-request.
+     *
+     * - `string` — use this organization for downstream data requests.
+     * - `null` — explicitly cleared; queries that require an org ID will be disabled.
+     * - `undefined` — not set at this level; inherit from the nearest ancestor or global store.
+     *
+     * When `undefined` across the **whole** cascade (no prop, no ancestor, no global
+     * value), the resolved org defaults to the loaded `initResponse.organizationId`
+     * (see {@link WidgetConfig.initResponse}) once the widget-init fetch settles. This
+     * is the lowest-priority fallback — any explicit `string` or `null` at any cascade
+     * level wins, and an explicit `null` is preserved and never falls back.
+     *
+     * Only an **explicit** ancestor org is inherited. An ancestor's *init-derived*
+     * default does not propagate into a descendant that owns its own fetch (its own
+     * `baseUrl`/`widgetToken`); such a descendant defaults to its own
+     * `initResponse.organizationId` instead, so it never sends an ancestor's org with
+     * its own token.
+     */
+    organizationId?: string | null;
+    /**
+     * Optional post-creation hook for the scoped HTTP client.
+     *
+     * Called once after the provider creates its scoped {@link EmbeddedClient} and
+     * applies the built-in `Authorization: Bearer` interceptor. Receives the
+     * fully-configured client and must return the client to be used for the lifetime of
+     * this provider level — either the same instance (with additional interceptors
+     * attached) or a new client entirely.
+     *
+     * **Order:** The built-in auth interceptor is always applied first. `configClient`
+     * is called on top of it, so any interceptors you add here run after auth is set.
+     *
+     * **Any prop triggers a scoped client.** A {@link WidgetProvider} creates its own
+     * scoped client whenever any prop is set — including `configClient` alone, without
+     * `baseUrl` or `widgetToken`. Only a fully props-free pass-through provider skips
+     * client creation and never calls this function.
+     *
+     * **Stability:** The function reference is included in the client creation memo's
+     * dependency array. Passing an unstable (inline) function recreates the client on
+     * every render. Stabilize with `useCallback` or define the function outside the
+     * component.
+     *
+     * **Cascade:** Inherits from the nearest ancestor when `undefined`. A child
+     * {@link WidgetProvider} that creates its own scoped client will use the resolved
+     * `configClient` from the cascade unless it provides its own override.
+     *
+     * @example
+     * ```tsx
+     * const addLogging = useCallback(
+     *   (client: EmbeddedClient) => {
+     *     client.interceptors.request.use((req) => {
+     *       console.log('[widget]', req.method, req.url);
+     *       return req;
+     *     });
+     *     return client;
+     *   },
+     *   [],
+     * );
+     *
+     * <RootWidgetProvider
+     *   baseUrl="https://api.tesouro.com"
+     *   widgetToken={token}
+     *   configClient={addLogging}
+     * >
+     *   <App />
+     * </RootWidgetProvider>
+     * ```
+     */
+    configClient?: (client: EmbeddedClient) => EmbeddedClient;
+    /**
+     * Component the embedded widgets should render in place of plain `<a>` tags.
+     *
+     * Pass e.g. Next.js's `Link` to make in-app navigation use the host router.
+     * Cascades like other config: provider prop > nearest ancestor > global store.
+     * When no value is set anywhere, widgets fall back to a plain `<a>` element.
+     */
+    linkComponent?: LinkComponent;
+    /**
+     * Which UI framework the widget UI layer should render with.
+     *
+     * Lets a consuming context bind widgets to either the shadcn/Tailwind or the
+     * Tecton implementation behind the same outward-facing API. The selection is
+     * a presentation concern only — it cascades through the provider tree exactly
+     * like {@link linkComponent} and is read by UI libraries via `useUIFramework`;
+     * it never appears in any widget's feature-library or component props.
+     *
+     * - `'shadcn'` — the shadcn/Tailwind implementation.
+     * - `'tecton'` — the Tecton implementation.
+     * - `null` / `undefined` — not set at this level; inherit from the nearest
+     *   ancestor or global store, falling back to `shadcn` when unset everywhere.
+     *   `shadcn` is the implicit default, so existing consumers need no changes.
+     */
+    uiFramework?: UIFramework | null;
+    /**
+     * Which implementation a widget renders with.
+     *
+     * Lets a consuming context bind widgets to either the Tesouro-native or the
+     * Monite SDK implementation behind the same outward-facing API. It cascades
+     * through the provider tree exactly like {@link linkComponent} and
+     * {@link uiFramework} — provider prop > nearest ancestor > global store — and
+     * is read via `useImplementation`.
+     *
+     * - `'native'` — the Tesouro-native implementation.
+     * - `'monite'` — the Monite SDK implementation.
+     * - `null` / `undefined` — not set at this level; inherit from the nearest
+     *   ancestor or global store, falling back to `native` when unset everywhere.
+     *   `native` is the implicit default, so existing consumers need no changes.
+     */
+    implementation?: Implementation | null;
+}
+/**
+ * Props shared by every analytics-owner-capable widget provider.
+ *
+ * Combines the full settable cascade ({@link WidgetConfigInput}) with the
+ * analytics opt-out honored by analytics owners. Both {@link RootWidgetProvider}
+ * and {@link WidgetProvider} build their public props on top of this; the latter
+ * adds error-boundary props of its own.
+ *
+ * @see {@link WidgetConfigInput} for per-field cascade and `null` vs omitted semantics
+ */
+interface WidgetProviderBaseProps extends WidgetConfigInput {
+    /**
+     * Opt out of all analytics capture and prevent PostHog from loading. Default `true`.
+     *
+     * Honored only by an analytics **owner** — a {@link RootWidgetProvider} or a
+     * standalone {@link WidgetProvider} with no parent provider. When `false`,
+     * owner-bound `track` calls in this subtree become no-ops and the PostHog
+     * installer is never dynamically imported for this owner's environment.
+     * Setting it on a nested {@link WidgetProvider} is ignored in v1 (a one-time
+     * `console.warn` is emitted to make the no-op discoverable).
+     */
+    analytics?: boolean;
+}
+/**
+ * The fully-resolved widget config at a given provider level.
+ *
+ * Extends {@link WidgetConfigInput} with `initResponse`, which is populated automatically
+ * after a successful `GET /api/widget-gateway/init` fetch. This type is returned by
+ * {@link useWidgetConfig} and represents the cascade result — it is never an input type.
+ *
+ * `initResponse` cascades as a **whole object** — it is either present (a fetch succeeded
+ * at some level in the tree) or absent (`undefined`). Fields are never merged across levels.
+ * It is cleared immediately when `widgetToken` or `baseUrl` changes to prevent stale tenant
+ * data from persisting across auth boundaries.
+ *
+ * @see {@link WidgetConfigInput} for the input type accepted by providers and setGlobalWidgetConfig
+ * @see {@link useWidgetConfig}
+ */
+interface WidgetConfig extends WidgetConfigInput {
+    /**
+     * The response from `GET /api/widget-gateway/init` for this level of the tree.
+     *
+     * Read-only — populated automatically by the provider. Use {@link useWidgetConfig}
+     * to access it; do not attempt to set this field via {@link setGlobalWidgetConfig}
+     * or provider props (those accept {@link WidgetConfigInput}, which excludes this field).
+     *
+     * Its `organizationId` also seeds the resolved {@link WidgetConfigInput.organizationId}
+     * when the org is unset across the whole cascade.
+     */
+    initResponse?: WidgetInitResponse;
+}
+
+/**
+ * Replaces the global widget config and notifies all reactive subscribers.
+ *
+ * Designed for non-React entry points — web component hosts, imperative SDKs, or any
+ * code outside the React tree — that need to push configuration into mounted widgets
+ * before or after they render. Any mounted {@link RootWidgetProvider} or component
+ * calling {@link useWidgetConfig} outside a provider re-renders automatically via
+ * `useSyncExternalStore`.
+ *
+ * **Priority**: The global store is the lowest-priority fallback. Any prop passed
+ * directly to a {@link RootWidgetProvider} or {@link WidgetProvider} overrides it.
+ *
+ * @param config - The new global config. **Replaces** the previous value entirely;
+ *   fields absent from `config` revert to `undefined` on the next read.
+ *
+ * @example
+ * ```ts
+ * // Web component attribute-change handler — outside the React tree
+ * setGlobalWidgetConfig({
+ *   baseUrl: 'https://api.tesouro.com',
+ *   widgetToken: tokenFromHost,
+ * });
+ * ```
+ *
+ * @see {@link getGlobalWidgetConfig} for a synchronous non-reactive read
+ * @see {@link RootWidgetProvider} for the React provider that subscribes to this store
+ */
+declare function setGlobalWidgetConfig(config: WidgetConfigInput): void;
+/**
+ * Merges a partial widget config into the global store and notifies subscribers.
+ *
+ * Unlike {@link setGlobalWidgetConfig}, this does **not** wipe untouched fields:
+ * keys absent from `patch` are preserved. Keys explicitly present in `patch` —
+ * including those set to `undefined` or `null` — overwrite. Use this when you
+ * have a single field to update (most commonly a freshly fetched
+ * `widgetToken`) without disturbing the rest of the global config.
+ *
+ * @param patch - The fields to merge into the existing global config. Omitted
+ *   keys are preserved; explicitly present keys replace their counterparts.
+ *
+ * @example
+ * ```ts
+ * setGlobalWidgetConfig({ baseUrl: 'https://api.tesouro.com', widgetToken: 'a' });
+ * updateGlobalWidgetConfig({ widgetToken: 'b' });
+ * // baseUrl is still 'https://api.tesouro.com'
+ * ```
+ *
+ * @see {@link setGlobalWidgetConfig} for the replace-all variant
+ */
+declare function updateGlobalWidgetConfig(patch: WidgetConfigInput): void;
+/**
+ * Returns the current global widget config synchronously without subscribing to changes.
+ *
+ * Use this in non-React contexts such as event handlers or imperative callbacks where
+ * you need a one-off read. For reactive reads inside React components use
+ * {@link useWidgetConfig} instead.
+ *
+ * @returns The current {@link WidgetConfig} from the global store. The object is
+ *   replaced (not mutated) on each {@link setGlobalWidgetConfig} call — do not
+ *   cache the return value across renders or async boundaries.
+ *
+ * @see {@link setGlobalWidgetConfig} to write to the global store
+ * @see {@link useWidgetConfig} for a reactive React hook alternative
+ */
+declare function getGlobalWidgetConfig(): WidgetConfigInput;
+
+/**
+ * Props for {@link RootWidgetProvider}.
+ *
+ * All fields are optional and come from {@link WidgetProviderBaseProps}. When a
+ * field is omitted the global store value (set via {@link setGlobalWidgetConfig})
+ * is used as a reactive fallback. See {@link WidgetConfigInput} for per-field
+ * cascade and `null` vs omitted semantics.
+ */
+type RootWidgetProviderProps = WidgetProviderBaseProps;
+/**
+ * Top-level provider for the widget config cascade.
+ *
+ * Place this **once** near the root of your React tree. It:
+ * - Resolves `baseUrl`, `widgetToken`, and `organizationId` from its own props,
+ *   falling back to the global store (see {@link setGlobalWidgetConfig}) for any
+ *   prop that is `undefined`.
+ * - Calls `GET /api/widget-gateway/init` whenever both `baseUrl` and `widgetToken`
+ *   resolve to a non-null value. The response is stored as `initResponse` and made
+ *   available to every descendant via {@link useWidgetConfig}.
+ * - Creates a stable `QueryClient` once on mount and provides it via
+ *   `QueryClientProvider` for the entire subtree.
+ * - Creates a scoped `@hey-api` HTTP client configured for `baseUrl`. The
+ *   `Authorization: Bearer` header is kept current via a ref-based interceptor so
+ *   token rotation never recreates the client.
+ * - Provides `QueryClientProvider`, {@link EmbedApiProvider}, and `WidgetContext`
+ *   for the entire subtree.
+ *
+ * Reacts to {@link setGlobalWidgetConfig} calls after mount — any global change
+ * that resolves a previously missing `baseUrl` or `widgetToken` triggers a fetch.
+ *
+ * @param props.baseUrl - API base URL. Falls back to `global.baseUrl` when omitted.
+ * @param props.widgetToken - Auth token. Falls back to `global.widgetToken` when omitted.
+ * @param props.organizationId - Org ID for data requests. Falls back to `global.organizationId`,
+ *   then to the init response's `organizationId` when unset everywhere.
+ * @param props.children - The React subtree that will consume the widget context.
+ *
+ * @example
+ * ```tsx
+ * // Standard usage — one fetch for the whole tree
+ * <RootWidgetProvider
+ *   baseUrl="https://api.tesouro.com"
+ *   widgetToken={userToken}
+ * >
+ *   <App />
+ * </RootWidgetProvider>
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Host sets the URL globally; React tree only needs the token
+ * setGlobalWidgetConfig({ baseUrl: 'https://api.tesouro.com' });
+ *
+ * <RootWidgetProvider widgetToken={token}>
+ *   <App />
+ * </RootWidgetProvider>
+ * ```
+ *
+ * @see {@link WidgetProvider} for mid-tree token or URL overrides
+ * @see {@link useWidgetConfig} to read the resolved config in descendants
+ * @see {@link setGlobalWidgetConfig} to push config imperatively from outside React
+ */
+declare function RootWidgetProvider({ children, baseUrl, widgetToken, organizationId, configClient, linkComponent, uiFramework, implementation, analytics, }: PropsWithChildren<RootWidgetProviderProps>): React.JSX.Element;
+
+/**
+ * Props for {@link WidgetProvider}.
+ *
+ * All fields are optional. When **all** are omitted the provider is a transparent
+ * pass-through: no fetch is issued and all resolved values cascade unchanged from
+ * the nearest ancestor.
+ */
+interface WidgetProviderProps extends WidgetProviderBaseProps {
+    /**
+     * Fallback rendered when a render-time exception is caught inside this
+     * provider's subtree. Pass either a `ReactNode` (rendered directly) or a
+     * render-prop receiving `{ error, resetErrorBoundary }` from
+     * `react-error-boundary`. Default is a plain `role="alert"` div with
+     * generic copy from `DEFAULT_LABELS.errorBoundaryFallback`.
+     */
+    errorFallback?: ReactNode | ((props: FallbackProps) => ReactNode);
+    /**
+     * Called once when the boundary catches an error, before the fallback
+     * renders. Use for telemetry / Sentry / partner logging. Exceptions
+     * thrown from `onError` propagate per `react-error-boundary` semantics.
+     */
+    onError?: (error: unknown, info: ErrorInfo) => void;
+}
+/**
+ * Mid-tree cascading provider for widget config.
+ *
+ * Inherits all resolved values from the nearest ancestor provider (or the global
+ * store when no ancestor exists). Only issues a fetch when at least one of `baseUrl`
+ * or `widgetToken` is explicitly set here, to avoid duplicating the root fetch.
+ *
+ * **Pass-through mode** (no props): transparent wrapper — no fetch, no new HTTP client,
+ * all values cascade from the parent unchanged. `refetch`, `loading`, and `error`
+ * all bubble up to the nearest fetch-owning ancestor automatically.
+ *
+ * **Fetch mode** (at least one of `baseUrl` or `widgetToken` explicitly set): issues
+ * its own `GET /api/widget-gateway/init` and makes the response available to its
+ * subtree, shadowing the parent's `initResponse`. Creates a scoped HTTP client with
+ * its own auth interceptor. Re-fetching keeps the previous `initResponse` visible
+ * until the new response arrives (no cross-tenant flash).
+ *
+ * **Standalone / web-component mode** (no {@link RootWidgetProvider} ancestor):
+ * behaves identically to a root — creates its own `QueryClient`, HTTP client, and
+ * {@link EmbedApiProvider}, and fetches as soon as `widgetToken` is available.
+ *
+ * @param props.baseUrl - API base URL override for this subtree.
+ * @param props.widgetToken - Auth token override for this subtree.
+ * @param props.organizationId - Org ID override for this subtree. Inherits the parent's
+ *   org when omitted, then defaults to this level's init-response `organizationId` when
+ *   the whole cascade is unset (an ancestor's explicit org wins over the init-response org).
+ * @param props.children - The React subtree that will consume the overridden context.
+ *
+ * @example
+ * ```tsx
+ * // Pass-through — no fetch, inherits everything from the parent
+ * <WidgetProvider>
+ *   <SomeWidget />
+ * </WidgetProvider>
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Token override — fetches with the partner token; parent tree is unaffected
+ * <RootWidgetProvider baseUrl={API_URL} widgetToken={platformToken}>
+ *   <MainContent />
+ *   <WidgetProvider widgetToken={partnerToken}>
+ *     <PartnerWidget /> {/* sees partner initResponse *\/}
+ *   </WidgetProvider>
+ * </RootWidgetProvider>
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Standalone web component — no RootWidgetProvider needed
+ * function MyWidget({ token }: { token: string }) {
+ *   return (
+ *     <WidgetProvider baseUrl="https://api.tesouro.com" widgetToken={token}>
+ *       <WidgetContent />
+ *     </WidgetProvider>
+ *   );
+ * }
+ * ```
+ *
+ * @see {@link RootWidgetProvider} for the dedicated root-level variant
+ * @see {@link useWidgetConfig} to read the resolved config in descendants
+ * @see {@link useRefetchWidget} to manually re-trigger the fetch
+ */
+declare function WidgetProvider({ children, baseUrl, widgetToken, organizationId, configClient, linkComponent, uiFramework, implementation, errorFallback, onError, analytics, }: PropsWithChildren<WidgetProviderProps>): React.JSX.Element;
+
+declare const USStateAbbreviation: {
+    readonly Alabama: "AL";
+    readonly Alaska: "AK";
+    readonly Arizona: "AZ";
+    readonly Arkansas: "AR";
+    readonly California: "CA";
+    readonly Colorado: "CO";
+    readonly Connecticut: "CT";
+    readonly Delaware: "DE";
+    readonly DistrictOfColumbia: "DC";
+    readonly Florida: "FL";
+    readonly Georgia: "GA";
+    readonly Hawaii: "HI";
+    readonly Idaho: "ID";
+    readonly Illinois: "IL";
+    readonly Indiana: "IN";
+    readonly Iowa: "IA";
+    readonly Kansas: "KS";
+    readonly Kentucky: "KY";
+    readonly Louisiana: "LA";
+    readonly Maine: "ME";
+    readonly Maryland: "MD";
+    readonly Massachusetts: "MA";
+    readonly Michigan: "MI";
+    readonly Minnesota: "MN";
+    readonly Mississippi: "MS";
+    readonly Missouri: "MO";
+    readonly Montana: "MT";
+    readonly Nebraska: "NE";
+    readonly Nevada: "NV";
+    readonly NewHampshire: "NH";
+    readonly NewJersey: "NJ";
+    readonly NewMexico: "NM";
+    readonly NewYork: "NY";
+    readonly NorthCarolina: "NC";
+    readonly NorthDakota: "ND";
+    readonly Ohio: "OH";
+    readonly Oklahoma: "OK";
+    readonly Oregon: "OR";
+    readonly Pennsylvania: "PA";
+    readonly RhodeIsland: "RI";
+    readonly SouthCarolina: "SC";
+    readonly SouthDakota: "SD";
+    readonly Tennessee: "TN";
+    readonly Texas: "TX";
+    readonly Utah: "UT";
+    readonly Vermont: "VT";
+    readonly Virginia: "VA";
+    readonly Washington: "WA";
+    readonly WestVirginia: "WV";
+    readonly Wisconsin: "WI";
+    readonly Wyoming: "WY";
+};
+type USStateAbbreviation = (typeof USStateAbbreviation)[keyof typeof USStateAbbreviation];
+
+type WidgetTokenFetcher = () => Promise<{
+    widgetToken: string;
+    exp?: number;
+}>;
+type WidgetTokenState = {
+    status: 'loading';
+} | {
+    status: 'ready';
+    widgetToken: string;
+    exp?: number;
+    isRefreshing: boolean;
+    lastError?: unknown;
+} | {
+    status: 'error';
+    error: unknown;
+};
+interface WidgetTokenManager {
+    start(): void;
+    stop(): void;
+    refresh(): Promise<void>;
+    getState(): WidgetTokenState;
+    subscribe(listener: () => void): () => void;
+}
+
+interface WidgetTokenRefreshProviderProps {
+    fetcher: WidgetTokenFetcher;
+    leadSeconds?: number;
+    onToken?: (widgetToken: string) => void;
+}
+declare function WidgetTokenRefreshProvider({ fetcher, leadSeconds, onToken, children, }: PropsWithChildren<WidgetTokenRefreshProviderProps>): React.JSX.Element;
+
+type RefreshingRootWidgetProviderProps = Omit<RootWidgetProviderProps, 'widgetToken'> & WidgetTokenRefreshProviderProps;
+/**
+ * One-stop provider that bundles {@link WidgetTokenRefreshProvider} and
+ * {@link RootWidgetProvider} so callers don't have to wire `useWidgetToken()`
+ * into the `widgetToken` prop themselves. Takes every `RootWidgetProvider`
+ * prop *except* `widgetToken` (which is managed by the internal token
+ * refresh manager) plus the refresh provider's `fetcher` / `leadSeconds` /
+ * `onToken`.
+ *
+ * While the manager is `loading` or `error`, this passes `widgetToken={null}`
+ * to `RootWidgetProvider`, deferring the init fetch until a valid token is
+ * available. Once `ready`, it passes the live `state.widgetToken` through.
+ *
+ * Children render inside both providers' contexts, so `useWidgetToken()` and
+ * `useWidgetConfig()` both work in descendants — useful for status badges,
+ * retry buttons, etc.
+ *
+ * @example
+ * ```tsx
+ * <RefreshingRootWidgetProvider
+ *   baseUrl="https://api.tesouro.com"
+ *   fetcher={async () => {
+ *     const res = await fetch('/api/widget-token').then((r) => r.json());
+ *     return { widgetToken: res.token, exp: res.exp };
+ *   }}
+ * >
+ *   <App />
+ * </RefreshingRootWidgetProvider>
+ * ```
+ */
+declare function RefreshingRootWidgetProvider({ fetcher, leadSeconds, onToken, children, ...rootProps }: PropsWithChildren<RefreshingRootWidgetProviderProps>): React.JSX.Element;
+
+/**
+ * Returns the fully-resolved {@link WidgetConfig} for the nearest provider level.
+ *
+ * Reads from the nearest `WidgetContext` ancestor (set by {@link RootWidgetProvider}
+ * or {@link WidgetProvider}) and falls back to the global store when called outside
+ * any provider. Subscribes to {@link setGlobalWidgetConfig} calls reactively via
+ * `useSyncExternalStore`.
+ *
+ * **Cascade priority** (highest to lowest):
+ * 1. Nearest `WidgetProvider` / `RootWidgetProvider` own prop
+ * 2. Global store (`setGlobalWidgetConfig`)
+ *
+ * @returns The resolved {@link WidgetConfig} at the nearest provider level. All fields
+ *   may be `undefined` if no values have been provided at any level. `initResponse` is
+ *   `undefined` until the first successful fetch completes.
+ *
+ * @example
+ * ```tsx
+ * function BankNameBadge() {
+ *   const { initResponse } = useWidgetConfig();
+ *   if (!initResponse) return <Skeleton />;
+ *   return <span>{initResponse.bankName}</span>;
+ * }
+ * ```
+ *
+ * @see {@link useWidgetLoading} to check whether a fetch is currently in progress
+ * @see {@link useWidgetError} to check whether the last fetch failed
+ * @see {@link useOwnWidgetConfig} to read only what the *current* level contributed
+ */
+declare function useWidgetConfig(): WidgetConfig;
+/**
+ * Returns only the {@link WidgetConfig} fields explicitly set at the **current**
+ * provider level, without inheriting from ancestors.
+ *
+ * Useful for debugging or conditional logic that needs to distinguish "set here"
+ * from "inherited from parent". Fields not explicitly set at this level are
+ * `undefined` even if a parent has a value.
+ *
+ * Does **not** subscribe to the global store — use {@link useWidgetConfig} if you
+ * need the fully-resolved (cascaded) config.
+ *
+ * @returns The partial {@link WidgetConfig} owned by the nearest provider, or `null`
+ *   when called outside any provider context.
+ *
+ * @example
+ * ```tsx
+ * function DebugLayer() {
+ *   const own = useOwnWidgetConfig();
+ *   // e.g. { baseUrl: undefined, widgetToken: 'tok_partner', organizationId: undefined }
+ *   // — only widgetToken was set at this provider level
+ *   console.log('own config at this level:', own);
+ *   return null;
+ * }
+ * ```
+ *
+ * @see {@link useWidgetConfig} to read the fully-resolved cascaded config instead
+ */
+declare function useOwnWidgetConfig(): WidgetConfigInput | null;
+/**
+ * Returns a stable callback that re-triggers the widget-init fetch at the
+ * **nearest provider level that owns a fetch**.
+ *
+ * Pass-through {@link WidgetProvider} instances (no own `baseUrl`/`widgetToken`)
+ * automatically bubble this up the tree, so the returned function always targets
+ * the correct fetch-owning ancestor regardless of nesting depth.
+ *
+ * Re-fetching keeps the current `initResponse` visible while the request is in
+ * flight — the previous data is not cleared until the new response arrives (or the
+ * fetch fails). This prevents a blank/loading flash during background refreshes.
+ * If the re-fetch fails, `initResponse` is cleared and {@link useWidgetError}
+ * returns the error.
+ *
+ * @returns A stable `() => void` function. Calling it increments an internal counter
+ *   that re-triggers the fetch effect. Returns a no-op when called outside any provider.
+ *
+ * @example
+ * ```tsx
+ * function RefreshButton() {
+ *   const refetch = useRefetchWidget();
+ *   return <button onClick={refetch}>Refresh</button>;
+ * }
+ * ```
+ *
+ * @see {@link useWidgetLoading} to show a loading indicator during the re-fetch
+ * @see {@link useWidgetError} to handle fetch failures after a re-fetch
+ */
+declare function useRefetchWidget(): () => void;
+/**
+ * Returns `true` while the nearest fetch-owning provider has a widget-init
+ * request in flight, `false` otherwise.
+ *
+ * Pass-through {@link WidgetProvider} instances (no own `baseUrl`/`widgetToken`)
+ * bubble this up automatically, so the value always reflects the owning ancestor
+ * regardless of nesting depth.
+ *
+ * `loading` transitions to `true` immediately when a fetch starts (including
+ * manual refetches) and back to `false` when the fetch settles — whether it
+ * succeeds or fails.
+ *
+ * @returns `true` during an active fetch, `false` at all other times.
+ *   Returns `false` when called outside any provider.
+ *
+ * @example
+ * ```tsx
+ * function WidgetShell() {
+ *   const loading = useWidgetLoading();
+ *   const { initResponse } = useWidgetConfig();
+ *
+ *   if (loading && !initResponse) return <Skeleton />;
+ *   if (!initResponse) return null;
+ *   return <Dashboard data={initResponse} />;
+ * }
+ * ```
+ *
+ * @see {@link useWidgetError} for fetch failure state
+ * @see {@link useRefetchWidget} to manually trigger a re-fetch
+ */
+declare function useWidgetLoading(): boolean;
+/**
+ * Returns the most recent fetch error from the nearest fetch-owning provider,
+ * or `null` when the last fetch succeeded (or no fetch has run yet).
+ *
+ * Pass-through {@link WidgetProvider} instances (no own `baseUrl`/`widgetToken`)
+ * bubble this up automatically, so the value always reflects the owning ancestor
+ * regardless of nesting depth.
+ *
+ * The error is cleared automatically when:
+ * - `widgetToken` or `baseUrl` changes (a new fetch is about to start).
+ * - A subsequent fetch succeeds.
+ *
+ * When an error is present, `initResponse` from {@link useWidgetConfig} is `undefined` —
+ * the previous response is always cleared on failure to prevent stale tenant data
+ * from persisting alongside an error state.
+ *
+ * API errors thrown by the HTTP client (4xx/5xx responses) are wrapped in a plain
+ * `Error` with `error.cause` set to the raw response body for inspection.
+ *
+ * @returns The `Error` from the last failed fetch, or `null`. Returns `null` when
+ *   called outside any provider.
+ *
+ * @example
+ * ```tsx
+ * function WidgetShell() {
+ *   const error = useWidgetError();
+ *   const { initResponse } = useWidgetConfig();
+ *   const refetch = useRefetchWidget();
+ *
+ *   if (error) return <ErrorBanner message={error.message} onRetry={refetch} />;
+ *   if (!initResponse) return <Skeleton />;
+ *   return <Dashboard data={initResponse} />;
+ * }
+ * ```
+ *
+ * @see {@link useWidgetLoading} for in-flight request status
+ * @see {@link useRefetchWidget} to retry after an error
+ */
+declare function useWidgetError(): Error | null;
+
+interface UseWidgetTokenResult {
+    state: WidgetTokenState;
+    refresh: () => Promise<void>;
+    /**
+     * Synchronously read the manager's current state without subscribing the
+     * caller to re-renders. Useful for non-React callbacks (e.g. a Monite
+     * `fetchToken` callback) that need the post-`await refresh()` token without
+     * the React render lag of `state`.
+     */
+    getState: () => WidgetTokenState;
+}
+declare function useWidgetToken(): UseWidgetTokenResult;
+
+interface FeatureLabels$5 {
+    accountFallback: string;
+    accountNumberLabel: string;
+    routingNumberLabel: string;
+    referenceLabel: string;
+    unavailableLabel: string;
+    defaultNickname: string;
+}
+
+interface BankAccountsWidgetProps extends WidgetProviderProps {
+    labels?: Partial<Labels$5>;
+    accountDetailsLabels?: Parameters<typeof AccountDetailsWidget>[0]['labels'];
+    featureLabels?: Partial<FeatureLabels$5>;
+    /**
+     * Controlled selection. Pass `null` to clear, a string to select an account.
+     * Leave undefined for uncontrolled behavior (driven by `defaultSelectedAccountId`).
+     */
+    selectedAccountId?: string | null;
+    defaultSelectedAccountId?: string | null;
+    onSelectedAccountIdChange?: (accountId: string | null) => void;
+}
+declare function BankAccountsWidget({ baseUrl, widgetToken, organizationId, configClient, linkComponent, implementation, uiFramework, errorFallback, onError, analytics, ...innerProps }: BankAccountsWidgetProps): React.JSX.Element;
+
+/**
+ * Action handlers for custom payment flows in payable operations.
+ *
+ * These handlers provide fine-grained control over payment workflows, allowing customers to:
+ * - Integrate external payment providers
+ * - Implement custom approval processes or multi-step authentication
+ * - Add specialized banking solutions or enterprise payment workflows
+ * - Control UI feedback and data refresh timing after payment completion
+ *
+ * @example Custom payment provider integration:
+ * ```typescript
+ * const onPay = (id: string, _data?: unknown, actions?: PayActionHandlers) => {
+ *   // Start custom payment flow
+ *   initiatePayment(id)
+ *     .then(() => {
+ *       // Payment successful - update SDK state and show success message
+ *       actions?.resolve({ showToast: true });
+ *     })
+ *     .catch((error) => {
+ *       // Payment failed - update SDK state and show error message
+ *       actions?.reject(error, { showToast: true });
+ *     });
+ * };
+ * ```
+ */
+type PayActionHandlers = {
+    /**
+     * Call when a custom payment flow has been successfully initiated/completed.
+     * This triggers SDK's built-in state management: refreshes payable data,
+     * payment records, and optionally displays success feedback to the user.
+     *
+     * @param options.showToast - Whether to display a success toast notification
+     */
+    resolve: (options?: {
+        showToast?: boolean;
+    }) => void;
+    /**
+     * Call when a custom payment flow failed or was cancelled by the user.
+     * This triggers SDK's built-in state management: refreshes payable data,
+     * payment records, and optionally displays error feedback to the user.
+     *
+     * @param error - Optional error details from the failed payment attempt
+     * @param options.showToast - Whether to display an error toast notification
+     */
+    reject: (error?: unknown, options?: {
+        showToast?: boolean;
+    }) => void;
+};
+
+type UsePayableDetailsProps = {
+    /**
+     * The ID of the payable
+     */
+    id?: string;
+    /** when provided it takes precedence over component settings */
+    enableGLCodes?: boolean;
+    /** when provided it makes the payable open in edit mode */
+    shouldOpenInEditMode?: boolean;
+    /**
+     * Callback function that is called when the payable is saved
+     *
+     * @param {string} id - The ID of the payable
+     *
+     * @returns {void}
+     */
+    onSaved?: (id: string) => void;
+    /**
+     * Callback function that is called when the payable is canceled
+     *
+     * @param {string} id - The ID of the payable
+     *
+     * @returns {void}
+     */
+    onCanceled?: (id: string) => void;
+    /**
+     * Callback function that is called when the payable is submitted
+     *
+     * @param {string} id - The ID of the payable
+     *
+     * @returns {void}
+     */
+    onSubmitted?: (id: string) => void;
+    /**
+     * Callback function that is called when the payable is rejected
+     *
+     * @param {string} id - The ID of the payable
+     *
+     * @returns {void}
+     */
+    onRejected?: (id: string) => void;
+    /**
+     * Callback function that is called when the payable is approved
+     *
+     * @param {string} id - The ID of the payable
+     *
+     * @returns {void}
+     */
+    onApproved?: (id: string) => void;
+    /** Callback function that is called when the payable is reopened
+     *
+     * @param {string} id - The ID of the payable
+     *
+     * @returns {void}
+     */
+    onReopened?: (id: string) => void;
+    /** Callback function that is called when the payable is deleted
+     *
+     * @param {string} id - The ID of the payable
+     *
+     * @returns {void}
+     */
+    onDeleted?: (id: string) => void;
+    /**
+     * Callback function that is called when the user press the Pay button
+     *
+     * @param {string} id - The ID of the payable
+     *
+     * @returns {void}
+     */
+    onPay?: (id: string, _data?: unknown, actions?: PayActionHandlers) => void;
+};
+
+type PayablesProps = {
+    pageTitleComponent: (children: ReactNode) => ReactNode;
+    /**
+     * Enable GL code selection for payable line items.
+     * When true, users can assign GL codes to individual line items.
+     * GL codes are fetched from the connected accounting system.
+     */
+    enableGLCodes?: boolean;
+} & Partial<Pick<UsePayableDetailsProps, 'onSaved' | 'onCanceled' | 'onSubmitted' | 'onRejected' | 'onApproved' | 'onReopened' | 'onDeleted' | 'onPay'>>;
+
+type ReceivablesProps = {
+    pageTitleComponent: (children: ReactNode) => ReactNode;
+};
+
+type ALIGN_DIALOG_TYPES = 'left' | 'right';
+declare module '@mui/material/transitions' {
+    interface TransitionProps {
+        alignDialog?: ALIGN_DIALOG_TYPES;
+    }
+}
+
+interface FinopsThemeColors {
+    primary?: string;
+    primaryForeground?: string;
+}
+interface MoniteWrapperProps {
+    finopsThemeColors?: FinopsThemeColors;
+}
+
+type MoniteRegionProviderProps = WidgetProviderProps & MoniteWrapperProps;
+
+type BillPayWidgetMoniteProps = MoniteRegionProviderProps & Omit<PayablesProps, 'pageTitleComponent'> & {
+    pageTitleComponent?: PayablesProps['pageTitleComponent'];
+};
+
+type BillPayWidgetProps = BillPayWidgetMoniteProps;
+/**
+ * BillPay widget entry point — selects the rendering implementation.
+ *
+ * BillPay is deliberately **pinned to `monite`** until the Tesouro-native
+ * (shadcn) build reaches parity (epic EMBD-2171;
+ * `docs/billpay-usification-shadcn/technical-design.md` §2). `native` is the
+ * global default across widgets, so BillPay applies its own `monite` fallback
+ * whenever *nothing* selects an implementation — this is what keeps the native
+ * build off by default.
+ *
+ * An explicit selection is still honored, whether it comes from this widget's
+ * `implementation` prop or from the provider/global cascade
+ * (`RootWidgetProvider implementation="native"`, `setGlobalWidgetConfig`). We
+ * read the *raw* cascade value (undefined when unset) rather than the resolved
+ * one so the global `native` default does not leak past the pin. The cutover is
+ * a one-line change: drop the `monite` fallback once native is at parity.
+ */
+declare function BillPayWidget({ implementation, ...props }: BillPayWidgetProps): React.JSX.Element;
+
+interface AddressFieldGroupLabels {
+    line1: string;
+    line2: string;
+    city: string;
+    state: string;
+    statePlaceholder: string;
+    postalCode: string;
+    country: string;
+    /** Fixed country display value (US-only locale in v1). */
+    countryValue: string;
+}
+interface CounterpartFormSheetLabels {
+    createTitleOrganization: string;
+    createTitleIndividual: string;
+    editTitleOrganization: string;
+    editTitleIndividual: string;
+    createTitleCustomer: string;
+    createTitleVendor: string;
+    editTitleCustomer: string;
+    editTitleVendor: string;
+    createDescriptionCustomer: string;
+    createDescriptionVendor: string;
+    customerTypeHeading: string;
+    vendorTypeHeading: string;
+    businessTypeOption: string;
+    businessTypeHint: string;
+    personTypeOption: string;
+    personTypeHint: string;
+    profileHeading: string;
+    addressHeading: string;
+    customerAddressDescription: string;
+    legalNameLabel: string;
+    businessNameLabel: string;
+    firstNameLabel: string;
+    lastNameLabel: string;
+    titleLabel: string;
+    emailLabel: string;
+    phoneLabel: string;
+    taxIdLabel: string;
+    customerTaxIdHelp: string;
+    vendorTaxIdHelp: string;
+    paymentRemindersLabel: string;
+    paymentRemindersDescription: string;
+    paymentMethodsHeading: string;
+    paymentMethodsDescription: string;
+    accountHolderNameLabel: string;
+    routingNumberLabel: string;
+    accountNumberLabel: string;
+    cancelButton: string;
+    createButton: string;
+    saveButton: string;
+    address: AddressFieldGroupLabels;
+}
+interface BankAccountFormSheetLabels {
+    createTitle: string;
+    editTitle: string;
+    nameLabel: string;
+    accountHolderNameLabel: string;
+    accountNumberLabel: string;
+    routingNumberLabel: string;
+    ibanLabel: string;
+    bicLabel: string;
+    sortCodeLabel: string;
+    currencyLabel: string;
+    currencyPlaceholder: string;
+    countryLabel: string;
+    countryValue: string;
+    isDefaultLabel: string;
+    cancelButton: string;
+    createButton: string;
+    saveButton: string;
+}
+interface AddressFormSheetLabels {
+    title: string;
+    cancelButton: string;
+    saveButton: string;
+    address: AddressFieldGroupLabels;
+}
+interface ConfirmDeleteDialogLabels {
+    confirmButton: string;
+    cancelButton: string;
+}
+
+/**
+ * Overridable validation / error messages produced by the counterparts feature
+ * layer and surfaced through each form's `errors` prop. Consumers override via
+ * the widget's `messageLabels` prop, merged over {@link COUNTERPART_MESSAGE_LABELS_EN}.
+ */
+interface CounterpartMessageLabels {
+    legalNameRequired: string;
+    firstNameRequired: string;
+    lastNameRequired: string;
+    emailRequired: string;
+    emailInvalid: string;
+    addressLine1Required: string;
+    cityRequired: string;
+    stateRequired: string;
+    postalCodeRequired: string;
+    bankAccountNameRequired: string;
+    bankAccountIdentifierRequired: string;
+    bankAccountCurrencyRequired: string;
+    routingNumberInvalid: string;
+    accountNumberInvalid: string;
+    vatIdValueRequired: string;
+    /** Shown for a non-field-specific submit failure. */
+    genericError: string;
+    /** Delete confirmation title; `{name}` is replaced with the entity name. */
+    deleteTitle: string;
+    deleteCounterpartMessage: string;
+    deleteSubEntityMessage: string;
+}
+
+/**
+ * Co-located user-facing strings for the counterparts widget UI. Each component
+ * takes a `labels?: Partial<...Labels>` prop merged over the matching
+ * `*_LABELS_EN` default, so integrators can re-label without forking the UI.
+ */
+interface CounterpartsScreenLabels {
+    customersTitle: string;
+    vendorsTitle: string;
+    createButton: string;
+    columnName: string;
+    sortByName: string;
+    columnBilledAmount: string;
+    columnReceivedAmount: string;
+    columnAmountDue: string;
+    columnTotalPaidToDate: string;
+    columnRejectedAmount: string;
+    columnBalanceDue: string;
+    columnActions: string;
+    openActionsMenu: string;
+    editAction: string;
+    deleteAction: string;
+    searchPlaceholder: string;
+    entityFilterAll: string;
+    entityFilterOrganization: string;
+    entityFilterIndividual: string;
+    customersEmptyTitle: string;
+    customersEmptyDescription: string;
+    customersEmptyAction: string;
+    vendorsEmptyTitle: string;
+    vendorsEmptyDescription: string;
+    vendorsEmptyAction: string;
+    customersFilterEmptyTitle: string;
+    vendorsFilterEmptyTitle: string;
+    filterEmptyDescription: string;
+    errorTitle: string;
+    errorDescription: string;
+    errorRetry: string;
+    accessRestrictedTitle: string;
+    accessRestrictedDescription: string;
+}
+interface CounterpartDetailsSheetLabels {
+    hiddenDescription: string;
+    loadingTitle: string;
+    errorTitle: string;
+    errorDescription: string;
+    openActionsMenu: string;
+    closeAction: string;
+    deleteCustomerAction: string;
+    deleteVendorAction: string;
+    summaryAmountDue: string;
+    summaryBalanceDue: string;
+    summaryBilled: string;
+    summaryReceived: string;
+    summaryPaid: string;
+    summaryRejected: string;
+    overdueTag: string;
+    sendPaymentAction: string;
+    issueInvoiceAction: string;
+    recentCustomerDocumentsHeading: string;
+    recentVendorDocumentsHeading: string;
+    recentCustomerDocumentsDescription: string;
+    recentVendorDocumentsDescription: string;
+    subtitleTemplate: string;
+    customerSubtitleLabel: string;
+    vendorSubtitleLabel: string;
+    entityTypePersonLabel: string;
+    entityTypeBusinessLabel: string;
+    remindersEnabledLabel: string;
+    remindersDisabledLabel: string;
+    paymentMethodTitle: string;
+    customerDetailsHeading: string;
+    vendorDetailsHeading: string;
+    customerDetailsDescription: string;
+    vendorDetailsDescription: string;
+    rowType: string;
+    rowName: string;
+    rowEmail: string;
+    rowPaymentReminders: string;
+    rowPhone: string;
+    rowTaxIdSsn: string;
+    rowTaxIdEin: string;
+    showTaxId: string;
+    hideTaxId: string;
+    customerTaxIdHelp: string;
+    vendorTaxIdHelp: string;
+    addressHeading: string;
+    customerAddressDescription: string;
+    addAddressAction: string;
+    editAddressAction: string;
+    noAddress: string;
+    paymentMethodsHeading: string;
+    paymentMethodsDescription: string;
+    addPaymentMethodAction: string;
+    editPaymentMethodAction: string;
+    deletePaymentMethodAction: string;
+    incompletePaymentMethod: string;
+    accountHolderLabel: string;
+    accountNumberLabel: string;
+    routingNumberLabel: string;
+    noPaymentMethods: string;
+    editButton: string;
+}
+
+/** Whether this widget is showing customers (receivables) or vendors (payables). */
+type CounterpartMode = 'customer' | 'vendor';
+
+interface CounterpartsWidgetOwnProps {
+    /** Selects customer (receivables) or vendor (payables) behavior and copy. */
+    counterpartType: CounterpartMode;
+    pageSizeOptions?: number[];
+    screenLabels?: Partial<CounterpartsScreenLabels>;
+    formLabels?: Partial<CounterpartFormSheetLabels>;
+    detailsLabels?: Partial<CounterpartDetailsSheetLabels>;
+    bankAccountLabels?: Partial<BankAccountFormSheetLabels>;
+    addressLabels?: Partial<AddressFormSheetLabels>;
+    deleteLabels?: Partial<ConfirmDeleteDialogLabels>;
+    /** Overrides for validation / error / delete-prompt messages. */
+    messageLabels?: Partial<CounterpartMessageLabels>;
+}
+/** Public props for {@link CounterpartsWidget}. */
+type CounterpartsWidgetProps = WidgetProviderProps & CounterpartsWidgetOwnProps;
+
+/**
+ * Self-contained customers/vendors widget: lists counterparts with money
+ * columns, and creates, edits, views, and deletes counterparts plus their
+ * payment method and address. `counterpartType` selects customer (receivables)
+ * vs vendor (payables) behavior. The provider/inner split keeps the public
+ * component a pure {@link WidgetProvider} wrapper.
+ *
+ * @example
+ * ```tsx
+ * <CounterpartsWidget
+ *   counterpartType="customer"
+ *   baseUrl="https://api.tesouro.com"
+ *   widgetToken="wt_..."
+ *   organizationId="org_..."
+ * />
+ * ```
+ */
+declare function CounterpartsWidget({ baseUrl, widgetToken, organizationId, configClient, linkComponent, implementation, uiFramework, errorFallback, onError, analytics, ...innerProps }: CounterpartsWidgetProps): React.JSX.Element;
+
+interface Labels$4 {
+    title: string;
+    description: string;
+    receiptsTab: string;
+    matchingTab: string;
+    policiesTab: string;
+    requirementsTab: string;
+}
+
+interface UploadReceiptWidgetProps {
+    emailAddress: string;
+    onFileUpload?: (file: File) => unknown | Promise<unknown>;
+    isUploading?: boolean;
+}
+declare function UploadReceiptWidget({ emailAddress, onFileUpload, isUploading, }: UploadReceiptWidgetProps): React.JSX.Element;
+
+interface ExpenseManagementWidgetProps extends WidgetProviderProps {
+    labels?: Partial<Labels$4>;
+    receiptUpload?: UploadReceiptWidgetProps;
+    receiptsContent?: ReactNode;
+    matchingContent?: ReactNode;
+    policiesContent?: ReactNode;
+    requirementsContent?: ReactNode;
+}
+declare function ExpenseManagementWidget({ baseUrl, widgetToken, organizationId, configClient, linkComponent, implementation, uiFramework, errorFallback, onError, analytics, ...innerProps }: ExpenseManagementWidgetProps): React.JSX.Element;
+
+type ExpenseApprovalPoliciesWidgetProps = WidgetProviderProps & {
+    /** @deprecated Use `widgetToken` instead */
+    token?: string | null;
+    /** @deprecated Use `organizationId` instead */
+    orgId?: string | null;
+};
+declare function ExpenseApprovalPoliciesWidget({ token, orgId, widgetToken, organizationId, baseUrl, configClient, linkComponent, implementation, uiFramework, errorFallback, onError, }?: ExpenseApprovalPoliciesWidgetProps): React.JSX.Element;
+
+type ExpenseRequirementsWidgetProps = WidgetProviderProps & {
+    /** @deprecated Use `widgetToken` instead */
+    token?: string | null;
+    /** @deprecated Use `organizationId` instead */
+    orgId?: string | null;
+};
+declare function ExpenseRequirementsWidget({ token, orgId, widgetToken, organizationId, baseUrl, configClient, linkComponent, implementation, uiFramework, errorFallback, onError, }?: ExpenseRequirementsWidgetProps): React.JSX.Element;
+
+interface BalancesWidgetLabels {
+    /** Card header title (e.g. next to the building icon) */
+    widgetTitle: string;
+    /** Shown under the total amount */
+    totalAvailableBalance: string;
+    /** Full explanation shown in the info tooltip */
+    totalAvailableBalanceTooltip: string;
+    /** Short label for the info control (e.g. `aria-label`) */
+    totalAvailableBalanceInfoAriaLabel: string;
+    /** CTA to open the full accounts list */
+    viewAllAccounts: string;
+    /** Shown when there are no balances to list */
+    noBalancesFound: string;
+    /** Shown when the bank account request failed */
+    loadErrorTitle: string;
+    loadErrorDescription: string;
+    /** Label for retry after a failed load */
+    loadErrorRetry: string;
+}
+declare const BALANCES_WIDGET_LABELS_EN: BalancesWidgetLabels;
+
+interface BalancesWidgetWithContextProps {
+    /**
+     * Maximum number of account rows to render in-card. Anything beyond this
+     * cap is reachable only via the View-all CTA. Default 5.
+     */
+    maxAccounts?: number;
+    labels?: Partial<BalancesWidgetLabels>;
+    onBalanceRowClick?: (accountId: string) => void;
+    onViewAllAccountsClick?: () => void;
+}
+type BalancesWidgetPassthroughProps = Pick<BalancesWidgetWithContextProps, 'maxAccounts' | 'labels' | 'onBalanceRowClick' | 'onViewAllAccountsClick'>;
+interface BalancesWidgetProps extends WidgetProviderProps, BalancesWidgetPassthroughProps {
+}
+declare function BalancesWidget({ maxAccounts, labels, onBalanceRowClick, onViewAllAccountsClick, ...widgetProviderProps }: BalancesWidgetProps): React.JSX.Element;
+
+interface InsightsWidgetLabels {
+    widgetTitle: string;
+    activeTab: string;
+    dismissedTab: string;
+    noInsightsFound: string;
+    loadErrorTitle: string;
+    loadErrorDescription: string;
+    loadErrorRetry: string;
+}
+declare const INSIGHTS_WIDGET_LABELS_EN: InsightsWidgetLabels;
+
+/**
+ * Presentational model for one insight row — screen-shaped only (no domain ids or types).
+ */
+interface InsightRowView {
+    displayText: string;
+    createdDate: string;
+    badgeLabel: string;
+    badgeIcon: ReactElement;
+    showDismissButton: boolean;
+    showToggle: boolean;
+    toggleLabel?: string;
+    /** Required when `onToggle` is set — owner-controlled switch state. */
+    toggleChecked?: boolean;
+    onToggle?: (checked: boolean) => void;
+    navigationLinkText?: string;
+    onNavigationClick?: () => void;
+    actionText?: string;
+    onActionClick?: () => void;
+}
+
+interface SingleInsightLabels {
+    dismissInsightAriaLabel: string;
+}
+declare const SINGLE_INSIGHT_LABELS_EN: SingleInsightLabels;
+
+interface InsightsFeatureLabels {
+    onboardingBadgeLabel: string;
+    routingOnboardingText: string;
+    enableRoutingToggle: string;
+    createAccountText: string;
+    connectExternalText: string;
+    linkAccountAction: string;
+    verifyExternalAccountText: (nickname: string) => string;
+}
+declare const INSIGHTS_FEATURE_LABELS_EN: InsightsFeatureLabels;
+
+/** Domain model for one generated insight — stays in the feature layer only. */
+interface InsightItem {
+    id: string;
+    isDismissed: boolean;
+    showToggle: boolean;
+    canDismiss: boolean;
+    displayText: string;
+    toggleLabel?: string;
+    toggleChecked?: boolean;
+    onToggle?: (checked: boolean) => void;
+    actionText?: string;
+    onActionClick?: () => void;
+}
+
+declare function mapInsightToRowView(insight: InsightItem, labels: InsightsFeatureLabels, createdDate: string): InsightRowView;
+
+interface SingleInsightProps {
+    insight: InsightItem;
+    createdDate: string;
+    featureLabels: Parameters<typeof mapInsightToRowView>[1];
+    onDismissClick: (id: string) => void;
+    labels?: Partial<SingleInsightLabels>;
+}
+declare const SingleInsight: ({ insight, createdDate, featureLabels, onDismissClick, labels, }: SingleInsightProps) => React.JSX.Element;
+
+interface InsightsWidgetInternalProps {
+    labels?: Partial<InsightsWidgetLabels>;
+    singleInsightLabels?: Parameters<typeof SingleInsight>[0]['labels'];
+}
+interface InsightsWidgetWithContextProps {
+    labels?: Partial<InsightsWidgetLabels>;
+    singleInsightLabels?: InsightsWidgetInternalProps['singleInsightLabels'];
+    featureLabels?: Partial<InsightsFeatureLabels>;
+    routingEnabled?: boolean;
+    onRoutingToggleChange?: (enabled: boolean) => void;
+    onLinkExternalAccountClick?: () => void;
+}
+type InsightsWidgetPassthroughProps = Pick<InsightsWidgetWithContextProps, 'labels' | 'singleInsightLabels' | 'featureLabels' | 'routingEnabled' | 'onRoutingToggleChange' | 'onLinkExternalAccountClick'>;
+interface InsightsWidgetProps extends WidgetProviderProps, InsightsWidgetPassthroughProps {
+}
+declare function InsightsWidget({ labels, singleInsightLabels, featureLabels, routingEnabled, onRoutingToggleChange, onLinkExternalAccountClick, ...widgetProviderProps }: InsightsWidgetProps): React.JSX.Element;
+
+type GlCode = {
+    id: string;
+    name: string;
+    nominal_code: string;
+    description: string;
+};
+interface GlCodeTableLabels {
+    columnName: string;
+    columnGlCode: string;
+    columnDescription: string;
+    columnActions: string;
+    actionEdit: string;
+    actionDelete: string;
+    emptyTitle: string;
+    emptyDescription: string;
+    emptyAddIntegration: string;
+    emptyImportCsv: string;
+    emptyLearnMore: string;
+    errorTitle: string;
+    errorDescription: string;
+    paginationPrev: string;
+    paginationNext: string;
+}
+declare const GL_CODE_TABLE_LABELS_EN: GlCodeTableLabels;
+interface GlCodeTableProps {
+    data: GlCode[];
+    isLoading?: boolean;
+    isError?: boolean;
+    sorting: SortingState;
+    onSortingChange: OnChangeFn<SortingState>;
+    pageSize: number;
+    onPageSizeChange: (pageSize: number) => void;
+    pageSizeOptions: number[];
+    hasNextPage?: boolean;
+    hasPrevPage?: boolean;
+    onNextPage: () => void;
+    onPrevPage: () => void;
+    /** Merged with GL_CODE_TABLE_LABELS_EN — only override what you need. */
+    labels?: Partial<GlCodeTableLabels>;
+    onEdit?: (row: GlCode) => void;
+    onDelete?: (row: GlCode) => void;
+    onAddIntegration?: () => void;
+    onImportCsv?: () => void;
+    learnMoreHref?: string;
+}
+declare function GlCodeTable({ data, isLoading, isError, sorting, onSortingChange, pageSize, onPageSizeChange, pageSizeOptions, hasNextPage, hasPrevPage, onNextPage, onPrevPage, labels, onEdit, onDelete, onAddIntegration, onImportCsv, learnMoreHref, }: GlCodeTableProps): React.JSX.Element;
+
+/**
+ * Props that the feature layer owns and wires internally — consumers cannot
+ * override these because they are driven by the query and pagination state.
+ */
+type TableProps = Omit<GlCodeTableProps, 'data' | 'isLoading' | 'isError' | 'sorting' | 'onSortingChange' | 'pageSize' | 'onPageSizeChange' | 'pageSizeOptions' | 'hasNextPage' | 'hasPrevPage' | 'onNextPage' | 'onPrevPage'>;
+/**
+ * Public props for {@link GLCodeTableWidget}.
+ *
+ * Merges {@link WidgetProviderProps} (auth/base-URL scope) with the subset of
+ * {@link GlCodeTableProps} that consumers are allowed to control (labels, row
+ * action callbacks, empty-state CTAs, etc.).
+ */
+type GLCodeTableWidgetProps = WidgetProviderProps & TableProps;
+/**
+ * Self-contained GL code table widget.
+ *
+ * Composes a {@link WidgetProvider} scope with the table's query and pagination
+ * logic. The two-component split (`GLCodeTableWidget` → `GLCodeTableWidgetInner`)
+ * ensures that `useGetLedgerAccountsQuery` runs *inside* the provider tree and
+ * can therefore resolve the correct API base URL and auth token from context.
+ *
+ * @example
+ * ```tsx
+ * <GLCodeTableWidget
+ *   baseUrl="https://api.example.com"
+ *   widgetToken="wt_..."
+ *   organizationId="org_..."
+ *   onEdit={(row) => openEditDialog(row)}
+ *   onDelete={(row) => confirmDelete(row)}
+ * />
+ * ```
+ */
+declare function GLCodeTableWidget({ baseUrl, widgetToken, organizationId, configClient, linkComponent, implementation, uiFramework, errorFallback, onError, ...tableProps }: GLCodeTableWidgetProps): React.JSX.Element;
+
+/**
+ * Static FAQ content for the Help widget.
+ *
+ * The shape mirrors the original MUI `HelpPage` rich-text model so the renderer
+ * can reproduce paragraphs, ordered/unordered bullet lists, nested bullets, and
+ * inline `<bold>…</bold>` runs. Callers may supply their own `HelpFaqSection[]`
+ * to override the default content below.
+ */
+/** Which list marker to render for a group of bullet points. */
+type HelpFaqBulletType = 'bullet' | 'numeric';
+/** A single bullet point, optionally with its own nested list. */
+interface HelpFaqBullet {
+    text: string;
+    bulletPointType?: HelpFaqBulletType;
+    bulletPoints?: HelpFaqBullet[];
+}
+/** One answer block: a paragraph, optionally followed by a bullet list. */
+interface HelpFaqAnswer {
+    text: string;
+    bulletPointType?: HelpFaqBulletType;
+    bulletPoints?: HelpFaqBullet[];
+}
+/** A question and its ordered list of answer blocks. */
+interface HelpFaqItem {
+    question: string;
+    answers: HelpFaqAnswer[];
+}
+/** A titled group of questions rendered as a single card. */
+interface HelpFaqSection {
+    title: string;
+    items: HelpFaqItem[];
+}
+/**
+ * Default English FAQ content, ported from the original
+ * `embedded-banking-dashboard-settings` Help page (`defaultWidgetFaqContent` —
+ * the embedded-widget variant, which omits the password-management questions
+ * since embedded users authenticate through the provider). A stray "Testing 1"
+ * placeholder bullet from the source has been dropped.
+ */
+declare const HELP_FAQ_EN: HelpFaqSection[];
+
+/**
+ * Externalized, overridable display strings for the Help widget.
+ *
+ * Callers pass `labels={{ ... }}` to override individual strings (merged over
+ * `HELP_WIDGET_LABELS_EN`). Defaults reproduce the copy from the original
+ * `embedded-banking-dashboard-settings` Help page.
+ */
+interface HelpWidgetLabels {
+    /** Heading above the FAQ accordion. */
+    title: string;
+    /** Heading for the contact section. */
+    contactUsTitle: string;
+    /**
+     * Lead-in text for the contact line, rendered as
+     * `{contactUsBody} {bankName} {link}.`
+     */
+    contactUsBody: string;
+    /** Text of the contact link (wraps `contactUrl`). */
+    contactUsLinkText: string;
+}
+declare const HELP_WIDGET_LABELS_EN: HelpWidgetLabels;
+
+/**
+ * The Help widget's public, framework-agnostic API surface.
+ *
+ * This is the single source of truth for the props consumers pass. Both the
+ * shadcn and Tecton implementations accept exactly these props, and the public
+ * {@link HelpWidget} switch forwards them unchanged — so the UI-framework choice
+ * never leaks into a consumer-facing prop. Keep this contract identical across
+ * implementations: a prop that only one framework honors does not belong here.
+ */
+interface HelpWidgetProps$1 {
+    /** FAQ content to render, grouped into titled sections. */
+    faq: HelpFaqSection[];
+    /** Bank/provider name interpolated into the contact line. */
+    bankName?: string;
+    /** When set, renders a "Contact Us" card linking here. Omit to hide it. */
+    contactUrl?: string;
+    /** Overrides merged over {@link HELP_WIDGET_LABELS_EN}. */
+    labels?: Partial<HelpWidgetLabels>;
+}
+
+/**
+ * Presentational props consumers may override. `faq` is optional here and
+ * defaults to {@link HELP_FAQ_EN} so the widget renders standalone with no
+ * configuration.
+ */
+type HelpContentProps = Partial<HelpWidgetProps$1>;
+/**
+ * Public props for {@link HelpWidget}: {@link WidgetProviderProps} (auth/base-URL
+ * scope) plus the overridable presentational props of the underlying UI widget.
+ */
+type HelpWidgetProps = WidgetProviderProps & HelpContentProps;
+/**
+ * Self-contained Help widget: a static, shadcn FAQ accordion with an optional
+ * "Contact Us" card. Composes a {@link WidgetProvider} scope around the
+ * presentational UI component so it can be wired as the Settings `help` section
+ * default with no props, or mounted standalone by an integrator.
+ *
+ * @example
+ * ```tsx
+ * <HelpWidget bankName="Acme Bank" contactUrl="https://acme.example/support" />
+ * ```
+ */
+declare function HelpWidget({ baseUrl, widgetToken, organizationId, configClient, linkComponent, implementation, uiFramework, errorFallback, onError, analytics, ...contentProps }: HelpWidgetProps): React.JSX.Element;
+
+type ReceivablesWidgetMoniteProps = MoniteRegionProviderProps & Omit<ReceivablesProps, 'pageTitleComponent'> & {
+    pageTitleComponent?: ReceivablesProps['pageTitleComponent'];
+};
+declare function ReceivablesWidgetMonite({ baseUrl, widgetToken, organizationId, configClient, linkComponent, errorFallback, onError, finopsThemeColors, analytics, pageTitleComponent, uiFramework, ...receivablesProps }: ReceivablesWidgetMoniteProps): React.JSX.Element;
+
+interface ProductFormSheetLabels {
+    createTitle: string;
+    /** Shown in the sheet description for the create form. */
+    headerDescription: string;
+    /** `{type}` is replaced with the product/service word. */
+    editTitle: string;
+    /** `{type}` is replaced with the product/service word. */
+    editingBanner: string;
+    nameLabel: string;
+    namePlaceholder: string;
+    descriptionLabel: string;
+    /** Appended to the description label to indicate it is optional. */
+    descriptionOptional: string;
+    descriptionPlaceholder: string;
+    /** `{count}` is replaced with the current character count. */
+    descriptionCount: string;
+    typeLabel: string;
+    typeProduct: string;
+    typeProductDescription: string;
+    typeService: string;
+    typeServiceDescription: string;
+    unitLabel: string;
+    unitPlaceholder: string;
+    /** Shown as the first option in the unit select to clear/leave blank. */
+    noUnit: string;
+    manageUnits: string;
+    priceLabel: string;
+    currencyLabel: string;
+    currencyPlaceholder: string;
+    cancelButton: string;
+    /** `{type}` is replaced with the product/service word. */
+    createButton: string;
+    saveButton: string;
+}
+interface MeasureUnitsManagerLabels {
+    title: string;
+    hiddenDescription: string;
+    searchPlaceholder: string;
+    columnLabel: string;
+    columnDescription: string;
+    namePlaceholder: string;
+    descriptionPlaceholder: string;
+    addButton: string;
+    doneButton: string;
+    editAction: string;
+    deleteAction: string;
+    saveAction: string;
+    cancelAction: string;
+    emptyText: string;
+}
+interface MeasureUnitDeleteDialogLabels {
+    /** `{name}` is replaced with the unit name. */
+    titleNoItems: string;
+    /** `{name}` is replaced with the unit name. */
+    titleWithItems: string;
+    messageNoItems: string;
+    messageNoItemsHint: string;
+    messageWithItems: string;
+    messageWithItemsHint: string;
+    confirmButton: string;
+    cancelButton: string;
+}
+
+/**
+ * Overridable validation / error messages produced by the products feature
+ * layer and surfaced through the form's `errors` prop and the measure-units
+ * manager. Consumers override via the widget's `messageLabels` prop, merged
+ * over {@link PRODUCT_MESSAGE_LABELS_EN}.
+ */
+interface ProductMessageLabels {
+    nameRequired: string;
+    /** Shown when a name exceeds the 100-character limit. */
+    nameTooLong: string;
+    typeRequired: string;
+    priceInvalid: string;
+    currencyRequired: string;
+    /** Shown when a description exceeds the 255-character limit. */
+    descriptionTooLong: string;
+    unitNameRequired: string;
+    /** Shown for a non-field-specific product submit failure. */
+    genericError: string;
+    /** Fallback when creating a measure unit fails without a server message. */
+    createMeasureUnitError: string;
+    /** Fallback when updating a measure unit fails without a server message. */
+    updateMeasureUnitError: string;
+}
+
+interface ReceivableStatusBadgeLabels {
+    draft: string;
+    issuing: string;
+    issued: string;
+    failed: string;
+    accepted: string;
+    expired: string;
+    declined: string;
+    recurring: string;
+    partially_paid: string;
+    paid: string;
+    overdue: string;
+    uncollectible: string;
+    canceled: string;
+    deleted: string;
+    unknown: string;
+}
+interface ReceivablesScreenLabels {
+    title: string;
+    createButton: string;
+    templateSettingsButton: string;
+    searchPlaceholder: string;
+    statusFilterAll: string;
+    tabInvoices: string;
+    tabQuotes: string;
+    tabCreditNotes: string;
+    columnDocument: string;
+    columnCustomer: string;
+    columnStatus: string;
+    columnIssueDate: string;
+    columnDueDate: string;
+    columnTotal: string;
+    columnAmountDue: string;
+    columnActions: string;
+    sortByDocument: string;
+    sortByCustomer: string;
+    sortByIssueDate: string;
+    sortByDueDate: string;
+    sortByTotal: string;
+    actionEdit: string;
+    actionIssue: string;
+    actionSend: string;
+    actionRecordPayment: string;
+    actionMarkPaid: string;
+    actionMarkUncollectible: string;
+    actionAccept: string;
+    actionDecline: string;
+    actionCancel: string;
+    actionClone: string;
+    actionDelete: string;
+    emptyTitle: string;
+    emptyDescription: string;
+    emptyAction: string;
+    filterEmptyTitle: string;
+    filterEmptyDescription: string;
+    errorTitle: string;
+    errorDescription: string;
+    errorRetry: string;
+    statusBadge: ReceivableStatusBadgeLabels;
+}
+type ReceivablesScreenLabelOverrides = Partial<Omit<ReceivablesScreenLabels, 'statusBadge'>> & {
+    statusBadge?: Partial<ReceivableStatusBadgeLabels>;
+};
+interface ReceivableFormSheetLabels {
+    createTitle: string;
+    editTitle: string;
+    hiddenDescription: string;
+    documentTypeLabel: string;
+    typeInvoice: string;
+    typeQuote: string;
+    customerLabel: string;
+    customerHint: string;
+    currencyLabel: string;
+    issueDateLabel: string;
+    dueDateLabel: string;
+    memoLabel: string;
+    paymentTermsLabel: string;
+    paymentTermsPlaceholder: string;
+    paymentTermsNone: string;
+    lineItemsHeading: string;
+    productLabel: string;
+    quantityLabel: string;
+    addLineItemButton: string;
+    removeLineItemButton: string;
+    cancelButton: string;
+    createButton: string;
+    updateButton: string;
+}
+interface ReceivableDetailsSheetLabels {
+    hiddenDescription: string;
+    loadingTitle: string;
+    errorTitle: string;
+    errorDescription: string;
+    summaryHeading: string;
+    lineItemsHeading: string;
+    activityHeading: string;
+    mailsHeading: string;
+    noLineItems: string;
+    noActivity: string;
+    noMails: string;
+    quantityColumn: string;
+    unitPriceColumn: string;
+    totalColumn: string;
+    closeButton: string;
+    downloadPdfButton: string;
+    editButton: string;
+    issueButton: string;
+    sendButton: string;
+    acceptButton: string;
+    declineButton: string;
+    recordPaymentButton: string;
+    markPaidButton: string;
+    markUncollectibleButton: string;
+    cancelButton: string;
+    cloneButton: string;
+    deleteButton: string;
+    statusBadge: ReceivableStatusBadgeLabels;
+}
+type ReceivableDetailsSheetLabelOverrides = Partial<Omit<ReceivableDetailsSheetLabels, 'statusBadge'>> & {
+    statusBadge?: Partial<ReceivableStatusBadgeLabels>;
+};
+interface ReceivableSendDialogLabels {
+    title: string;
+    description: string;
+    toLabel: string;
+    ccLabel: string;
+    bccLabel: string;
+    subjectLabel: string;
+    bodyLabel: string;
+    cancelButton: string;
+    sendButton: string;
+}
+interface ReceivablePaymentDialogLabels {
+    title: string;
+    description: string;
+    modeLabel: string;
+    fullPayment: string;
+    partialPayment: string;
+    amountPaidLabel: string;
+    paidAtLabel: string;
+    commentLabel: string;
+    cancelButton: string;
+    submitButton: string;
+}
+interface ReceivableActionDialogLabels {
+    cancelButton: string;
+    confirmButton: string;
+}
+
+type ReceivableDocumentType = 'invoice' | 'quote' | 'credit_note';
+type ReceivablesWidgetTab = 'invoices' | 'quotes' | 'credit_notes';
+
+interface ReceivableMessageLabels {
+    customerRequired: string;
+    customerAddressRequired: string;
+    currencyRequired: string;
+    lineItemProductRequired: string;
+    lineItemQuantityInvalid: string;
+    sendToRequired: string;
+    sendSubjectRequired: string;
+    sendBodyRequired: string;
+    paymentAmountInvalid: string;
+    genericError: string;
+    untitledDocument: string;
+    unknownCustomer: string;
+    notAvailable: string;
+    invoiceType: string;
+    quoteType: string;
+    creditNoteType: string;
+    summaryDocumentType: string;
+    summaryDocumentNumber: string;
+    summaryCustomer: string;
+    summaryIssued: string;
+    summaryDue: string;
+    summaryCreated: string;
+    summaryUpdated: string;
+    summaryTotal: string;
+    summaryAmountDue: string;
+    activityStatusChanged: string;
+    activityReceivableCreated: string;
+    activityReceivableUpdated: string;
+    activityPaymentReceived: string;
+    activityMailSent: string;
+    activityUnknown: string;
+    recipientsNone: string;
+    sendSubjectDefault: string;
+    sendBodyDefault: string;
+    issueTitle: string;
+    issueDescription: string;
+    issueConfirm: string;
+    acceptTitle: string;
+    acceptDescription: string;
+    acceptConfirm: string;
+    declineTitle: string;
+    declineDescription: string;
+    declineConfirm: string;
+    cancelTitle: string;
+    cancelDescription: string;
+    cancelConfirm: string;
+    cloneTitle: string;
+    cloneDescription: string;
+    cloneConfirm: string;
+    deleteTitle: string;
+    deleteDescription: string;
+    deleteConfirm: string;
+    markPaidTitle: string;
+    markPaidDescription: string;
+    markPaidConfirm: string;
+    markUncollectibleTitle: string;
+    markUncollectibleDescription: string;
+    markUncollectibleConfirm: string;
+}
+
+interface ReceivablesWidgetOwnProps {
+    defaultTab?: ReceivablesWidgetTab;
+    enabledTabs?: ReceivablesWidgetTab[];
+    pageSizeOptions?: number[];
+    onReceivableCreated?: (id: string, type: ReceivableDocumentType) => void;
+    onReceivableOpened?: (id: string, type: ReceivableDocumentType) => void;
+    onTemplateSettingsClick?: () => void;
+    screenLabels?: ReceivablesScreenLabelOverrides;
+    formLabels?: Partial<ReceivableFormSheetLabels>;
+    detailsLabels?: ReceivableDetailsSheetLabelOverrides;
+    sendLabels?: Partial<ReceivableSendDialogLabels>;
+    paymentLabels?: Partial<ReceivablePaymentDialogLabels>;
+    actionLabels?: Partial<ReceivableActionDialogLabels>;
+    productFormLabels?: Partial<ProductFormSheetLabels>;
+    counterpartFormLabels?: Partial<CounterpartFormSheetLabels>;
+    measureUnitsLabels?: Partial<MeasureUnitsManagerLabels>;
+    measureUnitDeleteLabels?: Partial<MeasureUnitDeleteDialogLabels>;
+    messageLabels?: Partial<ReceivableMessageLabels>;
+    productMessageLabels?: Partial<ProductMessageLabels>;
+    counterpartMessageLabels?: Partial<CounterpartMessageLabels>;
+}
+type ReceivablesWidgetProps = WidgetProviderProps & ReceivablesWidgetOwnProps;
+
+declare function ReceivablesWidget({ baseUrl, widgetToken, organizationId, configClient, linkComponent, implementation, uiFramework, errorFallback, onError, analytics, ...innerProps }: ReceivablesWidgetProps): React.JSX.Element;
+
+interface Labels$3 {
+    title: string;
+    connectButton: string;
+    verifyCtaButton: string;
+    learnMoreButton: string;
+    connectTitle: string;
+    nicknameLabel: string;
+    accountNumberLabel: string;
+    routingNumberLabel: string;
+    routingNumberError: string;
+    typeLabel: string;
+    accountTypePlaceholder: string;
+    checkingOption: string;
+    savingsOption: string;
+    cancelButton: string;
+    nextButton: string;
+    backButton: string;
+    /** Step indicator template, e.g. "Step {current}/{total}". */
+    stepIndicator: string;
+    connectStep1Heading: string;
+    connectStep1Description: string;
+    connectStep2Heading: string;
+    connectStep2Description: string;
+    teamMemberAccessTooltip: string;
+    teamMembersLoadingLabel: string;
+    teamMembersErrorTitle: string;
+    teamMembersEmptyLabel: string;
+    summaryCompletedHeading: string;
+    summaryNextStepsHeading: string;
+    summaryAccountPrefix: string;
+    summaryStep1Title: string;
+    summaryStep1Description: string;
+    summaryStep2Title: string;
+    summaryStep2Description: string;
+    summaryStep3Title: string;
+    summaryStep3Description: string;
+    summaryStep4Title: string;
+    summaryStep4Description: string;
+    statusComplete: string;
+    statusTodo: string;
+    backToTransfersButton: string;
+    saveButton: string;
+    editButton: string;
+    verifyButton: string;
+    unlinkButton: string;
+    linkButton: string;
+    editTitle: string;
+    verifyTitle: string;
+    verifyDescription: string;
+    verifySectionHeading: string;
+    verifyExampleLabel: string;
+    verifyExampleText: string;
+    verifyAccountInProcess: string;
+    verifySuccessTitle: string;
+    verifySuccessDescription: string;
+    unlinkTitle: string;
+    unlinkDescription: string;
+    unlinkConfirmButton: string;
+    firstAmountLabel: string;
+    secondAmountLabel: string;
+    verifyAmountError: string;
+    loadingLabel: string;
+    errorTitle: string;
+    actionErrorTitle: string;
+    emptyTitle: string;
+    emptyDescription: string;
+}
+
+interface FeatureLabels$4 {
+    accountFallback: string;
+    accountLabel: string;
+    pendingStatus: string;
+    editSuccessToast: string;
+    unlinkSuccessToast: string;
+}
+
+interface LinkedAccountsWidgetProps extends WidgetProviderProps {
+    labels?: Partial<Labels$3>;
+    featureLabels?: Partial<FeatureLabels$4>;
+}
+declare function LinkedAccountsWidget({ baseUrl, widgetToken, organizationId, configClient, linkComponent, implementation, uiFramework, errorFallback, onError, analytics, ...innerProps }: LinkedAccountsWidgetProps): React.JSX.Element;
+
+interface BusinessDetailsLabels {
+    heading: string;
+    subheading: string;
+    companyLegalName: string;
+    companyDbaName: string;
+    businessAddress: string;
+    city: string;
+    state: string;
+    statePlaceholder: string;
+    zipCode: string;
+    companyPhoneNumber: string;
+    companyStructure: string;
+    companyStructurePlaceholder: string;
+    website: string;
+    taxId: string;
+    taxIdHelper: string;
+    naicsCode: string;
+    naicsCodePlaceholder: string;
+    isAuthorizedQuestion: string;
+    isAuthorizedYes: string;
+    isAuthorizedNo: string;
+    acceptDisclosuresPrefix: string;
+    termsOfUse: string;
+    privacyPolicy: string;
+    electronicCommunication: string;
+    patriotAct: string;
+    acceptDisclosuresJoin: string;
+    acceptDisclosuresAnd: string;
+    companyStructureOptions: Record<'CORPORATION_PUBLIC' | 'CORPORATION_PRIVATE' | 'CORPORATION_NOT_FOR_PROFIT' | 'LLC' | 'LLP' | 'PARTNERSHIP' | 'SOLE_PROPRIETORSHIP' | 'GOVERNMENT' | 'COOPERATIVE' | 'ASSOCIATION' | 'OTHER', string>;
+    naicsTitles?: Record<string, string>;
+    stateTitles?: Partial<Record<USStateAbbreviation, string>>;
+}
+declare const BUSINESS_DETAILS_LABELS_EN: BusinessDetailsLabels;
+
+type CompanyStructureValue = 'CORPORATION_PUBLIC' | 'CORPORATION_PRIVATE' | 'CORPORATION_NOT_FOR_PROFIT' | 'LLC' | 'LLP' | 'PARTNERSHIP' | 'SOLE_PROPRIETORSHIP' | 'GOVERNMENT' | 'COOPERATIVE' | 'ASSOCIATION' | 'OTHER';
+interface BusinessDetailsFormValues {
+    companyLegalName: string;
+    companyDbaName: string;
+    businessAddress: string;
+    city: string;
+    state: string;
+    zipCode: string;
+    companyPhoneNumber: string;
+    companyStructure: CompanyStructureValue | '';
+    website: string;
+    taxId: string;
+    naicsCode: string;
+    isAuthorized: boolean | null;
+    isCheckboxChecked: boolean;
+}
+
+interface PersonalDetailsLabels {
+    heading: string;
+    subheading: string;
+    firstName: string;
+    lastName: string;
+    dateOfBirth: string;
+    dateOfBirthPlaceholder: string;
+    ssn: string;
+    ssnShow: string;
+    ssnHide: string;
+    homeAddress: string;
+    city: string;
+    state: string;
+    statePlaceholder: string;
+    zipCode: string;
+    mobilePhoneNumber: string;
+    workEmail: string;
+    ownsOver25Question: string;
+    ownsOver25Yes: string;
+    ownsOver25No: string;
+    ownershipPercentage: string;
+    stateTitles?: Partial<Record<USStateAbbreviation, string>>;
+}
+declare const PERSONAL_DETAILS_LABELS_EN: PersonalDetailsLabels;
+
+interface PersonalDetailsFormValues {
+    firstName: string;
+    lastName: string;
+    dateOfBirth: Date | undefined;
+    ssn: string;
+    homeAddress: string;
+    city: string;
+    state: string;
+    zipCode: string;
+    mobilePhoneNumber: string;
+    workEmail: string;
+    ownsOver25Percent: boolean | null;
+    ownershipPercentage: number | null;
+}
+
+interface AdditionalOwnersLabels {
+    heading: string;
+    subheading: string;
+    primaryOwnerRowLabel: string;
+    primaryOwnerShareLabel: string;
+    emptyOwnersText: string;
+    addOwner: string;
+    edit: string;
+    remove: string;
+    cancel: string;
+    save: string;
+    ownerNameColumn: string;
+    ownerShareColumn: string;
+    ownerActionsColumn: string;
+    formHeadingAdd: string;
+    formHeadingEdit: string;
+    firstName: string;
+    lastName: string;
+    dateOfBirth: string;
+    dateOfBirthPlaceholder: string;
+    ssn: string;
+    homeAddress: string;
+    city: string;
+    state: string;
+    statePlaceholder: string;
+    zipCode: string;
+    mobilePhoneNumber: string;
+    ownershipPercentage: string;
+    totalOwnershipExceedsTemplate: (total: number) => string;
+    stateTitles?: Partial<Record<USStateAbbreviation, string>>;
+}
+declare const ADDITIONAL_OWNERS_LABELS_EN: AdditionalOwnersLabels;
+
+interface AdditionalOwnerFormValues {
+    firstName: string;
+    lastName: string;
+    dateOfBirth: Date | undefined;
+    ssn: string;
+    homeAddress: string;
+    city: string;
+    state: string;
+    zipCode: string;
+    mobilePhoneNumber: string;
+    ownershipPercentage: number;
+}
+type AdditionalOwner = AdditionalOwnerFormValues;
+
+interface ResultLabels {
+    loadingMessage: string;
+    successHeading: string;
+    successBody: (companyName: string) => string;
+    successFollowUp: (email: string) => string;
+    pendingHeading: string;
+    pendingBody: (companyName: string) => string;
+    pendingFollowUp: (email: string) => string;
+    errorHeading: string;
+    errorBody: (companyName: string) => string;
+    errorFollowUp: (email: string) => string;
+    navigateToDashboard: string;
+    poweredBy: string;
+}
+declare const RESULT_LABELS_EN: ResultLabels;
+
+interface OnboardingWidgetLabels {
+    stepIndicator?: {
+        business?: string;
+        personal?: string;
+        ownership?: string;
+        done?: string;
+    };
+    businessDetails?: Partial<BusinessDetailsLabels>;
+    personalDetails?: Partial<PersonalDetailsLabels>;
+    additionalOwners?: Partial<AdditionalOwnersLabels>;
+    result?: Partial<ResultLabels>;
+    back?: string;
+    next?: string;
+    submit?: string;
+    errorPrefix?: string;
+    /** Accessible title for the onboarding modal. */
+    modalTitle?: string;
+}
+interface OnboardingWidgetInnerProps {
+    onEmbeddedOnboardingCompletedSuccessfully: () => void;
+    onNavigateToDashboard: () => void;
+    labels?: OnboardingWidgetLabels;
+    bankLogoSrc?: string;
+    termsHref?: string;
+    privacyHref?: string;
+    electronicCommunicationHref?: string;
+    patriotActHref?: string;
+    /**
+     * Controlled open state for the onboarding modal. When provided, the host
+     * application owns the open/close state and must update it via
+     * `onOpenChange`. Defaults to uncontrolled mode (`defaultOpen` is honoured).
+     */
+    open?: boolean;
+    /**
+     * Initial open state when uncontrolled. Defaults to `true` so the widget
+     * renders the modal on mount.
+     */
+    defaultOpen?: boolean;
+    /**
+     * Notified whenever the modal opens or closes — both from internal gestures
+     * (overlay click, escape key, close button) and external state updates.
+     */
+    onOpenChange?: (open: boolean) => void;
+}
+type OnboardingWidgetProps = WidgetProviderProps & OnboardingWidgetInnerProps;
+declare function OnboardingWidget({ baseUrl, widgetToken, organizationId, configClient, linkComponent, implementation, uiFramework, errorFallback, onError, ...innerProps }: OnboardingWidgetProps): React.JSX.Element;
+
+/**
+ * Co-located user-facing strings for the products widget UI. Each component
+ * takes a `labels?: Partial<…Labels>` prop merged over the matching
+ * `*_LABELS_EN` default.
+ */
+interface ProductTypeBadgeLabels {
+    product: string;
+    service: string;
+}
+interface ProductsScreenLabels {
+    title: string;
+    createButton: string;
+    manageUnitsButton: string;
+    columnName: string;
+    columnType: string;
+    columnDescription: string;
+    columnUnit: string;
+    columnPrice: string;
+    searchPlaceholder: string;
+    typeFilterAll: string;
+    typeFilterProduct: string;
+    typeFilterService: string;
+    unitFilterAll: string;
+    emptyTitle: string;
+    emptyDescription: string;
+    emptyAction: string;
+    filterEmptyTitle: string;
+    filterEmptyDescription: string;
+    errorTitle: string;
+    errorDescription: string;
+    errorRetry: string;
+    typeBadge: ProductTypeBadgeLabels;
+}
+interface ProductDetailsSheetLabels {
+    hiddenDescription: string;
+    /** `{type}` and `{createdAt}` are replaced at render time. */
+    subtitle: string;
+    /** `{type}` is replaced with "Product" or "Service". */
+    sectionHeading: string;
+    typeProductDescription: string;
+    typeServiceDescription: string;
+    /** `{type}` is replaced with "Product" or "Service". */
+    rowName: string;
+    rowDescription: string;
+    rowType: string;
+    rowUnit: string;
+    rowPrice: string;
+    historyHeading: string;
+    rowCreatedOn: string;
+    rowLastUpdate: string;
+    /** Accessible label for the overflow actions trigger button. */
+    moreActionsLabel: string;
+    /** Accessible label for the close button. */
+    closeLabel: string;
+    /** Fallback displayed in a detail row when the value is empty. */
+    rowEmptyValue: string;
+    /** Label for the delete item in the actions dropdown. `{type}` is replaced with "Product" or "Service". */
+    deleteProductOption: string;
+    editButton: string;
+    loadingTitle: string;
+    errorTitle: string;
+    errorDescription: string;
+    typeBadge: ProductTypeBadgeLabels;
+}
+interface ProductDeleteDialogLabels {
+    /** `{name}` is replaced with the product name. */
+    title: string;
+    message: string;
+    confirmButton: string;
+    cancelButton: string;
+}
+
+interface ProductsWidgetOwnProps {
+    pageSizeOptions?: number[];
+    screenLabels?: Partial<ProductsScreenLabels>;
+    formLabels?: Partial<ProductFormSheetLabels>;
+    detailsLabels?: Partial<ProductDetailsSheetLabels>;
+    deleteLabels?: Partial<ProductDeleteDialogLabels>;
+    measureUnitsLabels?: Partial<MeasureUnitsManagerLabels>;
+    measureUnitDeleteLabels?: Partial<MeasureUnitDeleteDialogLabels>;
+    /** Overrides for validation / error messages produced by the widget. */
+    messageLabels?: Partial<ProductMessageLabels>;
+}
+/** Public props for {@link ProductsWidget}. */
+type ProductsWidgetProps = WidgetProviderProps & ProductsWidgetOwnProps;
+
+/**
+ * Self-contained products/services widget: lists, filters, creates, edits,
+ * views, and deletes products, and manages measure units. The provider/inner
+ * split keeps the public component a pure {@link WidgetProvider} wrapper.
+ *
+ * @example
+ * ```tsx
+ * <ProductsWidget baseUrl="https://api.tesouro.com" widgetToken="wt_..." organizationId="org_..." />
+ * ```
+ */
+declare function ProductsWidget({ baseUrl, widgetToken, organizationId, configClient, linkComponent, implementation, uiFramework, errorFallback, onError, analytics, ...innerProps }: ProductsWidgetProps): React.JSX.Element;
+
+interface Labels$2 {
+    loadingLabel: string;
+    errorLabel: string;
+}
+
+interface FeatureLabels$3 {
+    personalTab: string;
+    businessTab: string;
+    personalBannerAlt: string;
+    businessBannerAlt: string;
+    subtitle: string;
+    nameLabel: string;
+    emailLabel: string;
+    phoneLabel: string;
+    legalNameLabel: string;
+    companyAddressLabel: string;
+    companyPhoneLabel: string;
+    companyEmailLabel: string;
+    emptyValue: string;
+}
+
+interface ProfileWidgetProps extends WidgetProviderProps {
+    labels?: Partial<Labels$2>;
+    featureLabels?: Partial<FeatureLabels$3>;
+}
+declare function ProfileWidget({ baseUrl, widgetToken, organizationId, configClient, linkComponent, implementation, uiFramework, errorFallback, onError, analytics, ...innerProps }: ProfileWidgetProps): React.JSX.Element;
+
+type ReceiptMatchWidgetProps = WidgetProviderProps & {
+    isOpen?: boolean;
+    preSelectedReceiptIds?: string[];
+    onClose?: () => void;
+    targetTransactionId?: string;
+    onSingleTransactionUpdate?: () => void;
+};
+declare function ReceiptMatchWidget({ baseUrl, widgetToken, organizationId, configClient, linkComponent, implementation, uiFramework, errorFallback, onError, isOpen, preSelectedReceiptIds, onClose, targetTransactionId, onSingleTransactionUpdate, }: ReceiptMatchWidgetProps): React.JSX.Element;
+
+interface Labels$1 {
+    title: string;
+    description: string;
+}
+
+interface FeatureLabels$2 {
+    profileSection: string;
+    teamSection: string;
+    invoiceSection: string;
+    billPaySection: string;
+    accountingSection: string;
+    tagsSection: string;
+    expenseSection: string;
+    helpSection: string;
+    expenseApprovalsTab: string;
+    expenseRequirementsTab: string;
+}
+
+interface SettingsWidgetProps extends MoniteRegionProviderProps {
+    labels?: Partial<Labels$1>;
+    featureLabels?: Partial<FeatureLabels$2>;
+    profileContent?: ReactNode;
+    teamContent?: ReactNode;
+    billPayContent?: ReactNode;
+    helpContent?: ReactNode;
+    expenseContent?: ReactNode;
+    accountingContent?: ReactNode;
+    tagsContent?: ReactNode;
+    invoiceContent?: ReactNode;
+}
+declare function SettingsWidget({ baseUrl, widgetToken, organizationId, configClient, linkComponent, implementation, uiFramework, errorFallback, onError, finopsThemeColors, analytics, ...innerProps }: SettingsWidgetProps): React.JSX.Element;
+
+/**
+ * Co-located user-facing strings for the tags widget UI. Each component takes a
+ * `labels?: Partial<…Labels>` prop merged over the matching `*_LABELS_EN` default.
+ */
+interface TagsScreenLabels {
+    title: string;
+    createButton: string;
+    columnName: string;
+    columnCategory: string;
+    columnKeywords: string;
+    columnCreatedAt: string;
+    columnUpdatedAt: string;
+    columnCreatedBy: string;
+    columnActions: string;
+    actionDelete: string;
+    openActionsMenu: string;
+    emptyTitle: string;
+    emptyDescription: string;
+    emptyAction: string;
+    errorTitle: string;
+    errorDescription: string;
+    errorRetry: string;
+}
+interface TagFormSheetLabels {
+    createTitle: string;
+    /** `{name}` is replaced with the tag being edited. */
+    editTitle: string;
+    nameLabel: string;
+    categoryLabel: string;
+    categoryPlaceholder: string;
+    keywordsLabel: string;
+    keywordsPlaceholder: string;
+    /** Accessible label for a keyword chip's remove button. `{keyword}` is replaced. */
+    removeKeyword: string;
+    cancelButton: string;
+    createButton: string;
+    saveButton: string;
+    deleteButton: string;
+}
+interface TagDeleteDialogLabels {
+    /** `{name}` is replaced with the tag name. */
+    title: string;
+    message: string;
+    confirmButton: string;
+    cancelButton: string;
+}
+
+/**
+ * Overridable validation / error messages produced by the tags feature layer
+ * and surfaced through the form's `errors` prop. Consumers override via the
+ * widget's `messageLabels` prop, merged over {@link TAG_MESSAGE_LABELS_EN}.
+ */
+interface TagMessageLabels {
+    nameRequired: string;
+    nameTooLong: string;
+    keywordTooShort: string;
+    keywordTooLong: string;
+    /** Shown for a non-field-specific submit failure. */
+    genericError: string;
+}
+
+interface TagsWidgetOwnProps {
+    /** Page-size options for the table footer. */
+    pageSizeOptions?: number[];
+    /** Label overrides for the tags table screen. */
+    screenLabels?: Partial<TagsScreenLabels>;
+    /** Label overrides for the create/edit form. */
+    formLabels?: Partial<TagFormSheetLabels>;
+    /** Label overrides for the delete confirmation. */
+    deleteLabels?: Partial<TagDeleteDialogLabels>;
+    /** Overrides for validation / error messages produced by the widget. */
+    messageLabels?: Partial<TagMessageLabels>;
+}
+/** Public props for {@link TagsWidget}. */
+type TagsWidgetProps = WidgetProviderProps & TagsWidgetOwnProps;
+
+/**
+ * Self-contained tags widget: lists, creates, edits, and deletes tags, and
+ * manages per-tag OCR auto-tagging keywords. The provider/inner split keeps the
+ * public component a pure {@link WidgetProvider} wrapper while the inner runs
+ * inside the provider tree so data-access hooks can read widget context.
+ *
+ * @example
+ * ```tsx
+ * <TagsWidget baseUrl="https://api.tesouro.com" widgetToken="wt_..." organizationId="org_..." />
+ * ```
+ */
+declare function TagsWidget({ baseUrl, widgetToken, organizationId, configClient, linkComponent, implementation, uiFramework, errorFallback, onError, analytics, ...innerProps }: TagsWidgetProps): React.JSX.Element;
+
+interface Labels {
+    title: string;
+    nameColumn: string;
+    roleColumn: string;
+    departmentColumn: string;
+    statusColumn: string;
+    loadingLabel: string;
+    emptyTitle: string;
+    emptyDescription: string;
+    errorTitle: string;
+    errorDescription: string;
+    rowsPerPageLabel: string;
+    previousPageButton: string;
+    nextPageButton: string;
+    detailsBackButton: string;
+    detailsEmailLabel: string;
+    detailsRoleLabel: string;
+    detailsStatusLabel: string;
+    detailsLastSignInLabel: string;
+    detailsDepartmentLabel: string;
+    detailsLocationLabel: string;
+    detailsAccountAccessLabel: string;
+    rolesSectionHeading: string;
+    rolesSectionDescription: string;
+    roleLoadingLabel: string;
+    detailsEditButton: string;
+    detailsDeactivateButton: string;
+    inviteButton: string;
+    inviteTitle: string;
+    inviteBackToTeamButton: string;
+    inviteDetailsSectionHeading: string;
+    inviteFirstNameLabel: string;
+    inviteLastNameLabel: string;
+    inviteWorkEmailLabel: string;
+    inviteDepartmentLabel: string;
+    inviteDepartmentPlaceholder: string;
+    inviteDepartmentEmpty: string;
+    inviteLocationLabel: string;
+    inviteLocationPlaceholder: string;
+    inviteLocationEmpty: string;
+    inviteReportingManagerLabel: string;
+    inviteReportingManagerPlaceholder: string;
+    inviteReportingManagerEmpty: string;
+    inviteOptionsLoading: string;
+    /** Clears an optional select (department/location/reporting manager). */
+    inviteOptionNone: string;
+    inviteRoleSectionHeading: string;
+    inviteRoleSectionDescription: string;
+    inviteCancelButton: string;
+    inviteSubmitButton: string;
+    editTitle: string;
+    editDescription: string;
+    editNameLabel: string;
+    editRoleLabel: string;
+    editRolePlaceholder: string;
+    editCancelButton: string;
+    editSaveButton: string;
+    actionDialogCancelButton: string;
+}
+
+/** Strings the feature layer bakes into the display-ready view models. */
+interface FeatureLabels$1 {
+    /** Placeholder for fields the API has no value for (role, department, ...). */
+    notAvailable: string;
+    /** Last sign-in value for members who have never signed in. */
+    neverSignedIn: string;
+    /** Prefix for the pagination range, e.g. "Viewing 1-10". */
+    viewingRangeLabel: string;
+    /** Validation messages the feature attaches to form fields. */
+    nameRequiredError: string;
+    firstNameRequiredError: string;
+    lastNameRequiredError: string;
+    emailRequiredError: string;
+    emailInvalidError: string;
+    roleRequiredError: string;
+    /** Mutation failure messages shown inline in the workflows. */
+    inviteFailedError: string;
+    editFailedError: string;
+    deactivateFailedError: string;
+    /** Deactivate confirmation copy. */
+    deactivateDialogTitle: string;
+    deactivateDialogDescription: string;
+    deactivateConfirmButton: string;
+    /** Tabs. */
+    teamMembersTab: string;
+    departmentsTab: string;
+    locationsTab: string;
+    /** Shared group-admin (departments + locations) strings. */
+    groupNameColumn: string;
+    groupAssignedColumn: string;
+    groupActionsColumn: string;
+    groupEditAction: string;
+    groupRowActionsAriaLabel: string;
+    groupMembersLabel: string;
+    groupMembersSearchPlaceholder: string;
+    groupMembersEmpty: string;
+    groupCancelButton: string;
+    groupSaveButton: string;
+    groupMemberSingular: string;
+    groupMemberPlural: string;
+    groupNoMembers: string;
+    /** Departments. */
+    departmentsTitle: string;
+    departmentsAddButton: string;
+    departmentsEmpty: string;
+    departmentsLoading: string;
+    departmentsErrorTitle: string;
+    departmentsErrorDescription: string;
+    departmentCreateTitle: string;
+    departmentEditTitle: string;
+    departmentDrawerDescription: string;
+    departmentNameLabel: string;
+    departmentNamePlaceholder: string;
+    departmentDeleteAction: string;
+    departmentDeleteDialogTitle: string;
+    departmentDeleteDialogDescription: string;
+    departmentDeleteConfirmButton: string;
+    departmentSaveFailed: string;
+    departmentDeleteFailed: string;
+    /** Locations. */
+    locationsTitle: string;
+    locationsAddButton: string;
+    locationsEmpty: string;
+    locationsLoading: string;
+    locationsErrorTitle: string;
+    locationsErrorDescription: string;
+    locationCreateTitle: string;
+    locationEditTitle: string;
+    locationDrawerDescription: string;
+    locationNameLabel: string;
+    locationNamePlaceholder: string;
+    locationDeleteAction: string;
+    locationDeleteDialogTitle: string;
+    locationDeleteDialogDescription: string;
+    locationDeleteConfirmButton: string;
+    locationSaveFailed: string;
+    locationDeleteFailed: string;
+}
+
+interface TeamWidgetProps extends WidgetProviderProps {
+    labels?: Partial<Labels>;
+    featureLabels?: Partial<FeatureLabels$1>;
+}
+declare function TeamWidget({ baseUrl, widgetToken, organizationId, configClient, linkComponent, implementation, uiFramework, errorFallback, onError, analytics, ...innerProps }: TeamWidgetProps): React.JSX.Element;
+
+interface TransfersWidgetLabels {
+    widgetTitle: string;
+    transferMoneyCta: string;
+    /** Tooltip when the transfer CTA is disabled for insufficient eligible accounts. */
+    transferMoneyCtaDisabledTooltip: string;
+    /** Fallback when an account has no nickname in lists or options. */
+    accountFallbackName: string;
+    /** Mask prefix before last four digits on account options. */
+    embeddedAccountMaskPrefix: string;
+    /** Prefix before full account number on review cards (e.g. "Account #:"). */
+    modalReviewAccountNumberPrefix: string;
+    /** Separator between from and to account names in the route line. */
+    listAccountsSeparator: string;
+    loadErrorTitle: string;
+    loadErrorDescription: string;
+    loadErrorRetry: string;
+    emptyTitle: string;
+    emptyDescription: string;
+    modalTitle: string;
+    /** Shown under the title on the accounts step (e.g. ACH timing). */
+    modalAccountsSubtitle: string;
+    /** Placeholder inside the From account select on the accounts step. */
+    modalFromAccountPlaceholder: string;
+    /** Placeholder inside the To account select on the accounts step. */
+    modalToAccountPlaceholder: string;
+    /** Primary action on the accounts step (legacy: full-width Confirm). */
+    modalAccountsConfirm: string;
+    modalStepAccounts: string;
+    modalStepAmount: string;
+    modalStepReview: string;
+    modalStepResult: string;
+    modalFromLabel: string;
+    modalToLabel: string;
+    modalAmountLabel: string;
+    /** Placeholder for the amount input (e.g. "0.00"). */
+    modalAmountPlaceholder: string;
+    modalContinue: string;
+    modalBack: string;
+    modalSubmit: string;
+    modalClose: string;
+    modalReviewHeading: string;
+    modalReviewFromAccountLabel: string;
+    modalReviewToAccountLabel: string;
+    modalAvailableBalanceCaption: string;
+    modalConfirmTransfer: string;
+    modalGoBack: string;
+    modalSuccessTitle: string;
+    modalSuccessDescription: string;
+    modalResultSuccessTitle: string;
+    modalResultErrorTitle: string;
+    modalResultTransferMessagePrefix: string;
+    modalResultSuccessMessageSuffix: string;
+    modalResultErrorMessageSuffix: string;
+    modalBackToTransfers: string;
+    modalSelectPlaceholder: string;
+    rowStatusCompleted: string;
+    rowStatusPending: string;
+    rowStatusFailed: string;
+    rowTypeInternal: string;
+    rowTypeToExternal: string;
+    rowTypeFromExternal: string;
+    modalAmountInvalidError: string;
+    /** Shown under the amount field when the from (embedded) balance is too low. */
+    modalInsufficientFundsError: string;
+    /** Resets from, to, and amount on the accounts step. */
+    modalClearSelections: string;
+    modalUnsupportedPairError: string;
+    modalSubmitFailedError: string;
+}
+declare const TRANSFERS_WIDGET_LABELS_EN: TransfersWidgetLabels;
+
+interface FeatureLabels {
+    unavailableLabel: string;
+    routeSeparator: string;
+    defaultCurrencyCode: string;
+    defaultSecCode: string;
+}
+declare const DEFAULT_FEATURE_LABELS: FeatureLabels;
+
+interface TransfersWidgetPassthroughProps {
+    labels?: Partial<TransfersWidgetLabels>;
+    featureLabels?: Partial<FeatureLabels>;
+}
+interface TransfersWidgetProps extends WidgetProviderProps, TransfersWidgetPassthroughProps {
+}
+declare function TransfersWidget({ labels, featureLabels, ...widgetProviderProps }: TransfersWidgetProps): React.JSX.Element;
+
+export { ADDITIONAL_OWNERS_LABELS_EN, BALANCES_WIDGET_LABELS_EN, BUSINESS_DETAILS_LABELS_EN, BalancesWidget, BankAccountsWidget, BillPayWidget, CounterpartsWidget, ExpenseApprovalPoliciesWidget, ExpenseManagementWidget, ExpenseRequirementsWidget, GLCodeTableWidget, GL_CODE_TABLE_LABELS_EN, GlCodeTable, HELP_FAQ_EN, HELP_WIDGET_LABELS_EN, HelpWidget, INSIGHTS_FEATURE_LABELS_EN, INSIGHTS_WIDGET_LABELS_EN, Implementation, InsightsWidget, ReceivablesWidgetMonite as InvoicingWidget, LinkedAccountsWidget, OnboardingWidget, PERSONAL_DETAILS_LABELS_EN, ProductsWidget, ProfileWidget, RESULT_LABELS_EN, ReceiptMatchWidget, ReceivablesWidget, RefreshingRootWidgetProvider, RootWidgetProvider, SINGLE_INSIGHT_LABELS_EN, SettingsWidget, DEFAULT_FEATURE_LABELS as TRANSFERS_FEATURE_LABELS_EN, TRANSFERS_WIDGET_LABELS_EN, TagsWidget, TeamWidget, TransfersWidget, UIFramework, UploadReceiptWidget, WidgetProvider, WidgetTokenRefreshProvider, cloneEmbeddedClient, getGlobalWidgetConfig, registerDesignSystemEnsurer, registerUIRenderers, setGlobalWidgetConfig, updateGlobalWidgetConfig, useOwnWidgetConfig, useRefetchWidget, useWidgetConfig, useWidgetError, useWidgetLoading, useWidgetToken };
+export type { Labels$6 as AccountDetailsWidgetLabels, AdditionalOwner, AdditionalOwnerFormValues, AdditionalOwnersLabels, AddressFormSheetLabels, BalancesWidgetLabels, BalancesWidgetProps, BankAccountFormSheetLabels, FeatureLabels$5 as BankAccountsWidgetFeatureLabels, Labels$5 as BankAccountsWidgetLabels, BankAccountsWidgetProps, BillPayWidgetProps, BusinessDetailsFormValues, BusinessDetailsLabels, ConfirmDeleteDialogLabels, CounterpartDetailsSheetLabels, CounterpartFormSheetLabels, CounterpartMessageLabels, CounterpartMode, CounterpartsScreenLabels, CounterpartsWidgetProps, EmbeddedClient, ExpenseApprovalPoliciesWidgetProps, Labels$4 as ExpenseManagementWidgetLabels, ExpenseManagementWidgetProps, ExpenseRequirementsWidgetProps, GLCodeTableWidgetProps, GlCode, GlCodeTableLabels, GlCodeTableProps, HelpFaqAnswer, HelpFaqBullet, HelpFaqBulletType, HelpFaqItem, HelpFaqSection, HelpWidgetLabels, HelpWidgetProps, InsightsFeatureLabels, InsightsWidgetLabels, InsightsWidgetProps, ReceivablesWidgetMoniteProps as InvoicingWidgetProps, LinkComponent, LinkComponentProps, FeatureLabels$4 as LinkedAccountsWidgetFeatureLabels, Labels$3 as LinkedAccountsWidgetLabels, LinkedAccountsWidgetProps, MeasureUnitDeleteDialogLabels, MeasureUnitsManagerLabels, OnboardingWidgetLabels, OnboardingWidgetProps, PersonalDetailsFormValues, PersonalDetailsLabels, ProductDeleteDialogLabels, ProductDetailsSheetLabels, ProductFormSheetLabels, ProductMessageLabels, ProductsScreenLabels, ProductsWidgetProps, FeatureLabels$3 as ProfileWidgetFeatureLabels, Labels$2 as ProfileWidgetLabels, ProfileWidgetProps, ReceiptMatchWidgetProps, ReceivableActionDialogLabels, ReceivableDetailsSheetLabelOverrides, ReceivableDetailsSheetLabels, ReceivableDocumentType, ReceivableFormSheetLabels, ReceivableMessageLabels, ReceivablePaymentDialogLabels, ReceivableSendDialogLabels, ReceivableStatusBadgeLabels, ReceivablesScreenLabelOverrides, ReceivablesScreenLabels, ReceivablesWidgetProps, ReceivablesWidgetTab, RefreshingRootWidgetProviderProps, ResultLabels, RootWidgetProviderProps, FeatureLabels$2 as SettingsWidgetFeatureLabels, Labels$1 as SettingsWidgetLabels, SettingsWidgetProps, SingleInsightLabels, TagDeleteDialogLabels, TagFormSheetLabels, TagMessageLabels, TagsScreenLabels, TagsWidgetProps, FeatureLabels$1 as TeamWidgetFeatureLabels, Labels as TeamWidgetLabels, TeamWidgetProps, FeatureLabels as TransfersWidgetFeatureLabels, TransfersWidgetLabels, TransfersWidgetProps, UploadReceiptWidgetProps, WidgetConfig, WidgetConfigInput, WidgetProviderProps, WidgetTokenFetcher, WidgetTokenManager, WidgetTokenRefreshProviderProps, WidgetTokenState };