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

package/build/types/legacy/jsonSchemaForm/arrayTypeSchema/ArraySchema.d.ts

@@ -0,0 +1,14 @@
+import { ArrayModel, ArraySchema as ArraySchemaType } from '@wise/dynamic-flow-types';
+import { GenericSchemaProps } from '../genericSchema/GenericSchema';
+declare const ArraySchema: {
+    (props: ArraySchemaProps): JSX.Element;
+    defaultProps: {
+        required: boolean;
+    };
+};
+export type ArraySchemaProps = GenericSchemaProps & {
+    schema: ArraySchemaType;
+    model: ArrayModel | null;
+    errors: string | null;
+};
+export default ArraySchema;

package/build/types/legacy/jsonSchemaForm/arrayTypeSchema/arrayListSchema/ArrayListSchema.d.ts

@@ -0,0 +1,15 @@
+import { ArrayModel, ArraySchema as ArraySchemaType } from '@wise/dynamic-flow-types';
+import { GenericSchemaProps } from '../../genericSchema/GenericSchema';
+type ArrayListSchemaProps = GenericSchemaProps & {
+    schema: ArraySchemaType;
+    errors?: string | null;
+    model: ArrayModel | null;
+};
+declare const ArrayListSchema: {
+    (props: ArrayListSchemaProps): JSX.Element;
+    defaultProps: {
+        errors: null;
+        required: boolean;
+    };
+};
+export default ArrayListSchema;

package/build/types/legacy/jsonSchemaForm/arrayTypeSchema/arrayListSchema/index.d.ts

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

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/legacy/jsonSchemaForm/arrayTypeSchema/arrayListSchema/multipleFileUploadSchema/index.d.ts

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

package/build/types/legacy/jsonSchemaForm/arrayTypeSchema/arrayListSchema/multipleFileUploadSchema/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './upload-utils';
+export * from './useFormattedDefaultErrorMessages';

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

@@ -0,0 +1,6 @@
+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;
+}): UploadResponse;
+export declare function constructUploadError(response: unknown): UploadError | undefined;

package/build/types/legacy/jsonSchemaForm/arrayTypeSchema/arrayListSchema/multipleFileUploadSchema/utils/useFormattedDefaultErrorMessages.d.ts

@@ -0,0 +1,9 @@
+export declare function useFormattedDefaultErrorMessages({ maxItems, minItems, }: {
+    maxItems?: number;
+    minItems?: number;
+}): {
+    maxFileSizeErrorMessage: string;
+    maxItemsErrorMessage: string;
+    minItemsErrorMessage: string;
+    requiredMessage: string;
+};

package/build/types/legacy/jsonSchemaForm/arrayTypeSchema/arrayListSchema/repeatableSchema/ItemSummary.d.ts

@@ -0,0 +1,12 @@
+import type { Icon, Image, Model } from '@wise/dynamic-flow-types';
+export type ItemSummary = {
+    value: Model | null;
+    title?: string;
+    description?: string;
+    icon?: Icon;
+    image?: Image;
+};
+export declare function ItemSummaryOption({ item, onClick }: {
+    item: ItemSummary;
+    onClick: () => void;
+}): JSX.Element;

package/build/types/legacy/jsonSchemaForm/arrayTypeSchema/arrayListSchema/repeatableSchema/RepeatableSchema.d.ts

@@ -0,0 +1,9 @@
+import type { ArrayModel, ListArraySchema } from '@wise/dynamic-flow-types';
+import type { GenericSchemaProps } from '../../../genericSchema/GenericSchema';
+type RepeatableSchemaProps = Omit<GenericSchemaProps, 'model' | 'onPersistAsync'> & {
+    schema: ListArraySchema;
+    model: ArrayModel | null;
+    required?: boolean;
+};
+declare function RepeatableSchema({ schema, model, errors, submitted, required, onChange, }: RepeatableSchemaProps): JSX.Element;
+export default RepeatableSchema;

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

@@ -0,0 +1,14 @@
+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';
+    schema: ListArraySchema;
+    model?: Model;
+    errors?: FormErrors;
+    submitted: boolean;
+    onModelChange: OnModelChange;
+    onAction: (actionType: RepeatableActionType, summaryText?: string) => void;
+};
+declare function RepeatableSchemaStep({ type, schema, model, errors, submitted, onModelChange, onAction, }: RepeatableSchemaStepProps): JSX.Element;
+export default RepeatableSchemaStep;

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

@@ -0,0 +1,3 @@
+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'], summaryTextOverride?: string) => ItemSummary;

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

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

