@lm_fe/components_m 0.1.201

package/dist/FU_components/MySelect/utils.d.ts

@@ -0,0 +1,13 @@
+import { ICommonOption } from "@lm_fe/env";
+import { IMySelectProps } from "./types";
+export declare function getMarshal({ uniqueKey, marshal }: IMySelectProps): number;
+export declare function parse_MC_value(props: IMySelectProps, changedValue: ICommonOption[]): any;
+export declare function check_multiple(props: IMySelectProps): boolean;
+export declare function get_mode(props: IMySelectProps): "multiple" | "tags" | undefined;
+export declare function get_select_opt(props: IMySelectProps): ICommonOption[];
+export declare function use_options(props: IMySelectProps): {
+    loading: boolean;
+    options: ICommonOption[];
+    data: ICommonOption[];
+    setData: import("react").Dispatch<import("react").SetStateAction<ICommonOption[]>>;
+};

package/dist/FU_components/OkButton/index.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { ButtonProps } from 'antd';
+export declare function OkButton(props: ButtonProps & {
+    text?: string;
+    btnText?: string;
+    defaultIcon?: React.ReactNode;
+    primary?: boolean;
+}): React.JSX.Element;

package/dist/FU_components/PressureInput/index.d.ts

@@ -0,0 +1,7 @@
+import { TCommonComponent } from '../types';
+export declare const MyPressureDisplayFC: TCommonComponent<{
+    marshal?: number;
+}, string | number[]>;
+export declare const MyPressure: TCommonComponent<{
+    marshal?: number;
+}, string | number[]>;

package/dist/FU_components/SimpleForm/components/TabForm/index.d.ts

@@ -0,0 +1,14 @@
+import { TabsProps } from "antd";
+import { SimpleFormProps } from '../..';
+interface IItem {
+    _id: number;
+    [x: string]: any;
+}
+interface IProps extends Omit<TabsProps, 'onChange'> {
+    value?: IItem[];
+    title: string;
+    onChange?: (v: IItem[]) => void;
+    formSchema: SimpleFormProps;
+}
+export default function TabForm({ value, formSchema, onChange, title, style, ...others }: IProps): import("react").JSX.Element;
+export {};

package/dist/FU_components/SimpleForm/components/extra/Custom.d.ts

@@ -0,0 +1,5 @@
+import { InputProps } from "antd";
+import { FC } from "react";
+export default function Custom({ CustomedComponent, value, onChange }: InputProps & {
+    CustomedComponent: FC<any>;
+}): import("react").JSX.Element;

package/dist/FU_components/SimpleForm/components/extra/SimpleSelect.d.ts

@@ -0,0 +1,6 @@
+import { SelectProps } from "antd";
+import React from "react";
+export default function SimpleSelect(props: SelectProps<any> & {
+    optionsArr: string[];
+    type?: 'Select' | 'Radio';
+}): React.JSX.Element;

package/dist/FU_components/SimpleForm/index.d.ts

@@ -0,0 +1,45 @@
+import { FormInstance, FormProps, TabsProps } from "antd";
+import { AllTypes } from "./types/metaTypes";
+import { Rule } from "antd/lib/form";
+export interface SimpleFormProps {
+    onValuesChange?: FormProps['onValuesChange'];
+    blocks?: {
+        title?: string;
+        rows: IRowSchema[];
+    }[];
+    disabled?: boolean;
+    form?: FormInstance;
+    formProps?: FormProps;
+    formItems?: (AllTypes | undefined | boolean)[];
+}
+interface IRowSchema {
+    itemsInRow: (AllTypes | null)[];
+    layoutType?: 8 | 16 | 24;
+    label?: string;
+    disabled?: boolean;
+}
+declare const SimpleFormInner: import("react").ForwardRefExoticComponent<SimpleFormProps & import("react").RefAttributes<FormInstance<any>>>;
+type InternalFormType = typeof SimpleFormInner;
+interface SimpleFormType extends InternalFormType {
+    getPresetRules: (name: keyof typeof basicRules, required?: boolean) => Rule[];
+    requiredRules: Rule[];
+}
+declare const SimpleForm: SimpleFormType;
+declare const basicRules: {
+    telephone: {
+        validator: (_: any, value: any) => Promise<void>;
+        message: string;
+    };
+};
+export default SimpleForm;
+interface IItem {
+    _id: number;
+    [x: string]: any;
+}
+interface IProps extends Omit<TabsProps, 'onChange'> {
+    value?: IItem[];
+    title: string;
+    onChange?: (v: IItem[]) => void;
+    formSchema: SimpleFormProps;
+}
+export declare function TabForm({ value, formSchema, onChange, title, style, ...others }: IProps): import("react").JSX.Element;

