@wise/dynamic-flow-client 0.0.0-experimental-20240319142919

package/build/types/legacy/common/hooks/usePersistAsync/usePersistAsync.d.ts

@@ -0,0 +1,7 @@
+import type { PersistAsync } from '@wise/dynamic-flow-types';
+type PersistAsyncModel = string | Blob | null;
+type PerformPersistAsyncFunction = (payload: PersistAsyncModel) => Promise<{
+    data: string | number;
+}>;
+export declare const usePersistAsync: (persistAsync: PersistAsync) => PerformPersistAsyncFunction;
+export {};

package/build/types/legacy/common/hooks/usePolling/usePolling.d.ts

@@ -0,0 +1,11 @@
+type PollingOptions<PR> = {
+    asyncFn: (() => Promise<PR>) | undefined;
+    interval: number;
+    maxAttempts: number;
+    maxConsecutiveFails: number;
+    onPollingResponse: (pollingResponse: PR) => boolean;
+    onFailure: () => void;
+};
+export declare function usePolling<PollingResponse>({ asyncFn, interval, maxAttempts, maxConsecutiveFails, onPollingResponse, onFailure, }: PollingOptions<PollingResponse>): void;
+export declare function createPollingClosure<PR>(asyncFn: (() => Promise<PR>) | undefined, maxAttempts: number, maxConsecutiveFails: number, onPollingResponse: (pollingResponse: PR) => boolean, onFailure: () => void): () => void;
+export {};

package/build/types/legacy/common/hooks/usePrevious/usePrevious.d.ts

@@ -0,0 +1 @@
+export function usePrevious(value: any): undefined;

package/build/types/legacy/common/hooks/useStepPolling/useStepPolling.d.ts

@@ -0,0 +1,2 @@
+import type { Action, PollingConfiguration } from '@wise/dynamic-flow-types';
+export declare function useStepPolling(polling: PollingConfiguration | undefined, onAction: (action: Action) => void): void;

package/build/types/legacy/common/messages.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    required: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};
+export default _default;

package/build/types/legacy/common/utils/api-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function isStatus2xx(status: Response['status']): boolean;
+export declare function isStatus422(status: Response['status']): boolean;

package/build/types/legacy/common/utils/date-utils.d.ts

@@ -0,0 +1,2 @@
+export declare const dateStringToDate: (dateString: string) => Date | null;
+export declare const dateToDateString: (date: Date) => string;

package/build/types/legacy/common/utils/debounce.d.ts

@@ -0,0 +1,6 @@
+export interface DebouncedFunc<T extends (...args: Parameters<T>) => ReturnType<T>> {
+    (...args: Parameters<T>): void;
+    cancel: () => void;
+    flush: () => void;
+}
+export declare const debounce: <T extends (...args: Parameters<T>) => ReturnType<T>>(callback: T, waitMs: number) => DebouncedFunc<T>;

package/build/types/legacy/common/utils/file-utils.d.ts

@@ -0,0 +1,4 @@
+import type { UploadedFile } from '@transferwise/components';
+export declare function toKilobytes(sizeInBytes: number): number;
+export declare const toBase64: (file: Blob) => Promise<string>;
+export declare function areFilesSame(newFiles: UploadedFile[], files: UploadedFile[]): boolean;

package/build/types/legacy/common/utils/id-utils.d.ts

@@ -0,0 +1 @@
+export declare const generateRandomId: (prefix?: string) => string;

package/build/types/legacy/common/utils/index.d.ts

@@ -0,0 +1,11 @@
+export * from './api-utils';
+export * from './date-utils';
+export * from './debounce';
+export * from './is-equal';
+export * from './file-utils';
+export * from './id-utils';
+export * from './step-utils';
+export * from './model-utils';
+export * from './misc-utils';
+export * from './schema-utils';
+export * from './mobile-utils';

package/build/types/legacy/common/utils/is-equal.d.ts

@@ -0,0 +1 @@
+export declare const isEqual: (a: unknown, b: unknown) => boolean;

package/build/types/legacy/common/utils/misc-utils.d.ts

