@ansible/ansible-ui-framework 0.0.0

package/framework/PageDialogs/SingleSelectDialog.d.ts

@@ -0,0 +1,20 @@
+import { ITableColumn } from '../PageTable/PageTableColumn';
+import { ISelected } from '../PageTable/useTableItems';
+import { IToolbarFilter } from '../PageToolbar/PageToolbarFilter';
+import { IView } from '../useView';
+export type SingleSelectDialogProps<T extends object> = {
+    title: string;
+    view: IView & ISelected<T> & {
+        itemCount?: number;
+        pageItems: T[] | undefined;
+    };
+    tableColumns: ITableColumn<T>[];
+    toolbarFilters: IToolbarFilter[];
+    onSelect: (item: T) => void;
+    confirmText?: string;
+    cancelText?: string;
+    emptyStateTitle?: string;
+    errorStateTitle?: string;
+    onClose?: () => void;
+};
+export declare function SingleSelectDialog<T extends object>(props: SingleSelectDialogProps<T>): import("react/jsx-runtime").JSX.Element;

package/framework/PageDialogs/useSelectDialog.d.ts

@@ -0,0 +1,33 @@
+import { ITableColumn } from '../PageTable/PageTableColumn';
+import { ISelected } from '../PageTable/useTableItems';
+import { IToolbarFilter } from '../PageToolbar/PageToolbarFilter';
+import { IView } from '../useView';
+interface ISelectDialogOptions<T extends object, TMultiple> {
+    view: IView & ISelected<T> & {
+        itemCount?: number;
+        pageItems: T[] | undefined;
+    };
+    tableColumns: ITableColumn<T>[];
+    toolbarFilters: IToolbarFilter[];
+    confirm: string;
+    cancel: string;
+    selected: string;
+    isMultiple?: TMultiple extends true ? true : false;
+}
+export declare function useSelectDialog<T extends {
+    id: number | string;
+    name: string | undefined;
+}, TMultiple = false>(options: ISelectDialogOptions<T, TMultiple>): (onSelect?: (TMultiple extends true ? (item: T[]) => void : (item: T) => void) | undefined, title?: string) => void;
+export type SelectDialogProps<T extends object, TMultiple> = {
+    title: string;
+    open: boolean;
+    isMultiple?: TMultiple extends true ? true : false;
+    setOpen: (open: boolean) => void;
+    onSelect: TMultiple extends true ? (item: T[]) => void : (item: T) => void;
+    keyFn: (item: T) => string | number;
+} & ISelectDialogOptions<T, TMultiple>;
+export declare function SelectDialog<T extends {
+    id: number | string;
+    name: string | undefined;
+}, TMultiple = false>(props: SelectDialogProps<T, TMultiple>): import("react/jsx-runtime").JSX.Element;
+export {};

package/framework/PageEmptyStates/PageNotFound.d.ts

