@wise/dynamic-flow-client 2.8.1 → 2.8.3

package/build/types/index.d.ts

@@ -6,5 +6,5 @@ export { DynamicLayout as Layout } from './legacy/layout';
 export { isValidSchema } from './legacy/common/validators';
 export { default as translations } from './i18n';
 export * from './legacy/dynamicFlow/DynamicFlow';
-export type { DynamicFlowProps, InitialAction } from './dynamic-flow-types';
+export type { DynamicFlowProps, InitialAction } from './legacy/dynamic-flow-types';
 export type { Step } from '@wise/dynamic-flow-types';

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

@@ -1,5 +1,5 @@
 import type React from 'react';
-import type { EventHandler } from '../../../../dynamic-flow-types';
+import type { EventHandler } from '../../../dynamic-flow-types';
 type Props = {
     metadata?: Record<string, unknown> & {
         flowId?: string;

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

@@ -1,5 +1,5 @@
 /// <reference types="react" />
-import type { Feature } from '../../../../dynamic-flow-types';
+import type { Feature } from '../../../dynamic-flow-types';
 import type { FeatureName } from '../../constants/FeatureName';
 type FeatureContextProviderProps = {
     features: Feature[] | undefined;

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

@@ -1,5 +1,5 @@
 /// <reference types="react" />
-import type { HttpClient } from '../../../../dynamic-flow-types';
+import type { HttpClient } from '../../../dynamic-flow-types';
 type ProviderProps = {
     httpClient: HttpClient;
     children: React.ReactNode;

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

@@ -1,5 +1,5 @@
 /// <reference types="react" />
-import type { LogLevel, LogEventHandler } from '../../../../dynamic-flow-types';
+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 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;

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

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

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

@@ -1,3 +1,3 @@
-import type { HttpClient } from '../../../dynamic-flow-types';
+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/responseParsers/response-parsers.d.ts

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

@@ -1,5 +1,5 @@
 /// <reference types="react" />
-import type { DynamicFlowProps } from '../../../dynamic-flow-types';
+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/legacy/jsonSchemaForm/JsonSchemaForm.d.ts

@@ -1,5 +1,5 @@
 import type { FormErrors, Model, Schema } from '@wise/dynamic-flow-types';
-import type { EventHandler, LogEventHandler } from '../../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;

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

@@ -1,4 +1,4 @@
-import { Model, ObjectModel, OneOfSchema, OneOfObjectSchema } from '@wise/dynamic-flow-types';
+import type { Model, ObjectModel, OneOfSchema, OneOfObjectSchema } from '@wise/dynamic-flow-types';
 export declare const getActiveSchemaIndex: (schema: OneOfSchema, model: Model) => number | null;
 export declare const getValidIndexFromValue: (schema: OneOfSchema, value: Model | undefined) => number;
 export declare function getBestMatchingSchemaIndexForValue(schema: OneOfObjectSchema, value: ObjectModel): number | null;

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

@@ -1,6 +1,6 @@
 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';
+import type { HttpClient } from '../../../dynamic-flow-types';
 type Props = UploadProps & {
     id: string;
     httpClient: HttpClient;

package/build/types/legacy/layout/search/useSearch.d.ts

@@ -1,6 +1,6 @@
 import type { SearchConfig, SearchResult } from '@wise/dynamic-flow-types';
 export declare const useSearch: (defaultSearchConfig: SearchConfig) => {
-    status: "error" | "success" | "loading" | "idle";
+    status: "success" | "loading" | "error" | "idle";
     results: SearchResult[];
     search: (query: string, { url, method, param }?: SearchConfig) => Promise<void>;
 };

package/build/types/legacy/step/cameraStep/cameraCapture/CameraCapture.d.ts

@@ -1,5 +1,5 @@
 import type { CameraDirection } from '@wise/dynamic-flow-types';
-import type { EventHandler } from '../../../../dynamic-flow-types';
+import type { EventHandler } from '../../../dynamic-flow-types';
 type Props = {
     direction?: CameraDirection;
     overlay?: string;

package/build/types/legacy/step/cameraStep/cameraCapture/hooks/useFullScreenOrientationLock.d.ts

@@ -1,4 +1,4 @@
-import type { EventHandler } from '../../../../../dynamic-flow-types';
+import type { EventHandler } from '../../../../dynamic-flow-types';
 export declare const useFullScreenOrientationLock: (shouldLockOrientation: boolean, onEvent: EventHandler | undefined) => {
     enterFullScreen: () => void;
     exitFullScreen: () => void;

package/build/types/legacy/step/cameraStep/cameraCapture/tracking/index.d.ts

@@ -1,5 +1,5 @@
 import type { CameraDirection } from '@wise/dynamic-flow-types';
-import type { EventHandler, EventName } from '../../../../../dynamic-flow-types';
+import type { EventHandler, EventName } from '../../../../dynamic-flow-types';
 export declare const trackCameraError: (message: EventName, onEvent: EventHandler | undefined, error: string | DOMException) => void | undefined;
 export declare const trackCameraFeedStarted: (onEvent: EventHandler | undefined, props: {
     direction?: CameraDirection;

package/build/types/legacy/test-utils/DynamicFlowProviders.d.ts

@@ -1,5 +1,5 @@
 import type React from 'react';
-import type { EventHandler, LogEventHandler } from '../../dynamic-flow-types';
+import type { EventHandler, LogEventHandler } from '../dynamic-flow-types';
 type DynamicFlowProvidersProps = {
     children: React.ReactNode;
     onLog?: LogEventHandler;

package/build/types/legacy/test-utils/legacy-utils.d.ts

@@ -1,6 +1,6 @@
 import { type ReactWrapper } from 'enzyme';
 import type { ReactNode } from 'react';
-import type { EventHandler, LogEventHandler } from '../../dynamic-flow-types';
+import type { EventHandler, LogEventHandler } from '../dynamic-flow-types';
 declare const getMockFetchPromise: (status: number, jsonFn: () => void, delay: number, signal?: AbortSignal | null) => Promise<Response>;
 declare const wait: (t: number) => Promise<unknown>;
 declare function mountWithProviders(component: ReactNode, locale?: string, messages?: Record<string, unknown>, baseUrl?: string, onEvent?: EventHandler, onLog?: LogEventHandler): ReactWrapper;

package/build/types/revamp/DynamicFlowRevamp.d.ts

@@ -1,7 +1,3 @@
-import type { Step as DFStep } from '@wise/dynamic-flow-types/build/next';
-import type { DynamicFlowProps } from '../dynamic-flow-types';
-type Props = Omit<DynamicFlowProps, 'initialStep'> & {
-    initialStep?: DFStep;
-};
-declare function DynamicFlowRevamp({ initialStep, onError }: Props): JSX.Element;
+import type { DynamicFlowProps } from './dynamic-flow-types';
+declare function DynamicFlowRevamp(props: DynamicFlowProps): JSX.Element;
 export default DynamicFlowRevamp;

package/build/types/revamp/domain/components/IntegerInputComponent.d.ts

@@ -0,0 +1,8 @@
+import type { InputComponent, UpdateComponent } from '../types';
+import type { IsInvalidCheck } from '../validation/value-checks';
+export type IntegerInputComponent = InputComponent<number> & {
+    type: 'integer';
+};
+export declare const createIntegerInputComponent: (integerInputProps: Pick<IntegerInputComponent, "description" | "disabled" | "title" | "placeholder" | "control" | "id" | "errors" | "value" | "autoComplete" | "uid"> & {
+    checks: IsInvalidCheck<number | null>[];
+}, updateComponent: UpdateComponent) => IntegerInputComponent;

package/build/types/revamp/domain/components/NumberInputComponent.d.ts

@@ -0,0 +1,8 @@
+import type { InputComponent, UpdateComponent } from '../types';
+import type { IsInvalidCheck } from '../validation/value-checks';
+export type NumberInputComponent = InputComponent<number> & {
+    type: 'number';
+};
+export declare const createNumberInputComponent: (numberInputProps: Pick<NumberInputComponent, "description" | "disabled" | "title" | "placeholder" | "control" | "id" | "errors" | "value" | "autoComplete" | "uid"> & {
+    checks: IsInvalidCheck<number | null>[];
+}, updateComponent: UpdateComponent) => NumberInputComponent;

package/build/types/revamp/domain/components/ObjectComponent.d.ts

@@ -1,11 +1,12 @@
 import type { Model } from '@wise/dynamic-flow-types/build/next';
 import type { BaseComponent, StepComponent } from '../types';
-export type ObjectComponent = BaseComponent<Record<string, Model>> & {
+export type ObjectComponent = Omit<BaseComponent<Record<string, Model>>, 'getValue'> & {
     type: 'object';
     title?: string;
     description?: string;
     componentMap: Record<string, StepComponent>;
     getChildren: () => StepComponent[];
+    getValue: () => Record<string, Model>;
 };
 export declare const createObjectComponent: (objectProps: {
     uid: string;

package/build/types/revamp/domain/components/TextInputComponent.d.ts

@@ -1,24 +1,8 @@
-import type { StringSchemaFormat } from '@wise/dynamic-flow-types/build/next';
 import type { InputComponent, UpdateComponent } from '../types';
-export type TextInputComponent = InputComponent<string | null> & {
+import type { IsInvalidCheck } from '../validation/value-checks';
+export type TextInputComponent = InputComponent<string> & {
     type: 'text';
-    title?: string;
-    description?: string;
-    placeholder?: string;
-    control?: string;
-    format?: 'date';
-    value: string | null;
-    errors: string[];
-    onChange: (value: string | null) => void;
 };
-export declare const createTextInputComponent: (textInputProps: {
-    uid: string;
-    id: string;
-    title?: string | undefined;
-    description?: string | undefined;
-    placeholder?: string | undefined;
-    control?: string | undefined;
-    format?: StringSchemaFormat | undefined;
-    value: string | null;
-    validate: (value: string | null) => string[];
+export declare const createTextInputComponent: (textInputProps: Pick<TextInputComponent, "description" | "disabled" | "title" | "placeholder" | "control" | "id" | "errors" | "value" | "autoComplete" | "uid"> & {
+    checks: IsInvalidCheck<string | null>[];
 }, updateComponent: UpdateComponent) => TextInputComponent;

package/build/types/revamp/domain/components/utils/component-utils.d.ts

@@ -0,0 +1,12 @@
+import type { StepComponent, UpdateComponent } from '../../types';
+/**
+ * Helper function to update a component.
+ *
+ * `updateComponent` is generic, meaning we have to specify the type of the draft whenever we use it. This function takes
+ * the component uid and type, and returns a typed function that will update the component without the need to type assert.
+ *
+ * @param uid uid of the component
+ * @param updateComponent the updateComponent function that will update the component with the given uid
+ * @returns a function that accepts a function that will update the component
+ */
+export declare const getInputUpdateFunction: <C extends StepComponent>(uid: string, updateComponent: UpdateComponent) => (updateFn: (component: C) => void) => void;

package/build/types/revamp/domain/events/getAnalyticsEventDispatcher.d.ts

@@ -0,0 +1,9 @@
+import type { Step } from '@wise/dynamic-flow-types/build/next';
+export type AnalyticsEventHandler = (eventName: string, properties?: Record<string, unknown>) => void;
+export type AnalyticsEventDispatcher = (eventName: EventName, properties?: Record<string, unknown>) => void;
+export declare const getAnalyticsEventDispatcher: ({ flowId, step, onEvent, }: {
+    flowId: string;
+    step?: Step | null | undefined;
+    onEvent?: AnalyticsEventHandler | undefined;
+}) => AnalyticsEventDispatcher;
+export type EventName = 'Flow Started' | 'Flow Completed' | 'Step Shown' | 'Action Triggered' | 'Action Succeeded' | 'Action Failed' | 'Refresh Triggered' | 'Refresh Succeeded' | 'Refresh Failed' | 'PersistAsync Triggered' | 'PersistAsync Succeeded' | 'PersistAsync Failed' | 'ValidationAsync Triggered' | 'ValidationAsync Succeeded' | 'ValidationAsync Failed' | 'Search Started' | 'Search Result Selected';

package/build/types/revamp/domain/events/getLogggingEventDispatcher.d.ts

@@ -0,0 +1,4 @@
+export type LogLevel = 'info' | 'warning' | 'error';
+export type LoggingEventHandler = (level: LogLevel, message: string, extra: Record<string, unknown>) => void;
+export type LoggingEventDispatcher = (level: LogLevel, message: string, extra?: Record<string, unknown>) => void;
+export declare const getLoggingEventDispatcher: (onLog?: LoggingEventHandler) => LoggingEventDispatcher;

package/build/types/revamp/domain/events/index.d.ts

@@ -0,0 +1,2 @@
+export * from './getAnalyticsEventDispatcher';
+export * from './getLogggingEventDispatcher';

package/build/types/revamp/domain/mappers/mapSchemaToComponent.d.ts

@@ -1,3 +1,3 @@
 import type { StepComponent } from '../types';
 import type { MapperProps, SchemaMapperProps } from './schema/types';
-export declare const mapSchemaToComponent: (uid: string, { schema, model }: SchemaMapperProps, mapperProps: MapperProps) => StepComponent;
+export declare const mapSchemaToComponent: (uid: string, schemaMapperProps: SchemaMapperProps, mapperProps: MapperProps) => StepComponent;

package/build/types/revamp/domain/mappers/schema/integerSchemaToComponent.d.ts

@@ -0,0 +1,5 @@
+import type { MapperProps, SchemaMapperProps } from './types';
+import type { IntegerSchema } from '@wise/dynamic-flow-types/build/next';
+export declare const integerSchemaToComponent: (uid: string, schemaMapperProps: SchemaMapperProps & {
+    schema: IntegerSchema;
+}, mapperProps: MapperProps) => import("../../components/IntegerInputComponent").IntegerInputComponent;

package/build/types/revamp/domain/mappers/schema/numberSchemaToComponent.d.ts

@@ -0,0 +1,5 @@
+import type { MapperProps, SchemaMapperProps } from './types';
+import type { NumberSchema } from '@wise/dynamic-flow-types/build/next';
+export declare const numberSchemaToComponent: (uid: string, schemaMapperProps: SchemaMapperProps & {
+    schema: NumberSchema;
+}, mapperProps: MapperProps) => import("../../components/NumberInputComponent").NumberInputComponent;

package/build/types/revamp/domain/mappers/schema/objectSchemaToComponent.d.ts

@@ -1,5 +1,5 @@
 import type { ObjectSchema } from '@wise/dynamic-flow-types/build/next';
 import type { MapperProps, SchemaMapperProps } from './types';
-export declare const objectSchemaToComponent: (uid: string, { schema, model }: SchemaMapperProps & {
+export declare const objectSchemaToComponent: (uid: string, { schema, model, validationErrors }: SchemaMapperProps & {
     schema: ObjectSchema;
 }, mapperProps: MapperProps) => import("../../components/ObjectComponent").ObjectComponent;

package/build/types/revamp/domain/mappers/schema/stringSchemaToComponent.d.ts

@@ -1,12 +1,5 @@
 import type { StringSchema } from '@wise/dynamic-flow-types/build/next';
 import type { MapperProps, SchemaMapperProps } from './types';
-import type { GetErrorMessageFunctions } from '../types';
-export declare const stringSchemaToComponent: (uid: string, { schema, model, required }: SchemaMapperProps & {
+export declare const stringSchemaToComponent: (uid: string, schemaMapperProps: SchemaMapperProps & {
     schema: StringSchema;
 }, mapperProps: MapperProps) => import("../../components/TextInputComponent").TextInputComponent;
-export declare const getStringValidationErrors: ({ schema, model, required, getErrorMessageFunctions, }: {
-    schema: StringSchema;
-    model: string | null;
-    required: boolean;
-    getErrorMessageFunctions: GetErrorMessageFunctions;
-}) => string[];

package/build/types/revamp/domain/mappers/schema/tests/test-utils.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="jest" />
+import type { Schema, Step } from '@wise/dynamic-flow-types/build/next';
+import type { MapperProps, SchemaMapperProps } from '../types';
+import type { StepComponent } from '../../../types';
+export declare const getMockMapperProps: (mapperProps?: Partial<MapperProps>) => {
+    step: Step;
+    getErrorMessageFunctions: jest.Mock<any, any, any> | import("../../types").GetErrorMessageFunctions;
+    onAction: jest.Mock<any, any, any> | import("../../../types").OnAction;
+    updateComponent: jest.Mock<any, any, any> | import("../../../types").UpdateComponent;
+    trackEvent: jest.Mock<any, any, any> | import("../../../events").AnalyticsEventDispatcher;
+    logEvent: jest.Mock<any, any, any> | import("../../../events").LoggingEventDispatcher;
+};
+export declare const getMockSchemaMapperProps: <S extends Schema>(schemaMapperProps: Partial<SchemaMapperProps> & {
+    schema: S;
+}) => {
+    schema: (Schema | undefined) & S;
+    model: import("@wise/dynamic-flow-types/build/next").Model;
+    required: boolean;
+    validationErrors: import("@wise/dynamic-flow-types/build/next").ValidationError;
+};
+export declare const mockUpdateFunction: <C extends StepComponent>(draftComponent: C) => jest.Mock<any, any, any>;

package/build/types/revamp/domain/mappers/schema/types.d.ts

@@ -1,14 +1,18 @@
-import type { Step as DFStep, Model, Schema } from '@wise/dynamic-flow-types/build/next';
+import type { Step as DFStep, Model, Schema, ValidationError } from '@wise/dynamic-flow-types/build/next';
 import type { OnAction, UpdateComponent } from '../../types';
 import type { GetErrorMessageFunctions } from '../types';
+import type { AnalyticsEventDispatcher, LoggingEventDispatcher } from '../../events';
 export type MapperProps = {
     step: DFStep;
     getErrorMessageFunctions: GetErrorMessageFunctions;
     onAction: OnAction;
     updateComponent: UpdateComponent;
+    trackEvent: AnalyticsEventDispatcher;
+    logEvent: LoggingEventDispatcher;
 };
 export type SchemaMapperProps = {
     schema: Schema;
     model: Model;
     required?: boolean;
+    validationErrors?: ValidationError;
 };

package/build/types/revamp/domain/mappers/types.d.ts

@@ -1,11 +1,12 @@
 export type GetErrorMessageFunctions = (validationMessages?: ValidationMessages) => ErrorMessageFunctions;
 export type ValidationMessages = Record<string, string | undefined>;
 export type ErrorMessageFunctions = {
-    minimumDate: (minDate: string) => string;
+    maximum: (maximum: number) => string;
+    minimum: (minimum: number) => string;
     maximumDate: (maxDate: string) => string;
-    minLength: (minLength: number) => string;
+    minimumDate: (minDate: string) => string;
     maxLength: (maxLength: number) => string;
+    minLength: (minLength: number) => string;
     pattern: () => string;
     required: () => string;
-    type: () => string;
 };

package/build/types/revamp/domain/mappers/utils/getAutocompleteString.d.ts

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

package/build/types/revamp/domain/types.d.ts

@@ -7,13 +7,15 @@ import type { ObjectComponent } from './components/ObjectComponent';
 import type { ParagraphComponent } from './components/ParagraphComponent';
 import type { TextInputComponent } from './components/TextInputComponent';
 import type { ColumnsComponent } from './components/ColumnsComponent';
-export type StepComponent = AlertComponent | BoxComponent | ButtonComponent | ColumnsComponent | HeadingComponent | ObjectComponent | ParagraphComponent | TextInputComponent;
+import type { NumberInputComponent } from './components/NumberInputComponent';
+import type { IntegerInputComponent } from './components/IntegerInputComponent';
+export type StepComponent = AlertComponent | BoxComponent | ButtonComponent | ColumnsComponent | HeadingComponent | ObjectComponent | ParagraphComponent | TextInputComponent | NumberInputComponent | IntegerInputComponent;
 export type ContainerComponent = ObjectComponent | BoxComponent | ColumnsComponent;
 export type BaseComponent<M extends Model> = {
     type: string;
     uid: string;
     validate: () => boolean;
-    getValue: () => M;
+    getValue: () => M | null;
 };
 export type LayoutComponent = BaseComponent<Model> & {
     margin: Margin;
@@ -21,6 +23,18 @@ export type LayoutComponent = BaseComponent<Model> & {
 };
 export type InputComponent<M extends Model> = BaseComponent<M> & {
     id: string;
+    autoComplete: string;
+    control?: string;
+    description?: string;
+    disabled: boolean;
+    errors: string[];
+    placeholder?: string;
+    title?: string;
+    value: M | null;
+    onChange: (value: M | null) => void;
+    onBlur: () => void;
+    onFocus: () => void;
+    getValue: () => M | null;
 };
 export type UpdateComponent = (id: string, update: (component: StepComponent) => void) => void;
 export type OnAction = (action: Action) => void;

package/build/types/revamp/domain/validation/getModelValidationErrors.d.ts

@@ -0,0 +1,6 @@
+import type { Model } from '@wise/dynamic-flow-types/build/next';
+import type { IsInvalidCheck } from './value-checks';
+export declare const getModelValidationErrors: <M extends Model>({ checks, model, }: {
+    checks: IsInvalidCheck<M>[];
+    model: M;
+}) => string[];

package/build/types/revamp/domain/validation/spec-utils.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="jest" />
+export declare const mockErrorMessageFunctions: {
+    minimum: jest.Mock<any, any, any>;
+    maximum: jest.Mock<any, any, any>;
+    minimumDate: jest.Mock<any, any, any>;
+    maximumDate: jest.Mock<any, any, any>;
+    minLength: jest.Mock<any, any, any>;
+    maxLength: jest.Mock<any, any, any>;
+    pattern: jest.Mock<any, any, any>;
+    required: jest.Mock<any, any, any>;
+};

package/build/types/revamp/{utils → domain/validation}/validateComponents.d.ts

@@ -1,2 +1,2 @@
-import type { StepComponent } from '../domain/types';
+import type { StepComponent } from '../types';
 export declare const validateComponents: (components: StepComponent[]) => boolean;

package/build/types/revamp/domain/validation/value-checks.d.ts

@@ -0,0 +1,13 @@
+import type { IntegerSchema, Model, NumberSchema, Schema, StringSchema } from '@wise/dynamic-flow-types/build/next';
+import type { ErrorMessageFunctions } from '../mappers/types';
+export type IsInvalidCheck<M extends Model> = (model: M | null) => string | null;
+type GetIsInvalidCheck<S extends Schema, M extends Model> = (schema: S, messageFunctions: ErrorMessageFunctions) => IsInvalidCheck<M>;
+export declare const getAboveMaxLengthCheck: GetIsInvalidCheck<StringSchema, string | null>;
+export declare const getBelowMinLengthCheck: GetIsInvalidCheck<StringSchema, string | null>;
+export declare const getAboveMaximumCheck: GetIsInvalidCheck<NumberSchema | IntegerSchema, number | null>;
+export declare const getBelowMinimumCheck: GetIsInvalidCheck<NumberSchema | IntegerSchema, number | null>;
+export declare const getAboveMaximumDateCheck: GetIsInvalidCheck<StringSchema, string | null>;
+export declare const getBelowMinimumDateCheck: GetIsInvalidCheck<StringSchema, string | null>;
+export declare const getNotAdheringToPatternCheck: GetIsInvalidCheck<StringSchema, string | null>;
+export declare const getRequiredCheck: (required: boolean, messageFunctions: ErrorMessageFunctions) => IsInvalidCheck<Model | null>;
+export {};

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

@@ -0,0 +1,38 @@
+import type { Step, Model } from '@wise/dynamic-flow-types/build/next';
+import type { AnalyticsEventHandler, LoggingEventHandler } from './domain/events';
+export type DynamicFlowProps = DynamicFlowPropsWithInitialAction | DynamicFlowPropsWithInitialStep;
+export type DynamicFlowPropsWithInitialAction = DynamicFlowPropsBasic & {
+    initialAction: InitialAction;
+    initialStep?: never;
+};
+export type DynamicFlowPropsWithInitialStep = DynamicFlowPropsBasic & {
+    initialAction?: never;
+    initialStep: Step;
+};
+export type InitialAction = {
+    $id?: string;
+    url: string;
+    method?: 'GET';
+    data?: never;
+} | {
+    $id?: string;
+    url: string;
+    method: 'POST';
+    data: Model;
+};
+type DynamicFlowPropsBasic = {
+    flowId: string;
+    displayStepTitle?: boolean;
+    features?: Feature[];
+    httpClient: HttpClient;
+    onCompletion: (result: Model) => void;
+    onError: (error: unknown, status?: number) => void;
+    onEvent?: AnalyticsEventHandler;
+    onLog?: LoggingEventHandler;
+};
+export type HttpClient = typeof fetch;
+type Feature = {
+    featureName: string;
+    variant: number | null;
+};
+export {};

package/build/types/revamp/renderers/mappers/integerInputComponentToProps.d.ts

@@ -0,0 +1,3 @@
+import type { IntegerInputComponent } from '../../domain/components/IntegerInputComponent';
+import type { IntegerInputRendererProps } from '../types';
+export declare const integerInputComponentToProps: (component: IntegerInputComponent) => IntegerInputRendererProps;

package/build/types/revamp/renderers/mappers/numberInputComponentToProps.d.ts

@@ -0,0 +1,3 @@
+import type { NumberInputComponent } from '../../domain/components/NumberInputComponent';
+import type { NumberInputRendererProps } from '../types';
+export declare const numberInputComponentToProps: (component: NumberInputComponent) => NumberInputRendererProps;

package/build/types/revamp/renderers/mappers/textInputComponentToProps.d.ts

@@ -1,3 +1,3 @@
 import type { TextInputComponent } from '../../domain/components/TextInputComponent';
 import type { TextInputRendererProps } from '../types';
-export declare const textComponentToProps: ({ format, errors, id, title, description, placeholder, value, onChange, }: TextInputComponent) => TextInputRendererProps;
+export declare const textInputComponentToProps: (component: TextInputComponent) => TextInputRendererProps;

package/build/types/revamp/renderers/types.d.ts

@@ -54,9 +54,9 @@ export interface ObjectRendererProps extends RendererProps {
     description?: string;
     children: ReactNode;
 }
-export interface TextInputRendererProps extends RendererProps {
-    type: 'input-text';
+interface BaseInputRendererProps<M extends string | number> extends RendererProps {
     id: string;
+    autoComplete: string;
     control?: string;
     description?: string;
     error?: string;
@@ -64,8 +64,21 @@ export interface TextInputRendererProps extends RendererProps {
     label?: string;
     name: string;
     placeholder?: string;
-    value: string | null;
-    onChange: (value: string | null) => void;
+    value: M | null;
+    onChange: (value: M | null) => void;
+    onBlur: () => void;
+    onFocus: () => void;
+}
+export interface TextInputRendererProps extends BaseInputRendererProps<string> {
+    type: 'input-text';
+    control?: string;
+    format?: 'date';
+}
+export interface NumberInputRendererProps extends BaseInputRendererProps<number> {
+    type: 'input-number';
+}
+export interface IntegerInputRendererProps extends BaseInputRendererProps<number> {
+    type: 'input-integer';
 }
 export interface ButtonRendererProps extends RendererProps {
     type: 'button';
@@ -76,3 +89,4 @@ export interface ButtonRendererProps extends RendererProps {
     margin: Margin;
     onClick: () => void;
 }
+export {};

package/build/types/revamp/step/Step.d.ts

@@ -1,8 +1,11 @@
 import type { Step as DFStep } from '@wise/dynamic-flow-types/build/next';
 import type { Renderer, RendererProps } from '../renderers/types';
+import type { AnalyticsEventDispatcher, LoggingEventDispatcher } from '../domain/events';
 type StepProps = {
     step: DFStep;
     renderers: Renderer<RendererProps>[];
+    trackEvent: AnalyticsEventDispatcher;
+    logEvent: LoggingEventDispatcher;
 };
-declare function Step({ step: dfStep, renderers }: StepProps): JSX.Element;
+declare function Step({ step, renderers, trackEvent, logEvent }: StepProps): JSX.Element;
 export default Step;

package/build/types/revamp/utils/type-utils.d.ts

@@ -1,4 +1,4 @@
-import type { AllOfSchema, Model, ObjectSchema, OneOfSchema, Schema, StringSchema } from '@wise/dynamic-flow-types/build/next';
+import type { AllOfSchema, IntegerSchema, Model, NumberSchema, ObjectSchema, OneOfSchema, Schema, StringSchema } from '@wise/dynamic-flow-types/build/next';
 import type { ContainerComponent, StepComponent } from '../domain/types';
 import type { ColumnsComponent } from '../domain/components/ColumnsComponent';
 export declare const isContainerComponent: (component: StepComponent) => component is ContainerComponent;
@@ -8,3 +8,5 @@ export declare const isAllOfSchema: (schema: Schema) => schema is AllOfSchema;
 export declare const isOneOfSchema: (schema: Schema) => schema is OneOfSchema;
 export declare const isObjectSchema: (schema: Schema) => schema is ObjectSchema;
 export declare const isStringSchema: (schema: Schema) => schema is StringSchema;
+export declare const isNumberSchema: (schema: Schema) => schema is NumberSchema;
+export declare const isIntegerSchema: (schema: Schema) => schema is IntegerSchema;

package/build/types/revamp/wise/renderers/IntegerInputRenderer.d.ts

@@ -0,0 +1,3 @@
+import type { Renderer, IntegerInputRendererProps } from '../../renderers/types';
+declare const IntegerInputRenderer: Renderer<IntegerInputRendererProps>;
+export default IntegerInputRenderer;

package/build/types/revamp/wise/renderers/NumberInputRenderer.d.ts

@@ -0,0 +1,3 @@
+import type { Renderer, NumberInputRendererProps } from '../../renderers/types';
+declare const NumberInputRenderer: Renderer<NumberInputRendererProps>;
+export default NumberInputRenderer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wise/dynamic-flow-client",
-  "version": "2.8.1",
+  "version": "2.8.3",
   "description": "Dynamic Flow web client",
   "license": "Apache-2.0",
   "main": "./build/main.min.js",

package/build/types/revamp/domain/mappers/utils/value-checks.d.ts

@@ -1,10 +0,0 @@
-import type { StringSchema } from '@wise/dynamic-flow-types/build/next';
-type IsInvalidCheck = (schema: StringSchema, model: string | null) => boolean;
-export declare const isAboveMaximum: IsInvalidCheck;
-export declare const isAboveMaxLength: IsInvalidCheck;
-export declare const isBelowMinimum: IsInvalidCheck;
-export declare const isBelowMinLength: IsInvalidCheck;
-export declare const isNotAdheringToPattern: IsInvalidCheck;
-export declare const isNotCorrectType: IsInvalidCheck;
-export declare const isNotProvided: IsInvalidCheck;
-export {};