@@ -0,0 +1,2 @@
+import type { FormErrors } from '@wise/dynamic-flow-types';
+export declare const isBasicError: (error: FormErrors) => error is string | null;

package/build/types/legacy/common/utils/mobile-utils.d.ts

@@ -0,0 +1,4 @@
+export declare const isMobile: () => boolean;
+export declare const isMobileUA: (userAgent?: string) => boolean;
+export declare const isMobileScreenSize: (width?: number, height?: number) => boolean;
+export declare const isTouchScreen: (navigator?: Navigator, matchMedia?: ((query: string) => MediaQueryList) & typeof matchMedia) => boolean;

package/build/types/legacy/common/utils/model-utils.d.ts

@@ -0,0 +1,7 @@
+import type { ArrayModel, BasicModel, Model, ObjectModel } from '@wise/dynamic-flow-types';
+export declare const isObjectModel: (model: Model) => model is ObjectModel;
+export declare const isNullableObjectModel: (model: Model) => model is ObjectModel | null;
+export declare const isNullableBasicModel: (model: Model) => model is BasicModel | null;
+export declare const isNullableStringModel: (model: Model) => model is string | null;
+export declare const isArrayModel: (model: Model) => model is ArrayModel;
+export declare const isNullableArrayModel: (model: Model) => model is ArrayModel | null;

package/build/types/legacy/common/utils/schema-utils.d.ts

@@ -0,0 +1,25 @@
+import type { AllOfSchema, ArraySchema, BasicSchema, BlobSchema, ConstSchema, FileUploadSchema, ListArraySchema, MultipleFileUploadSchema, ObjectSchema, OneOfObjectSchema, OneOfSchema, PersistAsyncSchema, Schema, StringSchema, TupleArraySchema, ValidationAsyncSchema } from '@wise/dynamic-flow-types';
+export declare function isConstSchema(schema: Schema | undefined): schema is ConstSchema;
+export declare function isNoNConstSchema(schema: Schema | undefined): boolean;
+export declare const isReadOnlySchema: (schema: Schema) => boolean;
+export declare const isPromotedOneOfSchema: (schema: Schema) => boolean;
+export declare const basicTypes: Set<string>;
+export declare function isBasicSchema(schema: Schema): schema is BasicSchema;
+export declare function isObjectSchema(schema: Schema): schema is ObjectSchema;
+export declare function isOneOfObjectSchema(schema: Schema): schema is OneOfObjectSchema;
+export declare function isOneOfSchema(schema: Schema): schema is OneOfSchema;
+export declare function isAllOfSchema(schema: Schema): schema is AllOfSchema;
+export declare function isBlobSchema(schema: Schema): schema is BlobSchema;
+export declare function isArraySchema(schema: Schema): schema is ArraySchema;
+export declare function isTupleArraySchema(schema: ArraySchema): schema is TupleArraySchema;
+export declare function isListArraySchema(schema: ArraySchema): schema is ListArraySchema;
+export declare function isStringSchema(schema: Schema): schema is StringSchema;
+export declare function isPersistAsyncSchema(schema: Schema): schema is PersistAsyncSchema;
+export declare function isPersistAsyncFileSchema(schema: Schema): schema is PersistAsyncSchema;
+export declare const isValidationAsyncSchema: (schema: Schema) => schema is ValidationAsyncSchema;
+export declare function isFileUploadSchema(schema: {
+    type?: string;
+    format?: string;
+}): schema is FileUploadSchema;
+export declare const isMultipleFileUploadSchema: (schema: Schema) => schema is MultipleFileUploadSchema;
+export declare const getSchemaType: (schema: Schema) => "allOf" | "persistAsync" | "array" | "object" | "oneOf" | "readOnly" | "validationAsync" | "promotedOneOf" | "basic" | null;

package/build/types/legacy/common/utils/step-utils.d.ts

@@ -0,0 +1,3 @@
+import type { Schema, Step } from '@wise/dynamic-flow-types';
+export declare const isCameraStep: (step: Step) => boolean;
+export declare const filterHiddenSchemas: (schemas: Schema[]) => Schema[];

package/build/types/legacy/common/validators/index.d.ts