package/dist/FU_components/SimpleForm/types/help.d.ts

@@ -0,0 +1,3 @@
+type omg = ((...args: any) => any) | (abstract new (...args: any) => any);
+export type GetProps<T extends omg> = T extends (abstract new (...args: any) => any) ? ConstructorParameters<T>['0'] : (T extends ((...args: any) => any) ? Parameters<T>['0'] : any);
+export {};

package/dist/FU_components/SimpleForm/types/lmTypes.d.ts

@@ -0,0 +1,85 @@
+import { DatePicker_L, RangePicker_L, TimePicker_L } from '@lm_fe/components';
+import { Checkbox, Divider, Form, Input, InputNumber, Radio, Rate, Row, Slider, Switch } from "antd";
+import CusDatePicker from "../../../GeneralComponents/DatePicker";
+import { GetProps } from "./help";
+declare const Tree: (<T extends Object = any>(props: import("antd").TreeProps<T>) => import("react").JSX.Element) & {
+    TreeNode: import("react").FC<import("rc-tree/es/TreeNode").TreeNodeProps<import("rc-tree/es/interface").DataNode>>;
+    DirectoryTree: (props: import("antd/lib/tree").DirectoryTreeProps) => import("react").JSX.Element;
+}, Select: (<T extends Object = any>(props: import("antd").SelectProps<T>) => import("react").JSX.Element) & {
+    Option: (props: import("rc-select/lib/Option").OptionProps) => import("react").JSX.Element;
+};
+export interface TypeMaps {
+    Input: GetProps<typeof Input>;
+    Select: GetProps<typeof Select>;
+    Radio: GetProps<typeof Radio>;
+    TextArea: GetProps<typeof Input.TextArea>;
+    InputNumber: GetProps<typeof InputNumber>;
+    Checkbox: GetProps<typeof Checkbox>;
+    TimePicker: GetProps<typeof TimePicker_L>;
+    DatePicker: GetProps<typeof DatePicker_L>;
+    RangePicker: GetProps<typeof RangePicker_L>;
+    MyDatePicker: GetProps<typeof CusDatePicker>;
+    Switch: GetProps<typeof Switch>;
+    Rate: GetProps<typeof Rate>;
+    Slider: GetProps<typeof Slider>;
+    Color: GetProps<typeof Input>;
+    CheckboxGroup: GetProps<typeof Checkbox.Group>;
+    Text: {
+        value: string;
+    };
+    Divider: GetProps<typeof Divider>;
+    Grid: GetProps<typeof Row> & {
+        list: ILmFormItemConfig<'Grid'>;
+    };
+    HospitalTreeSelect: GetProps<typeof Tree> & {
+        valueType?: 'string' | 'object' | 'normal';
+    };
+    SwitchSelect: GetProps<typeof Select>;
+}
+type ILmFormItemOptionsUnion<T extends keyof TypeMaps> = {
+    type: T;
+    isLayout?: boolean;
+    innerOptions?: TypeMaps[T] & {
+        value?: any;
+        onChange?: any;
+    };
+    outerOptions?: GetProps<typeof Form.Item>;
+    chosen?: boolean;
+    remote?: boolean;
+    readonly?: boolean;
+    showLabel?: boolean;
+    remoteOptions?: any[];
+    width?: number;
+    remoteFunc?: string;
+    onChangeFunc?: string;
+    id?: number;
+    icon?: string;
+    key?: string;
+    model?: string;
+    customClass?: string;
+};
+export type ILmInput = ILmFormItemOptionsUnion<'Input'>;
+export type ILmSelect = ILmFormItemOptionsUnion<'Select'>;
+export type ILmRadio = ILmFormItemOptionsUnion<'Radio'>;
+export type ILmTextArea = ILmFormItemOptionsUnion<'TextArea'>;
+export type ILmInputNumber = ILmFormItemOptionsUnion<'InputNumber'>;
+export type ILmCheckbox = ILmFormItemOptionsUnion<'Checkbox'>;
+export type ILmTimePicker = ILmFormItemOptionsUnion<'TimePicker'>;
+export type ILmDatePicker = ILmFormItemOptionsUnion<'DatePicker'>;
+export type ILmMyDatePicker = ILmFormItemOptionsUnion<'MyDatePicker'>;
+export type ILmSwitch = ILmFormItemOptionsUnion<'Switch'>;
+export type ILmRate = ILmFormItemOptionsUnion<'Rate'>;
+export type ILmSlider = ILmFormItemOptionsUnion<'Slider'>;
+export type ILmColor = ILmFormItemOptionsUnion<'Color'>;
+export type ILmCheckboxGroup = ILmFormItemOptionsUnion<'CheckboxGroup'>;
+export type ILmText = ILmFormItemOptionsUnion<'Text'>;
+export type ILmDivider = ILmFormItemOptionsUnion<'Divider'>;
+export type ILmGrid = ILmFormItemOptionsUnion<'Grid'>;
+export type ILmHospitalTreeSelect = ILmFormItemOptionsUnion<'HospitalTreeSelect'>;
+export type ILmSelectProps = ILmFormItemOptionsUnion<'SwitchSelect'>;
+export type ILmFormItemConfig<T extends keyof TypeMaps> = ILmFormItemOptionsUnion<T>;
+export type ILmFormItemInnerOptionsg<T extends keyof TypeMaps> = ILmFormItemConfig<T>['innerOptions'];
+export type ILmFormItemOuterOptions<T extends keyof TypeMaps> = ILmFormItemConfig<T>['outerOptions'];
+export type ILmFormItemOmitOptions<T extends keyof TypeMaps> = Omit<ILmFormItemConfig<T>, 'innerOptions'> | Omit<ILmFormItemConfig<T>, 'outerOptions'>;
+export type ILmFormItemConfigMixin = ILmInput | ILmSelect | ILmRadio | ILmTextArea | ILmInputNumber | ILmCheckbox | ILmTimePicker | ILmDatePicker | ILmSwitch | ILmRate | ILmText | ILmSlider | ILmColor | ILmCheckboxGroup | ILmDivider | ILmGrid | ILmHospitalTreeSelect | ILmSelectProps | ILmMyDatePicker | ILmFormItemOptionsUnion<'RangePicker'>;
+export {};

