iglooform 3.3.1 → 3.3.3

package/es/input/expiry-date.d.ts

@@ -0,0 +1,16 @@
+import { FC, IglooComponentProps } from '../types';
+import './style/input-date';
+type Props = IglooComponentProps & {
+    value?: {
+        year: string | number;
+        month: string | number;
+    };
+    onChange?: any;
+    disabled?: boolean;
+    check?: (value: {
+        year: string;
+        month: string;
+    }) => boolean;
+};
+declare const IglooExpiryDate: FC<Props>;
+export default IglooExpiryDate;

package/es/input/input-date.d.ts

@@ -0,0 +1,8 @@
+import { InputProps } from 'antd/es/input';
+import { FC, IglooComponentProps } from '../types';
+import './style/input-date';
+type Props = InputProps & IglooComponentProps & {
+    format: string;
+};
+declare const IglooInputDate: FC<Props>;
+export default IglooInputDate;

package/es/input/input-number/basic.d.ts

@@ -0,0 +1,6 @@
+import { InputProps } from 'antd/es/input';
+import { FC, IglooComponentProps } from '../../types';
+import '../style/index';
+type Props = InputProps & IglooComponentProps;
+declare const BasicInput: FC<Props>;
+export default BasicInput;

package/es/input/input-number/index.d.ts

@@ -0,0 +1,8 @@
+import { InputProps } from 'antd/es/input';
+import { InputNumberProps } from 'antd/es/input-number';
+import { FC, IglooComponentProps } from '../../types';
+type Props = InputProps & InputNumberProps & IglooComponentProps & {
+    mode?: 'step' | 'default';
+};
+declare const IglooInputNumber: FC<Props>;
+export default IglooInputNumber;

package/es/input/input-number/stepper/index.d.ts

@@ -0,0 +1,7 @@
+import { InputNumberProps } from 'antd/es/input-number';
+import { FC, IglooComponentProps } from '../../../types';
+import '../../style/index';
+import './index.less';
+type Props = InputNumberProps & IglooComponentProps;
+declare const Stepper: FC<Props>;
+export default Stepper;

package/es/input/phone-number.d.ts

@@ -0,0 +1,14 @@
+import { CSSProperties } from 'react';
+import { FC, IglooComponentProps } from '../types';
+import './style/phone-number';
+export interface PhoneNumberProps extends IglooComponentProps {
+    areaCode?: string | string[];
+    phoneNumber?: number;
+    className?: string;
+    style?: CSSProperties;
+    disabled?: boolean;
+    value?: any;
+    onChange?: any;
+}
+declare const PhoneNumber: FC<PhoneNumberProps>;
+export default PhoneNumber;

package/es/layout/defaultFooter.d.ts

@@ -0,0 +1,4 @@
+import { FC } from 'react';
+import './style';
+declare const DefaultFooter: FC<any>;
+export default DefaultFooter;

package/es/media/index.d.ts

@@ -0,0 +1,29 @@
+import { FC, CSSProperties } from 'react';
+import './style';
+type Download = false | {
+    actionType?: 'downloadBlob' | 'openUrl';
+};
+type GetNonCORSUrl = (originUrl: string) => Promise<string> | string;
+interface Props {
+    src: string | {
+        origin: string;
+        nonCORS: string;
+    };
+    name?: string;
+    type?: string;
+    index?: number;
+    list?: Array<{
+        type: string;
+        src: string;
+        nonCORSSrc?: string;
+    }>;
+    docNames?: string[];
+    className?: any;
+    style?: CSSProperties;
+    showAllPages?: boolean;
+    destroyOnClose?: boolean;
+    download?: Download;
+    getNonCORSUrl?: GetNonCORSUrl;
+}
+declare const MediaWithPreview: FC<Props>;
+export default MediaWithPreview;

package/es/media/preview.d.ts

@@ -0,0 +1,12 @@
+import { FC, CSSProperties } from 'react';
+interface MediaProps {
+    src: string;
+    type: string;
+    scale?: number;
+    isCurrent?: boolean;
+    className?: any;
+    style?: CSSProperties;
+    showAllPages?: boolean;
+}
+declare const Media: FC<MediaProps>;
+export default Media;

