@canonical/react-ds-core-form 0.9.0-experimental.2 → 0.9.0-experimental.21

package/dist/types/ui/Field/common/Label/Label.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Label.d.ts","sourceRoot":"","sources":["../../../../../../src/ui/Field/common/Label/Label.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,cAAc,CAAC;AAStB;;;GAGG;AACH,QAAA,MAAM,KAAK,GAAI,wFAUZ,UAAU,KAAG,KAAK,CAAC,YAYrB,CAAC;AAEF,eAAe,KAAK,CAAC"}

package/dist/types/ui/Field/common/Label/index.d.ts

@@ -0,0 +1,3 @@
+export { default as Label } from "./Label.js";
+export * from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/ui/Field/common/Label/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/ui/Field/common/Label/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE,MAAM,YAAY,CAAC;AAC9C,cAAc,YAAY,CAAC"}

package/dist/types/ui/Field/common/Label/types.d.ts

@@ -0,0 +1,17 @@
+import type React from "react";
+import type { JSX } from "react";
+export interface LabelMessages {
+    optional: () => string;
+}
+export interface LabelProps {
+    id?: string;
+    className?: string;
+    children?: React.ReactNode;
+    style?: React.CSSProperties;
+    name: string;
+    htmlFor?: string;
+    isOptional?: boolean;
+    messages?: LabelMessages;
+    tag?: keyof JSX.IntrinsicElements;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types/ui/Field/common/Label/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../src/ui/Field/common/Label/types.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC;AAEjC,MAAM,WAAW,aAAa;IAE5B,QAAQ,EAAE,MAAM,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,UAAU;IAEzB,EAAE,CAAC,EAAE,MAAM,CAAC;IAEZ,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAE3B,KAAK,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC;IAE5B,IAAI,EAAE,MAAM,CAAC;IAEb,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB,QAAQ,CAAC,EAAE,aAAa,CAAC;IAEzB,GAAG,CAAC,EAAE,MAAM,GAAG,CAAC,iBAAiB,CAAC;CACnC"}

package/dist/types/ui/Field/common/Wrapper/InvisibleWrapper.d.ts

@@ -0,0 +1,13 @@
+import type React from "react";
+import type { BaseInputProps, WrapperProps } from "../../types.js";
+/**
+ * InvisibleWrapper component for hidden form inputs.
+ * It wraps the specified input component and handles form registration
+ * without rendering visible elements like labels or error messages.
+ *
+ * @param {WrapperProps<ComponentProps>} props - Component props including the Component to wrap and form-related props.
+ * @returns {React.ReactElement} - Rendered wrapped component.
+ */
+declare const InvisibleWrapper: <ComponentProps extends BaseInputProps>({ name, Component, registerProps: userRegisterProps, nestedRegisterProps, unregisterOnUnmount, ...otherProps }: WrapperProps<ComponentProps>) => React.ReactElement;
+export default InvisibleWrapper;
+//# sourceMappingURL=InvisibleWrapper.d.ts.map

package/dist/types/ui/Field/common/Wrapper/InvisibleWrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InvisibleWrapper.d.ts","sourceRoot":"","sources":["../../../../../../src/ui/Field/common/Wrapper/InvisibleWrapper.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAGnE;;;;;;;GAOG;AACH,QAAA,MAAM,gBAAgB,GAAI,cAAc,SAAS,cAAc,EAAE,gHAO9D,YAAY,CAAC,cAAc,CAAC,KAAG,KAAK,CAAC,YAevC,CAAC;AAEF,eAAe,gBAAgB,CAAC"}

package/dist/types/ui/Field/common/Wrapper/Wrapper.d.ts

@@ -0,0 +1,10 @@
+import type React from "react";
+import type { BaseInputProps, WrapperProps } from "../../types.js";
+import "./styles.css";
+/**
+ * description of the Wrapper component
+ * @returns {React.ReactElement} - Rendered Wrapper
+ */
+declare const Wrapper: <ComponentProps extends BaseInputProps>({ id, className, style, name, Component, description, label, isOptional, registerProps: userRegisterProps, nestedRegisterProps, unregisterOnUnmount, mockLabel, ...otherProps }: WrapperProps<ComponentProps>) => React.ReactElement;
+export default Wrapper;
+//# sourceMappingURL=Wrapper.d.ts.map

package/dist/types/ui/Field/common/Wrapper/Wrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Wrapper.d.ts","sourceRoot":"","sources":["../../../../../../src/ui/Field/common/Wrapper/Wrapper.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACnE,OAAO,cAAc,CAAC;AAOtB;;;GAGG;AACH,QAAA,MAAM,OAAO,GAAI,cAAc,SAAS,cAAc,EAAE,iLAgBrD,YAAY,CAAC,cAAc,CAAC,KAAG,KAAK,CAAC,YAkDvC,CAAC;AAEF,eAAe,OAAO,CAAC"}

package/dist/types/ui/Field/common/Wrapper/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export { default as useFieldWrapper } from "./useFieldWrapper.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/ui/Field/common/Wrapper/hooks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/ui/Field/common/Wrapper/hooks/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/types/ui/Field/common/Wrapper/hooks/useFieldWrapper.d.ts

@@ -0,0 +1,498 @@
+import { type RegisterOptions } from "react-hook-form";
+type UseFieldWrapperOptions = {
+    label?: string;
+    isOptional?: boolean;
+    userRegisterProps?: RegisterOptions;
+    nestedRegisterProps?: RegisterOptions;
+    unregisterOnUnmount?: boolean;
+};
+/**
+ * Hook to provide field wrapper utilities
+ * @param name - The name of the field
+ * @param options - Additional options
+ */
+declare const useFieldWrapper: (name: string, options?: UseFieldWrapperOptions) => {
+    fieldError: import("react-hook-form").FieldError | undefined;
+    isError: boolean;
+    ariaProps: {
+        input: {
+            id: string;
+            "aria-labelledby": string;
+            "aria-describedby": string;
+            "aria-errormessage": string | undefined;
+            "aria-invalid": boolean;
+        };
+        label: {
+            id: string;
+            htmlFor: string;
+        };
+        description: {
+            id: string;
+        };
+        error: {
+            id: string;
+        };
+    };
+    registerProps: {
+        required?: string | import("react-hook-form").ValidationRule<boolean> | undefined;
+        min?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        max?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        maxLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        minLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        validate?: import("react-hook-form").Validate<any, import("react-hook-form").FieldValues> | Record<string, import("react-hook-form").Validate<any, import("react-hook-form").FieldValues>> | undefined;
+        value?: any;
+        setValueAs?: ((value: any) => any) | undefined;
+        shouldUnregister?: boolean;
+        onChange?: (event: any) => void;
+        onBlur?: (event: any) => void;
+        disabled?: boolean | undefined;
+        deps?: string | string[] | undefined;
+        pattern?: import("react-hook-form").ValidationRule<RegExp>;
+        valueAsNumber?: false;
+        valueAsDate?: false;
+    } | {
+        required?: string | import("react-hook-form").ValidationRule<boolean> | undefined;
+        min?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        max?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        maxLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        minLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        validate?: import("react-hook-form").Validate<any, import("react-hook-form").FieldValues> | Record<string, import("react-hook-form").Validate<any, import("react-hook-form").FieldValues>> | undefined;
+        value?: any;
+        setValueAs?: ((value: any) => any) | undefined;
+        shouldUnregister?: boolean;
+        onChange?: (event: any) => void;
+        onBlur?: (event: any) => void;
+        disabled?: boolean | undefined;
+        deps?: string | string[] | undefined;
+        pattern?: import("react-hook-form").ValidationRule<RegExp>;
+        valueAsNumber?: false;
+        valueAsDate?: boolean | undefined;
+    } | {
+        required?: string | import("react-hook-form").ValidationRule<boolean> | undefined;
+        min?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        max?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        maxLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        minLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        validate?: import("react-hook-form").Validate<any, import("react-hook-form").FieldValues> | Record<string, import("react-hook-form").Validate<any, import("react-hook-form").FieldValues>> | undefined;
+        value?: any;
+        setValueAs?: ((value: any) => any) | undefined;
+        shouldUnregister?: boolean;
+        onChange?: (event: any) => void;
+        onBlur?: (event: any) => void;
+        disabled?: boolean | undefined;
+        deps?: string | string[] | undefined;
+        pattern?: import("react-hook-form").ValidationRule<RegExp>;
+        valueAsNumber?: boolean | undefined;
+        valueAsDate?: false;
+    } | {
+        required?: string | import("react-hook-form").ValidationRule<boolean> | undefined;
+        min?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        max?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        maxLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        minLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        validate?: import("react-hook-form").Validate<any, import("react-hook-form").FieldValues> | Record<string, import("react-hook-form").Validate<any, import("react-hook-form").FieldValues>> | undefined;
+        value?: any;
+        setValueAs?: ((value: any) => any) | undefined;
+        shouldUnregister?: boolean;
+        onChange?: (event: any) => void;
+        onBlur?: (event: any) => void;
+        disabled?: boolean | undefined;
+        deps?: string | string[] | undefined;
+        pattern?: import("react-hook-form").ValidationRule<RegExp>;
+        valueAsNumber?: false;
+        valueAsDate?: boolean | undefined;
+    } | {
+        required?: string | import("react-hook-form").ValidationRule<boolean> | undefined;
+        min?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        max?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        maxLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        minLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        validate?: import("react-hook-form").Validate<any, import("react-hook-form").FieldValues> | Record<string, import("react-hook-form").Validate<any, import("react-hook-form").FieldValues>> | undefined;
+        value?: any;
+        setValueAs?: ((value: any) => any) | undefined;
+        shouldUnregister?: boolean;
+        onChange?: (event: any) => void;
+        onBlur?: (event: any) => void;
+        disabled?: boolean | undefined;
+        deps?: string | string[] | undefined;
+        pattern?: import("react-hook-form").ValidationRule<RegExp>;
+        valueAsNumber?: false;
+        valueAsDate?: boolean | undefined;
+    } | {
+        required?: string | import("react-hook-form").ValidationRule<boolean> | undefined;
+        min?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        max?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        maxLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        minLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        validate?: import("react-hook-form").Validate<any, import("react-hook-form").FieldValues> | Record<string, import("react-hook-form").Validate<any, import("react-hook-form").FieldValues>> | undefined;
+        value?: any;
+        setValueAs?: ((value: any) => any) | undefined;
+        shouldUnregister?: boolean;
+        onChange?: (event: any) => void;
+        onBlur?: (event: any) => void;
+        disabled?: boolean | undefined;
+        deps?: string | string[] | undefined;
+        pattern?: import("react-hook-form").ValidationRule<RegExp>;
+        valueAsNumber?: boolean | undefined;
+        valueAsDate?: boolean | undefined;
+    } | {
+        required?: string | import("react-hook-form").ValidationRule<boolean> | undefined;
+        min?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        max?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        maxLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        minLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        validate?: import("react-hook-form").Validate<any, import("react-hook-form").FieldValues> | Record<string, import("react-hook-form").Validate<any, import("react-hook-form").FieldValues>> | undefined;
+        value?: any;
+        setValueAs?: ((value: any) => any) | undefined;
+        shouldUnregister?: boolean;
+        onChange?: (event: any) => void;
+        onBlur?: (event: any) => void;
+        disabled?: boolean | undefined;
+        deps?: string | string[] | undefined;
+        pattern?: import("react-hook-form").ValidationRule<RegExp>;
+        valueAsNumber?: boolean | undefined;
+        valueAsDate?: false;
+    } | {
+        required?: string | import("react-hook-form").ValidationRule<boolean> | undefined;
+        min?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        max?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        maxLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        minLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        validate?: import("react-hook-form").Validate<any, import("react-hook-form").FieldValues> | Record<string, import("react-hook-form").Validate<any, import("react-hook-form").FieldValues>> | undefined;
+        value?: any;
+        setValueAs?: ((value: any) => any) | undefined;
+        shouldUnregister?: boolean;
+        onChange?: (event: any) => void;
+        onBlur?: (event: any) => void;
+        disabled?: boolean | undefined;
+        deps?: string | string[] | undefined;
+        pattern?: import("react-hook-form").ValidationRule<RegExp>;
+        valueAsNumber?: boolean | undefined;
+        valueAsDate?: boolean | undefined;
+    } | {
+        required?: string | import("react-hook-form").ValidationRule<boolean> | undefined;
+        min?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        max?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        maxLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        minLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        validate?: import("react-hook-form").Validate<any, import("react-hook-form").FieldValues> | Record<string, import("react-hook-form").Validate<any, import("react-hook-form").FieldValues>> | undefined;
+        value?: any;
+        setValueAs?: ((value: any) => any) | undefined;
+        shouldUnregister?: boolean;
+        onChange?: (event: any) => void;
+        onBlur?: (event: any) => void;
+        disabled?: boolean | undefined;
+        deps?: string | string[] | undefined;
+        pattern?: import("react-hook-form").ValidationRule<RegExp>;
+        valueAsNumber?: boolean | undefined;
+        valueAsDate?: false;
+    } | {
+        required?: string | import("react-hook-form").ValidationRule<boolean> | undefined;
+        min?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        max?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        maxLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        minLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        validate?: import("react-hook-form").Validate<any, import("react-hook-form").FieldValues> | Record<string, import("react-hook-form").Validate<any, import("react-hook-form").FieldValues>> | undefined;
+        value?: any;
+        setValueAs?: ((value: any) => any) | undefined;
+        shouldUnregister?: boolean;
+        onChange?: (event: any) => void;
+        onBlur?: (event: any) => void;
+        disabled?: boolean | undefined;
+        deps?: string | string[] | undefined;
+        pattern?: import("react-hook-form").ValidationRule<RegExp> | undefined;
+        valueAsNumber?: false;
+        valueAsDate?: boolean | undefined;
+    } | {
+        required?: string | import("react-hook-form").ValidationRule<boolean> | undefined;
+        min?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        max?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        maxLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        minLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        validate?: import("react-hook-form").Validate<any, import("react-hook-form").FieldValues> | Record<string, import("react-hook-form").Validate<any, import("react-hook-form").FieldValues>> | undefined;
+        value?: any;
+        setValueAs?: ((value: any) => any) | undefined;
+        shouldUnregister?: boolean;
+        onChange?: (event: any) => void;
+        onBlur?: (event: any) => void;
+        disabled?: boolean | undefined;
+        deps?: string | string[] | undefined;
+        pattern?: import("react-hook-form").ValidationRule<RegExp> | undefined;
+        valueAsNumber?: false;
+        valueAsDate?: boolean | undefined;
+    } | {
+        required?: string | import("react-hook-form").ValidationRule<boolean> | undefined;
+        min?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        max?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        maxLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        minLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        validate?: import("react-hook-form").Validate<any, import("react-hook-form").FieldValues> | Record<string, import("react-hook-form").Validate<any, import("react-hook-form").FieldValues>> | undefined;
+        value?: any;
+        setValueAs?: ((value: any) => any) | undefined;
+        shouldUnregister?: boolean;
+        onChange?: (event: any) => void;
+        onBlur?: (event: any) => void;
+        disabled?: boolean | undefined;
+        deps?: string | string[] | undefined;
+        pattern?: import("react-hook-form").ValidationRule<RegExp> | undefined;
+        valueAsNumber?: boolean | undefined;
+        valueAsDate?: boolean | undefined;
+    } | {
+        required?: string | import("react-hook-form").ValidationRule<boolean> | undefined;
+        min?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        max?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        maxLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        minLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        validate?: import("react-hook-form").Validate<any, import("react-hook-form").FieldValues> | Record<string, import("react-hook-form").Validate<any, import("react-hook-form").FieldValues>> | undefined;
+        value?: any;
+        setValueAs?: ((value: any) => any) | undefined;
+        shouldUnregister?: boolean;
+        onChange?: (event: any) => void;
+        onBlur?: (event: any) => void;
+        disabled?: boolean | undefined;
+        deps?: string | string[] | undefined;
+        pattern?: import("react-hook-form").ValidationRule<RegExp> | undefined;
+        valueAsNumber?: false;
+        valueAsDate?: boolean | undefined;
+    } | {
+        required?: string | import("react-hook-form").ValidationRule<boolean> | undefined;
+        min?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        max?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        maxLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        minLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        validate?: import("react-hook-form").Validate<any, import("react-hook-form").FieldValues> | Record<string, import("react-hook-form").Validate<any, import("react-hook-form").FieldValues>> | undefined;
+        value?: any;
+        setValueAs?: ((value: any) => any) | undefined;
+        shouldUnregister?: boolean;
+        onChange?: (event: any) => void;
+        onBlur?: (event: any) => void;
+        disabled?: boolean | undefined;
+        deps?: string | string[] | undefined;
+        pattern?: undefined;
+        valueAsNumber?: false;
+        valueAsDate?: true;
+    } | {
+        required?: string | import("react-hook-form").ValidationRule<boolean> | undefined;
+        min?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        max?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        maxLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        minLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        validate?: import("react-hook-form").Validate<any, import("react-hook-form").FieldValues> | Record<string, import("react-hook-form").Validate<any, import("react-hook-form").FieldValues>> | undefined;
+        value?: any;
+        setValueAs?: ((value: any) => any) | undefined;
+        shouldUnregister?: boolean;
+        onChange?: (event: any) => void;
+        onBlur?: (event: any) => void;
+        disabled?: boolean | undefined;
+        deps?: string | string[] | undefined;
+        pattern?: undefined;
+        valueAsNumber?: boolean | undefined;
+        valueAsDate?: boolean | undefined;
+    } | {
+        required?: string | import("react-hook-form").ValidationRule<boolean> | undefined;
+        min?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        max?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        maxLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        minLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        validate?: import("react-hook-form").Validate<any, import("react-hook-form").FieldValues> | Record<string, import("react-hook-form").Validate<any, import("react-hook-form").FieldValues>> | undefined;
+        value?: any;
+        setValueAs?: ((value: any) => any) | undefined;
+        shouldUnregister?: boolean;
+        onChange?: (event: any) => void;
+        onBlur?: (event: any) => void;
+        disabled?: boolean | undefined;
+        deps?: string | string[] | undefined;
+        pattern?: import("react-hook-form").ValidationRule<RegExp> | undefined;
+        valueAsNumber?: boolean | undefined;
+        valueAsDate?: boolean | undefined;
+    } | {
+        required?: string | import("react-hook-form").ValidationRule<boolean> | undefined;
+        min?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        max?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        maxLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        minLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        validate?: import("react-hook-form").Validate<any, import("react-hook-form").FieldValues> | Record<string, import("react-hook-form").Validate<any, import("react-hook-form").FieldValues>> | undefined;
+        value?: any;
+        setValueAs?: ((value: any) => any) | undefined;
+        shouldUnregister?: boolean;
+        onChange?: (event: any) => void;
+        onBlur?: (event: any) => void;
+        disabled?: boolean | undefined;
+        deps?: string | string[] | undefined;
+        pattern?: undefined;
+        valueAsNumber?: boolean | undefined;
+        valueAsDate?: boolean | undefined;
+    } | {
+        required?: string | import("react-hook-form").ValidationRule<boolean> | undefined;
+        min?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        max?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        maxLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        minLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        validate?: import("react-hook-form").Validate<any, import("react-hook-form").FieldValues> | Record<string, import("react-hook-form").Validate<any, import("react-hook-form").FieldValues>> | undefined;
+        value?: any;
+        setValueAs?: ((value: any) => any) | undefined;
+        shouldUnregister?: boolean;
+        onChange?: (event: any) => void;
+        onBlur?: (event: any) => void;
+        disabled?: boolean | undefined;
+        deps?: string | string[] | undefined;
+        pattern?: undefined;
+        valueAsNumber?: boolean | undefined;
+        valueAsDate?: boolean | undefined;
+    } | {
+        required?: string | import("react-hook-form").ValidationRule<boolean> | undefined;
+        min?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        max?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        maxLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        minLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        validate?: import("react-hook-form").Validate<any, import("react-hook-form").FieldValues> | Record<string, import("react-hook-form").Validate<any, import("react-hook-form").FieldValues>> | undefined;
+        value?: any;
+        setValueAs?: ((value: any) => any) | undefined;
+        shouldUnregister?: boolean;
+        onChange?: (event: any) => void;
+        onBlur?: (event: any) => void;
+        disabled?: boolean | undefined;
+        deps?: string | string[] | undefined;
+        pattern?: import("react-hook-form").ValidationRule<RegExp> | undefined;
+        valueAsNumber?: boolean | undefined;
+        valueAsDate?: false;
+    } | {
+        required?: string | import("react-hook-form").ValidationRule<boolean> | undefined;
+        min?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        max?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        maxLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        minLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        validate?: import("react-hook-form").Validate<any, import("react-hook-form").FieldValues> | Record<string, import("react-hook-form").Validate<any, import("react-hook-form").FieldValues>> | undefined;
+        value?: any;
+        setValueAs?: ((value: any) => any) | undefined;
+        shouldUnregister?: boolean;
+        onChange?: (event: any) => void;
+        onBlur?: (event: any) => void;
+        disabled?: boolean | undefined;
+        deps?: string | string[] | undefined;
+        pattern?: import("react-hook-form").ValidationRule<RegExp> | undefined;
+        valueAsNumber?: boolean | undefined;
+        valueAsDate?: boolean | undefined;
+    } | {
+        required?: string | import("react-hook-form").ValidationRule<boolean> | undefined;
+        min?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        max?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        maxLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        minLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        validate?: import("react-hook-form").Validate<any, import("react-hook-form").FieldValues> | Record<string, import("react-hook-form").Validate<any, import("react-hook-form").FieldValues>> | undefined;
+        value?: any;
+        setValueAs?: ((value: any) => any) | undefined;
+        shouldUnregister?: boolean;
+        onChange?: (event: any) => void;
+        onBlur?: (event: any) => void;
+        disabled?: boolean | undefined;
+        deps?: string | string[] | undefined;
+        pattern?: import("react-hook-form").ValidationRule<RegExp> | undefined;
+        valueAsNumber?: boolean | undefined;
+        valueAsDate?: false;
+    } | {
+        required?: string | import("react-hook-form").ValidationRule<boolean> | undefined;
+        min?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        max?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        maxLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        minLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        validate?: import("react-hook-form").Validate<any, import("react-hook-form").FieldValues> | Record<string, import("react-hook-form").Validate<any, import("react-hook-form").FieldValues>> | undefined;
+        value?: any;
+        setValueAs?: ((value: any) => any) | undefined;
+        shouldUnregister?: boolean;
+        onChange?: (event: any) => void;
+        onBlur?: (event: any) => void;
+        disabled?: boolean | undefined;
+        deps?: string | string[] | undefined;
+        pattern?: import("react-hook-form").ValidationRule<RegExp> | undefined;
+        valueAsNumber?: boolean | undefined;
+        valueAsDate?: boolean | undefined;
+    } | {
+        required?: string | import("react-hook-form").ValidationRule<boolean> | undefined;
+        min?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        max?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        maxLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        minLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        validate?: import("react-hook-form").Validate<any, import("react-hook-form").FieldValues> | Record<string, import("react-hook-form").Validate<any, import("react-hook-form").FieldValues>> | undefined;
+        value?: any;
+        setValueAs?: ((value: any) => any) | undefined;
+        shouldUnregister?: boolean;
+        onChange?: (event: any) => void;
+        onBlur?: (event: any) => void;
+        disabled?: boolean | undefined;
+        deps?: string | string[] | undefined;
+        pattern?: undefined;
+        valueAsNumber?: boolean | undefined;
+        valueAsDate?: boolean | undefined;
+    } | {
+        required?: string | import("react-hook-form").ValidationRule<boolean> | undefined;
+        min?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        max?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        maxLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        minLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        validate?: import("react-hook-form").Validate<any, import("react-hook-form").FieldValues> | Record<string, import("react-hook-form").Validate<any, import("react-hook-form").FieldValues>> | undefined;
+        value?: any;
+        setValueAs?: ((value: any) => any) | undefined;
+        shouldUnregister?: boolean;
+        onChange?: (event: any) => void;
+        onBlur?: (event: any) => void;
+        disabled?: boolean | undefined;
+        deps?: string | string[] | undefined;
+        pattern?: undefined;
+        valueAsNumber?: boolean | undefined;
+        valueAsDate?: boolean | undefined;
+    } | {
+        required?: string | import("react-hook-form").ValidationRule<boolean> | undefined;
+        min?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        max?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        maxLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        minLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        validate?: import("react-hook-form").Validate<any, import("react-hook-form").FieldValues> | Record<string, import("react-hook-form").Validate<any, import("react-hook-form").FieldValues>> | undefined;
+        value?: any;
+        setValueAs?: ((value: any) => any) | undefined;
+        shouldUnregister?: boolean;
+        onChange?: (event: any) => void;
+        onBlur?: (event: any) => void;
+        disabled?: boolean | undefined;
+        deps?: string | string[] | undefined;
+        pattern?: import("react-hook-form").ValidationRule<RegExp> | undefined;
+        valueAsNumber?: boolean | undefined;
+        valueAsDate?: false;
+    } | {
+        required?: string | import("react-hook-form").ValidationRule<boolean> | undefined;
+        min?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        max?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        maxLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        minLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        validate?: import("react-hook-form").Validate<any, import("react-hook-form").FieldValues> | Record<string, import("react-hook-form").Validate<any, import("react-hook-form").FieldValues>> | undefined;
+        value?: any;
+        setValueAs?: ((value: any) => any) | undefined;
+        shouldUnregister?: boolean;
+        onChange?: (event: any) => void;
+        onBlur?: (event: any) => void;
+        disabled?: boolean | undefined;
+        deps?: string | string[] | undefined;
+        pattern?: undefined;
+        valueAsNumber?: boolean | undefined;
+        valueAsDate?: boolean | undefined;
+    } | {
+        required?: string | import("react-hook-form").ValidationRule<boolean> | undefined;
+        min?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        max?: import("react-hook-form").ValidationRule<string | number> | undefined;
+        maxLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        minLength?: import("react-hook-form").ValidationRule<number> | undefined;
+        validate?: import("react-hook-form").Validate<any, import("react-hook-form").FieldValues> | Record<string, import("react-hook-form").Validate<any, import("react-hook-form").FieldValues>> | undefined;
+        value?: any;
+        setValueAs?: ((value: any) => any) | undefined;
+        shouldUnregister?: boolean;
+        onChange?: (event: any) => void;
+        onBlur?: (event: any) => void;
+        disabled?: boolean | undefined;
+        deps?: string | string[] | undefined;
+        pattern?: undefined;
+        valueAsNumber?: true;
+        valueAsDate?: false;
+    };
+};
+export default useFieldWrapper;
+//# sourceMappingURL=useFieldWrapper.d.ts.map

package/dist/types/ui/Field/common/Wrapper/hooks/useFieldWrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFieldWrapper.d.ts","sourceRoot":"","sources":["../../../../../../../src/ui/Field/common/Wrapper/hooks/useFieldWrapper.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,eAAe,EAAkB,MAAM,iBAAiB,CAAC;AAKvE,KAAK,sBAAsB,GAAG;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,iBAAiB,CAAC,EAAE,eAAe,CAAC;IACpC,mBAAmB,CAAC,EAAE,eAAe,CAAC;IACtC,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B,CAAC;AAEF;;;;GAIG;AACH,QAAA,MAAM,eAAe,GACnB,MAAM,MAAM,EACZ,UAAS,sBAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+CrC,CAAC;AACF,eAAe,eAAe,CAAC"}

package/dist/types/ui/Field/common/Wrapper/index.d.ts

@@ -0,0 +1,5 @@
+export { default as Wrapper } from "./Wrapper.js";
+export { default as InvisibleWrapper } from "./InvisibleWrapper.js";
+export { default as withWrapper } from "./withWrapper.js";
+export * from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/ui/Field/common/Wrapper/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/ui/Field/common/Wrapper/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACpE,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC1D,cAAc,YAAY,CAAC"}

package/dist/types/ui/Field/common/Wrapper/messages.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    required: (name: string) => string;
+};
+export default _default;
+//# sourceMappingURL=messages.d.ts.map