package/dist/FU_components/SimpleForm/types/metaTypes.d.ts

@@ -0,0 +1,28 @@
+import { Form } from "antd";
+import React from "react";
+import { ComponentMapping } from "../components";
+import { GetProps } from "./help";
+type OptionsWithType<T extends keyof typeof ComponentMapping, V = any> = {
+    type?: T;
+    customNode?: React.ReactNode;
+    isLayout?: boolean;
+    innerOptions?: GetProps<typeof ComponentMapping[T]>;
+    outerOptions?: Omit<GetProps<typeof Form.Item>, 'name'> & {
+        name: keyof V;
+    };
+    chosen?: boolean;
+    remote?: boolean;
+    readonly?: boolean;
+    showLabel?: boolean;
+    remoteOptions?: any[];
+    width?: number;
+    remoteFunc?: string;
+    onChangeFunc?: string;
+    id: string;
+    icon?: string;
+    key?: string;
+    model?: string;
+    customClass?: string;
+};
+export type AllTypes<V = any> = OptionsWithType<'Input', V> | OptionsWithType<'Select', V> | OptionsWithType<'Radio', V> | OptionsWithType<'TextArea', V> | OptionsWithType<'InputNumber', V> | OptionsWithType<'Checkbox', V> | OptionsWithType<'TimePicker', V> | OptionsWithType<'DatePicker', V> | OptionsWithType<'Switch', V> | OptionsWithType<'Rate', V> | OptionsWithType<'Color', V> | OptionsWithType<'CheckboxGroup', V> | OptionsWithType<'Text', V> | OptionsWithType<'Divider', V> | OptionsWithType<'Grid', V> | OptionsWithType<'MyDatePicker', V> | OptionsWithType<'SwitchSelect', V> | OptionsWithType<'SimpleSelect', V> | OptionsWithType<'Custom', V> | OptionsWithType<'TabForm', V>;
+export {};