@@ -0,0 +1,5 @@
+export { getValidModelParts, getValidObjectModelParts, getValidBasicModelOrNull, } from './models/model-validators';
+export { isValidSchema } from './schemas/schema-validators';
+export { getValidationFailures, getArrayValidationFailures, } from './validationFailures/validation-failures';
+export * from './types/type-validators';
+export * from './values/value-validators';

package/build/types/legacy/common/validators/models/model-utils.d.ts

@@ -0,0 +1,10 @@
+import type { AllOfSchema, ArrayModel, ArraySchema, BasicModel, Model, ObjectModel, ObjectSchema, OneOfSchema } from '@wise/dynamic-flow-types';
+export declare function cleanBasicModelWithOneOfSchema(model: BasicModel, schema: OneOfSchema): BasicModel | null;
+export declare function cleanArrayModelWithOneOfSchema(model: ArrayModel, schema: OneOfSchema): ArrayModel | null;
+export declare function cleanModelWithStringSchema(model: Model): string | null;
+export declare function cleanModelWithNumberSchema(model: Model): number | null;
+export declare function cleanModelWithBooleanSchema(model: Model): boolean | null;
+export declare function cleanModelWithArraySchema(model: Model, schema: ArraySchema): ArrayModel | null;
+export declare function cleanObjectModelWithObjectSchema(model: ObjectModel, schema: ObjectSchema): ObjectModel;
+export declare function cleanObjectModelWithAllOfSchema(model: ObjectModel, schema: AllOfSchema): ObjectModel;
+export declare function cleanObjectModelWithOneOfSchema(model: ObjectModel, schema: OneOfSchema): ObjectModel | null;

package/build/types/legacy/common/validators/models/model-validators.d.ts

@@ -0,0 +1,4 @@
+import type { BasicModel, Model, ObjectModel, Schema } from '@wise/dynamic-flow-types';
+export declare const getValidModelParts: (model: Model, schema: Schema) => Model;
+export declare function getValidBasicModelOrNull(model: BasicModel | null, schema: Schema): BasicModel | null;
+export declare function getValidObjectModelParts(model: ObjectModel | null, schema: Schema): ObjectModel | null;

package/build/types/legacy/common/validators/schemas/schema-validators.d.ts

@@ -0,0 +1,9 @@
+import type { Model, Schema } from '@wise/dynamic-flow-types';
+/**
+ * Validate any value against a given schema
+ *
+ * @param value
+ * @param schema
+ */
+declare function isValidSchema(value: Model, schema: Schema): boolean;
+export { isValidSchema };

package/build/types/legacy/common/validators/types/type-validators.d.ts

@@ -0,0 +1,8 @@
+export declare const isString: (value: unknown) => value is string;
+export declare const isNumber: (value: unknown) => value is number;
+export declare const isInteger: (value: unknown) => value is number;
+export declare const isBoolean: (value: unknown) => value is boolean;
+export declare const isObject: (value: unknown) => value is Record<string, unknown>;
+export declare const isArray: (value: unknown) => value is unknown[];
+export declare const isNull: (value: unknown) => value is null;
+export declare const isUndefined: (value: unknown) => value is undefined;

package/build/types/legacy/common/validators/validationFailures/validation-failures.d.ts

@@ -0,0 +1,23 @@
+import type { BlobSchema, NumberSchema, IntegerSchema, Model, Schema, AllOfSchema, OneOfSchema, StringSchema } from '@wise/dynamic-flow-types';
+declare function getValidationFailures(value: Model, schema: Schema, isRequired: boolean): string[];
+declare function getStringValidationFailures(value: Model, schema: StringSchema, isRequired?: boolean): string[];
+declare function getNumberValidationFailures(value: Model, schema: AllOfSchema | OneOfSchema | NumberSchema | IntegerSchema, isRequired?: boolean): string[];
+declare function getIntegerValidationFailures(value: Model, schema: AllOfSchema | OneOfSchema | NumberSchema | IntegerSchema, isRequired?: boolean): string[];
+declare function getBooleanValidationFailures(value: Model, _schema: Schema, isRequired?: boolean): string[];
+declare function getConstValidationFailures(value: Model, schema: Schema, isRequired?: boolean): string[];
+declare function getArrayValidationFailures(value: Model, schema: {
+    minItems?: number;
+    maxItems?: number;
+}, isRequired?: boolean): string[];
+declare function getBlobValidationFailures(value: Model, _schema: BlobSchema): string[];
+/**
+ * When validating an object we only checking that it is an object and that it
+ * has the required properties, we do not check if the properties are valid.
+ *
+ * @param value
+ * @param schema
+ */
+declare function getObjectValidationFailures(value: Model, schema: {
+    required?: string[];
+}): string[];
+export { getValidationFailures, getStringValidationFailures, getNumberValidationFailures, getIntegerValidationFailures, getBooleanValidationFailures, getConstValidationFailures, getArrayValidationFailures, getObjectValidationFailures, getBlobValidationFailures, };

