@tesouro/embedded-components-react 0.5.235 → 0.5.243

package/dist/scenarios/index.d.ts

@@ -0,0 +1,583 @@
+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 = ClientOptions> 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 {
+    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 DisclosureRequirement = 'NOT_REQUIRED' | 'REQUIRED';
+type OrganizationType = 'BANK' | 'EMBEDDED' | 'PLATFORM' | 'TRANSACTOR' | 'VERTICAL_SOFTWARE_PROVIDER';
+type WidgetInitResponse = {
+    bankName?: null | string;
+    /**
+     * Whether the user has accepted the version currently in force. False for a user who accepted an
+     * earlier version, which is what makes publishing a new one prompt them again, and false when
+     * there is no user yet. Prompt on this rather than on `status`, which cannot answer it: an
+     * already-active user can owe a re-acceptance while never being invited again.
+     */
+    disclosuresAccepted?: boolean;
+    /**
+     * Whether embedded banking requires this widget session's user to accept disclosures.
+     * Resolved through the organization hierarchy, nearest owner first: the organization asked about,
+     * then its VSP, then its parent platform, then the bank, defaulting to NOT_REQUIRED.
+     * Resolved for the user when there is one, which is the rung the acceptance writes against.
+     * It falls back to the organization owning the widget application in the two cases where the user
+     * cannot answer: before the user exists, which is what an onboarding widget needs, and when their
+     * organization's settings chain resolves nothing at all. In that second case the acceptance
+     * refuses rather than reporting the user clear, so a prompt shown here is never one the widget
+     * can silently fail to record.
+     */
+    disclosuresRequired?: DisclosureRequirement;
+    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;
+
+/**
+ * A widget-init response that renders the widget rather than a gate.
+ *
+ * `disclosuresRequired`/`disclosuresAccepted` are set explicitly because
+ * `WidgetProvider` replaces its whole subtree with the disclosures gate when
+ * init says acceptance is owed: mock the data perfectly, get the init wrong, and
+ * every story renders the gate instead of the widget.
+ *
+ * **`scopes` is empty on purpose.** A widget gates its surfaces on the session's
+ * scopes, and which ones it needs is the consumer's business, so supply them at
+ * the composition site rather than inheriting a broad default that would hide a
+ * real scope-gating bug:
+ *
+ * ```ts
+ * handleGetApiWidgetGatewayInit({
+ *   body: { ...A_WIDGET_INIT, scopes: [Scope.CreditCardReadOrg] },
+ * });
+ * ```
+ */
+declare const A_WIDGET_INIT: WidgetInitResponse;
+
+/**
+ * What each scenario is called and what it shows: the docs site's picker and
+ * the feature stories both read it. Mock response data (account nicknames,
+ * gateway error bodies) stays in the widget modules: it is what the fake API
+ * returns, not copy either one renders.
+ */
+type CrossCuttingKey = 'populated' | 'empty' | 'loading' | 'error' | 'control-hidden' | 'paginated';
+declare const CROSS_CUTTING_KEYS: readonly CrossCuttingKey[];
+declare const SCENARIO_LABELS: Record<CrossCuttingKey, ScenarioCopy>;
+interface ScenarioCopy {
+    label: string;
+    blurb: string;
+}
+
+declare const INIT = "/api/widget-gateway/init";
+declare const PROXY = "/api/widget-gateway/proxy/embedded-banking/v1";
+declare const FINOPS = "/api/widget-gateway/proxy/finops/v1";
+declare const IDENTITY = "/api/widget-gateway/proxy/identity/v1";
+interface RouteRequest {
+    method: string;
+    path: string;
+    query: URLSearchParams;
+    body: unknown;
+}
+interface UploadedFile {
+    name: string;
+    type: string;
+    size: number;
+}
+declare const bodyOf: <T = Record<string, unknown>>(req: RouteRequest) => Partial<T>;
+/**
+ * A Response answers; undefined falls through to the next route. The
+ * `undefined` sits inside the Promise too, because an `async` route that falls
+ * through returns `Promise<Response | undefined>`.
+ */
+type Route = (req: RouteRequest) => Response | undefined | Promise<Response | undefined>;
+interface Scenario<P = unknown> {
+    /** Deep-linked as `?scenario=<key>`. */
+    key: string;
+    label: string;
+    blurb: string;
+    /**
+     * A function when the world has to change as the reader acts. It runs once
+     * per mount, so a remount or a second demo never shares that state.
+     */
+    routes: Route[] | (() => Route[]);
+    props?: P;
+}
+type ConfigClient = (client: EmbeddedClient) => EmbeddedClient;
+declare const json: (body: unknown, status?: number) => Response;
+/** An error body shaped the way the gateway sends one. */
+declare const problem: (status: number, title: string, detail: string) => Response;
+declare const wait: (ms: number) => Promise<void>;
+declare const noContent: () => Response;
+type WidgetInit = typeof A_WIDGET_INIT;
+/**
+ * The fixture ships with no scopes on purpose, so a broad default cannot hide
+ * a scope-gating bug. Name them through `Scope` so a rename is a compile error.
+ */
+declare const initRoute: (scopes: readonly string[], overrides?: Partial<WidgetInit>) => Route;
+interface PagingStyle {
+    tokenParam: string;
+    next: string;
+    prev: string;
+}
+declare const EMBEDDED_PAGING: PagingStyle;
+declare const CARDS_PAGING: PagingStyle;
+declare const FINOPS_PAGING: PagingStyle;
+/** The one call whose answer decides what the reader sees. The cross-cutting scenarios vary only this. */
+interface PrimaryRead {
+    matches: (path: string) => boolean;
+    body: unknown;
+    /** Required only if the widget keeps `empty`. */
+    emptyBody?: unknown;
+    /** Required only if the widget keeps `paginated`. */
+    pages?: unknown[][];
+    paging?: PagingStyle;
+}
+interface CrossCuttingSpec {
+    scopes: readonly string[];
+    init?: Partial<WidgetInit>;
+    read: PrimaryRead;
+    /** Answered the same way in every scenario, tried before the read. */
+    supportRoutes?: Route[];
+    /** Per widget, since which control disappears depends on the widget. */
+    controlHidden?: {
+        scopes: readonly string[];
+        body?: unknown;
+    };
+    blurbs?: Partial<Record<CrossCuttingKey, string>>;
+}
+/** Long enough that the skeleton stays on screen rather than flashing. */
+declare const LOADING_DELAY_MS = 60000;
+declare const answer: (matches: (path: string) => boolean, respond: (req: RouteRequest) => Response | Promise<Response>) => Route;
+declare const matchPath: (template: string) => (path: string) => Record<string, string> | undefined;
+declare const endpoint: (method: string, template: string, respond: (req: RouteRequest, params: Record<string, string>) => Response | Promise<Response>) => Route;
+declare const readRoute: (path: string, body: unknown) => Route;
+declare const defaultScenario: (scopes: readonly string[], routes?: Route[]) => Scenario;
+declare const page: <T>(data: T[]) => {
+    data: T[];
+    nextPaginationToken: null;
+};
+declare const finopsPage: <T>(data: T[]) => {
+    data: T[];
+    next_pagination_token: null;
+};
+/** `pages[n]`, keyed by a pagination token of `page-<n>`, in the API's own casing. */
+declare const paged: (pages: unknown[][], style?: PagingStyle) => ((req: RouteRequest) => Response);
+/**
+ * The seven cross-cutting scenarios from one definition (plan §5.4). Seven is a
+ * ceiling: `keep` names, in picker order, only the ones this widget renders
+ * distinctly.
+ *
+ * A hidden control is a scope-gated rendering. A generic read refusal renders
+ * the same error panel as a 500, so it is not a separate picker choice.
+ */
+declare function crossCuttingScenarios(spec: CrossCuttingSpec, keep: readonly CrossCuttingKey[]): Scenario[];
+/** UUIDs are redacted even when an API embeds one in a dotted key rather than a path segment. */
+declare const templatePath: (path: string) => string;
+interface RequestSummary {
+    method: string;
+    route: string;
+}
+/** A scenario's routes, built fresh: a stateful world runs its factory once per call. */
+declare const routesOf: (scenario: Scenario) => Route[];
+/** Answers `request` from the first matching route, or undefined when none does. */
+declare function answerFrom(routes: Route[], request: Request): Promise<Response | undefined>;
+/** A scenario as a `fetch`, installed on the widget's client through `configClient`. */
+declare function scenarioFetch(scenario: Scenario, onRequest: (r: RequestSummary) => void): typeof fetch;
+/**
+ * Several widgets' worlds behind one `/init`, for a surface that mounts them
+ * together. The first world that answers a request wins, and init merges every
+ * world's answer: scopes are the union, other fields come from the earliest
+ * world that sets them, so a world listed first decides the session's state.
+ */
+declare const composeScenarios: (parts: Scenario<unknown>[]) => (() => Route[]);
+
+declare const acceptDisclosuresScenarios: Scenario[];
+
+declare const balancesScenarios: Scenario[];
+
+declare const bankAccountOnboardingScenarios: Scenario[];
+
+declare const bankAccountsScenarios: Scenario[];
+
+declare const billPayScenarios: Scenario[];
+
+/** The card every scenario serves; pass it as the widget's `cardId`. */
+declare const CARD_DETAILS_CARD_ID: string;
+declare const cardDetailsScenarios: Scenario[];
+
+declare const creditCardsScenarios: Scenario[];
+
+declare const debitCardsScenarios: Scenario[];
+
+declare const counterpartsScenarios: Scenario[];
+
+declare const expenseManagementScenarios: Scenario[];
+
+declare const insightsScenarios: Scenario[];
+
+declare const invoicingScenarios: Scenario[];
+
+declare const receivablesScenarios: Scenario[];
+
+declare const linkedAccountsScenarios: Scenario[];
+
+declare const marketingScenarios: Scenario[];
+
+declare const productsScenarios: Scenario[];
+
+interface SettingsDemoProps {
+    defaultSelectedSection?: 'profile' | 'team' | 'legal' | 'help';
+    helpContactUrl?: string;
+    profileContactUrl?: string;
+}
+declare const settingsScenarios: Scenario<SettingsDemoProps>[];
+
+declare const transfersScenarios: Scenario[];
+
+interface ReceiptMatchSummary {
+    total: number;
+    matched: number;
+    unmatched: number;
+    unreadable: number;
+    stillProcessing: number;
+}
+interface UploadReceiptWidgetProps {
+    emailAddress?: string;
+    onFileUpload?: (file: File) => unknown | Promise<unknown>;
+    onAwaitMatching?: (uploadedCount: number) => Promise<ReceiptMatchSummary>;
+    isUploading?: boolean;
+}
+interface UploadReceiptDemoProps extends UploadReceiptWidgetProps {
+    /** Callbacks that hold state, built once per mount by whoever renders the widget. */
+    perMount?: () => Partial<UploadReceiptWidgetProps>;
+}
+declare const uploadReceiptScenarios: Scenario<UploadReceiptDemoProps>[];
+
+type SectionId = 'dashboard' | 'accounts' | 'cards' | 'transfers' | 'bill-pay' | 'invoicing' | 'expenses' | 'settings';
+interface WidgetSuiteDemoProps {
+    sections?: readonly SectionId[];
+}
+declare const widgetSuiteScenarios: Scenario<WidgetSuiteDemoProps>[];
+
+export { CARDS_PAGING, CARD_DETAILS_CARD_ID, CROSS_CUTTING_KEYS, EMBEDDED_PAGING, FINOPS, FINOPS_PAGING, IDENTITY, INIT, LOADING_DELAY_MS, PROXY, SCENARIO_LABELS, acceptDisclosuresScenarios, answer, answerFrom, balancesScenarios, bankAccountOnboardingScenarios, bankAccountsScenarios, billPayScenarios, bodyOf, cardDetailsScenarios, composeScenarios, counterpartsScenarios, creditCardsScenarios, crossCuttingScenarios, counterpartsScenarios as customersScenarios, debitCardsScenarios, defaultScenario, endpoint, expenseManagementScenarios, finopsPage, initRoute, insightsScenarios, invoicingScenarios, json, linkedAccountsScenarios, marketingScenarios, matchPath, noContent, page, paged, problem, productsScenarios, readRoute, receivablesScenarios, routesOf, scenarioFetch, settingsScenarios, templatePath, transfersScenarios, uploadReceiptScenarios, wait, widgetSuiteScenarios };
+export type { ConfigClient, CrossCuttingKey, CrossCuttingSpec, PagingStyle, PrimaryRead, RequestSummary, Route, RouteRequest, Scenario, ScenarioCopy, SettingsDemoProps, UploadReceiptDemoProps, UploadedFile, WidgetInit, WidgetSuiteDemoProps };

package/dist/scenarios/index.js

@@ -0,0 +1,42 @@
+import { CROSS_CUTTING_KEYS as e, SCENARIO_LABELS as t } from "../libs/tesouro-embedded-components-react/shared/data-access-mocks/dist/mocks/scenarios/labels.js";
+import { CARDS_PAGING as n, EMBEDDED_PAGING as r, FINOPS as i, FINOPS_PAGING as a, IDENTITY as o, INIT as s, LOADING_DELAY_MS as c, PROXY as l, answer as u, answerFrom as d, bodyOf as f, composeScenarios as p, crossCuttingScenarios as m, defaultScenario as h, endpoint as g, finopsPage as _, initRoute as v, json as y, matchPath as b, noContent as x, page as S, paged as C, problem as w, readRoute as T, routesOf as E, scenarioFetch as D, templatePath as O, wait as k } from "../libs/tesouro-embedded-components-react/shared/data-access-mocks/dist/mocks/scenarios/scenario.js";
+import { invoicingScenarios as A } from "../libs/tesouro-embedded-components-react/invoicing-widget/feature/dist/mocks/invoicing.js";
+import { counterpartsScenarios as j } from "../libs/tesouro-embedded-components-react/counterparts-widget/feature/dist/mocks/counterparts.js";
+import "../libs/tesouro-embedded-components-react/counterparts-widget/feature/dist/scenarios.js";
+import { productsScenarios as M } from "../libs/tesouro-embedded-components-react/products-widget/feature/dist/mocks/products.js";
+import "../libs/tesouro-embedded-components-react/products-widget/feature/dist/scenarios.js";
+import { receivablesScenarios as N } from "../libs/tesouro-embedded-components-react/invoicing-widget/feature/dist/mocks/receivables.js";
+import "../libs/tesouro-embedded-components-react/invoicing-widget/feature/dist/scenarios.js";
+import { expenseManagementScenarios as P } from "../libs/tesouro-embedded-components-react/expense-management-widget/feature/dist/mocks/expenseManagement.js";
+import "../libs/tesouro-embedded-components-react/expense-management-widget/feature/dist/scenarios.js";
+import { bankAccountOnboardingScenarios as F } from "../libs/tesouro-embedded-components-react/bank-account-onboarding-widget/feature/dist/mocks/bankAccountOnboarding.js";
+import "../libs/tesouro-embedded-components-react/bank-account-onboarding-widget/feature/dist/scenarios.js";
+import { billPayScenarios as I } from "../libs/tesouro-embedded-components-react/bill-pay-widget/feature/dist/mocks/billPay.js";
+import "../libs/tesouro-embedded-components-react/bill-pay-widget/feature/dist/scenarios.js";
+import { bankAccountsScenarios as L } from "../libs/tesouro-embedded-components-react/bank-accounts-widget/feature/dist/mocks/bankAccounts.js";
+import "../libs/tesouro-embedded-components-react/bank-accounts-widget/feature/dist/scenarios.js";
+import { acceptDisclosuresScenarios as R } from "../libs/tesouro-embedded-components-react/accept-disclosures-widget/feature/dist/mocks/acceptDisclosures.js";
+import "../libs/tesouro-embedded-components-react/accept-disclosures-widget/feature/dist/scenarios.js";
+import { balancesScenarios as z } from "../libs/tesouro-embedded-components-react/balances-widget/feature/dist/mocks/balances.js";
+import "../libs/tesouro-embedded-components-react/balances-widget/feature/dist/scenarios.js";
+import { CARD_DETAILS_CARD_ID as B, cardDetailsScenarios as V } from "../libs/tesouro-embedded-components-react/card-details-widget/feature/dist/mocks/cardDetails.js";
+import "../libs/tesouro-embedded-components-react/card-details-widget/feature/dist/scenarios.js";
+import { creditCardsScenarios as H } from "../libs/tesouro-embedded-components-react/cards-widget/feature/dist/mocks/creditCards.js";
+import { debitCardsScenarios as U } from "../libs/tesouro-embedded-components-react/cards-widget/feature/dist/mocks/debitCards.js";
+import "../libs/tesouro-embedded-components-react/cards-widget/feature/dist/scenarios.js";
+import "../libs/tesouro-embedded-components-react/customers-widget/feature/dist/scenarios.js";
+import { insightsScenarios as W } from "../libs/tesouro-embedded-components-react/insights-widget/feature/dist/mocks/insights.js";
+import "../libs/tesouro-embedded-components-react/insights-widget/feature/dist/scenarios.js";
+import { linkedAccountsScenarios as G } from "../libs/tesouro-embedded-components-react/linked-accounts-widget/feature/dist/mocks/linkedAccounts.js";
+import "../libs/tesouro-embedded-components-react/linked-accounts-widget/feature/dist/scenarios.js";
+import { marketingScenarios as K } from "../libs/tesouro-embedded-components-react/marketing-widget/feature/dist/mocks/marketing.js";
+import "../libs/tesouro-embedded-components-react/marketing-widget/feature/dist/scenarios.js";
+import { settingsScenarios as q } from "../libs/tesouro-embedded-components-react/settings-widget/feature/dist/mocks/settings.js";
+import "../libs/tesouro-embedded-components-react/settings-widget/feature/dist/scenarios.js";
+import { transfersScenarios as J } from "../libs/tesouro-embedded-components-react/transfers-widget/feature/dist/mocks/transfers.js";
+import "../libs/tesouro-embedded-components-react/transfers-widget/feature/dist/scenarios.js";
+import { uploadReceiptScenarios as Y } from "../libs/tesouro-embedded-components-react/upload-receipt-widget/feature/dist/mocks/uploadReceipt.js";
+import "../libs/tesouro-embedded-components-react/upload-receipt-widget/feature/dist/scenarios.js";
+import { widgetSuiteScenarios as X } from "../libs/tesouro-embedded-components-react/widget-suite/feature/dist/mocks/widgetSuite.js";
+import "../libs/tesouro-embedded-components-react/widget-suite/feature/dist/scenarios.js";
+export { n as CARDS_PAGING, B as CARD_DETAILS_CARD_ID, e as CROSS_CUTTING_KEYS, r as EMBEDDED_PAGING, i as FINOPS, a as FINOPS_PAGING, o as IDENTITY, s as INIT, c as LOADING_DELAY_MS, l as PROXY, t as SCENARIO_LABELS, R as acceptDisclosuresScenarios, u as answer, d as answerFrom, z as balancesScenarios, F as bankAccountOnboardingScenarios, L as bankAccountsScenarios, I as billPayScenarios, f as bodyOf, V as cardDetailsScenarios, p as composeScenarios, j as counterpartsScenarios, H as creditCardsScenarios, m as crossCuttingScenarios, j as customersScenarios, U as debitCardsScenarios, h as defaultScenario, g as endpoint, P as expenseManagementScenarios, _ as finopsPage, v as initRoute, W as insightsScenarios, A as invoicingScenarios, y as json, G as linkedAccountsScenarios, K as marketingScenarios, b as matchPath, x as noContent, S as page, C as paged, w as problem, M as productsScenarios, T as readRoute, N as receivablesScenarios, E as routesOf, D as scenarioFetch, q as settingsScenarios, O as templatePath, J as transfersScenarios, Y as uploadReceiptScenarios, k as wait, X as widgetSuiteScenarios };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tesouro/embedded-components-react",
-  "version": "0.5.235",
+  "version": "0.5.243",
   "license": "Apache-2.0",
   "type": "module",
   "packageDepSync": {
@@ -57,6 +57,11 @@
       "import": "./dist/fixtures/index.js",
       "default": "./dist/fixtures/index.js"
     },
+    "./scenarios": {
+      "types": "./dist/scenarios/index.d.ts",
+      "import": "./dist/scenarios/index.js",
+      "default": "./dist/scenarios/index.js"
+    },
     "./monite-sdk": {
       "types": "./dist/lib/monite-sdk.d.ts",
       "import": "./dist/lib/monite-sdk.js",

package/dist/libs/tesouro-embedded-components-react/bank-accounts-widget/feature/dist/index9.js

@@ -1 +0,0 @@
-import "./index8.js";