package/dist/FU_components/TakeInVolumn/DisplayFC.d.ts

@@ -0,0 +1,7 @@
+import { TCommonComponent } from "../types";
+interface TakeInVolumnProps {
+    marshal?: boolean;
+    onBlur?: any;
+}
+export declare const TakeInVolumn_DisplayFC: TCommonComponent<TakeInVolumnProps, any>;
+export {};

package/dist/FU_components/TakeInVolumn/Inner.d.ts

@@ -0,0 +1,7 @@
+import { TCommonComponent } from "../types";
+interface TakeInVolumnProps {
+    marshal?: boolean;
+    onBlur?: any;
+}
+declare const TakeInVolumn: TCommonComponent<TakeInVolumnProps, any>;
+export default TakeInVolumn;

package/dist/FU_components/TakeOutVolumn/DisplayFC.d.ts

@@ -0,0 +1,7 @@
+import { TCommonComponent } from "../types";
+interface TakeOutVolumnProps {
+    marshal?: boolean;
+    onBlur?: any;
+}
+export declare const TakeOutVolumn_DisplayFC: TCommonComponent<TakeOutVolumnProps, any>;
+export {};

package/dist/FU_components/TakeOutVolumn/Inner.d.ts

@@ -0,0 +1,7 @@
+import { TCommonComponent } from "../types";
+interface TakeOutVolumnProps {
+    marshal?: boolean;
+    onBlur?: any;
+}
+declare const TakeOutVolumn: TCommonComponent<TakeOutVolumnProps, any>;
+export default TakeOutVolumn;

package/dist/FU_components/TemplateTextarea/index.d.ts

@@ -0,0 +1,14 @@
+import { ITemplateConfig, MODAL_TEMPLATE_TYPES } from '@lm_fe/env';
+import { TextAreaProps } from 'antd/lib/input';
+import React from 'react';
+interface ITemplateTextareaProps extends TextAreaProps {
+    value?: string;
+    onChange?(v: any): void;
+    type?: typeof MODAL_TEMPLATE_TYPES['科室个人'];
+    style?: React.CSSProperties;
+    rows?: number;
+    canOperate?: boolean;
+    TemplateTextarea_type?: ITemplateConfig[];
+}
+export declare function TemplateTextarea(props: ITemplateTextareaProps): React.JSX.Element;
+export {};

package/dist/FU_components/ToggleForm/Inner.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { IToggleFormProps } from './types';
+export default function ToggleForm<T = any>(props: IToggleFormProps<T>): React.JSX.Element;

package/dist/FU_components/ToggleForm/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types';
+declare const ToggleForm: import("react").LazyExoticComponent<typeof import("./Inner").default>;
+export { ToggleForm };