package/build/types/legacy/common/validators/validationFailures/validation-failures.utils.d.ts

@@ -0,0 +1,10 @@
+declare function isValidRequired(value: unknown, isRequired?: boolean): boolean;
+declare function isValidRequiredArray(value: unknown, isRequired?: boolean): boolean;
+declare function isValidMinLength(value: unknown, minLength: number | undefined): boolean;
+declare function isValidMaxLength(value: unknown, maxLength: number | undefined): boolean;
+declare function isValidPattern(value: string | undefined | null, pattern: string | undefined): boolean;
+declare function isValidMaximum(value: unknown, maximum: string | number | undefined): boolean;
+declare function isValidMinimum(value: unknown, minimum: string | number | undefined): boolean;
+declare function isValidMinItems(value: unknown, minItems: number | undefined): boolean;
+declare function isValidMaxItems(value: unknown, maxItems: number | undefined): boolean;
+export { isValidRequired, isValidMinLength, isValidMaxLength, isValidPattern, isValidMaximum, isValidMinimum, isValidMinItems, isValidMaxItems, isValidRequiredArray, };

package/build/types/legacy/common/validators/values/value-validators.d.ts

@@ -0,0 +1,2 @@
+declare const isEmpty: (value: unknown) => boolean;
+export { isEmpty };

package/build/types/legacy/dynamic-flow-types.d.ts

@@ -0,0 +1,57 @@
+import type { Size, Step } from '@wise/dynamic-flow-types';
+export type DynamicFlowProps = DynamicFlowPropsWithInitialAction | DynamicFlowPropsWithInitialStep;
+export type DynamicFlowPropsWithInitialAction = DynamicFlowPropsBasic & {
+    initialAction: InitialAction;
+    initialStep?: never;
+};
+export type DynamicFlowPropsWithInitialStep = DynamicFlowPropsBasic & {
+    initialAction?: never;
+    initialStep: Step;
+};
+export type HttpClient = typeof fetch;
+export type EventHandler = (eventName: EventName, properties: Record<string, unknown>) => void;
+export type EventName = 'Dynamic Flow - Flow Started' | 'Dynamic Flow - Flow Finished' | 'Dynamic Flow - Step Started' | 'Dynamic Flow - Step Submitted' | 'Dynamic Flow - Step Refreshed' | 'Dynamic Flow - OneOf Selected' | 'Dynamic Flow - PersistAsync' | 'Dynamic Flow - ValidationAsync' | 'Dynamic Flow - Camera Permission Denied' | 'Dynamic Flow - Camera Feed Started' | 'Dynamic Flow - Camera Not Supported' | 'Dynamic Flow - Camera Not Accessible' | 'Dynamic Flow - Camera Orientation Locked' | 'Dynamic Flow - Camera Orientation Lock Overlay Shown' | 'Dynamic Flow - Search Started' | 'Dynamic Flow - Search Result Selected' | 'Dynamic Flow - invalid submission response' | 'Dynamic Flow - onAction supressed' | 'Dynamic Flow - OneOf Searched';
+export type LogLevel = 'debug' | 'info' | 'warning' | 'error' | 'critical';
+export type LogEventHandler = (level: LogLevel, message: string, extra: Record<string, unknown>) => void;
+export type Feature = {
+    featureName: string;
+    /**
+     * The variant of the feature active for the user/profile.
+     * 0 is usually the control, and > 0 are variants.
+     */
+    variant: number | null;
+    /**
+     * If the feature is enabled for the user/profile.
+     * This is the same as checking if `variant > 0`.
+     */
+    enabled: boolean;
+    initiation: 'MISSING' | 'SKIPPED' | 'DEFAULT' | 'INITIATED';
+};
+export type InitialAction = {
+    $id?: string;
+    url: string;
+    method?: 'GET';
+    data?: never;
+} | {
+    $id?: string;
+    url: string;
+    method: 'POST';
+    data: Record<string, unknown>;
+};
+export type LoaderConfig = {
+    size?: Size;
+    initial?: boolean;
+    submission?: boolean;
+};
+type DynamicFlowPropsBasic = {
+    flowId: string;
+    loaderConfig?: LoaderConfig;
+    displayStepTitle?: boolean;
+    features?: Feature[];
+    httpClient: HttpClient;
+    onCompletion: (result: Record<string, unknown> | undefined | null) => void;
+    onError: (error: unknown, status?: number) => void;
+    onEvent?: EventHandler;
+    onLog?: LogEventHandler;
+};
+export {};