@@ -0,0 +1,3 @@
+export declare function PageNotFound(props: {
+    dashboardUrl?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/framework/PageEmptyStates/PageNotImplemented.d.ts

@@ -0,0 +1 @@
+export declare function PageNotImplemented(): import("react/jsx-runtime").JSX.Element;

package/framework/PageForm/ErrorAlert.cy.d.ts

@@ -0,0 +1 @@
+export {};

package/framework/PageForm/ErrorAlert.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode } from 'react';
+type ErrorType = string | ReactNode | (string | ReactNode)[] | null;
+interface ErrorAlertProps {
+    error: ErrorType;
+    isMd: boolean;
+    onCancel?: () => void;
+}
+export declare function ErrorAlert({ error, isMd, onCancel }: ErrorAlertProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/framework/PageForm/GenericForm.d.ts

@@ -0,0 +1,14 @@
+import { ReactNode } from 'react';
+import { DefaultValues } from 'react-hook-form';
+import { ErrorAdapter } from './typesErrorAdapter';
+import { PageFormSubmitHandler } from './PageForm';
+export interface GenericFormProps<T extends object> {
+    children?: ReactNode;
+    onSubmit: PageFormSubmitHandler<T>;
+    onCancel?: () => void;
+    defaultValue?: DefaultValues<T>;
+    isVertical?: boolean;
+    autoComplete?: 'on' | 'off';
+    errorAdapter?: ErrorAdapter;
+}
+export declare function GenericForm<T extends object>(props: GenericFormProps<T>): import("react/jsx-runtime").JSX.Element;

package/framework/PageForm/Inputs/FormGroupDateTimePicker.d.ts

@@ -0,0 +1,12 @@
+import { DatePickerProps, TimePickerProps } from '@patternfly/react-core';
+import React from 'react';
+import { PageFormGroupProps } from './PageFormGroup';
+export type FormGroupDateTimePickerProps = Omit<DatePickerProps, 'onChange' | 'placeholder' | 'value'> & Omit<TimePickerProps, 'onChange' | 'placeholder' | 'value'> & PageFormGroupProps & {
+    onTimeChange: (event: React.FormEvent<HTMLInputElement>, time: string, hour?: number, minute?: number, seconds?: number, isValid?: boolean) => void;
+    timePlaceHolder?: string;
+    timeValue: string;
+    onDateChange: (date: string) => void;
+    datePlaceHolder?: string;
+    dateValue: string;
+};
+export declare function FormGroupDateTimePicker(props: FormGroupDateTimePickerProps): import("react/jsx-runtime").JSX.Element;

package/framework/PageForm/Inputs/FormGroupTypeAheadMultiSelect.d.ts

@@ -0,0 +1,29 @@
+import { SelectOptionObject } from '@patternfly/react-core/deprecated';
+import React from 'react';
+export type FormGroupTypeAheadMultiSelectProps = {
+    id?: string;
+    label: string;
+    labelHelp?: string | string[] | React.ReactNode;
+    labelHelpTitle?: string;
+    helperText?: string;
+    helperTextInvalid?: string;
+    isReadOnly?: boolean;
+    placeholderText?: string | React.ReactNode;
+    options: {
+        value: string | {
+            name: string;
+        };
+        label: string;
+    }[];
+    onSelect?: (event: React.MouseEvent | React.ChangeEvent, value: string | SelectOptionObject, isPlaceholder?: boolean) => void;
+    onHandleSelection: (value: string | SelectOptionObject | {
+        name: string;
+    }) => void;
+    isSubmitting: boolean;
+    value: Partial<{
+        name: string;
+    }>[];
+    onHandleClear: (chip?: string) => void;
+    isRequired?: boolean;
+};
+export declare function FormGroupTypeAheadMultiSelect(props: FormGroupTypeAheadMultiSelectProps): import("react/jsx-runtime").JSX.Element;

package/framework/PageForm/Inputs/PageFormAsyncMultiSelect.cy.d.ts

@@ -0,0 +1 @@
+export {};

package/framework/PageForm/Inputs/PageFormAsyncMultiSelect.d.ts

@@ -0,0 +1,9 @@
+import { FieldPath, FieldPathValue, FieldValues, Validate } from 'react-hook-form';
+import { PageAsyncMultiSelectProps } from '../../PageInputs/PageAsyncMultiSelect';
+import { PageFormGroupProps } from './PageFormGroup';
+export type PageFormAsyncMultiSelectProps<TFieldValues extends FieldValues = FieldValues, TFieldName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>, ValueT = FieldPathValue<TFieldValues, TFieldName>> = {
+    name: TFieldName;
+    validate?: Validate<FieldPathValue<TFieldValues, TFieldName>, TFieldValues> | Record<string, Validate<FieldPathValue<TFieldValues, TFieldName>, TFieldValues>>;
+    isReadOnly?: boolean;
+} & Pick<PageAsyncMultiSelectProps<ValueT>, 'id' | 'placeholder' | 'footer' | 'isDisabled' | 'queryOptions' | 'queryPlaceholder' | 'queryErrorText' | 'disableClearChips' | 'disableClearSelection'> & Pick<PageFormGroupProps, 'label' | 'labelHelp' | 'labelHelpTitle' | 'additionalControls' | 'isRequired' | 'helperText'>;
+export declare function PageFormAsyncMultiSelect<TFieldValues extends FieldValues = FieldValues, TFieldName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>(props: PageFormAsyncMultiSelectProps<TFieldValues, TFieldName>): import("react/jsx-runtime").JSX.Element;

package/framework/PageForm/Inputs/PageFormAsyncSelect.d.ts

@@ -0,0 +1,49 @@
+import { ReactElement, ReactNode } from 'react';
+import { FieldPath, FieldValues } from 'react-hook-form';
+export interface PageFormAsyncSelectProps<TFieldValues extends FieldValues = FieldValues, TFieldName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>, SelectionType = unknown> {
+    id?: string;
+    name: TFieldName;
+    variant?: 'single' | 'typeahead' | 'typeaheadMulti';
+    label: string;
+    labelHelpTitle?: string;
+    labelHelp?: string | string[] | ReactNode;
+    placeholder: string;
+    loadingPlaceholder: string;
+    loadingErrorText: string;
+    additionalControls?: ReactElement;
+    query: (page: number) => Promise<{
+        total: number;
+        values: SelectionType[];
+    }>;
+    valueToString: (value: SelectionType | undefined) => string;
+    valueToDescription?: (value: SelectionType | undefined) => ReactNode;
+    isRequired?: boolean;
+    isReadOnly?: boolean;
+    openSelectDialog?: (onSelect: (value: SelectionType | null) => void, defaultSelection?: SelectionType) => void;
+    limit: number;
+}
+export declare function PageFormAsyncSelect<TFieldValues extends FieldValues = FieldValues, TFieldName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>, SelectionType = any>(props: PageFormAsyncSelectProps<TFieldValues, TFieldName, SelectionType>): import("react/jsx-runtime").JSX.Element;
+export interface AsyncSelectProps<SelectionType> {
+    id?: string;
+    value: SelectionType | undefined;
+    valueToString: (value: SelectionType | undefined) => string;
+    valueToDescription?: (value: SelectionType | undefined) => ReactNode;
+    onSelect: (value: SelectionType | null) => void;
+    query: (pageSize: number) => Promise<{
+        total: number;
+        values: SelectionType[];
+    }>;
+    placeholder: string;
+    variant?: 'single' | 'typeahead' | 'typeaheadMulti';
+    loadingPlaceholder: string;
+    labeledBy?: string;
+    isReadOnly?: boolean;
+    helperTextInvalid?: string;
+    validated?: 'success' | 'warning' | 'error' | 'default';
+    showRefreshButton?: boolean;
+    isRequired?: boolean;
+    limit: number;
+    loadingError?: boolean;
+    openSelectDialog?: (onSelect: (value: SelectionType | null) => void, defaultSelection?: SelectionType) => void;
+}
+export declare function AsyncSelect<SelectionType>(props: AsyncSelectProps<SelectionType>): import("react/jsx-runtime").JSX.Element;

package/framework/PageForm/Inputs/PageFormAsyncSingleSelect.cy.d.ts

@@ -0,0 +1 @@
+export {};

package/framework/PageForm/Inputs/PageFormAsyncSingleSelect.d.ts

@@ -0,0 +1,9 @@
+import { FieldPath, FieldPathValue, FieldValues, Validate } from 'react-hook-form';
+import { PageAsyncSingleSelectProps } from '../../PageInputs/PageAsyncSingleSelect';
+import { PageFormGroupProps } from './PageFormGroup';
+export type PageFormAsyncSingleSelectProps<TFieldValues extends FieldValues = FieldValues, TFieldName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>, ValueT = FieldPathValue<TFieldValues, TFieldName>> = {
+    name: TFieldName;
+    validate?: Validate<FieldPathValue<TFieldValues, TFieldName>, TFieldValues> | Record<string, Validate<FieldPathValue<TFieldValues, TFieldName>, TFieldValues>>;
+    isReadOnly?: boolean;
+} & Pick<PageAsyncSingleSelectProps<ValueT>, 'id' | 'placeholder' | 'footer' | 'isDisabled' | 'isRequired' | 'queryOptions' | 'queryPlaceholder' | 'queryErrorText'> & Pick<PageFormGroupProps, 'label' | 'labelHelp' | 'labelHelpTitle' | 'additionalControls' | 'isRequired' | 'helperText'>;
+export declare function PageFormAsyncSingleSelect<TFieldValues extends FieldValues = FieldValues, TFieldName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>(props: PageFormAsyncSingleSelectProps<TFieldValues, TFieldName>): import("react/jsx-runtime").JSX.Element;

package/framework/PageForm/Inputs/PageFormCheckbox.d.ts

@@ -0,0 +1,11 @@
+import { CheckboxProps } from '@patternfly/react-core';
+import { ReactNode } from 'react';
+import { FieldPath, FieldValues, Validate } from 'react-hook-form';
+export type PageFormCheckboxProps<TFieldValues extends FieldValues = FieldValues, TFieldName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = {
+    id?: string;
+    name: TFieldName;
+    validate?: Validate<boolean, TFieldValues> | Record<string, Validate<boolean, TFieldValues>>;
+    labelHelpTitle?: string;
+    labelHelp?: string | string[] | ReactNode;
+} & Omit<CheckboxProps, 'id' | 'onChange' | 'value'>;
+export declare function PageFormCheckbox<TFieldValues extends FieldValues = FieldValues, TFieldName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>(props: PageFormCheckboxProps<TFieldValues, TFieldName>): import("react/jsx-runtime").JSX.Element;

package/framework/PageForm/Inputs/PageFormCreatableSelect.d.ts

@@ -0,0 +1,20 @@
+import { ReactElement, ReactNode } from 'react';
+import { FieldPath, FieldPathValue, FieldValues, Validate } from 'react-hook-form';
+export type PageFormCreatableSelectProps<TFieldValues extends FieldValues = FieldValues, TFieldName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = {
+    id?: string;
+    name: TFieldName;
+    label: string;
+    labelHelp?: string | string[] | ReactNode;
+    labelHelpTitle?: string;
+    additionalControls?: ReactElement;
+    placeholderText?: string;
+    options: {
+        value: string | {
+            name: string;
+        };
+        label: string;
+    }[];
+    isRequired?: boolean;
+    validate?: Validate<FieldPathValue<TFieldValues, TFieldName>, TFieldValues> | Record<string, Validate<FieldPathValue<TFieldValues, TFieldName>, TFieldValues>>;
+};
+export declare function PageFormCreatableSelect<TFieldValues extends FieldValues = FieldValues, TFieldName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>(props: PageFormCreatableSelectProps<TFieldValues, TFieldName>): import("react/jsx-runtime").JSX.Element;

package/framework/PageForm/Inputs/PageFormDataEditor.cy.d.ts

@@ -0,0 +1 @@
+export {};

package/framework/PageForm/Inputs/PageFormDataEditor.d.ts

@@ -0,0 +1,36 @@
+import { ReactNode } from 'react';
+import { FieldPathByValue, FieldValues, Validate } from 'react-hook-form';
+import { DataEditorLanguages } from '../../components/DataEditor';
+export type PageFormDataEditorInputProps<TFieldValues extends FieldValues = FieldValues, TFieldName extends FieldPathByValue<TFieldValues, object | string | undefined | null> = FieldPathByValue<TFieldValues, object | string | undefined | null>> = {
+    id?: string;
+    name: TFieldName;
+    label: string;
+    labelHelp?: string | string[] | ReactNode;
+    labelHelpTitle?: string;
+    additionalControls?: ReactNode;
+    format: DataEditorLanguages | 'object';
+    disableCopy?: boolean;
+    disableUpload?: boolean;
+    disableDownload?: boolean;
+    disableExpand?: boolean;
+    defaultCollapsed?: boolean;
+    isRequired?: boolean;
+    validate?: Validate<string, TFieldValues> | Record<string, Validate<string, TFieldValues>>;
+    isReadOnly?: boolean;
+    isArray?: boolean;
+};
+export declare function PageFormDataEditor<TFieldValues extends FieldValues = FieldValues, TFieldName extends FieldPathByValue<TFieldValues, object | string | undefined | null> = FieldPathByValue<TFieldValues, object | string | undefined | null>>(props: PageFormDataEditorInputProps<TFieldValues, TFieldName>): import("react/jsx-runtime").JSX.Element;
+export declare function DataEditorButtons(props: {
+    handleCopy: (() => void) | false;
+    handleDownload: (() => void) | false;
+    handleUpload: (() => void) | false;
+    children?: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function DataEditorActions(props: {
+    handleCopy: (() => void) | false;
+    handleDownload: (() => void) | false;
+    handleUpload: (() => void) | false;
+    language: string;
+    setLanguage: (language: DataEditorLanguages) => void;
+    children?: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/framework/PageForm/Inputs/PageFormDateTimePicker.d.ts

@@ -0,0 +1,12 @@
+import { ReactNode } from 'react';
+import { FieldPath, FieldValues } from 'react-hook-form';
+export type PageFormDateTimePickerProps<TFieldValues extends FieldValues = FieldValues, TFieldName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = {
+    name: TFieldName;
+    datePlaceHolder?: string;
+    timePlaceHolder?: string;
+    label: string;
+    labelHelp?: string | string[] | ReactNode;
+    labelHelpTitle?: string;
+    isDisabled?: boolean;
+};
+export declare function PageFormDateTimePicker<TFieldValues extends FieldValues = FieldValues, TFieldName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>(props: PageFormDateTimePickerProps<TFieldValues, TFieldName>): import("react/jsx-runtime").JSX.Element;

package/framework/PageForm/Inputs/PageFormFileUpload.d.ts

@@ -0,0 +1,7 @@
+import { FileUploadProps } from '@patternfly/react-core';
+import { PageFormGroupProps } from './PageFormGroup';
+export type PageFormFileUploadProps = {
+    name: string;
+    placeholder?: string;
+} & PageFormGroupProps & Omit<FileUploadProps, 'id'>;
+export declare function PageFormFileUpload(props: PageFormFileUploadProps): import("react/jsx-runtime").JSX.Element;

package/framework/PageForm/Inputs/PageFormGroup.d.ts

@@ -0,0 +1,14 @@
+import { ReactNode } from 'react';
+export interface PageFormGroupProps {
+    fieldId?: string;
+    icon?: ReactNode;
+    label?: string;
+    labelHelp?: string | string[] | ReactNode;
+    labelHelpTitle?: string;
+    isRequired?: boolean;
+    additionalControls?: ReactNode;
+    children?: ReactNode;
+    helperText?: string;
+    helperTextInvalid?: string | string[] | false;
+}
+export declare function PageFormGroup(props: PageFormGroupProps): import("react/jsx-runtime").JSX.Element;

package/framework/PageForm/Inputs/PageFormMarkdown.d.ts

@@ -0,0 +1,19 @@
+import { ReactNode } from 'react';
+import { FieldPathByValue, FieldValues, Validate } from 'react-hook-form';
+export type PageFormMarkdownInputProps<TFieldValues extends FieldValues = FieldValues, TFieldName extends FieldPathByValue<TFieldValues, object | string | undefined | null> = FieldPathByValue<TFieldValues, object | string | undefined | null>> = {
+    id?: string;
+    name: TFieldName;
+    label: string;
+    labelHelp?: string | string[] | ReactNode;
+    labelHelpTitle?: string;
+    additionalControls?: ReactNode;
+    disableCopy?: boolean;
+    disableUpload?: boolean;
+    disableDownload?: boolean;
+    disableExpand?: boolean;
+    defaultCollapsed?: boolean;
+    isRequired?: boolean;
+    validate?: Validate<string, TFieldValues> | Record<string, Validate<string, TFieldValues>>;
+    isReadOnly?: boolean;
+};
+export declare function PageFormMarkdown<TFieldValues extends FieldValues = FieldValues, TFieldName extends FieldPathByValue<TFieldValues, object | string | undefined | null> = FieldPathByValue<TFieldValues, object | string | undefined | null>>(props: PageFormMarkdownInputProps<TFieldValues, TFieldName>): import("react/jsx-runtime").JSX.Element;

package/framework/PageForm/Inputs/PageFormMarkdownEditor.cy.d.ts

@@ -0,0 +1 @@
+export {};

package/framework/PageForm/Inputs/PageFormMultiInput.d.ts

@@ -0,0 +1,23 @@
+import { ChipGroupProps } from '@patternfly/react-core';
+import { FieldPath, FieldValues, Validate, ValidationRule } from 'react-hook-form';
+import { PageFormGroupProps } from './PageFormGroup';
+export type PageFormMultiInputProps<T, TFieldValues extends FieldValues = FieldValues, TFieldName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = {
+    name: TFieldName;
+    placeholder?: string;
+    minLength?: number | ValidationRule<number>;
+    maxLength?: number | ValidationRule<number>;
+    pattern?: ValidationRule<RegExp>;
+    validate?: Validate<T[], TFieldValues>;
+    selectTitle?: string;
+    isDisabled?: boolean;
+    selectOpen?: (callback: (selection: T[]) => void, title: string) => void;
+} & Omit<PageFormGroupProps, 'onChange' | 'value'> & ChipGroupProps;
+interface FieldValuesWithArray<T> extends FieldValues {
+    [key: string]: T[];
+}
+export declare function PageFormMultiInput<T extends {
+    hostname?: string;
+    id: number | string;
+    name: string;
+}, TFieldValues extends FieldValuesWithArray<T> = FieldValuesWithArray<T>, TFieldName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>(props: PageFormMultiInputProps<T, TFieldValues, TFieldName>): import("react/jsx-runtime").JSX.Element;
+export {};

package/framework/PageForm/Inputs/PageFormMultiSelect.d.ts

@@ -0,0 +1,9 @@
+import { FieldPath, FieldPathValue, FieldValues, Validate } from 'react-hook-form';
+import { PageMultiSelectProps } from '../../PageInputs/PageMultiSelect';
+import { PageFormGroupProps } from './PageFormGroup';
+export type PageFormMultiSelectProps<TFieldValues extends FieldValues = FieldValues, TFieldName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>, ValueT = FieldPathValue<TFieldValues, TFieldName>> = {
+    name: TFieldName;
+    validate?: Validate<FieldPathValue<TFieldValues, TFieldName>, TFieldValues> | Record<string, Validate<FieldPathValue<TFieldValues, TFieldName>, TFieldValues>>;
+    isReadOnly?: boolean;
+} & Pick<PageMultiSelectProps<ValueT>, 'id' | 'placeholder' | 'options' | 'footer' | 'isDisabled'> & Pick<PageFormGroupProps, 'label' | 'labelHelp' | 'labelHelpTitle' | 'additionalControls' | 'isRequired' | 'helperText'>;
+export declare function PageFormMultiSelect<TFieldValues extends FieldValues = FieldValues, TFieldName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>(props: PageFormMultiSelectProps<TFieldValues, TFieldName>): import("react/jsx-runtime").JSX.Element;

package/framework/PageForm/Inputs/PageFormSecret.cy.d.ts

@@ -0,0 +1 @@
+export {};

package/framework/PageForm/Inputs/PageFormSecret.d.ts

@@ -0,0 +1,14 @@
+import { ReactElement } from 'react';
+interface ChildProps {
+    labelHelp?: string;
+    label?: string;
+}
+interface IProps {
+    shouldHideField: boolean | undefined;
+    onClear: () => void;
+    children: ReactElement<ChildProps>;
+    labelHelp?: string;
+    label?: string;
+}
+export declare function PageFormSecret({ onClear, shouldHideField, label, labelHelp, children }: IProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/framework/PageForm/Inputs/PageFormSelect.d.ts

@@ -0,0 +1,21 @@
+import { ReactNode } from 'react';
+import { FieldPath, FieldPathValue, FieldValues, Validate } from 'react-hook-form';
+import { PageSelectOption } from '../../PageInputs/PageSelectOption';
+export type PageFormSelectProps<TFieldValues extends FieldValues = FieldValues, TFieldName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>, TSelection = unknown> = {
+    id?: string;
+    name: TFieldName;
+    label?: string;
+    labelHelpTitle?: string;
+    labelHelp?: string | string[] | ReactNode;
+    additionalControls?: ReactNode;
+    placeholderText?: string;
+    options: PageSelectOption<TSelection>[];
+    footer?: ReactNode;
+    helperText?: string;
+    isDisabled?: boolean;
+    isReadOnly?: boolean;
+    isRequired?: boolean;
+    fieldNameToResetOnFieldChange?: TFieldName;
+    validate?: Validate<FieldPathValue<TFieldValues, TFieldName>, TFieldValues> | Record<string, Validate<FieldPathValue<TFieldValues, TFieldName>, TFieldValues>>;
+};
+export declare function PageFormSelect<TFieldValues extends FieldValues = FieldValues, TFieldName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>, TSelection = unknown>(props: PageFormSelectProps<TFieldValues, TFieldName, TSelection>): import("react/jsx-runtime").JSX.Element;

package/framework/PageForm/Inputs/PageFormSingleSelect.d.ts

@@ -0,0 +1,9 @@
+import { FieldPath, FieldPathValue, FieldValues, Validate } from 'react-hook-form';
+import { PageSingleSelectProps } from '../../PageInputs/PageSingleSelect';
+import { PageFormGroupProps } from './PageFormGroup';
+export type PageFormSingleSelectProps<TFieldValues extends FieldValues = FieldValues, TFieldName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>, ValueT = FieldPathValue<TFieldValues, TFieldName>> = {
+    name: TFieldName;
+    validate?: Validate<FieldPathValue<TFieldValues, TFieldName>, TFieldValues> | Record<string, Validate<FieldPathValue<TFieldValues, TFieldName>, TFieldValues>>;
+    isReadOnly?: boolean;
+} & Pick<PageSingleSelectProps<ValueT>, 'id' | 'placeholder' | 'options' | 'footer' | 'isDisabled' | 'isRequired'> & Pick<PageFormGroupProps, 'label' | 'labelHelp' | 'labelHelpTitle' | 'additionalControls' | 'isRequired' | 'helperText'>;
+export declare function PageFormSingleSelect<TFieldValues extends FieldValues = FieldValues, TFieldName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>(props: PageFormSingleSelectProps<TFieldValues, TFieldName>): import("react/jsx-runtime").JSX.Element;

package/framework/PageForm/Inputs/PageFormSlider.d.ts

@@ -0,0 +1,9 @@
+export declare function PageFormSlider(props: {
+    id?: string;
+    label: string;
+    name: string;
+    autoFocus?: boolean;
+    min?: number;
+    max?: number;
+    valueLabel?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/framework/PageForm/Inputs/PageFormSwitch.d.ts

@@ -0,0 +1,18 @@
+import { ReactElement, ReactNode } from 'react';
+import { FieldPath, FieldValues, Validate, ValidationRule } from 'react-hook-form';
+export type PageFormSwitchProps<TFieldValues extends FieldValues = FieldValues, TFieldName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = {
+    id?: string;
+    name: TFieldName;
+    label?: string;
+    labelHelpTitle?: string;
+    labelHelp?: string | string[] | ReactNode;
+    isRequired?: boolean;
+    additionalControls?: ReactElement;
+    helperText?: string;
+    pattern?: ValidationRule<RegExp>;
+    validate?: Validate<string, TFieldValues> | Record<string, Validate<string, TFieldValues>>;
+    autoFocus?: boolean;
+    labelOn?: string;
+    labelOff?: string;
+};
+export declare function PageFormSwitch<TFieldValues extends FieldValues = FieldValues, TFieldName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>(props: PageFormSwitchProps<TFieldValues, TFieldName>): import("react/jsx-runtime").JSX.Element;

package/framework/PageForm/Inputs/PageFormTextArea.d.ts

@@ -0,0 +1,3 @@
+import { FieldPath, FieldValues } from 'react-hook-form';
+import { PageFormTextInputProps } from './PageFormTextInput';
+export declare function PageFormTextArea<TFieldValues extends FieldValues = FieldValues, TFieldName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>, TSelection extends FieldValues = FieldValues>(props: PageFormTextInputProps<TFieldValues, TFieldName, TSelection>): import("react/jsx-runtime").JSX.Element;

package/framework/PageForm/Inputs/PageFormTextInput.d.ts

@@ -0,0 +1,29 @@
+import { ReactNode } from 'react';
+import { FieldPath, FieldPathValue, FieldValues, Validate, ValidationRule } from 'react-hook-form';
+export type PageFormTextInputProps<TFieldValues extends FieldValues = FieldValues, TFieldName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>, TSelection extends FieldValues = FieldValues> = {
+    id?: string;
+    name: TFieldName;
+    type?: 'text' | 'date' | 'datetime-local' | 'email' | 'month' | 'number' | 'password' | 'search' | 'tel' | 'time' | 'url';
+    label?: string;
+    labelHelpTitle?: string;
+    labelHelp?: string | string[] | ReactNode;
+    additionalControls?: ReactNode;
+    placeholder?: string;
+    button?: ReactNode;
+    helperText?: string;
+    isDisabled?: boolean;
+    isReadOnly?: boolean;
+    isRequired?: boolean;
+    validate?: Validate<string, TFieldValues> | Record<string, Validate<string, TFieldValues>>;
+    minLength?: number | ValidationRule<number>;
+    maxLength?: number | ValidationRule<number>;
+    min?: number | string;
+    max?: number | string;
+    pattern?: ValidationRule<RegExp>;
+    selectTitle?: string;
+    selectValue?: (selection: TSelection) => FieldPathValue<TSelection, FieldPath<TSelection>>;
+    selectOpen?: (callback: (selection: TSelection) => void, title: string) => void;
+    autoFocus?: boolean;
+    autoComplete?: string;
+};
+export declare function PageFormTextInput<TFieldValues extends FieldValues = FieldValues, TFieldName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>, TSelection extends FieldValues = FieldValues>(props: PageFormTextInputProps<TFieldValues, TFieldName, TSelection>): import("react/jsx-runtime").JSX.Element;

package/framework/PageForm/Inputs/validation-hooks.d.ts

@@ -0,0 +1,4 @@
+export declare function useRequiredValidationRule(label: string, isRequired?: boolean): {
+    value: boolean;
+    message: string;
+} | undefined;

package/framework/PageForm/PageForm.d.ts

@@ -0,0 +1,37 @@
+import { ReactNode } from 'react';
+import { DefaultValues, ErrorOption, FieldPath, FieldValues, UseFormReturn } from 'react-hook-form';
+import { ErrorAdapter } from './typesErrorAdapter';
+export interface PageFormProps<T extends object> {
+    children?: ReactNode;
+    submitText?: string;
+    additionalActionText?: string;
+    onClickAdditionalAction?: PageFormSubmitHandler<T>;
+    onSubmit: PageFormSubmitHandler<T>;
+    cancelText?: string;
+    onCancel?: () => void;
+    defaultValue?: DefaultValues<T>;
+    isVertical?: boolean;
+    singleColumn?: boolean;
+    disablePadding?: boolean;
+    disableGrid?: boolean;
+    autoComplete?: 'on' | 'off';
+    footer?: ReactNode;
+    errorAdapter?: ErrorAdapter;
+    disableSubmitOnEnter?: boolean;
+}
+export declare function useFormErrors<T extends object>(defaultValue: DefaultValues<T> | undefined, errorAdapter: ErrorAdapter): {
+    form: UseFormReturn<T, any, undefined>;
+    handleSubmit: import("react-hook-form").UseFormHandleSubmit<T, undefined>;
+    error: string | ReactNode[] | null;
+    setError: import("react").Dispatch<import("react").SetStateAction<string | ReactNode[] | null>>;
+    handleSubmitError: (err: unknown) => void;
+    setFieldError: import("react-hook-form").UseFormSetError<T>;
+};
+export declare function PageForm<T extends object>(props: PageFormProps<T>): import("react/jsx-runtime").JSX.Element;
+export type PageFormSubmitHandler<T extends FieldValues> = (data: T, setError: (error: string) => void, setFieldError: (fieldName: FieldPath<T>, error: ErrorOption) => void, form: UseFormReturn<T> | undefined) => Promise<unknown>;
+export declare function PageFormGrid(props: {
+    children?: ReactNode;
+    isVertical?: boolean;
+    singleColumn?: boolean;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/framework/PageForm/PageFormButtons.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode, CSSProperties } from 'react';
+export declare function PageFormSubmitButton(props: {
+    children: ReactNode;
+    style?: CSSProperties;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function PageFormCancelButton(props: {
+    onCancel: () => void;
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/framework/PageForm/PageFormExpandableSection.cy.d.ts

@@ -0,0 +1 @@
+export {};

package/framework/PageForm/PageFormExpandableSection.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+interface IPageFormExpandableSectionProps {
+    children: React.ReactNode;
+    singleColumn?: boolean;
+}
+export declare function PageFormExpandableSection(props: IPageFormExpandableSectionProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/framework/PageForm/Utils/PageFormHidden.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react';
+export declare function PageFormHidden<T>(props: {
+    watch: string;
+    hidden: (value: T) => boolean;
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/framework/PageForm/Utils/PageFormSection.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from 'react';
+export declare function PageFormSection(props: {
+    title?: string;
+    children: ReactNode;
+    singleColumn?: boolean;
+    isHorizontal?: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/framework/PageForm/Utils/PageFormSetError.d.ts

@@ -0,0 +1,5 @@
+import { ReactNode } from 'react';
+import { FieldValues, UseFormSetError } from 'react-hook-form';
+export declare function PageFormSetError<TFieldValues extends FieldValues = FieldValues>(props: {
+    children: (setError: UseFormSetError<TFieldValues>) => ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/framework/PageForm/Utils/PageFormSetValue.d.ts

@@ -0,0 +1,5 @@
+import { ReactNode } from 'react';
+import { FieldValues, UseFormSetValue } from 'react-hook-form';
+export declare function PageFormSetValue<TFieldValues extends FieldValues = FieldValues>(props: {
+    children: (setValue: UseFormSetValue<TFieldValues>) => ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/framework/PageForm/Utils/PageFormWatch.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react';
+import { FieldValues, Path, PathValue, UseFormSetError } from 'react-hook-form';
+export declare function PageFormWatch<TFieldValues extends FieldValues = FieldValues, TFieldName extends Path<TFieldValues> = Path<TFieldValues>, TValue = PathValue<TFieldValues, TFieldName>>(props: {
+    watch: TFieldName;
+    children: (value: TValue, setError: UseFormSetError<TFieldValues>) => ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/framework/PageForm/genericErrorAdapter.cy.d.ts

@@ -0,0 +1 @@
+export {};

package/framework/PageForm/genericErrorAdapter.d.ts

@@ -0,0 +1,2 @@
+import { ErrorOutput } from './typesErrorAdapter';
+export declare const genericErrorAdapter: (error: unknown) => ErrorOutput;