package/dist/FU_components/ToggleForm/types.d.ts

@@ -0,0 +1,14 @@
+import { IMchc_FormDescriptions_Field } from '@lm_fe/service';
+import { ButtonProps, FormInstance } from 'antd';
+import { IFormSectionFormProps } from '../FormSection/FormSectionForm';
+export interface IToggleFormProps<T = any> {
+    value?: T;
+    title?: string;
+    onChange(data: T): void;
+    btnProps?: ButtonProps;
+    formSectionFormProps: IFormSectionFormProps;
+    formDescriptions: IMchc_FormDescriptions_Field[];
+    defaultValue?: any;
+    form?: FormInstance;
+    plainForm?: boolean;
+}

package/dist/FU_components/index.d.ts

@@ -0,0 +1,25 @@
+export { default as MyCheckbox } from '../GeneralComponents/CheckboxWithInput_gold';
+export * from './ArrayInput';
+export * from './ArrayPanel';
+export * from './CalcBmi';
+export * from './CheckboxWithValue';
+export * from './CommonFormTabs';
+export * from './DateRange';
+export * from './DateTimeInput';
+export * from './HbvdnaInput';
+export * from './HighriskGradeColorSpan';
+export * from './HourMinuteInput';
+export * from './MyAutoComplete';
+export * from './MyBaseTable';
+export * from './MyEditTable';
+export * from './MyReferralOrganizationSelect';
+export * from './MySelect';
+export * from './OkButton';
+export * from './PressureInput';
+export * from './TakeInVolumn';
+export * from './TakeOutVolumn';
+export * from './TemplateTextarea';
+export * from './ToggleForm';
+export * from './others/RolesPicker';
+export * from './LoadingPlaceholder';
+export * from './MchcDriverStatus';

package/dist/FU_components/others/RolesPicker/index.d.ts

@@ -0,0 +1,12 @@
+import { IMchc_Group } from '@lm_fe/service';
+import { PartialAll } from '@lm_fe/utils';
+import React from 'react';
+type IFuck_Group = (PartialAll<IMchc_Group> & {
+    groupRankList: PartialAll<IMchc_Group['groupRanks']>;
+});
+interface IRolesPickerProps {
+    value: IFuck_Group[];
+    onChange?(v: IFuck_Group[]): void;
+}
+export declare function RolesPicker(props: IRolesPickerProps): React.JSX.Element;
+export {};

package/dist/FU_components/types.d.ts

@@ -0,0 +1,12 @@
+import { FC } from "react";
+type TBase<PROPS = any, V = any, D = {
+    disabled?: boolean;
+    value?: V;
+    onChange?(v?: V | null): void;
+    isDisplay?: boolean;
+} & PROPS> = FC<D>;
+export type TCommonComponentDisplay<PROPS = any, V = any> = TBase<PROPS, V>;
+export type TCommonComponent<PROPS = any, V = any> = TBase<PROPS, V> & {
+    DisplayFC?: TBase<PROPS, V>;
+};
+export {};

package/dist/GeneralComponents/AsyncAutoComplete/index.d.ts

@@ -0,0 +1,13 @@
+import React, { Component } from 'react';
+export default class AsyncAutoComplete extends Component {
+    state: {
+        options: never[];
+        scrollPage: number;
+    };
+    handleFocus: () => void;
+    handleSearch: (value: string) => void;
+    handleSelect: (value: any, option: any) => void;
+    handlePopupScroll: (e: any) => void;
+    fetchOptions: (value: string, page?: number) => void;
+    render(): React.JSX.Element;
+}

package/dist/GeneralComponents/Button/index.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+export default function CustomButton({ name, label, type, size, onClick, input_props }: {
+    name: any;
+    label: any;
+    type?: string | undefined;
+    size?: string | undefined;
+    onClick: any;
+    input_props: any;
+}): React.JSX.Element;