package/build/types/legacy/dynamicFlow/BackButton.d.ts

@@ -0,0 +1,9 @@
+import type { Action } from '@wise/dynamic-flow-types';
+import type { OnAction } from './DynamicFlowTypes';
+type BackButtonProps = {
+    title?: string;
+    action: Action;
+    onAction: OnAction;
+};
+declare function BackButton({ title, action, onAction }: BackButtonProps): JSX.Element;
+export default BackButton;

package/build/types/legacy/dynamicFlow/DynamicFlow.d.ts

@@ -0,0 +1,3 @@
+import type { DynamicFlowProps } from '../dynamic-flow-types';
+declare function DynamicFlow(props: DynamicFlowProps): JSX.Element;
+export default DynamicFlow;

package/build/types/legacy/dynamicFlow/DynamicFlowStep.d.ts

@@ -0,0 +1,8 @@
+import type { GlobalError, Step } from '@wise/dynamic-flow-types';
+import type { LayoutStepProps } from '../step/layoutStep/LayoutStep';
+type DynamicFlowStepProps = Omit<LayoutStepProps, 'stepSpecification'> & {
+    step: Step | undefined;
+    globalError: GlobalError;
+};
+export declare function DynamicFlowStep(props: DynamicFlowStepProps): JSX.Element | null;
+export {};

package/build/types/legacy/dynamicFlow/DynamicFlowTypes.d.ts

@@ -0,0 +1,8 @@
+import type { Action, Schema } from '@wise/dynamic-flow-types';
+import type { OnChangeProps } from '../jsonSchemaForm/JsonSchemaForm';
+export type OnModelChangeProps = OnChangeProps & {
+    formSchema: Schema;
+};
+export type OnModelChange = (props: OnModelChangeProps) => void;
+export type OnAction = (action: Action) => void;
+export type OnPersistAsync = (promise: Promise<unknown>) => void;

package/build/types/legacy/dynamicFlow/index.d.ts

@@ -0,0 +1 @@
+export { default } from './DynamicFlow';

package/build/types/legacy/dynamicFlow/stories/fixtureHttpClient.d.ts

@@ -0,0 +1,3 @@
+import type { HttpClient } from '../../dynamic-flow-types';
+export declare const getObjectKeys: <T>(object: T) => (keyof T)[];
+export declare const fixtureHttpClient: HttpClient;

package/build/types/legacy/dynamicFlow/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from './useDebouncedRefresh/useDebouncedRefresh';
+export * from './useDynamicFlowState';
+export * from './useLoader';
+export { default as ErrorBoundary } from '../../../common/errorBoundary/ErrorBoundary';
+export * from './responseParsers/response-parsers';

package/build/types/legacy/dynamicFlow/utils/responseParsers/response-parsers.d.ts