package/dist/types/ui/Field/common/Wrapper/messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../../../../../src/ui/Field/common/Wrapper/messages.ts"],"names":[],"mappings":";qBACmB,MAAM;;AADzB,wBAEE"}

package/dist/types/ui/Field/common/Wrapper/types.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/types/ui/Field/common/Wrapper/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../src/ui/Field/common/Wrapper/types.ts"],"names":[],"mappings":""}

package/dist/types/ui/Field/common/Wrapper/withConditionalDisplay.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+import type { BaseInputProps, WrappedComponentProps } from "../../types.js";
+type WrappedComponentPropsInternal<ComponentProps extends BaseInputProps> = Omit<WrappedComponentProps<ComponentProps>, "Component">;
+declare const withConditionalDisplay: <ComponentProps extends BaseInputProps>(WrappedComponent: React.ComponentType<ComponentProps>) => (props: WrappedComponentPropsInternal<ComponentProps>) => React.ReactElement<ComponentProps, string | React.JSXElementConstructor<any>> | null;
+export default withConditionalDisplay;
+//# sourceMappingURL=withConditionalDisplay.d.ts.map

package/dist/types/ui/Field/common/Wrapper/withConditionalDisplay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withConditionalDisplay.d.ts","sourceRoot":"","sources":["../../../../../../src/ui/Field/common/Wrapper/withConditionalDisplay.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,KAAK,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAE5E,KAAK,6BAA6B,CAAC,cAAc,SAAS,cAAc,IACtE,IAAI,CAAC,qBAAqB,CAAC,cAAc,CAAC,EAAE,WAAW,CAAC,CAAC;AAG3D,QAAA,MAAM,sBAAsB,GAAI,cAAc,SAAS,cAAc,EACnE,kBAAkB,KAAK,CAAC,aAAa,CAAC,cAAc,CAAC,aAG5C,6BAA6B,CAAC,cAAc,CAAC,yFAcvD,CAAC;AAEF,eAAe,sBAAsB,CAAC"}