package/dist/GeneralComponents/ButtonModal/index.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { ModalProps } from 'antd/lib/modal';
+import './index.less';
+interface IProps extends ModalProps {
+    title?: string;
+    type?: string;
+    children?: React.ReactNode;
+}
+declare function ButtonWithModal({ title, type, children, ...rest }: IProps): React.JSX.Element;
+export default ButtonWithModal;

package/dist/GeneralComponents/CaseTemplete/Inner.d.ts

@@ -0,0 +1,21 @@
+import React, { Component } from 'react';
+import './index.less';
+interface IProps {
+    onSave: any;
+    content?: any;
+    containerProps?: any;
+    toolbars?: any;
+    mode?: 'DESIGN' | 'EDITOR' | 'STRICT' | 'READONLY';
+    hiddenButton?: boolean;
+}
+export default class CaseTempleteEdit extends Component<IProps> {
+    editRef: any;
+    componentDidMount(): void;
+    componentDidUpdate(): void;
+    shouldComponentUpdate(nextProps: any): boolean;
+    initSDE: () => void;
+    handleSave: () => void;
+    handlePrint: () => void;
+    render(): React.JSX.Element;
+}
+export {};

package/dist/GeneralComponents/CaseTemplete/config.d.ts

@@ -0,0 +1,20 @@
+export declare const defaultToolbars: {
+    name: string;
+    title: string;
+    items: {
+        name: string;
+        title: string;
+        items: (string | {
+            name: string;
+            title: string;
+            items: {
+                title: string;
+                name: string;
+            }[];
+        } | {
+            name: string;
+            title: string;
+            items?: undefined;
+        })[];
+    }[];
+}[];

package/dist/GeneralComponents/CaseTemplete/index.d.ts

@@ -0,0 +1,2 @@
+declare const CaseTemplete: import("react").LazyExoticComponent<typeof import("./Inner").default>;
+export default CaseTemplete;

package/dist/GeneralComponents/CheckAndCancelButton/index.d.ts

@@ -0,0 +1,3 @@
+import { FC } from 'react';
+declare const CheckAndCancelButton: FC<any>;
+export default CheckAndCancelButton;

package/dist/GeneralComponents/CheckboxGroupObject/index.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+interface optionProps {
+    key: string;
+    label: string;
+    warning?: boolean;
+}
+interface IProps {
+    value?: object;
+    options?: optionProps[];
+    optionKey?: '家族史';
+    [propName: string]: any;
+}
+export default function CheckboxGroupObject(props: IProps): React.JSX.Element;
+export declare function CheckboxItem({ value, option, onTextChange, type }: any): React.JSX.Element;
+export {};

package/dist/GeneralComponents/CheckboxGroupObjectCustom/Inner.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+interface optionProps {
+    key: string;
+    label: string;
+    warning?: boolean;
+}
+interface IProps {
+    value?: object;
+    options?: optionProps[];
+    [propName: string]: any;
+}
+export default function CheckboxGroupObject({ value, options, onChange, type, row, cusextraObj, ...restProps }: IProps): React.JSX.Element;
+export {};

package/dist/GeneralComponents/CheckboxGroupObjectCustom/index.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export default function CheckboxGroupObjectCustom(props: any): React.JSX.Element;

package/dist/GeneralComponents/CheckboxWithInput/Inner.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import { Option as MultipleInputWithLabelOption } from '../MultipleInputWithLabel';
+interface Option {
+    value: any;
+    label?: any;
+    span?: number;
+    withInput?: boolean;
+    isIssue?: boolean;
+    inputType?: 'multiple_input' | 'checkbox' | 'input';
+    inputSpan?: number;
+    options?: MultipleInputWithLabelOption[] | any[];
+}
+interface IProps {
+    value?: any;
+    options?: Option[];
+    onChange?: any;
+    type?: 'single' | 'multiple';
+    disabled?: boolean;
+}
+declare const _default: (props: IProps) => React.JSX.Element;
+export default _default;