package/es/message/index.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="react" />
+import useMessage from './useMessage';
+import './style';
+type ConfigContent = React.ReactNode | string;
+type ConfigDuration = number;
+export interface IglooGlobalMessage {
+    info(content: ConfigContent, duration?: ConfigDuration): any;
+    success(content: ConfigContent, duration?: ConfigDuration): any;
+    error(content: ConfigContent, duration?: ConfigDuration): any;
+    warning(content: ConfigContent, duration?: ConfigDuration): any;
+    useMessage: typeof useMessage;
+}
+declare const IglooMessage: IglooGlobalMessage;
+export default IglooMessage;

package/es/message/useMessage.d.ts

@@ -0,0 +1,6 @@
+import { type ReactElement } from 'react';
+import type { IglooGlobalMessage } from './';
+import './style';
+export type HookAPI = Omit<IglooGlobalMessage, 'useMessage'>;
+declare const useMessage: () => readonly [HookAPI, ReactElement];
+export default useMessage;

package/es/modal/index.d.ts

@@ -0,0 +1,33 @@
+import { FC } from 'react';
+import { ModalFuncProps, ModalProps } from 'antd/lib/modal';
+import { FormBasicConfig, FormItemConfig } from '../types';
+import useModal from './useModal';
+import './style';
+interface FormModalProps {
+    mode?: 'form' | 'normal';
+    formConfig?: FormItemConfig;
+    formProps?: {
+        locales?: FormBasicConfig['locales'];
+        initialValues?: FormBasicConfig['initialValues'];
+        validationCodeExtraParams?: Record<string, any>;
+    };
+    onOk?: (values: any, fullValue: any) => any;
+    limitHeight?: boolean;
+}
+interface ModalFuncReturn {
+    destroy: Function;
+    update: (props: ModalProps & ModalFuncProps & FormModalProps) => any;
+}
+export type ModalFunction = (props: ModalProps & ModalFuncProps & FormModalProps) => ModalFuncReturn;
+interface ModalType extends FC<ModalProps & ModalFuncProps & FormModalProps> {
+    confirm: ModalFunction;
+    info: ModalFunction;
+    warning: ModalFunction;
+    error: ModalFunction;
+    success: ModalFunction;
+    noFooter: ModalFunction;
+    destroyAll: Function;
+    useModal: typeof useModal;
+}
+declare const IglooModal: ModalType;
+export default IglooModal;

package/es/modal/useModal.d.ts

@@ -0,0 +1,12 @@
+import { type ReactElement } from 'react';
+import { type ModalFunction } from './';
+export interface HookAPI {
+    confirm: ModalFunction;
+    info: ModalFunction;
+    warning: ModalFunction;
+    error: ModalFunction;
+    success: ModalFunction;
+    noFooter: ModalFunction;
+}
+declare const useModal: () => readonly [HookAPI, ReactElement];
+export default useModal;

package/es/ocr/index.d.ts

@@ -0,0 +1,15 @@
+import { FC, IglooComponentProps, FormItemExtraConfig } from '../types';
+export interface OutputMap {
+    field: string[];
+    source: string[];
+    format?: string;
+    formatType?: string;
+}
+interface OCRProps extends IglooComponentProps, FormItemExtraConfig {
+    ocrConfig: {
+        vendor: string;
+        outputMap: OutputMap[];
+    };
+}
+declare const OCR: FC<OCRProps>;
+export default OCR;

package/es/ocr/micro-blink/index.d.ts

@@ -0,0 +1,8 @@
+import { FC, IglooComponentProps, FormItemExtraConfig } from '../../types';
+import { OutputMap } from '../index';
+import './style';
+interface MicroBlinkProps extends IglooComponentProps, FormItemExtraConfig {
+    outputMap: OutputMap[];
+}
+declare const MicroBlink: FC<MicroBlinkProps>;
+export default MicroBlink;

package/es/radio/index.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+import { RadioProps, RadioGroupProps } from 'antd/es/radio';
+import { FC, IglooComponentProps } from '../types';
+import './style';
+import { ComponentProps } from '../utils/option-utils';
+import { DefaultOptionType } from 'rc-select/lib/Select';
+type Props = RadioProps & IglooComponentProps;
+declare const IglooRadio: FC<Props>;
+export interface Option extends DefaultOptionType {
+    extraInfo?: {
+        content: any;
+        shownTrigger: 'unchecked' | 'checked' | 'all';
+    };
+}
+export interface IProps extends IglooComponentProps, Omit<RadioGroupProps, 'options'>, ComponentProps {
+    className?: string;
+    radioType?: string;
+    options: Option[];
+    preview?: boolean;
+}
+export declare const InnerRadioGroup: FC<IProps>;
+export declare const RadioGroup: FC<React.PropsWithChildren<import("../utils/option-utils").HOCProps & IProps>>;
+export default IglooRadio;
+export { default as RadioGroupWithOther } from './radio-group-with-other';