@@ -0,0 +1,17 @@
+import type { ActionResponseBody, ErrorResponseBody, Step } from '@wise/dynamic-flow-types';
+import type { DynamicFlowProps } from '../../../dynamic-flow-types';
+type ParsedBody = {
+    type: 'exit';
+    result: Parameters<DynamicFlowProps['onCompletion']>[0];
+} | {
+    type: 'action';
+    action: ActionResponseBody['action'];
+} | {
+    type: 'step';
+    step: Step;
+    etag?: string;
+};
+export declare const parseFetchResponse: (response: Response) => Promise<ParsedBody>;
+export declare const parseErrorResponse: (response: Response) => Promise<ErrorResponseBody>;
+export declare const getJsonObjectOrNull: (response: Response) => Promise<Parameters<DynamicFlowProps['onCompletion']>[0]>;
+export {};

package/build/types/legacy/dynamicFlow/utils/useDebouncedRefresh/useDebouncedRefresh.d.ts

@@ -0,0 +1,5 @@
+import type { Schema } from '@wise/dynamic-flow-types';
+type FetchRefresh = (url: string, data: unknown, etag: string | undefined) => Promise<void | null>;
+export declare function useDebouncedRefresh(fetchRefresh: FetchRefresh): (url: string, data: unknown, etag: string | undefined, schema: Schema) => void;
+export declare const shouldDebounceSchema: (schema: Schema) => boolean;
+export {};

package/build/types/legacy/dynamicFlow/utils/useDynamicFlowState.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="react" />
+import type { FormErrors, GlobalError, ObjectModel, Step } from '@wise/dynamic-flow-types';
+type ModelsMap = {
+    [key: string]: ObjectModel;
+};
+export declare const useDynamicFlowState: (initialStep?: Step) => {
+    formErrors: FormErrors;
+    globalError: GlobalError;
+    step: Step | undefined;
+    models: ModelsMap;
+    etag: string | undefined;
+    modelIsValid: boolean;
+    setFormErrors: import("react").Dispatch<import("react").SetStateAction<FormErrors>>;
+    setGlobalError: import("react").Dispatch<import("react").SetStateAction<GlobalError>>;
+    setStepAndEtag: (step: Step, etag?: string) => void;
+    setSchemaModel: (schemaId: string, objectModel: ObjectModel, onModelsUpdated: (models: ModelsMap) => void) => void;
+};
+export {};

package/build/types/legacy/dynamicFlow/utils/useLoader.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import type { DynamicFlowProps } from '../../dynamic-flow-types';
+type LoadingState = 'idle' | 'initial' | 'refresh' | 'submission';
+export declare function useLoader(loaderConfig: DynamicFlowProps['loaderConfig'], initialState: LoadingState): {
+    isLoading: boolean;
+    setLoadingState: import("react").Dispatch<import("react").SetStateAction<"initial" | "idle" | "refresh" | "submission">>;
+    loader: JSX.Element | null;
+};
+export {};

package/build/types/legacy/formControl/FormControl.d.ts