package/dist/GeneralComponents/CheckboxWithInput/index.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export default function CheckboxWithInput(props: any): React.JSX.Element;

package/dist/GeneralComponents/CheckboxWithInput_gold/Display.d.ts

@@ -0,0 +1,6 @@
+import { TCommonComponentDisplay } from '../../FU_components/types';
+import { ICheckboxWithInputProps } from './types';
+import { ICommonOption } from '@lm_fe/env';
+export * from './types';
+declare const MyCheckbox_DisplayFC: TCommonComponentDisplay<ICheckboxWithInputProps, string | number | ICommonOption[]>;
+export default MyCheckbox_DisplayFC;

package/dist/GeneralComponents/CheckboxWithInput_gold/Inner.d.ts

@@ -0,0 +1,5 @@
+import { ICommonOption } from '@lm_fe/env';
+import { TCommonComponent } from '../../FU_components/types';
+import { ICheckboxWithInputProps } from './types';
+declare const MyCheckbox: TCommonComponent<ICheckboxWithInputProps, string | number | ICommonOption[]>;
+export default MyCheckbox;

package/dist/GeneralComponents/CheckboxWithInput_gold/components.d.ts

@@ -0,0 +1,56 @@
+import { MyAutoComplete } from '../../FU_components';
+import MultipleInputWithLabel from '../MultipleInputWithLabel';
+export declare const components: {
+    MA: typeof MyAutoComplete;
+    MyAutoComplete: typeof MyAutoComplete;
+    Select: import("react").LazyExoticComponent<import("../../FU_components/types").TCommonComponent<import("../../FU_components").IMySelectProps, string | number>> & {
+        DisplayFC: typeof import("../../FU_components/MySelect/Display").DisplayFC;
+    };
+    MySelect: import("react").LazyExoticComponent<import("../../FU_components/types").TCommonComponent<import("../../FU_components").IMySelectProps, string | number>> & {
+        DisplayFC: typeof import("../../FU_components/MySelect/Display").DisplayFC;
+    };
+    MS: import("react").LazyExoticComponent<import("../../FU_components/types").TCommonComponent<import("../../FU_components").IMySelectProps, string | number>> & {
+        DisplayFC: typeof import("../../FU_components/MySelect/Display").DisplayFC;
+    };
+    InputNumber: ((props: Omit<import("antd").InputProps, "onChange"> & {
+        unknown?: boolean;
+        warn?: boolean;
+        onChange?: (v: any) => void;
+    }) => import("react").JSX.Element) & {
+        DisplayFC: (props: Omit<import("antd").InputProps, "onChange"> & {
+            unknown?: boolean;
+            warn?: boolean;
+            onChange?: (v: any) => void;
+        }) => import("react").JSX.Element;
+    };
+    MyInputNumber: ((props: Omit<import("antd").InputProps, "onChange"> & {
+        unknown?: boolean;
+        warn?: boolean;
+        onChange?: (v: any) => void;
+    }) => import("react").JSX.Element) & {
+        DisplayFC: (props: Omit<import("antd").InputProps, "onChange"> & {
+            unknown?: boolean;
+            warn?: boolean;
+            onChange?: (v: any) => void;
+        }) => import("react").JSX.Element;
+    };
+    MI: import("react").ForwardRefExoticComponent<import("@lm_fe/components").IMyInputProps & import("react").RefAttributes<import("antd").Input>>;
+    input: import("react").ForwardRefExoticComponent<import("@lm_fe/components").IMyInputProps & import("react").RefAttributes<import("antd").Input>>;
+    Input: import("react").ForwardRefExoticComponent<import("@lm_fe/components").IMyInputProps & import("react").RefAttributes<import("antd").Input>>;
+    MyInput: import("react").ForwardRefExoticComponent<import("@lm_fe/components").IMyInputProps & import("react").RefAttributes<import("antd").Input>>;
+    MyAddress: typeof import("@lm_fe/components").MyAddress;
+    MyImageEditor: ((props: import("@lm_fe/components").IMyImageEditorProps) => import("react").JSX.Element) & {
+        events: {
+            save: string;
+            create: string;
+        };
+    };
+    MultipleInputWithLabel: typeof MultipleInputWithLabel;
+    DatePicker: import("../DatePicker").TMyDatePicker;
+    CheckboxWithInput: string;
+    MyCheckbox: string;
+    MC: string;
+    Checkbox: string;
+    ArrayInput: import("../../FU_components/types").TCommonComponent<import("../../FU_components").IArrayInputProps, string>;
+    MArr: import("../../FU_components/types").TCommonComponent<import("../../FU_components").IArrayInputProps, string>;
+};