package/dist/types/ui/Field/common/Wrapper/withWrapper.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+import type { BaseInputProps, BaseWrapperProps, Condition, WrappedComponentProps, WrapperProps } from "../../types.js";
+type WrappedComponentPropsInternal<ComponentProps extends BaseInputProps> = Omit<WrappedComponentProps<ComponentProps>, "Component"> & {
+    condition?: Condition;
+};
+declare const withWrapper: <ComponentProps extends BaseInputProps, ComponentWrapperProps extends BaseWrapperProps<ComponentProps> = WrapperProps<ComponentProps>>(Component: React.ComponentType<ComponentProps>, options?: Partial<ComponentWrapperProps>, Wrapper?: React.ComponentType<WrapperProps<ComponentProps>>) => (props: "id" | "label" | "style" | "className" | "description" | "isOptional" | "nestedRegisterProps" | "unregisterOnUnmount" | "mockLabel" | "middleware" | "WrapperComponent" | "condition" | Exclude<Exclude<keyof ComponentProps, "Component">, "Component"> extends infer T extends keyof WrappedComponentProps<WrappedComponentPropsInternal<ComponentProps>> ? { [P in T]: WrappedComponentProps<WrappedComponentPropsInternal<ComponentProps>>[P]; } : never) => React.ReactElement<WrappedComponentPropsInternal<ComponentProps>, string | React.JSXElementConstructor<any>> | null;
+export default withWrapper;
+//# sourceMappingURL=withWrapper.d.ts.map