package/es/radio/radio-group-with-other.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import { IProps as RadioGroupProps } from './index';
+import { FC } from '../types';
+declare const RadioGroupWithOther: FC<import("react").PropsWithChildren<import("../utils/option-utils").HOCProps & RadioGroupProps & {
+    otherOptionLabel: string;
+}>>;
+export default RadioGroupWithOther;

package/es/types.d.ts

@@ -0,0 +1,188 @@
+/// <reference path="../typings.d.ts" />
+import { BlinkIdSingleSideRecognizerResult } from '@microblink/blinkid-in-browser-sdk';
+import { FormItemProps, FormInstance } from 'antd/es/form';
+import { ReactNode } from 'react';
+import { NamePath } from 'rc-field-form/lib/interface';
+import { CheckboxOptionType } from 'antd/es/checkbox';
+import { SelectProps } from 'antd/es/select';
+export { Rule } from 'rc-field-form/lib/interface';
+export interface OCRHooks {
+    microBlink?: {
+        initResult: {
+            error?: string;
+            failed: boolean;
+        };
+        recognize: ((file: File) => Promise<BlinkIdSingleSideRecognizerResult | null>) | null;
+        loading?: boolean;
+    };
+}
+export interface OCRConfig {
+    microBlink?: {
+        licenseKey: string;
+    };
+}
+export type FormItemName = NamePath;
+export interface FormBasicConfig {
+    config: FormItemConfig;
+    className?: string;
+    style?: Object;
+    locales?: {
+        cancelText?: string;
+        submitText?: string;
+        previewText?: string;
+        nextText?: string;
+        continueText?: string;
+        validateMessages?: Object;
+    };
+    initialValues?: any;
+    form?: FormInstance;
+    onCancel?(): void;
+    onSubmit?(values: Object, allValues?: Object): any;
+    requiredMark?: boolean;
+    showSubmitButton?: boolean;
+    getScrollContainer?: () => HTMLElement | null;
+    onFirstModified?: () => any;
+    uploadApi?: string;
+    selectDatasourceApi?: string;
+    validationRule?: string;
+    getRuleValidationApi?: string;
+    stepDirection?: 'vertical' | 'horizontal';
+    customizeComponents?: {
+        [name: string]: FC;
+    };
+    ocr?: OCRConfig;
+    validationCodeExtraParams?: Record<string, any>;
+    onValuesChange?: (changedValues: any, values: any) => void;
+}
+export type FormItemAssert = {
+    field: NamePath;
+    value?: any;
+    operation?: 'eq' | 'ne' | 'in' | 'ni' | 'lt' | 'le' | 'gt' | 'ge' | 'co' | 'nc' | 'filled' | 'unfilled' | 'co-some' | 'co-every' | 'some-in' | 'every-in';
+};
+export type FormItemCopyValue = {
+    assert: FormItemAssert;
+    copyFrom: NamePath;
+    disabled?: boolean;
+};
+export type FormItemSelectValue = {
+    assert: FormItemAssert;
+    value: any;
+    disabled?: boolean;
+};
+export interface FormItemExtraConfig extends FormItemProps {
+    elements?: FormItemConfig[];
+    required?: boolean;
+    requiredAsserts?: FormItemAssert[];
+    extraLabel?: any;
+    xl?: number;
+    md?: number;
+    xs?: number;
+    span?: number;
+    areaCode?: number | string | (number | string)[];
+    phoneNumber?: number | string;
+    mergeRules?: boolean;
+    dependencies?: NamePath[];
+    antdDependencies?: NamePath[];
+    asserts?: FormItemAssert[];
+    shouldRender?: (form?: FormInstance) => boolean;
+    ignore?: boolean;
+    copyValue?: FormItemCopyValue;
+    selectValue?: FormItemSelectValue[];
+    disabled?: boolean | FormItemAssert | FormItemAssert[];
+    halfRow?: boolean;
+    fullRow?: boolean;
+    limit?: number;
+    hideWhenPreview?: boolean;
+    hideWhenEdit?: boolean;
+    requiredMessage?: string | ReactNode;
+    showOptional?: boolean;
+    previewFormater?(value: any, form?: FormInstance): any;
+    handleNext?(values: any): any;
+    render?(preview: boolean, form?: FormInstance, value?: any, onChange?: (params: any) => any, setShowStepButton?: IglooComponentProps['setShowStepButton']): any;
+    locales?: {
+        [key: string]: string;
+    };
+    options?: (CheckboxOptionType & {
+        extraInfo?: {
+            content: any;
+            shownTrigger: 'unchecked' | 'checked' | 'all';
+        };
+    })[] | SelectProps['options'];
+    sendOtp?: (value: any) => any;
+    dependField?: FormItemName;
+    countDownSeconds?: number;
+    getButtonDisabledState?: (form: FormInstance) => boolean;
+    getPreviousDisabledState?: (form: FormInstance) => boolean;
+    handleUpload?(file: File): PromiseLike<string>;
+    withoutForm?: boolean;
+    disableEditButton?: boolean;
+    hidePreviewDivider?: boolean;
+    valueFormater?: (value: any) => any;
+    currentStep?: number;
+    subscribedFields?: FormItemName[];
+    description?: string | React.ReactNode;
+    dateLimitationType?: 'relative' | 'absolute';
+    absoluteRangeStart?: number;
+    absoluteRangeEnd?: number;
+    relativeRangeStart?: {
+        type: 'day' | 'month' | 'year';
+        quantity: number;
+        pattern?: string;
+        dependField?: NamePath;
+    };
+    relativeRangeEnd?: {
+        type: 'day' | 'month' | 'year';
+        quantity: number;
+        pattern?: string;
+        dependField?: NamePath;
+    };
+    validationCode?: {
+        code: string;
+        errorMessage: string;
+        warningOnly?: boolean;
+    }[];
+    length?: number;
+    minLength?: number;
+    maxLength?: number;
+    idType?: 'KTP' | 'NIK';
+    validationRule?: string;
+    shouldRenderCode?: string;
+    disabledCode?: string;
+    automaticCalcCode?: string;
+    enableAutomaticCalc?: boolean;
+    [key: string]: any;
+}
+export interface FormItemConfig extends FormItemExtraConfig {
+    type?: string;
+    name?: NamePath;
+    label?: string | React.ReactNode;
+    previewLabel?: string | React.ReactNode;
+    labelProps?: any;
+    contentProps?: any;
+    ocr?: {
+        vender: string;
+        outputMap: {
+            field: string[];
+            source: string[];
+        }[];
+    };
+}
+export type FormItemPropsHandler = (config: FormItemConfig) => FormItemConfig;
+export interface FC<P = {}> extends React.FunctionComponent<P> {
+    formItemPropsHandler?: FormItemPropsHandler;
+    isPreviewSupport?: boolean;
+}
+export interface Form extends React.ForwardRefExoticComponent<FormBasicConfig & React.RefAttributes<any>> {
+    useForm: () => FormInstance;
+}
+export interface IglooComponentProps {
+    validateField?: (nameList?: NamePath[]) => Promise<any>;
+    containerRef?: React.RefObject<any>;
+    setFieldError?(errorMsg?: string): void;
+    setFieldValue?(value?: any): void;
+    setShowStepButton?: (showButton: boolean) => void;
+    getFormInstance?: () => FormInstance;
+    locales?: {
+        [key: string]: string;
+    };
+}