@@ -0,0 +1,144 @@
+import { type RadioGroupProps } from '@transferwise/components';
+import type { UploadProps } from '@transferwise/components/build/types/upload/Upload';
+import type { AutocompleteToken } from '@wise/dynamic-flow-types';
+import { type ReactNode, PureComponent } from 'react';
+import { FormControlType } from '../common/constants';
+import type { OnChangeProps } from '../jsonSchemaForm/JsonSchemaForm';
+type RadioGroupRadios = RadioGroupProps<string | number>['radios'][number];
+export default class FormControl extends PureComponent<FormControlProps, FormControlState> {
+    static Type: {
+        RADIO: string;
+        CHECKBOX: string;
+        SELECT: string;
+        EMAIL: string;
+        FILE: string;
+        DATE: string;
+        DATETIME: string;
+        DATELOOKUP: string;
+        TEL: string;
+        NUMERIC: string;
+        NUMBER: string;
+        HIDDEN: string;
+        PASSWORD: string;
+        TEXT: string;
+        TEXTAREA: string;
+        UPLOAD: string;
+        TAB: string;
+    };
+    static Size: {
+        EXTRA_SMALL: string;
+        SMALL: string;
+        MEDIUM: string;
+        LARGE: string;
+        EXTRA_LARGE: string;
+    };
+    static MonthFormat: {
+        SHORT: string;
+        LONG: string;
+    };
+    static DateMode: {
+        DAY_MONTH_YEAR: string;
+        MONTH_YEAR: string;
+    };
+    constructor(props: FormControlProps);
+    static getDerivedStateFromProps(nextProps: FormControlProps, previousState: FormControlState): {
+        prevValue: string | number | boolean | Date | null;
+        value: string | number | boolean | Date | null;
+    } | null;
+    getAutocompleteValue: () => string;
+    handleOnChange: (value: string | number | boolean | null, metadata?: OnChangeProps['metadata']) => void;
+    handleInputOnChange: React.ChangeEventHandler<HTMLInputElement | HTMLTextAreaElement>;
+    handleOnFocus: () => void;
+    handleOnBlur: () => void;
+    getSelectedOption: (options: FormControlOption[]) => FormControlOption | undefined;
+    mapOption: (option: FormControlOption) => RadioGroupRadios;
+    render(): JSX.Element;
+    static defaultProps: {
+        autoComplete: boolean;
+        countryCode: null;
+        disabled: boolean;
+        displayPattern: null;
+        id: null;
+        label: string;
+        max: null;
+        maxDate: null;
+        maxLength: null;
+        min: null;
+        minDate: null;
+        minLength: null;
+        mode: string;
+        monthFormat: string;
+        onBlur: null;
+        onFocus: null;
+        onSearchChange: null;
+        options: never[];
+        placeholder: null;
+        readOnly: boolean;
+        required: boolean;
+        searchPlaceholder: null;
+        searchValue: string;
+        selectedOption: null;
+        size: string;
+        step: number;
+        type: string;
+        uploadProps: {};
+        value: null;
+    };
+}
+type FormControlOption = {
+    value: number | string | boolean;
+    label: string;
+    disabled?: boolean;
+    note?: string;
+    secondary?: string;
+};
+type FormControlSelectedOption = {
+    value: number | string | boolean;
+    label: string;
+    icon?: ReactNode;
+    currency?: string;
+    note?: ReactNode;
+    secondary?: ReactNode;
+};
+type FormControlProps = {
+    name: string;
+    onChange: (value: string | number | boolean | null, type?: 'init' | 'user', metadata?: OnChangeProps['metadata']) => void;
+    /** @deprecated - Use autocompleteHint instead */
+    autoComplete?: boolean;
+    autocompleteHint?: AutocompleteToken[];
+    countryCode?: string;
+    disabled?: boolean;
+    displayPattern?: string;
+    id: string;
+    label?: string;
+    max?: number;
+    maxDate?: Date;
+    maxLength?: number;
+    min?: number;
+    minDate?: Date;
+    minLength?: number;
+    mode?: 'day-month-year' | 'month-year';
+    monthFormat?: 'long' | 'short';
+    onBlur?: () => void;
+    onFocus?: () => void;
+    onSearchChange?: (searchValue: string) => void;
+    options: FormControlOption[];
+    placeholder?: string;
+    readOnly?: boolean;
+    required?: boolean;
+    searchPlaceholder?: string;
+    searchValue?: string;
+    selectedOption?: FormControlSelectedOption;
+    size?: 'sm' | 'md' | 'lg';
+    step?: number;
+    type?: (typeof FormControlType)[keyof typeof FormControlType];
+    uploadProps: UploadProps;
+    value: Date | string | number | boolean | null;
+    describedBy: string | undefined;
+};
+type FormControlState = {
+    prevValue: FormControlProps['value'];
+    selectedOption: FormControlSelectedOption | null | undefined;
+    touched: boolean;
+};
+export {};

package/build/types/legacy/formControl/index.d.ts

@@ -0,0 +1 @@
+export { default } from './FormControl';

package/build/types/legacy/formControl/utils/getAutocompleteString.d.ts

@@ -0,0 +1,2 @@
+import type { AutocompleteToken } from '@wise/dynamic-flow-types';
+export declare const getAutocompleteString: (hints: AutocompleteToken[]) => string;