package/build/types/legacy/jsonSchemaForm/basicTypeSchema/BasicTypeSchema.d.ts

@@ -0,0 +1,21 @@
+import { BasicModel, BasicSchema } from '@wise/dynamic-flow-types';
+import { OnChange } from '../JsonSchemaForm';
+import { GenericSchemaProps } from '../genericSchema/GenericSchema';
+declare const BasicTypeSchema: {
+    (props: BasicTypeSchemaProps): JSX.Element | null;
+    defaultProps: {
+        required: boolean;
+        disabled: boolean;
+        onBlur: null;
+    };
+};
+export type BasicTypeSchemaProps = Omit<GenericSchemaProps, 'schema' | 'model' | 'onChange' | 'errors' | 'onPersistAsync'> & {
+    schema: BasicSchema;
+    model: BasicModel | null;
+    errors: string | null;
+    required?: boolean;
+    infoMessage: string | null;
+    onBlur?: () => void;
+    onChange: OnChange;
+};
+export default BasicTypeSchema;

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

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

package/build/types/legacy/jsonSchemaForm/controlFeedback/ControlFeedback.d.ts

@@ -0,0 +1,33 @@
+import type { Schema } from '@wise/dynamic-flow-types';
+declare function ControlFeedback(props: ControlFeedbackProps): JSX.Element;
+declare namespace ControlFeedback {
+    var defaultProps: {
+        errors: string;
+        validations: never[];
+        validationMessages: {};
+        validationAsyncSuccessMessage: null;
+    };
+}
+type ValidationMessages = {
+    minimum?: string;
+    maximum?: string;
+    minLength?: string;
+    maxLength?: string;
+    minItems?: string;
+    maxItems?: string;
+    pattern?: string;
+    required?: string;
+};
+export type ControlFeedbackProps = {
+    id: string | undefined;
+    changed: boolean;
+    blurred: boolean;
+    focused: boolean;
+    submitted: boolean;
+    errors?: string | null;
+    validations?: string[];
+    validationMessages?: ValidationMessages;
+    schema: Schema;
+    infoMessage: string | null;
+};
+export default ControlFeedback;

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

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

package/build/types/legacy/jsonSchemaForm/genericSchema/GenericSchema.d.ts

@@ -0,0 +1,18 @@
+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;
+    errors: FormErrors;
+    submitted: boolean;
+    disabled?: boolean;
+    onChange: OnChange;
+    onPersistAsync: OnPersistAsync;
+};
+export type GenericSchemaFormProps = GenericSchemaProps & {
+    hideTitle?: boolean;
+    required?: boolean;
+};
+export default GenericSchemaForm;

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

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

package/build/types/legacy/jsonSchemaForm/help/Help.d.ts

@@ -0,0 +1,7 @@
+type Props = {
+    help: {
+        markdown: string;
+    };
+};
+declare function Help(props: Props): JSX.Element;
+export default Help;

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

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

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

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

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/objectSchema/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './ObjectSchema';
+export type { ObjectSchemaProps } from './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/oneOfSchema/index.d.ts

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

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

@@ -0,0 +1,4 @@
+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/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/legacy/jsonSchemaForm/persistAsyncSchema/index.d.ts

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

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

@@ -0,0 +1,20 @@
+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 function PersistAsyncBasicSchema(props: PersistAsyncBasicSchemaProps): JSX.Element;
+declare namespace PersistAsyncBasicSchema {
+    var defaultProps: {
+        required: boolean;
+    };
+}
+type PersistAsyncBasicSchemaProps = Omit<GenericSchemaProps, 'schema'> & {
+    schema: Schema & {
+        persistAsync: PersistAsync;
+    };
+    errors: string | null;
+    required?: boolean;
+};
+export default PersistAsyncBasicSchema;

package/build/types/legacy/jsonSchemaForm/persistAsyncSchema/persistAsyncBasicSchema/index.d.ts

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

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

@@ -0,0 +1,19 @@
+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 & {
+            schema: BlobSchema;
+        };
+    };
+    model: string | null;
+    errors: string | null;
+    required?: boolean;
+};
+export default PersistAsyncBlobSchema;

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/legacy/jsonSchemaForm/persistAsyncSchema/persistAsyncBlobSchema/index.d.ts

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

package/build/types/legacy/jsonSchemaForm/promotedOneOfSchema/PromotedOneOfSchema.d.ts