package/es/upload/index.d.ts

@@ -0,0 +1,16 @@
+import { UploadProps, RcFile } from 'antd/es/upload';
+import { FC, IglooComponentProps } from '../types';
+import './style';
+export interface IglooUploadProps extends UploadProps, IglooComponentProps {
+    placeholder?: string;
+    handleUpload?(file: RcFile): PromiseLike<string>;
+    value?: string[];
+    onChange?: (value: any) => void;
+    limit?: number;
+    limitErrorMessage?: Function | string;
+    containerRef?: any;
+    descriptions?: any;
+    bizKey?: string;
+}
+declare const IglooUpload: FC<IglooUploadProps>;
+export default IglooUpload;

package/es/upload-photo/index.d.ts

@@ -0,0 +1,28 @@
+import { FC, IglooComponentProps } from '../types';
+import './style';
+export interface Props extends IglooComponentProps {
+    handleUpload?(file: File): PromiseLike<string>;
+    value?: (string | {
+        name: string;
+        status: 'failed';
+        errorMsg: string;
+    })[];
+    onChange?: (value: any) => void;
+    limit?: number;
+    limitErrorMessage?: Function | string;
+    descriptions?: any;
+    buttonText?: any;
+    samples?: Sample[];
+    className?: any;
+    id?: string;
+    bizKey?: string;
+    capture?: boolean;
+    disabled?: boolean;
+}
+export type Sample = {
+    src: string;
+    label?: string;
+    type?: 'good' | 'bad';
+};
+declare const UploadPhoto: FC<Props>;
+export default UploadPhoto;

