@wise/dynamic-flow-client 2.6.1 → 2.7.1

package/build/types/common/errorBoundary/ErrorBoundaryAlert.d.ts

@@ -0,0 +1,5 @@
+type Props = {
+    onDismiss: () => void;
+};
+export declare function ErrorBoundaryAlert({ onDismiss }: Props): JSX.Element;
+export {};

package/build/types/{dynamicFlow/DynamicFlowTypes.d.ts → dynamic-flow-types.d.ts}

@@ -1,17 +1,5 @@
-import { Action, Schema, Size, Step } from '@wise/dynamic-flow-types';
-import { EventHandler, LogEventHandler } from '../common/contexts';
-import { OnChangeProps } from '../jsonSchemaForm/JsonSchemaForm';
-export 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;
-};
+import type { Size, Step } from '@wise/dynamic-flow-types';
+export type DynamicFlowProps = DynamicFlowPropsWithInitialAction | DynamicFlowPropsWithInitialStep;
 export type DynamicFlowPropsWithInitialAction = DynamicFlowPropsBasic & {
     initialAction: InitialAction;
     initialStep?: never;
@@ -20,31 +8,11 @@ export type DynamicFlowPropsWithInitialStep = DynamicFlowPropsBasic & {
     initialAction?: never;
     initialStep: Step;
 };
-export type DynamicFlowProps = DynamicFlowPropsWithInitialAction | DynamicFlowPropsWithInitialStep;
 export type HttpClient = typeof fetch;
-export type ETag = string;
-export type LoaderConfig = {
-    size?: Size;
-    initial?: boolean;
-    submission?: boolean;
-};
-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;
-export type InitialAction = {
-    $id?: string;
-    url: string;
-    method?: 'GET';
-    data?: never;
-} | {
-    $id?: string;
-    url: string;
-    method: 'POST';
-    data: Record<string, unknown>;
-};
+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 - 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;
     /**
@@ -59,3 +27,31 @@ export type Feature = {
     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/index.d.ts

@@ -1,10 +1,10 @@
-export { convertStepToLayout, inlineReferences } from './step/layoutStep/utils';
-export { default as DynamicFlow } from './dynamicFlow';
+export { convertStepToLayout, inlineReferences } from './legacy/step/layoutStep/utils';
+export { default as DynamicFlow } from './legacy/dynamicFlow';
 export { makeHttpClient } from './common/makeHttpClient';
-export { default as JsonSchemaForm } from './jsonSchemaForm';
-export { DynamicLayout as Layout } from './layout';
-export { isValidSchema } from './common/validators';
+export { default as JsonSchemaForm } from './legacy/jsonSchemaForm';
+export { DynamicLayout as Layout } from './legacy/layout';
+export { isValidSchema } from './legacy/common/validators';
 export { default as translations } from './i18n';
-export * from './dynamicFlow/DynamicFlow';
-export type { DynamicFlowProps, InitialAction } from './dynamicFlow/DynamicFlowTypes';
+export * from './legacy/dynamicFlow/DynamicFlow';
+export type { DynamicFlowProps, InitialAction } from './dynamic-flow-types';
 export type { Step } from '@wise/dynamic-flow-types';

package/build/types/legacy/common/contexts/eventsContext/EventsContext.d.ts

@@ -0,0 +1,14 @@
+import type React from 'react';
+import type { EventHandler } from '../../../../dynamic-flow-types';
+type Props = {
+    metadata?: Record<string, unknown> & {
+        flowId?: string;
+        stepId?: string;
+    };
+    children: React.ReactNode;
+    onEvent: EventHandler;
+};
+export declare function EventsContextProvider({ metadata, children, onEvent }: Props): JSX.Element;
+export declare function useEventDispatcher(): EventHandler;
+export declare const getEventDispatcher: (onEvent: EventHandler, metadata?: Record<string, unknown>) => EventHandler;
+export {};

package/build/types/legacy/common/contexts/featureContext/FeatureContext.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import type { Feature } from '../../../../dynamic-flow-types';
+import type { FeatureName } from '../../constants/FeatureName';
+type FeatureContextProviderProps = {
+    features: Feature[] | undefined;
+    children: React.ReactNode;
+};
+export declare function FeatureContextProvider({ features, children }: FeatureContextProviderProps): JSX.Element;
+export declare const useFeatureFlag: (featureName: FeatureName) => Feature | undefined;
+export {};

package/build/types/{common → legacy/common}/contexts/httpClientContext/HttpClientContext.d.ts

@@ -1,15 +1,15 @@
 /// <reference types="react" />
-type HttpClient = typeof fetch;
+import type { HttpClient } from '../../../../dynamic-flow-types';
 type ProviderProps = {
     httpClient: HttpClient;
     children: React.ReactNode;
 };
-export declare const HttpClientProvider: ({ httpClient, children }: ProviderProps) => JSX.Element;
+export declare function HttpClientProvider({ httpClient, children }: ProviderProps): JSX.Element;
 type ProviderFromBaseUrlProps = {
     baseUrl: string;
     children: React.ReactNode;
 };
-export declare const HttpClientProviderFromBaseUrl: ({ baseUrl, children }: ProviderFromBaseUrlProps) => JSX.Element;
+export declare function HttpClientProviderFromBaseUrl({ baseUrl, children }: ProviderFromBaseUrlProps): JSX.Element;
 /**
  * Provides the fetch(er) function for dynamic flows asynchronous operations.
  */

package/build/types/{common → legacy/common}/contexts/logContext/LogContext.d.ts

@@ -1,9 +1,7 @@
 /// <reference types="react" />
-export type LogLevel = 'debug' | 'info' | 'warning' | 'error' | 'critical';
+import type { LogLevel, LogEventHandler } from '../../../../dynamic-flow-types';
 export type LogTitle = 'Invalid schema or model' | 'Invalid model on change' | 'Invalid response' | 'Action supressed' | 'Deprecation warning' | 'Deprecated schema' | 'Error fetching';
-type ExtraProps = Record<string, unknown>;
-export type LogEventHandler = (level: LogLevel, message: string, extra: ExtraProps) => void;
-type LogFunction = (title: LogTitle, description: string, extra?: ExtraProps) => void;
+type LogFunction = (title: LogTitle, description: string, extra?: Record<string, unknown>) => void;
 export declare const getLogger: (level: LogLevel, onLog: LogEventHandler, flowId?: string | undefined, stepId?: string | undefined) => LogFunction;
 type LogProviderProps = {
     flowId?: string;
@@ -11,7 +9,7 @@ type LogProviderProps = {
     children: React.ReactNode;
     onLog: LogEventHandler;
 };
-export declare const LogProvider: ({ flowId, stepId, children, onLog }: LogProviderProps) => JSX.Element;
+export declare function LogProvider({ flowId, stepId, children, onLog }: LogProviderProps): JSX.Element;
 export declare const useLogger: () => {
     debug: LogFunction;
     info: LogFunction;

package/build/types/{common → legacy/common}/hooks/useDebouncedFunction/useDebouncedFunction.d.ts

@@ -1,2 +1,2 @@
-import { DebouncedFunc } from '../../utils';
+import { type DebouncedFunc } from '../../utils';
 export declare function useDebouncedFunction<T extends (...args: any[]) => any>(callback: T, waitMs: number): DebouncedFunc<T>;

package/build/types/{common → legacy/common}/hooks/useExternalStepPolling/useExternalStepPolling.d.ts

@@ -1,3 +1,3 @@
-import { Action, ExternalStepPollingConfiguration } from '@wise/dynamic-flow-types';
+import type { Action, ExternalStepPollingConfiguration } from '@wise/dynamic-flow-types';
 /** @deprecated External step is no longer supported */
 export declare function useExternalStepPolling(polling: ExternalStepPollingConfiguration | undefined, onAction: (action: Action) => void): void;

package/build/types/{common → legacy/common}/hooks/usePersistAsync/usePersistAsync.d.ts

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

package/build/types/{common → legacy/common}/hooks/useStepPolling/useStepPolling.d.ts

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

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

@@ -1,4 +1,3 @@
 export declare function isStatus2xx(status: Response['status']): boolean;
 export declare function isStatus422(status: Response['status']): boolean;
-export declare function getJson(response: Response): Promise<any>;
 export declare function isRelativePath(url?: string): boolean;

package/build/types/{common → legacy/common}/utils/debounce.d.ts

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

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

@@ -1,4 +1,4 @@
-import { UploadedFile } from '@transferwise/components';
+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/{common → legacy/common}/utils/misc-utils.d.ts

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

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

@@ -1,4 +1,4 @@
-import { ArrayModel, BasicModel, Model, ObjectModel } from '@wise/dynamic-flow-types';
+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;

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

@@ -1,4 +1,4 @@
-import { AllOfSchema, ArraySchema, BasicSchema, BlobSchema, ConstSchema, FileUploadSchema, ListArraySchema, MultipleFileUploadSchema, ObjectSchema, OneOfObjectSchema, OneOfSchema, PersistAsyncSchema, Schema, StringSchema, TupleArraySchema, ValidationAsyncSchema } from '@wise/dynamic-flow-types';
+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;

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

@@ -1,3 +1,3 @@
-import { Schema, Step } from '@wise/dynamic-flow-types';
+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/{common → legacy/common}/validators/models/model-utils.d.ts

@@ -1,4 +1,4 @@
-import { AllOfSchema, ArrayModel, ArraySchema, BasicModel, Model, ObjectModel, ObjectSchema, OneOfSchema } from '@wise/dynamic-flow-types';
+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;

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

@@ -1,4 +1,4 @@
-import { BasicModel, Model, ObjectModel, Schema } from '@wise/dynamic-flow-types';
+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/{common → legacy/common}/validators/schemas/schema-validators.d.ts

@@ -1,4 +1,4 @@
-import { Model, Schema } from '@wise/dynamic-flow-types';
+import type { Model, Schema } from '@wise/dynamic-flow-types';
 /**
  * Validate any value against a given schema
  *

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

@@ -1,4 +1,4 @@
-import { BlobSchema, NumberSchema, IntegerSchema, Model, Schema, AllOfSchema, OneOfSchema, StringSchema } from '@wise/dynamic-flow-types';
+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[];

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/{dynamicFlow → legacy/dynamicFlow}/stories/fixtureHttpClient.d.ts

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

package/build/types/{dynamicFlow → legacy/dynamicFlow}/utils/index.d.ts

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

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

@@ -1,5 +1,5 @@
-import { ActionResponseBody, ErrorResponseBody, Step } from '@wise/dynamic-flow-types';
-import { DynamicFlowProps } from '../../DynamicFlowTypes';
+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];

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/{dynamicFlow → legacy/dynamicFlow}/utils/useDynamicFlowState.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="react" />
-import { FormErrors, GlobalError, ObjectModel, Step } from '@wise/dynamic-flow-types';
+import type { FormErrors, GlobalError, ObjectModel, Step } from '@wise/dynamic-flow-types';
 type ModelsMap = {
     [key: string]: ObjectModel;
 };

package/build/types/{dynamicFlow → legacy/dynamicFlow}/utils/useLoader.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="react" />
-import { DynamicFlowProps } from '../DynamicFlowTypes';
+import type { DynamicFlowProps } from '../../../dynamic-flow-types';
 type LoadingState = 'idle' | 'initial' | 'refresh' | 'submission';
 export declare function useLoader(loaderConfig: DynamicFlowProps['loaderConfig'], initialState: LoadingState): {
     isLoading: boolean;

package/build/types/{jsonSchemaForm → legacy/jsonSchemaForm}/JsonSchemaForm.d.ts

@@ -1,7 +1,7 @@
-import { FormErrors, Model, Schema } from '@wise/dynamic-flow-types';
-import { EventHandler, LogEventHandler } from '../common/contexts';
-import { OnPersistAsync } from '../dynamicFlow/DynamicFlowTypes';
-declare const JsonSchemaForm: (props: JsonSchemaFormProps) => JSX.Element;
+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;

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/arrayTypeSchema/arrayListSchema/multipleFileUploadSchema/MultipleFileUploadSchema.d.ts

@@ -0,0 +1,16 @@
+import type { ArrayModel, MultipleFileUploadSchema as MultipleFileUploadSchemaType } from '@wise/dynamic-flow-types';
+import type { GenericSchemaProps } from '../../../genericSchema/GenericSchema';
+declare function MultipleFileUploadSchema(props: Props): JSX.Element;
+declare namespace MultipleFileUploadSchema {
+    var defaultProps: {
+        errors: null;
+        required: boolean;
+    };
+}
+type Props = Omit<GenericSchemaProps, 'model'> & {
+    schema: MultipleFileUploadSchemaType;
+    model: ArrayModel | null;
+    required?: boolean;
+    errors?: string | null;
+};
+export default MultipleFileUploadSchema;

package/build/types/{jsonSchemaForm → legacy/jsonSchemaForm}/arrayTypeSchema/arrayListSchema/multipleFileUploadSchema/utils/upload-utils.d.ts

@@ -1,4 +1,4 @@
-import { UploadError, UploadResponse } from '@transferwise/components';
+import type { UploadError, UploadResponse } from '@transferwise/components';
 export declare function createPayload(userUploadedFile: Blob | string | null, isBlobSchema: boolean): Promise<string | Blob | null>;
 export declare function constructUploadResponse(response: {
     data: string | number;

package/build/types/{jsonSchemaForm → legacy/jsonSchemaForm}/arrayTypeSchema/arrayListSchema/repeatableSchema/RepeatableSchemaStep.d.ts

@@ -1,5 +1,5 @@
-import { FormErrors, ListArraySchema, Model } from '@wise/dynamic-flow-types';
-import { OnModelChange } from '../../../../dynamicFlow/DynamicFlowTypes';
+import type { FormErrors, ListArraySchema, Model } from '@wise/dynamic-flow-types';
+import type { OnModelChange } from '../../../../dynamicFlow/DynamicFlowTypes';
 export type RepeatableActionType = 'add' | 'edit' | 'remove';
 type RepeatableSchemaStepProps = {
     type: 'add' | 'edit';
@@ -10,5 +10,5 @@ type RepeatableSchemaStepProps = {
     onModelChange: OnModelChange;
     onAction: (actionType: RepeatableActionType) => void;
 };
-declare const RepeatableSchemaStep: ({ type, schema, model, errors, submitted, onModelChange, onAction, }: RepeatableSchemaStepProps) => JSX.Element;
+declare function RepeatableSchemaStep({ type, schema, model, errors, submitted, onModelChange, onAction, }: RepeatableSchemaStepProps): JSX.Element;
 export default RepeatableSchemaStep;

package/build/types/{jsonSchemaForm → legacy/jsonSchemaForm}/arrayTypeSchema/arrayListSchema/repeatableSchema/utils/summary-utils.d.ts

@@ -1,3 +1,3 @@
-import { ArraySchema, Model, Schema } from '@wise/dynamic-flow-types';
-import { ItemSummary } from '../ItemSummary';
+import type { ArraySchema, Model, Schema } from '@wise/dynamic-flow-types';
+import type { ItemSummary } from '../ItemSummary';
 export declare const getItemSummaryFromSchema: (schema: Schema, model: Model | null, defaults?: ArraySchema['summary']) => ItemSummary;

package/build/types/{jsonSchemaForm → legacy/jsonSchemaForm}/genericSchema/GenericSchema.d.ts

@@ -1,7 +1,7 @@
-import { FormErrors, Model, Schema } from '@wise/dynamic-flow-types';
-import { OnPersistAsync } from '../../dynamicFlow/DynamicFlowTypes';
-import { OnChange } from '../JsonSchemaForm';
-declare const GenericSchemaForm: (props: GenericSchemaFormProps) => JSX.Element;
+import type { FormErrors, Model, Schema } from '@wise/dynamic-flow-types';
+import type { OnPersistAsync } from '../../dynamicFlow/DynamicFlowTypes';
+import type { OnChange } from '../JsonSchemaForm';
+declare function GenericSchemaForm(props: GenericSchemaFormProps): JSX.Element;
 export type GenericSchemaProps = {
     schema: Schema;
     model: Model;

package/build/types/legacy/jsonSchemaForm/objectSchema/ObjectSchema.d.ts

@@ -0,0 +1,15 @@
+import type { ObjectModel, ObjectSchema as ObjectSchemaType } from '@wise/dynamic-flow-types';
+import type { GenericSchemaProps } from '../genericSchema/GenericSchema';
+declare function ObjectSchema(props: ObjectSchemaProps): JSX.Element;
+declare namespace ObjectSchema {
+    var defaultProps: {
+        hideTitle: boolean;
+        disabled: boolean;
+    };
+}
+export type ObjectSchemaProps = GenericSchemaProps & {
+    schema: ObjectSchemaType;
+    model: ObjectModel | null;
+    hideTitle?: boolean;
+};
+export default ObjectSchema;

package/build/types/legacy/jsonSchemaForm/oneOfSchema/OneOfSchema.d.ts

@@ -0,0 +1,14 @@
+import type { OneOfSchema as OneOfSchemaType } from '@wise/dynamic-flow-types';
+import type { GenericSchemaProps } from '../genericSchema/GenericSchema';
+declare function OneOfSchema(props: OneOfSchemaProps): JSX.Element | null;
+declare namespace OneOfSchema {
+    var defaultProps: {
+        required: boolean;
+        disabled: boolean;
+    };
+}
+export type OneOfSchemaProps = Omit<GenericSchemaProps, 'schema'> & {
+    schema: OneOfSchemaType;
+    required?: boolean;
+};
+export default OneOfSchema;

package/build/types/legacy/jsonSchemaForm/persistAsyncSchema/PersistAsyncSchema.d.ts

@@ -0,0 +1,15 @@
+import type { PersistAsyncSchema as PersistAsyncSchemaType } from '@wise/dynamic-flow-types';
+import type { GenericSchemaProps } from '../genericSchema/GenericSchema';
+declare function PersistAsyncSchema(props: PersistAsyncSchemaProps): JSX.Element;
+declare namespace PersistAsyncSchema {
+    var defaultProps: {
+        required: boolean;
+    };
+}
+export type PersistAsyncSchemaProps = Omit<GenericSchemaProps, 'schema' | 'model' | 'errors'> & {
+    schema: PersistAsyncSchemaType;
+    model: string | null;
+    errors: string | null;
+    required?: boolean;
+};
+export default PersistAsyncSchema;

package/build/types/{jsonSchemaForm → legacy/jsonSchemaForm}/persistAsyncSchema/persistAsyncBasicSchema/PersistAsyncBasicSchema.d.ts

@@ -1,15 +1,15 @@
-import { PersistAsync, Schema } from '@wise/dynamic-flow-types';
-import { GenericSchemaProps } from '../../genericSchema/GenericSchema';
+import type { PersistAsync, Schema } from '@wise/dynamic-flow-types';
+import type { GenericSchemaProps } from '../../genericSchema/GenericSchema';
 export declare const getIdFromResponse: (idProperty: string, response: Record<string, unknown>) => string | number;
 export declare const getErrorFromResponse: (errorProperty: string, response: {
     validation?: Record<string, unknown>;
 }) => unknown;
-declare const PersistAsyncBasicSchema: {
-    (props: PersistAsyncBasicSchemaProps): JSX.Element;
-    defaultProps: {
+declare function PersistAsyncBasicSchema(props: PersistAsyncBasicSchemaProps): JSX.Element;
+declare namespace PersistAsyncBasicSchema {
+    var defaultProps: {
         required: boolean;
     };
-};
+}
 type PersistAsyncBasicSchemaProps = Omit<GenericSchemaProps, 'schema'> & {
     schema: Schema & {
         persistAsync: PersistAsync;

package/build/types/{jsonSchemaForm → legacy/jsonSchemaForm}/persistAsyncSchema/persistAsyncBlobSchema/PersistAsyncBlobSchema.d.ts

@@ -1,11 +1,11 @@
-import { BlobSchema, PersistAsync, Schema } from '@wise/dynamic-flow-types';
-import { GenericSchemaProps } from '../../genericSchema/GenericSchema';
-declare const PersistAsyncBlobSchema: {
-    (props: PersistAsyncBlobSchemaProps): JSX.Element;
-    defaultProps: {
+import type { BlobSchema, PersistAsync, Schema } from '@wise/dynamic-flow-types';
+import type { GenericSchemaProps } from '../../genericSchema/GenericSchema';
+declare function PersistAsyncBlobSchema(props: PersistAsyncBlobSchemaProps): JSX.Element;
+declare namespace PersistAsyncBlobSchema {
+    var defaultProps: {
         required: boolean;
     };
-};
+}
 type PersistAsyncBlobSchemaProps = Omit<GenericSchemaProps, 'model'> & {
     schema: Schema & {
         persistAsync: PersistAsync & {

package/build/types/legacy/jsonSchemaForm/persistAsyncSchema/persistAsyncBlobSchema/UploadInputAdapter.d.ts

@@ -0,0 +1,16 @@
+import type { UploadProps } from '@transferwise/components/build/types/upload/Upload';
+import type { PersistAsync } from '@wise/dynamic-flow-types';
+import type { HttpClient } from '../../../../dynamic-flow-types';
+type Props = UploadProps & {
+    id: string;
+    httpClient: HttpClient;
+    fileId: number | string;
+    idProperty: string;
+    httpOptions: {
+        url: string;
+        method?: PersistAsync['method'];
+        fileInputName?: string;
+    };
+};
+export declare function UploadInputAdapter(props: Props): JSX.Element;
+export {};

package/build/types/{jsonSchemaForm → legacy/jsonSchemaForm}/promotedOneOfSchema/promotedOneOfControl/PromotedOneOfControl.d.ts

@@ -1,12 +1,12 @@
 /// <reference types="react" />
-import { Icon, Image, Promotion } from '@wise/dynamic-flow-types';
-declare const PromotedOneOfControl: {
-    (props: PromotedOneOfControlProps): JSX.Element;
-    defaultProps: {
+import type { Icon, Image, Promotion } from '@wise/dynamic-flow-types';
+declare function PromotedOneOfControl(props: PromotedOneOfControlProps): JSX.Element;
+declare namespace PromotedOneOfControl {
+    var defaultProps: {
         id: string;
         title: undefined;
     };
-};
+}
 export type PromotedOneOfControlProps = {
     id?: string;
     title?: string;

package/build/types/legacy/jsonSchemaForm/promotedOneOfSchema/promotedOneOfControl/PromotedOneOfRadioControl.d.ts

@@ -0,0 +1,8 @@
+import type { PromotedOneOfControlProps } from './PromotedOneOfControl';
+declare function PromotedOneOfRadioControl(props: PromotedOneOfControlProps): JSX.Element;
+declare namespace PromotedOneOfRadioControl {
+    var defaultProps: {
+        title: undefined;
+    };
+}
+export default PromotedOneOfRadioControl;

package/build/types/legacy/jsonSchemaForm/readOnlySchema/ReadOnlySchema.d.ts

@@ -0,0 +1,7 @@
+import type { Model, Schema } from '@wise/dynamic-flow-types';
+type ReadOnlySchemaProps = {
+    schema: Schema;
+    model: Model;
+};
+declare function ReadOnlySchema({ schema, model }: ReadOnlySchemaProps): JSX.Element;
+export default ReadOnlySchema;