@@ -0,0 +1,8 @@
+import { ObjectModel, OneOfObjectSchema } from '@wise/dynamic-flow-types';
+import { GenericSchemaProps } from '../genericSchema/GenericSchema';
+declare const PromotedOneOfSchema: (props: PromotedOneOfSchemaProps) => JSX.Element;
+export type PromotedOneOfSchemaProps = Omit<GenericSchemaProps, 'schema' | 'model'> & {
+    schema: OneOfObjectSchema;
+    model: ObjectModel | null;
+};
+export default PromotedOneOfSchema;

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

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

package/build/types/legacy/jsonSchemaForm/promotedOneOfSchema/promoted-one-of-utils.d.ts

@@ -0,0 +1,2 @@
+import { ObjectModel, OneOfObjectSchema } from '@wise/dynamic-flow-types';
+export declare const getSelectionFromModel: (schema: OneOfObjectSchema, model: ObjectModel) => "other" | "promoted" | null;

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

@@ -0,0 +1,6 @@
+import { PromotedOneOfControlProps } from './PromotedOneOfControl';
+declare const PromotedOneOfCheckboxControl: {
+    (props: PromotedOneOfControlProps): JSX.Element;
+    defaultProps: {};
+};
+export default PromotedOneOfCheckboxControl;

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

@@ -0,0 +1,23 @@
+/// <reference types="react" />
+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;
+    promotedOneOf: {
+        title?: string;
+        description?: string;
+        image?: Image;
+        icon?: Icon;
+    };
+    promotion: Promotion;
+    selection: 'promoted' | 'other';
+    setSelection: React.Dispatch<React.SetStateAction<'promoted' | 'other'>>;
+};
+export default PromotedOneOfControl;

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;

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

@@ -0,0 +1,16 @@
+declare namespace _default {
+    namespace yes {
+        const id: string;
+        const defaultMessage: string;
+        const description: string;
+    }
+    namespace no {
+        const id_1: string;
+        export { id_1 as id };
+        const defaultMessage_1: string;
+        export { defaultMessage_1 as defaultMessage };
+        const description_1: string;
+        export { description_1 as description };
+    }
+}
+export default _default;

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

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

package/build/types/legacy/jsonSchemaForm/schemaFormControl/SchemaFormControl.d.ts

@@ -0,0 +1,27 @@
+import type { BasicModel, Schema, StringSchema } from '@wise/dynamic-flow-types';
+import { FormControlType } from '../../common/constants';
+import type { OnChangeProps } from '../JsonSchemaForm';
+export declare const getControlType: (schema: Schema) => (typeof FormControlType)[keyof typeof FormControlType] | undefined;
+export declare const getStringSchemaControlType: ({ format, control, }: StringSchema) => (typeof FormControlType)[keyof typeof FormControlType] | undefined;
+declare function SchemaFormControl(props: SchemaFormControlProps): JSX.Element;
+declare namespace SchemaFormControl {
+    var defaultProps: {
+        value: null;
+        onFocus: null;
+        onBlur: null;
+        onSearchChange: null;
+        disabled: boolean;
+    };
+}
+export type SchemaFormControlProps = {
+    id: string;
+    value: BasicModel | null;
+    schema: Schema;
+    onChange: (model: BasicModel | null, type?: 'init' | 'user', metadata?: OnChangeProps['metadata']) => void;
+    onFocus?: () => void;
+    onBlur?: () => void;
+    onSearchChange?: (searchValue: string) => void;
+    disabled?: boolean;
+    describedBy?: string | undefined;
+};
+export default SchemaFormControl;

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

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

package/build/types/legacy/jsonSchemaForm/schemaFormControl/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './mapping-utils';

package/build/types/legacy/jsonSchemaForm/schemaFormControl/utils/mapping-utils.d.ts

@@ -0,0 +1,33 @@
+import type { Icon, Image, Schema } from '@wise/dynamic-flow-types';
+declare const mapConstSchemaToOption: <ControlType extends string>(schema: Schema, controlType?: ControlType | undefined) => ControlType extends "select" ? SelectOption : RadioOption;
+type RadioOption = {
+    disabled?: boolean | undefined;
+    avatar?: JSX.Element | undefined;
+    currency?: string | undefined;
+    label: string;
+    value: string;
+};
+type SelectOption = {
+    searchStrings?: string[];
+    disabled?: boolean | undefined;
+    icon?: JSX.Element | undefined;
+    hideIconInTrigger?: boolean;
+    currency?: string | undefined;
+    note?: string;
+    secondary?: string;
+    label: string;
+    value: string;
+};
+declare const getAvatarPropertyForRadioOption: ({ image, icon }: {
+    image?: Image | undefined;
+    icon?: Icon | undefined;
+}) => {
+    avatar: JSX.Element;
+} | null;
+declare const mapSchemaToUploadOptions: ({ accepts }: {
+    accepts?: string[] | undefined;
+}) => {
+    usAccept?: string | undefined;
+};
+export { mapConstSchemaToOption, getAvatarPropertyForRadioOption, mapSchemaToUploadOptions };
+export type { RadioOption, SelectOption };