package/es/upload-preview/index.d.ts

@@ -0,0 +1,9 @@
+import { FC } from 'react';
+import './style';
+interface Props {
+    files: string[];
+    label?: any;
+    description?: any;
+}
+declare const UploadPreview: FC<Props>;
+export default UploadPreview;

package/es/upload-preview/media.d.ts

@@ -0,0 +1,7 @@
+import { FC } from 'react';
+declare const Media: FC<{
+    src: string;
+    type: 'image' | 'video' | 'pdf' | string;
+    className?: any;
+}>;
+export default Media;

package/es/utils/form-utils.d.ts

@@ -0,0 +1,79 @@
+import React from 'react';
+import { FormInstance } from 'antd/es/form';
+import { FormItemConfig, FormItemExtraConfig, FormItemName, FormItemCopyValue, FormItemSelectValue, FormItemAssert, Rule } from '../types';
+import { NamePath } from 'antd/es/form/interface';
+export declare const calcNamePath: (parentName: FormItemName | undefined, name: FormItemName | undefined) => any[];
+export declare const testAssert: (form: FormInstance, assert: FormItemAssert) => boolean;
+export declare const calcFormItemProps: (config: FormItemConfig, extraProps: FormItemExtraConfig, form?: FormInstance, parentName?: FormItemName, validationCodeExtraParams?: Record<string, any>) => {
+    colProps: {
+        span: number;
+        xs: number;
+        sm: number;
+        md: number;
+        halfRow: boolean | undefined;
+    };
+    formItemProps: {
+        name: any[];
+        className: string | undefined;
+        initialValue: any;
+        copiedValue: {
+            copied: boolean;
+            value?: undefined;
+            disabled?: undefined;
+        } | {
+            copied: boolean;
+            value: any;
+            disabled: boolean | undefined;
+        };
+        selectedValue: {
+            selected: boolean;
+            value?: undefined;
+            disabled?: undefined;
+        } | {
+            selected: boolean;
+            value: any;
+            disabled: boolean | undefined;
+        };
+        normalize: ((value: any, prevValue: any, allValues: import("rc-field-form/lib/interface").Store) => any) | undefined;
+        rules: Rule[];
+        validateTrigger: any[];
+        label: import("react/jsx-runtime").JSX.Element | null;
+        getValueFromEvent: ((...args: import("rc-field-form/lib/interface").EventArgs) => any) | undefined;
+        getValueProps: ((value: any) => Record<string, unknown>) | undefined;
+        extra: false | "" | 0 | import("react/jsx-runtime").JSX.Element | null | undefined;
+        help: React.ReactNode;
+        valuePropName: string | undefined;
+        messageVariables: {
+            label: string;
+        };
+        dependencies: any[] | undefined;
+    };
+    elementProps: {
+        [key: string]: any;
+    };
+    display: any;
+    previewFormater: ((value: any, form?: FormInstance<any> | undefined) => any) | undefined;
+};
+export declare const calcDisabled: (disabled?: boolean | FormItemAssert | FormItemAssert[], form?: FormInstance, disabledCode?: string, name?: FormItemName, parentName?: FormItemName) => any;
+export declare const calcCopyValue: (copyValue?: FormItemCopyValue, form?: FormInstance) => {
+    copied: boolean;
+    value?: undefined;
+    disabled?: undefined;
+} | {
+    copied: boolean;
+    value: any;
+    disabled: boolean | undefined;
+};
+export declare const calcSelectValue: (selectValue?: FormItemSelectValue[], form?: FormInstance) => {
+    selected: boolean;
+    value?: undefined;
+    disabled?: undefined;
+} | {
+    selected: boolean;
+    value: any;
+    disabled: boolean | undefined;
+};
+export declare const calcShouldRender: (name: NamePath, parentName: NamePath, dependencies?: NamePath[], asserts?: FormItemAssert[], shouldRender?: ((form?: FormInstance) => boolean) | undefined, shouldRenderCode?: string, form?: FormInstance) => any;
+export declare const automaticCalculate: (name: NamePath, parentName: NamePath, automaticCalcCode?: string, form?: FormInstance) => void;
+export declare const getRuleValidation: (url: string, rule: string | string[], values?: any, lang?: string) => Promise<any>;
+export declare const calcAddableSectionAssertField: (name: any[], field: FormItemAssert['field'], index: number, elements: FormItemConfig[] | React.ReactElement[]) => any;