package/build/types/legacy/formControl/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './value-utils';
+export { getAutocompleteString } from './getAutocompleteString';

package/build/types/legacy/formControl/utils/value-utils.d.ts

@@ -0,0 +1,9 @@
+type GetValueOptions = {
+    coerceValue?: boolean;
+};
+export declare const getSafeStringValue: (value: unknown, options?: GetValueOptions) => string | undefined;
+export declare const getSafeStringOrNumberValue: (value: unknown, options?: GetValueOptions) => string | number | undefined;
+export declare const getSafeBooleanValue: (value: unknown, options?: GetValueOptions) => boolean | undefined;
+export declare const getSafeDateOrStringValue: (value: unknown) => string | Date | undefined;
+export declare const getSafeDateStringValue: (value: unknown) => Date | null;
+export {};

package/build/types/legacy/jsonSchemaForm/JsonSchemaForm.d.ts

@@ -0,0 +1,65 @@
+import type { FormErrors, Model, Schema } from '@wise/dynamic-flow-types';
+import type { EventHandler, LogEventHandler } from '../dynamic-flow-types';
+import type { OnPersistAsync } from '../dynamicFlow/DynamicFlowTypes';
+declare function JsonSchemaForm(props: JsonSchemaFormProps): JSX.Element;
+export type OnChange = (parameters: OnChangeProps) => void;
+export type OnChangeProps = {
+    model: Model;
+    triggerSchema: Schema;
+    triggerModel: Model;
+    lastTriggerModel?: Model;
+    type?: 'init' | 'user';
+    metadata?: Record<string, unknown> | undefined;
+};
+export type JsonSchemaFormProps = {
+    /**
+     * The JSON schema we're trying to satisfy
+     */
+    schema: Schema;
+    /**
+     * An initial data model
+     */
+    model?: Model;
+    /**
+     * Errors should be human readable strings, the object should match the shape of the model.
+     */
+    errors?: FormErrors;
+    /**
+     * Fires when the internal data model changes as a result of form interaction.
+     *
+     * Provide a single object parameter with five properties:
+     *  - model: the new model (for the entire form)
+     *  - triggerSchema: the schema that triggered the change
+     *  - triggerModel: the model that changed (e.g. some string, number, boolean)
+     *  - lastTriggerModel: the previous value of that model
+     *  - type: the type of change: 'init' if the change was caused by initialisation, or 'user' if the change was caused by user interaction
+     */
+    onChange: OnChange;
+    /**
+     * Tell the form if it has been submitted, triggering display of any validation failures.
+     */
+    submitted: boolean;
+    /**
+     * Tell the form if it should disable all controls.
+     */
+    disabled?: boolean;
+    /**
+     * Fires when any internal persist async is triggered and API call is underway.
+     *
+     * Provides a Promise of the persist async call.
+     */
+    onPersistAsync: OnPersistAsync;
+    /**
+     * Fires when there is a trackable event
+     */
+    onEvent?: EventHandler;
+    /**
+     * Fires when there is a logging event
+     */
+    onLog?: LogEventHandler;
+    /**
+     * Specifies the baseUrl of persist async and validation async requests.
+     */
+    baseUrl?: string;
+};
+export default JsonSchemaForm;

package/build/types/legacy/jsonSchemaForm/allOfSchema/AllOfSchema.d.ts

@@ -0,0 +1,13 @@
+import type { AllOfSchema as AllOfSchemaType, ObjectModel } from '@wise/dynamic-flow-types';
+import type { GenericSchemaProps } from '../genericSchema/GenericSchema';
+declare function AllOfSchema(props: AllOfSchemaProps): JSX.Element;
+declare namespace AllOfSchema {
+    var defaultProps: {
+        disabled: boolean;
+    };
+}
+export type AllOfSchemaProps = Omit<GenericSchemaProps, 'schema' | 'model'> & {
+    schema: AllOfSchemaType;
+    model: ObjectModel;
+};
+export default AllOfSchema;

package/build/types/legacy/jsonSchemaForm/allOfSchema/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './AllOfSchema';
+export type { AllOfSchemaProps } from './AllOfSchema';