package/dist/GeneralComponents/CheckboxWithInput_gold/index.d.ts

@@ -0,0 +1,5 @@
+export * from './types';
+declare const MyCheckbox: import("react").LazyExoticComponent<import("../../FU_components/types").TCommonComponent<import("./types").ICheckboxWithInputProps, string | number | import("@lm_fe/env").ICommonOption[]>>;
+declare const MyCheckbox_Display: import("react").LazyExoticComponent<import("../../FU_components/types").TCommonComponentDisplay<import("./types").ICheckboxWithInputProps, string | number | import("@lm_fe/env").ICommonOption[]>>;
+export default MyCheckbox;
+export { MyCheckbox_Display };

package/dist/GeneralComponents/CheckboxWithInput_gold/types.d.ts

@@ -0,0 +1,52 @@
+import { AutoCompleteProps } from "antd";
+import { IArrayInputProps } from "../../FU_components/ArrayInput";
+import { ICusDatePickerProps } from "../DatePicker";
+import { IMultipleInputWithLabelProps } from "../MultipleInputWithLabel";
+import { ICommonOption } from "@lm_fe/env";
+import React from "react";
+import { IMyInputProps } from "@lm_fe/components";
+import { IMchc_FormDescriptions_Field } from "@lm_fe/service";
+export interface ICheckboxWithInputProps {
+    value?: string | ICommonOption[];
+    options?: ICheckboxWithInputOption[] | string;
+    onChange?(v?: any): void;
+    type?: 'single' | 'multiple';
+    disabled?: boolean;
+    inputWidth?: number;
+    optionKey?: string;
+    config?: IMchc_FormDescriptions_Field;
+    uniqueKey?: string;
+    marshal?: number;
+    sp?: ICheckboxWithInputOption[];
+    vertical?: boolean;
+    startIndex?: number;
+    onBlur?(e: any): void;
+    style?: React.CSSProperties;
+}
+type INil = Exclude<ICommonOption, 'props' | 'inputType'>;
+interface IMyInput extends ICommonOption {
+    inputType: 'MyInput';
+    props?: IMyInputProps;
+}
+interface IAutoComplete extends ICommonOption {
+    inputType: 'AutoComplete';
+    props?: AutoCompleteProps;
+}
+interface IMultiple_input extends ICommonOption {
+    inputType: 'MultipleInputWithLabel';
+    props?: IMultipleInputWithLabelProps;
+}
+interface ISelf extends ICommonOption {
+    inputType: 'CheckboxWithInput' | 'MyCheckbox';
+    props?: ICheckboxWithInputProps;
+}
+interface IArrayInput extends ICommonOption {
+    inputType: 'ArrayInput';
+    props?: IArrayInputProps;
+}
+interface ISingle_date_picker extends ICommonOption {
+    inputType: 'DatePicker';
+    props?: ICusDatePickerProps;
+}
+export type ICheckboxWithInputOption = IAutoComplete | IMultiple_input | IMyInput | ISelf | ISingle_date_picker | IArrayInput | INil;
+export {};