package/build/types/legacy/jsonSchemaForm/validationAsyncSchema/ValidationAsyncSchema.d.ts

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

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

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

package/build/types/legacy/layout/DynamicLayout.d.ts

@@ -0,0 +1,16 @@
+import type { FormErrors, LayoutComponent, Model } from '@wise/dynamic-flow-types';
+import type { OnAction, OnModelChange, OnPersistAsync } from '../dynamicFlow/DynamicFlowTypes';
+export type CommonLayoutProps = {
+    model?: Model;
+    submitted: boolean;
+    errors?: FormErrors;
+    baseUrl?: string;
+    onAction: OnAction;
+    onModelChange: OnModelChange;
+    onPersistAsync: OnPersistAsync;
+};
+type DynamicLayoutProps = {
+    components: LayoutComponent[];
+} & CommonLayoutProps;
+declare function DynamicLayout(props: DynamicLayoutProps): JSX.Element;
+export default DynamicLayout;

package/build/types/legacy/layout/alert/DynamicAlert.d.ts

@@ -0,0 +1,5 @@
+import { Alert as AlertType } from '@wise/dynamic-flow-types';
+declare const DynamicAlert: (props: {
+    component: AlertType;
+}) => JSX.Element;
+export default DynamicAlert;

package/build/types/legacy/layout/box/DynamicBox.d.ts

@@ -0,0 +1,7 @@
+import { BoxLayout } from '@wise/dynamic-flow-types';
+import { CommonLayoutProps } from '../DynamicLayout';
+type Props = CommonLayoutProps & {
+    component: BoxLayout;
+};
+declare const DynamicBox: (props: Props) => JSX.Element;
+export default DynamicBox;

package/build/types/legacy/layout/button/DynamicButton.d.ts

@@ -0,0 +1,7 @@
+import type { ButtonLayout } from '@wise/dynamic-flow-types';
+import type { CommonLayoutProps } from '../DynamicLayout';
+type Props = Omit<CommonLayoutProps, 'submitted' | 'onModelChange' | 'onPersistAsync'> & {
+    component: ButtonLayout;
+};
+declare function DynamicButton(props: Props): JSX.Element;
+export default DynamicButton;

package/build/types/legacy/layout/button/utils.d.ts

@@ -0,0 +1,4 @@
+import type { ButtonLayout, Size } from '@wise/dynamic-flow-types';
+export declare const getButtonPriority: (component: ButtonLayout) => "primary" | "secondary" | "tertiary";
+export declare const getButtonType: (component: ButtonLayout) => "positive" | "negative" | "accent";
+export declare const getButtonSize: (size: Size | undefined) => "sm" | "md" | "lg";

package/build/types/legacy/layout/columns/DynamicColumns.d.ts

@@ -0,0 +1,7 @@
+import { ColumnsLayout } from '@wise/dynamic-flow-types';
+import { CommonLayoutProps } from '../DynamicLayout';
+type Props = CommonLayoutProps & {
+    component: ColumnsLayout;
+};
+declare const DynamicColumns: (props: Props) => JSX.Element;
+export default DynamicColumns;

package/build/types/legacy/layout/decision/DynamicDecision.d.ts

@@ -0,0 +1,8 @@
+import type { DecisionLayout } from '@wise/dynamic-flow-types';
+import type { OnAction } from '../../dynamicFlow/DynamicFlowTypes';
+type Props = {
+    component: DecisionLayout;
+    onAction: OnAction;
+};
+declare function DynamicDecision({ component, onAction }: Props): JSX.Element;
+export default DynamicDecision;

package/build/types/legacy/layout/divider/DynamicDivider.d.ts

@@ -0,0 +1,6 @@
+import { DividerLayout } from '@wise/dynamic-flow-types';
+type Props = {
+    component: DividerLayout;
+};
+declare const DynamicDivider: ({ component }: Props) => JSX.Element;
+export default DynamicDivider;

package/build/types/legacy/layout/external/DynamicExternal.d.ts

@@ -0,0 +1,8 @@
+import { Action, ExternalLayout } from '@wise/dynamic-flow-types';
+type Props = {
+    component: ExternalLayout;
+    onAction: (action: Action) => void;
+};
+/** @deprecated - No longer supported, use the external feature instead */
+declare const DynamicExternal: ({ component, onAction }: Props) => JSX.Element;
+export default DynamicExternal;