package/es/utils/option-utils.d.ts

@@ -0,0 +1,29 @@
+import { PropsWithChildren } from 'react';
+import { FC, IglooComponentProps } from '../types';
+import { FormInstance } from 'antd/es/form';
+import { NamePath } from 'antd/es/form/interface';
+import { SelectProps, SelectValue } from 'antd/es/select';
+export declare const compareOptions: (newOptions: any[], oldOptions?: any[]) => boolean;
+export declare const compareSelected: (newValue: any | any[], oldValue: any | any[]) => boolean;
+type Options = SelectProps<SelectValue>['options'];
+export interface HOCProps extends IglooComponentProps {
+    options?: Options;
+    onSearch?: any;
+    getOptions?: (form: FormInstance) => any[];
+    optionGroups?: {
+        parentKey: string;
+        options: Options;
+    }[];
+    datasourceFilters?: string[];
+    datasourceKey?: string;
+    datasourceApi?: string;
+    dependField?: NamePath;
+    passCompareOptions?: boolean;
+}
+export interface ComponentProps extends IglooComponentProps {
+    options?: Options;
+    clearWhenOptionsUpdated?: boolean;
+}
+export declare function optionsHOC<T>(Component: FC<T>): FC<PropsWithChildren<HOCProps & T>>;
+export declare function previewSelectedOptions(options: Options, value: any): any;
+export {};

package/lib/admin-upload/index.d.ts

@@ -0,0 +1,37 @@
+import { FC } from 'react';
+import { RequestMethod } from 'umi-request';
+import { IglooButtonProps } from '../button';
+import { UploadProps } from 'antd/es/upload';
+import { Job } from './job-list';
+import './style';
+export interface AdminUploadProps {
+    dataSource: string | {
+        label: string;
+        value: string;
+    }[];
+    requestMethod: RequestMethod;
+    uploadMethod: (dataSource: string, file: File, enableApiAuth: boolean, onProgess: (e: ProgressEvent) => any) => {
+        abort: () => any;
+        result: Promise<{
+            success: boolean;
+            errorMessage?: string;
+        }>;
+    };
+    modalTitle?: string;
+    floatTitle?: string;
+    buttonText?: string;
+    buttonType?: IglooButtonProps['type'];
+    enableApiAuth?: boolean;
+    accept?: UploadProps['accept'];
+    refreshInteval?: number;
+    formatTips?: (props: {
+        uploading: number;
+        processing: number;
+        done: number;
+    }) => string;
+    selectPlaceholder?: string;
+    onFinish?: (jobs: Job[]) => any;
+    handleCloseFloat?: (hidden: () => {}) => any;
+}
+declare const AdminUpload: FC<AdminUploadProps>;
+export default AdminUpload;

package/lib/app/context.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import type { HookAPI as ModalHookAPI } from '../modal/useModal';
+import type { HookAPI as MessageHookAPI } from '../message/useMessage';
+export type AppContextType = {
+    modal: ModalHookAPI;
+    message: MessageHookAPI;
+};
+declare const AppContext: import("react").Context<AppContextType>;
+export default AppContext;

package/lib/app/index.d.ts

@@ -0,0 +1,8 @@
+import { type FC, type PropsWithChildren } from 'react';
+import { type AppContextType } from './context';
+interface AppProps {
+}
+declare const App: FC<PropsWithChildren<AppProps>> & {
+    useApp: () => AppContextType;
+};
+export default App;